DD.WellWorkover.Cloud/AsbCloudInfrastructure/Services/ScheduleService.cs

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

namespace AsbCloudInfrastructure.Services
{
    public class ScheduleService : CrudServiceBase<ScheduleDto, ScheduleItem>, IScheduleService
    {
        public ScheduleService(IAsbCloudDbContext context) : base(context)
        {
            Includes.Add(nameof(ScheduleItem.Driller));
        }

        public async Task<int>  DeleteAsync(int id, CancellationToken dto)
        { 
            return await base.DeleteAsync(id,dto);
        }

        public async Task<IEnumerable<ScheduleDto>> GetAllAsync(CancellationToken token)
        {
            return await base.GetAllAsync(token);
        }

        public async Task<ScheduleDto>  GetAsync(int id, CancellationToken token)
        {
            var res= await base.GetAsync(id,token)
                .ConfigureAwait(false);
            return res;
        }

        public async Task<DrillerDto> GetSchedule(int idWell, DateTimeOffset workTime, CancellationToken token = default)
        {
            IQueryable<ScheduleItem> query = context.Set<ScheduleItem>();
            foreach (var include in Includes)
                query = query.Include(include);

            var entires = query.Where(e => e.IdWell==idWell
                && e.DrillStart <= workTime
                && e.DrillEnd >= workTime)
                .FirstOrDefault();

            if (entires is null)
                return null;

            return entires.Driller.Adapt<DrillerDto>();
        }

        public async Task<int> InsertAsync(ScheduleDto dto, CancellationToken token)
        { 
            return await base.InsertAsync(dto,token);
        }

        public async Task<int>  UpdateAsync(int id, ScheduleDto dto, CancellationToken token)
        {
            return await base.UpdateAsync(id,dto,token);
        }

        
    }
}