Api/Brizco.Core/EntityServices/ActivityService.cs

using Brizco.Domain.CommandQueries.Queries;
using Brizco.Domain.Entities.Shift;
using Brizco.Domain.Entities.Task;
using System.Threading.Tasks;
using Brizco.Domain.Mappers;

namespace Brizco.Core.EntityServices;

public class ActivityService : IActivityService
{
    private readonly IMediator _mediator;
    private readonly IRepositoryWrapper _repositoryWrapper;

    public ActivityService(IMediator mediator,IRepositoryWrapper repositoryWrapper)
    {
        _mediator = mediator;
        _repositoryWrapper = repositoryWrapper;
    }


    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 tasks = await _repositoryWrapper.SetRepository<Brizco.Domain.Entities.Task.Task>()
            .ExecuteCommand(
                $@"SELECT t.""Id"", t.""Amount"", t.""AmountType"", t.""ComplexId"", 
t.""CreatedAt"", t.""CreatedBy"", t.""Description"", t.""Discriminator"", t.""HasDisposed"", t.""IsDisposable"", t.""IsRemoved"", t.""ModifiedAt"", 
t.""ModifiedBy"", t.""RemovedAt"", t.""RemovedBy"", t.""ScheduleType"", t.""SetFor"", t.""Title"", t.""Type"", t.""DoneAt"", t.""IsDone"", 
t.""PerformanceDescription"", t.""ShiftId"", t.""Status"", t.""UserId"" , t.""IsActivity"" , t.""UnDoneReason""
FROM public.""Tasks"" t
INNER JOIN public.""TaskShifts"" t1 ON t.""Id"" = t1.""TaskId""
INNER JOIN public.""TaskDays"" t2 ON t.""Id"" = t1.""TaskId""
INNER JOIN public.""TaskRoutines"" t3 ON t.""Id"" = t1.""TaskId""
AND {shiftPlan.ShiftId} = t1.""ShiftId""
AND {shiftPlan.RoutineId} = t3.""RoutineId""
AND {shiftPlan.PlanFor.DayOfWeek} = t2.""DayOfWeek""
GROUP BY t.""Id""").AsNoTracking().ToListAsync(cancellationToken);

        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.ShiftId == 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.ShiftId,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 tasks = await _repositoryWrapper.SetRepository<Brizco.Domain.Entities.Task.Task>()
            .ExecuteCommand(
                $@"SELECT t.""Id"", t.""Amount"", t.""AmountType"", t.""ComplexId"", 
t.""CreatedAt"", t.""CreatedBy"", t.""Description"", t.""Discriminator"", t.""HasDisposed"", t.""IsDisposable"", t.""IsRemoved"", t.""ModifiedAt"", 
t.""ModifiedBy"", t.""RemovedAt"", t.""RemovedBy"", t.""ScheduleType"", t.""SetFor"", t.""Title"", t.""Type"", t.""DoneAt"", t.""IsDone"", 
t.""PerformanceDescription"", t.""ShiftId"", t.""Status"", t.""UserId"" , t.""IsActivity"" , t.""UnDoneReason""
FROM public.""Tasks"" t
INNER JOIN public.""TaskShifts"" t1 ON t.""Id"" = t1.""TaskId""
INNER JOIN public.""TaskDays"" t2 ON t.""Id"" = t1.""TaskId""
INNER JOIN public.""TaskRoutines"" t3 ON t.""Id"" = t1.""TaskId""
AND {shiftPlan.ShiftId} = t1.""ShiftId""
AND {shiftPlan.RoutineId} = t3.""RoutineId""
AND {shiftPlan.PlanFor.DayOfWeek} = t2.""DayOfWeek""
GROUP BY t.""Id""").AsNoTracking().ToListAsync(cancellationToken);

        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.ShiftId, fundedUser.UserId),cancellationToken);
                }
            }
        }

        return true;
    }
}