Спринт 6. Изменения хранения истории просмотра задач на LinkedList и …

README.md

@@ -1,2 +1,5 @@
 # java-kanban
-Repository for homework project.
+Sprint 6. 
+Необходимо:
+- Сделать историю посещений неограниченной по размеру.
+- Избавиться от повторных просмотров в истории. Если какую-либо задачу посещали несколько раз, то в истории должен остаться только её последний просмотр. Предыдущий должен быть удалён.

src/Main.java

@@ -23,13 +23,13 @@ public static void main(String[] args) {
                 "Описание эпической задачи - 2");
         int epic2Id = manager.addNewEpic(epic2);
 
-        Subtask subtask1 = new Subtask( "Подзадача - 1",
+        Subtask subtask1 = new Subtask("Подзадача - 1",
                 "Описание подзадачи - 1, эпической задачи - 1", epic1.getId());
         int subtask1Id = manager.addNewSubtask(subtask1);
         Subtask subtask2 = new Subtask("Подзадача - 2",
 "Описание подзадачи - 2, эпической задачи - 1", epic1.getId());
         int subtask2Id = manager.addNewSubtask(subtask2);
-        Subtask subtask3 = new Subtask( "Подзадача - 3",
+        Subtask subtask3 = new Subtask("Подзадача - 3",
                 "Описание подзадачи - 3, эпической задачи - 2", epic2.getId());
         int subtask3Id = manager.addNewSubtask(subtask3);
 
@@ -48,6 +48,7 @@ public static void main(String[] args) {
 
         printAllTasks(manager);
     }
+
     private static void printAllTasks(TaskManager manager) {
         System.out.println("Задачи:");
         for (Task task : manager.getAllTasks()) {

src/service/HistoryManager.java

@@ -6,5 +6,8 @@
 
 public interface HistoryManager {
     void addInHistory(Task task);
+
+    void removeFromHistory(int id);
+
     List<Task> getHistory();
 }

src/service/InMemoryHistoryManager.java

@@ -3,28 +3,72 @@
 import model.Task;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class InMemoryHistoryManager implements HistoryManager {
-    private static final int SIZE_HISTORY = 10;
-    private final List<Task> history = new ArrayList<>(SIZE_HISTORY);
-
-    private void removeHistoryFirst() {
-        if (!history.isEmpty() && history.size() == SIZE_HISTORY) {
-            history.removeFirst();
-        }
-    }
+    private Node head = null;
+    private Node tail = null;
+    private final Map<Integer, Node> listHistory = new HashMap<>();
 
     @Override
     public List<Task> getHistory() {
-        return new ArrayList<>(history);
+        return getTasks();
     }
 
     @Override
     public void addInHistory(Task task) {
         if (task != null) {
-            removeHistoryFirst();
-            history.add(task);
+            linkLast(task);
+        }
+    }
+
+    private void linkLast(Task task) {
+        Node newNode = new Node(task, null, this.tail);
+        if (this.tail == null) {
+            this.head = newNode;
+        } else {
+            tail.setNext(newNode);
+        }
+        this.tail = newNode;
+        removeFromHistory(task.getId());
+        listHistory.put(task.getId(), newNode);
+    }
+
+    @Override
+    public void removeFromHistory(int id) {
+        if (listHistory.containsKey(id)) {
+            removeNode(listHistory.get(id));
+        }
+    }
+
+    private List<Task> getTasks() {
+        List<Task> listHistoryRes = new ArrayList<>();
+        Node node = head;
+        while (node != null) {
+            listHistoryRes.add(node.getItem());
+            node = node.getNext();
+        }
+        return listHistoryRes;
+    }
+
+    private void removeNode(Node node) {
+        if (node != null) {
+            Node nodeNext = node.getNext();
+            Node nodePrev = node.getPrev();
+            if (nodePrev == null) {
+                head = nodeNext;
+                head.setPrev(null);
+            } else {
+                nodePrev.setNext(nodeNext);
+            }
+            if (nodeNext == null) {
+                tail = nodePrev;
+                tail.setNext(null);
+            } else {
+                nodeNext.setPrev(nodePrev);
+            }
         }
     }
 }

src/service/Node.java

@@ -0,0 +1,39 @@
+package service;
+
+import model.Task;
+
+public class Node {
+    private Task item;
+    private Node next;
+    private Node prev;
+
+    public Node(Task item, Node next, Node prev) {
+        this.item = item;
+        this.next = next;
+        this.prev = prev;
+    }
+
+    public Task getItem() {
+        return item;
+    }
+
+    public void setItem(Task item) {
+        this.item = item;
+    }
+
+    public Node getNext() {
+        return next;
+    }
+
+    public void setNext(Node next) {
+        this.next = next;
+    }
+
+    public Node getPrev() {
+        return prev;
+    }
+
+    public void setPrev(Node prev) {
+        this.prev = prev;
+    }
+}

test/service/InMemoryHistoryManagerTest.java

@@ -13,54 +13,125 @@
 public class InMemoryHistoryManagerTest {
     private TaskManager manager;
     private Task task;
+    private Task task2;
     private Epic epic;
+    private Epic epic2;
 
     @BeforeEach
     void setUp() {
         task = new Task("Просто задача - 1", "Описание простой задачи - 1");
+        task2 = new Task("Просто задача - 2", "Описание простой задачи - 2");
         epic = new Epic("Эпическая задача - 1",
                 "Описание эпической задачи - 1");
+        epic2 = new Epic("Эпическая задача - 2",
+                "Описание эпической задачи - 2");
         manager = Managers.getDefault();
     }
 
     @Test
     void addTaskInHistoryTest() {
-        final int taskId = manager.addNewTask(task);
+        final int taskId1 = manager.addNewTask(task);
+        final int taskId2 = manager.addNewTask(task2);
+        manager.getTask(taskId1);
+        manager.getTask(taskId2);
 
-        manager.getTask(taskId);
+        final List<Task> history = manager.getHistory();
+
+        assertNotNull(history, "История не пустая.");
+        assertEquals(2, history.size(), "Размер истории не верный");
+        assertEquals(List.of(task, task2), manager.getHistory(), "История не соответствует");
+    }
+
+    @Test
+    void removeTaskFromHistoryTest() {
+        final int taskId1 = manager.addNewTask(task);
+        final int taskId2 = manager.addNewTask(task2);
+        manager.getTask(taskId1);
+        manager.getTask(taskId2);
+        manager.getTask(taskId1);
 
         final List<Task> history = manager.getHistory();
 
         assertNotNull(history, "История не пустая.");
-        assertEquals(1, history.size(), "История не пустая.");
+        assertEquals(2, history.size(), "Размер истории не верный");
+        assertEquals(List.of(task2, task), manager.getHistory(), "История не соответствует");
     }
 
     @Test
     void addEpicInHistoryTest() {
-        final int epicId = manager.addNewEpic(epic);
+        final int epicId1 = manager.addNewEpic(epic);
+        final int epicId2 = manager.addNewEpic(epic2);
+        manager.getEpic(epicId1);
+        manager.getEpic(epicId2);
 
-        manager.getEpic(epicId);
+        final List<Task> history = manager.getHistory();
+
+        assertNotNull(history, "История не пустая.");
+        assertEquals(2, history.size(), "Размер истории не верный");
+        assertEquals(List.of(epic, epic2), manager.getHistory(), "История не соответствует");
+    }
+
+    @Test
+    void removeEpicInHistoryTest() {
+        final int epicId1 = manager.addNewEpic(epic);
+        final int epicId2 = manager.addNewEpic(epic2);
+        manager.getEpic(epicId1);
+        manager.getEpic(epicId2);
+        manager.getEpic(epicId1);
 
         final List<Task> history = manager.getHistory();
 
         assertNotNull(history, "История не пустая.");
-        assertEquals(1, history.size(), "История не пустая.");
+        assertEquals(2, history.size(), "Размер истории не верный");
+        assertEquals(List.of(epic2, epic), manager.getHistory(), "История не соответствует");
     }
 
     @Test
     void addSubtaskInHistoryTest() {
-        final int epicId = manager.addNewEpic(epic);
-        Subtask subtask = new Subtask("Подзадача - 1",
-                "Описание подзадачи - 1, эпической задачи - 1", epicId);
-        final int subtaskId = manager.addNewSubtask(subtask);
+        final int epicId1 = manager.addNewEpic(epic);
+        final int epicId2 = manager.addNewEpic(epic2);
+        Subtask subtask1 = new Subtask("Подзадача - 1",
+                "Описание подзадачи - 1, эпической задачи - 1", epicId1);
+        Subtask subtask2 = new Subtask("Подзадача - 1",
+                "Описание подзадачи - 1, эпической задачи - 2", epicId2);
+        final int subtaskId1 = manager.addNewSubtask(subtask1);
+        final int subtaskId2 = manager.addNewSubtask(subtask2);
+
+        manager.getEpic(epicId1);
+        manager.getSubtask(subtaskId1);
+        manager.getEpic(epicId2);
+        manager.getSubtask(subtaskId2);
 
-        manager.getEpic(epicId);
-        manager.getSubtask(subtaskId);
+        final List<Task> history = manager.getHistory();
+
+        assertNotNull(history, "История не пустая.");
+        assertEquals(4, history.size(), "Размер истории не верный");
+        assertEquals(List.of(epic, subtask1, epic2, subtask2), manager.getHistory(), "История не соответствует");
+    }
+
+    @Test
+    void removeSubtaskInHistoryTest() {
+        final int epicId1 = manager.addNewEpic(epic);
+        final int epicId2 = manager.addNewEpic(epic2);
+        Subtask subtask1 = new Subtask("Подзадача - 1",
+                "Описание подзадачи - 1, эпической задачи - 1", epicId1);
+        Subtask subtask2 = new Subtask("Подзадача - 1",
+                "Описание подзадачи - 1, эпической задачи - 2", epicId2);
+        final int subtaskId1 = manager.addNewSubtask(subtask1);
+        final int subtaskId2 = manager.addNewSubtask(subtask2);
+
+        manager.getEpic(epicId1);
+        manager.getSubtask(subtaskId1);
+        manager.getEpic(epicId2);
+        manager.getSubtask(subtaskId2);
+        manager.getSubtask(subtaskId1);
+        manager.getEpic(epicId2);
 
         final List<Task> history = manager.getHistory();
 
         assertNotNull(history, "История не пустая.");
-        assertEquals(2, history.size(), "История не пустая.");
+        assertEquals(4, history.size(), "Размер истории не верный");
+        assertEquals(List.of(epic, subtask2, subtask1,epic2), manager.getHistory(), "История не соответствует");
     }
 
     @Test
@@ -72,10 +143,11 @@ void getHistoryTest() {
 
         manager.getEpic(epicId);
         manager.getSubtask(subtaskId);
+        manager.getEpic(epicId);
 
         final List<Task> history = manager.getHistory();
 
-        assertEquals(history.get(0), epic, "История возвращается неверно");
-        assertEquals(history.get(1), subtask, "История возвращается неверно");
+        assertEquals(history.get(0), subtask, "История возвращается неверно");
+        assertEquals(history.get(1), epic, "История возвращается неверно");
     }
 }

test/service/TaskManagerTest.java

@@ -168,13 +168,18 @@ void deleteAllEpicsTest() {
 
     @Test
     void deleteSubtaskTest() {
+        manager.addNewEpic(epic);
         Subtask subtask = new Subtask("Подзадача - 1",
                 "Описание подзадачи - 1, эпической задачи - 1", epic.getId());
-        int subtaskId = manager.addNewSubtask(subtask);
+        Integer subtaskId = manager.addNewSubtask(subtask);
+
+        assertEquals(1, epic.getSubtaskIds().size(), "ID сабтаски не зарегистрировался у эпика");
+
         manager.deleteSubtask(subtaskId);
 
         assertTrue(manager.getAllSubtasks().isEmpty(), "Сабтаск не удалился");
         assertEquals(0, manager.getAllSubtasks().size(), "Сабтаск не удалился");
+        assertTrue(epic.getSubtaskIds().isEmpty(), "ID сабтаски не удалился из списка у эпика");
     }
 
     @Test