feat: add patch endpoints

- add services and controllers
- edit automapper for that purpose
- make small fixes in other endpoints and services

src/CoinyProject.Api/Controllers/AlbumController.cs

@@ -25,7 +25,7 @@ public async Task<IActionResult> AddAlbum([FromBody] AlbumPostDto album)
         try
         {
             var id = await _albumService.AddAlbumAsync(album);
-            return Created($"/api/albums/{id}", id);
+            return CreatedAtAction(nameof(GetAlbumById), new { id }, await _albumService.GetAlbumById(id));
         }
         catch (ArgumentNullException e)
         {
@@ -50,4 +50,19 @@ public async Task<IActionResult> GetAlbumById([FromRoute] Guid id)
             return NotFound(e.Message);
         }
     }
+
+    [HttpPatch("{id:guid}")]
+    [Authorize]
+    public async Task<IActionResult> UpdateAlbum([FromRoute] Guid id, [FromBody] AlbumPatchDto album)
+    {
+        try
+        {
+            await _albumService.UpdateAlbumAsync(id, album);
+            return Ok(await _albumService.GetAlbumById(id));
+        }
+        catch (NotFoundException e)
+        {
+            return NotFound(e.Message);
+        }
+    }
 }

src/CoinyProject.Api/Controllers/AlbumElementController.cs

@@ -1,5 +1,6 @@
 using CoinyProject.Application.Abstractions.Services;
 using CoinyProject.Application.Dto.Album;
+using CoinyProject.Application.Dto.AlbumElement;
 using CoinyProject.Domain.Exceptions;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
@@ -16,25 +17,26 @@ public AlbumElementController(IAlbumElementService albumElementService)
     {
         _albumElementService = albumElementService;
     }
-    
+
     [HttpPost]
     [Authorize]
     public async Task<IActionResult> AddAlbumElement([FromForm] AlbumElementPostDto element)
     {
         try
         {
             var id = await _albumElementService.AddAlbumElement(element);
-            return Ok(id);
+            return CreatedAtAction(nameof(GetAlbumElementById), new { id },
+                await _albumElementService.GetAlbumElementByIdAsync(id));
         }
         catch (ArgumentNullException e)
         {
             return BadRequest(e.Message);
         }
     }
-    
-    [HttpGet("{albumId:guid}")]
-    public async Task<IActionResult> GetPagedAlbumElementsByAlbumIdAsync([FromRoute]Guid albumId, 
-        [FromQuery]int page = 1, int size = 10)
+
+    [HttpGet("by-album/{albumId:guid}")]
+    public async Task<IActionResult> GetPagedAlbumElementsByAlbumIdAsync([FromRoute] Guid albumId,
+        [FromQuery] int page = 1, int size = 10)
     {
         try
         {
@@ -50,4 +52,33 @@ public async Task<IActionResult> GetPagedAlbumElementsByAlbumIdAsync([FromRoute]
             return NotFound(e.Message);
         }
     }
+
+    [HttpGet("{id:guid}")]
+    public async Task<IActionResult> GetAlbumElementById([FromRoute] Guid id)
+    {
+        try
+        {
+            var element = await _albumElementService.GetAlbumElementByIdAsync(id);
+            return Ok(element);
+        }
+        catch (NotFoundException e)
+        {
+            return NotFound(e.Message);
+        }
+    }
+
+    [HttpPatch("{id:guid}")]
+    [Authorize]
+    public async Task<IActionResult> UpdateAlbumElement([FromRoute] Guid id, [FromForm] AlbumElementPatchDto element)
+    {
+        try
+        {
+            await _albumElementService.UpdateAlbumElementAsync(id, element);
+            return Ok(await _albumElementService.GetAlbumElementByIdAsync(id));
+        }
+        catch (NotFoundException e)
+        {
+            return NotFound(e.Message);
+        }
+    }
 }

src/CoinyProject.Application/Abstractions/Repositories/IGenericRepository.cs

@@ -8,6 +8,7 @@ public interface IGenericRepository<TEntity> where TEntity : class
         Task<TEntity?> GetByIdAsync(Guid id);
         Task<IEnumerable<TEntity>?> GetAllAsync();
         Task AddAsync(TEntity entity);
+        void Update(TEntity entity);
         void Remove(TEntity entity);
     }
 }

src/CoinyProject.Application/Abstractions/Services/IAlbumElementService.cs

@@ -1,5 +1,6 @@
 using CoinyProject.Application.Dto.Album;
 using CoinyProject.Application.DTO.Album;
+using CoinyProject.Application.Dto.AlbumElement;
 using CoinyProject.Application.Dto.Other;
 
 namespace CoinyProject.Application.Abstractions.Services;
@@ -8,5 +9,7 @@ public interface IAlbumElementService
 {
     Task<Guid> AddAlbumElement(AlbumElementPostDto element);
     Task<PagedResponse<AlbumElementGetDto> > GetPagedAlbumElementsByAlbumIdAsync(Guid id, int page, int size);
+    Task<AlbumElementGetDto> GetAlbumElementByIdAsync(Guid id);
+    Task<Guid> UpdateAlbumElementAsync(Guid id, AlbumElementPatchDto element);
 
 }

src/CoinyProject.Application/Abstractions/Services/IAlbumService.cs

@@ -6,7 +6,8 @@ namespace CoinyProject.Application.Abstractions.Services
     public interface IAlbumService
     {
         Task<Guid> AddAlbumAsync(AlbumPostDto album);
-        Task<AlbumWithElementsGetDto> GetAlbumById(Guid id);
+        Task<AlbumGetDto> GetAlbumById(Guid id);
+        Task<Guid> UpdateAlbumAsync(Guid id, AlbumPatchDto album);
         /*Task AddAlbumElement(AlbumElementPostDto? albumElement);
         Task<IEnumerable<AlbumGetDto>> GetAllAlbumsDTO(string? userId);
         Task<IEnumerable<AlbumGetForViewDTO>> GetAllAlbumsForView(string? userId);

src/CoinyProject.Application/AutoMapper/AutoMapperProfile.cs

@@ -2,6 +2,7 @@
 using CoinyProject.Application.AutoMapper.Resolvers;
 using CoinyProject.Application.Dto.Album;
 using CoinyProject.Application.DTO.Album;
+using CoinyProject.Application.Dto.AlbumElement;
 using CoinyProject.Application.Dto.Other;
 using CoinyProject.Domain.Entities;
 
@@ -15,11 +16,16 @@ public AutoMapperProfile()
 
             CreateMap<AlbumPostDto, Album>();
             CreateMap<AlbumElementPostDto, AlbumElement>()
-                .ForMember(dest => dest.ImageUrl, opt => opt.Ignore());
+                .ForMember(dest => dest.ImageUrl, src => src.Ignore());
 
-            CreateMap<Album, AlbumWithElementsGetDto>();
+            CreateMap<Album, AlbumGetDto>();
             CreateMap<AlbumElement, AlbumElementGetDto>()
-                .ForMember(dest => dest.ImageUrl, src => src.MapFrom<ImageUrlResolver>());
+                .ForMember(dest => dest.ImageUrl, src => src.MapFrom<GetImageUrlResolver>());
+
+            CreateMap<AlbumPatchDto, Album>()
+                .ForAllMembers(opts => opts.Condition((src, dest, srcMember) => srcMember != null));
+            CreateMap<AlbumElementPatchDto, AlbumElement>()
+                .ForAllMembers(opts => opts.Condition((src, dest, srcMember) => srcMember != null));
 
 
 

src/CoinyProject.Application/AutoMapper/Resolvers/ImageUrlResolver.cs → src/CoinyProject.Application/AutoMapper/Resolvers/GetImageUrlResolver.cs

@@ -1,15 +1,16 @@
 using AutoMapper;
 using CoinyProject.Application.Abstractions.DataServices;
 using CoinyProject.Application.DTO.Album;
+using CoinyProject.Application.Dto.AlbumElement;
 using CoinyProject.Domain.Entities;
 
 namespace CoinyProject.Application.AutoMapper.Resolvers;
 
-public class ImageUrlResolver : IValueResolver<AlbumElement, AlbumElementGetDto, string>
+public class GetImageUrlResolver : IValueResolver<AlbumElement, AlbumElementGetDto, string>
 {
     private readonly IFileService _fileService;
 
-    public ImageUrlResolver(IFileService fileService)
+    public GetImageUrlResolver(IFileService fileService)
     {
         _fileService = fileService;
     }

src/CoinyProject.Application/Dto/Album/AlbumPatchDto.cs

@@ -0,0 +1,3 @@
+namespace CoinyProject.Application.Dto.Album;
+
+public record AlbumPatchDto(string? Name, string? Description);

src/CoinyProject.Application/Dto/Album/AlbumElementGetDTO.cs → src/CoinyProject.Application/Dto/AlbumElement/AlbumElementGetDto.cs

@@ -1,5 +1,5 @@
 
-namespace CoinyProject.Application.DTO.Album
+namespace CoinyProject.Application.Dto.AlbumElement
 {
     public class AlbumElementGetDto
     {

src/CoinyProject.Application/Dto/AlbumElement/AlbumElementPatchDto.cs

@@ -0,0 +1,5 @@
+using Microsoft.AspNetCore.Http;
+
+namespace CoinyProject.Application.Dto.AlbumElement;
+
+public record AlbumElementPatchDto(string? Name, string? Description, IFormFile? Photo);

src/CoinyProject.Application/Dto/Album/AlbumElementPostDto.cs → src/CoinyProject.Application/Dto/AlbumElement/AlbumElementPostDto.cs

@@ -1,7 +1,7 @@
 
 using Microsoft.AspNetCore.Http;
 
-namespace CoinyProject.Application.Dto.Album
+namespace CoinyProject.Application.Dto.AlbumElement
 {
     public record AlbumElementPostDto(string Name, string? Description, Guid AlbumId, IFormFile Photo);
 }

src/CoinyProject.Application/Services/AlbumElementService.cs

@@ -4,6 +4,7 @@
 using CoinyProject.Application.Abstractions.Services;
 using CoinyProject.Application.Dto.Album;
 using CoinyProject.Application.DTO.Album;
+using CoinyProject.Application.Dto.AlbumElement;
 using CoinyProject.Application.Dto.Other;
 using CoinyProject.Domain.Entities;
 using CoinyProject.Domain.Exceptions;
@@ -44,10 +45,31 @@ public async Task<PagedResponse<AlbumElementGetDto>> GetPagedAlbumElementsByAlbu
 
         var elements = await _unitOfWork.AlbumElements.GetPagedAlbumElementsByAlbumIdAsync(id, page, size);
         if (elements.TotalPages == 0)
-        {
             throw new NotFoundException("No elements found for this album");
-        }
 
         return _mapper.Map<PagedResponse<AlbumElementGetDto>>(elements);
     }
+
+    public async Task<AlbumElementGetDto> GetAlbumElementByIdAsync(Guid id)
+    {
+        var element = await _unitOfWork.AlbumElements.GetByIdAsync(id);
+        if (element == null)
+            throw new NotFoundException("Element not found");
+
+        return _mapper.Map<AlbumElementGetDto>(element);
+    }
+
+    public async Task<Guid> UpdateAlbumElementAsync(Guid id, AlbumElementPatchDto element)
+    {
+        var oldElement = await _unitOfWork.AlbumElements.GetByIdAsync(id);
+        if (oldElement == null)
+            throw new NotFoundException("Element not found");
+
+        _mapper.Map(element, oldElement);
+        if (element.Photo != null)
+            oldElement.ImageUrl = await _fileService.SaveImageAsync(element.Photo);
+
+        await _unitOfWork.SaveChangesAsync();
+        return id;
+    }
 }

src/CoinyProject.Application/Services/AlbumService.cs

@@ -7,9 +7,7 @@
 using CoinyProject.Domain.Entities;
 using CoinyProject.Domain.Exceptions;
 using Microsoft.IdentityModel.Tokens;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Identity;
 
 
 namespace CoinyProject.Application.Services
@@ -18,17 +16,14 @@ public class AlbumService : IAlbumService
     {
         private readonly IMapper _mapper;
         private readonly IUnitOfWork _unitOfWork;
-        private readonly IHostingEnvironment _hostingEnvironment;
         private readonly IHttpContextAccessor _httpContextAccessor;
 
        // private readonly string imageFolder = "albums/elements/";
 
-       public AlbumService(IMapper mapper, IUnitOfWork unitOfWork, IHostingEnvironment hostingEnvironment,
-           IHttpContextAccessor httpContextAccessor)
+       public AlbumService(IMapper mapper, IUnitOfWork unitOfWork, IHttpContextAccessor httpContextAccessor)
        {
            _mapper = mapper;
            _unitOfWork = unitOfWork;
-           _hostingEnvironment = hostingEnvironment;
            _httpContextAccessor = httpContextAccessor;
        }
 
@@ -86,14 +81,27 @@ public async Task<Guid> AddAlbumAsync(AlbumPostDto album)
             return entity.Id;
         }
 
-        public async Task<AlbumWithElementsGetDto> GetAlbumById(Guid id)
+        public async Task<AlbumGetDto> GetAlbumById(Guid id)
         {
             var album = await _unitOfWork.Albums.GetByIdAsync(id);
 
             if (album == null)
                 throw new NotFoundException("Album not found.");
 
-            return _mapper.Map<AlbumWithElementsGetDto>(album);
+            return _mapper.Map<AlbumGetDto>(album);
+        }
+
+        public async Task<Guid> UpdateAlbumAsync(Guid id, AlbumPatchDto album)
+        {
+            var oldAlbum = await _unitOfWork.Albums.GetByIdAsync(id);
+            if (oldAlbum == null)
+                throw new NotFoundException("Album not found.");
+
+            _mapper.Map(album, oldAlbum);
+            await _unitOfWork.SaveChangesAsync();
+
+            return id;
+
         }