chore(ChangeServicesToCommand) , fix(FixControllerMethodsName)

Brizco.Api/Controllers/ActivityController.cs

@@ -1,4 +1,6 @@
-namespace Brizco.Api.Controllers;
+using Brizco.Core.EntityServices.CommandQueries;
+
+namespace Brizco.Api.Controllers;
 
 public class ActivityController : ICarterModule
 {
@@ -50,17 +52,17 @@ public class ActivityController : ICarterModule
             DateQueryFilter: dateQueryFilter), cancellationToken));
 
     // GET:Get An Entity By Id
-    public async Task<IResult> GetAsync(Guid id, IActivityService activityService, CancellationToken cancellationToken)
+    public async Task<IResult> GetAsync(Guid id, [FromServices]IMediator mediator, CancellationToken cancellationToken)
-        => TypedResults.Ok(await activityService.DoneActivityAsync(id, cancellationToken));
+        => TypedResults.Ok(await mediator.Send(new DoneActivityCommand(id),cancellationToken));
 
-    public async Task<IResult> CompleteActivityAsync([FromBody] List<CompleteActivityRequestDto> requestDtos, [FromServices] IActivityService activityService, CancellationToken cancellationToken)
+    public async Task<IResult> CompleteActivityAsync([FromBody] List<CompleteActivityRequestDto> requestDtos, [FromServices] IMediator mediator, CancellationToken cancellationToken)
-        => TypedResults.Ok(await activityService.CompleteActivitiesAsync(requestDtos, cancellationToken));
+        => TypedResults.Ok(await mediator.Send(new CompleteActivitiesCommand(requestDtos),cancellationToken));
 
-    public async Task<IResult> DoneActivityAsync(Guid id, [FromServices] IActivityService activityService, CancellationToken cancellationToken)
+    public async Task<IResult> DoneActivityAsync(Guid id, [FromServices] IMediator mediator, CancellationToken cancellationToken)
-        => TypedResults.Ok(await activityService.DoneActivityAsync(id, cancellationToken));
+        => TypedResults.Ok(await mediator.Send(new DoneActivityCommand(id),cancellationToken));
 
-    public async Task<IResult> UnDoneActivityAsync(Guid id, [FromQuery] string undoneReason, [FromServices] IActivityService activityService, CancellationToken cancellationToken)
+    public async Task<IResult> UnDoneActivityAsync(Guid id, [FromQuery] string undoneReason, [FromServices] IMediator mediator, CancellationToken cancellationToken)
-        => TypedResults.Ok(await activityService.UnDoneActivityAsync(id, undoneReason, cancellationToken));
+        => TypedResults.Ok(await mediator.Send(new UnDoneActivityCommand(id,undoneReason),cancellationToken));
 
     //// POST:Create Entity
     //public async Task<IResult> Post([FromQuery]Guid shiftPlanId,IActivityService activityService, CancellationToken cancellationToken)

Brizco.Api/Controllers/ComplexController.cs

@@ -10,24 +10,27 @@ public class ComplexController : ICarterModule
             .RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
 
         group.MapGet("", GetAllAsync)
-            .WithDisplayName("GetAllComplex")
+            .WithDisplayName("Get Complexes")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ViewComplexes, ApplicationPermission.ManageComplexes))
             .HasApiVersion(1.0);
 
         group.MapGet("{id}", GetAsync)
-            .WithDisplayName("GetOneComplex")
+            .WithDisplayName("Get Complex")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ViewComplexes, ApplicationPermission.ManageComplexes))
             .HasApiVersion(1.0);
 
         group.MapPost("", Post)
+            .WithDisplayName("Create Complex")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageComplexes))
             .HasApiVersion(1.0);
 
         group.MapPut("", Put)
+            .WithDisplayName("Update Complex")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageComplexes))
             .HasApiVersion(1.0);
 
         group.MapDelete("{id}", Delete)
+            .WithDisplayName("Delete Complex")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageComplexes))
             .HasApiVersion(1.0);
     }

Brizco.Api/Controllers/PositionController.cs

@@ -10,7 +10,7 @@ public class PositionController : ICarterModule
             .RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
 
         group.MapGet("", GetAllAsync)
-            .WithDisplayName("GetAllPositions")
+            .WithDisplayName("Get Positions")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ViewPositions,ApplicationPermission.ManagePositions))
             .HasApiVersion(1.0);
 
@@ -20,14 +20,17 @@ public class PositionController : ICarterModule
             .HasApiVersion(1.0);
 
         group.MapPost("", Post)
+            .WithDisplayName("Create Position")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManagePositions))
             .HasApiVersion(1.0);
 
         group.MapPut("", Put)
+            .WithDisplayName("Update Position")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManagePositions))
             .HasApiVersion(1.0);
 
         group.MapDelete("{id}", Delete)
+            .WithDisplayName("Delete Position")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManagePositions))
             .HasApiVersion(1.0);
 

Brizco.Api/Controllers/RoutineController.cs

@@ -9,7 +9,7 @@ public class RoutineController : ICarterModule
             .RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
 
         group.MapGet("", GetAllAsync)
-            .WithDisplayName("GetAllRoutines")
+            .WithDisplayName("Get Routines")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageRoutines,ApplicationPermission.ViewRoutines))
             .HasApiVersion(1.0);
 
@@ -24,14 +24,17 @@ public class RoutineController : ICarterModule
             .HasApiVersion(1.0);
 
         group.MapPost("", Post)
+            .WithDisplayName("Create Routine")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageRoutines))
             .HasApiVersion(1.0);
 
         group.MapPut("", Put)
+            .WithDisplayName("Update Routine")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageRoutines))
             .HasApiVersion(1.0);
 
         group.MapDelete("{id}", Delete)
+            .WithDisplayName("Delete Routine")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageRoutines))
             .HasApiVersion(1.0);
     }

Brizco.Api/Controllers/SectionController.cs

@@ -10,7 +10,7 @@ public class SectionController : ICarterModule
             .RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
 
         group.MapGet("", GetAllAsync)
-            .WithDisplayName("GetAllSections")
+            .WithDisplayName("Get Sections")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageSections, ApplicationPermission.ViewSections))
             .HasApiVersion(1.0);
 
@@ -20,14 +20,17 @@ public class SectionController : ICarterModule
             .HasApiVersion(1.0);
 
         group.MapPost("", Post)
+            .WithDisplayName("Create Section")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageSections))
             .HasApiVersion(1.0);
 
         group.MapPut("", Put)
+            .WithDisplayName("Update Section")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageSections))
             .HasApiVersion(1.0);
 
         group.MapDelete("{id}", Delete)
+            .WithDisplayName("Delete Section")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageSections))
             .HasApiVersion(1.0);
     }

Brizco.Api/Controllers/ShiftController.cs

@@ -11,24 +11,27 @@ public class ShiftController : ICarterModule
             .RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
 
         group.MapGet("", GetAllAsync)
-            .WithDisplayName("GetAllShift")
+            .WithDisplayName("Get Shift")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShifts, ApplicationPermission.ViewShifts))
             .HasApiVersion(1.0);
 
         group.MapGet("{id}", GetAsync)
-            .WithDisplayName("GetOneShift")
+            .WithDisplayName("Get Shift")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShifts, ApplicationPermission.ViewShifts))
             .HasApiVersion(1.0);
 
         group.MapPost("", Post)
+            .WithDisplayName("Create Shift")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShifts))
             .HasApiVersion(1.0);
 
         group.MapPut("", Put)
+            .WithDisplayName("Update Shift")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShifts))
             .HasApiVersion(1.0);
 
         group.MapDelete("{id}", Delete)
+            .WithDisplayName("Delete Shift")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShifts))
             .HasApiVersion(1.0);
     }

Brizco.Api/Controllers/ShiftPlanController.cs

@@ -1,4 +1,6 @@
-namespace Brizco.Api.Controllers;
+using Brizco.Core.EntityServices.CommandQueries;
+
+namespace Brizco.Api.Controllers;
 
 public class ShiftPlanController : ICarterModule
 {
@@ -32,20 +34,24 @@ public class ShiftPlanController : ICarterModule
 
 
         group.MapPost("", Post)
+            .WithDisplayName("Create ShiftPlan")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShiftPlans))
             .HasApiVersion(1.0);
 
         group.MapPut("", Put)
+            .WithDisplayName("Update ShiftPlan")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShiftPlans))
             .HasApiVersion(1.0);
 
         group.MapDelete("{id:guid}", Delete)
+            .WithDisplayName("Delete ShiftPlan")
+            .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShiftPlans))
             .HasApiVersion(1.0);
 
     }
 
-    public async Task<IResult> CompletePlanAsync(Guid id,[FromBody] CompleteShiftPlanRequestDto requestDtos, [FromServices] IShiftPlanService shiftPlanService, CancellationToken cancellationToken)
+    public async Task<IResult> CompletePlanAsync(Guid id, [FromBody] CompleteShiftPlanRequestDto requestDtos, [FromServices] IMediator mediator, CancellationToken cancellationToken)
-        => TypedResults.Ok(await shiftPlanService.CompleteShiftPlanAsync(id,requestDtos, cancellationToken));
+        => TypedResults.Ok(await mediator.Send(new CompleteShiftPlanCommand(id, requestDtos.CompleteDescription, requestDtos.CompleteActivities, requestDtos.CompletePercent), cancellationToken));
 
     // GET:Get All Entity
     public async Task<IResult> GetShiftPlanActivitiesAsync([FromRoute] Guid id, ISender sender, CancellationToken cancellationToken)
@@ -64,12 +70,12 @@ public class ShiftPlanController : ICarterModule
         => TypedResults.Ok(await sender.Send(new GetShiftPlanQuery(id), cancellationToken));
 
     // POST:Create Entity
-    public async Task<IResult> Post([FromBody] CreateShiftPlanCommand ent, IShiftPlanService shiftPlanService, CancellationToken cancellationToken)
+    public async Task<IResult> Post([FromBody] CreateShiftPlanCoreCommand ent, [FromServices] IMediator mediator, CancellationToken cancellationToken)
-        => TypedResults.Ok(await shiftPlanService.CreateAsync(ent, cancellationToken));
+        => TypedResults.Ok(await mediator.Send(ent, cancellationToken));
 
     // PUT:Update Entity
-    public async Task<IResult> Put([FromBody] UpdateShiftPlanCommand ent, IShiftPlanService shiftPlanService, CancellationToken cancellationToken)
+    public async Task<IResult> Put([FromBody] UpdateShiftPlanCoreCommand ent, [FromServices] IMediator mediator, CancellationToken cancellationToken)
-        => TypedResults.Ok(await shiftPlanService.UpdateAsync(ent, cancellationToken));
+        => TypedResults.Ok(await mediator.Send(ent, cancellationToken));
 
     // DELETE:Delete Entity
     public async Task<IResult> Delete(Guid id, ISender mediator, CancellationToken cancellationToken)

Brizco.Api/Controllers/TaskController.cs

@@ -9,24 +9,27 @@ public class TaskController : ICarterModule
             .RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
 
         group.MapGet("", GetAllAsync)
-            .WithDisplayName("GetAllTask")
+            .WithDisplayName("Get Tasks")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageTasks, ApplicationPermission.ViewTasks))
             .HasApiVersion(1.0);
 
         group.MapGet("{id}", GetAsync)
-            .WithDisplayName("GetOneTask")
+            .WithDisplayName("Get Task")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageTasks, ApplicationPermission.ViewTasks))
             .HasApiVersion(1.0);
 
         group.MapPost("", Post)
+            .WithDisplayName("Create Task")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageTasks))
             .HasApiVersion(1.0);
 
         group.MapPut("", Put)
+            .WithDisplayName("Update Task")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageTasks))
             .HasApiVersion(1.0);
 
         group.MapDelete("{id}", Delete)
+            .WithDisplayName("Delete Task")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageTasks))
             .HasApiVersion(1.0);
     }

Brizco.Api/Controllers/UserController.cs

@@ -12,17 +12,17 @@ public class UserController : ICarterModule
             .RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
 
         group.MapGet("", GetAllAsync)
-            .WithDisplayName("GetAllUser")
+            .WithDisplayName("Get Users")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ViewUsers,ApplicationPermission.ManageUsers))
             .HasApiVersion(1.0);
 
         group.MapGet("/staff", GetAllStaffAsync)
-            .WithDisplayName("GetAllStaff")
+            .WithDisplayName("Get Staffs")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ViewUsers, ApplicationPermission.ManageUsers))
             .HasApiVersion(1.0);
 
         group.MapGet("{id}", GetAsync)
-            .WithDisplayName("GetOneUser")
+            .WithDisplayName("Get User")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ViewUsers, ApplicationPermission.ManageUsers))
             .HasApiVersion(1.0);
 
@@ -31,18 +31,21 @@ public class UserController : ICarterModule
             .HasApiVersion(1.0);
 
         group.MapPost("/role/change/{roleId}", ChangeUserRoleAsync)
-            .WithDisplayName("GetUserProfile")
+            .WithDisplayName("Change User Role")
             .HasApiVersion(1.0);
 
         group.MapPost("", Post)
+            .WithDisplayName("Create User")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission,  ApplicationPermission.ManageUsers))
             .HasApiVersion(1.0);
 
         group.MapPut("", Put)
+            .WithDisplayName("Update User")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageUsers))
             .HasApiVersion(1.0);
 
         group.MapDelete("{id}", Delete)
+            .WithDisplayName("Delete User")
             .RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageUsers))
             .HasApiVersion(1.0);
     }

Brizco.Core/CoreServices/AccountService.cs

@@ -7,7 +7,7 @@ public class AccountService(
     ICurrentUserService currentUserService,
     IRepositoryWrapper repositoryWrapper,
     ISmsService smsService,
-    IComplexService complexService,
+    IMediator mediator,
     IUserService userService)
     : IAccountService
 {
@@ -150,11 +150,8 @@ public class AccountService(
         if (!result.Succeeded)
             throw new AppException(string.Join('|', result.Errors.Select(e => e.Description)));
 
-        var complex = await complexService.CreateComplexAsync(requestDto.ComplexName,
+        await mediator.Send(new CreateComplexCoreCommand(requestDto.ComplexName, requestDto.ComplexAddress,
-            requestDto.ComplexAddress,
+            requestDto.SupportPhoneNumber, user.Id),cancellationToken);
-            requestDto.SupportPhoneNumber,
-            user.Id,
-            cancellationToken);
 
         return await CompleteLogin(user, cancellationToken);
     }

Brizco.Core/EntityServices/Abstracts/IActivityService.cs

@@ -1,10 +0,0 @@
-namespace Brizco.Core.EntityServices.Abstracts;
-
-public interface IActivityService : IScopedDependency
-{
-    Task<bool> UpdateActivitiesByShiftPlan(Guid shiftPlanId, CancellationToken cancellationToken);
-    Task<bool> CreateActivitiesByShiftPlan(Guid shiftPlanId, CancellationToken cancellationToken);
-    Task<bool> DoneActivityAsync(Guid activityId, CancellationToken cancellationToken);
-    Task<bool> CompleteActivitiesAsync(List<CompleteActivityRequestDto> requestDtos, CancellationToken cancellationToken);
-    Task<bool> UnDoneActivityAsync(Guid activityId, string undoneReason, CancellationToken cancellationToken);
-}

Brizco.Core/EntityServices/Abstracts/IShiftPlanService.cs

@@ -1,9 +0,0 @@
-namespace Brizco.Core.EntityServices.Abstracts;
-
-public interface IShiftPlanService : IScopedDependency
-{
-    Task ChangeShiftPlanTaskStatusAsync(Guid shiftPlanId,bool isChangeToShift , bool isDisable);
-    Task<bool> CreateAsync(CreateShiftPlanCommand createShiftPlanCommand,CancellationToken cancellationToken);
-    Task<bool> UpdateAsync(UpdateShiftPlanCommand createShiftPlanCommand,CancellationToken cancellationToken);
-    Task<bool> CompleteShiftPlanAsync(Guid id,CompleteShiftPlanRequestDto requestDtos, CancellationToken cancellationToken);
-}

Brizco.Core/EntityServices/ActivityService.cs

@@ -1,194 +0,0 @@
-using Brizco.Domain.Entities.Tasks;
-using Task = Brizco.Domain.Entities.Tasks.Task;
-
-namespace Brizco.Core.EntityServices;
-
-public class ActivityService(IMediator mediator, IRepositoryWrapper repositoryWrapper) : IActivityService
-{
-
-
-    public async Task<bool> DoneActivityAsync(Guid activityId, CancellationToken cancellationToken)
-    {
-        var activity = await repositoryWrapper.SetRepository<Activity>()
-            .TableNoTracking
-            .FirstOrDefaultAsync(a => a.Id == activityId, cancellationToken);
-        if (activity == null)
-            throw new AppException("Activity not found", ApiResultStatusCode.NotFound);
-        activity.DoneActivity();
-        repositoryWrapper.SetRepository<Activity>()
-            .Update(activity);
-        await repositoryWrapper.SaveChangesAsync(cancellationToken);
-        return true;
-    }
-
-    public async Task<bool> CompleteActivitiesAsync(List<CompleteActivityRequestDto> requestDtos, CancellationToken cancellationToken)
-    {
-        foreach (var activityRequestDto in requestDtos)
-        {
-            var activity = await repositoryWrapper.SetRepository<Activity>().TableNoTracking
-                .FirstOrDefaultAsync(a => a.Id == activityRequestDto.ActivityId, cancellationToken);
-            if (activity == null)
-                continue;
-
-            activity.CompleteActivity(activityRequestDto.IsCompleted, activityRequestDto.PerformanceDescription);
-            repositoryWrapper.SetRepository<Activity>().Update(activity);
-            await repositoryWrapper.SaveChangesAsync(cancellationToken);
-        }
-
-        return true;
-    }
-
-
-    public async Task<bool> UnDoneActivityAsync(Guid activityId, string undoneReason, CancellationToken cancellationToken)
-    {
-        var activity = await repositoryWrapper.SetRepository<Activity>()
-            .TableNoTracking
-            .FirstOrDefaultAsync(a => a.Id == activityId, cancellationToken);
-        if (activity == null)
-            throw new AppException("Activity not found ", ApiResultStatusCode.NotFound);
-        activity.UnDoneActivity(undoneReason);
-        repositoryWrapper.SetRepository<Activity>()
-            .Update(activity);
-        await repositoryWrapper.SaveChangesAsync(cancellationToken);
-        return true;
-    }
-
-    public async Task<bool> UpdateActivitiesByShiftPlan(Guid shiftPlanId, CancellationToken cancellationToken)
-    {
-        var shiftPlan = await mediator.Send(new GetShiftPlanQuery(shiftPlanId), cancellationToken);
-        if (shiftPlan.Id == Guid.Empty)
-            return false;
-
-        var dailyTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
-                                join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
-                                join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
-                                    .TaskId
-                                where taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId && task.ScheduleType == TaskScheduleType.Daily
-                                select task).AsNoTracking().ToListAsync(cancellationToken);
-
-        var weeklyTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
-                                 join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
-                                 join taskDay in repositoryWrapper.SetRepository<TaskDay>().Entities on task.Id equals taskDay.TaskId
-                                 join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
-                                     .TaskId
-                                 where taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId &&
-                                       taskDay.DayOfWeek == shiftPlan.PlanFor.DayOfWeek && task.ScheduleType == TaskScheduleType.Weekly
-                                 group task by task.Id into groupedTask
-                                 select groupedTask.FirstOrDefault()).AsNoTracking().ToListAsync(cancellationToken);
-
-        var customTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
-                                 join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
-                                 join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
-                                     .TaskId
-                                 where taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId &&
-                                       task.ScheduleType == TaskScheduleType.Custom && task.SetFor.Date == shiftPlan.PlanFor.Date
-                                 select task).AsNoTracking().ToListAsync(cancellationToken);
-
-        var tasks = new List<Task>();
-        tasks.AddRange(weeklyTasks);
-
-        tasks.AddRange(dailyTasks);
-        tasks.AddRange(customTasks);
-
-        var shiftPlanPositions = await repositoryWrapper.SetRepository<ShiftPlanUser>()
-            .TableNoTracking
-            .Where(spu => spu.ShiftPlanId == shiftPlan.Id)
-            .ToListAsync(cancellationToken);
-
-
-        var activities = await repositoryWrapper.SetRepository<Activity>()
-            .TableNoTracking
-            .Where(a => a.ShiftPlanId == shiftPlan.ShiftId && a.SetFor.Date == shiftPlan.PlanFor.Date)
-            .Select(ActivityMapper.ProjectToLDto)
-            .ToListAsync(cancellationToken);
-        foreach (var activity in activities)
-        {
-            var foundedTask = tasks.FirstOrDefault(t => t.Title == activity.Title);
-            if (foundedTask == null)
-                continue;
-
-            var taskPositions = await repositoryWrapper.SetRepository<TaskPosition>()
-                .TableNoTracking
-                .Where(tp => tp.TaskId == foundedTask.Id)
-                .ToListAsync(cancellationToken);
-
-            foreach (var taskPosition in taskPositions)
-            {
-                var foundedUser = shiftPlanPositions.FirstOrDefault(spu => spu.PositionId == taskPosition.PositionId);
-                if (foundedUser == null)
-                    continue;
-                if (activity.UserId != foundedUser.UserId)
-                {
-
-                    await mediator.Send(new UpdateActivityCommand(activity.Id, activity.Status, activity.DoneAt, activity.PerformanceDescription,
-                    activity.Type, activity.Title, activity.Description, activity.IsDisposable, activity.SetFor, activity.HasDisposed, activity.Amount
-                    , activity.AmountType, activity.ScheduleType, shiftPlan.Id, foundedUser.UserId), cancellationToken);
-                }
-            }
-        }
-        return true;
-    }
-
-    public async Task<bool> CreateActivitiesByShiftPlan(Guid shiftPlanId, CancellationToken cancellationToken) {
-        var shiftPlan = await mediator.Send(new GetShiftPlanQuery(shiftPlanId), cancellationToken);
-        if (shiftPlan.Id == Guid.Empty)
-            return false;
-
-        var dailyTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
-                                join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
-                                join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
-                                    .TaskId
-                                where task.IsActivity == false && taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId && task.ScheduleType == TaskScheduleType.Daily
-                                select task).AsNoTracking().ToListAsync(cancellationToken);
-
-        var weeklyTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
-                                 join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
-                                 join taskDay in repositoryWrapper.SetRepository<TaskDay>().Entities on task.Id equals taskDay.TaskId
-                                 join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
-                                     .TaskId
-                                 where task.IsActivity == false && taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId &&
-                                       taskDay.DayOfWeek == shiftPlan.PlanFor.DayOfWeek && task.ScheduleType == TaskScheduleType.Weekly
-                                 group task by task.Id into groupedTask
-                                 select groupedTask.FirstOrDefault()).AsNoTracking().ToListAsync(cancellationToken);
-
-        var customTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
-                                 join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
-                                 join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
-                                     .TaskId
-                                 where task.IsActivity == false && taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId &&
-                                       task.ScheduleType == TaskScheduleType.Custom && task.SetFor.Date == shiftPlan.PlanFor.Date
-                                 select task).AsNoTracking().ToListAsync(cancellationToken);
-
-        var tasks = new List<Task>();
-        tasks.AddRange(weeklyTasks);
-        tasks.AddRange(dailyTasks);
-        tasks.AddRange(customTasks);
-
-
-        var shiftPlanPositions = await repositoryWrapper.SetRepository<ShiftPlanUser>()
-            .TableNoTracking
-            .Where(spu => spu.ShiftPlanId == shiftPlan.Id)
-            .ToListAsync(cancellationToken);
-
-        foreach (var task in tasks)
-        {
-            var taskPositions = await repositoryWrapper.SetRepository<TaskPosition>()
-                .TableNoTracking
-                .Where(tp => tp.TaskId == task.Id)
-                .ToListAsync(cancellationToken);
-
-            foreach (var taskPosition in taskPositions)
-            {
-                var fundedUser = shiftPlanPositions.FirstOrDefault(spu => spu.PositionId == taskPosition.PositionId);
-                if (fundedUser != null)
-                {
-                    await mediator.Send(new CreateActivityCommand(task.Type, task.Title, task.Description, task.IsDisposable,
-                        shiftPlan.PlanFor, task.HasDisposed, task.Amount, task.AmountType,
-                        task.ScheduleType, shiftPlan.Id, fundedUser.UserId), cancellationToken);
-                }
-            }
-        }
-
-        return true;
-    }
-}

Brizco.Core/EntityServices/CommandQueries/ActivityCommands.cs

@@ -0,0 +1,7 @@
+namespace Brizco.Core.EntityServices.CommandQueries;
+
+public sealed record DoneActivityCommand(Guid Id) : IRequest<bool>;
+public sealed record CompleteActivitiesCommand(List<CompleteActivityRequestDto> Dtos) : IRequest<bool>;
+public sealed record UnDoneActivityCommand(Guid Id,string UndoneReason) : IRequest<bool>;
+public sealed record UpdateActivitiesByShiftPlanCommand(Guid ShiftPlanId) : IRequest<bool>;
+public sealed record CreateActivitiesByShiftPlanCommand(Guid ShiftPlanId) : IRequest<bool>;

Brizco.Core/EntityServices/CommandQueries/ShiftPlanCommands.cs

@@ -0,0 +1,28 @@
+namespace Brizco.Core.EntityServices.CommandQueries;
+
+public sealed record ChangeShiftPlanTaskStatusCommand(
+    Guid ShiftPlanId,
+    bool IsChangeToShift,
+    bool IsDisable) : IRequest<bool>;
+
+public sealed record CreateShiftPlanCoreCommand(
+    long PlanDate, 
+    Guid ShiftId,
+    Guid RoutineId,
+    Guid SupervisionUserId,
+    List<KeyValuePair<Guid, Guid>> UserAndPositionIds) : IRequest<bool>;
+
+
+public sealed record UpdateShiftPlanCoreCommand(
+    Guid Id,
+    long PlanDate,
+    Guid ShiftId,
+    Guid RoutineId,
+    Guid SupervisionUserId,
+    List<KeyValuePair<Guid, Guid>> UserAndPositionIds) : IRequest<bool>;
+
+public sealed record CompleteShiftPlanCommand(
+    Guid Id,
+    string CompleteDescription,
+    List<CompleteActivityRequestDto> CompleteActivities,
+    int CompletePercent) : IRequest<bool>;

Brizco.Core/EntityServices/Handlers/Activities/CompleteActivitiesCommandHandler.cs

@@ -0,0 +1,23 @@
+using Brizco.Domain.Entities.Tasks;
+
+namespace Brizco.Core.EntityServices.Handlers.Activities;
+
+public class CompleteActivitiesCommandHandler(IRepositoryWrapper repositoryWrapper) : IRequestHandler<CompleteActivitiesCommand, bool>
+{
+    public async Task<bool> Handle(CompleteActivitiesCommand request, CancellationToken cancellationToken)
+    {
+        foreach (var activityRequestDto in request.Dtos)
+        {
+            var activity = await repositoryWrapper.SetRepository<Activity>().TableNoTracking
+                .FirstOrDefaultAsync(a => a.Id == activityRequestDto.ActivityId, cancellationToken);
+            if (activity == null)
+                continue;
+
+            activity.CompleteActivity(activityRequestDto.IsCompleted, activityRequestDto.PerformanceDescription);
+            repositoryWrapper.SetRepository<Activity>().Update(activity);
+            await repositoryWrapper.SaveChangesAsync(cancellationToken);
+        }
+
+        return true;
+    }
+}

Brizco.Core/EntityServices/Handlers/Activities/CreateActivitiesByShiftPlanCommandHandler.cs

@@ -0,0 +1,71 @@
+using Brizco.Domain.Entities.Tasks;
+using Task = Brizco.Domain.Entities.Tasks.Task;
+
+namespace Brizco.Core.EntityServices.Handlers.Activities;
+
+public class CreateActivitiesByShiftPlanCommandHandler(IRepositoryWrapper repositoryWrapper, IMediator mediator) : IRequestHandler<CreateActivitiesByShiftPlanCommand, bool>
+{
+    public async Task<bool> Handle(CreateActivitiesByShiftPlanCommand request, CancellationToken cancellationToken)
+    {
+        var shiftPlan = await mediator.Send(new GetShiftPlanQuery(request.ShiftPlanId), cancellationToken);
+        if (shiftPlan.Id == Guid.Empty)
+            return false;
+
+        var dailyTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
+            join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
+            join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
+                .TaskId
+            where task.IsActivity == false && taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId && task.ScheduleType == TaskScheduleType.Daily
+            select task).AsNoTracking().ToListAsync(cancellationToken);
+
+        var weeklyTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
+            join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
+            join taskDay in repositoryWrapper.SetRepository<TaskDay>().Entities on task.Id equals taskDay.TaskId
+            join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
+                .TaskId
+            where task.IsActivity == false && taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId &&
+                  taskDay.DayOfWeek == shiftPlan.PlanFor.DayOfWeek && task.ScheduleType == TaskScheduleType.Weekly
+            group task by task.Id into groupedTask
+            select groupedTask.FirstOrDefault()).AsNoTracking().ToListAsync(cancellationToken);
+
+        var customTasks = await (from task in repositoryWrapper.SetRepository<Task>().Entities
+            join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
+            join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
+                .TaskId
+            where task.IsActivity == false && taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId &&
+                  task.ScheduleType == TaskScheduleType.Custom && task.SetFor.Date == shiftPlan.PlanFor.Date
+            select task).AsNoTracking().ToListAsync(cancellationToken);
+
+        var tasks = new List<Task>();
+        tasks.AddRange(weeklyTasks);
+        tasks.AddRange(dailyTasks);
+        tasks.AddRange(customTasks);
+
+
+        var shiftPlanPositions = await repositoryWrapper.SetRepository<ShiftPlanUser>()
+            .TableNoTracking
+            .Where(spu => spu.ShiftPlanId == shiftPlan.Id)
+            .ToListAsync(cancellationToken);
+
+        foreach (var task in tasks)
+        {
+            var taskPositions = await repositoryWrapper.SetRepository<TaskPosition>()
+                .TableNoTracking
+                .Where(tp => tp.TaskId == task.Id)
+                .ToListAsync(cancellationToken);
+
+            foreach (var taskPosition in taskPositions)
+            {
+                var fundedUser = shiftPlanPositions.FirstOrDefault(spu => spu.PositionId == taskPosition.PositionId);
+                if (fundedUser != null)
+                {
+                    await mediator.Send(new CreateActivityCommand(task.Type, task.Title, task.Description, task.IsDisposable,
+                        shiftPlan.PlanFor, task.HasDisposed, task.Amount, task.AmountType,
+                        task.ScheduleType, shiftPlan.Id, fundedUser.UserId), cancellationToken);
+                }
+            }
+        }
+
+        return true;
+    }
+}

Brizco.Core/EntityServices/Handlers/Activities/DoneActivityCommandHandler.cs

@@ -0,0 +1,22 @@
+using Brizco.Domain.Entities.ShiftPlans;
+using Brizco.Domain.Entities.Tasks;
+
+namespace Brizco.Core.EntityServices.Handlers.Activities;
+
+public class DoneActivityCommandHandler(IRepositoryWrapper repositoryWrapper) : IRequestHandler<DoneActivityCommand,bool>
+{
+    public async Task<bool> Handle(DoneActivityCommand request, CancellationToken cancellationToken)
+    {
+
+        var activity = await repositoryWrapper.SetRepository<Activity>()
+            .TableNoTracking
+            .FirstOrDefaultAsync(a => a.Id == request.Id, cancellationToken);
+        if (activity == null)
+            throw new AppException("Activity not found", ApiResultStatusCode.NotFound);
+        activity.DoneActivity();
+        repositoryWrapper.SetRepository<Activity>()
+            .Update(activity);
+        await repositoryWrapper.SaveChangesAsync(cancellationToken);
+        return true;
+    }
+}

Brizco.Core/EntityServices/Handlers/Activities/UnDoneActivityCommandHandler.cs

@@ -0,0 +1,21 @@
+using Brizco.Domain.Entities.Tasks;
+
+namespace Brizco.Core.EntityServices.Handlers.Activities;
+
+public class UnDoneActivityCommandHandler(IRepositoryWrapper repositoryWrapper) : IRequestHandler<UnDoneActivityCommand, bool>
+{
+    public async Task<bool> Handle(UnDoneActivityCommand request, CancellationToken cancellationToken)
+    {
+
+        var activity = await repositoryWrapper.SetRepository<Activity>()
+            .TableNoTracking
+            .FirstOrDefaultAsync(a => a.Id == request.Id, cancellationToken);
+        if (activity == null)
+            throw new AppException("Activity not found ", ApiResultStatusCode.NotFound);
+        activity.UnDoneActivity(request.UndoneReason);
+        repositoryWrapper.SetRepository<Activity>()
+            .Update(activity);
+        await repositoryWrapper.SaveChangesAsync(cancellationToken);
+        return true;
+    }
+}

Brizco.Core/EntityServices/Handlers/Activities/UpdateActivitiesByShiftPlanCommandHandler.cs

@@ -0,0 +1,84 @@
+using Brizco.Domain.Entities.Tasks;
+using Task = Brizco.Domain.Entities.Tasks.Task;
+
+namespace Brizco.Core.EntityServices.Handlers.Activities;
+
+public class UpdateActivitiesByShiftPlanCommandHandler(IRepositoryWrapper repositoryWrapper,IMediator mediator) : IRequestHandler<UpdateActivitiesByShiftPlanCommand, bool>
+{
+    public async Task<bool> Handle(UpdateActivitiesByShiftPlanCommand request, CancellationToken cancellationToken)
+    {
+
+        var shiftPlan = await mediator.Send(new GetShiftPlanQuery(request.ShiftPlanId), cancellationToken);
+        if (shiftPlan.Id == Guid.Empty)
+            return false;
+
+        var dailyTasks = await(from task in repositoryWrapper.SetRepository<Task>().Entities
+            join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
+            join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
+                .TaskId
+            where taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId && task.ScheduleType == TaskScheduleType.Daily
+            select task).AsNoTracking().ToListAsync(cancellationToken);
+
+        var weeklyTasks = await(from task in repositoryWrapper.SetRepository<Task>().Entities
+            join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
+            join taskDay in repositoryWrapper.SetRepository<TaskDay>().Entities on task.Id equals taskDay.TaskId
+            join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
+                .TaskId
+            where taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId &&
+                  taskDay.DayOfWeek == shiftPlan.PlanFor.DayOfWeek && task.ScheduleType == TaskScheduleType.Weekly
+            group task by task.Id into groupedTask
+            select groupedTask.FirstOrDefault()).AsNoTracking().ToListAsync(cancellationToken);
+
+        var customTasks = await(from task in repositoryWrapper.SetRepository<Task>().Entities
+            join taskShift in repositoryWrapper.SetRepository<TaskShift>().Entities on task.Id equals taskShift.TaskId
+            join taskRoutine in repositoryWrapper.SetRepository<TaskRoutine>().Entities on task.Id equals taskRoutine
+                .TaskId
+            where taskShift.ShiftId == shiftPlan.ShiftId && taskRoutine.RoutineId == shiftPlan.RoutineId &&
+                  task.ScheduleType == TaskScheduleType.Custom && task.SetFor.Date == shiftPlan.PlanFor.Date
+            select task).AsNoTracking().ToListAsync(cancellationToken);
+
+        var tasks = new List<Task>();
+        tasks.AddRange(weeklyTasks);
+
+        tasks.AddRange(dailyTasks);
+        tasks.AddRange(customTasks);
+
+        var shiftPlanPositions = await repositoryWrapper.SetRepository<ShiftPlanUser>()
+            .TableNoTracking
+            .Where(spu => spu.ShiftPlanId == shiftPlan.Id)
+            .ToListAsync(cancellationToken);
+
+
+        var activities = await repositoryWrapper.SetRepository<Activity>()
+            .TableNoTracking
+            .Where(a => a.ShiftPlanId == shiftPlan.ShiftId && a.SetFor.Date == shiftPlan.PlanFor.Date)
+            .Select(ActivityMapper.ProjectToLDto)
+            .ToListAsync(cancellationToken);
+        foreach (var activity in activities)
+        {
+            var foundedTask = tasks.FirstOrDefault(t => t.Title == activity.Title);
+            if (foundedTask == null)
+                continue;
+
+            var taskPositions = await repositoryWrapper.SetRepository<TaskPosition>()
+                .TableNoTracking
+                .Where(tp => tp.TaskId == foundedTask.Id)
+                .ToListAsync(cancellationToken);
+
+            foreach (var taskPosition in taskPositions)
+            {
+                var foundedUser = shiftPlanPositions.FirstOrDefault(spu => spu.PositionId == taskPosition.PositionId);
+                if (foundedUser == null)
+                    continue;
+                if (activity.UserId != foundedUser.UserId)
+                {
+
+                    await mediator.Send(new UpdateActivityCommand(activity.Id, activity.Status, activity.DoneAt, activity.PerformanceDescription,
+                        activity.Type, activity.Title, activity.Description, activity.IsDisposable, activity.SetFor, activity.HasDisposed, activity.Amount
+                        , activity.AmountType, activity.ScheduleType, shiftPlan.Id, foundedUser.UserId), cancellationToken);
+                }
+            }
+        }
+        return true;
+    }
+}

Brizco.Core/EntityServices/Handlers/ShiftPlans/ChangeShiftPlanTaskStatusCommandHandler.cs

@@ -0,0 +1,10 @@
+namespace Brizco.Core.EntityServices.Handlers.ShiftPlans;
+
+public class ChangeShiftPlanTaskStatusCommandHandler(IMediator mediator) : IRequestHandler<ChangeShiftPlanTaskStatusCommand, bool>
+{
+    public async Task<bool> Handle(ChangeShiftPlanTaskStatusCommand request, CancellationToken cancellationToken)
+    {
+        var shiftPlan = await mediator.Send(new GetShiftPlanQuery(request.ShiftPlanId), cancellationToken);
+        return true;
+    }
+}

Brizco.Core/EntityServices/Handlers/ShiftPlans/CompleteShiftPlanCommandHandler.cs

@@ -0,0 +1,30 @@
+namespace Brizco.Core.EntityServices.Handlers.ShiftPlans;
+
+public class CompleteShiftPlanCommandHandler(IMediator mediator, IRepositoryWrapper repositoryWrapper) : IRequestHandler<CompleteShiftPlanCommand, bool>
+{
+    public async Task<bool> Handle(CompleteShiftPlanCommand request, CancellationToken cancellationToken)
+    {
+
+        var shiftPlan = await repositoryWrapper.SetRepository<ShiftPlan>()
+            .TableNoTracking.FirstOrDefaultAsync(s => s.Id == request.Id, cancellationToken);
+        if (shiftPlan == null)
+            throw new AppException("Shift plan not found", ApiResultStatusCode.NotFound);
+
+        shiftPlan.CompletePlan(request.CompleteDescription, request.CompletePercent);
+        repositoryWrapper.SetRepository<ShiftPlan>().Update(shiftPlan);
+        await repositoryWrapper.SaveChangesAsync(cancellationToken);
+        await mediator.Send(new CompleteActivitiesCommand(request.CompleteActivities), cancellationToken);
+
+        var shiftPlanUsers = await repositoryWrapper.SetRepository<ShiftPlanUser>()
+            .TableNoTracking.Where(s => s.ShiftPlanId == request.Id)
+            .Select(ShiftPlanUserMapper.ProjectToSDto)
+            .ToListAsync(cancellationToken);
+
+        foreach (var shiftPlanUser in shiftPlanUsers)
+        {
+            var message = $"{shiftPlanUser.UserFullName}";
+        }
+
+        return true;
+    }
+}

Brizco.Core/EntityServices/Handlers/ShiftPlans/CreateShiftPlanCoreCommandHandler.cs

@@ -0,0 +1,12 @@
+namespace Brizco.Core.EntityServices.Handlers.ShiftPlans;
+
+public class CreateShiftPlanCoreCommandHandler(IMediator mediator) : IRequestHandler<CreateShiftPlanCoreCommand, bool>
+{
+    public async Task<bool> Handle(CreateShiftPlanCoreCommand request, CancellationToken cancellationToken)
+    {
+        var shiftPlan = await mediator.Send(new CreateShiftPlanCommand(request.PlanDate, request.ShiftId, request.RoutineId, request.SupervisionUserId, request.UserAndPositionIds), cancellationToken);
+        await mediator.Send(new CreateShiftPlanNotificationsCommand(shiftPlan.Id, true), cancellationToken);
+        await mediator.Send(new CreateActivitiesByShiftPlanCommand(shiftPlan.Id), cancellationToken);
+        return true;
+    }
+}

Brizco.Core/EntityServices/Handlers/ShiftPlans/UpdateShiftPlanCoreCommandHandler.cs

@@ -0,0 +1,11 @@
+namespace Brizco.Core.EntityServices.Handlers.ShiftPlans;
+
+public class UpdateShiftPlanCoreCommandHandler(IMediator mediator) : IRequestHandler<UpdateShiftPlanCoreCommand, bool>
+{
+    public async Task<bool> Handle(UpdateShiftPlanCoreCommand request, CancellationToken cancellationToken)
+    {
+        await mediator.Send(new UpdateShiftPlanCommand(request.Id, request.PlanDate, request.ShiftId, request.RoutineId, request.SupervisionUserId, request.UserAndPositionIds), cancellationToken);
+        await mediator.Send(new UpdateActivitiesByShiftPlanCommand(request.Id), cancellationToken);
+        return true;
+    }
+}

Brizco.Core/EntityServices/ShiftPlanService.cs

@@ -1,50 +0,0 @@
-namespace Brizco.Core.EntityServices;
-
-public class ShiftPlanService(IMediator mediator, IActivityService activityService, IRepositoryWrapper repositoryWrapper) : IShiftPlanService
-{
-    public async Task ChangeShiftPlanTaskStatusAsync(Guid shiftPlanId, bool isChangeToShift, bool isDisable)
-    {
-        var shiftPlan = await mediator.Send(new GetShiftPlanQuery(shiftPlanId));
-
-    }
-
-    public async Task<bool> CreateAsync(CreateShiftPlanCommand createShiftPlanCommand, CancellationToken cancellationToken)
-    {
-        var shiftPlan = await mediator.Send(createShiftPlanCommand, cancellationToken);
-        await activityService.CreateActivitiesByShiftPlan(shiftPlan.Id, cancellationToken);
-        await mediator.Send(new CreateShiftPlanNotificationsCommand(shiftPlan.Id,true), cancellationToken);
-        return true;
-    }
-
-    public async Task<bool> UpdateAsync(UpdateShiftPlanCommand updateShiftPlanCommand, CancellationToken cancellationToken)
-    {
-         await mediator.Send(updateShiftPlanCommand, cancellationToken);
-         await activityService.UpdateActivitiesByShiftPlan(updateShiftPlanCommand.Id, cancellationToken);
-         return true;
-    }
-
-    public async Task<bool> CompleteShiftPlanAsync(Guid id, CompleteShiftPlanRequestDto requestDtos, CancellationToken cancellationToken)
-    {
-        var shiftPlan = await repositoryWrapper.SetRepository<ShiftPlan>()
-            .TableNoTracking.FirstOrDefaultAsync(s => s.Id == id, cancellationToken);
-        if (shiftPlan == null)
-            throw new AppException("Shift plan not found", ApiResultStatusCode.NotFound);
-
-        shiftPlan.CompletePlan(requestDtos.CompleteDescription,requestDtos.CompletePercent);
-        repositoryWrapper.SetRepository<ShiftPlan>().Update(shiftPlan);
-        await repositoryWrapper.SaveChangesAsync(cancellationToken);
-        await activityService.CompleteActivitiesAsync(requestDtos.CompleteActivities, cancellationToken);
-
-        var shiftPlanUsers = await repositoryWrapper.SetRepository<ShiftPlanUser>()
-            .TableNoTracking.Where(s => s.ShiftPlanId == id)
-            .Select(ShiftPlanUserMapper.ProjectToSDto)
-            .ToListAsync(cancellationToken);
-        
-        foreach (var shiftPlanUser in shiftPlanUsers)
-        {
-            var message = $"{shiftPlanUser.UserFullName}";
-        }
-
-        return true;
-    }
-}