Implementation of publication update.

codiki-application/src/main/java/org/codiki/application/category/CategoryUseCases.java

@@ -0,0 +1,21 @@
+package org.codiki.application.category;
+
+import java.util.Optional;
+import java.util.UUID;
+
+import org.codiki.domain.category.model.Category;
+import org.codiki.domain.category.port.CategoryPort;
+import org.springframework.stereotype.Service;
+
+@Service
+public class CategoryUseCases {
+    private final CategoryPort categoryPort;
+
+    public CategoryUseCases(CategoryPort categoryPort) {
+        this.categoryPort = categoryPort;
+    }
+
+    public Optional<Category> findById(UUID categoryId) {
+        return categoryPort.findById(categoryId);
+    }
+}

codiki-application/src/main/java/org/codiki/application/publication/PublicationCreationRequestValidator.java

@@ -1,26 +1,26 @@
 package org.codiki.application.publication;
 
-import org.codiki.domain.publication.exception.PublicationCreationException;
-import org.codiki.domain.publication.model.PublicationCreationRequest;
+import org.codiki.domain.publication.exception.PublicationEditionException;
+import org.codiki.domain.publication.model.PublicationEditionRequest;
 import org.springframework.stereotype.Component;
 
 @Component
 public class PublicationCreationRequestValidator {
-    void isValid(PublicationCreationRequest request) {
+    public void isValid(PublicationEditionRequest request) {
         if (request.title() == null) {
-            throw new PublicationCreationException("title cannot be null.");
+            throw new PublicationEditionException("title cannot be null");
         }
 
         if (request.text() == null) {
-            throw new PublicationCreationException("text cannot be null.");
+            throw new PublicationEditionException("text cannot be null");
         }
 
         if (request.description() == null) {
-            throw new PublicationCreationException("description cannot be null.");
+            throw new PublicationEditionException("description cannot be null");
         }
 
         if (request.image() == null) {
-            throw new PublicationCreationException("image cannot be null.");
+            throw new PublicationEditionException("image cannot be null");
         }
     }
 }

codiki-application/src/main/java/org/codiki/application/publication/PublicationUpdateRequestValidator.java

@@ -0,0 +1,22 @@
+package org.codiki.application.publication;
+
+import static java.util.Objects.isNull;
+
+import org.codiki.domain.publication.exception.PublicationEditionException;
+import org.codiki.domain.publication.model.PublicationEditionRequest;
+import org.springframework.stereotype.Component;
+
+@Component
+public class PublicationUpdateRequestValidator {
+    public void isValid(PublicationEditionRequest request) {
+        if (
+            isNull(request.title()) &&
+            isNull(request.text()) &&
+            isNull(request.description()) &&
+            isNull(request.image()) &&
+            isNull(request.categoryId())
+        ) {
+            throw new PublicationEditionException("no any field is filled");
+        }
+    }
+}

codiki-application/src/main/java/org/codiki/application/publication/PublicationUseCases.java

@@ -1,56 +1,63 @@
 package org.codiki.application.publication;
 
+import static java.util.Objects.isNull;
 import java.time.Clock;
 import java.time.ZonedDateTime;
 import java.util.UUID;
 
 import static org.codiki.domain.publication.model.builder.AuthorBuilder.anAuthor;
 import static org.codiki.domain.publication.model.builder.PublicationBuilder.aPublication;
+import org.codiki.application.category.CategoryUseCases;
 import org.codiki.application.user.UserUseCases;
+import org.codiki.domain.category.exception.CategoryNotFoundException;
 import org.codiki.domain.category.model.Category;
-import org.codiki.domain.category.port.CategoryPort;
 import org.codiki.domain.exception.AuthenticationRequiredException;
-import org.codiki.domain.publication.exception.PublicationCreationException;
+import org.codiki.domain.publication.exception.PublicationEditionException;
+import org.codiki.domain.publication.exception.PublicationNotFoundException;
+import org.codiki.domain.publication.exception.PublicationUpdateForbiddenException;
 import org.codiki.domain.publication.model.Publication;
-import org.codiki.domain.publication.model.PublicationCreationRequest;
+import org.codiki.domain.publication.model.PublicationEditionRequest;
+import org.codiki.domain.publication.model.builder.PublicationBuilder;
 import org.codiki.domain.publication.port.PublicationPort;
 import org.codiki.domain.user.model.User;
 import org.springframework.stereotype.Service;
 
 @Service
 public class PublicationUseCases {
-    private final CategoryPort categoryPort;
+    private final CategoryUseCases categoryUseCases;
     private final KeyGenerator keyGenerator;
     private final PublicationPort publicationPort;
     private final PublicationCreationRequestValidator publicationCreationRequestValidator;
+    private final PublicationUpdateRequestValidator publicationUpdateRequestValidator;
     private final UserUseCases userUseCases;
     private final Clock clock;
 
     public PublicationUseCases(
-        CategoryPort categoryPort,
+        CategoryUseCases categoryUseCases,
+        Clock clock,
         KeyGenerator keyGenerator,
-        PublicationPort publicationPort,
         PublicationCreationRequestValidator publicationCreationRequestValidator,
-        UserUseCases userUseCases,
-        Clock clock
+        PublicationPort publicationPort, PublicationUpdateRequestValidator publicationUpdateRequestValidator,
+        UserUseCases userUseCases
     ) {
-        this.publicationCreationRequestValidator = publicationCreationRequestValidator;
-        this.userUseCases = userUseCases;
-        this.keyGenerator = keyGenerator;
+        this.categoryUseCases = categoryUseCases;
         this.clock = clock;
-        this.categoryPort = categoryPort;
+        this.keyGenerator = keyGenerator;
+        this.publicationCreationRequestValidator = publicationCreationRequestValidator;
         this.publicationPort = publicationPort;
+        this.publicationUpdateRequestValidator = publicationUpdateRequestValidator;
+        this.userUseCases = userUseCases;
     }
 
-    public Publication createPublication(PublicationCreationRequest request) {
+    public Publication createPublication(PublicationEditionRequest request) {
         publicationCreationRequestValidator.isValid(request);
 
         User authenticatedUser = userUseCases.getAuthenticatedUser()
             .orElseThrow(AuthenticationRequiredException::new);
 
-        Category category = categoryPort.findById(request.categoryId())
-            .orElseThrow(() -> new PublicationCreationException(
-                String.format("No any category exists for id %s", request.categoryId())
+        Category category = categoryUseCases.findById(request.categoryId())
+            .orElseThrow(() -> new PublicationEditionException(
+                new CategoryNotFoundException(request.categoryId())
             ));
 
         Publication newPublication = aPublication()
@@ -69,4 +76,51 @@ public class PublicationUseCases {
 
         return newPublication;
     }
+
+    public Publication updatePublication(UUID publicationId, PublicationEditionRequest request) {
+        publicationUpdateRequestValidator.isValid(request);
+
+        Publication publicationToUpdate = publicationPort.findById(publicationId)
+            .orElseThrow(() -> new PublicationNotFoundException(publicationId));
+
+        User authenticatedUser = userUseCases.getAuthenticatedUser()
+            .orElseThrow(AuthenticationRequiredException::new);
+
+        if (!publicationToUpdate.author().id().equals(authenticatedUser.id())) {
+            throw new PublicationUpdateForbiddenException();
+        }
+
+        PublicationBuilder publicationBuilder = aPublication().basedOn(publicationToUpdate);
+
+        if (!isNull(request.title())) {
+            publicationBuilder.withTitle(request.title());
+        }
+
+        if (!isNull(request.text())) {
+            publicationBuilder.withText(request.text());
+        }
+
+        if (!isNull(request.description())) {
+            publicationBuilder.withDescription(request.description());
+        }
+
+        if (!isNull(request.image())) {
+            publicationBuilder.withImage(request.image());
+        }
+
+        if (!isNull(request.categoryId())) {
+            Category newCategory = categoryUseCases.findById(request.categoryId())
+                .orElseThrow(() -> new PublicationEditionException(
+                    new CategoryNotFoundException(request.categoryId())
+                ));
+
+            publicationBuilder.withCategory(newCategory);
+        }
+
+        Publication updatedPublication = publicationBuilder.build();
+
+        publicationPort.save(updatedPublication);
+
+        return updatedPublication;
+    }
 }