Implement EnemiesService.cs

EstusShots.Server/Models/Enemy.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 
 namespace EstusShots.Server.Models
@@ -13,8 +14,6 @@ namespace EstusShots.Server.Models
 
         public bool Defeated { get; set; }
 
-        public Guid? SeasonId { get; set; }
+        public ICollection<SeasonEnemies> SeasonEnemies { get; set; } = default!;
-
-        public Season? Season { get; set; }
     }
 }

EstusShots.Server/Models/Season.cs

@@ -20,6 +20,6 @@ namespace EstusShots.Server.Models
 
         public List<Episode> Episodes { get; set; } = default!;
 
-        public List<Enemy> Enemies { get; set; } = default!;
+        public ICollection<SeasonEnemies> SeasonEnemies { get; set; } = default!;
     }
 }

EstusShots.Server/Models/SeasonEnemies.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace EstusShots.Server.Models
+{
+    public class SeasonEnemies
+    {
+        public Guid SeasonId { get; set; } = default!;
+        public Season Season { get; set; } = default!;
+
+        public Guid EnemyId { get; set; } = default!;
+        public Enemy Enemy { get; set; } = default!;
+    }
+}

EstusShots.Server/Services/EnemiesService.cs

@@ -1,9 +1,14 @@
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using AutoMapper;
+using EstusShots.Server.Models;
 using EstusShots.Shared.Interfaces;
 using EstusShots.Shared.Models;
 using EstusShots.Shared.Models.Parameters;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using Dto = EstusShots.Shared.Dto;
 
 namespace EstusShots.Server.Services
 {
@@ -20,24 +25,78 @@ namespace EstusShots.Server.Services
             _context = context;
         }
 
-        public Task<ApiResponse<GetEnemiesResponse>> GetEnemies(GetEnemiesParameter parameter)
+        public async Task<ApiResponse<GetEnemiesResponse>> GetEnemies(GetEnemiesParameter parameter)
         {
-            throw new System.NotImplementedException();
+            List<Enemy> enemies;
+            if (parameter.SeasonId.IsEmpty())
+            {
+                enemies = await _context.Enemies.ToListAsync();
+                _logger.LogInformation($"Found {enemies.Count} enemies in database");
+            }
+            else
+            {
+                enemies = await _context.Enemies
+                    .Where(e => e.SeasonEnemies.Any(x => x.SeasonId == parameter.SeasonId))
+                    .ToListAsync();
+                _logger.LogInformation($"Found {enemies.Count} enemies for season '{parameter.SeasonId}'");
+            }
+            var dtos = _mapper.Map<List<Dto.Enemy>>(enemies);
+            return new ApiResponse<GetEnemiesResponse>(new GetEnemiesResponse(dtos));
         }
 
-        public Task<ApiResponse<GetEnemyResponse>> GetEnemy(GetEnemyParameter parameter)
+        public async Task<ApiResponse<GetEnemyResponse>> GetEnemy(GetEnemyParameter parameter)
         {
-            throw new System.NotImplementedException();
+            var enemy = await _context.Enemies.FindAsync(parameter.EnemyId);
+            if (enemy == null)
+            {
+                _logger.LogWarning($"Enemy {parameter.EnemyId} not found in database");
+                return new ApiResponse<GetEnemyResponse>(new OperationResult(false, "Object not found"));
+            }
+
+            var dto = _mapper.Map<Dto.Enemy>(enemy);
+            return new ApiResponse<GetEnemyResponse>(new GetEnemyResponse(dto));
         }
 
-        public Task<ApiResponse<SaveEnemyResponse>> SaveEnemy(SaveEnemyParameter parameter)
+        public async Task<ApiResponse<SaveEnemyResponse>> SaveEnemy(SaveEnemyParameter parameter)
         {
-            throw new System.NotImplementedException();
+            if (parameter.Enemy.EnemyId.IsEmpty())
+            {
+                var enemy = _mapper.Map<Enemy>(parameter.Enemy);
+                _context.Enemies.Add(enemy);
+                var count = await _context.SaveChangesAsync();
+                _logger.LogInformation($"Created enemy '{enemy.EnemyId}' ({count} rows)");
+                return new ApiResponse<SaveEnemyResponse>(new SaveEnemyResponse(enemy.EnemyId));
+            }
+            else
+            {
+                var enemy = await _context.Enemies.FindAsync(parameter.Enemy.EnemyId);
+                if (enemy == null)
+                {
+                    _logger.LogError($"Enemy '{parameter.Enemy.EnemyId}' not found in database");
+                    return new ApiResponse<SaveEnemyResponse>(new OperationResult(false, "Object not found"));
+                }
+
+                _context.Enemies.Update(enemy);
+                _mapper.Map(parameter.Enemy, enemy);
+                var count = await _context.SaveChangesAsync();
+                _logger.LogInformation($"Updated enemy '{enemy.EnemyId}' ({count} rows)");
+                return new ApiResponse<SaveEnemyResponse>(new SaveEnemyResponse(enemy.EnemyId));
+            }
         }
 
-        public Task<ApiResponse<DeleteEnemyResponse>> DeleteEnemy(DeleteEnemyParameter parameter)
+        public async Task<ApiResponse<DeleteEnemyResponse>> DeleteEnemy(DeleteEnemyParameter parameter)
         {
-            throw new System.NotImplementedException();
+            var enemy = await _context.Enemies.FindAsync(parameter.EnemyId);
+            if (enemy == null)
+            {
+                _logger.LogError($"Enemy '{parameter.EnemyId}' not found in database");
+                return new ApiResponse<DeleteEnemyResponse>(new OperationResult(false, "Object not found"));
+            }
+            
+            _context.Enemies.Remove(enemy);
+            var count = _context.SaveChangesAsync();
+            _logger.LogInformation($"Deleted enemy '{parameter.EnemyId}' ({count} rows)");
+            return new ApiResponse<DeleteEnemyResponse>(new DeleteEnemyResponse());
         }
     }
 }

EstusShots.Server/Services/EstusShotsContext.cs

@@ -13,11 +13,15 @@ namespace EstusShots.Server.Services
         public DbSet<Episode> Episodes { get; set; } = default!;
         public DbSet<Player> Players { get; set; } = default!;
         public DbSet<Drink> Drinks { get; set; } = default!;
+        public DbSet<Enemy> Enemies { get; set; } = default!;
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             modelBuilder.Entity<Season>().ToTable(nameof(Season));
             modelBuilder.Entity<Episode>().ToTable(nameof(Episode));
+            modelBuilder.Entity<Enemy>().ToTable(nameof(Enemy));
+            modelBuilder.Entity<Drink>().ToTable(nameof(Drink));
+            modelBuilder.Entity<Player>().ToTable(nameof(Player));
 
             modelBuilder.Entity<EpisodePlayers>()
                 .HasKey(t => new {t.EpisodeId, t.PlayerId});
@@ -31,6 +35,20 @@ namespace EstusShots.Server.Services
                 .HasOne(pt => pt.Player)
                 .WithMany(t => t.EpisodePlayers)
                 .HasForeignKey(pt => pt.PlayerId);
+
+            
+            modelBuilder.Entity<SeasonEnemies>()
+                .HasKey(t => new {t.SeasonId, t.EnemyId});
+            
+            modelBuilder.Entity<SeasonEnemies>()
+                .HasOne(pt => pt.Season)
+                .WithMany(p => p.SeasonEnemies)
+                .HasForeignKey(pt => pt.SeasonId);
+
+            modelBuilder.Entity<SeasonEnemies>()
+                .HasOne(pt => pt.Enemy)
+                .WithMany(t => t.SeasonEnemies)
+                .HasForeignKey(pt => pt.EnemyId);
         }
     }
 }

EstusShots.Shared/Dto/Enemy.cs

@@ -1,5 +1,5 @@
 using System;
-using System.ComponentModel.DataAnnotations;
+using System.Collections.Generic;
 
 namespace EstusShots.Shared.Dto
 {
@@ -15,6 +15,6 @@ namespace EstusShots.Shared.Dto
 
         public Guid? SeasonId { get; set; }
 
-        public Season Season { get; set; }
+        public List<Season> Seasons { get; set; }
     }
 }