Jakub Mroz

domain-model.md

@@ -0,0 +1,46 @@
+# Domain Modelling
+
+## ITodoTask
+| Methods/Properties                            | Scenario                            | Outputs                  |
+|-----------------------------------------------|-------------------------------------|--------------------------|
+| Id                                            | Stores task ID                      | int                      |
+| CompletionStatus                              | stores completion status            | TaskCompletionStatusEnum |
+| TaskContent                                   | task description                    | string                   |
+| Priority                                      | stores task priority                | TaskPriorityEnum         |
+| TimeCreated                                   | stores time of task creation        | DateTime                 |
+| TimeCompleted                                 | stores time of task completion      | DateTime                 |
+| TimeToComplete                                | shows time it took to complete task | TimeSpan                 |
+| Category                                      | stores task category                | TaskCategoryEnum         |
+| CompleteTask()                                | changes task completion status      |                          |
+| ChangeTaskPriority(TaskPriorityEnum priority) | changes priority of the task        |                          |
+| ChangeTaskContent(string newContent)          | changes content of the task         |                          |
+| ChangeTaskCategory(TaskCategoryEnum category) | changes category of the task        |                          |
+|                                               |                                     |                          |
+|                                               |                                     |                          |
+
+
+
+
+## ToDoList
+| Method                                                      | Scenario                                               | Outputs                                                    |
+|-------------------------------------------------------------|--------------------------------------------------------|------------------------------------------------------------|
+| AddTask(Task task)                                          | add new task to list                                   |                                                            |
+| GetAllTasks()                                               | gets all tasks                                         | return all tasks in IEnumerable<ITodoTask>                 |
+| GetCompletedTasks()                                         | gets all completed tasks                               | return all completed tasks in IEnumerable<ITodoTask>       |
+| GetIncompleteTasks()                                        | gets all incomplete tasks                              | return all incomplete tasks in IEnumerable<ITodoTask>      |
+| RemoveTaskByName(string name)                               | remove task by its content                             |                                                            |
+| RemoveTaskById(int id)                                      | remove task by its id                                  |                                                            |
+| GetAlphabeticallySortedTasks(bool ascending)                | Get all tasks sorted by content                        | returns sorted tasks in IEnumerable<ITodoTask>             |
+| ChangeTaskPriorityByName(string name)                       | change tasks priority value by name                    |                                                            |
+| ChangeTaskPriorityByid(int id)                              | change tasks priority value by id                      |                                                            |
+| GetAllTasksByPriority()                                     | get all tasks sorted by priority                       | returns tasks sorted by priority in IEnumerable<ITodoTask> |
+| GetTaskByName(string name)                                  | find a task by its name                                | return ITodoTask                                           |
+| GetTaskById(int id)                                         | find a task by id                                      | return ITodoTask                                           |
+| UpdateTaskNameById(int id, string newName)                  | update tasks description by id                         |                                                            |
+| CompleteTaskById(int id)                                    | complete task by id                                    |                                                            |
+| CompleteTaskByName(string name)                             | complete task by name                                  |                                                            |
+| GetTaskLongestToComplete()                                  | get task which took the longest to complete            | return ITodoTask                                           |
+| GetTaskShortestToComplete()                                 | get task which took the shortest to complete           | return ITodoTask                                           |
+| GetTasksWhichTookLongerToCompleteThan(int seconds)          | get task which took longer to complete than given time | IEnumerable<ITodoTask>                                     |
+| AssignCategoryToTaskById(int id, TaskCategoryEnum category) | assign category to task by id                          |                                                            |
+| GetTasksByCategory(TaskCategoryEnum category)               | get tasks from given category                          | IEnumerable<ITodoTask>                                     |

tdd-todo-list.CSharp.Main/ITodoTask.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace tdd_todo_list.CSharp.Main
+{
+    public interface ITodoTask
+    {
+        public int Id { get; }
+        public bool IsCompleted { get; }
+        public string TaskContent { get; }
+        public TaskPriorityEnum Priority { get; }
+        public DateTime TimeCreated { get; }
+        public DateTime TimeCompleted { get; }
+        public TimeSpan TimeToComplete { get; }
+        public TaskCategoryEnum Category { get; }
+
+        public void CompleteTask();
+        public void ChangeTaskPriority(TaskPriorityEnum priority);
+        public void ChangeTaskContent(string content);
+        public void ChangeTaskCategory(TaskCategoryEnum category);
+
+
+    }
+}

tdd-todo-list.CSharp.Main/MockTodoTask.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace tdd_todo_list.CSharp.Main
+{
+    public class MockTodoTask : ITodoTask
+    {
+        private int _id;
+        private string _taskContent = "";
+        private bool _isCompleted = false;
+        private TaskPriorityEnum _priority = TaskPriorityEnum.Medium;
+        private DateTime _timeCompleted;
+        private TimeSpan _timeToComplete;
+        private TaskCategoryEnum _category;
+
+        private DateTime _timeCreated;
+
+        public MockTodoTask(int id, string taskContent, bool isCompleted, TaskPriorityEnum priority, 
+            DateTime timeCompleted, TimeSpan timeToComplete, TaskCategoryEnum category,
+            DateTime timeCreated) 
+        { 
+            _id = id;
+            _taskContent = taskContent;
+            _isCompleted = isCompleted;
+            _priority = priority;
+            _timeCompleted = timeCompleted;
+            _timeToComplete = timeToComplete;
+            _category = category;
+            _timeCreated = timeCreated;
+
+        }
+
+        public int Id { get { return _id; } }
+
+        public bool IsCompleted { get { return _isCompleted; } }
+
+        public string TaskContent {  get { return _taskContent; } }
+
+        public TaskPriorityEnum Priority {  get { return _priority; } }
+
+        public DateTime TimeCreated {  get { return _timeCreated; } }
+
+        public DateTime TimeCompleted {  get { return _timeCompleted; } }
+
+        public TimeSpan TimeToComplete {  get { return _timeToComplete; } }
+
+        public TaskCategoryEnum Category {  get { return _category; } }
+
+        public void ChangeTaskCategory(TaskCategoryEnum category)
+        {
+            _category = category;
+        }
+
+        public void ChangeTaskContent(string content)
+        {
+            _taskContent = content;
+        }
+
+        public void ChangeTaskPriority(TaskPriorityEnum priority)
+        {
+            _priority = priority;
+        }
+
+        public void CompleteTask()
+        {
+            _isCompleted = true;
+        }
+    }
+}

tdd-todo-list.CSharp.Main/TaskCategoryEnum.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace tdd_todo_list.CSharp.Main
+{
+    public enum TaskCategoryEnum
+    {
+        None,
+        Study,
+        Work,
+        Admin
+    }
+}
+
+

tdd-todo-list.CSharp.Main/TaskNotFoundException.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace tdd_todo_list.CSharp.Main
+{
+    public class TaskNotFoundException : Exception
+    {
+    }
+}

tdd-todo-list.CSharp.Main/TaskPriorityEnum.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace tdd_todo_list.CSharp.Main
+{
+    public enum TaskPriorityEnum
+    {
+        Low,
+        Medium,
+        High
+    }
+}

tdd-todo-list.CSharp.Main/ToDoList.cs

@@ -3,10 +3,131 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Xml.Linq;
 
 namespace tdd_todo_list.CSharp.Main
 {
     public class TodoList
     {
+        public readonly List<ITodoTask> tasks = new();
+
+        public void AddTask(ITodoTask task)
+        {
+            tasks.Add(task);
+        }
+
+        public IEnumerable<ITodoTask> GetAllTasks()
+        {
+            return tasks;
+        }
+
+        public IEnumerable<ITodoTask> GetCompletedTasks()
+        {
+            return tasks.Where(t => t.IsCompleted == true).ToList();
+        }
+
+        public IEnumerable<ITodoTask> GetIncompleteTasks()
+        {
+            return tasks.Where(t => t.IsCompleted == false).ToList();
+        }
+
+        public void RemoveTaskByName(string taskContent) 
+        {
+            var taskToRemove = tasks.Where(t => t.TaskContent == taskContent).FirstOrDefault();
+            tasks.Remove(taskToRemove);
+        }
+
+        public void RemoveTaskById(int id)
+        {
+            var taskToRemove = tasks.Where(t => t.Id == id).FirstOrDefault();
+            tasks.Remove(taskToRemove);
+        }
+
+        public IEnumerable<ITodoTask> GetAlphabeticallySortedTasks(bool ascending) 
+        {  
+            if (ascending)
+                return tasks.OrderBy(task  => task.TaskContent).ToList();
+
+            return tasks.OrderByDescending(task => task.TaskContent).ToList();
+        }
+
+        public void ChangeTaskPriorityByName(string name, TaskPriorityEnum priority) 
+        {
+            tasks.Where(t => t.TaskContent == name).FirstOrDefault().ChangeTaskPriority(priority);
+        }
+
+        public void ChangeTaskPriorityById(int id, TaskPriorityEnum priority)
+        {
+            tasks.Where(t => t.Id == id).FirstOrDefault().ChangeTaskPriority(priority);
+        }
+
+        public IEnumerable<ITodoTask> GetAllTasksByPriority()
+        {
+            return tasks.OrderByDescending(t => t.Priority).ToArray();
+        }
+
+        public ITodoTask GetTaskByName(string name) 
+        { 
+            var task = tasks.Where(t => t.TaskContent == name).FirstOrDefault(); 
+
+            if (task != null)
+                return task;
+
+            else 
+                throw new TaskNotFoundException();
+        }
+
+        public ITodoTask GetTaskById(int id) 
+        {
+            return tasks.Where(t => t.Id == id).FirstOrDefault();
+        }
+
+        public void UpdateTaskNameById(int id, string newName) 
+        {  
+            var task = GetTaskById(id);
+            task.ChangeTaskContent(newName);
+        }
+
+        public void CompleteTaskById(int id) 
+        {
+            var task = GetTaskById(id);
+            task.CompleteTask();
+        }
+
+        public void CompleteTaskByName(string name)
+        {
+            var task = GetTaskByName(name);
+            task.CompleteTask();
+        }
+
+        public ITodoTask GetTaskLongestToComplete()
+        {
+            var task = tasks.OrderByDescending(t => t.TimeToComplete).FirstOrDefault();
+            return task;
+        }
+
+        public ITodoTask GetTaskShortestToComplete() 
+        {
+            var task = tasks.Where(t => t.IsCompleted == true).OrderBy(t => t.TimeToComplete).FirstOrDefault();
+            return task;
+        }
+
+        public IEnumerable<ITodoTask> GetTasksWhichTookLongerToCompleteThan(int seconds) 
+        {
+            TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
+            return tasks.Where(task => task.TimeToComplete > timeSpan).OrderByDescending(t => t.TimeToComplete).ToList();            
+        }
+
+        public void AssignCategoryToTaskById(int id, TaskCategoryEnum category) 
+        {
+            var task = GetTaskById(id);
+            task.ChangeTaskCategory(category);
+        }
+
+        public IEnumerable<ITodoTask> GetTasksByCategory(TaskCategoryEnum category)
+        {
+            return tasks.Where(task => task.Category == category).ToList();
+        }
+
     }
 }

tdd-todo-list.CSharp.Main/TodoTask.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace tdd_todo_list.CSharp.Main
+{
+    public class TodoTask : ITodoTask
+    {
+        private string _taskContent = "";
+        private bool _isCompleted = false;
+        private TaskPriorityEnum _priority = TaskPriorityEnum.Medium;
+        private DateTime _timeCompleted;
+        private TimeSpan _timeToComplete;
+        private TaskCategoryEnum _category;
+
+        public int Id { get; }
+        public bool IsCompleted { get { return _isCompleted; } }
+
+        public string TaskContent { get { return _taskContent; } }
+        public TaskPriorityEnum Priority { get { return _priority; } }
+
+        public DateTime TimeCreated { get; }
+        public DateTime TimeCompleted { get { return _timeCompleted; } }
+        public TimeSpan TimeToComplete { get { return _timeToComplete; } }
+
+        public TaskCategoryEnum Category { get { return _category; } }
+
+        public TodoTask(int id, string taskContent)
+        {
+            Id = id;
+            _taskContent = taskContent;
+            TimeCreated = DateTime.Now;
+        }
+        public void ChangeTaskContent(string taskContent)
+        {
+            _taskContent = taskContent;
+        }
+
+        public void CompleteTask()
+        {
+            _timeCompleted= DateTime.Now;
+            _timeToComplete = (TimeCompleted - TimeCreated);
+            _isCompleted = true;
+        }
+
+        public void ChangeTaskPriority(TaskPriorityEnum priority)
+        {
+            _priority = priority;
+        }
+
+        public void ChangeTaskCategory(TaskCategoryEnum category)
+        {
+            _category = category;
+        }
+
+
+    }
+
+}