Api/Brizco.Domain/Mappers/ActivityMapper.g.cs

using System;
using System.Linq.Expressions;
using Brizco.Domain.Dtos.LargDtos;
using Brizco.Domain.Dtos.SmallDtos;
using Brizco.Domain.Entities.Shift;
using Brizco.Domain.Entities.Task;
using Brizco.Domain.Entities.User;
using Mapster.Models;

namespace Brizco.Domain.Mappers
{
    public static partial class ActivityMapper
    {
        public static Activity AdaptToActivity(this ActivitySDto p1)
        {
            return p1 == null ? null : new Activity()
            {
                Status = p1.Status,
                DoneAt = p1.DoneAt,
                IsDone = p1.IsDone,
                UnDoneReason = p1.UnDoneReason,
                PerformanceDescription = p1.PerformanceDescription,
                User = new ApplicationUser()
                {
                    FirstName = p1.UserFirstName,
                    LastName = p1.UserLastName
                },
                ShiftId = p1.ShiftId,
                Shift = new Shift() {Id = p1.ShiftId},
                Type = p1.Type,
                Title = p1.Title,
                Description = p1.Description,
                IsDisposable = p1.IsDisposable,
                SetFor = p1.SetFor,
                HasDisposed = p1.HasDisposed,
                ScheduleType = p1.ScheduleType,
                Amount = p1.Amount,
                AmountType = p1.AmountType,
                Id = p1.Id
            };
        }
        public static Activity AdaptTo(this ActivitySDto p2, Activity p3)
        {
            if (p2 == null)
            {
                return null;
            }
            Activity result = p3 ?? new Activity();
            
            result.Status = p2.Status;
            result.DoneAt = p2.DoneAt;
            result.IsDone = p2.IsDone;
            result.UnDoneReason = p2.UnDoneReason;
            result.PerformanceDescription = p2.PerformanceDescription;
            result.User = funcMain1(new Never(), result.User, p2);
            result.ShiftId = p2.ShiftId;
            result.Shift = funcMain2(new Never(), result.Shift, p2);
            result.Type = p2.Type;
            result.Title = p2.Title;
            result.Description = p2.Description;
            result.IsDisposable = p2.IsDisposable;
            result.SetFor = p2.SetFor;
            result.HasDisposed = p2.HasDisposed;
            result.ScheduleType = p2.ScheduleType;
            result.Amount = p2.Amount;
            result.AmountType = p2.AmountType;
            result.Id = p2.Id;
            return result;
            
        }
        public static Expression<Func<ActivitySDto, Activity>> ProjectToActivity => p8 => new Activity()
        {
            Status = p8.Status,
            DoneAt = p8.DoneAt,
            IsDone = p8.IsDone,
            UnDoneReason = p8.UnDoneReason,
            PerformanceDescription = p8.PerformanceDescription,
            User = new ApplicationUser()
            {
                FirstName = p8.UserFirstName,
                LastName = p8.UserLastName
            },
            ShiftId = p8.ShiftId,
            Shift = new Shift() {Id = p8.ShiftId},
            Type = p8.Type,
            Title = p8.Title,
            Description = p8.Description,
            IsDisposable = p8.IsDisposable,
            SetFor = p8.SetFor,
            HasDisposed = p8.HasDisposed,
            ScheduleType = p8.ScheduleType,
            Amount = p8.Amount,
            AmountType = p8.AmountType,
            Id = p8.Id
        };
        public static ActivitySDto AdaptToSDto(this Activity p9)
        {
            return p9 == null ? null : new ActivitySDto()
            {
                Type = p9.Type,
                Title = p9.Title,
                Description = p9.Description,
                IsDisposable = p9.IsDisposable,
                SetFor = p9.SetFor,
                HasDisposed = p9.HasDisposed,
                ScheduleType = p9.ScheduleType,
                UnDoneReason = p9.UnDoneReason,
                Status = p9.Status,
                DoneAt = p9.DoneAt,
                IsDone = p9.IsDone,
                PerformanceDescription = p9.PerformanceDescription,
                UserFirstName = p9.User != null ? p9.User.FirstName : string.Empty,
                UserLastName = p9.User != null ? p9.User.LastName : string.Empty,
                Amount = p9.Amount,
                ShiftId = p9.ShiftId,
                AmountType = p9.AmountType,
                Id = p9.Id
            };
        }
        public static ActivitySDto AdaptTo(this Activity p10, ActivitySDto p11)
        {
            if (p10 == null)
            {
                return null;
            }
            ActivitySDto result = p11 ?? new ActivitySDto();
            
            result.Type = p10.Type;
            result.Title = p10.Title;
            result.Description = p10.Description;
            result.IsDisposable = p10.IsDisposable;
            result.SetFor = p10.SetFor;
            result.HasDisposed = p10.HasDisposed;
            result.ScheduleType = p10.ScheduleType;
            result.UnDoneReason = p10.UnDoneReason;
            result.Status = p10.Status;
            result.DoneAt = p10.DoneAt;
            result.IsDone = p10.IsDone;
            result.PerformanceDescription = p10.PerformanceDescription;
            result.UserFirstName = p10.User != null ? p10.User.FirstName : string.Empty;
            result.UserLastName = p10.User != null ? p10.User.LastName : string.Empty;
            result.Amount = p10.Amount;
            result.ShiftId = p10.ShiftId;
            result.AmountType = p10.AmountType;
            result.Id = p10.Id;
            return result;
            
        }
        public static Expression<Func<Activity, ActivitySDto>> ProjectToSDto => p12 => new ActivitySDto()
        {
            Type = p12.Type,
            Title = p12.Title,
            Description = p12.Description,
            IsDisposable = p12.IsDisposable,
            SetFor = p12.SetFor,
            HasDisposed = p12.HasDisposed,
            ScheduleType = p12.ScheduleType,
            UnDoneReason = p12.UnDoneReason,
            Status = p12.Status,
            DoneAt = p12.DoneAt,
            IsDone = p12.IsDone,
            PerformanceDescription = p12.PerformanceDescription,
            UserFirstName = p12.User != null ? p12.User.FirstName : string.Empty,
            UserLastName = p12.User != null ? p12.User.LastName : string.Empty,
            Amount = p12.Amount,
            ShiftId = p12.ShiftId,
            AmountType = p12.AmountType,
            Id = p12.Id
        };
        public static Activity AdaptToActivity(this ActivityLDto p13)
        {
            return p13 == null ? null : new Activity()
            {
                Status = p13.Status,
                DoneAt = p13.DoneAt,
                IsDone = p13.IsDone,
                PerformanceDescription = p13.PerformanceDescription,
                Type = p13.Type,
                Title = p13.Title,
                Description = p13.Description,
                IsDisposable = p13.IsDisposable,
                SetFor = p13.SetFor,
                HasDisposed = p13.HasDisposed,
                Amount = p13.Amount,
                AmountType = p13.AmountType,
                Id = p13.Id
            };
        }
        public static Activity AdaptTo(this ActivityLDto p14, Activity p15)
        {
            if (p14 == null)
            {
                return null;
            }
            Activity result = p15 ?? new Activity();
            
            result.Status = p14.Status;
            result.DoneAt = p14.DoneAt;
            result.IsDone = p14.IsDone;
            result.PerformanceDescription = p14.PerformanceDescription;
            result.Type = p14.Type;
            result.Title = p14.Title;
            result.Description = p14.Description;
            result.IsDisposable = p14.IsDisposable;
            result.SetFor = p14.SetFor;
            result.HasDisposed = p14.HasDisposed;
            result.Amount = p14.Amount;
            result.AmountType = p14.AmountType;
            result.Id = p14.Id;
            return result;
            
        }
        public static Expression<Func<ActivityLDto, Activity>> ProjectLDtoToActivity => p16 => new Activity()
        {
            Status = p16.Status,
            DoneAt = p16.DoneAt,
            IsDone = p16.IsDone,
            PerformanceDescription = p16.PerformanceDescription,
            Type = p16.Type,
            Title = p16.Title,
            Description = p16.Description,
            IsDisposable = p16.IsDisposable,
            SetFor = p16.SetFor,
            HasDisposed = p16.HasDisposed,
            Amount = p16.Amount,
            AmountType = p16.AmountType,
            Id = p16.Id
        };
        public static ActivityLDto AdaptToLDto(this Activity p17)
        {
            return p17 == null ? null : new ActivityLDto()
            {
                Type = p17.Type,
                Title = p17.Title,
                Description = p17.Description,
                IsDisposable = p17.IsDisposable,
                SetFor = p17.SetFor,
                HasDisposed = p17.HasDisposed,
                Status = p17.Status,
                DoneAt = p17.DoneAt,
                IsDone = p17.IsDone,
                PerformanceDescription = p17.PerformanceDescription,
                Amount = p17.Amount,
                AmountType = p17.AmountType,
                Id = p17.Id
            };
        }
        public static ActivityLDto AdaptTo(this Activity p18, ActivityLDto p19)
        {
            if (p18 == null)
            {
                return null;
            }
            ActivityLDto result = p19 ?? new ActivityLDto();
            
            result.Type = p18.Type;
            result.Title = p18.Title;
            result.Description = p18.Description;
            result.IsDisposable = p18.IsDisposable;
            result.SetFor = p18.SetFor;
            result.HasDisposed = p18.HasDisposed;
            result.Status = p18.Status;
            result.DoneAt = p18.DoneAt;
            result.IsDone = p18.IsDone;
            result.PerformanceDescription = p18.PerformanceDescription;
            result.Amount = p18.Amount;
            result.AmountType = p18.AmountType;
            result.Id = p18.Id;
            return result;
            
        }
        public static Expression<Func<Activity, ActivityLDto>> ProjectToLDto => p20 => new ActivityLDto()
        {
            Type = p20.Type,
            Title = p20.Title,
            Description = p20.Description,
            IsDisposable = p20.IsDisposable,
            SetFor = p20.SetFor,
            HasDisposed = p20.HasDisposed,
            Status = p20.Status,
            DoneAt = p20.DoneAt,
            IsDone = p20.IsDone,
            PerformanceDescription = p20.PerformanceDescription,
            Amount = p20.Amount,
            AmountType = p20.AmountType,
            Id = p20.Id
        };
        
        private static ApplicationUser funcMain1(Never p4, ApplicationUser p5, ActivitySDto p2)
        {
            ApplicationUser result = p5 ?? new ApplicationUser();
            
            result.FirstName = p2.UserFirstName;
            result.LastName = p2.UserLastName;
            return result;
            
        }
        
        private static Shift funcMain2(Never p6, Shift p7, ActivitySDto p2)
        {
            Shift result = p7 ?? new Shift();
            
            result.Id = p2.ShiftId;
            return result;
            
        }
    }
}