示例#1
0
        public List <CorrosionStudyDTO> GetBySearchFilters(CorrosionStudyFilterDTO corrosionStudyFilterDTO)
        {
            List <CorrosionStudyDTO> list = new List <CorrosionStudyDTO>();

            IQueryable <CorrosionStudyDTO> query = (from p in _unitOfWork.CorrosionStudy.GenerateEntityAsIQueryable()
                                                    join l in _context.Plant on p.PlantCode equals l.Code
                                                    select new CorrosionStudyDTO
            {
                ID = p.ID,
                ParentPlantCode = l.ParentPlant.Code,
                PlantCode = p.PlantCode,
                LoopNo = p.LoopNo,
                FluidCode = p.FluidCode,
                FluidName = p.FluidName,
                SubFluidCode = p.SubFluidCode,
                ProcessDescription = p.ProcessDescription,
                MinPressure = p.MinPressure,
                MaxPressure = p.MaxPressure,
                MinTemperature = p.MinTemperature,
                MaxTemperature = p.MaxTemperature,
            });

            if (corrosionStudyFilterDTO != null)
            {
                if (!string.IsNullOrWhiteSpace(corrosionStudyFilterDTO.LoopNo))
                {
                    query = (from re in query
                             where re.LoopNo == corrosionStudyFilterDTO.LoopNo
                             select re);
                }


                if (!string.IsNullOrWhiteSpace(corrosionStudyFilterDTO.PlantCode))
                {
                    query = (from re in query
                             where re.PlantCode == corrosionStudyFilterDTO.PlantCode
                             select re);
                }

                if (!string.IsNullOrWhiteSpace(corrosionStudyFilterDTO.FluidCode))
                {
                    query = (from re in query
                             where re.FluidCode == corrosionStudyFilterDTO.FluidCode
                             select re);
                }

                if (!string.IsNullOrWhiteSpace(corrosionStudyFilterDTO.ParentPlantCode))
                {
                    query = (from re in query
                             where re.ParentPlantCode == corrosionStudyFilterDTO.ParentPlantCode
                             select re);
                }

                list = query.OrderBy(p => p.LoopNo).ToList();
            }


            return(list);
        }
        public CorrosionStudyResponseDTO GetPipeClustersByLoopNo([FromBody] CorrosionStudyFilterDTO corrosionStudyFilterDTO)
        {
            CorrosionStudyResponseDTO result = new CorrosionStudyResponseDTO();

            try
            {
                result = _CorrosionStudyService.GetPipeClustersByLoopNo(corrosionStudyFilterDTO);
                _logger.LogDebug("Result returned");
            }
            catch (Exception exception)
            {
                _logger.LogError(exception, "");
            }

            return(result);
        }
示例#3
0
        public CorrosionStudyResponseDTO GetPipeClustersByLoopNo(CorrosionStudyFilterDTO corrosionStudyFilterDTO)
        {
            CorrosionStudyResponseDTO response = new CorrosionStudyResponseDTO();



            List <CorrosionStudyDTO> list = new List <CorrosionStudyDTO>();

            IQueryable <CorrosionStudyDTO> query = (from p in _unitOfWork.PipeMaster.GenerateEntityAsIQueryable()
                                                    join l in _context.Plant on p.PlantCode equals l.Code
                                                    select new CorrosionStudyDTO
            {
                ID = p.ID,
                ParentPlantCode = l.ParentPlant.Code,
                PlantCode = p.PlantCode,
                LoopNo = p.CorrosionLoopNo,
                FluidCode = p.FluidCode,
                FluidName = p.FluidName,
                SubFluidCode = p.SubFluid,
                ProcessDescription = "",
                MinPressure = p.DesignPressure,
                MaxPressure = p.DesignPressure,
                MinTemperature = p.DesignTemperature,
                MaxTemperature = p.DesignTemperature,
                ClusterNo = p.PipeClusterNo,
                MaterialCode = p.MaterialCode
            });

            if (corrosionStudyFilterDTO != null)
            {
                if (!string.IsNullOrWhiteSpace(corrosionStudyFilterDTO.LoopNo))
                {
                    query = (from re in query
                             where re.LoopNo == corrosionStudyFilterDTO.LoopNo
                             select re);
                }


                if (!string.IsNullOrWhiteSpace(corrosionStudyFilterDTO.PlantCode))
                {
                    query = (from re in query
                             where re.PlantCode == corrosionStudyFilterDTO.PlantCode
                             select re);
                }

                if (!string.IsNullOrWhiteSpace(corrosionStudyFilterDTO.FluidCode))
                {
                    query = (from re in query
                             where re.FluidCode == corrosionStudyFilterDTO.FluidCode
                             select re);
                }

                if (!string.IsNullOrWhiteSpace(corrosionStudyFilterDTO.ParentPlantCode))
                {
                    query = (from re in query
                             where re.ParentPlantCode == corrosionStudyFilterDTO.ParentPlantCode
                             select re);
                }

                list = query.OrderBy(p => p.LoopNo).ToList();
            }

            response.CorrosionStudyDTO = new CorrosionStudyDTO();

            response.COFMasterDTOList = new List <COFMasterDTO>();

            response.IOWDTOList = new List <IOWDTO>();

            response.PipeClusterPOFDTOList = new List <PipeClusterPOFDTO>();

            CorrosionStudyDTO corrosionStudy = new CorrosionStudyDTO();

            if (list != null && list.Count > 0)
            {
                corrosionStudy.ID              = 0;
                corrosionStudy.LoopNo          = list.Min(p => p.LoopNo);
                corrosionStudy.MinPressure     = list.Min(p => p.MinPressure);
                corrosionStudy.MaxPressure     = list.Max(p => p.MinPressure);
                corrosionStudy.MinTemperature  = list.Min(p => p.MinTemperature);
                corrosionStudy.MaxTemperature  = list.Max(p => p.MinTemperature);
                corrosionStudy.FluidCode       = list.Max(p => p.FluidCode);
                corrosionStudy.FluidName       = list.Max(p => p.FluidName);
                corrosionStudy.PlantCode       = list.Max(p => p.PlantCode);
                corrosionStudy.ParentPlantCode = list.Max(p => p.ParentPlantCode);
                corrosionStudy.ClusterNos      = list.Select(p => p.ClusterNo).Distinct().ToList <string>();

                response.CorrosionStudyDTO = corrosionStudy;

                foreach (string cluster in corrosionStudy.ClusterNos)
                {
                    PipeClusterPOFDTO pipeCluster = new PipeClusterPOFDTO();
                    pipeCluster.ID               = 0;
                    pipeCluster.Fluid            = response.CorrosionStudyDTO.FluidCode;
                    pipeCluster.ClusterNo        = cluster;
                    pipeCluster.MaterialCode     = list.Where(c => c.ClusterNo == cluster).Select(c => c.MaterialCode).FirstOrDefault();
                    pipeCluster.MinPressure      = list.Where(c => c.ClusterNo == cluster).Min(c => c.MinPressure);
                    pipeCluster.MaxPressure      = list.Where(c => c.ClusterNo == cluster).Max(c => c.MinPressure);
                    pipeCluster.MinTemperature   = list.Where(c => c.ClusterNo == cluster).Min(c => c.MinTemperature);
                    pipeCluster.MaxTemperature   = list.Where(c => c.ClusterNo == cluster).Max(c => c.MinTemperature);
                    pipeCluster.CorrosionStudyID = 0;
                    pipeCluster.DMGuideList      = new List <DMGuideDTO>();

                    response.PipeClusterPOFDTOList.Add(pipeCluster);
                }
            }


            return(response);
        }
 public List <CorrosionStudyDTO> GetBySearchFilters([FromBody] CorrosionStudyFilterDTO corrosionStudyFilterDTO)
 {
     return(_CorrosionStudyService.GetBySearchFilters(corrosionStudyFilterDTO));
 }