beenull/ente
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

separate hidden and trash from files state

Browse source
This commit is contained in:
Abhinav 2023-05-15 10:16:04 +05:30
parent c6358a486b
commit cd1fc6782b
12 changed files with 179 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
apps/photos/src/components/PhotoFrame.tsx
View file

@ -10,7 +10,6 @@ import {
ALL_SECTION,
ARCHIVE_SECTION,
CollectionType,
HIDDEN_SECTION,
TRASH_SECTION,
} from 'constants/collection';
import { isSharedFile } from 'utils/file';
@ -130,24 +129,14 @@ const PhotoFrame = ({
return false;
}
// Trashed files can only be seen in trash section
if (item.isTrashed || deletedFileIds?.has(item.id)) {
if (activeCollection === TRASH_SECTION) {
idSet.add(item.id);
return true;
} else {
return false;
}
}
// hidden files can only be seen in hidden section
if (item.isHidden) {
if (activeCollection === HIDDEN_SECTION) {
idSet.add(item.id);
return true;
} else {
return false;
}
if (
activeCollection === TRASH_SECTION ||
isDeduplicating ||
activeCollection === HIDDEN_SECTION ||
isIncomingSharedCollection
) {
idSet.add(item.id);
return true;
}
// SEARCH MODE
@ -210,12 +199,6 @@ const PhotoFrame = ({
}
}
// DEDUPLICATE PAGE
if (isDeduplicating) {
idSet.add(item.id);
return true;
}
// Archived files/collection files can only be seen in archive section or their respective collection
if (
IsArchived(item) ||

2
apps/photos/src/components/pages/gallery/PreviewCard.tsx
View file

@ -351,7 +351,7 @@ export default function PreviewCard(props: IProps) {
</p>
</FileAndCollectionNameOverlay>
)}
{props?.activeCollection === TRASH_SECTION && file.isTrashed && (
{props?.activeCollection === TRASH_SECTION && (
<FileAndCollectionNameOverlay>
<p>{formatDateRelative(file.deleteBy / 1000)}</p>
</FileAndCollectionNameOverlay>

6
apps/photos/src/pages/deduplicate/index.tsx
View file

@ -13,7 +13,7 @@ import { EnteFile } from 'types/file';
import { SelectedState } from 'types/gallery';
import { ServerErrorCodes } from 'utils/error';
import { getNonHiddenFiles, getSelectedFiles } from 'utils/file';
import { getSelectedFiles } from 'utils/file';
import {
DeduplicateContextType,
DefaultDeduplicateContext,
@ -84,9 +84,7 @@ export default function Deduplicate() {
collectionNameMap.set(collection.id, collection.name);
}
setCollectionNameMap(collectionNameMap);
const files = getNonHiddenFiles(
await syncFiles(collections, () => null)
);
const files = await syncFiles(collections, () => null);
let duplicates = await getDuplicateFiles(files, collectionNameMap);
if (clubSameTimeFilesOnly) {
duplicates = clubDuplicatesByTime(duplicates);

67
apps/photos/src/pages/gallery/index.tsx
View file

@ -2,6 +2,7 @@ import React, {
createContext,
useContext,
useEffect,
useMemo,
useRef,
useState,
} from 'react';
@ -13,6 +14,8 @@ import {
updateFileMagicMetadata,
trashFiles,
deleteFromTrash,
getLocalHiddenFiles,
syncHiddenFiles,
} from 'services/fileService';
import { styled, Typography } from '@mui/material';
import {
@ -44,7 +47,6 @@ import PhotoFrame from 'components/PhotoFrame';
import {
changeFilesVisibility,
downloadFiles,
getSearchableFiles,
getSelectedFiles,
mergeMetadata,
sortFiles,
@ -77,13 +79,10 @@ import {
getArchivedCollections,
hasNonSystemCollections,
getSearchableCollections,
splitNormalAndHiddenCollections,
} from 'utils/collection';
import { logError } from 'utils/sentry';
import {
getLocalTrash,
getTrashedFiles,
syncTrash,
} from 'services/trashService';
import { getLocalTrashedFiles, syncTrash } from 'services/trashService';
import FixCreationTime, {
FixCreationTimeAttributes,
@ -145,6 +144,8 @@ export default function Gallery() {
const [user, setUser] = useState(null);
const [collections, setCollections] = useState<Collection[]>(null);
const [files, setFiles] = useState<EnteFile[]>(null);
const [hiddenFiles, setHiddenFiles] = useState<EnteFile[]>(null);
const [trashedFiles, setTrashedFiles] = useState<EnteFile[]>(null);
const [favItemIds, setFavItemIds] = useState<Set<number>>();
@ -254,6 +255,25 @@ export default function Gallery() {
},
});
const displayFiles = useMemo(() => {
if (!files || !hiddenFiles || !trashedFiles) {
return [];
}
if (activeCollection === HIDDEN_SECTION) {
return hiddenFiles;
} else if (activeCollection === TRASH_SECTION) {
const markedForDeletionFiles = files.filter((file) =>
deletedFileIds.has(file.id)
);
return [...markedForDeletionFiles, ...trashedFiles];
} else {
const nonMarkedForDeletion = files.filter(
(file) => !deletedFileIds.has(file.id)
);
return nonMarkedForDeletion;
}
}, [activeCollection, files, hiddenFiles, trashedFiles]);
useEffect(() => {
appContext.showNavBar(true);
const key = getKey(SESSION_KEYS.ENCRYPTION_KEY);
@ -276,12 +296,18 @@ export default function Gallery() {
}
setIsFirstLogin(false);
const user = getData(LS_KEYS.USER);
let files = mergeMetadata(await getLocalFiles());
const files = sortFiles(mergeMetadata(await getLocalFiles()));
const hiddenFiles = sortFiles(
mergeMetadata(await getLocalHiddenFiles())
);
const collections = await getLocalCollections();
const trash = await getLocalTrash();
files = [...files, ...getTrashedFiles(trash)];
const trashedFiles = sortFiles(
mergeMetadata(await getLocalTrashedFiles())
);
setUser(user);
setFiles(sortFiles(files));
setFiles(files);
setTrashedFiles(trashedFiles);
setHiddenFiles(hiddenFiles);
setCollections(collections);
await syncWithRemote(true);
setIsFirstLoad(false);
@ -384,10 +410,13 @@ export default function Gallery() {
throw new Error(ServerErrorCodes.SESSION_EXPIRED);
}
!silent && startLoading();
const collections = await syncCollections();
setCollections(collections);
const files = await syncFiles(collections, setFiles);
await syncTrash(collections, files, setFiles);
const collections = await syncCollections(true);
const { normalCollections, hiddenCollections } =
await splitNormalAndHiddenCollections(collections);
setCollections(normalCollections);
await syncFiles(normalCollections, setFiles);
await syncHiddenFiles(hiddenCollections, setHiddenFiles);
await syncTrash(collections, setTrashedFiles);
} catch (e) {
switch (e.message) {
case ServerErrorCodes.SESSION_EXPIRED:
@ -428,11 +457,13 @@ export default function Gallery() {
user,
collections,
files,
trashedFiles,
hiddenFiles,
archivedCollections
);
setCollectionSummaries(collectionSummaries);
const hasNoPersonalFiles = files.every(
(file) => file.ownerID !== user.id && !file.isHidden
(file) => file.ownerID !== user.id
);
setHasNoPersonalFiles(hasNoPersonalFiles);
};
@ -659,6 +690,8 @@ export default function Gallery() {
setExportModalView(false);
};
console.log('rendering gallery', displayFiles);
return (
<GalleryContext.Provider
value={{
@ -720,7 +753,7 @@ export default function Gallery() {
openUploader={openUploader}
isInSearchMode={isInSearchMode}
collections={getSearchableCollections(collections)}
files={getSearchableFiles(files)}
files={files}
setActiveCollection={setActiveCollection}
updateSearch={updateSearch}
/>
@ -781,7 +814,7 @@ export default function Gallery() {
<GalleryEmptyState openUploader={openUploader} />
) : (
<PhotoFrame
files={files}
files={displayFiles}
collections={collections}
syncWithRemote={syncWithRemote}
favItemIds={favItemIds}

54
apps/photos/src/services/collectionService.ts
View file

@ -56,6 +56,7 @@ import {
isValidMoveTarget,
isHiddenCollection,
isValidReplacementAlbum,
getNonHiddenCollections,
} from 'utils/collection';
import ComlinkCryptoWorker from 'utils/comlink/ComlinkCryptoWorker';
import { getLocalFiles } from './fileService';
@ -178,24 +179,28 @@ const getCollections = async (
}
};
export const getLocalCollections = async (): Promise<Collection[]> => {
export const getLocalCollections = async (
includeHidden = false
): Promise<Collection[]> => {
const collections: Collection[] =
(await localForage.getItem(COLLECTION_TABLE)) ?? [];
return collections;
return includeHidden ? collections : getNonHiddenCollections(collections);
};
export const getCollectionUpdationTime = async (): Promise<number> =>
(await localForage.getItem<number>(COLLECTION_UPDATION_TIME)) ?? 0;
export const syncCollections = async () => {
const localCollections = await getLocalCollections();
export const syncCollections = async (includeHidden = false) => {
const localCollections = await getLocalCollections(includeHidden);
const lastCollectionUpdationTime = await getCollectionUpdationTime();
const token = getToken();
const key = await getActualKey();
const updatedCollections =
(await getCollections(token, lastCollectionUpdationTime, key)) ?? [];
if (updatedCollections.length === 0) {
return localCollections;
return includeHidden
? localCollections
: getNonHiddenCollections(localCollections);
}
const allCollectionsInstances = [
...localCollections,
@ -228,7 +233,7 @@ export const syncCollections = async () => {
await localForage.setItem(COLLECTION_TABLE, collections);
await localForage.setItem(COLLECTION_UPDATION_TIME, updationTime);
return collections;
return includeHidden ? collections : getNonHiddenCollections(collections);
};
export const getCollection = async (
@ -264,32 +269,20 @@ export const getCollectionLatestFiles = (
const latestFiles = new Map<number, EnteFile>();
files.forEach((file) => {
if (
!latestFiles.has(file.collectionID) &&
!file.isTrashed &&
!file.isHidden
) {
if (!latestFiles.has(file.collectionID)) {
latestFiles.set(file.collectionID, file);
}
if (!latestFiles.has(ARCHIVE_SECTION) && IsArchived(file)) {
latestFiles.set(ARCHIVE_SECTION, file);
}
if (!latestFiles.has(TRASH_SECTION) && file.isTrashed) {
latestFiles.set(TRASH_SECTION, file);
}
if (
!latestFiles.has(ALL_SECTION) &&
!IsArchived(file) &&
!file.isTrashed &&
!file.isHidden &&
file.ownerID === user.id &&
!archivedCollections.has(file.collectionID)
) {
latestFiles.set(ALL_SECTION, file);
}
if (!latestFiles.has(HIDDEN_SECTION) && file.isHidden) {
latestFiles.set(HIDDEN_SECTION, file);
}
});
return latestFiles;
};
@ -926,9 +919,7 @@ export const getNonEmptyCollections = (
) => {
const nonEmptyCollectionsIds = new Set<number>();
for (const file of files) {
if (!file.isTrashed) {
nonEmptyCollectionsIds.add(file.collectionID);
}
nonEmptyCollectionsIds.add(file.collectionID);
}
return collections.filter((collection) =>
nonEmptyCollectionsIds.has(collection.id)
@ -979,6 +970,8 @@ export async function getCollectionSummaries(
user: User,
collections: Collection[],
files: EnteFile[],
trashedFiles: EnteFile[],
hiddenFiles: EnteFile[],
archivedCollections: Set<number>
): Promise<CollectionSummaries> {
const collectionSummaries: CollectionSummaries = new Map();
@ -989,6 +982,8 @@ export async function getCollectionSummaries(
);
const collectionFilesCount = getCollectionsFileCount(
files,
trashedFiles,
hiddenFiles,
archivedCollections
);
@ -1071,6 +1066,8 @@ export async function getCollectionSummaries(
function getCollectionsFileCount(
files: EnteFile[],
trashedFiles: EnteFile[],
hiddenFiles: EnteFile[],
archivedCollections: Set<number>
): CollectionFilesCount {
const collectionIDToFileMap = groupFilesBasedOnCollectionID(files);
@ -1079,28 +1076,21 @@ function getCollectionsFileCount(
collectionFilesCount.set(id, files.length);
}
const user: User = getData(LS_KEYS.USER);
const uniqueTrashedFileIDs = new Set<number>();
const uniqueArchivedFileIDs = new Set<number>();
const uniqueAllSectionFileIDs = new Set<number>();
const uniqueHiddenSectionFileIDs = new Set<number>();
for (const file of files) {
if (isSharedFile(user, file)) {
continue;
}
if (file.isTrashed) {
uniqueTrashedFileIDs.add(file.id);
} else if (IsArchived(file)) {
uniqueArchivedFileIDs.add(file.id);
} else if (file.isHidden) {
uniqueHiddenSectionFileIDs.add(file.id);
} else if (!archivedCollections.has(file.collectionID)) {
uniqueAllSectionFileIDs.add(file.id);
}
}
collectionFilesCount.set(TRASH_SECTION, uniqueTrashedFileIDs.size);
collectionFilesCount.set(TRASH_SECTION, trashedFiles.length ?? 0);
collectionFilesCount.set(ARCHIVE_SECTION, uniqueArchivedFileIDs.size);
collectionFilesCount.set(ALL_SECTION, uniqueAllSectionFileIDs.size);
collectionFilesCount.set(HIDDEN_SECTION, uniqueHiddenSectionFileIDs.size);
collectionFilesCount.set(HIDDEN_SECTION, hiddenFiles.length ?? 0);
return collectionFilesCount;
}
@ -1191,7 +1181,7 @@ export function createUnCategorizedCollection() {
}
export async function getHiddenCollection(): Promise<Collection> {
const collections = await getLocalCollections();
const collections = await getLocalCollections(true);
const hiddenCollection = collections.find((collection) =>
isHiddenCollection(collection)
);

72
apps/photos/src/services/fileService.ts
View file

@ -6,7 +6,6 @@ import { Collection } from 'types/collection';
import HTTPService from './HTTPService';
import { logError } from 'utils/sentry';
import {
addIsHiddenProperty,
decryptFile,
getLatestVersionFiles,
mergeMetadata,
@ -17,7 +16,6 @@ import { EnteFile, EncryptedEnteFile, TrashRequest } from 'types/file';
import { SetFiles } from 'types/gallery';
import { BulkUpdateMagicMetadataRequest } from 'types/magicMetadata';
import { addLogLine } from 'utils/logging';
import { isHiddenCollection } from 'utils/collection';
import ComlinkCryptoWorker from 'utils/comlink/ComlinkCryptoWorker';
import {
getCollectionLastSyncTime,
@ -28,6 +26,7 @@ import { batch } from 'utils/common';
const ENDPOINT = getEndpoint();
const FILES_TABLE = 'files';
const HIDDEN_FILES_TABLE = 'hidden-files';
export const getLocalFiles = async () => {
const files: Array<EnteFile> =
@ -35,6 +34,12 @@ export const getLocalFiles = async () => {
return files;
};
export const getLocalHiddenFiles = async () => {
const files: Array<EnteFile> =
(await localForage.getItem<EnteFile[]>(HIDDEN_FILES_TABLE)) || [];
return files;
};
const setLocalFiles = async (files: EnteFile[]) => {
try {
await localForage.setItem(FILES_TABLE, files);
@ -58,14 +63,50 @@ const setLocalFiles = async (files: EnteFile[]) => {
}
};
const setLocalHiddenFiles = async (files: EnteFile[]) => {
try {
await localForage.setItem(HIDDEN_FILES_TABLE, files);
} catch (e1) {
try {
const storageEstimate = await navigator.storage.estimate();
logError(e1, 'failed to save files to indexedDB', {
storageEstimate,
});
addLogLine(`storage estimate ${JSON.stringify(storageEstimate)}`);
} catch (e2) {
logError(e1, 'failed to save files to indexedDB');
logError(e2, 'failed to get storage stats');
}
throw e1;
}
};
export const syncHiddenFiles = async (
collections: Collection[],
setFiles: SetFiles
) => {
return await syncFilesHelper(collections, setFiles, 'hidden');
};
export const syncFiles = async (
collections: Collection[],
setFiles: SetFiles
): Promise<EnteFile[]> => {
const localFiles = await getLocalFiles();
) => {
return await syncFilesHelper(collections, setFiles, 'normal');
};
const syncFilesHelper = async (
collections: Collection[],
setFiles: SetFiles,
type: 'normal' | 'hidden'
) => {
const localFiles =
type === 'normal' ? await getLocalFiles() : await getLocalHiddenFiles();
let files = await removeDeletedCollectionFiles(collections, localFiles);
if (files.length !== localFiles.length) {
await setLocalFiles(files);
type === 'normal'
? await setLocalFiles(files)
: await setLocalHiddenFiles(files);
setFiles(sortFiles(mergeMetadata(files)));
}
for (const collection of collections) {
@ -77,14 +118,11 @@ export const syncFiles = async (
continue;
}
const newFiles = await getFiles(
collection,
lastSyncTime,
setFiles,
isHiddenCollection(collection)
);
const newFiles = await getFiles(collection, lastSyncTime, setFiles);
files = getLatestVersionFiles([...files, ...newFiles]);
await setLocalFiles(files);
type === 'normal'
? await setLocalFiles(files)
: await setLocalHiddenFiles(files);
setCollectionLastSyncTime(collection, collection.updationTime);
}
return files;
@ -93,8 +131,7 @@ export const syncFiles = async (
export const getFiles = async (
collection: Collection,
sinceTime: number,
setFiles: SetFiles,
syncingHiddenCollection?: boolean
setFiles: SetFiles
): Promise<EnteFile[]> => {
try {
let decryptedFiles: EnteFile[] = [];
@ -116,7 +153,7 @@ export const getFiles = async (
}
);
let newDecryptedFilesBatch = await Promise.all(
const newDecryptedFilesBatch = await Promise.all(
resp.data.diff.map(async (file: EncryptedEnteFile) => {
if (!file.isDeleted) {
return await decryptFile(file, collection.key);
@ -125,11 +162,6 @@ export const getFiles = async (
}
}) as Promise<EnteFile>[]
);
if (syncingHiddenCollection) {
newDecryptedFilesBatch = addIsHiddenProperty(
newDecryptedFilesBatch
);
}
decryptedFiles = [...decryptedFiles, ...newDecryptedFilesBatch];
setFiles((files) =>

5
apps/photos/src/services/migrateThumbnailService.ts
View file

@ -8,7 +8,7 @@ import HTTPService from 'services/HTTPService';
import uploadHttpClient from 'services/upload/uploadHttpClient';
import { SetProgressTracker } from 'components/FixLargeThumbnail';
import { getFileType } from 'services/typeDetectionService';
import { getLocalTrash, getTrashedFiles } from './trashService';
import { getLocalTrashedFiles } from './trashService';
import { UploadURL } from 'types/upload';
import { FileAttributes } from 'types/file';
import { USE_CF_PROXY } from 'constants/upload';
@ -48,8 +48,7 @@ export async function replaceThumbnail(
const token = getToken();
const cryptoWorker = await ComlinkCryptoWorker.getInstance();
const files = await getLocalFiles();
const trash = await getLocalTrash();
const trashFiles = getTrashedFiles(trash);
const trashFiles = await getLocalTrashedFiles();
const largeThumbnailFiles = [...files, ...trashFiles].filter((file) =>
largeThumbnailFileIDs.has(file.id)
);

30
apps/photos/src/services/trashService.ts
View file

@ -2,14 +2,13 @@ import { SetFiles } from 'types/gallery';
import { Collection } from 'types/collection';
import { getEndpoint } from 'utils/common/apiUtil';
import { getToken } from 'utils/common/key';
import { decryptFile, mergeMetadata, sortFiles } from 'utils/file';
import { decryptFile, sortFiles } from 'utils/file';
import { logError } from 'utils/sentry';
import localForage from 'utils/storage/localForage';
import { getCollection } from './collectionService';
import HTTPService from './HTTPService';
import { EncryptedTrashItem, Trash } from 'types/trash';
import { EnteFile } from 'types/file';
const TRASH = 'file-trash';
const TRASH_TIME = 'trash-time';
@ -17,11 +16,15 @@ const DELETED_COLLECTION = 'deleted-collection';
const ENDPOINT = getEndpoint();
export async function getLocalTrash() {
async function getLocalTrash() {
const trash = (await localForage.getItem<Trash>(TRASH)) || [];
return trash;
}
export async function getLocalTrashedFiles() {
return getTrashedFiles(await getLocalTrash());
}
export async function getLocalDeletedCollections() {
const trashedCollections: Array<Collection> =
(await localForage.getItem<Collection[]>(DELETED_COLLECTION)) || [];
@ -50,7 +53,6 @@ async function getLastSyncTime() {
}
export async function syncTrash(
collections: Collection[],
files: EnteFile[],
setFiles: SetFiles
): Promise<void> {
const trash = await getLocalTrash();
@ -66,7 +68,6 @@ export async function syncTrash(
const updatedTrash = await updateTrash(
collectionMap,
lastSyncTime,
files,
setFiles,
trash
);
@ -76,7 +77,6 @@ export async function syncTrash(
export const updateTrash = async (
collections: Map<number, Collection>,
sinceTime: number,
files: EnteFile[],
setFiles: SetFiles,
currentTrash: Trash
): Promise<Trash> => {
@ -127,9 +127,7 @@ export const updateTrash = async (
time = resp.data.diff.slice(-1)[0].updatedAt;
}
setFiles(
sortFiles([...(files ?? []), ...getTrashedFiles(updatedTrash)])
);
setFiles(sortFiles(getTrashedFiles(updatedTrash)));
await localForage.setItem(TRASH, updatedTrash);
await localForage.setItem(TRASH_TIME, time);
} while (resp.data.hasMore);
@ -141,14 +139,12 @@ export const updateTrash = async (
};
export function getTrashedFiles(trash: Trash) {
return mergeMetadata(
trash.map((trashedFile) => ({
...trashedFile.file,
updationTime: trashedFile.updatedAt,
isTrashed: true,
deleteBy: trashedFile.deleteBy,
}))
);
return trash.map((trashedFile) => ({
...trashedFile.file,
updationTime: trashedFile.updatedAt,
isTrashed: true,
deleteBy: trashedFile.deleteBy,
}));
}
export const emptyTrash = async () => {

8
apps/photos/src/services/upload/uploadManager.ts
View file

@ -1,10 +1,6 @@
import { getLocalFiles } from '../fileService';
import { SetFiles } from 'types/gallery';
import {
sortFiles,
decryptFile,
getUserOwnedNonTrashedFiles,
} from 'utils/file';
import { sortFiles, decryptFile, getUserOwnedFiles } from 'utils/file';
import { logError } from 'utils/sentry';
import { getMetadataJSONMapKey, parseMetadataJSON } from './metadataService';
import {
@ -99,7 +95,7 @@ class UploadManager {
this.userOwnedNonTrashedExistingFiles = this.existingFiles;
} else {
this.existingFiles = await getLocalFiles();
this.userOwnedNonTrashedExistingFiles = getUserOwnedNonTrashedFiles(
this.userOwnedNonTrashedExistingFiles = getUserOwnedFiles(
this.existingFiles
);
}

2
apps/photos/src/types/file/index.ts
View file

@ -60,8 +60,6 @@ export interface EnteFile
w?: number;
h?: number;
title?: string;
isTrashed?: boolean;
isHidden?: boolean;
deleteBy?: number;
isSourceLoaded?: boolean;
originalVideoURL?: string;

24
apps/photos/src/utils/collection/index.ts
View file

@ -310,3 +310,27 @@ export function getSearchableCollections(
): Collection[] {
return collections.filter((collection) => !isHiddenCollection(collection));
}
export function getNonHiddenCollections(
collections: Collection[]
): Collection[] {
return collections.filter((collection) => !isHiddenCollection(collection));
}
export async function splitNormalAndHiddenCollections(
collections: Collection[]
): Promise<{
normalCollections: Collection[];
hiddenCollections: Collection[];
}> {
const normalCollections = [];
const hiddenCollections = [];
for (const collection of collections) {
if (isHiddenCollection(collection)) {
hiddenCollections.push(collection);
} else {
normalCollections.push(collection);
}
}
return { normalCollections, hiddenCollections };
}

26
apps/photos/src/utils/file/index.ts
View file

@ -135,9 +135,7 @@ export function groupFilesBasedOnCollectionID(files: EnteFile[]) {
if (!collectionWiseFiles.has(file.collectionID)) {
collectionWiseFiles.set(file.collectionID, []);
}
if (!file.isTrashed) {
collectionWiseFiles.get(file.collectionID).push(file);
}
collectionWiseFiles.get(file.collectionID).push(file);
}
return collectionWiseFiles;
}
@ -445,13 +443,6 @@ export function mergeMetadata(files: EnteFile[]): EnteFile[] {
});
}
export function addIsHiddenProperty(files: EnteFile[]): EnteFile[] {
return files.map((file) => ({
...file,
isHidden: true,
}));
}
export function updateExistingFilePubMetadata(
existingFile: EnteFile,
updatedFile: EnteFile
@ -477,13 +468,6 @@ export function getUniqueFiles(files: EnteFile[]) {
}
});
}
export function getSearchableFiles(files: EnteFile[]) {
return files.filter(
(file) =>
(typeof file.isTrashed === 'undefined' || !file.isTrashed) &&
(typeof file.isHidden === 'undefined' || !file.isHidden)
);
}
export async function downloadFiles(files: EnteFile[]) {
for (const file of files) {
@ -518,12 +502,12 @@ export const createTypedObjectURL = async (blob: Blob, fileName: string) => {
return URL.createObjectURL(new Blob([blob], { type: type.mimeType }));
};
export const getUserOwnedNonTrashedFiles = (files: EnteFile[]) => {
export const getUserOwnedFiles = (files: EnteFile[]) => {
const user: User = getData(LS_KEYS.USER);
if (!user?.id) {
throw Error('user missing');
}
return files.filter((file) => file.isTrashed || file.ownerID === user.id);
return files.filter((file) => file.ownerID === user.id);
};
// doesn't work on firefox
@ -595,7 +579,3 @@ export function getPersonalFiles(files: EnteFile[], user: User) {
export function getIDBasedSortedFiles(files: EnteFile[]) {
return files.sort((a, b) => a.id - b.id);
}
export function getNonHiddenFiles(files: EnteFile[]) {
return files.filter((file) => !file.isHidden);
}