Backup: Lots of fixes, refactoring and documentation

patches/react-native-background-upload+6.6.0.patch

@@ -7,7 +7,7 @@ index c89d495..5da9d14 100644
  import net.gotev.uploadservice.network.ServerResponse
  import net.gotev.uploadservice.observer.request.RequestObserverDelegate
 +import net.gotev.uploadservice.exceptions.UploadError
- 
+
  class GlobalRequestObserverDelegate(reactContext: ReactApplicationContext) : RequestObserverDelegate {
    private val TAG = "UploadReceiver"
 @@ -28,6 +29,10 @@ class GlobalRequestObserverDelegate(reactContext: ReactApplicationContext) : Req
@@ -26,11 +26,11 @@ index 8b2a07c..80cff93 100644
 --- a/node_modules/react-native-background-upload/index.d.ts
 +++ b/node_modules/react-native-background-upload/index.d.ts
 @@ -11,6 +11,8 @@ declare module "react-native-background-upload" {
- 
+
      export interface ErrorData extends EventData {
          error: string
-+        responseCode: number
-+        responseBody: string
++        responseCode?: number
++        responseBody?: string
      }
- 
+
      export interface CompletedData extends EventData {

src/@types/cozy-client.d.ts

@@ -130,6 +130,10 @@ declare module 'cozy-client' {
     ) => Promise<{ included: { attributes: unknown }[] }>
     createDirectoryByPath: (path: string) => Promise<FileCollectionGetResult>
     ensureDirectoryExists: (path: string) => Promise<string>
+    getDirectoryOrCreate: (
+      name: string,
+      parentDirectory: object
+    ) => Promise<FileCollectionGetResult>
     createFileMetadata: (metadata: object) => Promise<{ data: { id: string } }>
     addReferencesTo: (references: object, dirs: object[]) => Promise<void>
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

src/app/domain/backup/helpers/error.ts

@@ -1,3 +1,5 @@
+import { UploadError } from '/app/domain/upload/models'
+
 export class BackupError extends Error {
   statusCode: number | undefined
 
@@ -13,6 +15,13 @@ export class BackupError extends Error {
   }
 }
 
-export const STACK_ERRORS_INTERRUPTING_BACKUP = [
-  413 // quota exceeded
-]
+export const isQuotaExceededError = (error: UploadError): boolean => {
+  return (
+    error.statusCode === 413 &&
+    error.errors[0].detail === 'The file is too big and exceeds the disk quota'
+  )
+}
+
+export const isFatalError = (error: UploadError): boolean => {
+  return isQuotaExceededError(error)
+}

src/app/domain/backup/models/Media.ts

@@ -1,5 +1,3 @@
-import { StackErrors, IOCozyFile } from 'cozy-client'
-
 import { Album } from '/app/domain/backup/models'
 
 /**
@@ -30,13 +28,3 @@ export interface BackupedMedia {
   name: string
   remotePath: string
 }
-
-export type UploadMediaError = {
-  statusCode: number
-} & StackErrors
-
-// These type is incomplete there is more information in data
-export interface UploadMediaResult {
-  statusCode: number
-  data: IOCozyFile
-}

src/app/domain/backup/services/manageBackup.ts

@@ -22,7 +22,7 @@ import {
 import {
   cancelUpload,
   getCurrentUploadId
-} from '/app/domain/backup/services/uploadMedia'
+} from '/app/domain/upload/services/upload'
 import {
   fetchDeviceRemoteBackupConfig,
   fetchBackupedMedias,

src/app/domain/backup/services/manageRemoteBackupConfig.ts

@@ -22,6 +22,15 @@ import { IOCozyFile } from 'cozy-client/types/types'
 const DOCTYPE_APPS = 'io.cozy.apps'
 const DOCTYPE_FILES = 'io.cozy.files'
 const BACKUP_REF = `io.cozy.apps/photos/mobile`
+const PHOTOS_REF = `io.cozy.apps/photos`
+
+interface Folder {
+  _id: string
+  attributes: {
+    name: string
+    path: string
+  }
+}
 
 interface BackupFolder {
   _id: string
@@ -119,17 +128,65 @@ const createRemoteBackupFolderWithConflictStrategy = async (
   }
 }
 
+export const getOrCreatePhotosMagicFolder = async (
+  client: CozyClient
+): Promise<Folder> => {
+  const { included } = await client.collection(DOCTYPE_FILES).findReferencedBy({
+    _type: DOCTYPE_APPS,
+    _id: PHOTOS_REF
+  })
+
+  let photosMagicFolders = included as Folder[]
+
+  photosMagicFolders = photosMagicFolders.filter(
+    folder => !isInTrash(folder.attributes.path)
+  )
+
+  if (photosMagicFolders.length > 0) {
+    return photosMagicFolders[0]
+  }
+
+  const { data: newPhotosMagicFolder } = await client
+    .collection(DOCTYPE_FILES)
+    .createDirectoryByPath('/Photos')
+
+  await client.collection(DOCTYPE_FILES).addReferencesTo(
+    {
+      _id: PHOTOS_REF,
+      _type: DOCTYPE_APPS
+    },
+    [
+      {
+        _id: newPhotosMagicFolder._id
+      }
+    ]
+  )
+
+  return {
+    _id: newPhotosMagicFolder._id,
+    attributes: {
+      name: newPhotosMagicFolder.name,
+      path: newPhotosMagicFolder.path
+    }
+  }
+}
+
 export const createRemoteBackupFolder = async (
   client: CozyClient
 ): Promise<RemoteBackupConfig> => {
   const deviceName = await getDeviceName()
   const deviceId = await getDeviceId()
 
+  const photosMagicFolder = await getOrCreatePhotosMagicFolder(client)
+
   const {
     data: { _id: backupRootId }
   } = await client
     .collection(DOCTYPE_FILES)
-    .createDirectoryByPath(t('services.backup.backupRootPath'))
+    .getDirectoryOrCreate(
+      t('services.backup.backupRootName'),
+      photosMagicFolder
+    )
 
   const backupFolderAttributes = {
     type: 'directory',

src/app/domain/backup/services/uploadMedia.android.ts

@@ -1,114 +1,46 @@
-/* eslint-disable promise/always-return */
-import RNBackgroundUpload, {
-  UploadOptions
-} from 'react-native-background-upload'
-
 import { getMimeType } from '/app/domain/backup/services/getMedias'
-import { Media, UploadMediaResult } from '/app/domain/backup/models/Media'
+import { Media } from '/app/domain/backup/models/Media'
 import { t } from '/locales/i18n'
 
-import CozyClient, { StackErrors, IOCozyFile } from 'cozy-client'
-
-let currentUploadId: string | undefined
+import CozyClient from 'cozy-client'
 
-export const getCurrentUploadId = (): string | undefined => {
-  return currentUploadId
-}
-
-const setCurrentUploadId = (value: string): void => {
-  currentUploadId = value
-}
+import { uploadFile } from '/app/domain/upload/services/upload'
+import { UploadResult } from '/app/domain/upload/models'
 
 export const uploadMedia = async (
   client: CozyClient,
   uploadUrl: string,
   media: Media
-): Promise<UploadMediaResult> => {
+): Promise<UploadResult> => {
   const filepath = media.path.replace('file://', '')
 
-  return new Promise((resolve, reject) => {
-    const options = {
-      url: uploadUrl,
-      path: filepath,
-      method: 'POST',
-      type: 'raw',
-      headers: {
-        Accept: 'application/json',
-        'Content-Type': getMimeType(media),
-        Authorization: `Bearer ${
-          // @ts-expect-error Type issue which will be fixed in another PR
-          client.getStackClient().token.accessToken as string
-        }`
-      },
-      notification: {
-        enabled: true,
-        autoClear: true,
-        onProgressTitle: t('services.backup.notifications.onProgressTitle'),
-        onProgressMessage: t(
-          'services.backup.notifications.onProgressMessage',
-          {
-            filename: media.name
-          }
-        ),
-        onCompleteTitle: t('services.backup.notifications.onCompleteTitle'),
-        onCompleteMessage: t(
-          'services.backup.notifications.onCompleteMessage',
-          {
-            filename: media.name
-          }
-        ),
-        onErrorTitle: t('services.backup.notifications.onErrorTitle'),
-        onErrorMessage: t('services.backup.notifications.onErrorMessage', {
+  return uploadFile({
+    url: uploadUrl,
+    // @ts-expect-error Type issue which will be fixed in another PR
+    token: client.getStackClient().token.accessToken as string,
+    filename: media.name,
+    filepath,
+    mimetype: getMimeType(media),
+    notification: {
+      onProgressTitle: t('services.backup.notifications.onProgressTitle'),
+      onProgressMessage: t('services.backup.notifications.onProgressMessage', {
+        filename: media.name
+      }),
+      onCompleteTitle: t('services.backup.notifications.onCompleteTitle'),
+      onCompleteMessage: t('services.backup.notifications.onCompleteMessage', {
+        filename: media.name
+      }),
+      onErrorTitle: t('services.backup.notifications.onErrorTitle'),
+      onErrorMessage: t('services.backup.notifications.onErrorMessage', {
+        filename: media.name
+      }),
+      onCancelledTitle: t('services.backup.notifications.onCancelledTitle'),
+      onCancelledMessage: t(
+        'services.backup.notifications.onCancelledMessage',
+        {
           filename: media.name
-        }),
-        onCancelledTitle: t('services.backup.notifications.onCancelledTitle'),
-        onCancelledMessage: t(
-          'services.backup.notifications.onCancelledMessage',
-          {
-            filename: media.name
-          }
-        )
-      }
-    } as UploadOptions
-
-    RNBackgroundUpload.startUpload(options)
-      .then(uploadId => {
-        setCurrentUploadId(uploadId)
-
-        RNBackgroundUpload.addListener('error', uploadId, error => {
-          const { errors } = JSON.parse(error.responseBody) as StackErrors
-          reject({
-            statusCode: error.responseCode,
-            errors
-          })
-        })
-        RNBackgroundUpload.addListener('cancelled', uploadId, data => {
-          reject({ success: false, data })
-        })
-        RNBackgroundUpload.addListener('completed', uploadId, response => {
-          const { data } = JSON.parse(response.responseBody) as {
-            data: IOCozyFile
-          }
-
-          if (response.responseCode === 201) {
-            resolve({
-              statusCode: response.responseCode,
-              data
-            })
-          } else {
-            reject({
-              statusCode: response.responseCode,
-              data
-            })
-          }
-        })
-      })
-      .catch(e => {
-        reject(e)
-      })
+        }
+      )
+    }
   })
 }
-
-export const cancelUpload = (uploadId: string): Promise<boolean> => {
-  return RNBackgroundUpload.cancelUpload(uploadId)
-}