Feature/issue 833 timeline context

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/Create/CreateHistoricalContextCommand.cs

@@ -0,0 +1,9 @@
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.Timeline;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.Create
+{
+    public record CreateHistoricalContextCommand(HistoricalContextDTO context)
+        : IRequest<Result<HistoricalContextDTO>>;
+}

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/Create/CreateHistoricalContextHandler.cs

@@ -0,0 +1,49 @@
+using AutoMapper;
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.Timeline;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.Create
+{
+    public class CreateHistoricalContextHandler : IRequestHandler<CreateHistoricalContextCommand, Result<HistoricalContextDTO>>
+    {
+        private readonly IMapper _mapper;
+        private readonly IRepositoryWrapper _repositoryWrapper;
+        private readonly ILoggerService _logger;
+
+        public CreateHistoricalContextHandler(IMapper mapper, IRepositoryWrapper repositoryWrapper, ILoggerService logger)
+        {
+            _mapper = mapper;
+            _repositoryWrapper = repositoryWrapper;
+            _logger = logger;
+        }
+
+        public async Task<Result<HistoricalContextDTO>> Handle(CreateHistoricalContextCommand request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                /* read comment at Streetcode.BLL.MediatR.Timeline.HistoricalContext.Update line 29 */
+                var context = _mapper.Map<DAL.Entities.Timeline.HistoricalContext>(request.context);
+                var checkIfContextExists = await _repositoryWrapper.HistoricalContextRepository.GetFirstOrDefaultAsync(j => j.Title == request.context.Title);
+
+                if (checkIfContextExists is not null)
+                {
+                    string exceptionMessege = $"Context with title '{request.context.Title}' is already exists.";
+                    _logger.LogError(request, exceptionMessege);
+                    return Result.Fail(exceptionMessege);
+                }
+
+                var createdContext = await _repositoryWrapper.HistoricalContextRepository.CreateAsync(context);
+                await _repositoryWrapper.SaveChangesAsync();
+                return Result.Ok(_mapper.Map<HistoricalContextDTO>(createdContext));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(request, ex.Message);
+                return Result.Fail(ex.Message);
+            }
+        }
+    }
+}

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/Delete/DeleteHistoricalContextCommand.cs

@@ -0,0 +1,8 @@
+using FluentResults;
+using MediatR;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.Delete
+{
+    public record DeleteHistoricalContextCommand(int contextId)
+        : IRequest<Result<int>>;
+}

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/Delete/DeleteHistoricalContextHandler.cs

@@ -0,0 +1,43 @@
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.Delete
+{
+    public class DeleteHistoricalContextHandler : IRequestHandler<DeleteHistoricalContextCommand, Result<int>>
+    {
+        private readonly IRepositoryWrapper _repositoryWrapper;
+        private readonly ILoggerService _logger;
+
+        public DeleteHistoricalContextHandler(IRepositoryWrapper repository, ILoggerService logger)
+        {
+            _repositoryWrapper = repository;
+            _logger = logger;
+        }
+
+        public async Task<Result<int>> Handle(DeleteHistoricalContextCommand request, CancellationToken cancellationToken)
+        {
+            var contextToDelete =
+                await _repositoryWrapper.HistoricalContextRepository.GetFirstOrDefaultAsync(x => x.Id == request.contextId);
+            if (contextToDelete is null)
+            {
+                string exMessage = $"No context found by entered Id - {request.contextId}";
+                _logger.LogError(request, exMessage);
+                return Result.Fail(exMessage);
+            }
+
+            try
+            {
+                _repositoryWrapper.HistoricalContextRepository.Delete(contextToDelete);
+                await _repositoryWrapper.SaveChangesAsync();
+                return Result.Ok(request.contextId);
+            }
+            catch(Exception ex)
+            {
+                _logger.LogError(request, ex.Message);
+                return Result.Fail(ex.Message);
+            }
+        }
+    }
+}

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/GetAll/GetAllHistoricalContextHandler.cs

@@ -1,7 +1,6 @@
 using AutoMapper;
 using FluentResults;
 using MediatR;
-using Streetcode.BLL.DTO.AdditionalContent.Subtitles;
 using Microsoft.Extensions.Localization;
 using Streetcode.BLL.DTO.Timeline;
 using Streetcode.BLL.Interfaces.Logging;
@@ -38,7 +37,9 @@ public async Task<Result<IEnumerable<HistoricalContextDTO>>> Handle(GetAllHistor
                 return Result.Fail(new Error(errorMsg));
             }
 
-            return Result.Ok(_mapper.Map<IEnumerable<HistoricalContextDTO>>(historicalContextItems));
+            var historicalContexts = historicalContextItems.OrderBy(context => context.Title);
+
+            return Result.Ok(_mapper.Map<IEnumerable<HistoricalContextDTO>>(historicalContexts));
         }
     }
 }

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/GetById/GetHistoricalContextByIdHandler.cs

@@ -0,0 +1,46 @@
+using AutoMapper;
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.Timeline;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.GetById
+{
+    public class GetHistoricalContextByIdHandler : IRequestHandler<GetHistoricalContextByIdQuery, Result<HistoricalContextDTO>>
+    {
+        private readonly IMapper _mapper;
+        private readonly IRepositoryWrapper _repository;
+        private readonly ILoggerService _loggerService;
+
+        public GetHistoricalContextByIdHandler(IMapper mapper, IRepositoryWrapper repository, ILoggerService loggerService)
+        {
+            _mapper = mapper;
+            _repository = repository;
+            _loggerService = loggerService;
+        }
+
+        public async Task<Result<HistoricalContextDTO>> Handle(GetHistoricalContextByIdQuery request, CancellationToken cancellationToken)
+        {
+            var context = await _repository.HistoricalContextRepository.GetFirstOrDefaultAsync(j => j.Id == request.contextId);
+
+            if (context is null)
+            {
+                string exceptionMessege = $"No context found by entered Id - {request.contextId}";
+                _loggerService.LogError(request, exceptionMessege);
+                return Result.Fail(exceptionMessege);
+            }
+
+            try
+            {
+                var contextDto = _mapper.Map<HistoricalContextDTO>(context);
+                return Result.Ok(contextDto);
+            }
+            catch (Exception ex)
+            {
+                _loggerService.LogError(request, ex.Message);
+                return Result.Fail(ex.Message);
+            }
+        }
+    }
+}

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/GetById/GetHistoricalContextByIdQuery.cs

@@ -0,0 +1,8 @@
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.Timeline;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.GetById;
+
+public record GetHistoricalContextByIdQuery(int contextId)
+    : IRequest<Result<HistoricalContextDTO>>;

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/GetByTitle/GetHistoricalContextByTitleHandler.cs

@@ -0,0 +1,46 @@
+using AutoMapper;
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.Timeline;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.BLL.MediatR.Timeline.HistoricalContext.GetById;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.GetByTitle;
+
+public class GetHistoricalContextByTitleHandler : IRequestHandler<GetHistoricalContextByTitleQuery, Result<HistoricalContextDTO>>
+{
+    private readonly IMapper _mapper;
+    private readonly IRepositoryWrapper _repository;
+    private readonly ILoggerService _loggerService;
+
+    public GetHistoricalContextByTitleHandler(IMapper mapper, IRepositoryWrapper repository, ILoggerService loggerService)
+    {
+        _mapper = mapper;
+        _repository = repository;
+        _loggerService = loggerService;
+    }
+
+    public async Task<Result<HistoricalContextDTO>> Handle(GetHistoricalContextByTitleQuery request, CancellationToken cancellationToken)
+    {
+        var context = await _repository.HistoricalContextRepository.GetFirstOrDefaultAsync(j => j.Title == request.title);
+
+        if (context is null)
+        {
+            string exceptionMessege = $"No context found by title - {request.title}";
+            _loggerService.LogError(request, exceptionMessege);
+            return Result.Fail(exceptionMessege);
+        }
+
+        try
+        {
+            var contextDto = _mapper.Map<HistoricalContextDTO>(context);
+            return Result.Ok(contextDto);
+        }
+        catch (Exception ex)
+        {
+            _loggerService.LogError(request, ex.Message);
+            return Result.Fail(ex.Message);
+        }
+    }
+}

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/GetByTitle/GetHistoricalContextByTitleQuery.cs

@@ -0,0 +1,8 @@
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.Timeline;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.GetByTitle;
+
+public record GetHistoricalContextByTitleQuery(string title)
+    : IRequest<Result<HistoricalContextDTO>>;

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/Update/UpdateHistoricalContextCommand.cs

@@ -0,0 +1,8 @@
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.Timeline;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.Update
+{
+    public record UpdateHistoricalContextCommand(HistoricalContextDTO HistoricalContext) : IRequest<Result<HistoricalContextDTO>>;
+}

Streetcode/Streetcode.BLL/MediatR/Timeline/HistoricalContext/Update/UpdateHistoricalContextHandler.cs

@@ -0,0 +1,65 @@
+using AutoMapper;
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.Timeline;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+
+namespace Streetcode.BLL.MediatR.Timeline.HistoricalContext.Update
+{
+    public class
+        UpdateHistoricalContextHandler : IRequestHandler<UpdateHistoricalContextCommand, Result<HistoricalContextDTO>>
+    {
+        private readonly IMapper _mapper;
+        private readonly IRepositoryWrapper _repositoryWrapper;
+        private readonly ILoggerService _logger;
+
+        public UpdateHistoricalContextHandler(IRepositoryWrapper repository, IMapper mapper, ILoggerService logger)
+        {
+            _repositoryWrapper = repository;
+            _mapper = mapper;
+            _logger = logger;
+        }
+
+        public async Task<Result<HistoricalContextDTO>> Handle(
+            UpdateHistoricalContextCommand request,
+            CancellationToken cancellationToken)
+        {
+            var historicalContext =
+                await _repositoryWrapper.HistoricalContextRepository.GetFirstOrDefaultAsync(x =>
+                    x.Id == request.HistoricalContext.Id);
+            if (historicalContext is null)
+            {
+                string exMessage = $"No context found by entered Id - {request.HistoricalContext.Id}";
+                _logger.LogError(request, exMessage);
+                return Result.Fail(exMessage);
+            }
+
+            var historicalContextRepeat = await _repositoryWrapper.HistoricalContextRepository.GetFirstOrDefaultAsync(
+                x =>
+                    x.Title == request.HistoricalContext.Title);
+
+            if (historicalContextRepeat is not null)
+            {
+                string exMessage = $"There is already a context with title - {request.HistoricalContext.Title}";
+                _logger.LogError(request, exMessage);
+                return Result.Fail(exMessage);
+            }
+
+            try
+            {
+                /* have some shitty code right here, if you delete the DAL.Entities.Timeline. part it will show error
+                even if you have using Streetcode.DAL.Entities.Timeline; so sad :( */
+                var contextToUpdate = _mapper.Map<DAL.Entities.Timeline.HistoricalContext>(request.HistoricalContext);
+                _repositoryWrapper.HistoricalContextRepository.Update(contextToUpdate);
+                await _repositoryWrapper.SaveChangesAsync();
+                return Result.Ok(_mapper.Map<HistoricalContextDTO>(contextToUpdate));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(request, ex.Message);
+                return Result.Fail(ex.Message);
+            }
+        }
+    }
+}

Streetcode/Streetcode.WebApi/Controllers/Timeline/HistoricalContextController.cs

@@ -1,5 +1,13 @@
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Streetcode.BLL.DTO.Timeline;
+using Streetcode.BLL.MediatR.Timeline.HistoricalContext.Create;
+using Streetcode.BLL.MediatR.Timeline.HistoricalContext.Delete;
 using Streetcode.BLL.MediatR.Timeline.HistoricalContext.GetAll;
+using Streetcode.BLL.MediatR.Timeline.HistoricalContext.GetById;
+using Streetcode.BLL.MediatR.Timeline.HistoricalContext.GetByTitle;
+using Streetcode.BLL.MediatR.Timeline.HistoricalContext.Update;
+using Streetcode.DAL.Enums;
 
 namespace Streetcode.WebApi.Controllers.Timeline
 {
@@ -10,5 +18,44 @@ public async Task<IActionResult> GetAll()
         {
             return HandleResult(await Mediator.Send(new GetAllHistoricalContextQuery()));
         }
+
+        [HttpGet("{id:int}")]
+        public async Task<IActionResult> GetById(int id)
+        {
+            return HandleResult(await Mediator.Send(new GetHistoricalContextByIdQuery(id)));
+        }
+
+        [HttpGet("{title}")]
+        public async Task<IActionResult> GetByTitle(string title)
+        {
+            return HandleResult(await Mediator.Send(new GetHistoricalContextByTitleQuery(title)));
+        }
+
+        [HttpPut]
+        [Authorize(Roles = nameof(UserRole.Admin))]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        public async Task<IActionResult> Update([FromBody]HistoricalContextDTO contextDto)
+        {
+            return HandleResult(await Mediator.Send(new UpdateHistoricalContextCommand(contextDto)));
+        }
+
+        [HttpDelete("{id:int}")]
+        [Authorize(Roles = nameof(UserRole.Admin))]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        public async Task<IActionResult> Delete(int id)
+        {
+            return HandleResult(await Mediator.Send(new DeleteHistoricalContextCommand(id)));
+        }
+
+        [HttpPost]
+        [Authorize(Roles = nameof(UserRole.Admin))]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        public async Task<IActionResult> Create([FromBody]HistoricalContextDTO contextDto)
+        {
+            return HandleResult(await Mediator.Send(new CreateHistoricalContextCommand(contextDto)));
+        }
     }
 }

Streetcode/Streetcode.WebApi/appsettings.Local.json

@@ -1,6 +1,6 @@
 {
   "ConnectionStrings": {
-    "DefaultConnection": "Server=127.0.0.1;Database=StreetcodeDb;User Id=sa;Password=Admin@1234;MultipleActiveResultSets=true"
+    "DefaultConnection": "Server=PC;Database=Streetcode1;MultipleActiveResultSets=True;TrustServerCertificate=true;Trusted_Connection=true"
   },
   "CORS": {
     "AllowedOrigins": [ "http://localhost:3000" ],