Add services and controllers for games (#12)

Co-authored-by: Maxime Adler <madler@sqli.com>
Reviewed-on: #12

src/GameIdeas/Server/GameIdeas.WebAPI/Services/GameService.cs

@@ -0,0 +1,174 @@
+using AutoMapper;
+using GameIdeas.Shared.Dto;
+using GameIdeas.Shared.Exceptions;
+using GameIdeas.Shared.Model;
+using GameIdeas.WebAPI.Context;
+using Microsoft.EntityFrameworkCore;
+
+namespace GameIdeas.WebAPI.Services;
+
+public class GameService(GameIdeasContext context, IMapper mapper)
+{
+    public async Task<IEnumerable<GameDto>> GetGames(PaggingDto pagging)
+    {
+        var games = await SelectGames()
+            .OrderBy(g => g.Title)
+            .Skip((pagging.CurrentPage - 1) * pagging.NumberPerPage)
+            .Take(pagging.NumberPerPage)
+            .ToListAsync();
+
+        return mapper.Map<IEnumerable<GameDto>>(games);
+    }
+
+    public async Task<GameDto> GetGameById(int gameId)
+    {
+        var game = await SelectGames()
+            .FirstOrDefaultAsync(g => g.Id == gameId);
+
+        return game == null
+            ? throw new NotFoundException($"[{typeof(Game).FullName}] with ID {gameId} has not been found in context")
+            : mapper.Map<GameDto>(game);
+    }
+
+    public async Task<GameDto> CreateGame(GameDto gameDto)
+    {
+        var gameToCreate = mapper.Map<Game>(gameDto);
+
+        await context.Games.AddAsync(gameToCreate);
+        await context.SaveChangesAsync();
+
+        await HandlePlatformsCreation(gameDto.Platforms, gameToCreate.Id);
+        await HandlePropertiesCreation(gameDto.Properties, gameToCreate.Id);
+        await HandleTagsCreation(gameDto.Tags, gameToCreate.Id);
+        await HandlePublishersCreation(gameDto.Publishers, gameToCreate.Id);
+        await HandleDevelopersCreation(gameDto.Developers, gameToCreate.Id);
+
+        await context.SaveChangesAsync();
+
+        return mapper.Map<GameDto>(gameToCreate);
+    }
+
+    public async Task<GameDto> UpdateGame(GameDto gameDto)
+    {
+        if (await context.Games.CountAsync(g => g.Id == gameDto.Id) == 0)
+        {
+            throw new NotFoundException($"[{typeof(Game).FullName}] with ID {gameDto.Id} has not been found in context");
+        }
+
+        var gameToUpdate = mapper.Map<Game>(gameDto);
+
+        await HandlePlatformsCreation(gameDto.Platforms, gameToUpdate.Id);
+        await HandlePropertiesCreation(gameDto.Properties, gameToUpdate.Id);
+        await HandleTagsCreation(gameDto.Tags, gameToUpdate.Id);
+        await HandlePublishersCreation(gameDto.Publishers, gameToUpdate.Id);
+        await HandleDevelopersCreation(gameDto.Developers, gameToUpdate.Id);
+
+        context.Games.Update(gameToUpdate);
+        await context.SaveChangesAsync();
+
+        return mapper.Map<GameDto>(gameToUpdate);
+    }
+
+    public async Task<bool> DeleteGame(int gameId)
+    {
+        var gameToRemove = await context.Games
+            .FirstOrDefaultAsync(g => g.Id == gameId)
+            ?? throw new NotFoundException($"[{typeof(Game).FullName}] with ID {gameId} has not been found in context");
+
+        context.Games.Remove(gameToRemove);
+        return await context.SaveChangesAsync() != 0;
+    }
+
+    private IQueryable<Game> SelectGames()
+    {
+        return context.Games
+            .Include(g => g.CreationUser)
+            .Include(g => g.ModificationUser)
+            .Include(g => g.GamePlatforms).ThenInclude(p => p.Platform)
+            .Include(g => g.GameProperties).ThenInclude(p => p.Property)
+            .Include(g => g.GameTags).ThenInclude(p => p.Tag)
+            .Include(g => g.GamePublishers).ThenInclude(p => p.Publisher)
+            .Include(g => g.GameDevelopers).ThenInclude(p => p.Developer)
+            .AsQueryable();
+    }
+
+    private async Task HandlePlatformsCreation(IEnumerable<PlatformDto>? categoriesToCreate, int gameId)
+    {
+        if (categoriesToCreate != null)
+        {
+            var gps = mapper.Map<ICollection<GamePlatform>>(categoriesToCreate);
+
+            foreach (var gp in gps)
+            {
+                gp.GameId = gameId;
+            }
+
+            context.Platforms.AttachRange(gps.Select(gp => gp.Platform));
+            await context.GamePlatforms.AddRangeAsync(gps);
+        }
+    }
+
+    private async Task HandlePropertiesCreation(IEnumerable<PropertyDto>? categoriesToCreate, int gameId)
+    {
+        if (categoriesToCreate != null)
+        {
+            var gps = mapper.Map<ICollection<GameProperty>>(categoriesToCreate);
+
+            foreach (var gp in gps)
+            {
+                gp.GameId = gameId;
+            }
+
+            context.Properties.AttachRange(gps.Select(gp => gp.Property));
+            await context.GameProperties.AddRangeAsync(gps);
+        }
+    }
+
+    private async Task HandleTagsCreation(IEnumerable<TagDto>? categoriesToCreate, int gameId)
+    {
+        if (categoriesToCreate != null)
+        {
+            var gts = mapper.Map<ICollection<GameTag>>(categoriesToCreate);
+
+            foreach (var gt in gts)
+            {
+                gt.GameId = gameId;
+            }
+
+            context.Tags.AttachRange(gts.Select(gt => gt.Tag));
+            await context.GameTags.AddRangeAsync(gts);
+        }
+    }
+
+    private async Task HandlePublishersCreation(IEnumerable<PublisherDto>? categoriesToCreate, int gameId)
+    {
+        if (categoriesToCreate != null)
+        {
+            var gps = mapper.Map<ICollection<GamePublisher>>(categoriesToCreate);
+
+            foreach (var gp in gps)
+            {
+                gp.GameId = gameId;
+            }
+
+            context.Publishers.AttachRange(gps.Select(gp => gp.Publisher));
+            await context.GamePublishers.AddRangeAsync(gps);
+        }
+    }
+
+    private async Task HandleDevelopersCreation(IEnumerable<DeveloperDto>? categoriesToCreate, int gameId)
+    {
+        if (categoriesToCreate != null)
+        {
+            var gds = mapper.Map<ICollection<GameDeveloper>>(categoriesToCreate);
+
+            foreach (var gd in gds)
+            {
+                gd.GameId = gameId;
+            }
+
+            context.Developers.AttachRange(gds.Select(gd => gd.Developer));
+            await context.GameDevelopers.AddRangeAsync(gds);
+        }
+    }
+}

src/GameIdeas/Server/GameIdeas.WebAPI/Services/UserService.cs

@@ -0,0 +1,5 @@
+namespace GameIdeas.WebAPI.Services;
+
+public class UserService
+{
+}