using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Brizco.Common.Extensions;
using Brizco.Domain.Dtos.LargeDtos;
using Brizco.Domain.Dtos.SmallDtos;
using Brizco.Domain.Entities.Complexes;
using Brizco.Domain.Entities.Shifts;
using Brizco.Domain.Entities.Tasks;
using Mapster.Models;

namespace Brizco.Domain.Mappers
{
    public static partial class TaskMapper
    {
        public static Task AdaptToTask(this TaskSDto p1)
        {
            return p1 == null ? null : new Task()
            {
                Type = p1.Type,
                Title = p1.Title,
                Description = p1.Description,
                IsDisposable = p1.IsDisposable,
                SetFor = Convert.ToDateTime(p1.SetFor),
                HasDisposed = p1.HasDisposed,
                ScheduleType = p1.ScheduleType,
                ComplexId = p1.ComplexId,
                Complex = new Complex() {Id = p1.ComplexId},
                Amount = p1.Amount,
                AmountType = p1.AmountType,
                Shifts = funcMain1(p1.Shifts),
                Days = funcMain2(p1.Days),
                Routines = funcMain3(p1.Routines),
                Positions = funcMain4(p1.Positions),
                Id = p1.Id
            };
        }
        public static Task AdaptTo(this TaskSDto p6, Task p7)
        {
            if (p6 == null)
            {
                return null;
            }
            Task result = p7 ?? new Task();
            
            result.Type = p6.Type;
            result.Title = p6.Title;
            result.Description = p6.Description;
            result.IsDisposable = p6.IsDisposable;
            result.SetFor = Convert.ToDateTime(p6.SetFor);
            result.HasDisposed = p6.HasDisposed;
            result.ScheduleType = p6.ScheduleType;
            result.ComplexId = p6.ComplexId;
            result.Complex = funcMain5(new Never(), result.Complex, p6);
            result.Amount = p6.Amount;
            result.AmountType = p6.AmountType;
            result.Shifts = funcMain6(p6.Shifts, result.Shifts);
            result.Days = funcMain7(p6.Days, result.Days);
            result.Routines = funcMain8(p6.Routines, result.Routines);
            result.Positions = funcMain9(p6.Positions, result.Positions);
            result.Id = p6.Id;
            return result;
            
        }
        public static Expression<Func<TaskSDto, Task>> ProjectToTask => p18 => new Task()
        {
            Type = p18.Type,
            Title = p18.Title,
            Description = p18.Description,
            IsDisposable = p18.IsDisposable,
            SetFor = Convert.ToDateTime(p18.SetFor),
            HasDisposed = p18.HasDisposed,
            ScheduleType = p18.ScheduleType,
            ComplexId = p18.ComplexId,
            Complex = new Complex() {Id = p18.ComplexId},
            Amount = p18.Amount,
            AmountType = p18.AmountType,
            Shifts = p18.Shifts.Select<string, TaskShift>(p19 => (TaskShift)Convert.ChangeType((object)p19, typeof(TaskShift))).ToList<TaskShift>(),
            Days = p18.Days.Select<string, TaskDay>(p20 => (TaskDay)Convert.ChangeType((object)p20, typeof(TaskDay))).ToList<TaskDay>(),
            Routines = p18.Routines.Select<string, TaskRoutine>(p21 => (TaskRoutine)Convert.ChangeType((object)p21, typeof(TaskRoutine))).ToList<TaskRoutine>(),
            Positions = p18.Positions.Select<string, TaskPosition>(p22 => (TaskPosition)Convert.ChangeType((object)p22, typeof(TaskPosition))).ToList<TaskPosition>(),
            Id = p18.Id
        };
        public static TaskSDto AdaptToSDto(this Task p23)
        {
            return p23 == null ? null : new TaskSDto()
            {
                Type = p23.Type,
                Title = p23.Title,
                Description = p23.Description,
                IsDisposable = p23.IsDisposable,
                SetFor = DateTimeExtensions.DateTimeToUnixTimeStamp(p23.SetFor),
                HasDisposed = p23.HasDisposed,
                ComplexId = p23.ComplexId,
                ScheduleType = p23.ScheduleType,
                Shifts = funcMain10(p23.Shifts.Select<TaskShift, string>(funcMain11)),
                Routines = funcMain12(p23.Routines.Select<TaskRoutine, string>(funcMain13)),
                Positions = funcMain14(p23.Positions.Select<TaskPosition, string>(funcMain15)),
                Days = funcMain16(p23.Days.Select<TaskDay, string>(funcMain17).ToList<string>()),
                Amount = p23.Amount,
                AmountType = p23.AmountType,
                Id = p23.Id
            };
        }
        public static TaskSDto AdaptTo(this Task p28, TaskSDto p29)
        {
            if (p28 == null)
            {
                return null;
            }
            TaskSDto result = p29 ?? new TaskSDto();
            
            result.Type = p28.Type;
            result.Title = p28.Title;
            result.Description = p28.Description;
            result.IsDisposable = p28.IsDisposable;
            result.SetFor = DateTimeExtensions.DateTimeToUnixTimeStamp(p28.SetFor);
            result.HasDisposed = p28.HasDisposed;
            result.ComplexId = p28.ComplexId;
            result.ScheduleType = p28.ScheduleType;
            result.Shifts = funcMain18(p28.Shifts.Select<TaskShift, string>(funcMain11), result.Shifts);
            result.Routines = funcMain19(p28.Routines.Select<TaskRoutine, string>(funcMain13), result.Routines);
            result.Positions = funcMain20(p28.Positions.Select<TaskPosition, string>(funcMain15), result.Positions);
            result.Days = funcMain21(p28.Days.Select<TaskDay, string>(funcMain17).ToList<string>(), result.Days);
            result.Amount = p28.Amount;
            result.AmountType = p28.AmountType;
            result.Id = p28.Id;
            return result;
            
        }
        public static Expression<Func<Task, TaskSDto>> ProjectToSDto => p38 => new TaskSDto()
        {
            Type = p38.Type,
            Title = p38.Title,
            Description = p38.Description,
            IsDisposable = p38.IsDisposable,
            SetFor = DateTimeExtensions.DateTimeToUnixTimeStamp(p38.SetFor),
            HasDisposed = p38.HasDisposed,
            ComplexId = p38.ComplexId,
            ScheduleType = p38.ScheduleType,
            Shifts = (List<string>)p38.Shifts.Select<TaskShift, string>(d => d.Shift != null ? d.Shift.Title : string.Empty),
            Routines = (List<string>)p38.Routines.Select<TaskRoutine, string>(d => d.Routine != null ? d.Routine.Name : string.Empty),
            Positions = (List<string>)p38.Positions.Select<TaskPosition, string>(d => d.Position != null ? d.Position.Name : string.Empty),
            Days = p38.Days.Select<TaskDay, string>(d => d.DayOfWeek.GetPersianDayOfWeek()).ToList<string>(),
            Amount = p38.Amount,
            AmountType = p38.AmountType,
            Id = p38.Id
        };
        public static Task AdaptToTask(this TaskLDto p39)
        {
            return p39 == null ? null : new Task()
            {
                Type = p39.Type,
                Title = p39.Title,
                Description = p39.Description,
                IsDisposable = p39.IsDisposable,
                SetFor = Convert.ToDateTime(p39.SetFor),
                HasDisposed = p39.HasDisposed,
                ScheduleType = p39.ScheduleType,
                Amount = p39.Amount,
                AmountType = p39.AmountType,
                Shifts = funcMain22(p39.Shifts),
                Days = funcMain23(p39.Days),
                Routines = funcMain24(p39.Routines),
                Positions = funcMain25(p39.Positions),
                Id = p39.Id
            };
        }
        public static Task AdaptTo(this TaskLDto p44, Task p45)
        {
            if (p44 == null)
            {
                return null;
            }
            Task result = p45 ?? new Task();
            
            result.Type = p44.Type;
            result.Title = p44.Title;
            result.Description = p44.Description;
            result.IsDisposable = p44.IsDisposable;
            result.SetFor = Convert.ToDateTime(p44.SetFor);
            result.HasDisposed = p44.HasDisposed;
            result.ScheduleType = p44.ScheduleType;
            result.Amount = p44.Amount;
            result.AmountType = p44.AmountType;
            result.Shifts = funcMain26(p44.Shifts, result.Shifts);
            result.Days = funcMain27(p44.Days, result.Days);
            result.Routines = funcMain28(p44.Routines, result.Routines);
            result.Positions = funcMain29(p44.Positions, result.Positions);
            result.Id = p44.Id;
            return result;
            
        }
        public static TaskLDto AdaptToLDto(this Task p54)
        {
            return p54 == null ? null : new TaskLDto()
            {
                Type = p54.Type,
                Title = p54.Title,
                Description = p54.Description,
                IsDisposable = p54.IsDisposable,
                SetFor = DateTimeExtensions.DateTimeToUnixTimeStamp(p54.SetFor),
                HasDisposed = p54.HasDisposed,
                ScheduleType = p54.ScheduleType,
                Amount = p54.Amount,
                AmountType = p54.AmountType,
                Shifts = funcMain30(p54.Shifts),
                Positions = funcMain31(p54.Positions),
                Days = funcMain32(p54.Days),
                Routines = funcMain33(p54.Routines),
                Id = p54.Id
            };
        }
        public static TaskLDto AdaptTo(this Task p59, TaskLDto p60)
        {
            if (p59 == null)
            {
                return null;
            }
            TaskLDto result = p60 ?? new TaskLDto();
            
            result.Type = p59.Type;
            result.Title = p59.Title;
            result.Description = p59.Description;
            result.IsDisposable = p59.IsDisposable;
            result.SetFor = DateTimeExtensions.DateTimeToUnixTimeStamp(p59.SetFor);
            result.HasDisposed = p59.HasDisposed;
            result.ScheduleType = p59.ScheduleType;
            result.Amount = p59.Amount;
            result.AmountType = p59.AmountType;
            result.Shifts = funcMain34(p59.Shifts, result.Shifts);
            result.Positions = funcMain35(p59.Positions, result.Positions);
            result.Days = funcMain36(p59.Days, result.Days);
            result.Routines = funcMain37(p59.Routines, result.Routines);
            result.Id = p59.Id;
            return result;
            
        }
        public static Expression<Func<Task, TaskLDto>> ProjectToLDto => p69 => new TaskLDto()
        {
            Type = p69.Type,
            Title = p69.Title,
            Description = p69.Description,
            IsDisposable = p69.IsDisposable,
            SetFor = DateTimeExtensions.DateTimeToUnixTimeStamp(p69.SetFor),
            HasDisposed = p69.HasDisposed,
            ScheduleType = p69.ScheduleType,
            Amount = p69.Amount,
            AmountType = p69.AmountType,
            Shifts = p69.Shifts.Select<TaskShift, TaskShiftSDto>(p70 => new TaskShiftSDto()
            {
                ShiftId = p70.ShiftId,
                ShiftName = p70.Shift != null ? p70.Shift.Title : string.Empty,
                TaskId = p70.TaskId,
                TaskTitle = p70.Task != null ? p70.Task.Title : string.Empty,
                Id = p70.Id
            }).ToList<TaskShiftSDto>(),
            Positions = p69.Positions.Select<TaskPosition, TaskPositionSDto>(p71 => new TaskPositionSDto()
            {
                PositionId = p71.PositionId,
                PositionName = p71.Position != null ? p71.Position.Name : string.Empty,
                TaskId = p71.TaskId,
                Id = p71.Id
            }).ToList<TaskPositionSDto>(),
            Days = p69.Days.Select<TaskDay, TaskDaySDto>(p72 => new TaskDaySDto()
            {
                DayOfWeek = p72.DayOfWeek,
                TaskId = p72.TaskId,
                Id = p72.Id
            }).ToList<TaskDaySDto>(),
            Routines = p69.Routines.Select<TaskRoutine, TaskRoutineSDto>(p73 => new TaskRoutineSDto()
            {
                TaskId = p73.TaskId,
                RoutineId = p73.RoutineId,
                Id = p73.Id
            }).ToList<TaskRoutineSDto>(),
            Id = p69.Id
        };
        
        private static List<TaskShift> funcMain1(List<string> p2)
        {
            if (p2 == null)
            {
                return null;
            }
            List<TaskShift> result = new List<TaskShift>(p2.Count);
            
            int i = 0;
            int len = p2.Count;
            
            while (i < len)
            {
                string item = p2[i];
                result.Add(item == null ? null : (TaskShift)Convert.ChangeType((object)item, typeof(TaskShift)));
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDay> funcMain2(List<string> p3)
        {
            if (p3 == null)
            {
                return null;
            }
            List<TaskDay> result = new List<TaskDay>(p3.Count);
            
            int i = 0;
            int len = p3.Count;
            
            while (i < len)
            {
                string item = p3[i];
                result.Add(item == null ? null : (TaskDay)Convert.ChangeType((object)item, typeof(TaskDay)));
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutine> funcMain3(List<string> p4)
        {
            if (p4 == null)
            {
                return null;
            }
            List<TaskRoutine> result = new List<TaskRoutine>(p4.Count);
            
            int i = 0;
            int len = p4.Count;
            
            while (i < len)
            {
                string item = p4[i];
                result.Add(item == null ? null : (TaskRoutine)Convert.ChangeType((object)item, typeof(TaskRoutine)));
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPosition> funcMain4(List<string> p5)
        {
            if (p5 == null)
            {
                return null;
            }
            List<TaskPosition> result = new List<TaskPosition>(p5.Count);
            
            int i = 0;
            int len = p5.Count;
            
            while (i < len)
            {
                string item = p5[i];
                result.Add(item == null ? null : (TaskPosition)Convert.ChangeType((object)item, typeof(TaskPosition)));
                i++;
            }
            return result;
            
        }
        
        private static Complex funcMain5(Never p8, Complex p9, TaskSDto p6)
        {
            Complex result = p9 ?? new Complex();
            
            result.Id = p6.ComplexId;
            return result;
            
        }
        
        private static List<TaskShift> funcMain6(List<string> p10, List<TaskShift> p11)
        {
            if (p10 == null)
            {
                return null;
            }
            List<TaskShift> result = new List<TaskShift>(p10.Count);
            
            int i = 0;
            int len = p10.Count;
            
            while (i < len)
            {
                string item = p10[i];
                result.Add(item == null ? null : (TaskShift)Convert.ChangeType((object)item, typeof(TaskShift)));
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDay> funcMain7(List<string> p12, List<TaskDay> p13)
        {
            if (p12 == null)
            {
                return null;
            }
            List<TaskDay> result = new List<TaskDay>(p12.Count);
            
            int i = 0;
            int len = p12.Count;
            
            while (i < len)
            {
                string item = p12[i];
                result.Add(item == null ? null : (TaskDay)Convert.ChangeType((object)item, typeof(TaskDay)));
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutine> funcMain8(List<string> p14, List<TaskRoutine> p15)
        {
            if (p14 == null)
            {
                return null;
            }
            List<TaskRoutine> result = new List<TaskRoutine>(p14.Count);
            
            int i = 0;
            int len = p14.Count;
            
            while (i < len)
            {
                string item = p14[i];
                result.Add(item == null ? null : (TaskRoutine)Convert.ChangeType((object)item, typeof(TaskRoutine)));
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPosition> funcMain9(List<string> p16, List<TaskPosition> p17)
        {
            if (p16 == null)
            {
                return null;
            }
            List<TaskPosition> result = new List<TaskPosition>(p16.Count);
            
            int i = 0;
            int len = p16.Count;
            
            while (i < len)
            {
                string item = p16[i];
                result.Add(item == null ? null : (TaskPosition)Convert.ChangeType((object)item, typeof(TaskPosition)));
                i++;
            }
            return result;
            
        }
        
        private static List<string> funcMain10(IEnumerable<string> p24)
        {
            if (p24 == null)
            {
                return null;
            }
            List<string> result = new List<string>();
            
            IEnumerator<string> enumerator = p24.GetEnumerator();
            
            while (enumerator.MoveNext())
            {
                string item = enumerator.Current;
                result.Add(item);
            }
            return result;
            
        }
        
        private static string funcMain11(TaskShift d)
        {
            return d.Shift != null ? d.Shift.Title : string.Empty;
        }
        
        private static List<string> funcMain12(IEnumerable<string> p25)
        {
            if (p25 == null)
            {
                return null;
            }
            List<string> result = new List<string>();
            
            IEnumerator<string> enumerator = p25.GetEnumerator();
            
            while (enumerator.MoveNext())
            {
                string item = enumerator.Current;
                result.Add(item);
            }
            return result;
            
        }
        
        private static string funcMain13(TaskRoutine d)
        {
            return d.Routine != null ? d.Routine.Name : string.Empty;
        }
        
        private static List<string> funcMain14(IEnumerable<string> p26)
        {
            if (p26 == null)
            {
                return null;
            }
            List<string> result = new List<string>();
            
            IEnumerator<string> enumerator = p26.GetEnumerator();
            
            while (enumerator.MoveNext())
            {
                string item = enumerator.Current;
                result.Add(item);
            }
            return result;
            
        }
        
        private static string funcMain15(TaskPosition d)
        {
            return d.Position != null ? d.Position.Name : string.Empty;
        }
        
        private static List<string> funcMain16(List<string> p27)
        {
            if (p27 == null)
            {
                return null;
            }
            List<string> result = new List<string>(p27.Count);
            
            int i = 0;
            int len = p27.Count;
            
            while (i < len)
            {
                string item = p27[i];
                result.Add(item);
                i++;
            }
            return result;
            
        }
        
        private static string funcMain17(TaskDay d)
        {
            return d.DayOfWeek.GetPersianDayOfWeek();
        }
        
        private static List<string> funcMain18(IEnumerable<string> p30, List<string> p31)
        {
            if (p30 == null)
            {
                return null;
            }
            List<string> result = new List<string>();
            
            IEnumerator<string> enumerator = p30.GetEnumerator();
            
            while (enumerator.MoveNext())
            {
                string item = enumerator.Current;
                result.Add(item);
            }
            return result;
            
        }
        
        private static List<string> funcMain19(IEnumerable<string> p32, List<string> p33)
        {
            if (p32 == null)
            {
                return null;
            }
            List<string> result = new List<string>();
            
            IEnumerator<string> enumerator = p32.GetEnumerator();
            
            while (enumerator.MoveNext())
            {
                string item = enumerator.Current;
                result.Add(item);
            }
            return result;
            
        }
        
        private static List<string> funcMain20(IEnumerable<string> p34, List<string> p35)
        {
            if (p34 == null)
            {
                return null;
            }
            List<string> result = new List<string>();
            
            IEnumerator<string> enumerator = p34.GetEnumerator();
            
            while (enumerator.MoveNext())
            {
                string item = enumerator.Current;
                result.Add(item);
            }
            return result;
            
        }
        
        private static List<string> funcMain21(List<string> p36, List<string> p37)
        {
            if (p36 == null)
            {
                return null;
            }
            List<string> result = new List<string>(p36.Count);
            
            int i = 0;
            int len = p36.Count;
            
            while (i < len)
            {
                string item = p36[i];
                result.Add(item);
                i++;
            }
            return result;
            
        }
        
        private static List<TaskShift> funcMain22(List<TaskShiftSDto> p40)
        {
            if (p40 == null)
            {
                return null;
            }
            List<TaskShift> result = new List<TaskShift>(p40.Count);
            
            int i = 0;
            int len = p40.Count;
            
            while (i < len)
            {
                TaskShiftSDto item = p40[i];
                result.Add(item == null ? null : new TaskShift()
                {
                    TaskId = item.TaskId,
                    Task = new Task()
                    {
                        Title = item.TaskTitle,
                        Id = item.TaskId
                    },
                    ShiftId = item.ShiftId,
                    Shift = new Shift() {Id = item.ShiftId},
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDay> funcMain23(List<TaskDaySDto> p41)
        {
            if (p41 == null)
            {
                return null;
            }
            List<TaskDay> result = new List<TaskDay>(p41.Count);
            
            int i = 0;
            int len = p41.Count;
            
            while (i < len)
            {
                TaskDaySDto item = p41[i];
                result.Add(item == null ? null : new TaskDay()
                {
                    DayOfWeek = item.DayOfWeek,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutine> funcMain24(List<TaskRoutineSDto> p42)
        {
            if (p42 == null)
            {
                return null;
            }
            List<TaskRoutine> result = new List<TaskRoutine>(p42.Count);
            
            int i = 0;
            int len = p42.Count;
            
            while (i < len)
            {
                TaskRoutineSDto item = p42[i];
                result.Add(item == null ? null : new TaskRoutine()
                {
                    TaskId = item.TaskId,
                    RoutineId = item.RoutineId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPosition> funcMain25(List<TaskPositionSDto> p43)
        {
            if (p43 == null)
            {
                return null;
            }
            List<TaskPosition> result = new List<TaskPosition>(p43.Count);
            
            int i = 0;
            int len = p43.Count;
            
            while (i < len)
            {
                TaskPositionSDto item = p43[i];
                result.Add(item == null ? null : new TaskPosition()
                {
                    PositionId = item.PositionId,
                    Position = new Position()
                    {
                        Name = item.PositionName,
                        Id = item.PositionId
                    },
                    TaskId = item.TaskId,
                    Task = new Task() {Id = item.TaskId},
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskShift> funcMain26(List<TaskShiftSDto> p46, List<TaskShift> p47)
        {
            if (p46 == null)
            {
                return null;
            }
            List<TaskShift> result = new List<TaskShift>(p46.Count);
            
            int i = 0;
            int len = p46.Count;
            
            while (i < len)
            {
                TaskShiftSDto item = p46[i];
                result.Add(item == null ? null : new TaskShift()
                {
                    TaskId = item.TaskId,
                    Task = new Task()
                    {
                        Title = item.TaskTitle,
                        Id = item.TaskId
                    },
                    ShiftId = item.ShiftId,
                    Shift = new Shift() {Id = item.ShiftId},
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDay> funcMain27(List<TaskDaySDto> p48, List<TaskDay> p49)
        {
            if (p48 == null)
            {
                return null;
            }
            List<TaskDay> result = new List<TaskDay>(p48.Count);
            
            int i = 0;
            int len = p48.Count;
            
            while (i < len)
            {
                TaskDaySDto item = p48[i];
                result.Add(item == null ? null : new TaskDay()
                {
                    DayOfWeek = item.DayOfWeek,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutine> funcMain28(List<TaskRoutineSDto> p50, List<TaskRoutine> p51)
        {
            if (p50 == null)
            {
                return null;
            }
            List<TaskRoutine> result = new List<TaskRoutine>(p50.Count);
            
            int i = 0;
            int len = p50.Count;
            
            while (i < len)
            {
                TaskRoutineSDto item = p50[i];
                result.Add(item == null ? null : new TaskRoutine()
                {
                    TaskId = item.TaskId,
                    RoutineId = item.RoutineId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPosition> funcMain29(List<TaskPositionSDto> p52, List<TaskPosition> p53)
        {
            if (p52 == null)
            {
                return null;
            }
            List<TaskPosition> result = new List<TaskPosition>(p52.Count);
            
            int i = 0;
            int len = p52.Count;
            
            while (i < len)
            {
                TaskPositionSDto item = p52[i];
                result.Add(item == null ? null : new TaskPosition()
                {
                    PositionId = item.PositionId,
                    Position = new Position()
                    {
                        Name = item.PositionName,
                        Id = item.PositionId
                    },
                    TaskId = item.TaskId,
                    Task = new Task() {Id = item.TaskId},
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskShiftSDto> funcMain30(List<TaskShift> p55)
        {
            if (p55 == null)
            {
                return null;
            }
            List<TaskShiftSDto> result = new List<TaskShiftSDto>(p55.Count);
            
            int i = 0;
            int len = p55.Count;
            
            while (i < len)
            {
                TaskShift item = p55[i];
                result.Add(item == null ? null : new TaskShiftSDto()
                {
                    ShiftId = item.ShiftId,
                    ShiftName = item.Shift != null ? item.Shift.Title : string.Empty,
                    TaskId = item.TaskId,
                    TaskTitle = item.Task != null ? item.Task.Title : string.Empty,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPositionSDto> funcMain31(List<TaskPosition> p56)
        {
            if (p56 == null)
            {
                return null;
            }
            List<TaskPositionSDto> result = new List<TaskPositionSDto>(p56.Count);
            
            int i = 0;
            int len = p56.Count;
            
            while (i < len)
            {
                TaskPosition item = p56[i];
                result.Add(item == null ? null : new TaskPositionSDto()
                {
                    PositionId = item.PositionId,
                    PositionName = item.Position != null ? item.Position.Name : string.Empty,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDaySDto> funcMain32(List<TaskDay> p57)
        {
            if (p57 == null)
            {
                return null;
            }
            List<TaskDaySDto> result = new List<TaskDaySDto>(p57.Count);
            
            int i = 0;
            int len = p57.Count;
            
            while (i < len)
            {
                TaskDay item = p57[i];
                result.Add(item == null ? null : new TaskDaySDto()
                {
                    DayOfWeek = item.DayOfWeek,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutineSDto> funcMain33(List<TaskRoutine> p58)
        {
            if (p58 == null)
            {
                return null;
            }
            List<TaskRoutineSDto> result = new List<TaskRoutineSDto>(p58.Count);
            
            int i = 0;
            int len = p58.Count;
            
            while (i < len)
            {
                TaskRoutine item = p58[i];
                result.Add(item == null ? null : new TaskRoutineSDto()
                {
                    TaskId = item.TaskId,
                    RoutineId = item.RoutineId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskShiftSDto> funcMain34(List<TaskShift> p61, List<TaskShiftSDto> p62)
        {
            if (p61 == null)
            {
                return null;
            }
            List<TaskShiftSDto> result = new List<TaskShiftSDto>(p61.Count);
            
            int i = 0;
            int len = p61.Count;
            
            while (i < len)
            {
                TaskShift item = p61[i];
                result.Add(item == null ? null : new TaskShiftSDto()
                {
                    ShiftId = item.ShiftId,
                    ShiftName = item.Shift != null ? item.Shift.Title : string.Empty,
                    TaskId = item.TaskId,
                    TaskTitle = item.Task != null ? item.Task.Title : string.Empty,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskPositionSDto> funcMain35(List<TaskPosition> p63, List<TaskPositionSDto> p64)
        {
            if (p63 == null)
            {
                return null;
            }
            List<TaskPositionSDto> result = new List<TaskPositionSDto>(p63.Count);
            
            int i = 0;
            int len = p63.Count;
            
            while (i < len)
            {
                TaskPosition item = p63[i];
                result.Add(item == null ? null : new TaskPositionSDto()
                {
                    PositionId = item.PositionId,
                    PositionName = item.Position != null ? item.Position.Name : string.Empty,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskDaySDto> funcMain36(List<TaskDay> p65, List<TaskDaySDto> p66)
        {
            if (p65 == null)
            {
                return null;
            }
            List<TaskDaySDto> result = new List<TaskDaySDto>(p65.Count);
            
            int i = 0;
            int len = p65.Count;
            
            while (i < len)
            {
                TaskDay item = p65[i];
                result.Add(item == null ? null : new TaskDaySDto()
                {
                    DayOfWeek = item.DayOfWeek,
                    TaskId = item.TaskId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
        
        private static List<TaskRoutineSDto> funcMain37(List<TaskRoutine> p67, List<TaskRoutineSDto> p68)
        {
            if (p67 == null)
            {
                return null;
            }
            List<TaskRoutineSDto> result = new List<TaskRoutineSDto>(p67.Count);
            
            int i = 0;
            int len = p67.Count;
            
            while (i < len)
            {
                TaskRoutine item = p67[i];
                result.Add(item == null ? null : new TaskRoutineSDto()
                {
                    TaskId = item.TaskId,
                    RoutineId = item.RoutineId,
                    Id = item.Id
                });
                i++;
            }
            return result;
            
        }
    }
}