Added sending a message when a comic is added or processed [#659]

comixed-model/src/main/java/org/comixedproject/action/PerObjectAction.java

@@ -0,0 +1,36 @@
+/*
+ * ComiXed - A digital comic book library management application.
+ * Copyright (C) 2021, The ComiXed Project.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses>
+ */
+
+package org.comixedproject.action;
+
+/**
+ * <code>PerObjectAction</code> defines a type that performs an action on instance of an object
+ * type.
+ *
+ * @param <T> the object type
+ * @author Darryl L. Pierce
+ */
+@FunctionalInterface
+public interface PerObjectAction<T> {
+  /**
+   * The action to be executed.
+   *
+   * @param object the target object
+   */
+  void execute(T object);
+}

comixed-tasks/src/main/java/org/comixedproject/task/model/AbstractWorkerTask.java

@@ -18,17 +18,12 @@
 
 package org.comixedproject.task.model;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
 /**
  * <code>AbstractWorkerTask</code> provides a foundation for creating new {@link WorkerTask} types.
  *
  * @author Darryl L. Pierce
  */
 public abstract class AbstractWorkerTask implements WorkerTask {
-  protected static final Logger logger = LogManager.getLogger(AbstractWorkerTask.class);
-
   private String description;
 
   public AbstractWorkerTask() {}

comixed-tasks/src/main/java/org/comixedproject/task/model/AddComicWorkerTask.java

@@ -18,13 +18,15 @@
 
 package org.comixedproject.task.model;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import java.io.File;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.extern.log4j.Log4j2;
 import org.comixedproject.adaptors.FilenameScraperAdaptor;
 import org.comixedproject.handlers.ComicFileHandler;
 import org.comixedproject.model.comic.Comic;
+import org.comixedproject.model.messaging.Constants;
 import org.comixedproject.model.tasks.Task;
 import org.comixedproject.service.comic.ComicService;
 import org.comixedproject.service.task.TaskService;
@@ -34,6 +36,7 @@
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Scope;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -51,11 +54,10 @@ public class AddComicWorkerTask extends AbstractWorkerTask {
   @Autowired private ComicFileHandler comicFileHandler;
   @Autowired private ComicService comicService;
   @Autowired private FilenameScraperAdaptor filenameScraper;
-
-  @Autowired
-  private ObjectFactory<ProcessComicWorkerTaskEncoder> processComicTaskEncoderObjectFactory;
-
+  @Autowired private ObjectFactory<ProcessComicWorkerTaskEncoder> processTaskEncoderObjectFactory;
   @Autowired private TaskService taskService;
+  @Autowired private SimpMessagingTemplate messagingTemplate;
+  @Autowired private ObjectMapper objectMapper;
 
   @Getter @Setter private String filename;
   @Getter @Setter private boolean deleteBlockedPages = false;
@@ -86,9 +88,12 @@ public void startTask() throws WorkerTaskException {
       log.debug("Saving comic");
       result = this.comicService.save(result);
 
+      log.trace("Publishing updated comic");
+      this.messagingTemplate.convertAndSend(Constants.COMIC_LIST_UPDATE_TOPIC, result);
+
       log.debug("Encoding process comic task");
       final ProcessComicWorkerTaskEncoder taskEncoder =
-          this.processComicTaskEncoderObjectFactory.getObject();
+          this.processTaskEncoderObjectFactory.getObject();
       taskEncoder.setComic(result);
       taskEncoder.setDeleteBlockedPages(this.deleteBlockedPages);
       taskEncoder.setIgnoreMetadata(this.ignoreMetadata);

comixed-tasks/src/main/java/org/comixedproject/task/model/ProcessComicWorkerTask.java

@@ -18,6 +18,8 @@
 
 package org.comixedproject.task.model;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.Date;
@@ -31,13 +33,15 @@
 import org.comixedproject.model.comic.Comic;
 import org.comixedproject.model.comic.ComicFileDetails;
 import org.comixedproject.model.comic.Page;
+import org.comixedproject.model.messaging.Constants;
 import org.comixedproject.service.comic.ComicService;
-import org.comixedproject.service.comic.PageService;
 import org.comixedproject.service.library.BlockedPageHashService;
 import org.comixedproject.utils.Utils;
+import org.comixedproject.views.View;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.context.annotation.Scope;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
 import org.springframework.stereotype.Component;
 
 /**
@@ -50,13 +54,12 @@
 @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
 @Log4j2
 public class ProcessComicWorkerTask extends AbstractWorkerTask {
-  private static final Object semaphore = new Object();
-
   @Autowired private ComicService comicService;
   @Autowired private Utils utils;
   @Autowired private ComicFileHandler comicFileHandler;
-  @Autowired private PageService pageService;
   @Autowired private BlockedPageHashService blockedPageHashService;
+  @Autowired private SimpMessagingTemplate messagingTemplate;
+  @Autowired private ObjectMapper objectMapper;
 
   @Getter @Setter private Comic comic;
   @Getter @Setter private boolean deleteBlockedPages;
@@ -69,12 +72,12 @@ protected String createDescription() {
 
   @Override
   public void startTask() throws WorkerTaskException {
-    logger.debug("Processing comic: id={}", comic.getId());
-    logger.debug("Getting archive adaptor");
+    log.debug("Processing comic: id={}", comic.getId());
+    log.debug("Getting archive adaptor");
     final ArchiveAdaptor adaptor =
         this.comicFileHandler.getArchiveAdaptorFor(this.comic.getArchiveType());
     if (adaptor == null) throw new WorkerTaskException("No archive adaptor found");
-    logger.debug("Loading comic");
+    log.debug("Loading comic");
     try {
       if (this.ignoreMetadata) {
         log.debug("Filling comic from disk");
@@ -100,12 +103,12 @@ public void startTask() throws WorkerTaskException {
       }
     }
 
-    logger.debug("Sorting pages");
+    log.debug("Sorting pages");
     comic.sortPages();
-    logger.debug("Setting comic file details");
+    log.debug("Setting comic file details");
     ComicFileDetails fileDetails = comic.getFileDetails();
     if (fileDetails == null) {
-      logger.debug("Creating new file details entry for comic");
+      log.debug("Creating new file details entry for comic");
       fileDetails = new ComicFileDetails();
     }
 
@@ -118,8 +121,17 @@ public void startTask() throws WorkerTaskException {
     fileDetails.setComic(comic);
     comic.setFileDetails(fileDetails);
 
-    logger.debug("Updating comic");
+    log.debug("Updating comic");
     comic.setDateLastUpdated(new Date());
-    this.comicService.save(comic);
+    final Comic result = this.comicService.save(comic);
+
+    log.debug("Publishing comic update");
+    try {
+      this.messagingTemplate.convertAndSend(
+          Constants.COMIC_LIST_UPDATE_TOPIC,
+          this.objectMapper.writerWithView(View.ComicDetailsView.class).writeValueAsString(result));
+    } catch (JsonProcessingException error) {
+      log.error("Failed to publish comic changes", error);
+    }
   }
 }

comixed-tasks/src/test/java/org/comixedproject/task/model/AddComicWorkerTaskTest.java

@@ -18,13 +18,16 @@
 
 package org.comixedproject.task.model;
 
+import static junit.framework.TestCase.assertFalse;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
 import java.io.File;
 import org.comixedproject.adaptors.AdaptorException;
 import org.comixedproject.adaptors.FilenameScraperAdaptor;
 import org.comixedproject.handlers.ComicFileHandler;
 import org.comixedproject.handlers.ComicFileHandlerException;
 import org.comixedproject.model.comic.Comic;
-import org.comixedproject.model.comic.Page;
+import org.comixedproject.model.messaging.Constants;
 import org.comixedproject.model.tasks.Task;
 import org.comixedproject.service.comic.ComicService;
 import org.comixedproject.service.task.TaskService;
@@ -37,30 +40,51 @@
 import org.mockito.junit.MockitoJUnitRunner;
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
 import org.springframework.test.context.TestPropertySource;
 
 @RunWith(MockitoJUnitRunner.class)
 @TestPropertySource(locations = "classpath:application.properties")
 @SpringBootTest
 public class AddComicWorkerTaskTest {
   private static final String TEST_CBZ_FILE = "src/test/resources/example.cbz";
-  private static final String PAGE_HASH = "0123456789ABCDEF";
 
   @InjectMocks private AddComicWorkerTask task;
   @Mock private ComicFileHandler comicFileHandler;
   @Mock private ComicService comicService;
   @Mock private ObjectFactory<Comic> comicFactory;
   @Mock private Comic comic;
-  @Mock private Page page;
   @Mock private FilenameScraperAdaptor filenameScraperAdaptor;
   @Mock private ObjectFactory<ProcessComicWorkerTaskEncoder> processComicTaskEncoderObjectFactory;
   @Mock private ProcessComicWorkerTaskEncoder processComicTaskEncoder;
   @Mock private Task workerTask;
   @Mock private TaskService taskService;
+  @Mock private SimpMessagingTemplate messagingTemplate;
+
+  @Test
+  public void testCreateDescription() {
+    assertFalse(task.createDescription().isEmpty());
+  }
+
+  @Test
+  public void testStartTaskAlreadyImported()
+      throws WorkerTaskException, ComicFileHandlerException, AdaptorException,
+          JsonProcessingException {
+    Mockito.when(comicService.findByFilename(Mockito.anyString())).thenReturn(comic);
+
+    task.setFilename(TEST_CBZ_FILE);
+
+    task.startTask();
+
+    Mockito.verify(comicService, Mockito.times(1))
+        .findByFilename(new File(TEST_CBZ_FILE).getAbsolutePath());
+    Mockito.verify(comicFactory, Mockito.never()).getObject();
+  }
 
   @Test
-  public void testAddFile()
-      throws WorkerTaskException, ComicFileHandlerException, AdaptorException {
+  public void testStartTask()
+      throws WorkerTaskException, ComicFileHandlerException, AdaptorException,
+          JsonProcessingException {
     Mockito.when(comicService.findByFilename(Mockito.anyString())).thenReturn(null);
     Mockito.when(comicFactory.getObject()).thenReturn(comic);
     Mockito.when(comicService.save(Mockito.any(Comic.class))).thenReturn(comic);
@@ -84,11 +108,15 @@ public void testAddFile()
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setComic(comic);
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setDeleteBlockedPages(false);
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setIgnoreMetadata(false);
+    Mockito.verify(taskService, Mockito.times(1)).save(workerTask);
+    Mockito.verify(messagingTemplate, Mockito.times(1))
+        .convertAndSend(Constants.COMIC_LIST_UPDATE_TOPIC, comic);
   }
 
   @Test
-  public void testAddFileIgnoreMetadata()
-      throws WorkerTaskException, ComicFileHandlerException, AdaptorException {
+  public void testStartTaskIgnoreMetadata()
+      throws WorkerTaskException, ComicFileHandlerException, AdaptorException,
+          JsonProcessingException {
     Mockito.when(comicService.findByFilename(Mockito.anyString())).thenReturn(null);
     Mockito.when(comicFactory.getObject()).thenReturn(comic);
     Mockito.when(comicService.save(Mockito.any(Comic.class))).thenReturn(comic);
@@ -112,11 +140,15 @@ public void testAddFileIgnoreMetadata()
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setComic(comic);
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setDeleteBlockedPages(false);
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setIgnoreMetadata(true);
+    Mockito.verify(taskService, Mockito.times(1)).save(workerTask);
+    Mockito.verify(messagingTemplate, Mockito.times(1))
+        .convertAndSend(Constants.COMIC_LIST_UPDATE_TOPIC, comic);
   }
 
   @Test
-  public void testAddFileDeleteBlockedPages()
-      throws WorkerTaskException, ComicFileHandlerException, AdaptorException {
+  public void testStartTaskDeleteBlockedPages()
+      throws WorkerTaskException, ComicFileHandlerException, AdaptorException,
+          JsonProcessingException {
     Mockito.when(comicService.findByFilename(Mockito.anyString())).thenReturn(null);
     Mockito.when(comicFactory.getObject()).thenReturn(comic);
     Mockito.when(comicService.save(Mockito.any(Comic.class))).thenReturn(comic);
@@ -140,11 +172,15 @@ public void testAddFileDeleteBlockedPages()
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setComic(comic);
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setDeleteBlockedPages(true);
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setIgnoreMetadata(false);
+    Mockito.verify(taskService, Mockito.times(1)).save(workerTask);
+    Mockito.verify(messagingTemplate, Mockito.times(1))
+        .convertAndSend(Constants.COMIC_LIST_UPDATE_TOPIC, comic);
   }
 
   @Test
-  public void testAddFileDeleteBlockedPagesIgnoreMetadata()
-      throws WorkerTaskException, ComicFileHandlerException, AdaptorException {
+  public void testStartTaskDeleteBlockedPagesIgnoreMetadata()
+      throws WorkerTaskException, ComicFileHandlerException, AdaptorException,
+          JsonProcessingException {
     Mockito.when(comicService.findByFilename(Mockito.anyString())).thenReturn(null);
     Mockito.when(comicFactory.getObject()).thenReturn(comic);
     Mockito.when(comicService.save(Mockito.any(Comic.class))).thenReturn(comic);
@@ -168,5 +204,8 @@ public void testAddFileDeleteBlockedPagesIgnoreMetadata()
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setComic(comic);
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setDeleteBlockedPages(true);
     Mockito.verify(processComicTaskEncoder, Mockito.times(1)).setIgnoreMetadata(true);
+    Mockito.verify(taskService, Mockito.times(1)).save(workerTask);
+    Mockito.verify(messagingTemplate, Mockito.times(1))
+        .convertAndSend(Constants.COMIC_LIST_UPDATE_TOPIC, comic);
   }
 }