Changed the REST APIs to talk to TaskManager as needed [#432]

comixed-adaptors/src/main/java/org/comixedproject/adaptors/archive/AbstractArchiveAdaptor.java

@@ -34,7 +34,6 @@
 import org.comixedproject.loaders.EntryLoader;
 import org.comixedproject.loaders.EntryLoaderException;
 import org.comixedproject.model.comic.Comic;
-import org.comixedproject.model.comic.ComicFileEntry;
 import org.comixedproject.utils.ComicFileUtils;
 import org.comixedproject.utils.FileTypeIdentifier;
 import org.springframework.beans.factory.InitializingBean;
@@ -226,20 +225,11 @@ protected void processContent(Comic comic, String filename, byte[] content) {
   }
 
   private void recordFileEntry(Comic comic, String filename, byte[] content) {
-    log.debug("Recording file entry");
-    ComicFileEntry fileEntry = new ComicFileEntry();
-
-    fileEntry.setComic(comic);
-    fileEntry.setFileName(filename);
-    fileEntry.setFileSize(content.length);
-    fileEntry.setFileType(this.fileTypeIdentifier.basetypeFor(new ByteArrayInputStream(content)));
-    comic.addFileEntry(fileEntry);
-    log.debug(
-        "Added file entry: filename={} size={} index={} type={} ",
-        fileEntry.getFileName(),
-        fileEntry.getFileSize(),
-        fileEntry.getFileNumber(),
-        fileEntry.getFileType());
+    log.debug("Adding file entry");
+    comic.addFileEntry(
+        filename,
+        content.length,
+        this.fileTypeIdentifier.basetypeFor(new ByteArrayInputStream(content)));
   }
 
   @Override

comixed-model/src/main/java/org/comixedproject/model/comic/Comic.java

@@ -359,29 +359,36 @@ public class Comic {
   /**
    * Adds a file entry, or replaces one if it already exists.
    *
-   * @param fileEntry the file entry
+   * @param name the entry filename
+   * @param size the entry size
+   * @param type the entry MIME type
    */
-  public void addFileEntry(ComicFileEntry fileEntry) {
+  public void addFileEntry(final String name, final int size, final String type) {
     int index = this.fileEntries.size();
     boolean replacement = false;
     for (int idx = 0; idx < this.fileEntries.size(); idx++) {
-      if (this.fileEntries.get(idx).getFileName().equals(fileEntry.getFileName())) {
+      if (this.fileEntries.get(idx).getFileName().equals(name)) {
         index = idx;
         replacement = true;
         break;
       }
     }
 
     if (replacement) {
-      log.debug("Removing existing file entry: [{}] {}", index, fileEntry.getFileName());
-      final ComicFileEntry deadEntry = fileEntries.get(index);
-      deadEntry.setComic(null);
-      fileEntries.remove(deadEntry);
+      log.debug("Updating existing file entry: [{}] {}", index, name);
+      final ComicFileEntry existing = fileEntries.get(index);
+      existing.setFileSize(size);
+      existing.setFileType(type);
+    } else {
+      log.debug("Adding new file entry: [{}] {}", index, name);
+      final ComicFileEntry fileEntry = new ComicFileEntry();
+      fileEntry.setFileName(name);
+      fileEntry.setFileSize(size);
+      fileEntry.setFileType(type);
+      fileEntry.setFileNumber(index);
+      this.fileEntries.add(fileEntry);
+      fileEntry.setComic(this);
     }
-    log.debug("Adding file entry: [{}] {}", index, fileEntry.getFileName());
-    fileEntry.setFileNumber(index);
-    this.fileEntries.add(index, fileEntry);
-    fileEntry.setComic(this);
   }
 
   /**

comixed-repositories/src/main/java/org/comixedproject/repositories/comic/ComicRepository.java

@@ -109,4 +109,7 @@ List<Comic> findIssuesAfterComic(
 
   @Query("SELECT c FROM Comic c")
   List<Comic> findComicsToMove(PageRequest page);
+
+  @Query("SELECT c FROM Comic c WHERE c.id > :threshold ORDER BY c.id")
+  List<Comic> getComicsById(@Param("threshold") Long threshold, Pageable page);
 }

comixed-rest-api/src/main/java/org/comixedproject/controller/comic/ComicController.java

@@ -41,10 +41,8 @@
 import org.comixedproject.net.GetLibraryUpdatesResponse;
 import org.comixedproject.net.UndeleteMultipleComicsRequest;
 import org.comixedproject.net.UndeleteMultipleComicsResponse;
-import org.comixedproject.repositories.ComiXedUserRepository;
 import org.comixedproject.repositories.comic.ComicFormatRepository;
 import org.comixedproject.repositories.comic.ScanTypeRepository;
-import org.comixedproject.repositories.library.LastReadDatesRepository;
 import org.comixedproject.service.comic.ComicException;
 import org.comixedproject.service.comic.ComicService;
 import org.comixedproject.service.comic.PageCacheService;
@@ -73,14 +71,13 @@ public class ComicController {
   @Autowired private PageCacheService pageCacheService;
   @Autowired private FileService fileService;
   @Autowired private FileTypeIdentifier fileTypeIdentifier;
-  @Autowired private ComiXedUserRepository userRepository;
-  @Autowired private LastReadDatesRepository lastReadRepository;
   @Autowired private ScanTypeRepository scanTypeRepository;
   @Autowired private ComicFormatRepository comicFormatRepository;
   @Autowired private ComicDataAdaptor comicDataAdaptor;
   @Autowired private TaskManager taskManager;
   @Autowired private ObjectFactory<DeleteComicsWorkerTask> deleteComicsWorkerTaskFactory;
   @Autowired private ObjectFactory<UndeleteComicsWorkerTask> undeleteComicsWorkerTaskObjectFactory;
+  @Autowired private ObjectFactory<RescanComicsWorkerTask> rescanComicsWorkerTaskObjectFactory;
   @Autowired private ComicFileHandler comicFileHandler;
 
   @DeleteMapping(value = "/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
@@ -252,17 +249,18 @@ public Iterable<ScanType> getScanTypes() {
     return this.scanTypeRepository.findAll();
   }
 
+  /**
+   * Starts the process of rescanning all comics in the library.
+   *
+   * @return the number of rescan tasks
+   */
   @PostMapping(value = "/rescan")
   public int rescanComics() {
     log.info("Beginning rescan of library");
 
-    final int result = this.comicService.rescanComics();
-
-    ComicController.stopWaitingForStatus();
-
-    log.debug("Returning: {}", result);
-
-    return result;
+    final RescanComicsWorkerTask task = this.rescanComicsWorkerTaskObjectFactory.getObject();
+    this.taskManager.runTask(task);
+    return this.comicService.getRescanCount();
   }
 
   @PutMapping(value = "/{id}/format")

comixed-rest-api/src/main/java/org/comixedproject/controller/file/FileController.java

@@ -29,12 +29,15 @@
 import org.comixedproject.handlers.ComicFileHandlerException;
 import org.comixedproject.model.file.FileDetails;
 import org.comixedproject.net.GetAllComicsUnderRequest;
+import org.comixedproject.net.ImportComicFilesRequest;
 import org.comixedproject.net.ImportComicFilesResponse;
-import org.comixedproject.net.ImportRequestBody;
-import org.comixedproject.repositories.comic.ComicRepository;
+import org.comixedproject.service.comic.ComicService;
 import org.comixedproject.service.file.FileService;
+import org.comixedproject.task.model.QueueComicsWorkerTask;
+import org.comixedproject.task.runner.TaskManager;
 import org.comixedproject.utils.ComicFileUtils;
 import org.json.JSONException;
+import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.MediaType;
 import org.springframework.security.access.annotation.Secured;
@@ -50,8 +53,10 @@
 @RequestMapping("/api/files")
 @Log4j2
 public class FileController {
-  @Autowired private ComicRepository comicRepository;
+  @Autowired private ComicService comicService;
   @Autowired private FileService fileService;
+  @Autowired private TaskManager taskManager;
+  @Autowired private ObjectFactory<QueueComicsWorkerTask> queueComicsWorkerTaskObjectFactory;
 
   private int requestId = 0;
 
@@ -85,7 +90,7 @@ private void getAllFilesUnder(File root, List<FileDetails> result) throws IOExce
       } else {
 
         if (ComicFileUtils.isComicFile(file)
-            && (this.comicRepository.findByFilename(file.getCanonicalPath()) == null)) {
+            && (this.comicService.findByFilename(file.getCanonicalPath()) == null)) {
           log.debug("Adding file: " + file.getCanonicalPath());
           result.add(new FileDetails(file.getCanonicalPath(), file.length()));
         }
@@ -136,24 +141,29 @@ public int getImportStatus() throws InterruptedException {
       produces = MediaType.APPLICATION_JSON_VALUE,
       consumes = MediaType.APPLICATION_JSON_VALUE)
   @Secured("ROLE_ADMIN")
-  public ImportComicFilesResponse importComicFiles(@RequestBody() ImportRequestBody request)
+  public ImportComicFilesResponse importComicFiles(@RequestBody() ImportComicFilesRequest request)
       throws UnsupportedEncodingException {
+    final List<String> filenames = request.getFilenames();
+    final boolean deleteBlockedPages = request.isDeleteBlockedPages();
+    final boolean ignoreMetadata = request.isIgnoreMetadata();
+
     log.info(
         "Importing {} comic files: delete blocked pages={} ignore metadata={}",
-        request.getFilenames().length,
-        request.isDeleteBlockedPages(),
-        request.isIgnoreMetadata());
+        filenames.size(),
+        deleteBlockedPages,
+        ignoreMetadata);
+
+    final QueueComicsWorkerTask task = this.queueComicsWorkerTaskObjectFactory.getObject();
+    task.setFilenames(filenames);
+    task.setDeleteBlockedPages(deleteBlockedPages);
+    task.setIgnoreMetadata(ignoreMetadata);
 
-    this.fileService.importComicFiles(
-        request.getFilenames(), request.isDeleteBlockedPages(), request.isIgnoreMetadata());
+    log.debug("Enqueueing task");
+    this.taskManager.runTask(task);
 
     log.debug("Notifying waiting processes");
     ComicController.stopWaitingForStatus();
 
-    final ImportComicFilesResponse response = new ImportComicFilesResponse();
-
-    response.setImportComicCount(request.getFilenames().length);
-
-    return response;
+    return new ImportComicFilesResponse(filenames.size());
   }
 }

comixed-rest-api/src/main/java/org/comixedproject/controller/library/LibraryController.java

@@ -34,7 +34,11 @@
 import org.comixedproject.service.library.ReadingListService;
 import org.comixedproject.service.user.ComiXedUserException;
 import org.comixedproject.service.user.UserService;
+import org.comixedproject.task.model.ConvertComicsWorkerTask;
+import org.comixedproject.task.model.MoveComicsWorkerTask;
+import org.comixedproject.task.runner.TaskManager;
 import org.comixedproject.views.View;
+import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.*;
@@ -47,6 +51,9 @@ public class LibraryController {
   @Autowired private ComicService comicService;
   @Autowired private UserService userService;
   @Autowired private ReadingListService readingListService;
+  @Autowired private TaskManager taskManager;
+  @Autowired private ObjectFactory<ConvertComicsWorkerTask> convertComicsWorkerTaskObjectFactory;
+  @Autowired private ObjectFactory<MoveComicsWorkerTask> moveComicsWorkerTaskObjectFactory;
 
   @PostMapping(
       value = "/library/updates",
@@ -142,7 +149,13 @@ public void convertComics(@RequestBody() ConvertComicsRequest request) {
         renamePages ? " (rename pages)" : "",
         deletePages ? " (delete pages)" : "");
 
-    this.libraryService.convertComics(idList, archiveType, renamePages, deletePages);
+    final ConvertComicsWorkerTask task = this.convertComicsWorkerTaskObjectFactory.getObject();
+    task.setIdList(idList);
+    task.setTargetArchiveType(archiveType);
+    task.setRenamePages(renamePages);
+    task.setDeletePages(deletePages);
+
+    this.taskManager.runTask(task);
   }
 
   @PostMapping(
@@ -180,7 +193,12 @@ public MoveComicsResponse moveComics(@RequestBody() MoveComicsRequest request) {
 
     log.info("Moving comics: targetDirectory={}", targetDirectory);
     log.info("             : renamingRule={}", renamingRule);
-    this.libraryService.moveComics(deletePhysicalFiles, targetDirectory, renamingRule);
+
+    final MoveComicsWorkerTask task = this.moveComicsWorkerTaskObjectFactory.getObject();
+    task.setDirectory(targetDirectory);
+    task.setRenamingRule(renamingRule);
+
+    this.taskManager.runTask(task);
 
     return new MoveComicsResponse(true);
   }

comixed-rest-api/src/main/java/org/comixedproject/net/ImportRequestBody.java → comixed-rest-api/src/main/java/org/comixedproject/net/ImportComicFilesRequest.java

@@ -19,33 +19,39 @@
 package org.comixedproject.net;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
-
-public class ImportRequestBody {
+import java.util.ArrayList;
+import java.util.List;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * <code>ImportComicFilesRequest</code> represents the payload for a request to import comics into
+ * the library.
+ *
+ * @author Darryl L. Pierce
+ */
+public class ImportComicFilesRequest {
   @JsonProperty("filenames")
-  private String[] filenames;
+  @Getter
+  @Setter
+  private List<String> filenames = new ArrayList<>();
 
   @JsonProperty("ignoreMetadata")
+  @Getter
+  @Setter
   private boolean ignoreMetadata;
 
   @JsonProperty("deleteBlockedPages")
+  @Getter
+  @Setter
   private boolean deleteBlockedPages;
 
-  public ImportRequestBody(
-      final String[] filenames, final boolean deleteBlockedPages, final boolean ignoreMetadata) {
+  public ImportComicFilesRequest(
+      final List<String> filenames,
+      final boolean deleteBlockedPages,
+      final boolean ignoreMetadata) {
     this.filenames = filenames;
     this.deleteBlockedPages = deleteBlockedPages;
     this.ignoreMetadata = ignoreMetadata;
   }
-
-  public String[] getFilenames() {
-    return filenames;
-  }
-
-  public boolean isIgnoreMetadata() {
-    return ignoreMetadata;
-  }
-
-  public boolean isDeleteBlockedPages() {
-    return deleteBlockedPages;
-  }
 }

comixed-rest-api/src/main/java/org/comixedproject/net/ImportComicFilesResponse.java

@@ -19,16 +19,18 @@
 package org.comixedproject.net;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
 
+/**
+ * <code>ImportComicFilesResponse</code> represents the response body for q previous {@link
+ * ImportComicFilesRequest}.
+ *
+ * @author Darryl L. Pierce
+ */
+@AllArgsConstructor
 public class ImportComicFilesResponse {
   @JsonProperty("import_comic_count")
-  private int importComicCount;
-
-  public int getImportComicCount() {
-    return importComicCount;
-  }
-
-  public void setImportComicCount(final int importComicCount) {
-    this.importComicCount = importComicCount;
-  }
+  @Getter
+  private final int importComicCount;
 }

comixed-rest-api/src/test/java/org/comixedproject/controller/comic/ComicControllerTest.java

@@ -46,7 +46,9 @@
 import org.comixedproject.service.comic.PageCacheService;
 import org.comixedproject.service.file.FileService;
 import org.comixedproject.task.model.DeleteComicsWorkerTask;
+import org.comixedproject.task.model.RescanComicsWorkerTask;
 import org.comixedproject.task.model.UndeleteComicsWorkerTask;
+import org.comixedproject.task.model.WorkerTask;
 import org.comixedproject.task.runner.TaskManager;
 import org.comixedproject.utils.FileTypeIdentifier;
 import org.junit.Test;
@@ -99,6 +101,8 @@ public class ComicControllerTest {
   @Mock private LastReadDate lastReadDate;
   @Mock private ComicFileHandler comicFileHandler;
   @Mock private ArchiveAdaptor archiveAdaptor;
+  @Mock private ObjectFactory<RescanComicsWorkerTask> rescanComicsWorkerTaskObjectFactory;
+  @Mock private RescanComicsWorkerTask rescanComicsWorkerTask;
 
   private final List<Comic> emptyComicList = new ArrayList<>();
 
@@ -453,13 +457,16 @@ public void testUpdateComic() {
 
   @Test
   public void testRescanComics() {
-    Mockito.when(comicService.rescanComics()).thenReturn(TEST_RESCAN_COUNT);
+    Mockito.when(rescanComicsWorkerTaskObjectFactory.getObject())
+        .thenReturn(rescanComicsWorkerTask);
+    Mockito.doNothing().when(taskManager).runTask(Mockito.any(WorkerTask.class));
+    Mockito.when(comicService.getRescanCount()).thenReturn(TEST_RESCAN_COUNT);
 
     final int result = controller.rescanComics();
 
     assertEquals(TEST_RESCAN_COUNT, result);
 
-    Mockito.verify(comicService, Mockito.times(1)).rescanComics();
+    Mockito.verify(taskManager, Mockito.times(1)).runTask(rescanComicsWorkerTask);
   }
 
   @Test(expected = ComicException.class)