Restructure module 7

docs/aca/07-aca-cron-bindings/FakeTasksManager.cs

@@ -0,0 +1,114 @@
+using TasksTracker.TasksManager.Backend.Api.Models;
+
+namespace TasksTracker.TasksManager.Backend.Api.Services
+{
+    public class FakeTasksManager : ITasksManager
+    {
+        List<TaskModel> _tasksList = new List<TaskModel>();
+        Random rnd = new Random();
+
+        private void GenerateRandomTasks()
+        {
+            for (int i = 0; i < 10; i++)
+            {
+                var task = new TaskModel()
+                {
+                    TaskId = Guid.NewGuid(),
+                    TaskName = $"Task number: {i}",
+                    TaskCreatedBy = "tjoudeh@bitoftech.net",
+                    TaskCreatedOn = DateTime.UtcNow.AddMinutes(i),
+                    TaskDueDate = DateTime.UtcNow.AddDays(i),
+                    TaskAssignedTo = $"assignee{rnd.Next(50)}@mail.com",
+                };
+                _tasksList.Add(task);
+            }
+        }
+
+        public FakeTasksManager()
+        {
+            GenerateRandomTasks();
+        }
+
+        public Task<Guid> CreateNewTask(string taskName, string createdBy, string assignedTo, DateTime dueDate)
+        {
+            var task = new TaskModel()
+            {
+                TaskId = Guid.NewGuid(),
+                TaskName = taskName,
+                TaskCreatedBy = createdBy,
+                TaskCreatedOn = DateTime.UtcNow,
+                TaskDueDate = dueDate,
+                TaskAssignedTo = assignedTo,
+            };
+
+            _tasksList.Add(task);
+
+            return Task.FromResult(task.TaskId);
+        }
+
+        public Task<bool> DeleteTask(Guid taskId)
+        {
+            var task = _tasksList.FirstOrDefault(t => t.TaskId.Equals(taskId));
+
+            if (task != null)
+            {
+                _tasksList.Remove(task);
+                return Task.FromResult(true);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public Task<TaskModel?> GetTaskById(Guid taskId)
+        {
+            var taskModel = _tasksList.FirstOrDefault(t => t.TaskId.Equals(taskId));
+            return Task.FromResult(taskModel);
+        }
+
+        public Task<List<TaskModel>> GetTasksByCreator(string createdBy)
+        {
+            var tasksList = _tasksList.Where(t => t.TaskCreatedBy.Equals(createdBy)).OrderByDescending(o => o.TaskCreatedOn).ToList();
+            return Task.FromResult(tasksList);
+        }
+
+        public Task<bool> MarkTaskCompleted(Guid taskId)
+        {
+            var task = _tasksList.FirstOrDefault(t => t.TaskId.Equals(taskId));
+
+            if (task != null)
+            {
+                task.IsCompleted = true;
+                return Task.FromResult(true);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public Task<bool> UpdateTask(Guid taskId, string taskName, string assignedTo, DateTime dueDate)
+        {
+            var task = _tasksList.FirstOrDefault(t => t.TaskId.Equals(taskId));
+
+            if (task != null)
+            {
+                task.TaskName = taskName;
+                task.TaskAssignedTo = assignedTo;
+                task.TaskDueDate = dueDate;
+                return Task.FromResult(true);
+            }
+
+            return Task.FromResult(false);
+        }
+
+        public Task MarkOverdueTasks(List<TaskModel> overDueTasksList)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<List<TaskModel>> GetYesterdaysDueTasks()
+        {
+            var tasksList = _tasksList.Where(t => t.TaskDueDate.Equals(DateTime.Today.AddDays(-1))).ToList();
+
+            return Task.FromResult(tasksList);
+        }  
+    }
+}

docs/aca/07-aca-cron-bindings/ITasksManager.cs

@@ -0,0 +1,16 @@
+using TasksTracker.TasksManager.Backend.Api.Models;
+
+namespace TasksTracker.TasksManager.Backend.Api.Services
+{
+    public interface ITasksManager
+    {
+        Task<List<TaskModel>> GetTasksByCreator(string createdBy);
+        Task<TaskModel?> GetTaskById(Guid taskId);
+        Task<Guid> CreateNewTask(string taskName, string createdBy, string assignedTo, DateTime dueDate);
+        Task<bool> UpdateTask(Guid taskId, string taskName, string assignedTo, DateTime dueDate);
+        Task<bool> MarkTaskCompleted(Guid taskId);
+        Task<bool> DeleteTask(Guid taskId);
+        Task MarkOverdueTasks(List<TaskModel> overdueTasksList);
+        Task<List<TaskModel>> GetYesterdaysDueTasks();
+    }
+}

docs/aca/07-aca-cron-bindings/ScheduledTasksManagerController.cs

@@ -10,8 +10,7 @@ public class ScheduledTasksManagerController : ControllerBase
     {
         private readonly ILogger<ScheduledTasksManagerController> _logger;
         private readonly DaprClient _daprClient;
-        public ScheduledTasksManagerController(ILogger<ScheduledTasksManagerController> logger,
-                                                DaprClient daprClient)
+        public ScheduledTasksManagerController(ILogger<ScheduledTasksManagerController> logger, DaprClient daprClient)
         {
             _logger = logger;
             _daprClient = daprClient;

docs/aca/07-aca-cron-bindings/TasksStoreManager.cs

@@ -0,0 +1,136 @@
+using Dapr.Client;
+using System.Text.Json;
+using System.Text.Encodings.Web;
+using System.Text.Json.Serialization;
+using TasksTracker.TasksManager.Backend.Api.Models;
+
+namespace TasksTracker.TasksManager.Backend.Api.Services
+{
+    public class TasksStoreManager : ITasksManager
+    {
+        private static string STORE_NAME = "statestore";
+        private readonly DaprClient _daprClient;
+        private readonly IConfiguration _config;
+        private readonly ILogger<TasksStoreManager> _logger;
+
+        public TasksStoreManager(DaprClient daprClient, IConfiguration config, ILogger<TasksStoreManager> logger)
+        {
+            _daprClient = daprClient;
+            _config = config;
+            _logger = logger;
+        }
+        public async Task<Guid> CreateNewTask(string taskName, string createdBy, string assignedTo, DateTime dueDate)
+        {
+            var taskModel = new TaskModel()
+            {
+                TaskId = Guid.NewGuid(),
+                TaskName = taskName,
+                TaskCreatedBy = createdBy,
+                TaskCreatedOn = DateTime.UtcNow,
+                TaskDueDate = dueDate,
+                TaskAssignedTo = assignedTo,
+            };
+
+            _logger.LogInformation("Save a new task with name: '{0}' to state store", taskModel.TaskName);
+            await _daprClient.SaveStateAsync<TaskModel>(STORE_NAME, taskModel.TaskId.ToString(), taskModel);
+            return taskModel.TaskId;
+        }
+
+        public async Task<bool> DeleteTask(Guid taskId)
+        {
+            _logger.LogInformation("Delete task with Id: '{0}'", taskId);
+            await _daprClient.DeleteStateAsync(STORE_NAME, taskId.ToString());
+            return true;
+        }
+
+        public async Task<TaskModel?> GetTaskById(Guid taskId)
+        {
+            _logger.LogInformation("Getting task with Id: '{0}'", taskId);
+            var taskModel = await _daprClient.GetStateAsync<TaskModel>(STORE_NAME, taskId.ToString());
+            return taskModel;
+        }
+
+        public async Task<List<TaskModel>> GetTasksByCreator(string createdBy)
+        {
+            var query = "{" +
+                    "\"filter\": {" +
+                        "\"EQ\": { \"taskCreatedBy\": \"" + createdBy + "\" }" +
+                    "}}";
+
+            var queryResponse = await _daprClient.QueryStateAsync<TaskModel>(STORE_NAME, query);
+
+            var tasksList = queryResponse.Results.Select(q => q.Data).OrderByDescending(o=>o.TaskCreatedOn);
+            return tasksList.ToList();
+        }
+
+        public async Task<bool> MarkTaskCompleted(Guid taskId)
+        {
+            _logger.LogInformation("Mark task with Id: '{0}' as completed", taskId);
+            var taskModel = await _daprClient.GetStateAsync<TaskModel>(STORE_NAME, taskId.ToString());
+            if (taskModel != null)
+            {
+                taskModel.IsCompleted = true;
+                await _daprClient.SaveStateAsync<TaskModel>(STORE_NAME, taskModel.TaskId.ToString(), taskModel);
+                return true;
+            }
+            return false;
+        }
+
+        public async Task<bool> UpdateTask(Guid taskId, string taskName, string assignedTo, DateTime dueDate)
+        {
+            _logger.LogInformation("Update task with Id: '{0}'", taskId);
+            var taskModel = await _daprClient.GetStateAsync<TaskModel>(STORE_NAME, taskId.ToString());
+            var currentAssignee = taskModel.TaskAssignedTo;
+            if (taskModel != null)
+            {
+                taskModel.TaskName = taskName;
+                taskModel.TaskAssignedTo = assignedTo;
+                taskModel.TaskDueDate = dueDate;
+                await _daprClient.SaveStateAsync<TaskModel>(STORE_NAME, taskModel.TaskId.ToString(), taskModel);
+                return true;
+            }
+            return false;
+        }
+
+        public async Task<List<TaskModel>> GetYesterdaysDueTasks()
+        {
+            var options = new JsonSerializerOptions
+            {
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                WriteIndented = true,
+                Converters =
+                {
+                    new JsonStringEnumConverter(),
+                    new DateTimeConverter("yyyy-MM-ddTHH:mm:ss")
+                },
+                PropertyNameCaseInsensitive = true,
+                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+                Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+            };
+            var yesterday = DateTime.Today.AddDays(-1);
+
+            var jsonDate = JsonSerializer.Serialize(yesterday, options);
+
+            _logger.LogInformation("Getting overdue tasks for yesterday date: '{0}'", jsonDate);
+
+            var query = "{" +
+                    "\"filter\": {" +
+                        "\"EQ\": { \"taskDueDate\": " + jsonDate + " }" +
+                    "}}";
+
+            var queryResponse = await _daprClient.QueryStateAsync<TaskModel>(STORE_NAME, query);
+            var tasksList = queryResponse.Results.Select(q => q.Data).Where(q=>q.IsCompleted==false && q.IsOverDue==false).OrderBy(o=>o.TaskCreatedOn);
+            return tasksList.ToList();
+        }
+
+        public async Task MarkOverdueTasks(List<TaskModel> overDueTasksList)
+        {
+            foreach (var taskModel in overDueTasksList)
+            {
+                _logger.LogInformation("Mark task with Id: '{0}' as OverDue task", taskModel.TaskId);
+                taskModel.IsOverDue = true;
+                await _daprClient.SaveStateAsync<TaskModel>(STORE_NAME, taskModel.TaskId.ToString(), taskModel);
+            }
+        }
+    }
+}