conv UploadResult

2025-03-18 14:25:59 +05:30
parent b065e20d65
commit 48eec72bf6
5 changed files with 70 additions and 90 deletions
--- a/web/apps/photos/src/components/UploadProgress.tsx
+++ b/web/apps/photos/src/components/UploadProgress.tsx
@@ -1,6 +1,6 @@
 import { FilledIconButton } from "@/base/components/mui";
 import { useBaseContext } from "@/base/context";
-import { UPLOAD_RESULT, type UploadPhase } from "@/gallery/services/upload";
+import { type UploadPhase, type UploadResult } from "@/gallery/services/upload";
 import { SpaceBetweenFlex } from "@ente/shared/components/Container";
 import CloseIcon from "@mui/icons-material/Close";
 import ExpandMoreIcon from "@mui/icons-material/ExpandMore";
@@ -265,13 +265,12 @@ function UploadProgressDialog() {

    useEffect(() => {
        if (
-            finishedUploads.get(UPLOAD_RESULT.ALREADY_UPLOADED)?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.BLOCKED)?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.FAILED)?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.LARGER_THAN_AVAILABLE_STORAGE)
-                ?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.TOO_LARGE)?.length > 0 ||
-            finishedUploads.get(UPLOAD_RESULT.UNSUPPORTED)?.length > 0
+            finishedUploads.get("alreadyUploaded")?.length > 0 ||
+            finishedUploads.get("blocked")?.length > 0 ||
+            finishedUploads.get("failed")?.length > 0 ||
+            finishedUploads.get("largerThanAvailableStorage")?.length > 0 ||
+            finishedUploads.get("tooLarge")?.length > 0 ||
+            finishedUploads.get("unsupported")?.length > 0
        ) {
            setHasUnUploadedFiles(true);
        } else {
@@ -290,13 +289,11 @@ function UploadProgressDialog() {
                <DialogContent sx={{ "&&&": { px: 0 } }}>
                    {uploadPhase === "uploading" && <InProgressSection />}
                    <ResultSection
-                        uploadResult={UPLOAD_RESULT.UPLOADED}
+                        uploadResult="uploaded"
                        sectionTitle={t("SUCCESSFUL_UPLOADS")}
                    />
                    <ResultSection
-                        uploadResult={
-                            UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL
-                        }
+                        uploadResult="uploadedWithStaticThumbnail"
                        sectionTitle={t("THUMBNAIL_GENERATION_FAILED_UPLOADS")}
                        sectionInfo={t("THUMBNAIL_GENERATION_FAILED_INFO")}
                    />
@@ -306,12 +303,12 @@ function UploadProgressDialog() {
                        </NotUploadSectionHeader>
                    )}
                    <ResultSection
-                        uploadResult={UPLOAD_RESULT.BLOCKED}
+                        uploadResult="blocked"
                        sectionTitle={t("BLOCKED_UPLOADS")}
                        sectionInfo={<Trans i18nKey={"ETAGS_BLOCKED"} />}
                    />
                    <ResultSection
-                        uploadResult={UPLOAD_RESULT.FAILED}
+                        uploadResult="failed"
                        sectionTitle={t("FAILED_UPLOADS")}
                        sectionInfo={
                            uploadPhase == "done"
@@ -320,26 +317,24 @@ function UploadProgressDialog() {
                        }
                    />
                    <ResultSection
-                        uploadResult={UPLOAD_RESULT.ALREADY_UPLOADED}
+                        uploadResult="alreadyUploaded"
                        sectionTitle={t("SKIPPED_FILES")}
                        sectionInfo={t("SKIPPED_INFO")}
                    />
                    <ResultSection
-                        uploadResult={
-                            UPLOAD_RESULT.LARGER_THAN_AVAILABLE_STORAGE
-                        }
+                        uploadResult="largerThanAvailableStorage"
                        sectionTitle={t(
                            "LARGER_THAN_AVAILABLE_STORAGE_UPLOADS",
                        )}
                        sectionInfo={t("LARGER_THAN_AVAILABLE_STORAGE_INFO")}
                    />
                    <ResultSection
-                        uploadResult={UPLOAD_RESULT.UNSUPPORTED}
+                        uploadResult="unsupported"
                        sectionTitle={t("UNSUPPORTED_FILES")}
                        sectionInfo={t("UNSUPPORTED_INFO")}
                    />
                    <ResultSection
-                        uploadResult={UPLOAD_RESULT.TOO_LARGE}
+                        uploadResult="tooLarge"
                        sectionTitle={t("TOO_LARGE_UPLOADS")}
                        sectionInfo={t("TOO_LARGE_INFO")}
                    />
@@ -457,7 +452,7 @@ const NotUploadSectionHeader = styled("div")(
 );

 interface ResultSectionProps {
-    uploadResult: UPLOAD_RESULT;
+    uploadResult: UploadResult;
    sectionTitle: string;
    sectionInfo?: React.ReactNode;
 }
@@ -552,8 +547,8 @@ const DoneFooter: React.FC = () => {
    return (
        <DialogActions>
            {uploadPhase == "done" &&
-                (finishedUploads?.get(UPLOAD_RESULT.FAILED)?.length > 0 ||
-                finishedUploads?.get(UPLOAD_RESULT.BLOCKED)?.length > 0 ? (
+                (finishedUploads?.get("failed")?.length > 0 ||
+                finishedUploads?.get("blocked")?.length > 0 ? (
                    <Button fullWidth onClick={retryFailed}>
                        {t("RETRY_FAILED")}
                    </Button>
--- a/web/apps/photos/src/services/upload/upload-service.ts
+++ b/web/apps/photos/src/services/upload/upload-service.ts
@@ -14,7 +14,7 @@ import {
 import type { UploadItem } from "@/gallery/services/upload";
 import {
    RANDOM_PERCENTAGE_PROGRESS_FOR_PUT,
-    UPLOAD_RESULT,
+    type UploadResult,
 } from "@/gallery/services/upload";
 import {
    detectFileTypeInfoFromChunk,
@@ -528,7 +528,7 @@ type MakeProgressTracker = (
 ) => unknown;

 interface UploadResponse {
-    uploadResult: UPLOAD_RESULT;
+    uploadResult: UploadResult;
    uploadedFile?: EncryptedEnteFile | EnteFile;
 }

@@ -574,7 +574,7 @@ export const uploader = async (
        } catch (e) {
            if (isFileTypeNotSupportedError(e)) {
                log.error(`Not uploading ${fileName}`, e);
-                return { uploadResult: UPLOAD_RESULT.UNSUPPORTED };
+                return { uploadResult: "unsupported" };
            }
            throw e;
        }
@@ -582,8 +582,7 @@ export const uploader = async (
        const { fileTypeInfo, fileSize, lastModifiedMs } = assetDetails;

        const maxFileSize = 4 * 1024 * 1024 * 1024; /* 4 GB */
-        if (fileSize >= maxFileSize)
-            return { uploadResult: UPLOAD_RESULT.TOO_LARGE };
+        if (fileSize >= maxFileSize) return { uploadResult: "tooLarge" };

        abortIfCancelled();

@@ -608,7 +607,7 @@ export const uploader = async (
            );
            if (matchInSameCollection) {
                return {
-                    uploadResult: UPLOAD_RESULT.ALREADY_UPLOADED,
+                    uploadResult: "alreadyUploaded",
                    uploadedFile: matchInSameCollection,
                };
            } else {
@@ -616,10 +615,7 @@ export const uploader = async (
                const symlink = Object.assign({}, anyMatch);
                symlink.collectionID = collection.id;
                await addToCollection(collection, [symlink]);
-                return {
-                    uploadResult: UPLOAD_RESULT.ADDED_SYMLINK,
-                    uploadedFile: symlink,
-                };
+                return { uploadResult: "addedSymlink", uploadedFile: symlink };
            }
        }

@@ -669,8 +665,8 @@ export const uploader = async (

        return {
            uploadResult: metadata.hasStaticThumbnail
-                ? UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL
-                : UPLOAD_RESULT.UPLOADED,
+                ? "uploadedWithStaticThumbnail"
+                : "uploaded",
            uploadedFile: uploadedFile,
        };
    } catch (e) {
@@ -683,13 +679,11 @@ export const uploader = async (
        const error = handleUploadError(e);
        switch (error.message) {
            case CustomError.ETAG_MISSING:
-                return { uploadResult: UPLOAD_RESULT.BLOCKED };
+                return { uploadResult: "blocked" };
            case CustomError.FILE_TOO_LARGE:
-                return {
-                    uploadResult: UPLOAD_RESULT.LARGER_THAN_AVAILABLE_STORAGE,
-                };
+                return { uploadResult: "largerThanAvailableStorage" };
            default:
-                return { uploadResult: UPLOAD_RESULT.FAILED };
+                return { uploadResult: "failed" };
        }
    }
 };
--- a/web/apps/photos/src/services/upload/uploadManager.ts
+++ b/web/apps/photos/src/services/upload/uploadManager.ts
@@ -9,9 +9,9 @@ import { ComlinkWorker } from "@/base/worker/comlink-worker";
 import type { UploadItem } from "@/gallery/services/upload";
 import {
    RANDOM_PERCENTAGE_PROGRESS_FOR_PUT,
-    UPLOAD_RESULT,
    shouldDisableCFUploadProxy,
    type UploadPhase,
+    type UploadResult,
 } from "@/gallery/services/upload";
 import type { Collection } from "@/media/collection";
 import {
@@ -64,14 +64,14 @@ export interface InProgressUpload {

 export interface FinishedUpload {
    localFileID: FileID;
-    result: UPLOAD_RESULT;
+    result: UploadResult;
 }

 export type InProgressUploads = Map<FileID, PercentageUploaded>;

-export type FinishedUploads = Map<FileID, UPLOAD_RESULT>;
+export type FinishedUploads = Map<FileID, UploadResult>;

-export type SegregatedFinishedUploads = Map<UPLOAD_RESULT, FileID[]>;
+export type SegregatedFinishedUploads = Map<UploadResult, FileID[]>;

 export interface ProgressUpdater {
    setPercentComplete: React.Dispatch<React.SetStateAction<number>>;
@@ -161,7 +161,7 @@ class UIService {
        this.setTotalFileCount(count);
        this.filesUploadedCount = 0;
        this.inProgressUploads = new Map<number, number>();
-        this.finishedUploads = new Map<number, UPLOAD_RESULT>();
+        this.finishedUploads = new Map<number, UploadResult>();
        this.updateProgressBarUI();
    }

@@ -205,7 +205,7 @@ class UIService {
        this.updateProgressBarUI();
    }

-    moveFileToResultList(key: number, uploadResult: UPLOAD_RESULT) {
+    moveFileToResultList(key: number, uploadResult: UploadResult) {
        this.finishedUploads.set(key, uploadResult);
        this.inProgressUploads.delete(key);
        this.updateProgressBarUI();
@@ -595,39 +595,36 @@ class UploadManager {

    private async postUploadTask(
        uploadableItem: UploadableUploadItem,
-        uploadResult: UPLOAD_RESULT,
+        uploadResult: UploadResult,
        uploadedFile: EncryptedEnteFile | EnteFile | undefined,
    ) {
-        const key = UPLOAD_RESULT[uploadResult];
-        log.info(
-            `Uploaded ${uploadableItem.fileName} with result ${uploadResult} (${key})`,
-        );
+        log.info(`Uploaded ${uploadableItem.fileName} (${uploadResult})`);
        try {
            const electron = globalThis.electron;
            if (electron) await markUploaded(electron, uploadableItem);

            let decryptedFile: EnteFile;
            switch (uploadResult) {
-                case UPLOAD_RESULT.FAILED:
-                case UPLOAD_RESULT.BLOCKED:
+                case "failed":
+                case "blocked":
                    this.failedItems.push(uploadableItem);
                    break;
-                case UPLOAD_RESULT.ALREADY_UPLOADED:
+                case "alreadyUploaded":
                    decryptedFile = uploadedFile as EnteFile;
                    break;
-                case UPLOAD_RESULT.ADDED_SYMLINK:
+                case "addedSymlink":
                    decryptedFile = uploadedFile as EnteFile;
-                    uploadResult = UPLOAD_RESULT.UPLOADED;
+                    uploadResult = "uploaded";
                    break;
-                case UPLOAD_RESULT.UPLOADED:
-                case UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL:
+                case "uploaded":
+                case "uploadedWithStaticThumbnail":
                    decryptedFile = await decryptFile(
                        uploadedFile as EncryptedEnteFile,
                        uploadableItem.collection.key,
                    );
                    break;
-                case UPLOAD_RESULT.UNSUPPORTED:
-                case UPLOAD_RESULT.TOO_LARGE:
+                case "unsupported":
+                case "tooLarge":
                    // no-op
                    break;
                default:
@@ -635,9 +632,9 @@ class UploadManager {
            }
            if (
                [
-                    UPLOAD_RESULT.ADDED_SYMLINK,
-                    UPLOAD_RESULT.UPLOADED,
-                    UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL,
+                    "addedSymlink",
+                    "uploaded",
+                    "uploadedWithStaticThumbnail",
                ].includes(uploadResult)
            ) {
                const uploadItem =
@@ -645,9 +642,8 @@ class UploadManager {
                    uploadableItem.livePhotoAssets.image;
                if (
                    uploadItem &&
-                    (uploadResult == UPLOAD_RESULT.UPLOADED ||
-                        uploadResult ==
-                            UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL)
+                    (uploadResult == "uploaded" ||
+                        uploadResult == "uploadedWithStaticThumbnail")
                ) {
                    indexNewUpload(decryptedFile, uploadItem);
                }
@@ -661,12 +657,12 @@ class UploadManager {
            return uploadResult;
        } catch (e) {
            log.error("failed to do post file upload action", e);
-            return UPLOAD_RESULT.FAILED;
+            return "failed";
        }
    }

    private async watchFolderCallback(
-        fileUploadResult: UPLOAD_RESULT,
+        fileUploadResult: UploadResult,
        fileWithCollection: ClusteredUploadItem,
        uploadedFile: EncryptedEnteFile,
    ) {
--- a/web/apps/photos/src/services/watch.ts
+++ b/web/apps/photos/src/services/watch.ts
@@ -11,7 +11,7 @@ import type {
    FolderWatch,
    FolderWatchSyncedFile,
 } from "@/base/types/ipc";
-import { UPLOAD_RESULT } from "@/gallery/services/upload";
+import { type UploadResult } from "@/gallery/services/upload";
 import type { Collection } from "@/media/collection";
 import { EncryptedEnteFile } from "@/media/file";
 import {
@@ -324,7 +324,7 @@ class FolderWatcher {
     * {@link upload} gets uploaded.
     */
    async onFileUpload(
-        fileUploadResult: UPLOAD_RESULT,
+        fileUploadResult: UploadResult,
        item: UploadItemWithCollection,
        file: EncryptedEnteFile,
    ) {
@@ -333,10 +333,10 @@ class FolderWatcher {
        // file on disk).
        if (
            [
-                UPLOAD_RESULT.ADDED_SYMLINK,
-                UPLOAD_RESULT.UPLOADED,
-                UPLOAD_RESULT.UPLOADED_WITH_STATIC_THUMBNAIL,
-                UPLOAD_RESULT.ALREADY_UPLOADED,
+                "addedSymlink",
+                "uploaded",
+                "uploadedWithStaticThumbnail",
+                "alreadyUploaded",
            ].includes(fileUploadResult)
        ) {
            if (item.isLivePhoto) {
@@ -354,11 +354,7 @@ class FolderWatcher {
                    file,
                );
            }
-        } else if (
-            [UPLOAD_RESULT.UNSUPPORTED, UPLOAD_RESULT.TOO_LARGE].includes(
-                fileUploadResult,
-            )
-        ) {
+        } else if (["unsupported", "tooLarge"].includes(fileUploadResult)) {
            if (item.isLivePhoto) {
                this.unUploadableFilePaths.add(
                    ensureString(item.livePhotoAssets.image),
--- a/web/packages/gallery/services/upload.ts
+++ b/web/packages/gallery/services/upload.ts
@@ -94,17 +94,16 @@ export type UploadPhase =
    | "cancelling"
    | "done";

-export enum UPLOAD_RESULT {
-    FAILED,
-    ALREADY_UPLOADED,
-    UNSUPPORTED,
-    BLOCKED,
-    TOO_LARGE,
-    LARGER_THAN_AVAILABLE_STORAGE,
-    UPLOADED,
-    UPLOADED_WITH_STATIC_THUMBNAIL,
-    ADDED_SYMLINK,
-}
+export type UploadResult =
+    | "failed"
+    | "alreadyUploaded"
+    | "unsupported"
+    | "blocked"
+    | "tooLarge"
+    | "largerThanAvailableStorage"
+    | "uploaded"
+    | "uploadedWithStaticThumbnail"
+    | "addedSymlink";

 /**
 * Return true to disable the upload of files via Cloudflare Workers.