tnb.server/PerMgr/Tnb.PerMgr/PerProcessParamTypeService.cs

using JNPF.Common.Core.Manager;
using JNPF.Common.Enums;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Tnb.EquipMgr.Entities;
using Tnb.PerMgr.Entities;
using Tnb.PerMgr.Entities.Dto;
using Tnb.PerMgr.Interfaces;

namespace Tnb.PerMgr
{
    /// <summary>
    /// 工艺参数类型
    /// </summary>
    [ApiDescriptionSettings
        (Tag = ModuleConsts.Tag, Area = ModuleConsts.Area, Order = 700)]
    [Route("api/[area]/[controller]/[action]")]
    public class PerProcessParamTypeService : IPerProcessParamTypeService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarRepository<PerProcessParamType> _repository;
        private readonly IUserManager _userManager;
        
        public PerProcessParamTypeService(ISqlSugarRepository<PerProcessParamType> repository, IUserManager userManager)
        {
            _userManager = userManager;
            _repository = repository;
        }

        [HttpPost]
        public async Task<dynamic> GetProcessParamType(Dictionary<string, string> dic)
        {
            string equipId = dic["equip_id"];
            var db = _repository.AsSugarClient();
            var equipment = await db.Queryable<EqpEquipment>().Where(x => x.id == equipId).SingleAsync();
            string equipTypeId = equipment?.equip_type_id;

            //List<PerProcessParamType> perProcessParamTypes = await _repository.GetListAsync(x => x.equip_type_id == equipTypeId);
            var result = await db.Queryable<PerProcessParamType>()
                .Where(x => x.equip_type_id == equipTypeId)
                .OrderBy(x=>x.ordinal)
                .Select(x => new
                {
                    tab_id = x.id,
                    tab_name = x.name,
                    daq_list = SqlFunc.Subqueryable<EqpDaq>().Where(a=>a.equip_id==equipId).ToList<ProcessParamTypeDaqListOutput>(a=>new ProcessParamTypeDaqListOutput
                    {
                        id = a.id,
                        label_name = a.label_name,
                    }),
                    children = SqlFunc.Subqueryable<PerProcessParam>()
                        .LeftJoin<PerToleranceCategory>((y,z)=>y.tolerance_category_id==z.id)
                        .Where(y=>y.process_param_type_id==x.id)
                        .OrderBy((y,z)=>y.ordinal)
                        .ToList<ProcessParamTypeChildrenOutput>((y,z)=>new ProcessParamTypeChildrenOutput
                            {
                                process_param_id = y.id,
                                name = y.name,
                                upper_value = z.upper_value,
                                lower_value = z.lower_value
                            }),
                }).ToListAsync();


            return result;

        }

        [HttpPost]
        public async Task<string> SaveData(List<ProcessChildDataInput> input)
        {
            var db = _repository.AsSugarClient();
            DbResult<bool> result = await db.Ado.UseTranAsync(async () =>
            {

                List<PerProcessStandardsD> list = new List<PerProcessStandardsD>();
                List<string> insertIds = new List<string>();
                if (input != null && input.Count > 0)
                {
                    foreach (var item in input)
                    {
                        PerProcessStandardsD processStandardsD = await db.Queryable<PerProcessStandardsD>().Where(x =>
                            x.process_param_id == item.process_param_id && x.process_standards_id == item.process_standards_id &&
                            item.process_param_type_id == x.process_param_type_id).FirstAsync();

                        if (processStandardsD != null)
                        {
                            PerProcessStandardsH perProcessStandardsH = await db.Queryable<PerProcessStandardsH>().SingleAsync(x => x.id == processStandardsD.process_standards_id);
                            PerProcessParam processParam = await db.Queryable<PerProcessParam>().SingleAsync(x => x.id == processStandardsD.process_param_id);

                            if (processStandardsD.value != item.value)
                            {
                                PerProcessParamEditRecord record = new PerProcessParamEditRecord
                                {
                                    process_param_id = item.process_param_id,
                                    old_value = processStandardsD.value,
                                    new_value = item.value,
                                    modify_id = _userManager.UserId,
                                    modify_time = DateTime.Now,
                                    org_id = _userManager.GetUserInfo().Result.organizeId,
                                    equip_id = perProcessStandardsH.equip_id,
                                    process_param_name = processParam.name
                                };
                                db.Insertable<PerProcessParamEditRecord>(record).ExecuteCommandAsync();
                            }
                            
                        }
                        
                        if (string.IsNullOrEmpty(item.id))
                        {
                            PerProcessStandardsD insertObj = new PerProcessStandardsD()
                            {
                                value = item.value,
                                process_param_id = item.process_param_id,
                                process_standards_id = item.process_standards_id,
                                process_param_type_id = item.process_param_type_id,
                                daq_id = item.daq_id,
                            };
                                
                            insertIds.Add(insertObj.id);
                            await db.Insertable<PerProcessStandardsD>(insertObj).ExecuteCommandAsync();
                        }
                        else
                        {
                            await db.Updateable<PerProcessStandardsD>()
                                .SetColumns(x=>x.value==item.value)
                                .SetColumns(x=>x.daq_id==item.daq_id)
                                .Where(x=>x.id==item.id).ExecuteCommandAsync();
                        }
                        
                    }

                    List<string> notDeleteIds = input.Select(x => x.id).ToList();
                    notDeleteIds.AddRange(insertIds);
                    await db.Deleteable<PerProcessStandardsD>().Where(x => !notDeleteIds.Contains(x.id)).ExecuteCommandAsync();


                }
                
            });
            if(!result.IsSuccess) throw Oops.Oh(ErrorCode.COM1008);

            return result.IsSuccess ? "保存成功" : result.ErrorMessage;
        }

        [HttpPost]
        public async Task<dynamic> GetProcessStandardsChildrenInfo(Dictionary<string, string> dic)
        {
            string id = dic["id"];
            var db = _repository.AsSugarClient();
            var perProcessStandardsH = await db.Queryable<PerProcessStandardsH>().SingleAsync(x => x.id == id);
            var equipment = await db.Queryable<EqpEquipment>().Where(x => x.id == perProcessStandardsH.equip_id).SingleAsync();
            string equipTypeId = equipment?.equip_type_id;

            var result = await db.Queryable<PerProcessParamType>()
                .Where(a => a.equip_type_id == equipTypeId)
                .OrderBy(a=>a.ordinal)
                .Select(a => new
                {
                    tab_id = a.id,
                    tab_name = a.name,
                    daq_list = SqlFunc.Subqueryable<EqpDaq>().Where(e=>e.equip_id==perProcessStandardsH.equip_id).ToList<ProcessParamTypeDaqListOutput>(e=>new ProcessParamTypeDaqListOutput
                    {
                        id = e.id,
                        label_name = e.label_name,
                    }),
                    children = SqlFunc.Subqueryable<PerProcessStandardsD>()
                        .LeftJoin<PerProcessParam>((b,c)=>b.process_param_id==c.id)
                        .LeftJoin<PerToleranceCategory>((b,c,d)=>c.tolerance_category_id==d.id)
                        .Where((b,c,d)=>c.process_param_type_id==a.id && b.process_standards_id==id)
                        .OrderBy((b,c,d)=>c.ordinal)
                        .ToList<ProcessParamTypeChildrenOutput>((b,c,d)=>new ProcessParamTypeChildrenOutput
                            {
                                id = b.id,
                                process_param_id = c.id,
                                name = c.name,
                                value = b.value,
                                upper_value = d.upper_value,
                                lower_value = d.lower_value,
                                daq_id = b.daq_id
                            }),
                }).ToListAsync();


            return result;
        }
    }
}