Challenge sizebay jeansouza

backend-challenge/source/backend/challenge/modules/task/exceptions/DeleteException.java

@@ -0,0 +1,9 @@
+package backend.challenge.modules.task.exceptions;
+
+public class DeleteException extends RuntimeException {
+
+    public DeleteException(String message)
+    {
+        super(message);
+    }
+}

backend-challenge/source/backend/challenge/modules/task/exceptions/UpdateException.java

@@ -0,0 +1,8 @@
+package backend.challenge.modules.task.exceptions;
+
+public class UpdateException extends RuntimeException{
+    public UpdateException(String message)
+    {
+        super(message);
+    }
+}

backend-challenge/source/backend/challenge/modules/task/factories/TaskDTOFactory.java

@@ -0,0 +1,15 @@
+package backend.challenge.modules.task.factories;
+
+import backend.challenge.modules.task.dtos.TaskDTO;
+import backend.challenge.modules.task.interfaces.ITaskDTOFactory;
+
+public class TaskDTOFactory implements ITaskDTOFactory {
+
+    @Override
+    public TaskDTO build(String title, String description) {
+        TaskDTO taskDTO = TaskDTO.create();
+        taskDTO.setTitle(title);
+        taskDTO.setDescription(description);
+        return taskDTO;
+    }
+}

backend-challenge/source/backend/challenge/modules/task/factories/TaskFactory.java

@@ -0,0 +1,25 @@
+package backend.challenge.modules.task.factories;
+
+import java.util.Date;
+import java.util.UUID;
+
+import backend.challenge.modules.task.dtos.TaskDTO;
+import backend.challenge.modules.task.enums.TaskStatus;
+import backend.challenge.modules.task.interfaces.ITaskFactory;
+import backend.challenge.modules.task.models.Task;
+
+public class TaskFactory implements ITaskFactory {
+
+	@Override
+	public Task build(TaskDTO taskDTO) {
+		Task task = new Task();
+		task.setId(UUID.randomUUID().getLeastSignificantBits());
+		task.setTitle(taskDTO.getTitle());
+		task.setDescription(taskDTO.getDescription());
+		task.setStatus(TaskStatus.PROGRESS);
+		task.setProgress(0);
+		task.setCreatedAt(new Date());
+		return task;
+	}
+
+}

backend-challenge/source/backend/challenge/modules/task/factories/TaskProgressDTOFactory.java

@@ -0,0 +1,18 @@
+package backend.challenge.modules.task.factories;
+
+import backend.challenge.modules.task.dtos.TaskProgressDTO;
+import backend.challenge.modules.task.interfaces.ITaskProgressDTOFactory;
+
+import java.util.UUID;
+
+public class TaskProgressDTOFactory implements ITaskProgressDTOFactory {
+
+    @Override
+    public TaskProgressDTO build(Long id, int progress)
+    {
+        TaskProgressDTO taskProgressDTO = TaskProgressDTO.create();
+        taskProgressDTO.setId(id);
+        taskProgressDTO.setProgress(progress);
+        return taskProgressDTO;
+    }
+}

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

@@ -0,0 +1,101 @@
+package backend.challenge.modules.task.infra.http.controllers;
+
+import backend.challenge.modules.task.exceptions.DeleteException;
+import backend.challenge.modules.task.exceptions.UpdateException;
+import backend.challenge.modules.task.factories.TaskDTOFactory;
+import backend.challenge.modules.task.infra.http.views.TaskView;
+import backend.challenge.modules.task.interfaces.*;
+import backend.challenge.modules.task.models.Task;
+import kikaha.urouting.api.*;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+@Singleton
+@Path("tasks")
+public class TaskController {
+
+	private static final String TASK_SUCCESSFULLY_DELETED = "Task successfully deleted!";
+	private static final int ERROR_BAD_REQUEST = 400;
+	private final ICreateTaskService createTaskService;
+	private final IDeleteTaskService deleteTaskService;
+	private final IRetrieveAllTasksService retrieveAllTasksService;
+	private final IRetrieveTaskByIdService retrieveTaskByIdService;
+	private final IUpdateTaskService updateTaskService;
+
+	@Inject
+	public TaskController(
+		final ICreateTaskService createTaskService,
+		final IDeleteTaskService deleteTaskService,
+		final IRetrieveAllTasksService retrieveAllTasksService
+	) {
+		this.createTaskService = createTaskService;
+		this.deleteTaskService = deleteTaskService;
+		this.retrieveAllTasksService = retrieveAllTasksService;
+		this.retrieveTaskByIdService = null;
+		this.updateTaskService = null;
+	}
+
+	@GET
+	public Response show() {
+		return DefaultResponse.ok().entity(retrieveAllTasksService.execute());
+	}
+
+	@GET
+	@Path("single/{taskId}")
+	public Response index(@PathParam("taskId") Long taskId) {
+		try
+		{
+			Task task = retrieveTaskByIdService.execute(taskId);
+			return DefaultResponse.ok().entity(task);
+		}
+		catch (Exception exception)
+		{
+			exception.printStackTrace();
+			return DefaultResponse.notFound().entity(exception.getMessage());
+		}
+	}
+
+	@POST
+	public Response create(TaskView task) {
+		return DefaultResponse.ok().entity(new TaskDTOFactory().build(task.getTitle(), task.getDescription()));
+	}
+
+	@PUT
+	@Path("single/{taskId}")
+	public Response update(@PathParam("taskId") Long taskId, Task task) {
+		if(task.getId().equals(taskId))
+		{
+			try
+			{
+				this.updateTaskService.execute(task);
+			}
+			catch(UpdateException updateException)
+			{
+				updateException.printStackTrace();
+				return DefaultResponse.badRequest().statusCode(ERROR_BAD_REQUEST);
+			}
+		}
+		else
+		{
+				return DefaultResponse.badRequest().statusCode(ERROR_BAD_REQUEST);
+		}
+		return DefaultResponse.ok().entity(task);
+	}
+
+	@DELETE
+	@Path("single/{taskId}")
+	public Response delete(@PathParam("taskId") Long taskId) {
+		try
+		{
+			this.deleteTaskService.execute(taskId);
+		}
+		catch(DeleteException deleteException)
+		{
+			deleteException.printStackTrace();
+			return DefaultResponse.notFound().entity(deleteException.getMessage());
+		}
+		return DefaultResponse.ok().entity(TASK_SUCCESSFULLY_DELETED);
+	}
+
+}

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

@@ -0,0 +1,43 @@
+package backend.challenge.modules.task.infra.http.controllers;
+
+import backend.challenge.modules.task.dtos.TaskProgressDTO;
+import backend.challenge.modules.task.exceptions.UpdateException;
+import backend.challenge.modules.task.factories.TaskProgressDTOFactory;
+import backend.challenge.modules.task.infra.http.views.TaskProgressView;
+import backend.challenge.modules.task.interfaces.IUpdateTaskProgressService;
+import backend.challenge.modules.task.models.Task;
+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
+	public TaskProgressController(final IUpdateTaskProgressService updateTaskProgressService) {
+		this.updateTaskProgressService = updateTaskProgressService;
+	}
+
+	@PUT
+	@Path("single/{taskId}")
+	public Response updateProgress(@PathParam("taskId") Long taskId, TaskProgressView taskProgressView) {
+		TaskProgressDTO taskProgressDTO = new TaskProgressDTOFactory().build(taskId, taskProgressView.getProgress());
+		Task task = null;
+		try
+		{
+			task = this.updateTaskProgressService.execute(taskProgressDTO);
+		}
+		catch (UpdateException updateException)
+		{
+			updateException.printStackTrace();
+			return DefaultResponse.notFound().entity(updateException.getMessage());
+		}
+		return DefaultResponse.ok().entity(task);
+	}
+
+}

backend-challenge/source/backend/challenge/modules/task/interfaces/ITaskDTOFactory.java

@@ -0,0 +1,7 @@
+package backend.challenge.modules.task.interfaces;
+
+import backend.challenge.modules.task.dtos.TaskDTO;
+
+public interface ITaskDTOFactory {
+    TaskDTO build(String title, String description);
+}

backend-challenge/source/backend/challenge/modules/task/interfaces/ITaskFactory.java

@@ -0,0 +1,8 @@
+package backend.challenge.modules.task.interfaces;
+
+import backend.challenge.modules.task.dtos.TaskDTO;
+import backend.challenge.modules.task.models.Task;
+
+public interface ITaskFactory {
+	Task build(TaskDTO taskDTO);
+}

backend-challenge/source/backend/challenge/modules/task/interfaces/ITaskProgressDTOFactory.java

@@ -0,0 +1,8 @@
+package backend.challenge.modules.task.interfaces;
+
+import backend.challenge.modules.task.dtos.TaskProgressDTO;
+
+public interface ITaskProgressDTOFactory {
+
+    TaskProgressDTO build(Long id, int progress);
+}

backend-challenge/source/backend/challenge/modules/task/interfaces/ITaskRepository.java

@@ -0,0 +1,17 @@
+package backend.challenge.modules.task.interfaces;
+
+import backend.challenge.modules.task.dtos.TaskDTO;
+import backend.challenge.modules.task.dtos.TaskProgressDTO;
+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);
+	void delete(Long taskId);
+	Task updateProgress(TaskProgressDTO taskProgressDTO);
+}

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

@@ -0,0 +1,109 @@
+package backend.challenge.modules.task.repositories;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.inject.Singleton;
+
+import backend.challenge.modules.task.dtos.TaskDTO;
+import backend.challenge.modules.task.dtos.TaskProgressDTO;
+import backend.challenge.modules.task.enums.TaskStatus;
+import backend.challenge.modules.task.exceptions.DeleteException;
+import backend.challenge.modules.task.exceptions.UpdateException;
+import backend.challenge.modules.task.factories.TaskFactory;
+import backend.challenge.modules.task.interfaces.ITaskRepository;
+import backend.challenge.modules.task.models.Task;
+
+@Singleton
+public class TaskRepository implements ITaskRepository {
+
+	private static final String UPDATE_MESSAGE_ERROR = "An error occurred while trying to update this Task. Please contact technical support for more details!";
+	private static final String DELETE_MESSAGE_ERROR = "An error occurred while trying to delete this Task. Please contact technical support for more details!";
+	private static final int MAX_PROGRESS = 100;
+	private List<Task> tasks = new ArrayList<>();
+	@Override
+	public Task index(final Long taskId) {
+		List<Task> atualTasks = this.tasks.stream().filter(atualTask -> atualTask.getId().equals(taskId)).collect(Collectors.toList());
+		return atualTasks != null && !atualTasks.isEmpty() ? atualTasks.get(0) : null;
+	}
+
+	@Override
+	public List<Task> show() {
+		return this.tasks != null ? this.tasks : new ArrayList<>();
+	}
+
+	@Override
+	public Task create(final TaskDTO taskDTO) {
+		Task task = new TaskFactory().build(taskDTO);
+		this.tasks.add(task);
+		return task;
+	}
+
+	@Override
+	public Task update(final Task task) throws UpdateException {
+		Task atualTask = this.index(task.getId());
+		if(atualTask != null)
+		{
+			atualTask.setTitle(task.getTitle());
+			atualTask.setDescription(task.getDescription());
+		}
+		else
+		{
+			throw new UpdateException(UPDATE_MESSAGE_ERROR);
+		}
+		return atualTask;
+	}
+
+	@Override
+	public void delete(final Long taskId) {
+		Task task = this.index(taskId);
+		if(task != null)
+		{
+			this.tasks.remove(task);
+		}
+		else
+		{
+			throw new DeleteException(DELETE_MESSAGE_ERROR);
+		}
+	}
+
+	@Override
+	public Task updateProgress(TaskProgressDTO taskProgressDTO) {
+		Task task = this.index(taskProgressDTO.getId());
+		if(task != null)
+		{
+			if(checkMaxProgress(taskProgressDTO.getProgress()))
+			{
+				updateProgress(task, MAX_PROGRESS);
+				updateStatus(task, TaskStatus.COMPLETE);
+			}
+			else
+			{
+				updateProgress(task, taskProgressDTO.getProgress());
+				updateStatus(task, TaskStatus.PROGRESS);
+			}
+		}
+		else
+		{
+			throw new UpdateException(UPDATE_MESSAGE_ERROR);
+		}
+		return task;
+	}
+
+	private boolean checkMaxProgress(int progress)
+	{
+		if(progress >= MAX_PROGRESS) return true;
+		return false;
+	}
+
+	private void updateProgress(Task task, int progress)
+	{
+		task.setProgress(progress);
+	}
+	private void updateStatus(Task task, TaskStatus taskStatus)
+	{
+		task.setStatus(taskStatus);
+	}
+
+}