Merge pull request #109 from pierrick-fonquerne/62-dashboard-utilisateur

62 dashboard utilisateur

Author: pierrick-fonquerne

src/backend/src/FantasyRealm.Api/Controllers/CharactersController.cs

@@ -203,6 +203,65 @@ public async Task<IActionResult> CheckNameAvailability(
             return Ok(new { available = result.Value });
         }
 
+        /// <summary>
+        /// Duplicates an approved character with a new name.
+        /// </summary>
+        /// <param name="id">The character identifier to duplicate.</param>
+        /// <param name="request">The duplicate request containing the new name.</param>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>The newly created character in Draft status.</returns>
+        /// <response code="201">Character duplicated successfully.</response>
+        /// <response code="400">Character status does not allow duplication (must be Approved) or invalid name.</response>
+        /// <response code="403">The authenticated user is not the owner.</response>
+        /// <response code="404">Character not found.</response>
+        /// <response code="409">A character with the same name already exists for this user.</response>
+        [HttpPost("{id:int}/duplicate")]
+        [ProducesResponseType(typeof(CharacterResponse), StatusCodes.Status201Created)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ProducesResponseType(StatusCodes.Status409Conflict)]
+        public async Task<IActionResult> Duplicate(int id, [FromBody] DuplicateCharacterRequest request, CancellationToken cancellationToken)
+        {
+            if (!TryGetUserId(out var userId))
+                return Unauthorized(new { message = "Token invalide." });
+
+            var result = await characterService.DuplicateAsync(id, userId, request.Name, cancellationToken);
+
+            if (result.IsFailure)
+                return StatusCode(result.ErrorCode ?? 400, new { message = result.Error });
+
+            return CreatedAtAction(nameof(GetById), new { id = result.Value!.Id }, result.Value);
+        }
+
+        /// <summary>
+        /// Toggles the sharing status of an approved character.
+        /// </summary>
+        /// <param name="id">The character identifier.</param>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>The updated character with toggled IsShared value.</returns>
+        /// <response code="200">Sharing status toggled successfully.</response>
+        /// <response code="400">Character status does not allow sharing (must be Approved).</response>
+        /// <response code="403">The authenticated user is not the owner.</response>
+        /// <response code="404">Character not found.</response>
+        [HttpPatch("{id:int}/share")]
+        [ProducesResponseType(typeof(CharacterResponse), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public async Task<IActionResult> ToggleShare(int id, CancellationToken cancellationToken)
+        {
+            if (!TryGetUserId(out var userId))
+                return Unauthorized(new { message = "Token invalide." });
+
+            var result = await characterService.ToggleShareAsync(id, userId, cancellationToken);
+
+            if (result.IsFailure)
+                return StatusCode(result.ErrorCode ?? 400, new { message = result.Error });
+
+            return Ok(result.Value);
+        }
+
         private bool TryGetUserId(out int userId)
         {
             userId = 0;

src/backend/src/FantasyRealm.Application/DTOs/CharacterSummaryResponse.cs

@@ -1,12 +1,21 @@
 namespace FantasyRealm.Application.DTOs
 {
     /// <summary>
-    /// Lightweight character summary for list views.
+    /// Character summary for list views including appearance data for preview.
     /// </summary>
     public sealed record CharacterSummaryResponse(
         int Id,
         string Name,
         string ClassName,
         string Status,
-        string Gender);
+        string Gender,
+        bool IsShared,
+        string SkinColor,
+        string HairColor,
+        string EyeColor,
+        string FaceShape,
+        string HairStyle,
+        string EyeShape,
+        string NoseShape,
+        string MouthShape);
 }

src/backend/src/FantasyRealm.Application/DTOs/DuplicateCharacterRequest.cs

@@ -0,0 +1,7 @@
+namespace FantasyRealm.Application.DTOs
+{
+    /// <summary>
+    /// Request payload for duplicating a character.
+    /// </summary>
+    public sealed record DuplicateCharacterRequest(string Name);
+}

src/backend/src/FantasyRealm.Application/Interfaces/ICharacterService.cs

@@ -47,5 +47,24 @@ public interface ICharacterService
         /// <param name="cancellationToken">Cancellation token.</param>
         /// <returns>True if the name is available, false otherwise.</returns>
         Task<Result<bool>> IsNameAvailableAsync(string name, int userId, int? excludeCharacterId, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Duplicates an approved character with a new name.
+        /// </summary>
+        /// <param name="characterId">The character identifier to duplicate.</param>
+        /// <param name="userId">The user identifier (must be owner).</param>
+        /// <param name="newName">The name for the duplicated character.</param>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>The newly created character in Draft status.</returns>
+        Task<Result<CharacterResponse>> DuplicateAsync(int characterId, int userId, string newName, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Toggles the sharing status of an approved character.
+        /// </summary>
+        /// <param name="characterId">The character identifier.</param>
+        /// <param name="userId">The user identifier (must be owner).</param>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>The updated character with toggled IsShared value.</returns>
+        Task<Result<CharacterResponse>> ToggleShareAsync(int characterId, int userId, CancellationToken cancellationToken);
     }
 }

src/backend/src/FantasyRealm.Application/Services/CharacterService.cs

@@ -68,16 +68,7 @@ public async Task<Result<CharacterResponse>> GetByIdAsync(int characterId, int u
         public async Task<Result<IReadOnlyList<CharacterSummaryResponse>>> GetMyCharactersAsync(int userId, CancellationToken cancellationToken)
         {
             var characters = await characterRepository.GetByUserIdAsync(userId, cancellationToken);
-
-            var summaries = characters
-                .Select(c => new CharacterSummaryResponse(
-                    c.Id,
-                    c.Name,
-                    c.Class.Name,
-                    c.Status.ToString(),
-                    c.Gender.ToString()))
-                .ToList() as IReadOnlyList<CharacterSummaryResponse>;
-
+            var summaries = characters.Select(MapToSummaryResponse).ToList().AsReadOnly();
             return Result<IReadOnlyList<CharacterSummaryResponse>>.Success(summaries);
         }
 
@@ -167,6 +158,70 @@ public async Task<Result<bool>> IsNameAvailableAsync(string name, int userId, in
             return Result<bool>.Success(!nameExists);
         }
 
+        /// <inheritdoc />
+        public async Task<Result<CharacterResponse>> DuplicateAsync(int characterId, int userId, string newName, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(newName))
+                return Result<CharacterResponse>.Failure("Le nom est requis.", 400);
+
+            var character = await characterRepository.GetByIdAsync(characterId, cancellationToken);
+            if (character is null)
+                return Result<CharacterResponse>.Failure("Personnage introuvable.", 404);
+
+            if (character.UserId != userId)
+                return Result<CharacterResponse>.Failure("Accès non autorisé.", 403);
+
+            if (character.Status != CharacterStatus.Approved)
+                return Result<CharacterResponse>.Failure("Seuls les personnages approuvés peuvent être dupliqués.", 400);
+
+            var nameExists = await characterRepository.ExistsByNameAndUserAsync(newName, userId, null, cancellationToken);
+            if (nameExists)
+                return Result<CharacterResponse>.Failure("Vous avez déjà un personnage avec ce nom.", 409);
+
+            var duplicate = new Character
+            {
+                Name = newName,
+                ClassId = character.ClassId,
+                Gender = character.Gender,
+                Status = CharacterStatus.Draft,
+                SkinColor = character.SkinColor,
+                EyeColor = character.EyeColor,
+                HairColor = character.HairColor,
+                HairStyle = character.HairStyle,
+                EyeShape = character.EyeShape,
+                NoseShape = character.NoseShape,
+                MouthShape = character.MouthShape,
+                FaceShape = character.FaceShape,
+                IsShared = false,
+                CreatedAt = DateTime.UtcNow,
+                UpdatedAt = DateTime.UtcNow,
+                UserId = userId
+            };
+
+            var created = await characterRepository.CreateAsync(duplicate, cancellationToken);
+            return Result<CharacterResponse>.Success(MapToResponse(created, character.Class.Name));
+        }
+
+        /// <inheritdoc />
+        public async Task<Result<CharacterResponse>> ToggleShareAsync(int characterId, int userId, CancellationToken cancellationToken)
+        {
+            var character = await characterRepository.GetByIdAsync(characterId, cancellationToken);
+            if (character is null)
+                return Result<CharacterResponse>.Failure("Personnage introuvable.", 404);
+
+            if (character.UserId != userId)
+                return Result<CharacterResponse>.Failure("Accès non autorisé.", 403);
+
+            if (character.Status != CharacterStatus.Approved)
+                return Result<CharacterResponse>.Failure("Seuls les personnages approuvés peuvent être partagés.", 400);
+
+            character.IsShared = !character.IsShared;
+            character.UpdatedAt = DateTime.UtcNow;
+
+            await characterRepository.UpdateAsync(character, cancellationToken);
+            return Result<CharacterResponse>.Success(MapToResponse(character, character.Class.Name));
+        }
+
         private static CharacterResponse MapToResponse(Character character, string className)
         {
             return new CharacterResponse(
@@ -188,5 +243,24 @@ private static CharacterResponse MapToResponse(Character character, string class
                 character.CreatedAt,
                 character.UpdatedAt);
         }
+
+        private static CharacterSummaryResponse MapToSummaryResponse(Character character)
+        {
+            return new CharacterSummaryResponse(
+                character.Id,
+                character.Name,
+                character.Class.Name,
+                character.Status.ToString(),
+                character.Gender.ToString(),
+                character.IsShared,
+                character.SkinColor,
+                character.HairColor,
+                character.EyeColor,
+                character.FaceShape,
+                character.HairStyle,
+                character.EyeShape,
+                character.NoseShape,
+                character.MouthShape);
+        }
     }
 }

src/backend/tests/FantasyRealm.Tests.Integration/Controllers/AuthControllerIntegrationTests.cs

@@ -16,16 +16,10 @@ namespace FantasyRealm.Tests.Integration.Controllers
     /// </summary>
     [Trait("Category", "Integration")]
     [Trait("Category", "Auth")]
-    public class AuthControllerIntegrationTests : IClassFixture<FantasyRealmWebApplicationFactory>
+    public class AuthControllerIntegrationTests(FantasyRealmWebApplicationFactory factory) : IClassFixture<FantasyRealmWebApplicationFactory>
     {
-        private readonly HttpClient _client;
-        private readonly FantasyRealmWebApplicationFactory _factory;
-
-        public AuthControllerIntegrationTests(FantasyRealmWebApplicationFactory factory)
-        {
-            _factory = factory;
-            _client = factory.CreateClient();
-        }
+        private readonly HttpClient _client = factory.CreateClient();
+        private readonly FantasyRealmWebApplicationFactory _factory = factory;
 
         [Fact]
         public async Task Register_WithValidData_ReturnsCreatedAndUserResponse()