Maryhipp/delete images on board

invokeai/app/api/routers/boards.py

@@ -5,6 +5,7 @@
 from invokeai.app.services.image_record_storage import OffsetPaginatedResults
 from invokeai.app.services.models.board_record import BoardDTO
 
+
 from ..dependencies import ApiDependencies
 
 boards_router = APIRouter(prefix="/v1/boards", tags=["boards"])
@@ -71,11 +72,19 @@ async def update_board(
 @boards_router.delete("/{board_id}", operation_id="delete_board")
 async def delete_board(
     board_id: str = Path(description="The id of board to delete"),
+    include_images: Optional[bool] = Query(
+        description="Permanently delete all images on the board", default=False
+    ),
 ) -> None:
     """Deletes a board"""
-
     try:
-        ApiDependencies.invoker.services.boards.delete(board_id=board_id)
+        if include_images is True:
+            ApiDependencies.invoker.services.images.delete_images_on_board(
+                board_id=board_id
+            )
+            ApiDependencies.invoker.services.boards.delete(board_id=board_id)
+        else:
+            ApiDependencies.invoker.services.boards.delete(board_id=board_id)
     except Exception as e:
         # TODO: Does this need any exception handling at all?
         pass

invokeai/app/services/image_file_storage.py

@@ -85,16 +85,18 @@ def __init__(self, output_folder: str | Path):
         self.__cache_ids = Queue()
         self.__max_cache_size = 10  # TODO: get this from config
 
-        self.__output_folder: Path = output_folder if isinstance(output_folder, Path) else Path(output_folder)
-        self.__thumbnails_folder = self.__output_folder / 'thumbnails'
+        self.__output_folder: Path = (
+            output_folder if isinstance(output_folder, Path) else Path(output_folder)
+        )
+        self.__thumbnails_folder = self.__output_folder / "thumbnails"
 
         # Validate required output folders at launch
         self.__validate_storage_folders()
 
     def get(self, image_name: str) -> PILImageType:
         try:
             image_path = self.get_path(image_name)
-            
+
             cache_item = self.__get_cache(image_path)
             if cache_item:
                 return cache_item
@@ -155,7 +157,7 @@ def delete(self, image_name: str) -> None:
     # TODO: make this a bit more flexible for e.g. cloud storage
     def get_path(self, image_name: str, thumbnail: bool = False) -> Path:
         path = self.__output_folder / image_name
-        
+
         if thumbnail:
             thumbnail_name = get_thumbnail_name(image_name)
             path = self.__thumbnails_folder / thumbnail_name
@@ -166,7 +168,7 @@ def validate_path(self, path: str | Path) -> bool:
         """Validates the path given for an image or thumbnail."""
         path = path if isinstance(path, Path) else Path(path)
         return path.exists()
-    
+
     def __validate_storage_folders(self) -> None:
         """Checks if the required output folders exist and create them if they don't"""
         folders: list[Path] = [self.__output_folder, self.__thumbnails_folder]
@@ -179,7 +181,9 @@ def __get_cache(self, image_name: Path) -> PILImageType | None:
     def __set_cache(self, image_name: Path, image: PILImageType):
         if not image_name in self.__cache:
             self.__cache[image_name] = image
-            self.__cache_ids.put(image_name)  # TODO: this should refresh position for LRU cache
+            self.__cache_ids.put(
+                image_name
+            )  # TODO: this should refresh position for LRU cache
             if len(self.__cache) > self.__max_cache_size:
                 cache_id = self.__cache_ids.get()
                 if cache_id in self.__cache:

invokeai/app/services/image_record_storage.py

@@ -94,6 +94,11 @@ def delete(self, image_name: str) -> None:
         """Deletes an image record."""
         pass
 
+    @abstractmethod
+    def delete_many(self, image_names: list[str]) -> None:
+        """Deletes many image records."""
+        pass
+
     @abstractmethod
     def save(
         self,
@@ -385,6 +390,25 @@ def delete(self, image_name: str) -> None:
         finally:
             self._lock.release()
 
+    def delete_many(self, image_names: list[str]) -> None:
+        try:
+            placeholders = ",".join("?" for _ in image_names)
+
+            self._lock.acquire()
+
+            # Construct the SQLite query with the placeholders
+            query = f"DELETE FROM images WHERE image_name IN ({placeholders})"
+
+            # Execute the query with the list of IDs as parameters
+            self._cursor.execute(query, image_names)
+
+            self._conn.commit()
+        except sqlite3.Error as e:
+            self._conn.rollback()
+            raise ImageRecordDeleteException from e
+        finally:
+            self._lock.release()
+
     def save(
         self,
         image_name: str,

invokeai/app/services/images.py

@@ -112,6 +112,11 @@ def delete(self, image_name: str):
         """Deletes an image."""
         pass
 
+    @abstractmethod
+    def delete_images_on_board(self, board_id: str):
+        """Deletes all images on a board."""
+        pass
+
 
 class ImageServiceDependencies:
     """Service dependencies for the ImageService."""
@@ -341,6 +346,28 @@ def delete(self, image_name: str):
             self._services.logger.error("Problem deleting image record and file")
             raise e
 
+    def delete_images_on_board(self, board_id: str):
+        try:
+            images = self._services.board_image_records.get_images_for_board(board_id)
+            image_name_list = list(
+                map(
+                    lambda r: r.image_name,
+                    images.items,
+                )
+            )
+            for image_name in image_name_list:
+                self._services.image_files.delete(image_name)
+            self._services.image_records.delete_many(image_name_list)
+        except ImageRecordDeleteException:
+            self._services.logger.error(f"Failed to delete image records")
+            raise
+        except ImageFileDeleteException:
+            self._services.logger.error(f"Failed to delete image files")
+            raise
+        except Exception as e:
+            self._services.logger.error("Problem deleting image records and files")
+            raise e
+
     def _get_metadata(
         self, session_id: Optional[str] = None, node_id: Optional[str] = None
     ) -> Union[ImageMetadata, None]:

invokeai/frontend/web/src/app/components/App.tsx

@@ -25,6 +25,7 @@ import DeleteImageModal from 'features/gallery/components/DeleteImageModal';
 import { requestCanvasRescale } from 'features/canvas/store/thunks/requestCanvasScale';
 import UpdateImageBoardModal from '../../features/gallery/components/Boards/UpdateImageBoardModal';
 import { useListModelsQuery } from 'services/api/endpoints/models';
+import DeleteBoardImagesModal from '../../features/gallery/components/Boards/DeleteBoardImagesModal';
 
 const DEFAULT_CONFIG = {};
 
@@ -158,6 +159,7 @@ const App = ({
       </Grid>
       <DeleteImageModal />
       <UpdateImageBoardModal />
+      <DeleteBoardImagesModal />
       <Toaster />
       <GlobalHotkeys />
     </>

invokeai/frontend/web/src/app/components/InvokeAIUI.tsx

@@ -24,6 +24,7 @@ import {
 import UpdateImageBoardModal from '../../features/gallery/components/Boards/UpdateImageBoardModal';
 import { AddImageToBoardContextProvider } from '../contexts/AddImageToBoardContext';
 import { $authToken, $baseUrl } from 'services/api/client';
+import { DeleteBoardImagesContextProvider } from '../contexts/DeleteBoardImagesContext';
 
 const App = lazy(() => import('./App'));
 const ThemeLocaleProvider = lazy(() => import('./ThemeLocaleProvider'));
@@ -86,11 +87,13 @@ const InvokeAIUI = ({
             <ImageDndContext>
               <DeleteImageContextProvider>
                 <AddImageToBoardContextProvider>
-                  <App
-                    config={config}
-                    headerComponent={headerComponent}
-                    setIsReady={setIsReady}
-                  />
+                  <DeleteBoardImagesContextProvider>
+                    <App
+                      config={config}
+                      headerComponent={headerComponent}
+                      setIsReady={setIsReady}
+                    />
+                  </DeleteBoardImagesContextProvider>
                 </AddImageToBoardContextProvider>
               </DeleteImageContextProvider>
             </ImageDndContext>

invokeai/frontend/web/src/app/contexts/DeleteBoardImagesContext.tsx

@@ -0,0 +1,170 @@
+import { useDisclosure } from '@chakra-ui/react';
+import { PropsWithChildren, createContext, useCallback, useState } from 'react';
+import { BoardDTO } from 'services/api/types';
+import { useDeleteBoardMutation } from '../../services/api/endpoints/boards';
+import { defaultSelectorOptions } from '../store/util/defaultMemoizeOptions';
+import { createSelector } from '@reduxjs/toolkit';
+import { some } from 'lodash-es';
+import { canvasSelector } from '../../features/canvas/store/canvasSelectors';
+import { controlNetSelector } from '../../features/controlNet/store/controlNetSlice';
+import { selectImagesById } from '../../features/gallery/store/imagesSlice';
+import { nodesSelector } from '../../features/nodes/store/nodesSlice';
+import { generationSelector } from '../../features/parameters/store/generationSelectors';
+import { RootState } from '../store/store';
+import { useAppDispatch, useAppSelector } from '../store/storeHooks';
+import { ImageUsage } from './DeleteImageContext';
+import { requestedBoardImagesDeletion } from '../../features/gallery/store/actions';
+
+export const selectBoardImagesUsage = createSelector(
+  [
+    (state: RootState) => state,
+    generationSelector,
+    canvasSelector,
+    nodesSelector,
+    controlNetSelector,
+    (state: RootState, board_id?: string) => board_id,
+  ],
+  (state, generation, canvas, nodes, controlNet, board_id) => {
+    const initialImage = generation.initialImage
+      ? selectImagesById(state, generation.initialImage.imageName)
+      : undefined;
+    const isInitialImage = initialImage?.board_id === board_id;
+
+    const isCanvasImage = canvas.layerState.objects.some((obj) => {
+      if (obj.kind === 'image') {
+        const image = selectImagesById(state, obj.imageName);
+        return image?.board_id === board_id;
+      }
+      return false;
+    });
+
+    const isNodesImage = nodes.nodes.some((node) => {
+      return some(node.data.inputs, (input) => {
+        if (input.type === 'image' && input.value) {
+          const image = selectImagesById(state, input.value.image_name);
+          return image?.board_id === board_id;
+        }
+        return false;
+      });
+    });
+
+    const isControlNetImage = some(controlNet.controlNets, (c) => {
+      const controlImage = c.controlImage
+        ? selectImagesById(state, c.controlImage)
+        : undefined;
+      const processedControlImage = c.processedControlImage
+        ? selectImagesById(state, c.processedControlImage)
+        : undefined;
+      return (
+        controlImage?.board_id === board_id ||
+        processedControlImage?.board_id === board_id
+      );
+    });
+
+    const imageUsage: ImageUsage = {
+      isInitialImage,
+      isCanvasImage,
+      isNodesImage,
+      isControlNetImage,
+    };
+
+    return imageUsage;
+  },
+  defaultSelectorOptions
+);
+
+type DeleteBoardImagesContextValue = {
+  /**
+   * Whether the move image dialog is open.
+   */
+  isOpen: boolean;
+  /**
+   * Closes the move image dialog.
+   */
+  onClose: () => void;
+  imagesUsage?: ImageUsage;
+  board?: BoardDTO;
+  onClickDeleteBoardImages: (board: BoardDTO) => void;
+  handleDeleteBoardImages: (boardId: string) => void;
+  handleDeleteBoardOnly: (boardId: string) => void;
+};
+
+export const DeleteBoardImagesContext =
+  createContext<DeleteBoardImagesContextValue>({
+    isOpen: false,
+    onClose: () => undefined,
+    onClickDeleteBoardImages: () => undefined,
+    handleDeleteBoardImages: () => undefined,
+    handleDeleteBoardOnly: () => undefined,
+  });
+
+type Props = PropsWithChildren;
+
+export const DeleteBoardImagesContextProvider = (props: Props) => {
+  const [boardToDelete, setBoardToDelete] = useState<BoardDTO>();
+  const { isOpen, onOpen, onClose } = useDisclosure();
+  const dispatch = useAppDispatch();
+
+  // Check where the board images to be deleted are used (eg init image, controlnet, etc.)
+  const imagesUsage = useAppSelector((state) =>
+    selectBoardImagesUsage(state, boardToDelete?.board_id)
+  );
+
+  const [deleteBoard] = useDeleteBoardMutation();
+
+  // Clean up after deleting or dismissing the modal
+  const closeAndClearBoardToDelete = useCallback(() => {
+    setBoardToDelete(undefined);
+    onClose();
+  }, [onClose]);
+
+  const onClickDeleteBoardImages = useCallback(
+    (board?: BoardDTO) => {
+      console.log({ board });
+      if (!board) {
+        return;
+      }
+      setBoardToDelete(board);
+      onOpen();
+    },
+    [setBoardToDelete, onOpen]
+  );
+
+  const handleDeleteBoardImages = useCallback(
+    (boardId: string) => {
+      if (boardToDelete) {
+        dispatch(
+          requestedBoardImagesDeletion({ board: boardToDelete, imagesUsage })
+        );
+        closeAndClearBoardToDelete();
+      }
+    },
+    [dispatch, closeAndClearBoardToDelete, boardToDelete, imagesUsage]
+  );
+
+  const handleDeleteBoardOnly = useCallback(
+    (boardId: string) => {
+      if (boardToDelete) {
+        deleteBoard(boardId);
+        closeAndClearBoardToDelete();
+      }
+    },
+    [deleteBoard, closeAndClearBoardToDelete, boardToDelete]
+  );
+
+  return (
+    <DeleteBoardImagesContext.Provider
+      value={{
+        isOpen,
+        board: boardToDelete,
+        onClose: closeAndClearBoardToDelete,
+        onClickDeleteBoardImages,
+        handleDeleteBoardImages,
+        handleDeleteBoardOnly,
+        imagesUsage,
+      }}
+    >
+      {props.children}
+    </DeleteBoardImagesContext.Provider>
+  );
+};

invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/index.ts

@@ -83,6 +83,7 @@ import {
   addImageRemovedFromBoardRejectedListener,
 } from './listeners/imageRemovedFromBoard';
 import { addReceivedOpenAPISchemaListener } from './listeners/receivedOpenAPISchema';
+import { addRequestedBoardImageDeletionListener } from './listeners/boardImagesDeleted';
 
 export const listenerMiddleware = createListenerMiddleware();
 
@@ -124,6 +125,7 @@ addRequestedImageDeletionListener();
 addImageDeletedPendingListener();
 addImageDeletedFulfilledListener();
 addImageDeletedRejectedListener();
+addRequestedBoardImageDeletionListener();
 
 // Image metadata
 addImageMetadataReceivedFulfilledListener();