DD.WellWorkover.Cloud/AsbCloudInfrastructure/Repository/ScheduleRepository.cs

using AsbCloudApp.Data;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Requests;
using Mapster;

namespace AsbCloudInfrastructure.Repository
{

    public class ScheduleRepository : CrudWellRelatedRepositoryBase<ScheduleDto, Schedule>, 
        IScheduleRepository
    {
        private readonly IWellService wellService;

        public ScheduleRepository(IAsbCloudDbContext context, IWellService wellService)
            : base(context, dbSet => dbSet.Include(s => s.Driller))
        {
            this.wellService = wellService;
        }

        public async Task<IEnumerable<ScheduleDto>> GetAsync(int idWell, DateTimeOffset workTime, CancellationToken token)
        {
            var entities = await BuildQuery(idWell, workTime)
                .AsNoTracking()
                .ToArrayAsync(token);

            return entities.Select(Convert);
        }

        public async Task<DrillerDto?> GetOrDefaultDrillerAsync(int idWell, DateTimeOffset workTime, CancellationToken token)
        {
            var entities = await BuildQuery(idWell, workTime)
                .AsNoTracking()
                .ToArrayAsync(token);

            if (!entities.Any())
                return null;
            
            var hoursOffset = wellService.GetTimezone(idWell).Hours;
            var time = new TimeOnly(workTime.Hour, workTime.Minute, workTime.Second);
            
            var entity = entities.FirstOrDefault(s =>
                s.ShiftStart > s.ShiftEnd ^
                (time >= s.ShiftStart && time < s.ShiftEnd)
            );
            
            return entity?.Driller.Adapt<DrillerDto>();
        }

        public async Task<IEnumerable<ScheduleDto>> GetPageAsync(GetStatRequest request, CancellationToken token)
        {
            var idWell = request.IdsWells;
            var idsDrillers = request.IdsDrillers;
            var query =  GetQuery().Where(s =>  request.IdsWells.Contains(s.IdWell));
            if (idsDrillers.Any())
            {
                query = query.Where(s => idsDrillers.Contains(s.IdDriller));
            }

            var result = await query.ToArrayAsync(token);
            return result.Select(Convert);

        }

        private IQueryable<Schedule> BuildQuery(int idWell, DateTimeOffset workTime)
        {
            var hoursOffset = wellService.GetTimezone(idWell).Hours;

            var workTimeDateTime = workTime.ToUniversalTime();
            
            return GetQuery().Where(s => s.IdWell == idWell
                                  && s.DrillStart <= workTimeDateTime
                                  && s.DrillEnd >= workTimeDateTime);
        }

        protected override Schedule Convert(ScheduleDto dto)
        {
            var entity = base.Convert(dto);
            entity.DrillStart = dto.DrillStart.ToUniversalTime();
            entity.DrillEnd = dto.DrillEnd.ToUniversalTime();
            return entity;
        }

        protected override ScheduleDto Convert(Schedule entity)
        {
            var hoursOffset = wellService.GetTimezone(entity.IdWell).Hours;
            var timeSpan = TimeSpan.FromHours(hoursOffset);

            var dto = base.Convert(entity);
            dto.DrillStart = entity.DrillStart.ToOffset(timeSpan);
            dto.DrillEnd = entity.DrillEnd.ToOffset(timeSpan);
            return dto;
        }
    }

}