Finalização do projeto back-end

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

@@ -1,20 +1,42 @@
 package backend.challenge.modules.task.dtos;
 
 import backend.challenge.modules.task.enums.TaskStatus;
+import backend.challenge.modules.task.models.Task;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
-import java.util.Date;
-
 @Getter
 @Setter
+@Builder
 @Accessors(chain = true)
 @NoArgsConstructor(staticName = "create")
+@AllArgsConstructor
 public class TaskDTO {
 
-	private String title;
-	private String description;
+    private String title;
+
+    private String description;
+
+    private Long id;
+
+    private int progress;
+
+    private TaskStatus status;
+
+    public TaskDTO(Task task) {
+        this.description = task.getDescription();
+        this.title = task.getTitle();
+        this.id = task.getId();
+        this.progress = task.getProgress();
+        this.status = task.getStatus();
+    }
 
+    public TaskDTO(String title, String description) {
+        this.description = description;
+        this.title = title;
+    }
 }

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

@@ -1,12 +1,12 @@
 package backend.challenge.modules.task.infra.http.controllers;
 
-import backend.challenge.modules.task.infra.http.views.TaskView;
-import backend.challenge.modules.task.models.Task;
+import backend.challenge.modules.task.dtos.TaskDTO;
 import backend.challenge.modules.task.services.*;
 import kikaha.urouting.api.*;
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
+import java.util.List;
 
 @Singleton
 @Path("tasks")
@@ -22,54 +22,77 @@ public class TaskController {
 	public TaskController(
 		final ICreateTaskService createTaskService,
 		final IDeleteTaskService deleteTaskService,
-		final IRetrieveAllTasksService retrieveAllTasksService
+		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");
+		try {
+			List<TaskDTO> tasks = this.retrieveAllTasksService.execute();
+			return DefaultResponse.ok().entity(tasks);
+		} catch (Exception e) {
+			return DefaultResponse.serverError();
+		}
 	}
 
 	@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");
+		try {
+			TaskDTO task = this.retrieveTaskByIdService.execute(taskId);
+			if (task != null) {
+				return DefaultResponse.ok().entity(task);
+			} else {
+				return DefaultResponse.notFound().entity("Task not found");
+			}
+		} catch (Exception e) {
+			return DefaultResponse.serverError();
+		}
 	}
 
 	@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.
-
-		return DefaultResponse.ok().entity("Hello world");
+	public Response create(TaskDTO taskDTO) {
+		try {
+			TaskDTO createdTask = this.createTaskService.execute(taskDTO);
+			return DefaultResponse.ok().entity(createdTask);
+		} catch (Exception e) {
+			return DefaultResponse.serverError();
+		}
 	}
 
 	@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") Long taskId, TaskDTO task) {
+		try {
+			TaskDTO updatedTask = this.updateTaskService.execute(task, taskId);
+			if (updatedTask != null) {
+				return DefaultResponse.ok().entity(updatedTask);
+			} else {
+				return DefaultResponse.notFound().entity("Task not found");
+			}
+		} catch (Exception e) {
+			return DefaultResponse.serverError();
+		}
 	}
 
 	@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
+		try {
+			this.deleteTaskService.execute(taskId);
+		} catch (Exception e) {
+			return DefaultResponse.serverError();
+		}
 
-		return DefaultResponse.ok().entity("Hello world");
+		return DefaultResponse.ok("Task with id: " + taskId + " deleted.");
 	}
 
 }

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

@@ -1,7 +1,6 @@
 package backend.challenge.modules.task.infra.http.controllers;
 
 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.*;
 
@@ -22,14 +21,7 @@ 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");
+		return DefaultResponse.ok().entity(this.updateTaskProgressService.execute(taskId, taskProgressView));
 	}
 
 }

source/backend/challenge/modules/task/infra/http/views/TaskProgressView.java

@@ -1,12 +1,20 @@
 package backend.challenge.modules.task.infra.http.views;
 
+import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 
 @Getter
 @Setter
+@AllArgsConstructor
+@NoArgsConstructor
 public class TaskProgressView {
 
 	private int progress;
 
+	public boolean validateIfProgressIsValid() {
+		return this.progress >= 0 && this.progress <= 100;
+	}
+
 }

source/backend/challenge/modules/task/infra/http/views/TaskView.java

@@ -1,11 +1,8 @@
 package backend.challenge.modules.task.infra.http.views;
 
-import backend.challenge.modules.task.enums.TaskStatus;
 import lombok.Getter;
 import lombok.Setter;
 
-import java.util.Date;
-
 @Getter
 @Setter
 public class TaskView {

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

@@ -1,23 +1,39 @@
 package backend.challenge.modules.task.models;
 
+import backend.challenge.modules.task.dtos.TaskDTO;
 import backend.challenge.modules.task.enums.TaskStatus;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import lombok.RequiredArgsConstructor;
 import lombok.Setter;
-import lombok.experimental.Accessors;
 
 import java.util.Date;
+import java.util.UUID;
 
 @Getter
 @Setter
+@NoArgsConstructor
+@AllArgsConstructor
 public class Task {
 
-	private Long id;
-	private String title;
-	private String description;
-	private int progress;
-	private TaskStatus status;
-	private Date createdAt;
+    private Long id;
 
+    private String title;
+
+    private String description;
+
+    private int progress;
+
+    private TaskStatus status;
+
+    private Date createdAt;
+
+    public Task(final TaskDTO dto) {
+    	this.id = Math.abs(UUID.randomUUID().getLeastSignificantBits());
+		this.createdAt = new Date();
+		this.description = dto.getDescription();
+		this.progress = 0;
+		this.status = TaskStatus.PROGRESS;
+		this.title = dto.getTitle();
+    }
 }

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

@@ -1,16 +1,23 @@
 package backend.challenge.modules.task.repositories;
 
 import backend.challenge.modules.task.dtos.TaskDTO;
+import backend.challenge.modules.task.infra.http.views.TaskProgressView;
 import backend.challenge.modules.task.models.Task;
 
 import java.util.List;
 
 public interface ITaskRepository {
 
-	Task index(Long taskId);
-	List<Task> show();
-	Task create(TaskDTO taskDTO);
-	Task update(Task task);
+	TaskDTO index(Long taskId);
+
+	List<TaskDTO> show();
+
+	TaskDTO create(TaskDTO taskDTO);
+
+	TaskDTO update(TaskDTO taskDTO, Long taskId);
+
 	void delete(Long taskId);
 
+	TaskDTO updateTaskProgress(Long taskId, TaskProgressView taskProgressView);
+
 }

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

@@ -1,46 +1,75 @@
 package backend.challenge.modules.task.repositories;
 
 import backend.challenge.modules.task.dtos.TaskDTO;
+import backend.challenge.modules.task.enums.TaskStatus;
+import backend.challenge.modules.task.infra.http.views.TaskProgressView;
 import backend.challenge.modules.task.models.Task;
 
 import javax.inject.Singleton;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 @Singleton
 public class TaskRepository implements ITaskRepository {
 
-	@Override
-	public Task index(final Long taskId) {
-		// TODO: Criar método responsável por retornar tarefa por id
+	private final List<Task> tasks = new ArrayList<>();
 
-		return null;
+	@Override
+	public TaskDTO index(Long taskId) {
+		Task task = findTaskById(taskId).orElseThrow(() -> new RuntimeException("Task with id: " + taskId + " not found."));
+		return new TaskDTO(task);
 	}
 
 	@Override
-	public List<Task> show() {
-		// TODO: Criar método responsável por retornar todas as tarefas
-
-		return null;
+	public List<TaskDTO> show() {
+		return tasks.stream().map(TaskDTO::new).collect(Collectors.toList());
 	}
 
 	@Override
-	public Task create(final TaskDTO taskDTO) {
-		// TODO: Criar método responsável por criar uma tarefa
-
-		return null;
+	public TaskDTO create(TaskDTO taskDTO) {
+		Task task = new Task(taskDTO);
+		tasks.add(task);
+		return new TaskDTO(task);
 	}
 
 	@Override
-	public Task update(final Task task) {
-		// TODO: Criar método responsável por atualizar uma tarefa
+	public TaskDTO update(TaskDTO taskDTO, Long taskId) {
+		tasks.stream().filter(task -> task.getId().equals(taskId)).forEach(task -> {
+			task.setDescription(taskDTO.getDescription());
+			task.setTitle(taskDTO.getTitle());
+		});
+		return this.index(taskId);
+	}
 
-		return null;
+	@Override
+	public void delete(Long taskId) {
+		tasks.removeIf(task -> task.getId().equals(taskId));
 	}
 
 	@Override
-	public void delete(final Long taskId) {
- 		// TODO: Criar método responsável por deletar tarefa por id
+	public TaskDTO updateTaskProgress(Long taskId, TaskProgressView taskProgressView) {
+		boolean isProgressValid = taskProgressView.validateIfProgressIsValid();
+		if(!isProgressValid) {
+			throw new RuntimeException("Progress % invalid.");
+		}
+
+		tasks.stream().filter(task -> task.getId().equals(taskId))
+				.forEach(task -> {
+					int progress = taskProgressView.getProgress();
+					task.setProgress(progress);
+
+					if (progress == 100) {
+						task.setStatus(TaskStatus.COMPLETE);
+					}
+				});
+
+		return this.index(taskId);
+	}
 
+	private Optional<Task> findTaskById(Long taskId) {
+		return tasks.stream().filter(task -> task.getId().equals(taskId)).findFirst();
 	}
 
 }