Parti end poin2

Sources/BowlingApi/BowlingApi.csproj

@@ -7,9 +7,18 @@
         <LangVersion>11</LangVersion>
     </PropertyGroup>
 
+    <PropertyGroup Condition=" '$(RunConfiguration)' == 'https' " />
+    <PropertyGroup Condition=" '$(RunConfiguration)' == 'http' " />
     <ItemGroup>
         <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="7.0.0" />
         <PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
+        <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="7.0.2" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.2" />
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="7.0.2">
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+          <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="7.0.2" />
     </ItemGroup>
 
     <ItemGroup>
@@ -18,6 +27,12 @@
         
     </ItemGroup>
 
+    <ItemGroup>
+      <None Remove="Microsoft.VisualStudio.Web.CodeGeneration.Design" />
+      <None Remove="Microsoft.EntityFrameworkCore.SqlServer" />
+      <None Remove="Microsoft.EntityFrameworkCore.Tools" />
+      <None Remove="Microsoft.EntityFrameworkCore.Sqlite" />
+    </ItemGroup>
     <ItemGroup>
       <None Update="bowling.db">
         <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

Sources/BowlingApi/Controllers/PartieController.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BowlingEF.Entities;
+using BowlingLib.Model;
+using BowlingService;
+using BowlingService.Interfaces;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace BowlingApi.Controllers
+{
+
+
+    [Route("api/[controller]")]
+    [ApiController]
+    public class PartieController : ControllerBase
+    {
+
+
+        private IpartieService _partieService;
+
+        public PartieController(IpartieService partieService)
+        {
+            _partieService = partieService;
+        }
+
+
+
+
+        // GET: api/Partie
+        [HttpGet]
+        public async Task< IActionResult >Get()
+        {
+            try
+            {
+                var result = await _partieService.GetAll();
+                if (result == null)
+                {
+                    return NotFound();
+                }
+                return Ok(result);
+            }
+            catch (Exception e)
+            {
+                return StatusCode(StatusCodes.Status500InternalServerError, e.Message);
+                throw;
+            }
+       //var result =  _partieService.GetAll().Result;
+            //return Ok(result);
+        }
+
+        // GET: api/Partie/djon
+        [HttpGet("{name}")]
+        public async Task < IActionResult> Get(string name)
+        {
+            //  return Ok(_partieService.GetDataWithName(name));
+
+
+            try
+            {
+                if (name == null)
+                    return BadRequest("Le nom de la partie  est obligatoire");
+
+                var result = _partieService.GetDataWithName(name).Result;
+                if (result == null)
+                {
+                    return NotFound();
+                }
+                return Ok(result);
+            }
+            catch (Exception e)
+            {
+                return StatusCode(StatusCodes.Status500InternalServerError, e.Message);
+                throw;
+            }
+
+        }
+
+        // POST: api/Partie
+        [HttpPost]
+        public async Task<ActionResult<PartieDTO>>  Post([FromBody] PartieDTO parti)
+        {
+
+
+            try
+            {
+                if (parti == null)
+                {
+                    return BadRequest("partie est obligatoire");
+                }
+                var createdpartie = _partieService.Add(parti).Result;
+                return CreatedAtAction(nameof(Get), new { id = parti.Id }, createdpartie);
+
+            }
+            catch (Exception e)
+            {
+                return StatusCode(StatusCodes.Status500InternalServerError, e.Message);
+                throw;
+            }
+
+        }
+
+        // PUT: api/Partie/5
+        [HttpPut("{id}")]
+        public async Task<ActionResult<PartieDTO>> Put(string name, [FromBody] PartieDTO partie)
+        {
+            try
+            {
+                if (partie == null)
+                    return BadRequest("La partie est obligatoire");
+
+                var updatepartie = _partieService.Update(partie);
+                if (updatepartie.Result == null)
+                {
+                    return NotFound();
+                }
+
+                return Ok(updatepartie);
+            }
+            catch (Exception e)
+            {
+                StatusCode(StatusCodes.Status500InternalServerError, e.Message);
+                throw;
+            }
+
+        }
+
+        // DELETE: api/Partie/5
+
+    }
+}

Sources/BowlingApi/Program.cs

@@ -18,6 +18,8 @@ builder.Services.AddSwaggerGen();
 builder.Services.AddAutoMapper(typeof(JoueurProfile));
 builder.Services.AddScoped<IJoueurService, JoueurService>();
 builder.Services.AddScoped<IJoueurRepository, JoueurRepository>();
+builder.Services.AddScoped<IpartieRepository, PartieRepository>();
+builder.Services.AddScoped<IpartieService, PartieService>();
 
 var app = builder.Build();
 

Sources/BowlingApi/Properties/launchSettings.json

@@ -1,4 +1,4 @@
-{
+{
   "$schema": "https://json.schemastore.org/launchsettings.json",
   "iisSettings": {
     "windowsAuthentication": false,
@@ -11,7 +11,6 @@
   "profiles": {
     "http": {
       "commandName": "Project",
-      "dotnetRunMessages": true,
       "launchBrowser": true,
       "launchUrl": "swagger",
       "applicationUrl": "http://localhost:5229",
@@ -21,7 +20,6 @@
     },
     "https": {
       "commandName": "Project",
-      "dotnetRunMessages": true,
       "launchBrowser": true,
       "launchUrl": "swagger",
       "applicationUrl": "https://localhost:7097;http://localhost:5229",
@@ -38,4 +36,4 @@
       }
     }
   }
-}
+}

Sources/BowlingEF/Entities/PartieEntity.cs

@@ -21,7 +21,7 @@ namespace BowlingEF.Entities
         [ForeignKey("JoueurForeignKey")]
         public JoueurEntity Joueur { get; set; }
         [Required]
-        public DateTime Date { get; set; }
+        public DateTime Date { get; set; } = DateTime.Now;
         public ICollection<FrameEntity> Frames { get; set; }
         [Required]
         public int? Score { get; set; }

Sources/BowlingRepository/Interface/IEquipeRepository.cs

@@ -1,4 +1,4 @@
-using BowlingEF.Entities;
+  using BowlingEF.Entities;
 
 namespace BowlingRepository.Interface;
 

Sources/BowlingRepository/Interface/IpartieRepository.cs

@@ -0,0 +1,17 @@
+using System;
+using BowlingEF.Entities;
+
+namespace BowlingRepository.Interface
+{
+	public interface IpartieRepository
+    {
+      public  Task<PartieEntity> Add(PartieEntity _partie);
+      public  Task<bool> Delete(long id);
+      public Task<bool> Update(PartieEntity _partie);
+      public Task<List<PartieEntity>> GetAll();
+      public Task<IEnumerable<PartieEntity>> GetAllWithDate(DateTime date);
+      public Task<PartieEntity> GetDataWithName(string nom);
+        
+    }
+}
+

Sources/BowlingRepository/Interface/PartieRepository.cs

@@ -0,0 +1,63 @@
+using System;
+using BowlingEF.Context;
+using BowlingEF.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace BowlingRepository.Interface
+{
+	public class PartieRepository:IpartieRepository
+    {
+        private readonly BowlingContext _context;
+        public PartieRepository()
+        {
+            _context = new BowlingContext();
+        }
+
+        public async Task<PartieEntity> Add(PartieEntity partie)
+        {
+
+            var result = await _context.Parties.AddAsync(partie);
+            await _context.SaveChangesAsync();
+            return result.Entity;
+
+            //_context.Parties.Add( partie);
+            //return await _context.SaveChangesAsync() > 0;
+
+
+        }
+
+        public async Task<bool> Delete(long id)
+        {
+            using (var context = new BowlingContext())
+            {
+                PartieEntity entity = context.Parties.Find(id);
+                context.Parties.Remove(entity);
+                return await context.SaveChangesAsync() > 0;
+            }
+        }
+
+      
+
+        public async Task<List<PartieEntity>> GetAll()
+        {
+            return await _context.Parties.ToListAsync();
+        }
+
+        public Task<IEnumerable<PartieEntity>> GetAllWithDate(DateTime date)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<PartieEntity> GetDataWithName(string nom)
+        {
+            //  return await _context.Parties.FirstOrDefaultAsync(n => n == nom);
+            throw new NotImplementedException();
+        }
+
+        public async Task<bool> Update(PartieEntity _partie)
+        {
+            return await _context.SaveChangesAsync() > 0;
+        }
+    }
+}
+

Sources/BowlingService/Interfaces/IPartieService.cs

@@ -0,0 +1,16 @@
+using System;
+using BowlingEF.Entities;
+
+namespace BowlingService.Interfaces
+{
+	public interface IpartieService
+    {
+        public Task<bool> Add(PartieDTO _partie);
+        public Task<bool> Delete(PartieDTO _partie);
+        public Task<bool> Update(PartieDTO _partie);
+        public Task<IEnumerable<PartieDTO>> GetAll();
+        public Task<IEnumerable<PartieEntity>> GetAllWithDate(DateTime date);
+        public Task<PartieDTO> GetDataWithName(string nom);
+    }
+}
+

Sources/BowlingService/Interfaces/PartieService.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Xml.Linq;
+using AutoMapper;
+using BowlingEF.Context;
+using BowlingEF.Entities;
+using BowlingLib.Model;
+using BowlingRepository;
+using BowlingRepository.Interface;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace BowlingService.Interfaces
+{
+	public class PartieService:IpartieService
+	{
+        private readonly IpartieRepository _IpartieRepository;
+        private readonly ILogger<JoueurService> _logger;
+        private readonly IMapper _mapper;
+
+        public PartieService(IpartieRepository ipartieRepository, IMapper mapper, ILogger<JoueurService> logger)
+        {
+            _IpartieRepository = ipartieRepository;
+            _mapper = mapper;
+            _logger = logger;
+        }
+
+        public PartieService()
+		{
+
+		}
+
+        //Add
+
+        public async Task<bool> Add(PartieDTO _partie)
+        {
+            bool result = false;
+            using (var context = new BowlingContext())
+            {
+                PartieEntity entity = _mapper.Map<PartieEntity>(_partie);
+                context.Parties.Add(entity);
+                try
+                {
+                    var data = await context.SaveChangesAsync();
+                    result = data == 1;
+                    _logger.LogInformation("A new player was added : {player}", _partie.Id);
+
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error while adding new player : {player}", _partie.Id);
+                    throw;
+                }
+            }
+
+            return result;
+        }
+        //Delete
+
+        public async Task<bool> Delete(PartieDTO _partie)
+        {
+            // return await _IpartieRepository.Delete(_partie.Id);
+
+            var result = false;
+            try
+            {
+                result = await _IpartieRepository.Delete(_partie.Id);
+                _logger.LogInformation("la partie est supprimer", _partie.Id);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error while deleting player : {player}", _partie.Id);
+                throw;
+            }
+            return result;
+
+        }
+
+        public async Task<IEnumerable<PartieDTO>> GetAll()
+        {
+            List<PartieDTO> result = new List<PartieDTO>();
+            using (var context = new BowlingContext())
+            {
+                foreach (PartieEntity entity in await _IpartieRepository.GetAll())
+                {
+                    JoueurDTO joueur = _mapper.Map<JoueurDTO>(entity.Joueur);
+                    List<FrameDTO> frames = new List<FrameDTO>();
+                    foreach (FrameEntity frameEntity in entity.Frames)
+                    {
+                        FrameDTO frame = _mapper.Map<FrameDTO>(frameEntity);
+                        frames.Add(frame);
+                    }
+                    result.Add(_mapper.Map<PartieDTO>(entity));
+                }
+            }
+            return result.OrderBy(item => item.Date).ToList<PartieDTO>();
+
+        }
+
+        public Task<IEnumerable<PartieEntity>> GetAllWithDate(DateTime date)
+        {
+            throw new NotImplementedException();
+        }
+
+        public async  Task<PartieDTO> GetDataWithName(string nom)
+        {
+            PartieDTO  _partie = null;
+
+            try
+            {
+                var partientity = await _IpartieRepository.GetDataWithName(nom);
+                _partie = _mapper.Map<PartieDTO>(partientity);
+                _logger.LogInformation("partie was retrieved : {partie}", nom);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error while retrieving partie : {partie}", nom);
+                throw;
+            }
+            return _partie;
+        }
+
+
+        //Update
+
+        public async Task<bool> Update(PartieDTO _partie)
+        {
+
+            bool result = false;
+            using(var context =new BowlingContext())
+            {
+                PartieEntity entity = _mapper.Map<PartieEntity>(_partie);
+                entity.Date = _partie.Date;
+                entity.Score = _partie.Score;
+                result =  _IpartieRepository.Update(entity).Result;
+
+            }
+            return result;
+
+        }
+
+       
+    }
+}
+

Sources/BowlingService/JoueurService.cs

@@ -43,7 +43,7 @@ namespace BowlingService
                         Pseudo = _joueur.Pseudo,
                     };
 
-                    //Parcourt de la liste des parties d'un joueur
+                    //Parcourt de la liste des parties d'un joueur DTA
                     for (int i = 0; i < _joueur.PartieDTO.Count; i++)
                     {
                         //Mapping entre les parties d'un joueur et les partieEntity d'une partieEntity

Sources/DTOs/EquipeDTO.cs

@@ -16,7 +16,6 @@ namespace BowlingEF.Entities
         public string Nom { get; set; }
         public ICollection<JoueurDTO> Joueurs { get; set; }
         #endregion
-
         #region Constructeurs
         public EquipeDTO()
         {

Sources/DTOs/FrameDTO.cs

@@ -9,17 +9,12 @@ namespace BowlingEF.Entities
     public class FrameDTO
     {
         #region Properties
-        [Key]
-        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        
         public long Id { get; set; }
-        [Required]
         public int Numero { get; set; }
-        [Required]
         public int Lancer1 { get; set; }
-        [Required]
         public int Lancer2 { get; set; }
         public int Lancer3 { get; set; }
-
         public PartieDTO Partie { get; set; }
         #endregion
     }

Sources/DTOs/JoueurDTO.cs

@@ -12,8 +12,6 @@ namespace BowlingEF.Entities
         [Key]
         [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
         public long Id { get; set; }
-
-        [Required]
         public string Pseudo { get; set; }
         public ICollection<PartieDTO> PartieDTO { get; set; } = new List<PartieDTO>();
         #endregion

Sources/DTOs/PartieDTO.cs

@@ -14,16 +14,14 @@ namespace BowlingEF.Entities
     public class PartieDTO
     {
         #region Properties
-        [Key]
-        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        
         public long Id { get; set; }
 
-        [ForeignKey("JoueurForeignKey")]
         public JoueurDTO Joueur { get; set; }
-        [Required]
+      
         public DateTime Date { get; set; }
         public ICollection<FrameDTO> FramesDTO { get; set; }
-        [Required]
+  
         public int? Score { get; set; }
         #endregion
 

Sources/Mapper/PartieProfile.cs

@@ -7,6 +7,6 @@ public class PartieProfile:Profile
 {
     public PartieProfile()
     {
-        CreateMap<PartieDTO, PartieEntity>();
+        CreateMap<PartieDTO, PartieEntity>().ReverseMap();
     }
 }

Sources/Tests/BowlingAppUnitTest/BowlingAppUnitTest.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 25.0.1704.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BowlingAppUnitTest", "BowlingAppUnitTest.csproj", "{6CE80C57-58B9-4481-B4EE-1DD615117D93}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{6CE80C57-58B9-4481-B4EE-1DD615117D93}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6CE80C57-58B9-4481-B4EE-1DD615117D93}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6CE80C57-58B9-4481-B4EE-1DD615117D93}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6CE80C57-58B9-4481-B4EE-1DD615117D93}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {977E7E9D-643B-4F31-B0F3-229032EB3B68}
+	EndGlobalSection
+EndGlobal