126 lines
3.8 KiB
TypeScript
126 lines
3.8 KiB
TypeScript
import { useEffect, useCallback, useRef } from 'react';
|
|
import { useQueryClient } from '@tanstack/react-query';
|
|
import { File, UploadType } from 'expo-file-system';
|
|
import NetInfo, { NetInfoState } from '@react-native-community/netinfo';
|
|
import { safDirectory, StoredFolder } from '../services/safDirectory';
|
|
import { localFileRegistry } from '../services/localFileRegistry';
|
|
import { apiClient } from '../api/client';
|
|
import { API_BASE_URL, ENDPOINTS } from '../constants/api';
|
|
import { ApiError } from '../types';
|
|
import { setIsSyncing } from './useSyncQueue';
|
|
|
|
function canSyncFolder(folder: StoredFolder, netInfo: NetInfoState): boolean {
|
|
if (folder.syncMode !== 'auto') return false;
|
|
if (!netInfo.isConnected) return false;
|
|
if (!folder.syncCellular && netInfo.type !== 'wifi') return false;
|
|
return true;
|
|
}
|
|
|
|
interface UploadResult {
|
|
name: string;
|
|
id: string;
|
|
}
|
|
|
|
async function uploadFile(file: { uri: string; type: string; name: string }): Promise<UploadResult> {
|
|
const fsFile = new File(file.uri);
|
|
const headers: Record<string, string> = {};
|
|
const token = apiClient.getAccessToken();
|
|
if (token) {
|
|
headers['Authorization'] = `Bearer ${token}`;
|
|
}
|
|
const result = await fsFile.upload(`${API_BASE_URL}${ENDPOINTS.UPLOAD}`, {
|
|
httpMethod: 'POST',
|
|
uploadType: UploadType.MULTIPART,
|
|
fieldName: 'file',
|
|
mimeType: file.type,
|
|
headers,
|
|
});
|
|
|
|
if (result.status >= 400) {
|
|
let message = 'Upload failed';
|
|
try {
|
|
const body: ApiError = JSON.parse(result.body);
|
|
message = body.error?.message || message;
|
|
} catch {
|
|
message = result.body || message;
|
|
}
|
|
throw new Error(message);
|
|
}
|
|
|
|
const body = JSON.parse(result.body);
|
|
const items = body.data ?? body;
|
|
const item = Array.isArray(items) ? items[0] : items;
|
|
return item as UploadResult;
|
|
}
|
|
|
|
export function useAutoSync() {
|
|
const queryClient = useQueryClient();
|
|
const isRunning = useRef(false);
|
|
|
|
const checkAndSync = useCallback(async () => {
|
|
if (isRunning.current) return;
|
|
isRunning.current = true;
|
|
|
|
try {
|
|
const folders = safDirectory.getAll();
|
|
const autoFolders = folders.filter((f) => f.syncMode === 'auto');
|
|
if (autoFolders.length === 0) return;
|
|
|
|
const netInfo = await NetInfo.fetch();
|
|
const eligible = autoFolders.filter((f) => canSyncFolder(f, netInfo));
|
|
if (eligible.length === 0) return;
|
|
|
|
const eligibleIds = new Set(eligible.map((f) => f.id));
|
|
const registry = localFileRegistry.getAll();
|
|
|
|
const pendingFiles = registry.filter(
|
|
(entry) =>
|
|
!entry.backendFileId &&
|
|
entry.syncStatus === 'local' &&
|
|
entry.folderId &&
|
|
eligibleIds.has(entry.folderId) &&
|
|
entry.localUri
|
|
);
|
|
|
|
if (pendingFiles.length === 0) return;
|
|
|
|
console.log(`[useAutoSync] upload de ${pendingFiles.length} fichier(s)`);
|
|
setIsSyncing(true);
|
|
|
|
for (const entry of pendingFiles) {
|
|
try {
|
|
const uploaded = await uploadFile({
|
|
uri: entry.localUri,
|
|
type: entry.mimeType,
|
|
name: entry.name,
|
|
});
|
|
|
|
localFileRegistry.register({
|
|
...entry,
|
|
backendFileId: uploaded.id,
|
|
syncStatus: 'synced',
|
|
});
|
|
|
|
console.log(`[useAutoSync] "${entry.name}" uploadé → id=${uploaded.id}`);
|
|
} catch (err) {
|
|
console.error(`[useAutoSync] échec upload "${entry.name}":`, err);
|
|
}
|
|
}
|
|
|
|
queryClient.invalidateQueries({ queryKey: ['files'] });
|
|
console.log(`[useAutoSync] sync terminé`);
|
|
} finally {
|
|
setIsSyncing(false);
|
|
isRunning.current = false;
|
|
}
|
|
}, [queryClient]);
|
|
|
|
useEffect(() => {
|
|
const interval = setInterval(checkAndSync, 30_000);
|
|
checkAndSync();
|
|
return () => clearInterval(interval);
|
|
}, [checkAndSync]);
|
|
|
|
return { triggerSync: checkAndSync };
|
|
}
|