Resolução do desafio

source/backend/challenge/modules/task/dtos/TaskDTO.java

@@ -1,19 +1,17 @@
 package backend.challenge.modules.task.dtos;
 
-import backend.challenge.modules.task.enums.TaskStatus;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
-import java.util.Date;
-
 @Getter
 @Setter
 @Accessors(chain = true)
 @NoArgsConstructor(staticName = "create")
+@AllArgsConstructor
 public class TaskDTO {
-
 	private String title;
 	private String description;
 

source/backend/challenge/modules/task/dtos/TaskProgressDTO.java

@@ -1,17 +1,21 @@
 package backend.challenge.modules.task.dtos;
 
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
+import java.util.UUID;
+
 @Getter
 @Setter
 @Accessors(chain = true)
 @NoArgsConstructor(staticName = "create")
+@AllArgsConstructor
 public class TaskProgressDTO {
 
-	private Long id;
+	private UUID id;
 	private int progress;
 
 }

source/backend/challenge/modules/task/infra/http/controllers/TaskController.java

@@ -1,17 +1,18 @@
 package backend.challenge.modules.task.infra.http.controllers;
 
+import backend.challenge.modules.task.dtos.TaskDTO;
 import backend.challenge.modules.task.infra.http.views.TaskView;
 import backend.challenge.modules.task.models.Task;
 import backend.challenge.modules.task.services.*;
 import kikaha.urouting.api.*;
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
+import java.util.UUID;
 
 @Singleton
 @Path("tasks")
 public class TaskController {
-
 	private final ICreateTaskService createTaskService;
 	private final IDeleteTaskService deleteTaskService;
 	private final IRetrieveAllTasksService retrieveAllTasksService;
@@ -20,56 +21,112 @@ public class TaskController {
 
 	@Inject
 	public TaskController(
-		final ICreateTaskService createTaskService,
-		final IDeleteTaskService deleteTaskService,
-		final IRetrieveAllTasksService retrieveAllTasksService
+			final ICreateTaskService createTaskService,
+			final IDeleteTaskService deleteTaskService,
+			final IRetrieveAllTasksService retrieveAllTasksService,
+			final IRetrieveTaskByIdService retrieveTaskByIdService,
+			final IUpdateTaskService updateTaskService
 	) {
 		this.createTaskService = createTaskService;
 		this.deleteTaskService = deleteTaskService;
 		this.retrieveAllTasksService = retrieveAllTasksService;
-		this.retrieveTaskByIdService = null;
-		this.updateTaskService = null;
+		this.retrieveTaskByIdService = retrieveTaskByIdService;
+		this.updateTaskService = updateTaskService;
 	}
 
 	@GET
 	public Response show() {
-		// TODO: Rota que lista todas as tarefas
-
-		return DefaultResponse.ok().entity("Hello world");
+		IRetrieveAllTasksService.OutputPort outputPort = this.retrieveAllTasksService.execute();
+		return DefaultResponse.ok().entity(outputPort);
 	}
 
 	@GET
 	@Path("single/{taskId}")
-	public Response index(@PathParam("taskId") Long taskId) {
-		// TODO: A rota deve retornar somente a tarefa a qual o id corresponder
-
-		return DefaultResponse.ok().entity("Hello world");
+	public Response index(@PathParam("taskId") String taskId) {
+		UUID id = UUID.fromString(taskId);
+		IRetrieveTaskByIdService.OutputPort outputPort = this.retrieveTaskByIdService.execute(new IRetrieveTaskByIdService.InputPort(id));
+
+		if (outputPort instanceof IRetrieveTaskByIdService.OutputPort.Ok) {
+			IRetrieveTaskByIdService.OutputPort.Ok ok = (IRetrieveTaskByIdService.OutputPort.Ok) outputPort;
+			return DefaultResponse.ok().entity(ok);
+		}
+
+		if (outputPort instanceof IRetrieveTaskByIdService.OutputPort.NotFound) {
+			IRetrieveTaskByIdService.OutputPort.NotFound notFound = (IRetrieveTaskByIdService.OutputPort.NotFound) outputPort;
+			return DefaultResponse.notFound().entity(notFound);
+		}
+
+		if (outputPort instanceof IRetrieveTaskByIdService.OutputPort.Error) {
+			IRetrieveTaskByIdService.OutputPort.Error error = (IRetrieveTaskByIdService.OutputPort.Error) outputPort;
+			return DefaultResponse.badRequest().entity(error);
+		}
+
+		return DefaultResponse.serverError().entity("An unexpected error occurred");
 	}
 
 	@POST
 	public Response create(TaskView task) {
-		// TODO: A rota deve receber title e description, sendo o `title` o título da tarefa e `description` uma descrição da tarefa.
+		TaskDTO inputPort = new TaskDTO(task.getTitle(), task.getDescription());
+		ICreateTaskService.OutputPort outputPort = this.createTaskService.execute(new ICreateTaskService.InputPort(inputPort));
+
+		if (outputPort instanceof ICreateTaskService.OutputPort.Ok) {
+			ICreateTaskService.OutputPort.Ok ok = (ICreateTaskService.OutputPort.Ok) outputPort;
+			return DefaultResponse.created().entity(ok);
+		}
 
-		return DefaultResponse.ok().entity("Hello world");
+		if (outputPort instanceof ICreateTaskService.OutputPort.Error) {
+			ICreateTaskService.OutputPort.Error error = (ICreateTaskService.OutputPort.Error) outputPort;
+			return DefaultResponse.badRequest().entity(error);
+		}
+
+		return DefaultResponse.serverError().entity("An unexpected error occurred");
 	}
 
 	@PUT
 	@Path("single/{taskId}")
-	public Response update(@PathParam("taskId") Long taskId, Task task) {
-		/*
-			TODO:  A rota deve alterar apenas o title e description da tarefa
-			 			 que possua o id igual ao id correspondente nos parâmetros da rota.
-		 */
-
-		return DefaultResponse.ok().entity("Hello world");
+	public Response update(@PathParam("taskId") String taskId, Task task) {
+		UUID id = UUID.fromString(taskId);
+		TaskDTO inputPort = new TaskDTO(task.getTitle(), task.getDescription());
+		IUpdateTaskService.OutputPort outputPort = this.updateTaskService.execute(new IUpdateTaskService.InputPort(id, inputPort));
+
+		if (outputPort instanceof IUpdateTaskService.OutputPort.Ok) {
+			return DefaultResponse.noContent();
+		}
+
+		if (outputPort instanceof IUpdateTaskService.OutputPort.NotFound) {
+			IUpdateTaskService.OutputPort.NotFound notFound = (IUpdateTaskService.OutputPort.NotFound) outputPort;
+			return DefaultResponse.notFound().entity(notFound);
+		}
+
+		if (outputPort instanceof IUpdateTaskService.OutputPort.Error) {
+			IUpdateTaskService.OutputPort.Error error = (IUpdateTaskService.OutputPort.Error) outputPort;
+			return DefaultResponse.badRequest().entity(error);
+		}
+
+		return DefaultResponse.serverError().entity("An unexpected error occurred");
 	}
 
 	@DELETE
 	@Path("single/{taskId}")
-	public Response delete(@PathParam("taskId") Long taskId) {
-		// TODO: A rota deve deletar a tarefa com o id correspondente nos parâmetros da rota
-
-		return DefaultResponse.ok().entity("Hello world");
+	public Response delete(@PathParam("taskId") String taskId) {
+		UUID id = UUID.fromString(taskId);
+		IDeleteTaskService.OutputPort outputPort = this.deleteTaskService.execute(new IDeleteTaskService.InputPort(id));
+
+		if (outputPort instanceof IDeleteTaskService.OutputPort.Ok) {
+			IDeleteTaskService.OutputPort.Ok ok = (IDeleteTaskService.OutputPort.Ok) outputPort;
+			return DefaultResponse.noContent();
+		}
+
+		if (outputPort instanceof IDeleteTaskService.OutputPort.NotFound) {
+			IDeleteTaskService.OutputPort.NotFound notFound = (IDeleteTaskService.OutputPort.NotFound) outputPort;
+			return DefaultResponse.notFound().entity(notFound);
+		}
+
+		if (outputPort instanceof IDeleteTaskService.OutputPort.Error) {
+			IDeleteTaskService.OutputPort.Error error = (IDeleteTaskService.OutputPort.Error) outputPort;
+			return DefaultResponse.badRequest().entity(error);
+		}
+
+		return DefaultResponse.serverError().entity("An unexpected error occurred");
 	}
-
 }

source/backend/challenge/modules/task/infra/http/controllers/TaskProgressController.java

@@ -1,17 +1,17 @@
 package backend.challenge.modules.task.infra.http.controllers;
 
+import backend.challenge.modules.task.dtos.TaskProgressDTO;
 import backend.challenge.modules.task.infra.http.views.TaskProgressView;
-import backend.challenge.modules.task.models.Task;
 import backend.challenge.modules.task.services.*;
 import kikaha.urouting.api.*;
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
+import java.util.UUID;
 
 @Singleton
 @Path("tasks/progress")
 public class TaskProgressController {
-
 	private final IUpdateTaskProgressService updateTaskProgressService;
 
 	@Inject
@@ -21,15 +21,28 @@ public TaskProgressController(final IUpdateTaskProgressService updateTaskProgres
 
 	@PUT
 	@Path("single/{taskId}")
-	public Response updateProgress(@PathParam("taskId") Long taskId, TaskProgressView taskProgressView) {
-		/*
-			TODO: A rota deve alterar apenas o progresso da tarefa que possua o id igual ao id correspondente
-			 			nos parâmetros da rota.
-			 			O `progress` pode ter o valor máximo de 100, e quando ele atingi o máximo,
-			 			o `status` deve ser alterado para `COMPLETE`
-		 */
-
-		return DefaultResponse.ok().entity("Hello world");
+	public Response updateProgress(@PathParam("taskId") String taskId, TaskProgressView taskProgressView) {
+		UUID id = UUID.fromString(taskId);
+		TaskProgressDTO taskProgressDTO = new TaskProgressDTO(id, taskProgressView.getProgress());
+		IUpdateTaskProgressService.InputPort inputPort = new IUpdateTaskProgressService.InputPort(taskProgressDTO);
+
+		IUpdateTaskProgressService.OutputPort outputPort = this.updateTaskProgressService.execute(inputPort);
+
+		if (outputPort instanceof IUpdateTaskProgressService.OutputPort.Ok) {
+			return DefaultResponse.noContent();
+		}
+
+		if (outputPort instanceof IUpdateTaskProgressService.OutputPort.NotFound) {
+			IUpdateTaskProgressService.OutputPort.NotFound notFound = (IUpdateTaskProgressService.OutputPort.NotFound) outputPort;
+			return DefaultResponse.notFound().entity(notFound);
+		}
+
+		if (outputPort instanceof IUpdateTaskProgressService.OutputPort.Error) {
+			IUpdateTaskProgressService.OutputPort.Error error = (IUpdateTaskProgressService.OutputPort.Error) outputPort;
+			return DefaultResponse.badRequest().entity(error);
+		}
+
+		return DefaultResponse.serverError().entity("An unexpected error occurred");
 	}
 
 }

source/backend/challenge/modules/task/messages/ErrorMessages.java

@@ -0,0 +1,13 @@
+package backend.challenge.modules.task.messages;
+
+public class ErrorMessages {
+    public static final String TASK_IS_REQUIRED = "Task is required";
+    public static final String TITLE_IS_REQUIRED = "Title is required";
+    public static final String TASK_ID_IS_REQUIRED = "Task ID is required";
+    public static final String TASK_NOT_FOUND = "Task not found";
+    public static final String INVALID_INPUT = "Invalid input";
+    public static final String TASK_PROGRESS_IS_REQUIRED = "Task progress is required";
+    public static final String TASK_PROGRESS_MUST_BE_GREATER_THAN_OR_EQUAL_TO_0 = "Task progress must be greater than or equal to 0";
+    public static final String TASK_PROGRESS_MUST_BE_LESS_THAN_OR_EQUAL_TO_100 = "Task progress must be less than or equal to 100";
+    public static final String TASK_IS_ALREADY_COMPLETE = "Task is already complete";
+}

source/backend/challenge/modules/task/models/Task.java

@@ -1,23 +1,25 @@
 package backend.challenge.modules.task.models;
 
 import backend.challenge.modules.task.enums.TaskStatus;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.RequiredArgsConstructor;
-import lombok.Setter;
-import lombok.experimental.Accessors;
+import lombok.*;
 
+import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.util.Date;
+import java.util.UUID;
+
+import static backend.challenge.modules.task.enums.TaskStatus.PROGRESS;
 
 @Getter
 @Setter
+@NoArgsConstructor
+@AllArgsConstructor
 public class Task {
-
-	private Long id;
+	private UUID id = UUID.randomUUID();
 	private String title;
 	private String description;
-	private int progress;
-	private TaskStatus status;
-	private Date createdAt;
+	private int progress = 0;
+	private TaskStatus status = PROGRESS;
+	private Date createdAt = Date.from(LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant());
 
 }

source/backend/challenge/modules/task/repositories/ITaskRepository.java

@@ -4,13 +4,13 @@
 import backend.challenge.modules.task.models.Task;
 
 import java.util.List;
+import java.util.UUID;
 
 public interface ITaskRepository {
 
-	Task index(Long taskId);
+	Task index(UUID taskId);
 	List<Task> show();
 	Task create(TaskDTO taskDTO);
 	Task update(Task task);
-	void delete(Long taskId);
-
+	void delete(UUID taskId);
 }

source/backend/challenge/modules/task/repositories/TaskRepository.java

@@ -4,43 +4,53 @@
 import backend.challenge.modules.task.models.Task;
 
 import javax.inject.Singleton;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.UUID;
 
 @Singleton
 public class TaskRepository implements ITaskRepository {
+	private final List<Task> tasks = new ArrayList<>();
 
 	@Override
-	public Task index(final Long taskId) {
-		// TODO: Criar método responsável por retornar tarefa por id
-
-		return null;
+	public Task index(final UUID taskId) {
+		return this.tasks.stream()
+				.filter(t -> t.getId().equals(taskId))
+				.findFirst()
+				.orElse(null);
 	}
 
 	@Override
 	public List<Task> show() {
-		// TODO: Criar método responsável por retornar todas as tarefas
-
-		return null;
+		return new ArrayList<>(this.tasks);
 	}
 
 	@Override
 	public Task create(final TaskDTO taskDTO) {
-		// TODO: Criar método responsável por criar uma tarefa
+		Task newTask = new Task();
+		newTask.setTitle(taskDTO.getTitle());
+		newTask.setDescription(taskDTO.getDescription());
+
+		this.tasks.add(newTask);
 
-		return null;
+		return newTask;
 	}
 
 	@Override
 	public Task update(final Task task) {
-		// TODO: Criar método responsável por atualizar uma tarefa
-
-		return null;
+		tasks.stream()
+				.filter(existingTask -> existingTask.getId().equals(task.getId()))
+				.findFirst()
+				.ifPresent(existingTask -> {
+					existingTask.setTitle(task.getTitle());
+					existingTask.setDescription(task.getDescription());
+				});
+
+		return task;
 	}
 
 	@Override
-	public void delete(final Long taskId) {
- 		// TODO: Criar método responsável por deletar tarefa por id
-
+	public void delete(UUID taskId) {
+		this.tasks.removeIf(task -> task.getId().equals(taskId));
 	}
-
 }