+ {children}
+
+ );
+}
+
+function useSelection
(): SelectionContextProps {
+ const context = React.useContext>(SelectionContext);
+ if (context === undefined) {
+ throw new Error('useSelection must be used within a SelectionProvider');
+ }
+
+ return context;
+}
+
+export { SelectionProvider, Selectable, useSelection };
diff --git a/src/SelectionToolbar.tsx b/src/SelectionToolbar.tsx
new file mode 100644
index 0000000..280f686
--- /dev/null
+++ b/src/SelectionToolbar.tsx
@@ -0,0 +1,44 @@
+import { FC } from "react";
+import { useParams } from "react-router-dom";
+
+import BottomNavigation from "@mui/material/BottomNavigation";
+import BottomNavigationAction from "@mui/material/BottomNavigationAction";
+import DeleteForeverIcon from '@mui/icons-material/DeleteForever';
+import DeselectIcon from '@mui/icons-material/Deselect';
+import Divider from "@mui/material/Divider";
+import DriveFileMoveIcon from '@mui/icons-material/DriveFileMove';
+import SelectAllIcon from '@mui/icons-material/SelectAll';
+
+import { PhotoImageType } from "./types";
+import { useDialog } from "./dialogs";
+import { useSelection } from "./Selection";
+
+const SelectionToolbar: FC = () => {
+ const { collection = "", album = "" } = useParams();
+ const { get, all, cancel, isSelecting } = useSelection();
+ const dialog = useDialog();
+
+ const handleMove = () => {
+ dialog.move(collection, album, get());
+ }
+ const handleDelete = () => {
+ dialog.delete(collection, album, get());
+ }
+
+ if(!isSelecting)
+ return null;
+
+ return (
+
+
+ } />
+ } />
+
+ } />
+ } />
+
+
Do not delete all matches!}
+ }>
+
+
+ }
+ {collection}: {album} - {id}
+
+
+ {files.map((f, i) =>
+ {f.from < 0 ? <>∅ : photo.files[f.from].id} ↔ {f.to < 0 ? <>∅ : foundFiles[f.to].id}
+ )}
+ )
+ )}
+ />
+ );
+}
+const ItemUnique: FC> = ({item}) => {
+ const dialog = useDialog();
+
+ const handleOpenPhoto = () => {
+ dialog.lightbox([item], 0);
+ }
+
+ return (<>
+
+
+
+ {item.files.map((f, i) => {f.id}
)}}
+ />
+ );
+}
+
+interface SelectableItemProps {
+ item: T;
+ component: FC>;
+}
+function SelectableItem({ item, component }: SelectableItemProps) {
+ const [selected, setSelected] = useState(false);
+ const Item = component;
+
+ const handleSelect = (state: boolean) => {
+ setSelected(state);
+ }
+
+ return (
+ item={item} onChange={handleSelect}>
+
+
+
+ {items.map((item, index) => ())}
+
+
+ Select All -
+ Clear Selection
+
+ );
+}
+
+interface TabPanelProps {
+ children?: React.ReactNode;
+ index: number;
+ value: number;
+}
+function TabPanel(props: TabPanelProps) {
+ const { children, value, index, ...other } = props;
+
+ return (
+
+ {value === index && children}
+
+ );
+}
+
+interface DialogProps {
+ open: boolean;
+ collection: string;
+ album: string;
+ onClose: () => void;
+}
+
+const defaultData: ResponseDuplicates = {
+ total: 0,
+ albums: [],
+ keep: [],
+ unique: [],
+ delete: [],
+ conflict: [],
+ samealbum: [],
+ countKeep: 0,
+ countDelete: 0,
+ countUnique: 0,
+ countConflict: 0,
+ countSameAlbum: 0
+}
+
+function filterList(list: Duplicate[], filter: PseudoAlbumType[], onlyMultiple: boolean): Duplicate[] {
+ const validList = list || [];
+
+ const filteredAlbums = filter.length < 1 ? validList :
+ validList.map(d => ({
+ ...d,
+ found: d.found.filter(p => filter.some(f => f.collection === p.photo.collection && f.album === p.photo.album))
+ })).filter(d => d.found.length > 0);
+
+ return onlyMultiple ?
+ filteredAlbums.filter(d => d.found.length > 1) :
+ filteredAlbums;
+}
+
+const DuplicatesDialog: FC = ({open, collection, album, onClose}) => {
+ const theme = useTheme();
+ const fullScreen = useMediaQuery(theme.breakpoints.down('sm'));
+ const dialog = useDialog();
+ const favorite = useFavorite();
+ const { data = defaultData, isFetching } = useDuplicatedPhotosQuery({ collection, album }, {skip: !open});
+ const [albumsFilter, setAlbumsFilter] = useState([]);
+ const [onlyMultiple, setOnlyMultiple] = useState(false);
+ const [tab, setTab] = useState(0);
+ const [isSelectingDups, setSelectingDups] = useState(false);
+ const [isSelectingUniq, setSelectingUniq] = useState(false);
+ const [selDups, setSelDups] = useState([]);
+ const [selUniq, setSelUniq] = useState([]);
+
+ const noSelection = isFetching ||
+ // Delete, Keep, Conflict, Same
+ ((tab === 0 || tab === 1 || tab === 2 || tab === 3) && !isSelectingDups) ||
+ // Unique
+ (tab === 4 && !isSelectingUniq);
+
+ // Filter by selected albums
+ const filter = albumsFilter.map(album => JSON.parse(album) as PseudoAlbumType);
+ const listDelete = filterList(data.delete, filter, onlyMultiple);
+ const listKeep = filterList(data.keep, filter, onlyMultiple);
+ const listConflict = filterList(data.conflict, filter, onlyMultiple);
+ const listSameAlbum = filterList(data.samealbum, filter, onlyMultiple);
+ const listUnique = data.unique || [];
+
+ // Clear album filter when opening
+ useEffect(() => setAlbumsFilter([]), [open]);
+
+ const handleChangeAlbumsFilter = (event: SelectChangeEvent) => {
+ const val = event.target.value;
+ // On autofill we get a stringified value.
+ setAlbumsFilter(typeof val === "string" ? [val] : val);
+ };
+
+ const handleOnlyMultiple = (event: React.ChangeEvent) => {
+ setOnlyMultiple(event.target.checked);
+ };
+
+ const handleClose = () => {
+ onClose();
+ };
+
+ const handleFavorite = async () => {
+ const isSelectingDupsBak = isSelectingDups;
+ const isSelectingUniqBak = isSelectingUniq;
+ setSelectingDups(false);
+ setSelectingUniq(false);
+
+ const grouped = new Map>>();
+
+ if(tab === 0 || tab === 1 || tab === 2 || tab === 3) {
+ selDups.forEach(duplicate => {
+ duplicate.found.forEach(({photo}) => {
+ // Collection
+ const collection = grouped.get(photo.collection) || new Map>();
+ if (!grouped.has(photo.collection))
+ grouped.set(photo.collection, collection);
+ // Album
+ const album = collection.get(photo.album) || new Set();
+ if (!collection.has(photo.album))
+ collection.set(photo.album, album);
+ // Photo
+ album.add(photo.id);
+ });
+ });
+ } else if(tab === 4) {
+ selUniq.forEach(entry => {
+ // Collection
+ const collection = grouped.get(entry.collection) || new Map>();
+ if (!grouped.has(entry.collection)) {
+ grouped.set(entry.collection, collection);
+ }
+ // Album
+ const album = collection.get(entry.album) || new Set();
+ if (!collection.has(entry.album)) {
+ collection.set(entry.album, album);
+ }
+ // Photo
+ album.add(entry.id);
+ })
+ }
+
+ const promises: Promise[] = [];
+ grouped.forEach((collectionMap, collection) => {
+ collectionMap.forEach(async (albumSet, album) => {
+ promises.push(favorite.save({ collection, album, photos: Array.from(albumSet) }, [], true));
+ });
+ });
+ await Promise.all(promises);
+
+ setSelectingDups(isSelectingDupsBak);
+ setSelectingUniq(isSelectingUniqBak);
+ };
+
+ const handleMove = () => {
+ const selection =
+ tab === 0 || tab === 1 || tab === 2 || tab === 3 ? selDups.map(item => item.photo) :
+ tab === 4 ? selUniq : [];
+ // Create urls for thumbnails
+ const photos: PhotoImageType[] = selection.map(photo => ({ ...photo, src: urls.thumb(photo) }));
+ // Show move dialog
+ dialog.move(collection, album, photos);
+ onClose();
+ };
+
+ const handleDelete = () => {
+ const selection =
+ tab === 0 || tab === 1 || tab === 2 || tab === 3 ? selDups.map(item => item.photo) :
+ tab === 4 ? selUniq : [];
+ // Create urls for thumbnails
+ const photos: PhotoImageType[] = selection.map(photo => ({ ...photo, src: urls.thumb(photo) }));
+ // Show delete dialog
+ dialog.delete(collection, album, photos);
+ onClose();
+ };
+
+ const handleChangeTab = (_event: React.SyntheticEvent, newValue: number) => {
+ setTab(newValue);
+ // Selection is lost when swapping between tabs
+ setSelectingDups(false);
+ setSelectingUniq(false);
+ setSelDups([]);
+ setSelUniq([]);
+ };
+
+ return (
+
+ );
+}
+
+export default DuplicatesDialog;
diff --git a/src/dialogs/Move.tsx b/src/dialogs/Move.tsx
new file mode 100644
index 0000000..aaf581b
--- /dev/null
+++ b/src/dialogs/Move.tsx
@@ -0,0 +1,232 @@
+import { FC, useEffect, useState } from 'react';
+
+import Autocomplete from '@mui/material/Autocomplete';
+import Button from '@mui/material/Button';
+import CloseIcon from '@mui/icons-material/Close';
+import Dialog from '@mui/material/Dialog';
+import DialogActions from '@mui/material/DialogActions';
+import DialogContent from '@mui/material/DialogContent';
+import DialogContentText from '@mui/material/DialogContentText';
+import DialogTitle from '@mui/material/DialogTitle';
+import FormControl from '@mui/material/FormControl';
+import FormControlLabel from '@mui/material/FormControlLabel';
+import FormHelperText from '@mui/material/FormHelperText';
+import FormLabel from '@mui/material/FormLabel';
+import IconButton from '@mui/material/IconButton';
+import InputLabel from '@mui/material/InputLabel';
+import MenuItem from '@mui/material/MenuItem';
+import Radio from '@mui/material/Radio';
+import RadioGroup from '@mui/material/RadioGroup';
+import Select, { SelectChangeEvent } from '@mui/material/Select';
+import TextField from '@mui/material/TextField';
+
+import PhotoAlbum from 'react-photo-album';
+
+import {
+ QueryAddAlbum,
+ QueryMovePhotos,
+ useAddAlbumMutation,
+ useGetAlbumsQuery,
+ useGetCollectionsQuery,
+ useMovePhotosMutation
+} from '../services/api';
+import useNotification from '../Notification';
+import { PhotoImageType, MoveConflictMode } from '../types';
+
+interface DialogProps {
+ open: boolean;
+ collection: string;
+ album: string;
+ photos: PhotoImageType[];
+ onClose: () => void;
+}
+
+const isValidAlbumName = (function () {
+ const rg1 = /^[^\\/:*?"<>|]+$/; // forbidden characters \ / : * ? " < > |
+ const rg2 = /^\./; // cannot start with dot (.)
+ const rg3 = /^(nul|prn|con|lpt[0-9]|com[0-9])(\.|$)/i; // forbidden file names
+ return (fname: string) => rg1.test(fname) && !rg2.test(fname) && !rg3.test(fname);
+})();
+
+function mostCommon(arr: PhotoImageType[]): string {
+ const dates = arr
+ .filter(v => !v?.date?.startsWith("0001-01-01"))
+ .map(v => v.date.slice(0, v.date.lastIndexOf('T')));
+
+ const dist: {[key: string]: number} = {};
+ let best = "";
+ dates.forEach((v) => {
+ dist[v] = (dist[v] || 0) + 1;
+ if(dist[v] > (dist[best] || 0))
+ best = v;
+ });
+ return best;
+}
+
+/* Dialog for move action */
+const MoveDialog: FC = ({collection, album, photos, open, onClose}) => {
+ const [movePhotos] = useMovePhotosMutation();
+ const [addAlbum] = useAddAlbumMutation();
+ const [targetCollection, setTargetCollection] = useState(collection);
+ const [targetAlbum, setTargetAlbum] = useState("");
+ const [mode, setMode] = useState(MoveConflictMode.Cancel);
+ const [isNewAlbum, setIsNewAlbum] = useState(false);
+ const [errorName, setErrorName] = useState(false);
+ const [processingAction, setProcessingAction] = useState(false);
+
+ const { successNotification, errorNotification } = useNotification();
+ const { data: collections = [], isFetching } = useGetCollectionsQuery();
+ const { data: tmpAlbums = [] } = useGetAlbumsQuery({ collection: targetCollection }, { skip: !open || isFetching || targetCollection === "" });
+ const albums = tmpAlbums.filter(v => !v.pseudo && v.name !== album);
+
+ // Set initial values
+ // collection
+ useEffect(() => {
+ if(!isFetching && targetCollection === "")
+ setTargetCollection(collection)
+ }, [open, collection, targetCollection, isFetching]);
+ // album
+ useEffect(() => setTargetAlbum(mostCommon(photos)), [open, album, photos]);
+
+ // Find out if it is a new album
+ useEffect(() => {
+ // Check if is not moving for the same album or it is a valid name
+ if((targetCollection === collection && targetAlbum === album) || !isValidAlbumName(targetAlbum)) {
+ setErrorName(true);
+ return;
+ }
+ // all good
+ setErrorName(false);
+ setIsNewAlbum(albums.find(a => a.name === targetAlbum) === undefined);
+ }, [collection, targetCollection, album, albums, targetAlbum]);
+
+ const changeCollection = (event: SelectChangeEvent) => {
+ setTargetCollection(event.target.value);
+ };
+
+ const changeAlbum = (_event: React.SyntheticEvent, value: string | null) => {
+ setTargetAlbum(value?.trim() || "");
+ };
+
+ const changeMode = (_event: React.ChangeEvent, value: string) => {
+ setMode(value as MoveConflictMode);
+ };
+
+ const handleClose = () => {
+ onClose();
+ }
+
+ const handleMove = async () => {
+ if(isNewAlbum) {
+ const addAlbumData: QueryAddAlbum = {
+ collection: targetCollection,
+ name: targetAlbum.trim(),
+ type: "regular"
+ }
+
+ // Form validation
+ if(!addAlbumData.name)
+ return;
+
+ setProcessingAction(true);
+ try {
+ await addAlbum(addAlbumData).unwrap();
+ successNotification(`Album created with name ${addAlbumData.name}`);
+ }
+ catch(error) {
+ setProcessingAction(false);
+ errorNotification(`Could not create album named ${addAlbumData.name}!`);
+ console.log(error);
+ return;
+ }
+ }
+
+ const query: QueryMovePhotos = {
+ collection,
+ album,
+ target: {
+ mode,
+ collection: targetCollection,
+ album: targetAlbum.trim(),
+ photos: photos.map(photo => photo.id),
+ }
+ };
+
+ setProcessingAction(true);
+ try {
+ const stats = await movePhotos(query).unwrap();
+ successNotification(`${stats.moved_photos} photos (${stats.moved_files} files)
+ were moved to ${album}, ${stats.skipped} skipped and ${stats.renamed} renamed.`);
+ onClose();
+ }
+ catch(error: any) {
+ errorNotification(`Error while moving photos: ${error.data.message}!`);
+ console.log(error);
+ }
+ setProcessingAction(false);
+ }
+
+ return (
+ );
+}
+
+export default MoveDialog;
diff --git a/src/dialogs/index.tsx b/src/dialogs/index.tsx
index 3296992..a17031a 100644
--- a/src/dialogs/index.tsx
+++ b/src/dialogs/index.tsx
@@ -1,6 +1,10 @@
-import React, { useState } from 'react'
+import React, { useState } from 'react';
+import DeleteAlbumDialog from './DeleteAlbum';
+import DeleteDialog from './Delete';
+import DuplicatesDialog from './Duplicates';
import Lightbox from './Lightbox';
+import MoveDialog from './Move';
import NewAlbumDialog from './NewAlbum';
import PhotoInfoDialog from './PhotoInfo';
@@ -10,18 +14,37 @@ interface DialogContext {
lightbox(photos: PhotoType[], selected: number): void;
newAlbum(): void;
info(photos: PhotoType[], selected: number): void;
+ move(collection: string, album: string, photos: PhotoImageType[]): void;
+ delete(collection: string, album: string, photos: PhotoImageType[]): void;
+ deleteAlbum(collection: string, album: string): void;
+ duplicates(collection: string, album: string): void;
}
const DialogContext = React.createContext({
lightbox: function (): void {},
newAlbum: function (): void {},
info: function (): void {},
+ move: function (): void {},
+ delete: function (): void {},
+ deleteAlbum: function (): void {},
+ duplicates: function (): void {},
});
interface DialogProviderProps {
children?: React.ReactNode;
}
+interface CollectionAlbum {
+ collection: string;
+ album: string;
+}
+
+interface CollectionAlbumPhotos {
+ collection: string;
+ album: string;
+ photos: PhotoImageType[];
+}
+
interface SelectedPhotos {
photos: PhotoImageType[];
selected: number;
@@ -31,6 +54,10 @@ const DialogProvider: React.FC = ({ children }) => {
const [lightbox, setLightbox] = useState(null);
const [newAlbum, setNewAlbum] = useState(false);
const [info, setInfo] = useState(null);
+ const [move, setMove] = useState(null);
+ const [del, setDelete] = useState(null);
+ const [deleteAlbum, setDeleteAlbum] = useState(null);
+ const [duplicates, setDuplicates] = useState(null);
// Lightbox
const openLightbox = (photos: PhotoImageType[], selected: number) => {
@@ -53,12 +80,44 @@ const DialogProvider: React.FC = ({ children }) => {
const closeInfo = () => {
setInfo(null);
}
+ // Move
+ const openMove = (collection: string, album: string, photos: PhotoImageType[]) => {
+ setMove({collection, album, photos});
+ }
+ const closeMove = () => {
+ setMove(null);
+ }
+ // Delete
+ const openDelete = (collection: string, album: string, photos: PhotoImageType[]) => {
+ setDelete({collection, album, photos});
+ }
+ const closeDelete = () => {
+ setDelete(null);
+ }
+ // Delete Album
+ const openDeleteAlbum = (collection: string, album: string) => {
+ setDeleteAlbum({collection, album});
+ }
+ const closeDeleteAlbum = () => {
+ setDeleteAlbum(null);
+ }
+ // Duplicates
+ const openDuplicates = (collection: string, album: string) => {
+ setDuplicates({collection, album});
+ }
+ const closeDuplicates = () => {
+ setDuplicates(null);
+ }
return (
{ children }
@@ -79,6 +138,32 @@ const DialogProvider: React.FC = ({ children }) => {
selected={info?.selected || 0}
onClose={closeInfo} />
+
+
+
+
+
+
+
+
);
}
diff --git a/src/favoriteHook.ts b/src/favoriteHook.ts
index 4de7134..2f1fecf 100644
--- a/src/favoriteHook.ts
+++ b/src/favoriteHook.ts
@@ -3,12 +3,14 @@ import { useParams } from "react-router-dom";
import { selectFavorite } from "./services/app";
import { QuerySaveFavorite, useSavePhotoToPseudoMutation } from './services/api';
+import { useSelection } from "./Selection";
import { PhotoImageType, PhotoType, PseudoAlbumType } from './types';
import useNotification from "./Notification";
const useFavorite = () => {
const favorite = useSelector(selectFavorite);
const { collection, album } = useParams();
+ const { indexes: getSelection } = useSelection();
const [saveFavorite] = useSavePhotoToPseudoMutation();
const { infoNotification, errorNotification } = useNotification();
@@ -32,7 +34,8 @@ const useFavorite = () => {
return;
}
- const indexes = [index];
+ const selection = getSelection();
+ const indexes = selection.includes(index) ? selection : [index];
const isFavorite = !(favoriteStatus(photos[index].favorite).isFavoriteThis);
const saveData = {
diff --git a/src/selection.scss b/src/selection.scss
new file mode 100644
index 0000000..31d8866
--- /dev/null
+++ b/src/selection.scss
@@ -0,0 +1,14 @@
+.selection_ {
+ &_not-draggable, &_not-draggable img {
+ -webkit-user-drag: none;
+ -khtml-user-drag: none;
+ -moz-user-drag: none;
+ -o-user-drag: none;
+ user-drag: none;
+ -webkit-user-select: none;
+ -khtml-user-select: none;
+ -moz-user-select: none;
+ -o-user-select: none;
+ user-select: none;
+ }
+}
diff --git a/src/services/api.ts b/src/services/api.ts
index 182b34f..e9ba65a 100644
--- a/src/services/api.ts
+++ b/src/services/api.ts
@@ -1,7 +1,11 @@
import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
-import { CollectionType, PseudoAlbumType, AlbumType, PhotoType } from "../types";
+import { CollectionType, PseudoAlbumType, AlbumType, PhotoType, MoveConflictMode } from "../types";
import { changeFavorite } from "./app";
+export interface ResponseError {
+ message: string;
+}
+
export interface QueryAlbums {
collection?: string;
}
@@ -23,6 +27,32 @@ export interface QueryPhoto {
photo?: string;
}
+export interface QueryMovePhotos {
+ collection: CollectionType["name"];
+ album: AlbumType["name"];
+ target: {
+ mode: MoveConflictMode;
+ collection: CollectionType["name"];
+ album: AlbumType["name"];
+ photos: PhotoType["title"][];
+ }
+}
+
+export interface ResponseMovePhotos {
+ moved_photos: number;
+ moved_files: number;
+ skipped: number;
+ renamed: number;
+}
+
+export interface QueryDeletePhotos {
+ collection: CollectionType["name"];
+ album: AlbumType["name"];
+ target: {
+ photos: PhotoType["title"][];
+ }
+}
+
export interface QuerySaveFavorite {
collection: CollectionType["name"];
album: AlbumType["name"];
@@ -35,6 +65,37 @@ export interface QuerySaveFavorite {
}
}
+export interface Duplicate {
+ photo: PhotoType;
+ found: {
+ photo: PhotoType;
+ files: {
+ from: number;
+ to: number;
+ }[];
+ // Flags
+ equal: boolean; // All files were matched
+ partial: boolean; // Only some files were matched
+ incomplete: boolean; // Found photos with more files
+ conflict: boolean; // Combination of Partial and Incomplete
+ samealbum: boolean; // Photos are in the same album
+ }[];
+}
+export interface ResponseDuplicates {
+ albums: PseudoAlbumType[];
+ keep: Duplicate[];
+ delete: Duplicate[];
+ unique: PhotoType[];
+ conflict: Duplicate[];
+ samealbum: Duplicate[];
+ countKeep: number;
+ countDelete: number;
+ countUnique: number;
+ countConflict: number;
+ countSameAlbum: number;
+ total: number;
+}
+
const albumId = (arg: { collection: string, album: string }) => arg.collection + ":" + arg.album;
export const api = createApi({
@@ -67,6 +128,37 @@ export const api = createApi({
}),
invalidatesTags: [ 'Pseudo', 'Albums'],
}),
+ deleteAlbum: builder.mutation({
+ query: ({ collection, album }) => ({
+ url: `/collections/${collection}/albums/${album}`,
+ method: 'DELETE',
+ }),
+ invalidatesTags: (_result, _error, arg) => ['Pseudo', 'Albums', { type: 'Album', id: albumId(arg) }],
+ }),
+ duplicatedPhotos: builder.query({
+ query: ({ collection, album }) => `/collections/${collection}/albums/${album}/duplicates`
+ }),
+ movePhotos: builder.mutation({
+ query: ({ collection, album, target }) => ({
+ url: `/collections/${collection}/albums/${album}/photos/move`,
+ method: 'PUT',
+ body: target,
+ }),
+ invalidatesTags: (_result, _error, arg) => [
+ { type: 'Album', id: albumId(arg) },
+ { type: 'Album', id: albumId(arg.target) }
+ ],
+ }),
+ deletePhotos: builder.mutation({
+ query: ({ collection, album, target }) => ({
+ url: `/collections/${collection}/albums/${album}/photos`,
+ method: 'DELETE',
+ body: target,
+ }),
+ invalidatesTags: (_result, _error, arg) => [
+ { type: 'Album', id: albumId(arg) },
+ ],
+ }),
getPhotoInfo: builder.query({
query: ({collection, album, id }) => `/collections/${collection}/albums/${album}/photos/${id}/info`,
}),
@@ -109,6 +201,12 @@ export const {
useGetAlbumsQuery,
useGetAlbumQuery,
useAddAlbumMutation,
+ useDeleteAlbumMutation,
+ useDuplicatedPhotosQuery,
+ useMovePhotosMutation,
+ useDeletePhotosMutation,
useGetPhotoInfoQuery,
useSavePhotoToPseudoMutation,
} = api;
+
+export default api;
diff --git a/src/types.ts b/src/types.ts
index 500dabc..dca5fd8 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -57,6 +57,12 @@ export interface FileType {
export type PhotoImageType = PhotoType & Image;
+export enum MoveConflictMode {
+ Cancel = "cancel",
+ Skip = "skip",
+ Rename = "rename",
+}
+
export const urls = {
thumb: (photo: PhotoType) => `/api/collections/${photo.collection}/albums/${photo.album}/photos/${photo.id}/thumb`,
file: (photo: PhotoType, file: FileType) => `/api/collections/${photo.collection}/albums/${photo.album}/photos/${photo.id}/files/${file.id}`,