Create Gamification API (part2)

backend/Controllers/AuthenticationController.cs

@@ -3,7 +3,6 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
-using TaskSync.Filters;
 using TaskSync.Models.Dto;
 using TaskSync.Services.Interfaces;
 
@@ -23,18 +22,6 @@ public AuthenticationController(IUserService userService, IAuthenticationService
             _authenticationService = authenticationService;
         }
 
-        [ValidateRequestFilter]
-        [HttpPost("test")]
-        public async Task<IActionResult> Test([FromBody] TestRequest request)
-        {
-            Console.WriteLine("In 'auth/test' controller");
-
-            var result = await _userService.GetUserAsync();
-
-            return Ok(result);
-        }
-
-        [ValidateRequestFilter]
         [HttpPost("login")]
         public async Task<IActionResult> Login([FromBody] LoginRequest request)
         {

backend/Controllers/HomeController.cs

@@ -0,0 +1,20 @@
+using Microsoft.AspNetCore.Mvc;
+
+using TaskSync.Services.Interfaces;
+
+namespace TaskSync.Controllers
+{
+    [Route("")]
+    public class HomeController : Controller
+    {
+        private readonly IHomeVmService _homeVmService;
+        public HomeController(IHomeVmService homeVmService) => _homeVmService = homeVmService;
+
+        [HttpGet("")]
+        public IActionResult Index()
+        {
+            var vm = _homeVmService.Build();
+            return View("~/Views/Home/Index.cshtml", vm); // Return Razor View
+        }
+    }
+}

backend/Controllers/TaskController.cs

@@ -1,14 +1,15 @@
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
 
-using TaskSync.Controllers.TempDto;
+using TaskSync.Models;
 using TaskSync.Models.Dto;
 using TaskSync.Services.Interfaces;
 
 namespace TaskSync.Controllers
 {
     [ApiController]
     [ApiVersion("1.0")]
-    [Route("api/v{version:apiVersion}/task")]
+    [Route("api/v{version:apiVersion}")]
     public class TaskController : ControllerBase
     {
         private readonly ITaskService _taskService;
@@ -18,31 +19,33 @@ public TaskController(ITaskService taskService)
             _taskService = taskService;
         }
 
-        [HttpGet("getTasks/{projectId}")]
+        [HttpGet("projects/{projectId}/tasks")]
         public async Task<IActionResult> GetTasks([FromRoute] int projectId)
         {
             var tasks = await _taskService.GetTasksAsync(projectId);
-
             return Ok(new KanbanBoardVm() { Tasks = tasks });
         }
 
-        [HttpPost("addTask")]
-        public async Task<IActionResult> AddTask([FromBody] AddTaskRequest request)
+        [Authorize]
+        [HttpPost("projects/{projectId}/tasks")]
+        public async Task<IActionResult> AddTask([FromRoute] int projectId, [FromBody] AddTaskRequest request)
         {
-            var taskDto = await _taskService.AddTaskAsync(request);
+            var taskDto = await _taskService.AddTaskAsync(projectId, request);
             return StatusCode(StatusCodes.Status201Created, taskDto);
         }
 
-        [HttpPatch("updateStatus/{taskId}")]
+        [Authorize]
+        [HttpPatch("tasks/{taskId}")]
         public async Task<IActionResult> UpdateStatus([FromRoute] int taskId, [FromBody] UpdateTaskRequest request) // [FromRoute], [FromBody] are called ModelBining
         {
             var taskDto = await _taskService.UpdateTaskStatusAsync(taskId, request);
 
             return taskDto != null ? Ok(taskDto) : BadRequest("Task not found");
         }
 
-        [HttpDelete("deleteTask/{taskId}")]
-        public async Task<IActionResult> AddTask([FromRoute] int taskId)
+        [Authorize]
+        [HttpDelete("tasks/{taskId}")]
+        public async Task<IActionResult> DeleteTask([FromRoute] int taskId)
         {
             var isSucess = await _taskService.DeleteTaskAsync(taskId);
             return isSucess ? NoContent() : NotFound("Task not found");

backend/Enums/TaskStatus.cs

@@ -6,5 +6,7 @@ public enum TASK_STATUS
         TODO,
         INPROGRESS,
         DONE,
+        CREATE,
+        DELETE,
     }
 }

backend/ExternalApi/GamificationApi.cs

@@ -0,0 +1,50 @@
+using Microsoft.Extensions.Options;
+
+using TaskSync.ExternalApi.Interfaces;
+using TaskSync.Infrastructure.Http.Interface;
+using TaskSync.Infrastructure.Settings;
+using TaskSync.Models.Dto;
+
+using TaskStatus = TaskSync.Enums.TASK_STATUS;
+
+namespace TaskSync.ExternalApi
+{
+    public class GamificationApi : IGamificationApi
+    {
+        private readonly GamificationApiSettings _gamApiSettings;
+        private readonly IHttpContextReader _httpContextReader;
+        private readonly HttpClient _httpClient;
+        private readonly ILogger<GamificationApi> _logger;
+
+        public GamificationApi(IOptions<GamificationApiSettings> options, IHttpContextReader httpContextReader, IHttpClientFactory httpClientFactory, ILogger<GamificationApi> logger)
+        {
+            _gamApiSettings = options.Value;
+            _httpContextReader = httpContextReader;
+            _httpClient = httpClientFactory.CreateClient();
+            _logger = logger;
+        }
+
+        public async Task UpdatePoint(int taskId, TaskStatus status)
+        {
+            try
+            {
+                var httpMessage = new HttpRequestMessage(HttpMethod.Post, $"{_gamApiSettings.BaseUrl}/points")
+                {
+                    Content = JsonContent.Create(new CreatePointDto()
+                    {
+                        TaskId = taskId,
+                        TaskStatus = status,
+                        UserId = _httpContextReader.GetUserId(),
+                    }),
+                };
+                httpMessage.Headers.Add("x-gamapi-auth", "true");
+
+                await _httpClient.SendAsync(httpMessage);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, ex.Message);
+            }
+        }
+    }
+}

backend/ExternalApi/Interfaces/IGamificationApi.cs

@@ -0,0 +1,9 @@
+using TaskStatus = TaskSync.Enums.TASK_STATUS;
+
+namespace TaskSync.ExternalApi.Interfaces
+{
+    public interface IGamificationApi
+    {
+        Task UpdatePoint(int taskId, TaskStatus status);
+    }
+}

backend/Filters/ValidateRequestFilter.cs

@@ -3,7 +3,7 @@
 
 namespace TaskSync.Filters
 {
-    // todo-moch: 1) add some custom logic
+    // todo-moch: add some custom logic
     public class ValidateRequestFilter : ActionFilterAttribute
     {
         public override void OnActionExecuting(ActionExecutingContext context)

backend/Infrastructure/Caching/MemoryCacheBase.cs

@@ -12,13 +12,11 @@ protected MemoryCacheBase(IMemoryCache memoryCache)
             _memoryCache = memoryCache;
         }
 
-        protected abstract string GetCacheKey(int cacheKey);
-
         public async Task<T?> GetAsync(int cacheKey, Func<Task<T?>> fallbackCall)
         {
             if (_memoryCache.TryGetValue(GetCacheKey(cacheKey), out T? cached))
             {
-                Console.WriteLine($"[MemoryCache] get '{GetCacheKey(cacheKey)}' from memory");
+                Console.WriteLine($"[MemoryCacheBase] get '{GetCacheKey(cacheKey)}' from memory");
                 return cached;
             }
 
@@ -27,7 +25,7 @@ protected MemoryCacheBase(IMemoryCache memoryCache)
             {
                 Set(cacheKey, data);
             }
-            Console.WriteLine($"[MemoryCache] get '{GetCacheKey(cacheKey)}' from database");
+            Console.WriteLine($"[MemoryCacheBase] get '{GetCacheKey(cacheKey)}' from database");
 
             return data;
         }
@@ -47,7 +45,9 @@ public void Set(int cacheKey, T data)
         public void Remove(int cacheKey)
         {
             _memoryCache.Remove(GetCacheKey(cacheKey));
-            Console.WriteLine($"[MemoryCache] remove '{GetCacheKey(cacheKey)}' from memory");
+            Console.WriteLine($"[MemoryCacheBase] remove '{GetCacheKey(cacheKey)}' from memory");
         }
+
+        protected abstract string GetCacheKey(int cacheKey);
     }
 }

backend/Infrastructure/Configurations/DependencyInjectionConfiguration.cs

@@ -1,5 +1,7 @@
 using Microsoft.EntityFrameworkCore;
 
+using TaskSync.ExternalApi;
+using TaskSync.ExternalApi.Interfaces;
 using TaskSync.Infrastructure.Caching;
 using TaskSync.Infrastructure.Caching.Interfaces;
 using TaskSync.Infrastructure.Http;
@@ -16,16 +18,17 @@ namespace TaskSync.Infrastructure.Configurations
 {
     public static class DependencyInjectionConfiguration
     {
-        public static IServiceCollection RegisterDependencies(this IServiceCollection services, IConfiguration configuration)
+        public static IServiceCollection ConfigureDependencyInjection(this IServiceCollection services, IConfiguration configuration)
         {
             services.AddDbContext<AppDbContext>(options =>
                 options.UseNpgsql(configuration.GetConnectionString("DefaultConnection"))
             );
 
             services.AddSingleton<IJwtService, JwtService>();
+            services.AddSingleton<IHomeVmService, HomeVmService>();
             services.AddSingleton<ITaskNotificationService, TaskNotificationService>();
-            services.AddSingleton<IMemoryCacheService<IList<TaskEntity>>, TaskEntitiesCache>();
             services.AddSingleton<ICacheBackgroundRefresher, CacheBackgroundRefresher>();
+            services.AddSingleton<IMemoryCacheService<IList<TaskEntity>>, TaskEntitiesCache>();
 
             services.AddScoped<IHttpContextReader, HttpContextReader>();
             services.AddScoped<IRepository<UserEntity>, UserRepository>();
@@ -34,6 +37,8 @@ public static IServiceCollection RegisterDependencies(this IServiceCollection se
             services.AddScoped<IAuthenticationService, AuthenticationService>();
             services.AddScoped<ITaskService, TaskService>();
 
+            services.AddScoped<IGamificationApi, GamificationApi>();
+
             return services;
         }
     }

backend/Infrastructure/Configurations/ResponseCompressionConfiguration.cs

@@ -0,0 +1,26 @@
+using System.IO.Compression;
+
+using Microsoft.AspNetCore.ResponseCompression;
+
+namespace TaskSync.Infrastructure.Configurations
+{
+    public static class ResponseCompressionConfiguration
+    {
+
+        public static IServiceCollection ConfigureResponseCompression(this IServiceCollection services)
+        {
+            services.AddResponseCompression(options =>
+            {
+                options.Providers.Add<GzipCompressionProvider>();
+                options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(new[] { "application/json" }); // explicitly add JSON
+            });
+
+            services.Configure<GzipCompressionProviderOptions>(options =>
+            {
+                options.Level = CompressionLevel.Fastest;
+            });
+
+            return services;
+        }
+    }
+}

backend/Infrastructure/Configurations/SettingsConfiguration.cs

@@ -6,8 +6,10 @@ public static class SettingsConfiguration
     {
         public static IServiceCollection ConfigureAppSettings(this IServiceCollection services, IConfiguration configuration)
         {
+            services.Configure<AppInfo>(configuration.GetSection("AppInfo"));
             services.Configure<JwtSettings>(configuration.GetSection("JwtSettings"));
             services.Configure<MiddlewareSettings>(configuration.GetSection("MiddlewareSettings"));
+            services.Configure<GamificationApiSettings>(configuration.GetSection("GamificationApi"));
 
             return services;
         }

backend/Infrastructure/Http/HttpContextReader.cs

@@ -7,20 +7,30 @@
     public class HttpContextReader : IHttpContextReader
     {
         private readonly IHttpContextAccessor _httpContextAccessor;
+        public HttpContextReader(IHttpContextAccessor httpContextAccessor) => _httpContextAccessor = httpContextAccessor;
 
-        public HttpContextReader(IHttpContextAccessor httpContextAccessor)
+        public string? GetConnectionId()
         {
-            _httpContextAccessor = httpContextAccessor;
+            return _httpContextAccessor.HttpContext?.Request.Headers["x-connection-id"].FirstOrDefault();
         }
 
-        public string? GetConnectionId()
+        public string GetUserId()
         {
-            return _httpContextAccessor.HttpContext?.Request.Headers["x-connection-id"].FirstOrDefault();
+            return _httpContextAccessor.HttpContext?.User.FindFirstValue(ClaimTypes.NameIdentifier) ?? string.Empty;
         }
 
-        public string? GetUserId()
+        public string? GetCookie(string cookieKey)
         {
-            return _httpContextAccessor.HttpContext?.User.FindFirstValue(ClaimTypes.NameIdentifier);
+            return _httpContextAccessor.HttpContext?.Request.Cookies[cookieKey]; // read
+            // Response.Cookies.Append("MyCookieKey", "my_value", new CookieOptions // write
+            // {
+            //     HttpOnly = true, // javascript cannot access
+            //     Secure = true,   // only https
+            //     SameSite = SameSiteMode.Strict,
+            //     Expires = DateTimeOffset.UtcNow.AddDays(7)
+            // });
+            // 
+            // Response.Cookies.Delete("MyCookieKey"); // delete
         }
     }
 }

backend/Infrastructure/Http/Interface/IHttpContextReader.cs

@@ -3,6 +3,7 @@
     public interface IHttpContextReader
     {
         string? GetConnectionId();
-        string? GetUserId();
+        string GetUserId();
+        string? GetCookie(string cookieKey);
     }
 }

backend/Infrastructure/Settings/AppInfo.cs

@@ -0,0 +1,8 @@
+namespace TaskSync.Infrastructure.Settings
+{
+    public class AppInfo
+    {
+        public required string AppName { get; set; }
+        public required string Environment { get; set; }
+    }
+}

backend/Infrastructure/Settings/GamificationApiSettings.cs

@@ -0,0 +1,7 @@
+namespace TaskSync.Infrastructure.Settings
+{
+    public class GamificationApiSettings
+    {
+        public required string BaseUrl { get; set; }
+    }
+}