Feature/issue 833 timeline context

Streetcode/Streetcode.BLL/DTO/AdditionalContent/Tag/UpdateTagDTO.cs

@@ -0,0 +1,9 @@
+namespace Streetcode.BLL.DTO.AdditionalContent.Tag
+{
+    public class UpdateTagDTO
+    {
+        public int Id { get; set; }
+
+        public string Title { get; set; }
+    }
+}

Streetcode/Streetcode.BLL/Mapping/AdditionalContent/TagProfile.cs

@@ -10,6 +10,7 @@ public class TagProfile : Profile
     public TagProfile()
     {
         CreateMap<Tag, TagDTO>().ForMember(x => x.Streetcodes, conf => conf.Ignore());
+        CreateMap<Tag, UpdateTagDTO>().ReverseMap();
         CreateMap<Tag, StreetcodeTagDTO>().ReverseMap();
         CreateMap<StreetcodeTagIndex, StreetcodeTagDTO>()
             .ForMember(x => x.Id, conf => conf.MapFrom(ti => ti.TagId))

Streetcode/Streetcode.BLL/MediatR/AdditionalContent/Tag/Create/CreateTagHandler.cs

@@ -22,6 +22,15 @@ public CreateTagHandler(IRepositoryWrapper repositoryWrapper, IMapper mapper, IL
 
         public async Task<Result<TagDTO>> Handle(CreateTagQuery request, CancellationToken cancellationToken)
         {
+            var exists = await _repositoryWrapper.TagRepository.GetFirstOrDefaultAsync(t => request.tag.Title == t.Title);
+
+            if (exists is not null)
+            {
+                var errMessage = $"Tag with title {request.tag.Title} already exists";
+                _logger.LogError(request, errMessage);
+                return Result.Fail(errMessage);
+            }
+
             var newTag = await _repositoryWrapper.TagRepository.CreateAsync(new DAL.Entities.AdditionalContent.Tag()
             {
                 Title = request.tag.Title

Streetcode/Streetcode.BLL/MediatR/AdditionalContent/Tag/Delete/DeleteTagCommand.cs

@@ -0,0 +1,8 @@
+using FluentResults;
+using MediatR;
+
+namespace Streetcode.BLL.MediatR.AdditionalContent.Tag.Delete
+{
+  public record DeleteTagCommand(int id)
+        : IRequest<Result<int>>;
+}

Streetcode/Streetcode.BLL/MediatR/AdditionalContent/Tag/Delete/DeleteTagHandler.cs

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

Streetcode/Streetcode.BLL/MediatR/AdditionalContent/Tag/GetAll/GetAllTagsHandler.cs

@@ -29,14 +29,14 @@ public GetAllTagsHandler(IRepositoryWrapper repositoryWrapper, IMapper mapper, I
     public async Task<Result<IEnumerable<TagDTO>>> Handle(GetAllTagsQuery request, CancellationToken cancellationToken)
     {
         var tags = await _repositoryWrapper.TagRepository.GetAllAsync();
-
         if (tags is null)
         {
             string errorMsg = _stringLocalizerCannotFind?["CannotFindAnyTags"].Value;
             _logger.LogError(request, errorMsg);
             return Result.Fail(new Error(errorMsg));
         }
 
-        return Result.Ok(_mapper.Map<IEnumerable<TagDTO>>(tags));
+        var sorted_tags = tags.OrderBy(tag => tag.Title);
+        return Result.Ok(_mapper.Map<IEnumerable<TagDTO>>(sorted_tags));
     }
 }

Streetcode/Streetcode.BLL/MediatR/AdditionalContent/Tag/Update/UpdateTagCommand.cs

@@ -0,0 +1,10 @@
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.AdditionalContent;
+using Streetcode.BLL.DTO.AdditionalContent.Tag;
+
+namespace Streetcode.BLL.MediatR.AdditionalContent.Tag.Update
+{
+	public record UpdateTagCommand(UpdateTagDTO tag)
+		: IRequest<Result<TagDTO>>;
+}

Streetcode/Streetcode.BLL/MediatR/AdditionalContent/Tag/Update/UpdateTagHandler.cs

@@ -0,0 +1,57 @@
+using AutoMapper;
+using FluentResults;
+using MediatR;
+using Streetcode.BLL.DTO.AdditionalContent;
+using Streetcode.BLL.Interfaces.Logging;
+using Streetcode.DAL.Repositories.Interfaces.Base;
+using TagEntity = Streetcode.DAL.Entities.AdditionalContent.Tag;
+
+namespace Streetcode.BLL.MediatR.AdditionalContent.Tag.Update
+{
+	public class UpdateTagHandler : IRequestHandler<UpdateTagCommand, Result<TagDTO>>
+	{
+		private readonly IRepositoryWrapper _repositoryWrapper;
+		private readonly IMapper _mapper;
+		private readonly ILoggerService _logger;
+		public UpdateTagHandler(IRepositoryWrapper repository, IMapper mapper, ILoggerService logger)
+		{
+			_repositoryWrapper = repository;
+			_mapper = mapper;
+			_logger = logger;
+		}
+
+		public async Task<Result<TagDTO>> Handle(UpdateTagCommand request, CancellationToken cancellationToken)
+		{
+			var existedTag =
+				await _repositoryWrapper.TagRepository.GetFirstOrDefaultAsync(x => x.Id == request.tag.Id);
+			if (existedTag is null)
+			{
+				string exMessage = $"No tag found by entered Id - {request.tag.Id}";
+				_logger.LogError(request, exMessage);
+				return Result.Fail(exMessage);
+			}
+
+			existedTag = await _repositoryWrapper.TagRepository.GetFirstOrDefaultAsync(x => x.Title == request.tag.Title);
+
+			if (existedTag is not null)
+			{
+                var errMessage = $"Tag with title {request.tag.Title} already exists";
+                _logger.LogError(request, errMessage);
+                return Result.Fail(errMessage);
+            }
+
+			try
+			{
+				var tagToUpdate = _mapper.Map<TagEntity>(request.tag);
+				_repositoryWrapper.TagRepository.Update(tagToUpdate);
+				await _repositoryWrapper.SaveChangesAsync();
+				return Result.Ok(_mapper.Map<TagDTO>(tagToUpdate));
+			}
+			catch(Exception ex)
+			{
+				_logger.LogError(request, ex.Message);
+				return Result.Fail(ex.Message);
+			}
+		}
+	}
+}

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>>;