zhuangpei-mesbackend/MDM/Services/Process/ProcessOperationWorkstationMappingService.cs

using DOAN.Model.MES.recipe;
using DOAN.Model.MES.recipe.Dto;
using Infrastructure.Attribute;
using MathNet.Numerics;
using MDM.Model;
using MDM.Model.Plant;
using MDM.Model.Process;
using MDM.Model.Process.Dto;
using MDM.Models.Process;
using MDM.Repository;
using MDM.Service;
using MDM.Services.IProcessService;
namespace MDM.Services.Process
{
    /// <summary>
    /// Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IProcessOperationWorkstationMappingService), ServiceLifetime = LifeTime.Transient)]
    public class ProcessOperationWorkstationMappingService : BaseService<ProcessOperationWorkstationMapping>, IProcessOperationWorkstationMappingService
    {
        /// <summary>
        /// 查询列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<ProcessOperationWorkstationMappingDto> GetList(ProcessOperationWorkstationMappingQueryDto parm)
        {
            var predicate = Expressionable.Create<ProcessOperationWorkstationMapping>()
                .AndIF(!string.IsNullOrEmpty(parm.FkRoutingCode), m => m.FkRoutingCode.Contains(parm.FkRoutingCode))
                .AndIF(!string.IsNullOrEmpty(parm.FkOperationCode), m => m.FkOperationCode.Contains(parm.FkOperationCode))
                .AndIF(!string.IsNullOrEmpty(parm.FkWorkstationCode), m => m.FkWorkstationCode.Contains(parm.FkWorkstationCode))
                .AndIF(!string.IsNullOrEmpty(parm.FkProductlinebodyCode), m => m.FkProductlinebodyCode.Contains(parm.FkProductlinebodyCode))


                ;

            var response = Queryable()
                .Where(predicate.ToExpression())
                .ToPage<ProcessOperationWorkstationMapping, ProcessOperationWorkstationMappingDto>(parm);

            return response;
        }


        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public ProcessOperationWorkstationMappingInfoDto GetInfo(int Id)
        {
            var response = Queryable()
             .Where(x => x.Id == Id)
             .Select(it => new ProcessOperationWorkstationMappingInfoDto()
             {
                 Id = it.Id,
                 FkRoutingCode = it.FkRoutingCode,
                 FkProductlinebodyCode = it.FkProductlinebodyCode,
                 FkOperationCode = it.FkOperationCode,
                 FkWorkstationCode = it.FkWorkstationCode,
                 IsActive = it.IsActive,
                 Priority = it.Priority,
                 StandardTime = it.StandardTime,
                 SetupTime = it.SetupTime,
                 CreatedTime = it.CreatedTime,
                 CreatedBy = it.CreatedBy,
                 Remark = it.Remark,
                 UpdatedTime = it.UpdatedTime,
                 UpdatedBy = it.UpdatedBy,


                 //绑定的工位PLC地址
                 PlcAddress = SqlFunc.Subqueryable<PlantWorkstation>().Where(s => s.FkProductlinebody == it.FkProductlinebodyCode && s.WorkstationCode == it.FkWorkstationCode).Select(s=>s.PlcAddress),

                 //绑定的流程信息
                 OperationFlows = SqlFunc.Subqueryable<ProcessOperationFlow>().Where(s => s.FkRoutingCode == it.FkRoutingCode && s.FkOperationCode == it.FkOperationCode).ToList(),

                 ////绑定的配方参数信息
                 //OperationRecipeParameters = SqlFunc.Subqueryable<PfRefProductRecipe>()
                 //.LeftJoin<PfRecipeVersion>((refpr, ver) => refpr.RecipeCode == ver.RecipeCode)
                 //.LeftJoin<PfRecipeParameters>((refpr, ver, param) => ver.RecipeCode == param.RecipeCode && ver.Version == param.Version)
                 //.Where((refpr, ver, param) => refpr.FkRoutingCode == it.FkRoutingCode && refpr.FkOperationCode == it.FkOperationCode)
                 //.ToList((refpr, ver, param) => new PfRecipeParametersDto
                 //{
                 //    Id = param.Id,
                 //    RecipeCode = param.RecipeCode,
                 //    Version = param.Version,
                 //    ParamName = param.ParamName,
                 //    Unit = param.Unit,
                 //    UpperLimit = param.UpperLimit,
                 //    LowerLimit = param.LowerLimit,
                 //    StandardValue = param.StandardValue,
                 //    Remark = param.Remark
                 //}),
                 ////绑定的工序工位采集参数
                 ProcessOperationWorkstationCollectParameters = SqlFunc.Subqueryable<ProcessOperationWorkstationFlowCollectParameter>().Where(s => s.FkRoutingCode == it.FkRoutingCode && s.FkOperationCode == it.FkOperationCode && s.FkProductlinebodyCode == it.FkProductlinebodyCode && s.FkWorkstationCode == it.FkWorkstationCode).ToList(),

                 // 绑定的物料参数
                 ProcessOperationFlowMaterialParamters = SqlFunc.Subqueryable<ProcessOperationFlowMaterialParamter>().Where(s => s.FkRoutingCode == it.FkRoutingCode && s.FkOperationCode == it.FkOperationCode).ToList(),


             })
               .First();

            return response;
        }

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ProcessOperationWorkstationMapping AddProcessOperationWorkstationMapping(ProcessOperationWorkstationMapping model)
        {
            return Context.Insertable(model).ExecuteReturnEntity();
        }


        public List<ProcessRouting> SelectRouting(string routing)
        {
            var response = Context.Queryable<ProcessRouting>().WhereIF(!string.IsNullOrEmpty(routing), it => it.RoutingCode.Contains(routing)).ToList();
            return response;

        }

        public List<ProcessOperation> SelectOperation(string routingcode)
        {
            var response = Context.Queryable<ProcessOperation>()
                .WhereIF(!string.IsNullOrEmpty(routingcode), it => it.FkRoutingCode.Contains(routingcode))
                .ToList();
            return response;
        }


        public List<PlantFactorySite> GetFactorySite(string site_code)
        {
            return Context.Queryable<PlantFactorySite>().WhereIF(!string.IsNullOrEmpty(site_code), it => it.SiteCode.Contains(site_code)).ToList();
        }

        public List<PlantWorkshop> GetWorkShop(string site_code, string workshop_code)
        {
            return Context.Queryable<PlantWorkshop>()
                .WhereIF(!string.IsNullOrEmpty(site_code), it => it.FkSiteCode.Contains(site_code))
                .WhereIF(!string.IsNullOrEmpty(workshop_code), it => it.WorkshopCode.Contains(workshop_code))
                .ToList();
        }
        public List<PlantProductlinebody> GetPlantProductlinebodies(string site_code, string workshop_code, string linecode)
        {
            return Context.Queryable<PlantProductlinebody>()
            .WhereIF(!string.IsNullOrEmpty(site_code), it => it.FkFactorySiteCode.Contains(site_code))
            .WhereIF(!string.IsNullOrEmpty(workshop_code), it => it.FkWorkshopCode.Contains(workshop_code))
            .WhereIF(!string.IsNullOrEmpty(linecode), it => it.LineCode.Contains(linecode))



        .ToList();
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateProcessOperationWorkstationMapping(ProcessOperationWorkstationMapping model)
        {
            //var response = Update(w => w.Id == model.Id, it => new ProcessOperationWorkstationMapping()
            //{
            //    FkOperationCode = model.FkOperationCode,
            //    FkWorkstationCode = model.FkWorkstationCode,
            //    IsActive = model.IsActive,
            //    Priority = model.Priority,
            //    StandardTime = model.StandardTime,
            //    SetupTime = model.SetupTime,
            //    CreatedTime = model.CreatedTime,
            //    CreatedBy = model.CreatedBy,
            //    Remark = model.Remark,
            //    UpdatedTime = model.UpdatedTime,
            //    UpdatedBy = model.UpdatedBy,
            //});
            //return response;
            return Update(model, true);
        }

        /// <summary>
        /// 采集参数 实体化 （同步）
        /// </summary>
        /// <param name="OperationWorkstationMappingId"></param>
        /// <returns></returns>
        public int SyncCollectParameter(int OperationWorkstationMappingId)
        {
            int result = 0;
            //获取工序工位映射信息
            ProcessOperationWorkstationMapping selectMapping = Context.Queryable<ProcessOperationWorkstationMapping>().Where(it => it.Id == OperationWorkstationMappingId).First();
            if(selectMapping!=null&&!string.IsNullOrEmpty(selectMapping.FkRoutingCode) && !string.IsNullOrEmpty(selectMapping.FkOperationCode))
            {
                // 获取工序的采集参数
                List<ProcessOperationCollectParameter> ProcessOperationCollectParameterList = Context.Queryable<ProcessOperationCollectParameter>()
                    .Where(it => it.FkRoutingCode == selectMapping.FkRoutingCode && it.FkOperationCode == selectMapping.FkOperationCode).ToList();

                //同步
                if (ProcessOperationCollectParameterList != null && ProcessOperationCollectParameterList.Count > 0)
                {
                    List<ProcessOperationWorkstationFlowCollectParameter> insertData = new List<ProcessOperationWorkstationFlowCollectParameter>();
                    foreach (var parameter in ProcessOperationCollectParameterList)
                    {
                        //判断是否存在
                        int count = Context.Queryable<ProcessOperationWorkstationFlowCollectParameter>()
                            .Where(it => it.FkRoutingCode == parameter.FkRoutingCode
                                && it.FkOperationCode == parameter.FkOperationCode                         
                                && it.ParameterCode == parameter.ParameterCode)
                            .Count();
                        if (count == 0)
                        {
                            //不存在则添加
                            ProcessOperationWorkstationFlowCollectParameter newEntity = new ProcessOperationWorkstationFlowCollectParameter()
                            {
                                FkRoutingCode = parameter.FkRoutingCode,
                                FkOperationCode = parameter.FkOperationCode,
                                FkProductlinebodyCode = selectMapping.FkProductlinebodyCode,
                                FkWorkstationCode = selectMapping.FkWorkstationCode,
                                ParameterCode = parameter.ParameterCode,
                                ParameterName = parameter.ParameterName,
                                FkFlowCode = parameter.FkFlowCode,
                                Description = parameter.Description,
                                DataType = parameter.DataType,
                                Unit = parameter.Unit,
                                StandardValue = parameter.StandardValue,
                                MinValue = parameter.MinValue,
                                MaxValue = parameter.MaxValue,
                                IsControlled = parameter.IsControlled,
                                IsMonitored = parameter.IsMonitored,
                                ControlType = parameter.ControlType,
                                DefaultValue = parameter.DefaultValue,
                                IsRequired = parameter.IsRequired,
                                Sequence = parameter.Sequence,
                                CreatedTime = DateTime.Now,
                                CreatedBy = "SystemSync"
                            };
                            insertData.Add(newEntity);

                        }


                       

                    }

                    if (insertData.Count > 0)
                    {
                        result = Context.Insertable<ProcessOperationWorkstationFlowCollectParameter>(insertData).ExecuteCommand();
                    }
                }
            }
            return result;
        }


        public int UpdatePlcPoint( int ProcessOperationWorkstationFlowCollectParameterId, string  plc_point)
        {
           return  Context.Updateable<ProcessOperationWorkstationFlowCollectParameter>()
                .SetColumns(it => new ProcessOperationWorkstationFlowCollectParameter() { PlcPoint = plc_point })
                .Where(it => it.Id == ProcessOperationWorkstationFlowCollectParameterId)
                .ExecuteCommand();
        }

        public PagedInfo<PfRecipeParametersDto> QueryProcessOperationRecipe(ProcessOperationQuery2Dto query)
        {

            return Context.Queryable<PfRefProductRecipe>()
              .LeftJoin<PfRecipeVersion>((refpr, ver) => refpr.RecipeCode == ver.RecipeCode)
              .LeftJoin<PfRecipeParameters>((refpr, ver, param) => ver.RecipeCode == param.RecipeCode && ver.Version == param.Version)
              .Where((refpr, ver, param) => refpr.FkRoutingCode == query.FkRoutingCode && refpr.FkOperationCode == query.OperationCode)
              .Select((refpr, ver, param) => new PfRecipeParametersDto
              {
                  Id = param.Id,
                  RecipeCode = param.RecipeCode,
                  Version = param.Version,
                  ParamName = param.ParamName,
                  Unit = param.Unit,
                  UpperLimit = param.UpperLimit,
                  LowerLimit = param.LowerLimit,
                  StandardValue = param.StandardValue,
                  Remark = param.Remark
              }).ToPage<PfRecipeParametersDto, PfRecipeParametersDto>(query);

        }

    }
}