diff --git a/.idea/libraries/gson_2_9_0.xml b/.idea/libraries/gson_2_9_0.xml new file mode 100644 index 0000000..2377008 --- /dev/null +++ b/.idea/libraries/gson_2_9_0.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml index 5a454e3..5e2ea00 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,4 +1,3 @@ - diff --git a/java-kanban.iml b/java-kanban.iml index 6e05be3..697460d 100644 --- a/java-kanban.iml +++ b/java-kanban.iml @@ -35,5 +35,6 @@ + \ No newline at end of file diff --git a/resources/text.txt b/resources/text.txt index e6a3638..cea0305 100644 --- a/resources/text.txt +++ b/resources/text.txt @@ -2,4 +2,4 @@ id,type,name,status,description,epic 1,TASK,задача_5,NEW,описание задачи_5,2025.03.04 10:50:24,15 2,TASK,задача_6,NEW,описание задачи_6,2025.03.04 10:50:24,25 3,EPIC,эпик_7,NEW,описание эпик_7,2025.03.04 10:50:24,25 -4,EPIC,эпик_8,NEW,описание эпик_8,2025.03.04 10:50:24,25 +4,EPIC,эпик_8,NEW,описание эпик_8,2025.03.04 10:50:24,25 \ No newline at end of file diff --git a/src/Main.java b/src/Main.java index c35ecb7..aadc508 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,4 +1,4 @@ -import managers.FileBackedTaskManager; +/* import managers.FileBackedTaskManager; import managers.InMemoryTaskManager; import managers.Managers; import tasks.Epic; @@ -7,13 +7,14 @@ import util.Status; import java.io.File; +import java.io.IOException; import java.time.LocalDateTime; import static managers.FileBackedTaskManager.loadFromFile; public class Main { - public static void main(String[] args) { + public static void main(String[] args) throws IOException { String home = System.getProperty("user.dir"); home += "\\resources\\"; @@ -24,14 +25,16 @@ public static void main(String[] args) { SubTask subTask1 = new SubTask("subtask1", "подзадача epic3", 3, LocalDateTime.now().plusHours(5), 25); SubTask subTask2 = new SubTask("subtask2", "подзадача epic3", 3, LocalDateTime.now().plusHours(10), 225); SubTask subTask3 = new SubTask("subtask3", "подзадача epic3", 3, LocalDateTime.now().plusHours(6), 25); + + // загрузка существуещего файла с добавлением в него Задач - FileBackedTaskManager fileBackedTaskManager = (loadFromFile(new File(home + "text.txt"))); + FileBackedTaskManager fileBackedTaskManager = (loadFromFile(new File(home + "text.txt"))); fileBackedTaskManager.newTack(task1); fileBackedTaskManager.newTack(task2); fileBackedTaskManager.newEpic(epic1); fileBackedTaskManager.newEpic(epic2); printAllTasks(fileBackedTaskManager); - // создание нового файла с задачами*/ + // создание нового файла с задачами FileBackedTaskManager fileBackedTaskManager2 = new FileBackedTaskManager(Managers.getDefaultHistory(), home + "text2.txt"); fileBackedTaskManager2.newTack(task1); @@ -43,11 +46,17 @@ public static void main(String[] args) { fileBackedTaskManager2.newSubTask(subTask3); printAllTasks(fileBackedTaskManager2); System.out.println("________________"); + + Task task3 = new Task("задача_6", "описание задачи_5", LocalDateTime.now(), 15); + Epic epic3 = new Epic("эпик_9", "описание эпик_8"); + fileBackedTaskManager2.newTack(task3); + fileBackedTaskManager2.newEpic(epic3); + fileBackedTaskManager2.clearEpicList(); + printAllTasks(fileBackedTaskManager2); fileBackedTaskManager2.getToIdTask(1); fileBackedTaskManager2.getToIdSubTask(5); fileBackedTaskManager2.getToIdEpic(3); task1.setStatus(Status.IN_PROGRESS); - task1.setStartTime(LocalDateTime.now()); fileBackedTaskManager2.updateTask(1, task1); subTask3.setStartTime(LocalDateTime.now().plusMinutes(30)); fileBackedTaskManager2.updateSubTask(7, subTask3); @@ -55,30 +64,32 @@ public static void main(String[] args) { printAllTasks(fileBackedTaskManager2); } - private static void printAllTasks(InMemoryTaskManager manager) { + + private static void printAllTasks(InMemoryTaskManager inMemoryTaskManager) { System.out.println("Задачи:"); - for (Task task : manager.getTasks()) { + for (Task task : inMemoryTaskManager.getTasks()) { System.out.println(task); } System.out.println("Эпики:"); - for (Task epic : manager.getEpic()) { + for (Task epic : inMemoryTaskManager.getEpic()) { System.out.println(epic); - for (Task task : manager.getToIdSubtaskInEpic(epic.getId())) { + for (Task task : inMemoryTaskManager.getToIdSubtaskInEpic(epic.getId())) { System.out.println("--> " + task); } } System.out.println("Подзадачи:"); - for (Task subtask : manager.getSubTask()) { + for (Task subtask : inMemoryTaskManager.getSubTask()) { System.out.println(subtask); } System.out.println("История:"); - for (Task task : manager.getHistory()) { + for (Task task : inMemoryTaskManager.getHistory()) { System.out.println(task); } System.out.println("задачи по времени:"); - for (Task task : manager.getPrioritizedTasks()) { + for (Task task : inMemoryTaskManager.getPrioritizedTasks()) { System.out.println(task); } } } +*/ \ No newline at end of file diff --git a/src/exceptions/ManagerSaveException.java b/src/exceptions/ManagerSaveException.java index fcc8f73..2faa959 100644 --- a/src/exceptions/ManagerSaveException.java +++ b/src/exceptions/ManagerSaveException.java @@ -5,5 +5,4 @@ public class ManagerSaveException extends RuntimeException { public ManagerSaveException(final String message) { super(message); } - } diff --git a/src/http/HttpTaskServer.java b/src/http/HttpTaskServer.java new file mode 100644 index 0000000..e5d2f45 --- /dev/null +++ b/src/http/HttpTaskServer.java @@ -0,0 +1,66 @@ +package http; + +import com.sun.net.httpserver.HttpServer; +import http.handler.*; +import managers.Managers; +import managers.TaskManager; +import tasks.Epic; +import tasks.SubTask; +import tasks.Task; + +import java.io.IOException; +import java.net.InetSocketAddress; +import java.time.LocalDateTime; + +public class HttpTaskServer { + public static final int PORT = 8080; + public final HttpServer httpServer; + + public final TaskManager manager; + + public HttpTaskServer(TaskManager manager) throws IOException { + + this.manager = manager; + + httpServer = HttpServer.create(new InetSocketAddress("localhost", PORT), 0); + httpServer.createContext("/tasks", new TaskHttpHandler(manager)); + httpServer.createContext("/subtasks", new SubTaskHandler(manager)); + httpServer.createContext("/epics", new EpicTaskHandler(manager)); + httpServer.createContext("/history", new HistoryHandler(manager)); + httpServer.createContext("/prioritized", new PrioritizedHandler(manager)); + } + + public void start() { + httpServer.start(); + System.out.println("старт сервера на порту:" + PORT); + } + + public void stop() { + httpServer.stop(0); + System.out.println("остановка сервера на порту:" + PORT); + } + + public static void main(String[] args) throws IOException { + + Task task1 = new Task("задача_5", "описание задачи_5", LocalDateTime.now().plusHours(2), 15); + Task task2 = new Task("задача_6", "описание задачи_6", LocalDateTime.now().plusHours(1), 25); + Epic epic1 = new Epic("эпик_7", "описание эпик_7"); + Epic epic2 = new Epic("эпик_8", "описание эпик_8"); + SubTask subTask1 = new SubTask("subtask1", "подзадача epic3", 3, LocalDateTime.now().plusHours(5), 25); + SubTask subTask2 = new SubTask("subtask2", "подзадача epic3", 3, LocalDateTime.now().plusHours(10), 225); + SubTask subTask3 = new SubTask("subtask3", "подзадача epic3", 3, LocalDateTime.now().plusHours(6), 25); + + TaskManager manager = Managers.getDefault(); + + manager.newTack(task1); + manager.newTack(task2); + manager.newEpic(epic1); + manager.newEpic(epic2); + manager.newSubTask(subTask1); + manager.newSubTask(subTask2); + manager.newSubTask(subTask3); + + HttpTaskServer taskServer = new HttpTaskServer(manager); + taskServer.start(); + } +} diff --git a/src/http/LocalDataTimeAdapter.java b/src/http/LocalDataTimeAdapter.java new file mode 100644 index 0000000..410aa48 --- /dev/null +++ b/src/http/LocalDataTimeAdapter.java @@ -0,0 +1,23 @@ +package http; + +import com.google.gson.TypeAdapter; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +import java.io.IOException; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; + +public class LocalDataTimeAdapter extends TypeAdapter { + private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm:ss"); + + @Override + public void write(final JsonWriter jsonWriter, final LocalDateTime localDate) throws IOException { + jsonWriter.value(localDate.format(formatter)); + } + + @Override + public LocalDateTime read(final JsonReader jsonReader) throws IOException { + return LocalDateTime.parse(jsonReader.nextString(), formatter); + } +} \ No newline at end of file diff --git a/src/http/handler/BaseHttpHandler.java b/src/http/handler/BaseHttpHandler.java new file mode 100644 index 0000000..404544d --- /dev/null +++ b/src/http/handler/BaseHttpHandler.java @@ -0,0 +1,67 @@ +package http.handler; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.sun.net.httpserver.HttpExchange; +import http.LocalDataTimeAdapter; +import managers.TaskManager; + +import java.io.IOException; +import java.io.OutputStream; +import java.nio.charset.StandardCharsets; +import java.time.LocalDateTime; + +public class BaseHttpHandler { + + protected TaskManager manager; + protected Gson gson; + + protected String readText(HttpExchange httpExchange) throws IOException { + return new String(httpExchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8); + } + + protected void sendText(HttpExchange httpExchange, String text) throws IOException { + byte[] result = text.getBytes(StandardCharsets.UTF_8); + httpExchange.getResponseHeaders().add("Content-Type", "application/json;charset=utf-8"); + httpExchange.sendResponseHeaders(200, result.length); + OutputStream os = httpExchange.getResponseBody(); + os.write(result); + httpExchange.close(); + } + + protected void sendNotFound(HttpExchange httpExchange) throws IOException { + httpExchange.sendResponseHeaders(404, 0); + httpExchange.close(); + } + + protected void sendHasInteractions(HttpExchange httpExchange) throws IOException { + httpExchange.sendResponseHeaders(406, 0); + httpExchange.close(); + } + + protected void sendOk(HttpExchange httpExchange) throws IOException { + httpExchange.sendResponseHeaders(201, 0); + httpExchange.close(); + } + + protected void sendErr(HttpExchange httpExchange) throws IOException { + httpExchange.sendResponseHeaders(500, 0); + httpExchange.close(); + } + + protected void sendBadRequest(HttpExchange httpExchange) throws IOException { + httpExchange.sendResponseHeaders(400, 0); + httpExchange.close(); + } + + protected void sendMethodNotAllowed(HttpExchange httpExchange) throws IOException { + httpExchange.sendResponseHeaders(405, 0); + httpExchange.close(); + } + + public static Gson getGson() { + GsonBuilder gsonBuilder = new GsonBuilder(); + gsonBuilder.registerTypeAdapter(LocalDateTime.class, new LocalDataTimeAdapter()); + return gsonBuilder.create(); + } +} diff --git a/src/http/handler/EpicTaskHandler.java b/src/http/handler/EpicTaskHandler.java new file mode 100644 index 0000000..a535acf --- /dev/null +++ b/src/http/handler/EpicTaskHandler.java @@ -0,0 +1,111 @@ +package http.handler; + +import com.sun.net.httpserver.HttpExchange; +import com.sun.net.httpserver.HttpHandler; +import exceptions.ManagerException; +import managers.TaskManager; +import tasks.Epic; +import tasks.SubTask; + +import java.io.IOException; +import java.util.List; + +public class EpicTaskHandler extends BaseHttpHandler implements HttpHandler { + + public EpicTaskHandler(TaskManager manager) { + this.manager = manager; + gson = getGson(); + } + + public Integer getIdFromPath(String path) { + String[] paths = path.split("/"); + if (paths.length > 2) + return Integer.parseInt(paths[2]); + else return null; + } + + @Override + public void handle(HttpExchange httpExchange) throws IOException { + final String path = httpExchange.getRequestURI().getPath(); + final Integer idPath = getIdFromPath(path); + final String method = httpExchange.getRequestMethod(); + switch (method) { + case ("GET"): { + if ((path.split("/").length > 3)) + sendMethodNotAllowed(httpExchange); + else { + if (idPath == null) { + List epics = manager.getEpic(); + String response = gson.toJson(epics); + sendText(httpExchange, response); + System.out.println("возвращаем все епики"); + return; + } + Epic epic = manager.getToIdEpic(idPath); + if (epic != null) { + if ((path.split("/").length > 3) && (path.split("/")[3].equals("subtasks"))) { + List subTaskList = manager.getToIdSubtaskInEpic(idPath); + String response = gson.toJson(subTaskList); + sendText(httpExchange, response); + System.out.println("возвращаем список подзадачть по епик id= " + idPath); + } else if (path.split("/").length == 3) { + String response = gson.toJson(epic); + sendText(httpExchange, response); + System.out.println("возвращаем епик " + idPath); + } else { + sendMethodNotAllowed(httpExchange); + System.out.println("нет такого действия"); + } + + } else { + sendNotFound(httpExchange); + System.out.println("епик id=" + idPath + " нет"); + } + + } + sendMethodNotAllowed(httpExchange); + break; + } + case ("POST"): { + if (idPath == null) { + String json = readText(httpExchange); + Epic epic = gson.fromJson(json, Epic.class); + final int id = epic.getId(); + if (id > 0) { + System.out.println("обновлять епик нельзя"); + sendNotFound(httpExchange); + } else + try { + manager.newEpic(epic); + System.out.println("Епик создан"); + sendOk(httpExchange); + } catch (ManagerException e) { + System.out.println("пересекается с существующими"); + sendHasInteractions(httpExchange); + } + } else { + System.out.println("нет такого действия"); + sendMethodNotAllowed(httpExchange); + } + break; + } + case ("DELETE"): { + if (idPath == null) { + manager.clearEpicList(); + System.out.println("удалили все Епики"); + sendText(httpExchange, "все задачи(Епик) удалены"); + return; + } else { + if (manager.getToIdEpic(idPath) != null) { + manager.removeToIdEpic(idPath); + System.out.println("удалили Епик id= " + idPath); + sendText(httpExchange, "удалена задача id= " + idPath); + } else + sendNotFound(httpExchange); + } + } + default: + sendBadRequest(httpExchange); + } + } +} diff --git a/src/http/handler/HistoryHandler.java b/src/http/handler/HistoryHandler.java new file mode 100644 index 0000000..832b628 --- /dev/null +++ b/src/http/handler/HistoryHandler.java @@ -0,0 +1,33 @@ +package http.handler; + +import com.sun.net.httpserver.HttpExchange; +import com.sun.net.httpserver.HttpHandler; +import managers.TaskManager; +import tasks.Task; + +import java.io.IOException; +import java.util.List; + +public class HistoryHandler extends BaseHttpHandler implements HttpHandler { + + public HistoryHandler(TaskManager manager) { + this.manager = manager; + this.gson = getGson(); + } + + @Override + public void handle(HttpExchange httpExchange) throws IOException { + final String path = httpExchange.getRequestURI().getPath(); + final String method = httpExchange.getRequestMethod(); + switch (method) { + case ("GET"): { + List historyList = manager.getHistory(); + String repsone = gson.toJson(historyList); + sendText(httpExchange, repsone); + System.out.println("выводим историю"); + } + default: + sendMethodNotAllowed(httpExchange); + } + } +} diff --git a/src/http/handler/PrioritizedHandler.java b/src/http/handler/PrioritizedHandler.java new file mode 100644 index 0000000..41cc44c --- /dev/null +++ b/src/http/handler/PrioritizedHandler.java @@ -0,0 +1,33 @@ +package http.handler; + +import com.sun.net.httpserver.HttpExchange; +import com.sun.net.httpserver.HttpHandler; +import managers.TaskManager; +import tasks.Task; + +import java.io.IOException; +import java.util.List; + +public class PrioritizedHandler extends BaseHttpHandler implements HttpHandler { + + public PrioritizedHandler(TaskManager manager) { + this.manager = manager; + this.gson = getGson(); + } + + @Override + public void handle(HttpExchange httpExchange) throws IOException { + final String path = httpExchange.getRequestURI().getPath(); + final String method = httpExchange.getRequestMethod(); + switch (method) { + case ("GET"): { + List priritizedList = manager.getPrioritizedTasks(); + String repsone = gson.toJson(priritizedList); + sendText(httpExchange, repsone); + System.out.println("выводим задачи по приоритету"); + } + default: + sendMethodNotAllowed(httpExchange); + } + } +} diff --git a/src/http/handler/SubTaskHandler.java b/src/http/handler/SubTaskHandler.java new file mode 100644 index 0000000..7363906 --- /dev/null +++ b/src/http/handler/SubTaskHandler.java @@ -0,0 +1,99 @@ +package http.handler; + +import com.sun.net.httpserver.HttpExchange; +import com.sun.net.httpserver.HttpHandler; +import exceptions.ManagerException; +import managers.TaskManager; +import tasks.SubTask; + +import java.io.IOException; +import java.util.List; + + +public class SubTaskHandler extends BaseHttpHandler implements HttpHandler { + + public SubTaskHandler(TaskManager manager) { + this.manager = manager; + gson = getGson(); + } + + public Integer getIdFromPath(String path) { + String[] paths = path.split("/"); + if (paths.length > 2) + return Integer.parseInt(paths[2]); + else return null; + } + + @Override + public void handle(HttpExchange httpExchange) throws IOException { + final String path = httpExchange.getRequestURI().getPath(); + final Integer idPath = getIdFromPath(path); + final String method = httpExchange.getRequestMethod(); + switch (method) { + case ("GET"): { + if ((path.split("/").length > 3)) + sendMethodNotAllowed(httpExchange); + else { + if (idPath == null) { + List subTask = manager.getSubTask(); + String response = gson.toJson(subTask); + sendText(httpExchange, response); + System.out.println("возвращаем все саптаски"); + return; + } + SubTask subTasktask = manager.getToIdSubTask(idPath); + if (subTasktask != null) { + String response = gson.toJson(subTasktask); + sendText(httpExchange, response); + System.out.println("возвращаем саптаску " + idPath); + } else { + sendNotFound(httpExchange); + System.out.println("саптаски id=" + idPath + " нет"); + } + } + sendMethodNotAllowed(httpExchange); + break; + } + case ("POST"): { + if (idPath == null) { + String json = readText(httpExchange); + SubTask subTask = gson.fromJson(json, SubTask.class); + final int id = subTask.getId(); + if (id > 0) { + manager.updateSubTask(id, subTask); + System.out.println("обновили саптаску id=" + id); + sendOk(httpExchange); + } else + try { + manager.newSubTask(subTask); + System.out.println("подзадача создана"); + sendOk(httpExchange); + } catch (ManagerException e) { + System.out.println("пересекается с существующими"); + sendHasInteractions(httpExchange); + } + } else + sendMethodNotAllowed(httpExchange); + break; + } + case ("DELETE"): { + if (idPath == null) { + manager.clearSubTaskList(); + System.out.println("удалили все саптаски"); + sendText(httpExchange, "все подзадачи удалены"); + return; + } else { + if (manager.getToIdSubTask(idPath) != null) { + manager.removeToIdSubTask(idPath); + System.out.println("удалили саптаску id= " + idPath); + sendText(httpExchange, "удалена подзадача id= " + idPath); + } else + sendMethodNotAllowed(httpExchange); + } + break; + } + default: + sendBadRequest(httpExchange); + } + } +} diff --git a/src/http/handler/TaskHttpHandler.java b/src/http/handler/TaskHttpHandler.java new file mode 100644 index 0000000..b0f1e77 --- /dev/null +++ b/src/http/handler/TaskHttpHandler.java @@ -0,0 +1,100 @@ +package http.handler; + +import com.sun.net.httpserver.HttpExchange; +import com.sun.net.httpserver.HttpHandler; +import exceptions.ManagerException; +import managers.TaskManager; +import tasks.Task; + +import java.io.IOException; +import java.util.List; + + +public class TaskHttpHandler extends BaseHttpHandler implements HttpHandler { + + public TaskHttpHandler(TaskManager manager) { + this.manager = manager; + gson = getGson(); + } + + public Integer getIdFromPath(String path) { + String[] paths = path.split("/"); + if (paths.length > 2) + return Integer.parseInt(paths[2]); + else return null; + } + + @Override + public void handle(HttpExchange httpExchange) throws IOException { + final String path = httpExchange.getRequestURI().getPath(); + final Integer idPath = getIdFromPath(path); + final String method = httpExchange.getRequestMethod(); + switch (method) { + case ("GET"): { + if ((path.split("/").length > 3)) + sendMethodNotAllowed(httpExchange); + else { + if (idPath == null) { + List tasks = manager.getTasks(); + String response = gson.toJson(tasks); + sendText(httpExchange, response); + System.out.println("возвращаем все таски"); + return; + } + Task task = manager.getToIdTask(idPath); + if (task != null) { + String response = gson.toJson(task); + sendText(httpExchange, response); + System.out.println("возвращаем таску " + idPath); + } else { + sendNotFound(httpExchange); + System.out.println("таска id=" + idPath + " нет"); + } + } + break; + } + case ("POST"): { + if (idPath == null) { + String json = readText(httpExchange); + Task task = gson.fromJson(json, Task.class); + final int id = task.getId(); + if (id > 0) { + manager.updateTask(id, task); + System.out.println("обновили таску id=" + id); + sendOk(httpExchange); + } else + try { + manager.newTack(task); + System.out.println("Задача создана"); + sendOk(httpExchange); + } catch (ManagerException e) { + System.out.println("пересекается с существующими"); + sendHasInteractions(httpExchange); + } + } else { + sendMethodNotAllowed(httpExchange); + } + break; + } + case ("DELETE"): { + if (idPath == null) { + manager.clearTaskList(); + System.out.println("удалили все таски"); + sendText(httpExchange, "все задачи удалены"); + return; + } else { + if (manager.getToIdTask(idPath) != null) { + manager.removeToIdTask(idPath); + System.out.println("удалили таску id= " + idPath); + sendText(httpExchange, "удалена задача id= " + idPath); + } else + sendNotFound(httpExchange); + } + break; + } + default: + sendBadRequest(httpExchange); + } + } +} + diff --git a/src/managers/FileBackedTaskManager.java b/src/managers/FileBackedTaskManager.java index 667587c..848de4e 100644 --- a/src/managers/FileBackedTaskManager.java +++ b/src/managers/FileBackedTaskManager.java @@ -37,6 +37,7 @@ public FileBackedTaskManager(HistoryManager historyManager, String file) { public void newTack(Task task) { super.newTack(task); save(); + } @Override diff --git a/src/managers/InMemoryTaskManager.java b/src/managers/InMemoryTaskManager.java index 814b43e..72b4748 100644 --- a/src/managers/InMemoryTaskManager.java +++ b/src/managers/InMemoryTaskManager.java @@ -79,7 +79,13 @@ public void removeToIdTask(int id) { // удаление task по id @Override public void updateTask(int id, Task task) { // передача обновленого task по id if (id != 0 && task != null && taskMaps.containsKey(id)) { - prioritizedTasks.remove(task); + List tempPrioritizedTasks = new ArrayList<>(prioritizedTasks); + prioritizedTasks.clear(); + tempPrioritizedTasks + .forEach(task1 -> { + if (task1.getId() != id) + addPrioritizedTasks(task1); + }); addPrioritizedTasks(task); taskMaps.put(id, task); } @@ -290,7 +296,8 @@ public Boolean validity(Task task) { // валидатность при else { return getPrioritizedTasks().stream() .anyMatch(task1 -> { - return (task1.getStartTime().isBefore(startTaskTime) && task1.getEndTime().isAfter(endTaskTime)) || + return (task1.getStartTime().isEqual(startTaskTime) && task1.getEndTime().isEqual(endTaskTime) || + task1.getStartTime().isBefore(startTaskTime) && task1.getEndTime().isAfter(endTaskTime)) || (task1.getStartTime().isAfter(startTaskTime) && task1.getEndTime().isBefore(endTaskTime)) || (task1.getStartTime().isBefore(startTaskTime) && task1.getEndTime().isAfter(startTaskTime)) || (task1.getStartTime().isBefore(endTaskTime) && task1.getEndTime().isAfter(endTaskTime)); diff --git a/src/tasks/Epic.java b/src/tasks/Epic.java index 447c41b..d2b51cf 100644 --- a/src/tasks/Epic.java +++ b/src/tasks/Epic.java @@ -12,14 +12,15 @@ public class Epic extends Task { private LocalDateTime endTime; + public Epic(String name, String description) { super(name, description); this.status = Status.NEW; this.listSubTaskId = new ArrayList<>(); this.type = Type.EPIC; - this.startTime = LocalDateTime.MAX; + this.startTime = LocalDateTime.of(0000, 01, 01, 01, 01, 00); this.duration = 0; - this.endTime = LocalDateTime.MIN; + this.endTime = LocalDateTime.of(9999, 01, 01, 01, 01, 00); } public Epic(int id, Type type, String name, Status status, String description) { @@ -46,7 +47,8 @@ public void removeValueListSubTask(Integer value) { } public void clearListSubTask() { - listSubTaskId.clear(); + if (!listSubTaskId.isEmpty()) + listSubTaskId.clear(); } @Override @@ -67,7 +69,7 @@ public String toString() { ", id=" + getId() + ", status=" + status + ", listSubTaskId=" + listSubTaskId.toString() + - ", startTime=" + startTime.format(formatter) + + ", startTime=" + startTime.format(getFormatter()) + ", duration=" + duration + "}" + '\n'; } diff --git a/src/tasks/SubTask.java b/src/tasks/SubTask.java index 78f8e36..32630fb 100644 --- a/src/tasks/SubTask.java +++ b/src/tasks/SubTask.java @@ -38,7 +38,7 @@ public int getEpicId() { @Override public String toStringInFile() { - return String.format("%s,%s,%s,%s,%s,%s,%s,%s", id, type, name, status, description, startTime.format(formatter), duration, epicId); + return String.format("%s,%s,%s,%s,%s,%s,%s,%s", id, type, name, status, description, startTime.format(getFormatter()), duration, epicId); } @Override @@ -49,7 +49,7 @@ public String toString() { ", description='" + getDescription() + '\'' + ", id=" + getId() + ", status=" + status + - ", startTime=" + startTime.format(formatter) + + ", startTime=" + startTime.format(getFormatter()) + ", duration=" + duration + ", epicId=" + epicId + "} " + '\n'; diff --git a/src/tasks/Task.java b/src/tasks/Task.java index a449c2d..37f987f 100644 --- a/src/tasks/Task.java +++ b/src/tasks/Task.java @@ -17,7 +17,10 @@ public class Task { protected long duration; // minuts - protected final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm:ss"); + protected DateTimeFormatter getFormatter() { + return DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm:ss"); + } + // DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm:ss"); public Task(String name, String description) { @@ -115,7 +118,7 @@ public LocalDateTime getEndTime() { } public String toStringInFile() { - return String.format("%s,%s,%s,%s,%s,%s,%s", id, type, name, status, description, startTime.format(formatter), duration); + return String.format("%s,%s,%s,%s,%s,%s,%s", id, type, name, status, description, startTime.format(getFormatter()), duration); } @Override @@ -126,7 +129,7 @@ public String toString() { ", description='" + description + '\'' + ", id=" + id + ", status=" + status + - ", startTime=" + startTime.format(formatter) + + ", startTime=" + startTime.format(getFormatter()) + ", duration=" + duration + "}" + '\n'; } diff --git a/test/http/HttpTaskManagerEpicTest.java b/test/http/HttpTaskManagerEpicTest.java new file mode 100644 index 0000000..dde3a1b --- /dev/null +++ b/test/http/HttpTaskManagerEpicTest.java @@ -0,0 +1,248 @@ +package http; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import http.handler.BaseHttpHandler; +import managers.InMemoryHistoryManager; +import managers.InMemoryTaskManager; +import managers.TaskManager; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tasks.Epic; +import tasks.SubTask; + +import java.io.IOException; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.time.LocalDateTime; +import java.util.List; + +public class HttpTaskManagerEpicTest { + TaskManager taskManager = new InMemoryTaskManager(new InMemoryHistoryManager()); + HttpTaskServer httpTaskServer = new HttpTaskServer(taskManager); + Gson gson = BaseHttpHandler.getGson(); + + public HttpTaskManagerEpicTest() throws IOException { + } + + @BeforeEach + public void setUp() { + taskManager.clearTaskList(); + taskManager.clearTaskList(); + taskManager.clearEpicList(); + httpTaskServer.start(); + } + + @AfterEach + public void setDown() { + httpTaskServer.stop(); + } + + class UserListTypeToken extends TypeToken> { + } + + @Test + public void addEpic() throws IOException, InterruptedException { + // cоздаем таску для отпрвки на сервер + Epic epic = new Epic("Epic 1", "test epic1"); + String jsonEpic = gson.toJson(epic); + //создаем http клиента + HttpClient client = HttpClient.newHttpClient(); + URI uri = URI.create("http://localhost:8080/epics"); + //создраем запрос + HttpRequest request = HttpRequest.newBuilder() + .uri(uri) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic)) + .build(); + //отправяем запрос, получаем в ответ код + HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); + //проверем значения + Assertions.assertEquals(201, response.statusCode(), "Не верный код ответа"); + List allTasks = taskManager.getEpic(); + Assertions.assertNotNull(allTasks, "задача не добавилась"); + Assertions.assertEquals(1, allTasks.size(), "колличество задач не совпадает"); + } + + @Test + public void getEpic() throws IOException, InterruptedException { + + HttpClient client = HttpClient.newHttpClient(); + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics/1")) + .GET() + .build(); + + HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(404, response.statusCode(), "не верный код ответа"); + + Epic epic = new Epic("Epic 1", "test epic1"); + String jsonEpic = gson.toJson(epic); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic)) + .build(); + + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics/1")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Epic epicFromJson = gson.fromJson(response.body(), Epic.class); + Assertions.assertEquals(200, response.statusCode(), "не верный код ответа"); + Assertions.assertEquals(taskManager.getToIdEpic(1), epicFromJson, "не совпали Epic"); + + //проверяем на несуществующую Епик + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics/121")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(404, response.statusCode(), "не верный код ответа"); + } + + @Test + public void getAllEpic() throws IOException, InterruptedException { + HttpResponse response; + HttpRequest request; + Epic epic1 = new Epic("epic 1", "test epic1"); + String jsonEpic1 = gson.toJson(epic1); + Epic epic2 = new Epic("epic 2", "test epic2"); + String jsonEpic2 = gson.toJson(epic2); + + + //пустой запрос всех epic + HttpClient client = HttpClient.newHttpClient(); + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals("[]", response.body(), "вернулся не пустой список задач"); + + // добавлеям epic + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic2)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + // проверяем возращение списка из всех тасков + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + List allEpic = gson.fromJson(response.body(), new HttpTaskManagerEpicTest.UserListTypeToken().getType()); + Assertions.assertEquals(taskManager.getEpic().size(), allEpic.size(), + "не свопадает количество записей"); + } + + @Test + public void getSubtaskToEpicId() throws IOException, InterruptedException { + HttpResponse response; + HttpRequest request; + HttpClient client = HttpClient.newHttpClient(); + + Epic epic1 = new Epic("epic 1", "test epic1"); + String jsonEpic1 = gson.toJson(epic1); + SubTask subTask1 = new SubTask("test subtask1_1", "subtask1 descriprion", 1, + LocalDateTime.of(2025, 01, 01, 03, 00, 00), 25); + SubTask subTask2 = new SubTask("test subtask1_1", "subtask1 descriprion", 1, + LocalDateTime.of(2025, 02, 01, 03, 00, 00), 25); + String jsonSubTask1 = gson.toJson(subTask1); + String jsonSubTask2 = gson.toJson(subTask2); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask2)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + List allSubtaskToEpicId = gson.fromJson(response.body(), new UserListTypeToken().getType()); + Assertions.assertEquals(allSubtaskToEpicId.size(), taskManager.getToIdSubtaskInEpic(1).size(), + "количество не совпало"); + } + + @Test + public void deleteEpic() throws IOException, InterruptedException { + HttpResponse response; + HttpRequest request; + + Epic epic1 = new Epic("epic 1", "test epic1"); + String jsonEpic1 = gson.toJson(epic1); + Epic epic2 = new Epic("epic 2", "test epic2"); + String jsonEpic2 = gson.toJson(epic2); + Epic epic3 = new Epic("epic 3", "test epic3"); + String jsonEpic3 = gson.toJson(epic3); + HttpClient client = HttpClient.newHttpClient(); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic2)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic3)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + //удаляем 1 epic + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics/2")) + .DELETE() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode()); + Assertions.assertEquals(taskManager.getEpic().size(), 2, "не удалилась задача"); + + // удаляем все задачи + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .DELETE() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode()); + Assertions.assertEquals(taskManager.getEpic().size(), 0, "не удалилась задача"); + } + + +} diff --git a/test/http/HttpTaskManagerGetListTest.java b/test/http/HttpTaskManagerGetListTest.java new file mode 100644 index 0000000..95c9402 --- /dev/null +++ b/test/http/HttpTaskManagerGetListTest.java @@ -0,0 +1,115 @@ +package http; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import http.handler.BaseHttpHandler; +import managers.InMemoryHistoryManager; +import managers.InMemoryTaskManager; +import managers.TaskManager; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tasks.Epic; +import tasks.SubTask; +import tasks.Task; + +import java.io.IOException; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.time.LocalDateTime; +import java.util.List; + +public class HttpTaskManagerGetListTest { + + TaskManager taskManager = new InMemoryTaskManager(new InMemoryHistoryManager()); + HttpTaskServer httpTaskServer = new HttpTaskServer(taskManager); + Gson gson = BaseHttpHandler.getGson(); + + public HttpTaskManagerGetListTest() throws IOException { + } + + @BeforeEach + public void setUp() { + taskManager.clearTaskList(); + taskManager.clearTaskList(); + taskManager.clearEpicList(); + httpTaskServer.start(); + } + + @AfterEach + public void setDown() { + httpTaskServer.stop(); + } + + class UserListTypeToken extends TypeToken> { + } + + HttpResponse response; + HttpRequest request; + HttpClient client = HttpClient.newHttpClient(); + final Task task = new Task("Task 1", "test task1", LocalDateTime.now(), 25); + + final Epic epic1 = new Epic("epic 1", "test epic1"); + + final SubTask subTask1 = new SubTask("test subtask1_1", "subtask1 descriprion", 2, + LocalDateTime.of(2025, 01, 01, 03, 00, 00), 25); + final SubTask subTask2 = new SubTask("test subtask1_1", "subtask1 descriprion", 2, + LocalDateTime.of(2025, 02, 01, 03, 00, 00), 25); + + @Test + public void GetHistoryList() throws IOException, InterruptedException { + taskManager.newTack(task); + taskManager.newEpic(epic1); + taskManager.newSubTask(subTask1); + taskManager.newSubTask(subTask2); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/history")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode(), "вернулся не правильный код"); + Assertions.assertEquals("[]", response.body(), "вернулся не пустой список задач"); + + taskManager.getToIdTask(1); + taskManager.getToIdSubTask(3); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/history")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode(), "вернулся не правильный код"); + List allTaskHistory = gson.fromJson(response.body(), new UserListTypeToken().getType()); + Assertions.assertEquals(taskManager.getHistory().size(), allTaskHistory.size(), "вернулся не пустой список задач"); + } + + @Test + public void GetPrioritizedList() throws IOException, InterruptedException { + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/prioritized")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode(), "вернулся не правильный код"); + Assertions.assertEquals("[]", response.body(), "вернулся не пустой список задач"); + + taskManager.newTack(task); + taskManager.newEpic(epic1); + taskManager.newSubTask(subTask1); + taskManager.newSubTask(subTask2); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/prioritized")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode(), "вернулся не правильный код"); + List allTaskHistory = gson.fromJson(response.body(), new UserListTypeToken().getType()); + Assertions.assertEquals(taskManager.getPrioritizedTasks().size(), allTaskHistory.size(), "вернулся не пустой список задач"); + } + +} diff --git a/test/http/HttpTaskManagerSubTaskTest.java b/test/http/HttpTaskManagerSubTaskTest.java new file mode 100644 index 0000000..f1f8253 --- /dev/null +++ b/test/http/HttpTaskManagerSubTaskTest.java @@ -0,0 +1,254 @@ +package http; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import http.handler.BaseHttpHandler; +import managers.InMemoryHistoryManager; +import managers.InMemoryTaskManager; +import managers.TaskManager; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tasks.Epic; +import tasks.SubTask; +import util.Status; +import util.Type; + +import java.io.IOException; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.time.LocalDateTime; +import java.util.List; + +public class HttpTaskManagerSubTaskTest { + + TaskManager taskManager = new InMemoryTaskManager(new InMemoryHistoryManager()); + HttpTaskServer httpTaskServer = new HttpTaskServer(taskManager); + Gson gson = BaseHttpHandler.getGson(); + + HttpResponse response; + HttpRequest request; + HttpClient client = HttpClient.newHttpClient(); + + final Epic epic1 = new Epic("epic 1", "test epic1"); + final String jsonEpic1 = gson.toJson(epic1); + final SubTask subTask1 = new SubTask("test subtask1_1", "subtask1 descriprion", 1, + LocalDateTime.of(2025, 01, 01, 03, 00, 00), 25); + final SubTask subTask2 = new SubTask("test subtask1_1", "subtask1 descriprion", 1, + LocalDateTime.of(2025, 02, 01, 03, 00, 00), 25); + final String jsonSubTask1 = gson.toJson(subTask1); + final String jsonSubTask2 = gson.toJson(subTask2); + + + public HttpTaskManagerSubTaskTest() throws IOException { + } + + @BeforeEach + public void setUp() { + taskManager.clearTaskList(); + taskManager.clearTaskList(); + taskManager.clearEpicList(); + httpTaskServer.start(); + } + + @AfterEach + public void setDown() { + httpTaskServer.stop(); + } + + class UserListTypeToken extends TypeToken> { + } + + @Test + public void addSubTask() throws IOException, InterruptedException { + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + // добавляем саптаск + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask1)) + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(201, response.statusCode()); + List allSubTasks = taskManager.getSubTask(); + Assertions.assertNotNull(allSubTasks, "задача не добавилась"); + Assertions.assertEquals(1, allSubTasks.size(), "колличество задач не совпадает"); + +// проверяем на пересечение, вывод 406 ошибки + SubTask subTask3 = new SubTask("test subtask 3", "subtask descriprion", 1, + LocalDateTime.of(2025, 01, 01, 03, 00, 00), 25); + String jsonSubTask3 = gson.toJson(subTask3); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask3)) + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(406, response.statusCode()); + } + + @Test + public void updatSubTask() throws IOException, InterruptedException { + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + URI uri = URI.create("http://localhost:8080/subtasks"); + request = HttpRequest.newBuilder() + .uri(uri) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + SubTask subTaskUpdate = new SubTask(2, Type.SUBTUSK, "test subtask update", Status.IN_PROGRESS, "subtask descriprion", + LocalDateTime.of(2025, 01, 01, 03, 00, 00), 25, 1); + String jsonTaskUpdate = gson.toJson(subTaskUpdate); + HttpRequest requestUpdate = HttpRequest.newBuilder() + .uri(uri) + .POST(HttpRequest.BodyPublishers.ofString(jsonTaskUpdate)) + .build(); + response = client.send(requestUpdate, HttpResponse.BodyHandlers.ofString()); + List allTasks = taskManager.getSubTask(); + Assertions.assertEquals(201, response.statusCode(), "Не верный код ответа"); + Assertions.assertEquals(1, allTasks.size(), "колличество задач не совпадает"); + Assertions.assertEquals("test subtask update", allTasks.get(0).getName(), "Некорректное имя задачи"); + } + + @Test + public void getSubTask() throws IOException, InterruptedException { + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + //проверяем на несуществующую Субтаск + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks/110")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(404, response.statusCode(), "не верный код ответа"); +//добавляем + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask1)) + .build(); + + client.send(request, HttpResponse.BodyHandlers.ofString()); +// провеяем что вывелась по id + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks/2")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + + SubTask subTaskFromJson = gson.fromJson(response.body(), SubTask.class); + Assertions.assertEquals(200, response.statusCode(), "не верный код ответа"); + Assertions.assertEquals(taskManager.getToIdSubTask(2), subTaskFromJson, "не не совпали Subtask"); + } + + @Test + public void getAllSubTask() throws IOException, InterruptedException { + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + //пустой запрос всех саптасков + HttpClient client = HttpClient.newHttpClient(); + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals("[]", response.body(), "вернулся не пустой список задач"); + + // проверяем возращение списка из всех тасков + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask2)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + List allSubTask = gson.fromJson(response.body(), new UserListTypeToken().getType()); + Assertions.assertEquals(taskManager.getSubTask().size(), allSubTask.size(), + "не свопадает количество записей"); + } + + @Test + public void deleteSubTask() throws IOException, InterruptedException { + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/epics")) + .POST(HttpRequest.BodyPublishers.ofString(jsonEpic1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + final SubTask subTask3 = new SubTask("test subtask1_1", "subtask1 descriprion", 1, + LocalDateTime.of(2025, 04, 01, 03, 00, 00), 25); + String jsonSubTask3 = gson.toJson(subTask3); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask2)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonSubTask3)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + //удаляем 1 задачу + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks/2")) + .DELETE() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode()); + Assertions.assertEquals(taskManager.getSubTask().size(), 2, "не удалилась задача"); + + // удаляем все задачи + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/subtasks")) + .DELETE() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode()); + Assertions.assertEquals(taskManager.getSubTask().size(), 0, "не удалилась задача"); + } + +} diff --git a/test/http/HttpTaskManagerTasksTest.java b/test/http/HttpTaskManagerTasksTest.java new file mode 100644 index 0000000..0d795a9 --- /dev/null +++ b/test/http/HttpTaskManagerTasksTest.java @@ -0,0 +1,233 @@ +package http; + +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; +import http.handler.BaseHttpHandler; +import managers.InMemoryHistoryManager; +import managers.InMemoryTaskManager; +import managers.TaskManager; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.AfterEach; +import tasks.Task; +import util.Status; +import util.Type; + +import java.io.IOException; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.time.LocalDateTime; +import java.util.List; + +public class HttpTaskManagerTasksTest { + TaskManager taskManager = new InMemoryTaskManager(new InMemoryHistoryManager()); + HttpTaskServer httpTaskServer = new HttpTaskServer(taskManager); + Gson gson = BaseHttpHandler.getGson(); + + public HttpTaskManagerTasksTest() throws IOException { + } + + @BeforeEach + public void setUp() { + taskManager.clearTaskList(); + taskManager.clearTaskList(); + taskManager.clearEpicList(); + httpTaskServer.start(); + } + + @AfterEach + public void setDown() { + httpTaskServer.stop(); + } + + class UserListTypeToken extends TypeToken> { + } + + @Test + public void addTask() throws IOException, InterruptedException { + // cоздаем таску для отпрвки на сервер + Task task = new Task("Task 1", "test task1", LocalDateTime.now(), 25); + String jsonTask = gson.toJson(task); + //создаем http клиента + HttpClient client = HttpClient.newHttpClient(); + URI uri = URI.create("http://localhost:8080/tasks"); + //создраем запрос + HttpRequest request = HttpRequest.newBuilder() + .uri(uri) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask)) + .build(); + //отправяем запрос, получаем в ответ код + HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); + //проверем значения + Assertions.assertEquals(201, response.statusCode(), "Не верный код ответа"); + List allTasks = taskManager.getTasks(); + Assertions.assertNotNull(allTasks, "задача не добавилась"); + Assertions.assertEquals(1, allTasks.size(), "колличество задач не совпадает"); + } + + @Test + public void updateTask() throws IOException, InterruptedException { + Task task = new Task("Task 1", "test task1", + LocalDateTime.of(2025, 03, 22, 10, 00), 25); + String jsonTask = gson.toJson(task); + HttpClient client = HttpClient.newHttpClient(); + URI uri = URI.create("http://localhost:8080/tasks"); + HttpRequest request = HttpRequest.newBuilder() + .uri(uri) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + Task taskUpdate = new Task(1, Type.TASK, "Task update", Status.IN_PROGRESS, "test task1", + LocalDateTime.of(2025, 03, 22, 10, 00), 25); + String jsonTaskUpdate = gson.toJson(taskUpdate); + HttpRequest requestUpdate = HttpRequest.newBuilder() + .uri(uri) + .POST(HttpRequest.BodyPublishers.ofString(jsonTaskUpdate)) + .build(); + HttpResponse response = client.send(requestUpdate, HttpResponse.BodyHandlers.ofString()); + List allTasks = taskManager.getTasks(); + Assertions.assertEquals(201, response.statusCode(), "Не верный код ответа"); + Assertions.assertEquals(1, allTasks.size(), "колличество задач не совпадает"); + Assertions.assertEquals("Task update", allTasks.get(0).getName(), "Некорректное имя задачи"); + } + + @Test + public void getTask() throws IOException, InterruptedException { +//проверяем на несуществующую Таску + HttpClient client = HttpClient.newHttpClient(); + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks/1")) + .GET() + .build(); + + HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(404, response.statusCode(), "не верный код ответа"); + + Task task = new Task("Task 1", "test task1", LocalDateTime.now(), 25); + String jsonTask = gson.toJson(task); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask)) + .build(); + + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks/1")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + + Task taskFromJson = gson.fromJson(response.body(), Task.class); + Assertions.assertEquals(200, response.statusCode(), "не верный код ответа"); + Assertions.assertEquals(taskManager.getToIdTask(1), taskFromJson, "не не совпали Task"); + } + + @Test + public void getAllTask() throws IOException, InterruptedException { + HttpResponse response; + HttpRequest request; + Task task = new Task("Task 1", "test task1", LocalDateTime.now(), 25); + String jsonTask1 = gson.toJson(task); + Task task2 = new Task("Task 2", "test task2", LocalDateTime.now(), 25); + String jsonTask2 = gson.toJson(task2); + Task task3 = new Task("Task 3", "test task2", LocalDateTime.now().plusHours(1), 25); + String jsonTask3 = gson.toJson(task3); + + //пустой запрос всех тасков + HttpClient client = HttpClient.newHttpClient(); + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals("[]", response.body(), "вернулся не пустой список задач"); + + // проверяем на пересечение при добавление таск 2 + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask2)) + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(406, response.statusCode(), "вернулся не код ошибки пересечения записей"); + + // проверяем возращение списка из всех тасков + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask3)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .GET() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + List allTask = gson.fromJson(response.body(), new UserListTypeToken().getType()); + Assertions.assertEquals(taskManager.getTasks().size(), allTask.size(), + "не свопадает количество записей"); + } + + @Test + public void deleteTask() throws IOException, InterruptedException { + HttpResponse response; + HttpRequest request; + Task task = new Task("Task 1", "test task1", LocalDateTime.now(), 25); + String jsonTask1 = gson.toJson(task); + Task task2 = new Task("Task 2", "test task2", LocalDateTime.now().plusHours(1), 25); + String jsonTask2 = gson.toJson(task2); + Task task3 = new Task("Task 3", "test task2", LocalDateTime.now().plusHours(2), 25); + String jsonTask3 = gson.toJson(task3); + HttpClient client = HttpClient.newHttpClient(); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask1)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask2)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .POST(HttpRequest.BodyPublishers.ofString(jsonTask3)) + .build(); + client.send(request, HttpResponse.BodyHandlers.ofString()); + + //удаляем 1 задачу + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks/2")) + .DELETE() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode()); + Assertions.assertEquals(taskManager.getTasks().size(), 2, "не удалилась задача"); + + // удаляем все задачи + request = HttpRequest.newBuilder() + .uri(URI.create("http://localhost:8080/tasks")) + .DELETE() + .build(); + response = client.send(request, HttpResponse.BodyHandlers.ofString()); + Assertions.assertEquals(200, response.statusCode()); + Assertions.assertEquals(taskManager.getTasks().size(), 0, "не удалилась задача"); + } + + +} + + diff --git a/test/managers/InMemoryTaskManagerTest.java b/test/managers/InMemoryTaskManagerTest.java index 3df33aa..418fcbc 100644 --- a/test/managers/InMemoryTaskManagerTest.java +++ b/test/managers/InMemoryTaskManagerTest.java @@ -88,6 +88,7 @@ void orderPrioritizedTasks() { task2.setStartTime(LocalDateTime.now().minusHours(2)); taskManager.updateTask(2, task2); Assertions.assertEquals(task2, taskManager.getPrioritizedTasks().get(0), "порядок записей не соответствует"); + } } diff --git a/test/managers/TaskManagerTest.java b/test/managers/TaskManagerTest.java index 9e9bc80..df70c6b 100644 --- a/test/managers/TaskManagerTest.java +++ b/test/managers/TaskManagerTest.java @@ -227,13 +227,13 @@ void calculateStatusEpic() { taskManager.updateSubTask(2, subTask1); Assertions.assertEquals(Status.IN_PROGRESS, taskManager.getToIdEpic(1).getStatus(), "статус не совпал"); subTask2.setStatus(Status.IN_PROGRESS); - taskManager.updateSubTask(2, subTask2); + taskManager.updateSubTask(3, subTask2); Assertions.assertEquals(Status.IN_PROGRESS, taskManager.getToIdEpic(1).getStatus(), "статус не совпал"); subTask1.setStatus(Status.DONE); taskManager.updateSubTask(2, subTask1); Assertions.assertEquals(Status.IN_PROGRESS, taskManager.getToIdEpic(1).getStatus(), "статус не совпал"); subTask2.setStatus(Status.DONE); - taskManager.updateSubTask(2, subTask2); + taskManager.updateSubTask(3, subTask2); Assertions.assertEquals(Status.DONE, taskManager.getToIdEpic(1).getStatus(), "статус не совпал"); } }