Add project files.

FaKrosnoEfDataModel/Services/IScheduleOrderDetailsService.cs

@@ -0,0 +1,14 @@
+using FaKrosnoEfDataModel.Dtos;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FaKrosnoEfDataModel.Services
+{
+    public interface IScheduleOrderDetailsService
+    {
+        Task<IEnumerable<ScheduleOrderDetailDto>?> GetScheduleOrderDetailsAsync(int scheduleOrderId);
+    }
+}

FaKrosnoEfDataModel/Services/IScheduleOrderService.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FaKrosnoEfDataModel.Dtos;
+
+namespace FaKrosnoEfDataModel.Services
+{
+    public interface IScheduleOrderService
+    {
+        Task<IEnumerable<ScheduleOrderDto?>> GetEntities();
+        Task<ScheduleOrderDto?> GetById(int id);
+        Task<IEnumerable<ScheduleOrderDto?>> GetByRecipientId(int recipientId);
+        Task<IEnumerable<ScheduleOrderDto?>> GetEntitiesByLastUpdateDate(DateTime date);
+        Task<IEnumerable<ScheduleOrderDto?>> GetByRecipientAndLastUpdateDate(int recipientId, DateTime date);
+    }
+}

FaKrosnoEfDataModel/Services/ScheduleOrderDetailsService.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using FaKrosnoEfDataModel.Dtos;
+using Microsoft.EntityFrameworkCore;
+
+namespace FaKrosnoEfDataModel.Services
+{
+    public class ScheduleOrderDetailsService : ServiceBase<ScheduleOrderDetailDto>, IScheduleOrderDetailsService
+    {
+        public ScheduleOrderDetailsService(FaKrosnoDbContext context, IMapper mapper) : base(context, mapper)
+        {
+        }
+
+        public async Task<IEnumerable<ScheduleOrderDetailDto>?> GetScheduleOrderDetailsAsync(int scheduleOrderId)
+        {
+            return await Context.ScheduleOrderDetails.Where(x => x.ScheduleOrderID == scheduleOrderId)
+                .ProjectTo<ScheduleOrderDetailDto>(Mapper.ConfigurationProvider).ToListAsync();
+        }
+    }
+}

FaKrosnoEfDataModel/Services/ScheduleOrderService.cs

@@ -0,0 +1,51 @@
+using AutoMapper;
+using FaKrosnoEfDataModel.Dtos;
+using FaKrosnoEfDataModel.Entities;
+using FaKrosnoEfDataModel.Queries;
+using Microsoft.EntityFrameworkCore;
+
+namespace FaKrosnoEfDataModel.Services
+{
+    public class ScheduleOrderService : ServiceBase<ScheduleOrderDto>, IScheduleOrderService
+    {
+        public ScheduleOrderService(FaKrosnoDbContext context, IMapper mapper) : base(context, mapper)
+        {
+        }
+
+        public override async Task<ScheduleOrderDto?> GetById(int id)
+        {
+            var scheduleOrder = await Task.FromResult(ScheduleOrderQueries.GetById(Context, id));
+
+            return scheduleOrder != null ? Mapper.Map<ScheduleOrderDto>(scheduleOrder) : null;
+        }
+
+        public async Task<IEnumerable<ScheduleOrderDto?>> GetByRecipientId(int recipientId)
+        {
+            IList<ScheduleOrderDto> scheduleOrders = (await GetAll()).ToList();
+
+            return scheduleOrders.Where(x => x?.RecipientID == recipientId);
+        }
+
+        public async Task<IEnumerable<ScheduleOrderDto?>> GetByRecipientAndLastUpdateDate(int recipientId, DateTime date)
+        {
+            IList<ScheduleOrderDto?> scheduleOrders = (await GetEntitiesByLastUpdateDate(date)).ToList();
+
+            return scheduleOrders.Where(x => x?.RecipientID == recipientId && x.LastUpdateDate >= date);
+        }
+
+        public async Task<IEnumerable<ScheduleOrderDto?>> GetEntities()
+        {
+            IList<ScheduleOrder> scheduleOrders = await Context.ScheduleOrders.Include(x => x.Recipient)
+                .ThenInclude(x => x.Purchaser).ToListAsync();
+
+            return Mapper.Map<IEnumerable<ScheduleOrderDto>>(scheduleOrders);
+        }
+        public async Task<IEnumerable<ScheduleOrderDto?>> GetEntitiesByLastUpdateDate(DateTime date)
+        {
+            IList<ScheduleOrder?> scheduleOrders =
+                (await Task.FromResult(ScheduleOrderQueries.GetEntitiesByDate(Context, date))).ToList();
+
+            return Mapper.Map<IEnumerable<ScheduleOrderDto>>(scheduleOrders);
+        }
+    }
+}

FaKrosnoEfDataModel/Services/ServiceBase.cs

@@ -0,0 +1,73 @@
+using AutoMapper;
+using AutoMapper.Internal;
+using FaKrosnoEfDataModel.Dtos;
+using Microsoft.EntityFrameworkCore;
+using System.Reflection;
+
+namespace FaKrosnoEfDataModel.Services
+{
+    public class ServiceBase<T> where T : DtoBase 
+    {
+        protected readonly FaKrosnoDbContext Context;
+        protected readonly IMapper Mapper;
+        protected readonly Type EntityType;
+
+        public ServiceBase(FaKrosnoDbContext context, IMapper mapper)
+        {
+            Context = context;
+            Mapper = mapper;
+            EntityType = FindEntityTypeForDto(typeof(T));
+        }
+
+        public virtual async Task<T?> GetById(int id)
+        {
+            object? entity = await Context.FindAsync(EntityType, id);
+
+            if (entity != null)
+            {
+                return (T)Mapper.Map(entity, entity.GetType(), typeof(T));
+            }
+
+            return default;
+        }
+
+        public virtual async Task<IEnumerable<T>> GetAll()
+        {
+            MethodInfo? setMethod =
+                typeof(DbContext).GetMethod("Set", Array.Empty<Type>())?.MakeGenericMethod(EntityType);
+            
+            IQueryable? dbSet = setMethod?.Invoke(Context, null) as IQueryable;
+
+            if (dbSet == null)
+            {
+                throw new InvalidOperationException("Failed to get DbSet for entity type.");
+            }
+
+            IList<object> entities = await Task.Run(() => dbSet.Cast<object>().ToListAsync());
+
+            return entities.Select(e => (T)Mapper.Map(e, e.GetType(), typeof(T)));
+        }
+
+        private Type FindEntityTypeForDto(Type dtoType)
+        {
+            IGlobalConfiguration? internalApi = Mapper.ConfigurationProvider.Internal();
+            
+            TypeMap map = internalApi.FindTypeMapFor(dtoType, null);
+
+            if (map != null)
+            {
+                return map.DestinationType;
+            }
+            
+            foreach (var typeMap in internalApi.GetAllTypeMaps())
+            {
+                if (typeMap.SourceType == dtoType)
+                {
+                    return typeMap.DestinationType;
+                }
+            }
+
+            throw new InvalidOperationException($"No mapping found for DTO type: {dtoType.Name}");
+        }
+    }
+}