tnb.server/BasicData/Tnb.BasicData/BasCalendarService.cs

using JNPF.Common.Core.Manager;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.JsonSerialization;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Tnb.BasicData.Entities;
using Tnb.BasicData.Entities.Dto;
using Tnb.BasicData.Entities.Dto.BasCalendar;
using Tnb.BasicData.Entities.Enums;
using Tnb.BasicData.Interfaces;

namespace Tnb.BasicData
{
    /// <summary>
    /// 工作日管理
    /// </summary>
    [ApiDescriptionSettings(Tag = ModuleConst.Tag, Area = ModuleConst.Area, Order = 1102)]
    [Route("api/[area]/[controller]/[action]")]
    public class BasCalendarService : IBasCalendarService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarRepository<BasCalendar> _repository;
        private readonly IUserManager _userManager;

        public BasCalendarService(ISqlSugarRepository<BasCalendar> repository, IUserManager userManager)
        {
            _repository = repository;
            _userManager = userManager;
        }

        /// <summary>
        /// 保存工作日历
        /// </summary>
        /// <param name="CalendarInput"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task SaveData(CalendarInput CalendarInput)
        {
            ISqlSugarClient db = _repository.AsSugarClient();
            _ = await db.Deleteable<BasCalendar>(p => p.datetext == CalendarInput.datetext).ExecuteCommandAsync();
            BasCalendar BasCalendar = new()
            {
                datetext = CalendarInput.datetext,
                datetype = CalendarInput.datetype,
                workhour = CalendarInput.workhour,
                worktype = CalendarInput.worktype,
                create_id = _userManager.UserId,
                create_time = DateTime.Now
            };
            _ = await db.Insertable(BasCalendar).ExecuteCommandAsync();
        }

        /// <summary>
        /// 获取工作日历
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<dynamic> GetWorkData(CalendarInput CalendarInput)
        {
            List<CalendarOut> CalendarOuts = new();
            if (CalendarInput.calendartype == (int)EnumCalendarType.分类)
            {
                ISqlSugarClient db = _repository.AsSugarClient();
                List<BasCalendar> lists = await db.Queryable<BasCalendar>().Where(p => p.worktype == CalendarInput.content).ToListAsync();

                foreach (BasCalendar list in lists)
                {
                    CalendarOut CalendarOut = new()
                    {
                        datetext = list.datetext,
                        datetype = list.datetype,
                        workhour = JSON.Deserialize<List<WorkHour>>(list.workhour),
                        worktype = list.worktype
                    };
                    CalendarOuts.Add(CalendarOut);
                }
            }
            else if (CalendarInput.calendartype == (int)EnumCalendarType.班组)
            {
                ISqlSugarClient db = _repository.AsSugarClient();
                List<string> Shifts = await db.Queryable<BasShiftWorkgroup>().Where(p => p.workgroup_id == CalendarInput.content).Select(p => p.shift_id).ToListAsync();
                if (Shifts != null && Shifts.Count > 0)
                {
                    List<Shift> BasTimePeriods = await db.Queryable<BasTimePeriod, BasShift>((a, b) => new object[] { JoinType.Inner, a.shifttype_id == b.id })
                        .Where((a, b) => Shifts.Contains(a.shifttype_id!))
                        .Select((a, b) =>
                            new Shift
                            {
                                startday = b.shiftb_time,
                                endday = b.shifte_time,
                                workhour = new WorkHour { start = a.tpb_time, end = a.tpe_time },
                            }
                        ).ToListAsync();

                    List<Shift> BasTimePeriodRests = await db.Queryable<BasTimePeriodRest, BasShift>((a, b) => new object[] { JoinType.Inner, a.shift_type_id == b.id })
                        .Where((a, b) => Shifts.Contains(a.shift_type_id!))
                        .Select((a, b) =>
                        new Shift
                        {
                            startday = b.shiftb_time,
                            endday = b.shifte_time,
                            workhour = new WorkHour { start = a.tp_b_time, end = a.tp_e_time },
                        }).ToListAsync();
                    foreach (Shift? BasTimePeriod in BasTimePeriods)
                    {
                        DateTime start = DateTime.Parse(BasTimePeriod.startday!);
                        DateTime end = DateTime.Parse(BasTimePeriod.endday!);
                        for (DateTime date = start; date <= end; date = date.AddDays(1))
                        {
                            if (CalendarOuts.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).Any())
                            {
                                CalendarOuts.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).First().workhour!.Add(BasTimePeriod.workhour!);
                            }
                            else
                            {
                                CalendarOut CalendarOut = new()
                                {
                                    datetext = date.ToString("yyyy-MM-dd"),
                                    datetype = "workDay",
                                    workhour = new List<WorkHour> { BasTimePeriod.workhour! }
                                };
                                CalendarOuts.Add(CalendarOut);
                            }
                        }
                    }
                    foreach (Shift? BasTimePeriodRest in BasTimePeriodRests)
                    {
                        DateTime start = DateTime.Parse(BasTimePeriodRest.startday!);
                        DateTime end = DateTime.Parse(BasTimePeriodRest.endday!);
                        for (DateTime date = start; date <= end; date = date.AddDays(1))
                        {
                            if (CalendarOuts.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).Any())
                            {
                                CalendarOuts.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).First().workhour!.Add(BasTimePeriodRest.workhour!);
                            }
                            else
                            {
                                CalendarOut CalendarOut = new()
                                {
                                    datetext = date.ToString("yyyy-MM-dd"),
                                    datetype = "dayOff",
                                    workhour = new List<WorkHour> { BasTimePeriodRest.workhour! }
                                };
                                CalendarOuts.Add(CalendarOut);
                            }
                        }
                    }
                }
            }
            else if (CalendarInput.calendartype == (int)EnumCalendarType.个人)
            {
                ISqlSugarClient db = _repository.AsSugarClient();
                List<string> groups = await db.Queryable<BasWorkgroupEmployee>().Where(p => p.employee_id == CalendarInput.content).Select(p => p.group_id).ToListAsync();
                List<string> Shifts = await db.Queryable<BasShiftWorkgroup>().Where(p => groups.Contains(p.workgroup_id)).Select(p => p.shift_id).ToListAsync();
                if (Shifts != null && Shifts.Count > 0)
                {
                    List<Shift> BasTimePeriods = await db.Queryable<BasTimePeriod, BasShift>((a, b) => new object[] { JoinType.Inner, a.shifttype_id == b.id })
                        .Where((a, b) => Shifts.Contains(a.shifttype_id!))
                        .Select((a, b) =>
                            new Shift
                            {
                                startday = b.shiftb_time,
                                endday = b.shifte_time,
                                workhour = new WorkHour { start = a.tpb_time, end = a.tpe_time },
                            }
                        ).ToListAsync();

                    List<Shift> BasTimePeriodRests = await db.Queryable<BasTimePeriodRest, BasShift>((a, b) => new object[] { JoinType.Inner, a.shift_type_id == b.id })
                        .Where((a, b) => Shifts.Contains(a.shift_type_id!))
                        .Select((a, b) =>
                        new Shift
                        {
                            startday = b.shiftb_time,
                            endday = b.shifte_time,
                            workhour = new WorkHour { start = a.tp_b_time, end = a.tp_e_time },
                        }).ToListAsync();
                    foreach (Shift? BasTimePeriod in BasTimePeriods)
                    {
                        DateTime start = DateTime.Parse(BasTimePeriod.startday!);
                        DateTime end = DateTime.Parse(BasTimePeriod.endday!);
                        for (DateTime date = start; date <= end; date = date.AddDays(1))
                        {
                            if (CalendarOuts.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).Any())
                            {
                                CalendarOuts.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).First().workhour!.Add(BasTimePeriod.workhour!);
                            }
                            else
                            {
                                CalendarOut CalendarOut = new()
                                {
                                    datetext = date.ToString("yyyy-MM-dd"),
                                    datetype = "workDay",
                                    workhour = new List<WorkHour> { BasTimePeriod.workhour! }
                                };
                                CalendarOuts.Add(CalendarOut);
                            }
                        }
                    }
                    foreach (Shift? BasTimePeriodRest in BasTimePeriodRests)
                    {
                        DateTime start = DateTime.Parse(BasTimePeriodRest.startday!);
                        DateTime end = DateTime.Parse(BasTimePeriodRest.endday!);
                        for (DateTime date = start; date <= end; date = date.AddDays(1))
                        {
                            if (CalendarOuts.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).Any())
                            {
                                CalendarOuts.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).First().workhour!.Add(BasTimePeriodRest.workhour!);
                            }
                            else
                            {
                                CalendarOut CalendarOut = new()
                                {
                                    datetext = date.ToString("yyyy-MM-dd"),
                                    datetype = "dayOff",
                                    workhour = new List<WorkHour> { BasTimePeriodRest.workhour! }
                                };
                                CalendarOuts.Add(CalendarOut);
                            }
                        }
                    }
                }
            }
            return CalendarOuts;
        }

        /// <summary>
        /// 批量保存工作日历
        /// </summary>
        /// <param name="CalendarBatchInput"></param>
        /// <returns></returns>
        public async Task SaveBatchData(CalendarBatchInput CalendarBatchInput)
        {
            ISqlSugarClient db = _repository.AsSugarClient();
            DateTime start = DateTime.Parse(CalendarBatchInput.startenday![0]);
            DateTime end = DateTime.Parse(CalendarBatchInput.startenday![1]);
            List<BasCalendar> BasCalendars = new();
            List<BasCalendar> lists = await db.Queryable<BasCalendar>().Where(p => start <= DateTime.Parse(p.datetext!) && end >= DateTime.Parse(p.datetext!) && p.worktype == CalendarBatchInput.worktype).ToListAsync();
            List<BasCalendar> updatelist = new();
            for (DateTime date = start; date <= end; date = date.AddDays(1))
            {
                if (CalendarBatchInput.weekday!.Contains((int)date.DayOfWeek))
                {
                    if (lists.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).Any())
                    {
                        BasCalendar BasCalendar = lists.Where(p => p.datetext == date.ToString("yyyy-MM-dd")).First();
                        BasCalendar.datetype = CalendarBatchInput.datetype;
                        updatelist.Add(BasCalendar);
                    }
                    else
                    {
                        BasCalendar BasCalendar = new()
                        {
                            datetext = date.ToString("yyyy-MM-dd"),
                            datetype = CalendarBatchInput.datetype,
                            workhour = CalendarBatchInput.workhour,
                            worktype = CalendarBatchInput.worktype,
                            create_id = _userManager.UserId,
                            create_time = DateTime.Now
                        };
                        BasCalendars.Add(BasCalendar);
                    }
                }
            }
            _ = await db.Updateable(updatelist).ExecuteCommandAsync();
            _ = await db.Insertable(BasCalendars).ExecuteCommandAsync();
        }
    }
}