Revize 7f0fd41c

Lock update

src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/Comments/Commands/EditComment.cs

@@ +1 @@
+using Leuze.Core.Application.CQRS;
+using Leuze.Core.Domain.Repositories;
+using Leuze.Modules.Goal.Domain.Repositories;
+using Microsoft.AspNetCore.Components.Authorization;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Claims;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Leuze.Modules.Goal.Application.CQRS.Comments.Commands
+{
+    public static class EditComment
+    {
+        public record Command(Guid commentId, string text, bool isPrivate) : IBaseRequest<Response>;
+
+        public record Response();
+
+
+        public class Handler : IBaseRequestHandler<Command, Response>
+        {
+            private readonly ICommentRepository _commentRepo;
+            private readonly AuthenticationStateProvider _authenticationStateProvider;
+            private readonly IDomainUserRepository _domainUserRepo;
+
+            public Handler(ICommentRepository commentRepo, AuthenticationStateProvider authStateProvider, IDomainUserRepository domainUserRepo)
+            {
+                _commentRepo = commentRepo;
+                _authenticationStateProvider = authStateProvider;
+                _domainUserRepo = domainUserRepo;
+            }
+
+            public async Task<RequestResponse<Response>> Handle(Command request, CancellationToken cancellationToken)
+            {
+                //TODO: user muze byt null, ale to my nechceme!!!
+                var state = await _authenticationStateProvider.GetAuthenticationStateAsync();
+                var id = Guid.Parse(state.User!.FindFirst(ClaimTypes.NameIdentifier)!.Value);
+                var editor = await _domainUserRepo.GetByIdAsync(id);
+                var comment = await _commentRepo.GetByIdAsync(request.commentId);
+
+                if (editor == null)
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Editor user with id: {id} not found!");
+                }
+                if (comment == null)
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Comment with id: {request.commentId} not found!");
+                }
+                if (editor.UserId != comment.CreatorId)
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Editor and comment creator are not the same person!");
+                }
+                if (string.IsNullOrWhiteSpace(request.text))
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Comment text is empty!");
+                }
+
+                comment.SetText(request.text);
+
+                if (request.isPrivate)
+                {
+                    comment.SetPrivate();
+                }
+                else
+                {
+                    comment.SetPublic();
+                }
+
+                await _commentRepo.UpdateRepo();
+
+                return RequestResponse<Response>.CreateSuccessResponse(new());
+            }
+        }
+    }
+}

src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/Comments/Commands/RemoveComment.cs

@@ +1 @@
+using Leuze.Core.Application.CQRS;
+using Leuze.Core.Domain.Repositories;
+using Leuze.Modules.Goal.Domain.Repositories;
+using Microsoft.AspNetCore.Components.Authorization;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Claims;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Leuze.Modules.Goal.Application.CQRS.Comments.Commands
+{
+    public static class RemoveComment
+    {
+        public record Command(Guid commentId) : IBaseRequest<Response>;
+
+        public record Response();
+
+
+        public class Handler : IBaseRequestHandler<Command, Response>
+        {
+            private readonly ICommentRepository _commentRepo;
+            private readonly AuthenticationStateProvider _authenticationStateProvider;
+            private readonly IDomainUserRepository _domainUserRepo;
+
+            public Handler(ICommentRepository commentRepo, AuthenticationStateProvider authStateProvider, IDomainUserRepository domainUserRepo)
+            {
+                _commentRepo = commentRepo;
+                _authenticationStateProvider = authStateProvider;
+                _domainUserRepo = domainUserRepo;
+            }
+
+            public async Task<RequestResponse<Response>> Handle(Command request, CancellationToken cancellationToken)
+            {
+                //TODO: user muze byt null, ale to my nechceme!!!
+                var state = await _authenticationStateProvider.GetAuthenticationStateAsync();
+                var id = Guid.Parse(state.User!.FindFirst(ClaimTypes.NameIdentifier)!.Value);
+                var editor = await _domainUserRepo.GetByIdAsync(id);
+                var comment = await _commentRepo.GetByIdAsync(request.commentId);
+
+                if (editor == null)
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Editor user with id: {id} not found!");
+                }
+                if (comment == null)
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Comment with id: {request.commentId} not found!");
+                }
+                if (editor.UserId != comment.CreatorId)
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Editor and comment creator are not the same person!");
+                }
+
+                await _commentRepo.RemoveAsync(comment.Id);
+
+                return RequestResponse<Response>.CreateSuccessResponse(new());
+            }
+        }
+    }
+}

src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/Goals/Commands/CreateGoal.cs

@@ -51 +51 @@
                     return RequestResponse<Response>.CreateErrorResponse($"Goal definition with id: {request.GoalDefinitionId} not found!");
                 }
 
+                if (goalDef.IsLocked())
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Goal definition with id: {request.GoalDefinitionId} is write protected!");
+                }
+
                 GoalItem item = new(goalDef, user, request.Name, request.Description);
                 await _goalItemRepo.AddAsync(item);
 

src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/Goals/Commands/EditGoal.cs

@@ -50 +50 @@
                     return RequestResponse<Response>.CreateErrorResponse($"Cíl s ID: {request.goalId} nebyl nalezen!");
                 }
 
-                if(request.name == null || request.name == "")
+                if (goal.IsLocked())
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Cíl s ID: {request.goalId} byl uzamčen proti přepsání!");
+                }
+
+                if (goal.GoalDefinition.IsLocked())
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Definice s cílem je uzamčena proti přepsání!");
+                }
+
+                if (request.name == null || request.name == "")
                 {
                     return RequestResponse<Response>.CreateErrorResponse($"Nelze změnit název cíle");
                 }

src/Modules/Goal/Application/Leuze.Modules.Goal.Application/CQRS/Goals/Commands/RemoveGoal.cs

@@ -22 +22 @@
 
             public async Task<RequestResponse<Response>> Handle(Command request, CancellationToken cancellationToken)
             {
+                var item = await _repository.GetByIdAsync(request.Id);
+
+                if(item == null)
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Goal with ID '{request.Id}' not found");
+                }
+                if (item.IsLocked())
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Goal is write protected!");
+                }
+                if (item.GoalDefinition.IsLocked())
+                {
+                    return RequestResponse<Response>.CreateErrorResponse($"Goal definition of item is write protected!");
+                }
+
                 if (!await _repository.RemoveAsync(request.Id))
                     return RequestResponse<Response>.CreateErrorResponse($"Goal with ID '{request.Id}' not found");
 

src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalDefinition.cs

@@ -83 +83 @@
             this.OwnerLocked = false;
             this.SupervisorLocked = false;
         }
+
+        public bool IsLocked()
+        {
+            return SupervisorLocked && OwnerLocked;
+        }
     }
 }

src/Modules/Goal/Domain/Leuze.Modules.Goal.Domain/Domains/GoalItem.cs

@@ -85 +85 @@
             this.OwnerLocked = false;
             this.SupervisorLocked = false;
         }
+
+        public bool IsLocked()
+        {
+            return SupervisorLocked && OwnerLocked;
+        }
     }
 }

src/Modules/Goal/Infrastructure/Leuze.Modules.Goal.Infrastructure.Persistence/Repositories/GoalItemRepository.cs

@@ -38 +38 @@
 
         public async Task<GoalItem> GetByIdAsync(Guid id)
         {
-            return await dbSet.FindAsync(id);
+            return await dbSet.Where(o => o.Id == id).Include(o => o.GoalDefinition).FirstOrDefaultAsync();
         }
 
         public async Task<List<GoalItem>> GetAllForUserDefinitionAsync(Guid definitionId)