chore(ChangeServicesToCommand) , fix(FixControllerMethodsName)

master
Amir Hossein Khademi 2024-08-11 20:25:18 +03:30
parent 39f6320063
commit cba03cc53b
26 changed files with 396 additions and 314 deletions

View File

@ -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)
=> TypedResults.Ok(await activityService.DoneActivityAsync(id, cancellationToken));
public async Task<IResult> GetAsync(Guid id, [FromServices]IMediator mediator, CancellationToken cancellationToken)
=> TypedResults.Ok(await mediator.Send(new DoneActivityCommand(id),cancellationToken));
public async Task<IResult> CompleteActivityAsync([FromBody] List<CompleteActivityRequestDto> requestDtos, [FromServices] IActivityService activityService, CancellationToken cancellationToken)
=> TypedResults.Ok(await activityService.CompleteActivitiesAsync(requestDtos, cancellationToken));
public async Task<IResult> CompleteActivityAsync([FromBody] List<CompleteActivityRequestDto> requestDtos, [FromServices] IMediator mediator, CancellationToken cancellationToken)
=> TypedResults.Ok(await mediator.Send(new CompleteActivitiesCommand(requestDtos),cancellationToken));
public async Task<IResult> DoneActivityAsync(Guid id, [FromServices] IActivityService activityService, CancellationToken cancellationToken)
=> TypedResults.Ok(await activityService.DoneActivityAsync(id, cancellationToken));
public async Task<IResult> DoneActivityAsync(Guid id, [FromServices] IMediator mediator, CancellationToken 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)
=> TypedResults.Ok(await activityService.UnDoneActivityAsync(id, undoneReason, cancellationToken));
public async Task<IResult> UnDoneActivityAsync(Guid id, [FromQuery] string undoneReason, [FromServices] IMediator mediator, CancellationToken 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)

View File

@ -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);
}

View File

@ -11,7 +11,7 @@ public class PageController : ICarterModule
.RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
group.MapGet("/app/dashboard", GetAppDashboardAsync)
.WithDisplayName("GetAppDashboard")
.WithDisplayName("Get App Dashboard")
.HasApiVersion(1.0);
group.MapGet("/app/shifting", GetAppShiftingPageAsync)

View File

@ -10,24 +10,27 @@ 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);
group.MapGet("{id}", GetAsync)
.WithDisplayName("GetPosition")
.WithDisplayName("Get Position")
.RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ViewPositions, ApplicationPermission.ManagePositions))
.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);

View File

@ -9,29 +9,32 @@ 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);
group.MapGet("{id}/shift", GetShiftsAsync)
.WithDisplayName("GetRoutineShifts")
.WithDisplayName("Get Routine Shifts")
.RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageRoutines, ApplicationPermission.ViewRoutines))
.HasApiVersion(1.0);
group.MapGet("{id}", GetAsync)
.WithDisplayName("GetRoutine")
.WithDisplayName("Get Routine")
.RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageRoutines))
.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);
}

View File

@ -10,24 +10,27 @@ 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);
group.MapGet("{id}", GetAsync)
.WithDisplayName("GetSection")
.WithDisplayName("Get Section")
.RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageSections, ApplicationPermission.ViewSections))
.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);
}

View File

@ -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);
}

View File

@ -1,4 +1,6 @@
namespace Brizco.Api.Controllers;
using Brizco.Core.EntityServices.CommandQueries;
namespace Brizco.Api.Controllers;
public class ShiftPlanController : ICarterModule
{
@ -10,66 +12,70 @@ public class ShiftPlanController : ICarterModule
.RequireAuthorization(builder => builder.AddAuthenticationSchemes("Bearer").RequireAuthenticatedUser());
group.MapGet("", GetAllAsync)
.WithDisplayName("GetShiftPlans")
.WithDisplayName("Get ShiftPlans")
.RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShiftPlans, ApplicationPermission.ViewShiftPlans))
.HasApiVersion(1.0);
group.MapGet("{id:guid}", GetAsync)
.WithDisplayName("GetShiftPlan")
.WithDisplayName("Get ShiftPlan")
.RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShiftPlans, ApplicationPermission.ViewShiftPlans))
.HasApiVersion(1.0);
group.MapPost("{id:guid}/complete", CompletePlanAsync)
.WithDisplayName("DoneActivity")
.WithDisplayName("Done Activity")
.RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShiftPlans))
.HasApiVersion(1.0);
group.MapPost("{id:guid}/activity", GetShiftPlanActivitiesAsync)
.WithDisplayName("Get Shift Plan Activities")
.WithDisplayName("Get ShiftPlan Activities")
.RequireAuthorization(builder => builder.RequireClaim(CustomClaimType.Permission, ApplicationPermission.ManageShiftPlans))
.HasApiVersion(1.0);
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)
.HasApiVersion(1.0);
.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)
=> TypedResults.Ok(await shiftPlanService.CompleteShiftPlanAsync(id,requestDtos, cancellationToken));
public async Task<IResult> CompletePlanAsync(Guid id, [FromBody] CompleteShiftPlanRequestDto requestDtos, [FromServices] IMediator mediator, CancellationToken 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)
public async Task<IResult> GetShiftPlanActivitiesAsync([FromRoute] Guid id, ISender sender, CancellationToken cancellationToken)
=> TypedResults.Ok(await sender.Send(new GetShiftPlanActivitiesQuery(ShiftPlanId: id), cancellationToken));
// GET:Get All Entity
public async Task<IResult> GetAllAsync([FromQuery] int page,
[FromQuery] long? selectedDate,
[FromQuery] DateTimeQueryFilter? dateFilter ,
[FromServices]ISender sender, CancellationToken cancellationToken)
=> TypedResults.Ok(await sender.Send(new GetShiftPlansQuery(page , selectedDate ?? 0 , DateTimeQueryFilter: dateFilter), cancellationToken));
[FromQuery] DateTimeQueryFilter? dateFilter,
[FromServices] ISender sender, CancellationToken cancellationToken)
=> TypedResults.Ok(await sender.Send(new GetShiftPlansQuery(page, selectedDate ?? 0, DateTimeQueryFilter: dateFilter), cancellationToken));
// GET:Get An Entity By Id
public async Task<IResult> GetAsync(Guid id, ISender sender, CancellationToken cancellationToken)
=> TypedResults.Ok(await sender.Send(new GetShiftPlanQuery(id),cancellationToken));
=> TypedResults.Ok(await sender.Send(new GetShiftPlanQuery(id), cancellationToken));
// POST:Create Entity
public async Task<IResult> Post([FromBody] CreateShiftPlanCommand ent, IShiftPlanService shiftPlanService, CancellationToken cancellationToken)
=> TypedResults.Ok(await shiftPlanService.CreateAsync(ent, cancellationToken));
public async Task<IResult> Post([FromBody] CreateShiftPlanCoreCommand ent, [FromServices] IMediator mediator, CancellationToken cancellationToken)
=> TypedResults.Ok(await mediator.Send(ent, cancellationToken));
// PUT:Update Entity
public async Task<IResult> Put([FromBody] UpdateShiftPlanCommand ent, IShiftPlanService shiftPlanService, CancellationToken cancellationToken)
=> TypedResults.Ok(await shiftPlanService.UpdateAsync(ent, cancellationToken));
public async Task<IResult> Put([FromBody] UpdateShiftPlanCoreCommand ent, [FromServices] IMediator mediator, CancellationToken cancellationToken)
=> TypedResults.Ok(await mediator.Send(ent, cancellationToken));
// DELETE:Delete Entity
public async Task<IResult> Delete(Guid id, ISender mediator, CancellationToken cancellationToken)

View File

@ -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);
}

View File

@ -12,37 +12,40 @@ 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);
group.MapGet("/profile", GetUserProfileAsync)
.WithDisplayName("GetUserProfile")
.WithDisplayName("Get User Profile")
.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);
}

View File

@ -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,
requestDto.ComplexAddress,
requestDto.SupportPhoneNumber,
user.Id,
cancellationToken);
await mediator.Send(new CreateComplexCoreCommand(requestDto.ComplexName, requestDto.ComplexAddress,
requestDto.SupportPhoneNumber, user.Id),cancellationToken);
return await CompleteLogin(user, cancellationToken);
}

View File

@ -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);
}

View File

@ -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);
}

View File

@ -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;
}
}

View File

@ -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>;

View File

@ -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>;

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}