Tiobon.Web.Core/Tiobon.Core.Services/Ghre/Ghre_OpenClassServices.cs

using MathNet.Numerics.Distributions;
using Microsoft.EntityFrameworkCore.Metadata.Internal;

namespace Tiobon.Core.Services;

/// <summary>
/// 开班管理 (服务)
/// </summary>
public class Ghre_OpenClassServices : BaseServices<Ghre_OpenClass, Ghre_OpenClassDto, InsertGhre_OpenClassInput, EditGhre_OpenClassInput>, IGhre_OpenClassServices
{
    private readonly IGhre_OpenClassStaffServices _ghre_OpenClassStaffServices;
    private readonly IGhre_OpenClassFeeServices _ghre_OpenClassFeeServices;
    private readonly IGhre_OpenClassScheduleServices _ghre_OpenClassScheduleServices;
    private readonly IBaseRepository<Ghre_OpenClass> _dal;
    public Ghre_OpenClassServices(ICaching caching,
        IBaseRepository<Ghre_OpenClass> dal,
        IGhre_OpenClassStaffServices ghre_OpenClassStaffServices,
        IGhre_OpenClassFeeServices ghre_OpenClassFeeServices,
        IGhre_OpenClassScheduleServices ghre_OpenClassScheduleServices)
    {
        this._dal = dal;
        base.BaseDal = dal;
        base._caching = caching;
        _ghre_OpenClassStaffServices = ghre_OpenClassStaffServices;
        _ghre_OpenClassFeeServices = ghre_OpenClassFeeServices;
        _ghre_OpenClassScheduleServices = ghre_OpenClassScheduleServices;
    }

    public override async Task<ServicePageResult<Ghre_OpenClassDto>> QueryFilterPage(QueryBody filter, string condition, bool? IsEnable = true)
    {

        if (filter.jsonParam != null)
            foreach (JProperty jProperty in filter.jsonParam.Properties())
            {
                var name = jProperty.Name;
                var value = jProperty.Value.ToString();
                if (name == "StartEndTime")
                {
                    var jsonParam = JsonHelper.JsonToObj<JsonParam>(value);

                    if (jsonParam.columnValue != null)
                    {
                        var ids1 = JsonHelper.JsonToObj<List<string>>(jsonParam.columnValue.ToString());

                        condition += $" AND ((StartTime>='{ids1[0]} 00:00:00' AND StartTime<='{ids1[1]} 23:59:59')";
                        condition += $" OR (EndTime>='{ids1[0]} 00:00:00' AND EndTime<='{ids1[1]} 23:59:59'))";
                    }
                }

            }

        var result = await base.QueryFilterPage(filter, condition, IsEnable);

        for (int i = 0; i < result.result.DT_TableDataT1.Count; i++)
        {
            var DT_TableDataT1 = result.result.DT_TableDataT1[i];

            DT_TableDataT1.OpenClassType = await GetParaLabel("TrainingOpenClassType", result.result.DT_TableDataT1[i].OpenClassType);
            DT_TableDataT1.OpenClassWay = await GetParaLabel("TrainingOpenClassWay", result.result.DT_TableDataT1[i].OpenClassWay);
            DT_TableDataT1.ScoringMethod = await GetParaLabel("ScoreMethod", result.result.DT_TableDataT1[i].ScoringMethod);

            if (DT_TableDataT1.LinkType == "Course")
                DT_TableDataT1.CourseOrSceneName = (await Db.Queryable<Ghre_Course>().FirstAsync(x => x.Id == DT_TableDataT1.LinkId))?.CourseName;
            else
                DT_TableDataT1.CourseOrSceneName = (await Db.Queryable<Ghre_CourseScene>().FirstAsync(x => x.Id == DT_TableDataT1.LinkId))?.SceneName;

            if (DT_TableDataT1.StartTime != null && DT_TableDataT1.EndTime != null)
                DT_TableDataT1.StartEndTime1 = $"{DateTimeHelper.ConvertToMiniuteString(DT_TableDataT1.StartTime)}~{DateTimeHelper.ConvertToMiniuteString(DT_TableDataT1.EndTime)}";

            if (DT_TableDataT1.RegisterStartTime != null && DT_TableDataT1.RegisterEndTime != null)
                DT_TableDataT1.RegisterStartEndTime1 = $"{DateTimeHelper.ConvertToMiniuteString(DT_TableDataT1.RegisterStartTime)}~{DateTimeHelper.ConvertToMiniuteString(DT_TableDataT1.RegisterEndTime)}";

            if (DT_TableDataT1.ExamStartTime != null && DT_TableDataT1.ExamEndTime != null)
                DT_TableDataT1.ExamStartEndTime1 = $"{DateTimeHelper.ConvertToMiniuteString(DT_TableDataT1.ExamStartTime)}~{DateTimeHelper.ConvertToMiniuteString(DT_TableDataT1.ExamEndTime)}";

            if (DT_TableDataT1.ExamPaperId != null)
                DT_TableDataT1.ExamPaperName = (await Db.Queryable<Ghre_ExamPaper>().FirstAsync(x => x.Id == DT_TableDataT1.ExamPaperId))?.PaperName;


            if (DT_TableDataT1.ManagerId != null)
                DT_TableDataT1.ManagerName = (await Db.Queryable<Ghra_Staff>().FirstAsync(x => x.StaffID == DT_TableDataT1.ManagerId))?.StaffName;

            if (DT_TableDataT1.TeacherId != null)
                DT_TableDataT1.TeacherName = (await Db.Queryable<Ghre_Teacher>().FirstAsync(x => x.Id == DT_TableDataT1.TeacherId))?.TeacherName;

            result.result.DT_TableDataT1[i] = DT_TableDataT1;
        }
        return result;
    }

    public override async Task<long> Add(InsertGhre_OpenClassInput entity)
    {
        entity.LinkId = entity.LinkType == "Course" ? entity.CourseId : entity.CourseSceneId;
        entity.Status = "Temporary";

        var prefixTemp = string.Empty;
        if (entity.LinkType == "Course")
            prefixTemp = (await Db.Queryable<Ghre_Course>().FirstAsync(x => x.Id == entity.CourseId))?.CourseNo;
        else
            prefixTemp = (await Db.Queryable<Ghre_CourseScene>().FirstAsync(x => x.Id == entity.CourseSceneId))?.SceneNo;

        if (entity.StartEndTime.Count == 2)
        {
            entity.StartTime = entity.StartEndTime[0];
            entity.EndTime = entity.StartEndTime[1];
        }
        if (entity.RegisterStartEndTime.Count == 2)
        {
            entity.RegisterStartTime = entity.RegisterStartEndTime[0];
            entity.RegisterEndTime = entity.RegisterStartEndTime[1];
        }
        if (entity.ExamStartEndTime.Count == 2)
        {
            entity.ExamStartTime = entity.ExamStartEndTime[0];
            entity.ExamEndTime = entity.ExamStartEndTime[1];
        }


        prefixTemp = prefixTemp + "K";
        entity.OpenClassNo = await GenerateContinuousSequence("Ghre_OpenClass", "OpenClassNo", prefixTemp, prefixTemp.Length + 4, 4);
        var result = await base.Add(entity);

        if (entity.Schedules != null && entity.Schedules.Any())
        {
            entity.Schedules.ForEach(x =>
            {
                x.OpenClassId = result;
                if (x.StartEndTime.Count == 2)
                {
                    x.StartTime = x.StartEndTime[0];
                    x.EndTime = x.StartEndTime[1];
                }
            });
            await _ghre_OpenClassScheduleServices.Add(entity.Schedules);
        }

        if (entity.Attachments != null && entity.Attachments.Any())
        {
            var paths = entity.Attachments.Select(x => x.RelativePath).ToList();
            await Db.Updateable<Ghre_Attachment>()
                .SetColumns(it => new Ghre_Attachment() { TableName = result.ObjToString(), AttachmentGroupID = 1 })
                .Where(it => paths.Contains(it.RelativePath))
                .ExecuteCommandAsync();
        }
        return result;
    }

    public override async Task<bool> Update(long Id, EditGhre_OpenClassInput entity)
    {

        entity.LinkId = entity.LinkType == "Course" ? entity.CourseId : entity.CourseSceneId;

        if (entity.StartEndTime.Count == 2)
        {
            entity.StartTime = entity.StartEndTime[0];
            entity.EndTime = entity.StartEndTime[2];
        }
        if (entity.RegisterStartEndTime.Count == 2)
        {
            entity.RegisterStartTime = entity.RegisterStartEndTime[0];
            entity.RegisterEndTime = entity.RegisterStartEndTime[2];
        }
        if (entity.ExamStartEndTime.Count == 2)
        {
            entity.ExamStartTime = entity.ExamStartEndTime[0];
            entity.ExamEndTime = entity.ExamStartEndTime[2];
        }
        await _ghre_OpenClassScheduleServices.Delete(x => x.OpenClassId == Id);
        if (entity.Schedules != null && entity.Schedules.Any())
        {
            entity.Schedules.ForEach(x => x.OpenClassId = Id);

            await _ghre_OpenClassScheduleServices.Add(entity.Schedules);
        }
        await Db.Updateable<Ghre_Attachment>()
                .SetColumns(it => new Ghre_Attachment() { TableName = null, AttachmentGroupID = null })
                .Where(it => it.TableName == Id.ObjToString() && it.AttachmentGroupID == 1)
                .ExecuteCommandAsync();

        if (entity.Attachments != null && entity.Attachments.Any())
        {
            var paths = entity.Attachments.Select(x => x.RelativePath).ToList();
            await Db.Updateable<Ghre_Attachment>()
                .SetColumns(it => new Ghre_Attachment() { TableName = Id.ObjToString(), AttachmentGroupID = 1 })
                .Where(it => paths.Contains(it.RelativePath))
                .ExecuteCommandAsync();
        }
        var result = await base.Update(Id, entity, null, ["Status"]);

        return result;
    }


    public override async Task<ServiceFormResult<Ghre_OpenClassDto>> QueryForm(QueryForm body)
    {
        var result = await base.QueryForm(body);
        if (result.result.DT_TableDataT1.Any())
        {
            if (result.result.DT_TableDataT1[0].LinkType == "Course")
                result.result.DT_TableDataT1[0].CourseId = result.result.DT_TableDataT1[0].LinkId;
            else
                result.result.DT_TableDataT1[0].CourseSceneId = result.result.DT_TableDataT1[0].LinkId;

            result.result.DT_TableDataT1[0].StartEndTime.Add(result.result.DT_TableDataT1[0].StartTime);
            result.result.DT_TableDataT1[0].StartEndTime.Add(result.result.DT_TableDataT1[0].EndTime);

            result.result.DT_TableDataT1[0].RegisterStartEndTime.Add(result.result.DT_TableDataT1[0].RegisterStartTime);
            result.result.DT_TableDataT1[0].RegisterStartEndTime.Add(result.result.DT_TableDataT1[0].RegisterEndTime);

            result.result.DT_TableDataT1[0].ExamStartEndTime.Add(result.result.DT_TableDataT1[0].ExamStartTime);
            result.result.DT_TableDataT1[0].ExamStartEndTime.Add(result.result.DT_TableDataT1[0].ExamEndTime);
            result.result.DT_TableDataT1[0].Schedules = await _ghre_OpenClassScheduleServices.QueryDto(x => x.OpenClassId == body.id);
            result.result.DT_TableDataT1[0].Attachments = await Db.Queryable<Ghre_Attachment>().Where(x => x.TableName == body.id.ObjToString() && x.AttachmentGroupID == 1).ToListAsync();
        }
        return result;
    }

    #region 学员
    public async Task<ServiceResult<List<Ghre_OpenClassStaffDto>>> QueryStaff(long Id)
    {
        var result = await _ghre_OpenClassStaffServices.QueryFilterPage(new QueryBody(), $"OpenClassId='{Id}'");
        return ServiceResult<List<Ghre_OpenClassStaffDto>>.OprateSuccess("查询成功！", result.result.DT_TableDataT1);
    }

    public async Task<ServiceResult> InsertStaff(long Id, List<int> staffIds)
    {
        var staffIds1 = await Db.Queryable<Ghre_OpenClassStaff>().Select(s => s.StaffId).ToListAsync();
        var inserts = staffIds.Where(x => !staffIds1.Contains(x))
            .Select(x => new InsertGhre_OpenClassStaffInput()
            {
                StaffId = x,
                OpenClassId = Id
            }).Distinct().ToList();
        await _ghre_OpenClassStaffServices.Add(inserts);
        return ServiceResult.OprateSuccess();
    }

    public async Task<ServiceResult> DeleteStaff(long Id, List<int> staffIds)
    {
        await Db.Updateable<Ghre_OpenClassStaff>()
                   .SetColumns(it => new Ghre_OpenClassStaff() { IsEnable = 0 })
                   .Where(it => it.StaffId != null && it.OpenClassId == Id && staffIds.Contains(it.StaffId.Value))
                   .ExecuteCommandAsync();
        return ServiceResult.OprateSuccess();
    }
    #endregion

    #region 费用
    public async Task<ServiceResult<List<Ghre_OpenClassFeeDto>>> QueryGroupFee(long Id)
    {
        var result = await _ghre_OpenClassFeeServices.QueryFilterPage(new QueryBody(), $"OpenClassId='{Id}' AND StaffId IS NULL");
        return ServiceResult<List<Ghre_OpenClassFeeDto>>.OprateSuccess("查询成功！", result.result.DT_TableDataT1);
    }
    public async Task<ServiceResult<List<Ghre_OpenClassFeeDto>>> QueryPersonalFee(long Id)
    {
        var result = await _ghre_OpenClassFeeServices.QueryFilterPage(new QueryBody(), $"OpenClassId='{Id}' AND StaffId IS NOT NULL");
        return ServiceResult<List<Ghre_OpenClassFeeDto>>.OprateSuccess("查询成功！", result.result.DT_TableDataT1);
    }


    public async Task<ServiceResult> InsertFee(long Id, InsertGhre_OpenClassFeeInput fee)
    {
        fee.OpenClassId = Id;
        await _ghre_OpenClassFeeServices.Add(fee);
        return ServiceResult.OprateSuccess();
    }

    public async Task<ServiceResult> DeleteFee(List<long> feeIds)
    {
        await Db.Updateable<Ghre_OpenClassFee>()
                   .SetColumns(it => new Ghre_OpenClassFee() { IsEnable = 0 })
                   .Where(it => feeIds.Contains(it.Id))
                   .ExecuteCommandAsync();
        return ServiceResult.OprateSuccess();
    }
    #endregion

    #region 总结

    public async Task<ServiceResult<Ghre_OpenClassDto>> QuerySummary(long Id)
    {
        var result = await base.QueryById(Id);

        var result1 = new Ghre_OpenClassDto();
        result1.Summary = result.Summary;
        result1.Attachments = await Db.Queryable<Ghre_Attachment>().Where(x => x.TableName == Id.ObjToString() && x.AttachmentGroupID == 2).ToListAsync();
        return ServiceResult<Ghre_OpenClassDto>.OprateSuccess("查询成功！", result1);
    }
    public async Task<ServiceResult> InsertSummary(long Id, InsertGhre_OpenClassInput entity)
    {

        await Db.Updateable<Ghre_OpenClass>()
               .SetColumns(it => new Ghre_OpenClass() { Summary = entity.Summary })
               .Where(it => it.Id == Id)
               .ExecuteCommandAsync();
        await Db.Updateable<Ghre_Attachment>()
                .SetColumns(it => new Ghre_Attachment() { TableName = null, AttachmentGroupID = null })
                .Where(it => it.TableName == Id.ObjToString() && it.AttachmentGroupID == 2)
                .ExecuteCommandAsync();

        if (entity.Attachments != null && entity.Attachments.Any())
        {
            var paths = entity.Attachments.Select(x => x.RelativePath).ToList();
            await Db.Updateable<Ghre_Attachment>()
                .SetColumns(it => new Ghre_Attachment() { TableName = Id.ObjToString(), AttachmentGroupID = 2 })
                .Where(it => paths.Contains(it.RelativePath))
                .ExecuteCommandAsync();
        }
        return ServiceResult.OprateSuccess();
    }
    #endregion

    #region 修改状态
    public async Task<ServiceResult> UpdateStatus(List<long> ids, string status)
    {
        await Db.Updateable<Ghre_OpenClass>()
                   .SetColumns(it => new Ghre_OpenClass() { Status = status })
                   .Where(it => ids.Contains(it.Id))
                   .ExecuteCommandAsync();
        return ServiceResult.OprateSuccess();
    }
    #endregion
}