From f680da60e6c3a293465a01a212067566d0f7dae4 Mon Sep 17 00:00:00 2001 From: zhn <947514737@qq.com> Date: Tue, 12 Sep 2023 17:07:38 +0800 Subject: [PATCH] =?UTF-8?q?=E5=B9=B3=E5=8F=B0=E4=BB=B6=E9=A1=B9=E7=9B=AE?= =?UTF-8?q?=E5=BA=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../controller/ProjectPlatformController.java | 311 ++ .../mapper/ProjectPlatformMapper.java | 32 + .../mapper/xml/ProjectPlatform.xml | 303 ++ .../service/IProjectPlatformService.java | 191 + .../impl/ProjectPlatformServiceImpl.java | 3573 +++++++++++++++++ 5 files changed, 4410 insertions(+) create mode 100644 jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/controller/ProjectPlatformController.java create mode 100644 jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/mapper/ProjectPlatformMapper.java create mode 100644 jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/mapper/xml/ProjectPlatform.xml create mode 100644 jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/service/IProjectPlatformService.java create mode 100644 jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/service/impl/ProjectPlatformServiceImpl.java diff --git a/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/controller/ProjectPlatformController.java b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/controller/ProjectPlatformController.java new file mode 100644 index 000000000..3d02d8201 --- /dev/null +++ b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/controller/ProjectPlatformController.java @@ -0,0 +1,311 @@ +package com.jero.modules.projectPlatform.controller; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.jero.common.api.vo.Result; +import com.jero.common.aspect.annotation.AutoLog; +import com.jero.common.system.base.controller.JeroController; +import com.jero.common.system.vo.DictModel; +import com.jero.modules.project.entity.ProjectLibraryBase; +import com.jero.modules.project.service.IProjectLibraryBaseService; +import com.jero.modules.projectPlatform.service.IProjectPlatformService; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.extern.slf4j.Slf4j; +import org.apache.shiro.authz.annotation.RequiresPermissions; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.servlet.ModelAndView; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.text.ParseException; +import java.util.Arrays; +import java.util.List; +import java.util.Map; + + +/** + * @Description: 项目库基础表 + * @Author: jero-boot + * @Date: 2022-04-11 + * @Version: V1.0 + */ +@Api(tags="平台件项目库") +@RestController +@RequestMapping("/project/platform") +@Slf4j +public class ProjectPlatformController extends JeroController { + @Autowired + private IProjectPlatformService projectPlatformService; + + /** + * 分页列表查询 + * + * @return + */ + @AutoLog(value = "项目库基础表-分页列表查询") + @ApiOperation(value="项目库基础表-分页列表查询", notes="项目库基础表-分页列表查询") + @PostMapping(value = "/page") + public Result queryPageList(@RequestBody Map params) { + List pageList= projectPlatformService.queryPageList(params); + Page pages = projectPlatformService.getPages(Integer.parseInt(params.get("pageNo").toString()), Integer.parseInt(params.get("pageSize").toString()), pageList); + return Result.OK(params.get("cut").toString(),pages); + } + + /** + * 列表查询 + * + * @return + */ + @AutoLog(value = "项目库基础表-列表查询") + @ApiOperation(value="项目库基础表-列表查询", notes="项目库基础表-列表查询") + @GetMapping(value = "/list") + public Result> queryList(ProjectLibraryBase projectLibraryBase) { + List list = projectPlatformService.getList(projectLibraryBase); + return Result.OK(list); + } + + /** + * 添加 + * + * @param projectLibraryBase + * @return + */ + @AutoLog(value = "项目库基础表-添加") + @ApiOperation(value="项目库基础表-添加", notes="项目库基础表-添加") + @RequiresPermissions("projectLibraryBase:add") + @PostMapping(value = "/add") + public Result add(@Validated @RequestBody ProjectLibraryBase projectLibraryBase) throws ParseException { + projectPlatformService.add(projectLibraryBase); + return Result.OK("添加成功！"); + } + /** + * 项目扩展(添加子项目子项目基本信息、相关人员名单、法规/认证任务计划与被扩展项目保持一致) + * + * @param projectLibraryBase + * @return + */ + @AutoLog(value = "项目扩展(添加子项目)") + @ApiOperation(value="项目扩展(添加子项目)", notes="项目扩展(添加子项目)") + @RequiresPermissions("projectLibraryBase:add") + @PostMapping(value = "/addChild") + public Result addChild(@Validated @RequestBody ProjectLibraryBase projectLibraryBase) throws ParseException { + projectPlatformService.addChild(projectLibraryBase); + return Result.OK("添加成功！"); + } + + /** + * 编辑 + * + * @param projectLibraryBase + * @return + */ + @AutoLog(value = "项目库基础表-编辑") + @ApiOperation(value="项目库基础表-编辑", notes="项目库基础表-编辑") + @RequiresPermissions("projectLibraryBase:edit") + @PutMapping(value = "/edit") + public Result edit(@Validated @RequestBody ProjectLibraryBase projectLibraryBase) { + projectPlatformService.editById(projectLibraryBase); + return Result.OK("编辑成功!"); + } + + /** + * 通过id删除 + * + * @param id + * @return + */ + @AutoLog(value = "项目库基础表-通过id删除") + @ApiOperation(value="项目库基础表-通过id删除", notes="项目库基础表-通过id删除") + @RequiresPermissions("projectLibraryBase:delete") + @DeleteMapping(value = "/delete") + public Result delete(@RequestParam(name="id",required=true) String id, + @RequestParam(name="cut",required=true) String cut) { + projectPlatformService.deleteById(id,cut); + return Result.OK("删除成功!"); + } + + /** + * 批量删除 + * + * @param ids + * @return + */ + @AutoLog(value = "项目库基础表-批量删除") + @ApiOperation(value="项目库基础表-批量删除", notes="项目库基础表-批量删除") + @RequiresPermissions("projectLibraryBase:deleteBatch") + @DeleteMapping(value = "/deleteBatch") + public Result deleteBatch(@RequestParam(name="ids",required=true) String ids, + @RequestParam(name="cut",required=true) String cut) { + this.projectPlatformService.deleteByIds(Arrays.asList(ids.split(",")),cut); + return Result.OK("批量删除成功!"); + } + + /** + * 通过id查询 + * + * @param id + * @return + */ + @AutoLog(value = "项目库基础表-通过id查询") + @ApiOperation(value="项目库基础表-通过id查询", notes="项目库基础表-通过id查询") + @RequiresPermissions("projectLibraryBase:queryById") + @GetMapping(value = "/queryById") + public Result queryById(@RequestParam(name="id",required=true) String id, + @RequestParam(name="cut",required=true) String cut) { + List data = projectPlatformService.queryById(id,cut); + if(data==null) { + return Result.error("未找到对应数据"); + } + return Result.OK(cut,data); + } + + /** + * 导出excel + * + * @param request + * @param projectLibraryBase + */ + @RequestMapping(value = "/exportXls") + public ModelAndView exportXls(HttpServletRequest request, ProjectLibraryBase projectLibraryBase) { + return super.exportXls(request, projectLibraryBase, ProjectLibraryBase.class, "项目库基础表"); + } + + /** + * 通过excel导入数据 + * + * @param request + * @param response + * @return + */ + @RequestMapping(value = "/importExcel", method = RequestMethod.POST) + public Result importExcel(HttpServletRequest request, HttpServletResponse response) { + return super.importExcel(request, response, ProjectLibraryBase.class); + } + + /** + * 项目详情-统计接口 + * @param id 项目库id + * @return + */ + @AutoLog(value = "项目详情-统计接口") + @ApiOperation(value="项目详情-统计接口", notes="项目详情-统计接口") + @GetMapping(value = "/getProjectDetailsStatistics") + public Result getProjectDetailsStatistics(@RequestParam(name="id",required=true) String id, + @RequestParam(name="cut",required=true) String cut) { + Map data = projectPlatformService.getProjectDetailsStatistics(id); + return Result.OK(cut,data); + } + + /** + * 项目详情-统计接口-根据领域分组 + * @return + */ + @AutoLog(value = "项目详情-统计接口-根据领域分组") + @ApiOperation(value="项目详情-统计接口-根据领域分组", notes="项目详情-统计接口-根据领域分组") + @GetMapping(value = "/getProjectDetailsStatisticsGroupByTerritory") + public Result getProjectDetailsStatisticsGroupByTerritory(@RequestParam Map params) { + Map data = projectPlatformService.getProjectDetailsStatisticsGroupByTerritory(params); + return Result.OK((String)params.get("cut"),data); + } + + /** + * 导出excel + * + * @param request + * @param params + */ + @RequestMapping(value = "/exportProjectDetailsStatisticsGroupByTerritoryXls") + public void exportProjectDetailsStatisticsGroupByTerritoryXls(HttpServletResponse response,HttpServletRequest request, @RequestParam Map params) { + projectPlatformService.exportProjectDetailsStatisticsGroupByTerritoryXls(response,request, params); + } + + + /** + * 项目置顶,取消置顶(只置顶主项目) + * @param id + * @param flag 0为置顶, 1为取消置顶 + * @return + */ + @AutoLog(value = "项目置顶,取消置顶(只置顶主项目)") + @ApiOperation(value="项目置顶,取消置顶(只置顶主项目)", notes="项目置顶,取消置顶(只置顶主项目)") + @GetMapping(value = "/top") + public Result top(String id,String flag) { + projectPlatformService.top(id,flag); + return Result.OK("编辑成功!"); + } + + /** + * 获取项目所有的版本(主版本和子版本的集合) + * @param id 项目id + * @return + */ + @AutoLog(value = "获取项目所有的版本(主版本和子版本的集合)") + @ApiOperation(value="获取项目所有的版本(主版本和子版本的集合)", notes="获取项目所有的版本(主版本和子版本的集合)") + @GetMapping(value = "/getVersionsInfo") + public Result getVersionsInfo(String id) { + List versionsInfoList = projectPlatformService.getVersionsInfo(id); + return Result.OK(versionsInfoList); + } + + /** + * 版本统计 + * @return + */ + @AutoLog(value = "版本统计") + @ApiOperation(value="版本统计)", notes="版本统计") + @PostMapping(value = "/versionStatistics") + public Result versionStatistics(@RequestBody Map params) { + List projectLibraryBasesList = projectPlatformService.versionStatistics(String.valueOf(params.get("id"))); + Page pages = projectPlatformService.getPages(Integer.parseInt(params.get("pageNo").toString()), Integer.parseInt(params.get("pageSize").toString()), projectLibraryBasesList); + return Result.OK(pages); + } + + @AutoLog(value = "对接火山引擎接口getProjectInfo") + @ApiOperation(value="对接火山引擎接口-获取项目统计信息1", notes="对接火山引擎接口-获取项目统计信息1") + @PostMapping(value = "/getProjectInfo") + public Result getProjectInfo(){ + JSONArray resList = projectPlatformService.getProjectInfo(); + return Result.OK(resList); + } + + @AutoLog(value = "对接火山引擎接口getProjectProgressInfo") + @ApiOperation(value="对接火山引擎接口-获取项目统计信息2", notes="对接火山引擎接口-获取项目统计信息2") + @PostMapping(value = "/getProjectProgressInfo") + public Result getProjectProgressInfo(){ + JSONArray resList = this.projectPlatformService.getProjectProgressInfo(); + return Result.OK(resList); + } + + // 导出项目进度统计(状态导出) + @RequestMapping(value = "/exportProjectProgressStatisticsXls") + public void exportProjectProgressStatisticsXls(HttpServletResponse response,HttpServletRequest request, @RequestParam Map params) { + this.projectPlatformService.exportProjectProgressStatisticsXls(response,request, params); + } + + @AutoLog(value = "获取用户在该项目中所有的责任领域") + @ApiOperation(value="获取用户在该项目中所有的责任领域", notes="获取用户在该项目中所有的责任领域") + @GetMapping(value = "/getUserAllDutyTerritoryList") + public Result> getUserAllDutyTerritoryList(@RequestParam Map params){ + List resList = this.projectPlatformService.getUserAllDutyTerritoryList(params); + return Result.OK(resList); + } + + @AutoLog(value = "全局替换用户") + @ApiOperation(value="全局替换用户", notes="全局替换用户") + @PostMapping(value = "/overallReplacementUser") + public Result overallReplacementUser(@RequestBody JSONObject json){ + return this.projectPlatformService.overallReplacementUser(json); + } +} diff --git a/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/mapper/ProjectPlatformMapper.java b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/mapper/ProjectPlatformMapper.java new file mode 100644 index 000000000..20c20cead --- /dev/null +++ b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/mapper/ProjectPlatformMapper.java @@ -0,0 +1,32 @@ +package com.jero.modules.projectPlatform.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.jero.modules.project.entity.ProjectLibraryBase; +import org.apache.ibatis.annotations.Param; + +import java.util.List; +import java.util.Map; + +/** + * @Description: 项目库基础表 + * @Author: jero-boot + * @Date: 2022-04-11 + * @Version: V1.0 + */ +public interface ProjectPlatformMapper extends BaseMapper { + /**分页列表*/ + List queryPageList(@Param("params") Map params); + List queryMaimList(); +// IPage queryPageList(IPage page, Map params); + + List getList(@Param("projectLibraryBase") ProjectLibraryBase projectLibraryBase); + + /**根据id查询*/ + List queryById(String id); + + ProjectLibraryBase selectProjectName(@Param("projectLibraryId") String projectLibraryId); + + List getListByIds(@Param("idList") List idList); + + +} diff --git a/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/mapper/xml/ProjectPlatform.xml b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/mapper/xml/ProjectPlatform.xml new file mode 100644 index 000000000..aae850b73 --- /dev/null +++ b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/mapper/xml/ProjectPlatform.xml @@ -0,0 +1,303 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + select + plb.id, + plb.project_name_id, + pni.project_name as project_name, + pyni.id as year_name_id, + pyni.year_name, + plb.target_market, + plb.project_status, + plb.studio_engineer, + studiouser.username as studio_engineer_name, + plb.certification_engineer, + plb.vehicle_platform, + plb.digital_platform, + plb.ipd_info, + plb.vehicle_development_plan, + plb.attestation_plan, + plb.create_by, + plb.create_time, + plb.sys_org_code, + plb.update_by, + plb.update_time, + plb.parent_id, + plb.project_version, + plb.explanation, + plb.software_version, + plb.sort, + plb.flag, + plb.brand, + sdi.item_text brandText, + sdi.en_name brandTextEn + from project_library_base as plb + left join project_name_info as pni on plb.project_name_id=pni.id + left join sys_user as studiouser on plb.studio_engineer=studiouser.id + left join project_year_name_info as pyni on plb.year_name_id=pyni.id + left join sys_dict_item as sdi on sdi.item_value = plb.brand + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/service/IProjectPlatformService.java b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/service/IProjectPlatformService.java new file mode 100644 index 000000000..7a3996700 --- /dev/null +++ b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/service/IProjectPlatformService.java @@ -0,0 +1,191 @@ +package com.jero.modules.projectPlatform.service; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.IService; +import com.jero.common.api.vo.Result; +import com.jero.common.system.vo.DictModel; +import com.jero.modules.project.entity.ProjectLibraryBase; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.text.ParseException; +import java.util.List; +import java.util.Map; + +/** + * @Description: 项目库基础表 + * @Author: jero-boot + * @Date: 2022-04-11 + * @Version: V1.0 + */ +public interface IProjectPlatformService extends IService { + + /** + * 保存 + * + * @param projectLibraryBase + * @return + */ + void add(ProjectLibraryBase projectLibraryBase) throws ParseException; + + /** + * 项目扩展(添加子项目-子项目基本信息、相关人员名单、法规/认证任务计划与被扩展项目保持一致) + * + * @param projectLibraryBase + * @return + */ + void addChild(ProjectLibraryBase projectLibraryBase) throws ParseException; + + /** + * 更新 + * + * @param projectLibraryBase + * @return + */ + void editById(ProjectLibraryBase projectLibraryBase); + + /** + * 通过id删除 + * + * @param id + * @return + */ + void deleteById(String id, String cut); + + /** + * 批量删除 + * + * @param ids + * @return + */ + void deleteByIds(List ids,String cut); + + /** + * 通过id查询 + * + * @param id + * @return + */ + List queryById(String id,String cut); + + /** + * 列表查询 + * + * @return + */ + List getList(ProjectLibraryBase projectLibraryBase); + + /** + * 分页列表查询 + * + * @return + */ + List queryPageList(Map params); +// IPage queryPageList(Map params); + + /** + * 项目详情-统计接口 + * @param id + * @return + */ + Map getProjectDetailsStatistics(String id); + + /** + * 项目详情-统计接口-根据领域分组 + * @param params + * @return + */ + Map getProjectDetailsStatisticsGroupByTerritory(Map params); + + void exportProjectDetailsStatisticsGroupByTerritoryXls(HttpServletResponse response, HttpServletRequest request, Map params); + + void checkData(String id, String cut); + + void disposeData(List records,String cut,boolean disposeTargetMarketFlag); + + Page getPages(Integer currentPage, Integer pageSize, List list); + + /** + * 项目置顶,取消置顶(只置顶主项目) + * @param id + * @param flag 0为置顶, 1为取消置顶 + * @return + */ + void top(String id,String flag); + + /** + * 获取项目所有的版本(主版本和子版本的集合) + * @param id + * @return + */ + List getVersionsInfo(String id); + + /** + * 版本统计 + * @param id + * @return + */ + List versionStatistics(String id); + + /** + * 通过主项目id和子项目版本号 + * @param version + * @param parentId + * @return + */ + String getIdByVersionAndParentId(String version, String parentId); + + /** + * 查询主项目及其所有子项目 + * @param parentId + * @return + */ + List getParentAndChildern(String parentId); + + /** + * 根据id查询项目库详情信息 发送飞书消息时使用，之前的 queryById不太兼容 + * @param projectLibraryId + * @return + */ + ProjectLibraryBase selectById(String projectLibraryId); + + /** + * 对接火山引擎接口-获取项目统计信息 + * @return + */ + JSONArray getProjectInfo(); + + /** + * 对接火山引擎接口-获取项目统计信息 + * @return + */ + JSONArray getProjectProgressInfo(); + + /** + * 导出项目进度统计(状态导出) + * @param response + * @param request + * @param params + */ + void exportProjectProgressStatisticsXls(HttpServletResponse response, HttpServletRequest request, Map params); + + /** + * 获取用户在该项目中所有的责任领域数组 + * @param params + * @return + */ + List getUserAllDutyTerritoryList(Map params); + + /** + * 全局替换用户 + * @param json + * @return + */ + Result overallReplacementUser(JSONObject json); + + List queryList(List projectIdList); + + List getListByIds(List projectIdList); +} diff --git a/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/service/impl/ProjectPlatformServiceImpl.java b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/service/impl/ProjectPlatformServiceImpl.java new file mode 100644 index 000000000..e328bc564 --- /dev/null +++ b/jero-boot/jero-boot-modules/src/main/java/com/jero/modules/projectPlatform/service/impl/ProjectPlatformServiceImpl.java @@ -0,0 +1,3573 @@ +package com.jero.modules.projectPlatform.service.impl; + +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.jero.common.api.vo.Result; +import com.jero.common.constant.enums.CutEnum; +import com.jero.common.exception.JeroBootException; +import com.jero.common.system.vo.DictModel; +import com.jero.common.system.vo.LoginUser; +import com.jero.modules.cert.collect.entity.ParamsCollectManifestEO; +import com.jero.modules.cert.collect.entity.ParamsManifestEO; +import com.jero.modules.cert.collect.enums.CollectManifestStateEnum; +import com.jero.modules.cert.collect.enums.CollectManifestStatisticsStateEnum; +import com.jero.modules.cert.collect.service.IParamsCollectManifestEOService; +import com.jero.modules.cert.collect.service.IParamsManifestEOService; +import com.jero.modules.cert.template.enums.ControlTypeEnum; +import com.jero.modules.dummy.enums.OrderEnum; +import com.jero.modules.enums.DictCodeEnum; +import com.jero.modules.feishu.enums.TemplateInfoEnum2; +import com.jero.modules.ota.service.impl.OtaManageApplyEOServiceImpl; +import com.jero.modules.project.entity.ProjectCertificationInventoryEO; +import com.jero.modules.project.entity.ProjectLawsInventoryEO; +import com.jero.modules.project.entity.ProjectLawsInventoryLogEO; +import com.jero.modules.project.entity.ProjectLibraryBase; +import com.jero.modules.project.entity.ProjectLibraryRoleRelEO; +import com.jero.modules.project.entity.ProjectRelatedPersonnel; +import com.jero.modules.project.entity.ProjectTaskInventoryEO; +import com.jero.modules.project.entity.ProjectTaskPlanning; +import com.jero.modules.project.entity.ProjectUserPermission; +import com.jero.modules.project.enums.CertificationFlowNodeEnum; +import com.jero.modules.project.enums.CertificationInventoryFlowStatusEnum; +import com.jero.modules.project.enums.CertificationProgressEnum; +import com.jero.modules.project.enums.ComplianceFlowStatusEnum; +import com.jero.modules.project.enums.DesignComplianceStatusEnum; +import com.jero.modules.project.enums.HSStatisticalNodesEnum; +import com.jero.modules.project.enums.OperatorTypeEnum; +import com.jero.modules.project.enums.PermissionDescriptionEnum; +import com.jero.modules.project.enums.ProjectRoleEnum; +import com.jero.modules.project.enums.ProjectTaskPlanningNameEnum; +import com.jero.modules.project.enums.ProjectUserLocationEnum; +import com.jero.modules.project.enums.RoleRelModelTypeEnum; +import com.jero.modules.project.enums.TaskAffirmStatusEnum; +import com.jero.modules.project.enums.TaskStatusEnum; +import com.jero.modules.project.enums.TopEnum; +import com.jero.modules.project.mapper.ProjectLawsInventoryEOMapper; +import com.jero.modules.project.mapper.ProjectLibraryBaseMapper; +import com.jero.modules.project.mapper.ProjectNameInfoEOMapper; +import com.jero.modules.project.mapper.ProjectRelatedPersonnelMapper; +import com.jero.modules.project.mapper.ProjectTaskInventoryEOMapper; +import com.jero.modules.project.mapper.ProjectUserPermissionMapper; +import com.jero.modules.project.service.IConditionAssessmentEOService; +import com.jero.modules.project.service.IProjectCertificationInventoryEOService; +import com.jero.modules.project.service.IProjectLibraryBaseService; +import com.jero.modules.project.service.IProjectLibraryRoleRelEOService; +import com.jero.modules.project.service.IProjectLibraryStatisticsService; +import com.jero.modules.project.service.IProjectUserPermissionService; +import com.jero.modules.project.service.impl.ProjectLawsInventoryEOServiceImpl; +import com.jero.modules.project.service.impl.ProjectLawsInventoryLogEOServiceImpl; +import com.jero.modules.project.service.impl.ProjectNameInfoEOServiceImpl; +import com.jero.modules.project.service.impl.ProjectRelatedPersonnelServiceImpl; +import com.jero.modules.project.service.impl.ProjectTaskPlanningServiceImpl; +import com.jero.modules.project.vo.TimeNodeVO; +import com.jero.modules.projectPlatform.mapper.ProjectPlatformMapper; +import com.jero.modules.projectPlatform.service.IProjectPlatformService; +import com.jero.modules.system.entity.SysDictItem; +import com.jero.modules.system.entity.SysUser; +import com.jero.modules.system.enums.DicCodeEnum; +import com.jero.modules.system.mapper.SysDictItemMapper; +import com.jero.modules.system.mapper.SysRoleMapper; +import com.jero.modules.system.mapper.SysUserMapper; +import com.jero.modules.system.service.IProjectUserBrandService; +import com.jero.modules.system.service.ISysDictService; +import com.jero.modules.system.service.ISysUserService; +import com.jero.modules.system.service.impl.SysDictItemServiceImpl; +import com.jero.modules.system.util.StringUtils; +import com.jero.modules.todoCenter.entity.ProcessInfoDetailEO; +import com.jero.modules.todoCenter.service.IProcessInfoDetailEOService; +import com.jero.modules.top.entity.TopProjectEO; +import com.jero.modules.top.service.ITopProjectEOService; +import com.jero.modules.wkflow.enums.FlowTypeEnum; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.poi.hssf.usermodel.HSSFSheet; +import org.apache.poi.hssf.usermodel.HSSFWorkbook; +import org.apache.poi.ss.usermodel.Cell; +import org.apache.poi.ss.usermodel.CellStyle; +import org.apache.poi.ss.usermodel.HorizontalAlignment; +import org.apache.poi.ss.usermodel.Row; +import org.apache.poi.ss.util.CellRangeAddress; +import org.apache.shiro.SecurityUtils; +import org.jetbrains.annotations.NotNull; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Propagation; +import org.springframework.transaction.annotation.Transactional; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.io.OutputStream; +import java.text.Collator; +import java.text.DecimalFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.stream.Collectors; + +/** + * @Description: 项目库基础表 + * @Author: jero-boot + * @Date: 2022-04-11 + * @Version: V1.0 + */ +@Service +public class ProjectPlatformServiceImpl extends ServiceImpl implements IProjectPlatformService { + @Autowired + private ProjectLibraryBaseMapper projectLibraryBaseMapper; + + @Autowired + private SysDictItemMapper sysDictItemMapper; + + @Autowired + private SysUserMapper sysUserMapper; + + @Autowired + private ProjectRelatedPersonnelServiceImpl projectRelatedPersonnelService; + @Autowired + private ProjectTaskPlanningServiceImpl projectTaskPlanningService; + + @Autowired + private ProjectLawsInventoryEOMapper projectLawsInventoryEOMapper; + + @Autowired + private ProjectTaskInventoryEOMapper projectTaskInventoryEOMapper; + + @Autowired + private IConditionAssessmentEOService conditionAssessmentEOService; + + @Autowired + private SysDictItemServiceImpl sysDictItemServiceImpl; + + @Autowired + private ProjectNameInfoEOMapper projectNameInfoEOMapper; + @Autowired + private ProjectNameInfoEOServiceImpl projectNameInfoEOService; + + @Autowired + private IProjectLibraryRoleRelEOService projectLibraryRoleRelEOService; + + @Autowired + private ProjectLawsInventoryEOServiceImpl projectLawsInventoryEOService; + + @Autowired + private ProjectLawsInventoryLogEOServiceImpl projectLawsInventoryLogEOService; + + @Autowired + private ProjectRelatedPersonnelMapper projectRelatedPersonnelMapper; + + @Autowired + private IParamsManifestEOService paramsManifestEOService; + + @Autowired + private ISysDictService sysDictService; + + @Autowired + private ISysUserService sysUserService; + + @Autowired + private SysRoleMapper sysRoleMapper; + + @Autowired + private IProjectUserPermissionService projectUserPermissionService; + + @Autowired + private ProjectUserPermissionMapper projectUserPermissionMapper; + + @Autowired + private IProjectUserBrandService projectUserBrandService; + + @Autowired + private ITopProjectEOService iTopProjectEOService; + + @Autowired + private IProjectCertificationInventoryEOService projectCertificationInventoryEOService; + + @Autowired + private IProcessInfoDetailEOService processInfoDetailEOService; + + @Autowired + private IParamsCollectManifestEOService paramsCollectManifestEOService; + + @Autowired + private IProjectLibraryStatisticsService projectLibraryStatisticsService; + @Autowired + private OtaManageApplyEOServiceImpl otaManageApplyEOService; + + private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + private static DecimalFormat df = new DecimalFormat("#.00"); + private static String percentSign = "%"; + + /** + * 保存 + * + * @param projectLibraryBase + * @return + */ + @Override + @Transactional + public void add(ProjectLibraryBase projectLibraryBase) throws ParseException { + Date now = new Date(); + + projectLibraryBase.setCreateTime(now); + projectLibraryBase.setUpdateTime(now); + LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); + projectLibraryBase.setCreateBy(sysUser.getUsername()); + projectLibraryBase.setUpdateBy(sysUser.getUsername()); + + checkExitData(projectLibraryBase); + save(projectLibraryBase); + + //创建任务计划时间轴 + projectTaskPlanningService.setProjectTaskPlanning(projectLibraryBase.getId()); + + List projectLibraryRoleRelEOList = new ArrayList<>(); + //初始化当前项目的studio与项目库 法规清单 角色关系 + ProjectLibraryRoleRelEO lawsInventoryRoleRelEO = new ProjectLibraryRoleRelEO(); + lawsInventoryRoleRelEO.setProjectLibraryId(projectLibraryBase.getId()); + lawsInventoryRoleRelEO.setUserId(projectLibraryBase.getStudioEngineer()); + lawsInventoryRoleRelEO.setRoleCode(ProjectRoleEnum.STUDIO_ENGINEER.getValue()); + lawsInventoryRoleRelEO.setModelType(RoleRelModelTypeEnum.LAWS_INVENTORY.getValue()); + projectLibraryRoleRelEOList.add(lawsInventoryRoleRelEO); + + // 初始化当前项目的studio与项目库 认证清单 角色关系 + ProjectLibraryRoleRelEO certificationInventoryRoleRelEO = new ProjectLibraryRoleRelEO(); + certificationInventoryRoleRelEO.setProjectLibraryId(projectLibraryBase.getId()); + certificationInventoryRoleRelEO.setUserId(projectLibraryBase.getStudioEngineer()); + certificationInventoryRoleRelEO.setRoleCode(ProjectRoleEnum.STUDIO_ENGINEER.getValue()); + certificationInventoryRoleRelEO.setModelType(RoleRelModelTypeEnum.CERTIFICATION_INVENTORY.getValue()); + projectLibraryRoleRelEOList.add(certificationInventoryRoleRelEO); + this.projectLibraryRoleRelEOService.saveBatch(projectLibraryRoleRelEOList); + + //项目权限表添加 + List adds = new ArrayList<>(); + if (ObjectUtils.isNotEmpty(projectLibraryBase.getStudioEngineer())) { + ProjectUserPermission projectUserPermission = new ProjectUserPermission(); + projectUserPermission.setProjectId(projectLibraryBase.getId()); + projectUserPermission.setUserId(projectLibraryBase.getStudioEngineer()); + projectUserPermission.setBelong(ProjectUserLocationEnum.PROJECT_ADD_STUDIO.getValue()); + projectUserPermission.setCreateTime(now); + projectUserPermission.setUpdateTime(now); + adds.add(projectUserPermission); + } + if (ObjectUtils.isNotEmpty(projectLibraryBase.getCertificationEngineer())) { + for (String id : projectLibraryBase.getCertificationEngineer().split(",")) { + ProjectUserPermission projectUserPermission = new ProjectUserPermission(); + projectUserPermission.setProjectId(projectLibraryBase.getId()); + projectUserPermission.setUserId(id); + projectUserPermission.setBelong(ProjectUserLocationEnum.PROJECT_ADD_CERTIFICATION.getValue()); + projectUserPermission.setCreateTime(now); + projectUserPermission.setUpdateTime(now); + adds.add(projectUserPermission); + } + } + if (ObjectUtils.isNotEmpty(adds)) { + projectUserPermissionService.saveBatch(adds); + } + + } + + + + /** + * 项目扩展(添加子项目--子项目基本信息、相关人员名单、法规/认证任务计划与被扩展项目保持一致) + * @param projectLibraryBase + * @throws ParseException + */ + @Override + @Transactional(value = "transactionManager", readOnly = false, propagation = Propagation.REQUIRED, rollbackFor = Throwable.class) + public void addChild(ProjectLibraryBase projectLibraryBase) throws ParseException { + String id = projectLibraryBase.getId();//主项目id + String projectId = UUID.randomUUID().toString().replace("-", ""); + //主表中添加数据 + ProjectLibraryBase projectLibraryBaseTemp = this.getById(id); + projectLibraryBaseTemp.setCreateBy(null); + projectLibraryBaseTemp.setCreateTime(null); + projectLibraryBaseTemp.setUpdateBy(null); + projectLibraryBaseTemp.setUpdateTime(null); + projectLibraryBaseTemp.setId(projectId); + projectLibraryBaseTemp.setParentId(id); + projectLibraryBaseTemp.setProjectVersion(projectLibraryBase.getProjectVersion()); + projectLibraryBaseTemp.setExplanation(projectLibraryBase.getExplanation()); + this.save(projectLibraryBaseTemp); + + //处理版本号排序问题，如果版本号插入到中间，后面版本数字顺眼 + checkVersionOrder(id,projectLibraryBase.getProjectVersion(),projectId); + + Date now = new Date(); + //相关人员名单中添加数据 + List projectRelatedPersonnelList = projectRelatedPersonnelMapper.queryPageList(id, + DictCodeEnum.DUTY_TERRITORY.getValue(), + null, + null, + null, + null,null); + if(projectRelatedPersonnelList.size() != 0){ + List relatedPersonnelPermissionList = new ArrayList<>(); + for (ProjectRelatedPersonnel projectRelatedPersonnel : projectRelatedPersonnelList) { + String relatedPersonnelId = UUID.randomUUID().toString().replace("-", ""); + projectRelatedPersonnel.setId(relatedPersonnelId); + projectRelatedPersonnel.setProjectId(projectId); + + //添加人员权限 + if (ObjectUtils.isNotEmpty(projectRelatedPersonnel.getLawEngineer())) { + for (String lawEngineerId : projectRelatedPersonnel.getLawEngineer().split(",")) { + //projectUserPermissionService.queryRelatedPersonnelPermission(projectLibraryBase.getId(),lawEngineerId,ProjectUserLocationEnum.PROJECT_DETAIL_RELEVANT_PERSONNEL_LAW.getValue()); + ProjectUserPermission permission = new ProjectUserPermission(); + permission.setProjectId(projectId); + permission.setUserId(lawEngineerId); + permission.setBelong(ProjectUserLocationEnum.PROJECT_DETAIL_RELEVANT_PERSONNEL_LAW.getValue()); + permission.setDescription(PermissionDescriptionEnum.PROJECT_RELATED_PERSONNEL.getValue() + relatedPersonnelId); + permission.setCreateTime(now); + permission.setUpdateTime(now); + relatedPersonnelPermissionList.add(permission); + } + } + if (ObjectUtils.isNotEmpty(projectRelatedPersonnel.getEngineeringInterfacePerson())) { + for (String engineeringInterfacePersonId : projectRelatedPersonnel.getEngineeringInterfacePerson().split(",")) { + ProjectUserPermission permission = new ProjectUserPermission(); + permission.setProjectId(projectId); + permission.setUserId(engineeringInterfacePersonId); + permission.setBelong(ProjectUserLocationEnum.PROJECT_DETAIL_RELEVANT_PERSONNEL_INTERFACE.getValue()); + permission.setDescription(PermissionDescriptionEnum.PROJECT_RELATED_PERSONNEL.getValue() + relatedPersonnelId); + permission.setCreateTime(now); + permission.setUpdateTime(now); + relatedPersonnelPermissionList.add(permission); + } + } + if (ObjectUtils.isNotEmpty(projectRelatedPersonnel.getCertificationEngineer())) { + for (String certificationEngineerId : projectRelatedPersonnel.getCertificationEngineer().split(",")) { + ProjectUserPermission permission = new ProjectUserPermission(); + permission.setProjectId(projectId); + permission.setUserId(certificationEngineerId); + permission.setBelong(ProjectUserLocationEnum.PROJECT_DETAIL_RELEVANT_PERSONNEL_CERTIFICATION.getValue()); + permission.setDescription(PermissionDescriptionEnum.PROJECT_RELATED_PERSONNEL.getValue() + relatedPersonnelId); + permission.setCreateTime(now); + permission.setUpdateTime(now); + relatedPersonnelPermissionList.add(permission); + } + + } + + } + projectRelatedPersonnelService.saveBatch(projectRelatedPersonnelList); + if (ObjectUtils.isNotEmpty(relatedPersonnelPermissionList)) { + projectUserPermissionService.saveBatch(relatedPersonnelPermissionList); + } + } + + //法规/认证任务计划添加数据 projectTaskPlanningService + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.in(ProjectTaskPlanning::getProjectId,projectLibraryBase.getId()); + ProjectTaskPlanning projectTaskPlanning = projectTaskPlanningService.getOne(wrapper); + if(ObjectUtils.isNotEmpty(projectTaskPlanning)){ + projectTaskPlanning.setId(UUID.randomUUID().toString().replace("-", "")); + projectTaskPlanning.setProjectId(projectId); + projectTaskPlanningService.add(projectTaskPlanning); + } + + + //初始化当前项目的studio与项目库 角色关系 projectLibraryRoleRelEOService + LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>(); + queryWrapper.in(ProjectLibraryRoleRelEO::getProjectLibraryId,projectLibraryBase.getId()); + List projectLibraryRoleRelEOList = projectLibraryRoleRelEOService.list(queryWrapper); + + List studioUserPermissions = new ArrayList<>(); + if(ObjectUtils.isNotEmpty(projectLibraryRoleRelEOList)){ + for (ProjectLibraryRoleRelEO projectLibraryRoleRelEO : projectLibraryRoleRelEOList) { + projectLibraryRoleRelEO.setId(UUID.randomUUID().toString().replace("-", "")); + projectLibraryRoleRelEO.setProjectLibraryId(projectId); + projectLibraryRoleRelEOService.add(projectLibraryRoleRelEO); + //添加studio权限 + ProjectUserPermission studioUserPermission = new ProjectUserPermission(); + studioUserPermission.setProjectId(projectId); + studioUserPermission.setUserId(projectLibraryRoleRelEO.getUserId()); + studioUserPermission.setBelong(ProjectUserLocationEnum.PROJECT_ADD_STUDIO.getValue()); + studioUserPermission.setCreateTime(now); + studioUserPermission.setUpdateTime(now); + studioUserPermissions.add(studioUserPermission); + } + } + if (ObjectUtils.isNotEmpty(studioUserPermissions)) { + projectUserPermissionService.saveBatch(studioUserPermissions); + } + } + + /** + * 如果创建的子项目版本号重复，处理排序 + * @param id + * @param version + * @param projectId + */ + private void checkVersionOrder(String id,String version,String projectId) { + LambdaQueryWrapper wrapperVer = new LambdaQueryWrapper<>(); + //查找其他统计子版本项目 + wrapperVer.eq(ProjectLibraryBase::getParentId, id); + wrapperVer.orderByAsc(ProjectLibraryBase::getProjectVersion); + List clist = this.list(wrapperVer); + int tmpInt = Integer.parseInt(version); + for (ProjectLibraryBase plb : clist) { + int ver = Integer.parseInt(plb.getProjectVersion()); + if(!plb.getId().equals(projectId) && ver == tmpInt){ + tmpInt++; + String verStr = String.valueOf(tmpInt); + if(verStr.length() <= 1){ + verStr= "0" + verStr; + } + plb.setProjectVersion(verStr); + this.updateById(plb); + } + } + } + + + /**检查车型名称id,年款号,目标市场,版本同时存在,报错*/ + public void checkExitData(ProjectLibraryBase projectLibraryBase){ + String projectNameId = projectLibraryBase.getProjectNameId(); + String yearNameId = projectLibraryBase.getYearNameId(); + String targetMarket = projectLibraryBase.getTargetMarket(); + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.eq("project_name_id",projectNameId) + .eq("year_name_id",yearNameId) + .eq("target_market",targetMarket) + .eq("project_version",targetMarket); + if(StringUtils.isNotBlank(projectLibraryBase.getId())){ + queryWrapper.ne("id",projectLibraryBase.getId()); + } + Integer count = projectLibraryBaseMapper.selectCount(queryWrapper); + if (count > 0) { + if(CutEnum.CN.getValue().equals(projectLibraryBase.getCut())) { + throw new JeroBootException("已存在车型名称,年款号,目标市场均同的数据"); + }else{ + throw new JeroBootException("There are data with the same model name, model number and target market."); + } + } + } + /** + * 更新 + * + * @param projectLibraryBase + * @return + */ + @Override + public void editById(ProjectLibraryBase projectLibraryBase) { + Date now = new Date(); + projectLibraryBase.setUpdateTime(now); + LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); + projectLibraryBase.setUpdateBy(sysUser.getUsername()); + + ProjectLibraryBase original = baseMapper.selectById(projectLibraryBase.getId()); + + // 如果studio编辑了认证工程师，需要给旧的认证工程师发送认证清单任务消息 + if(StringUtils.isNotEmpty(projectLibraryBase.getCertificationEngineer()) && StringUtils.isNotEmpty(original.getCertificationEngineer())){ + this.editCertificationEngineer(projectLibraryBase, original); + } + + checkExitData(projectLibraryBase); + saveOrUpdate(projectLibraryBase); + checkVersionOrder(projectLibraryBase.getParentId(),projectLibraryBase.getProjectVersion(),projectLibraryBase.getId()); + + // 删除当前项目的studio与项目库 角色关系 + QueryWrapper deleteLibraryRoleRelWrapper = new QueryWrapper<>(); + deleteLibraryRoleRelWrapper.lambda().eq(ProjectLibraryRoleRelEO::getProjectLibraryId,projectLibraryBase.getId()); + projectLibraryRoleRelEOService.remove(deleteLibraryRoleRelWrapper); + //删除当前项目studio项目权限 + QueryWrapper delStudioPermission = new QueryWrapper<>(); + delStudioPermission.eq("project_id", projectLibraryBase.getId()).eq("belong", ProjectUserLocationEnum.PROJECT_ADD_STUDIO.getValue()); + projectUserPermissionService.remove(delStudioPermission); + //删除当前项目certification engineer项目权限 + QueryWrapper delCertificationPermission = new QueryWrapper<>(); + delCertificationPermission.eq("project_id", projectLibraryBase.getId()).eq("belong", ProjectUserLocationEnum.PROJECT_ADD_CERTIFICATION.getValue()); + projectUserPermissionService.remove(delCertificationPermission); + + /*// 初始化当前项目的studio与项目库 角色关系 + ProjectLibraryRoleRelEO projectLibraryRoleRelEO = new ProjectLibraryRoleRelEO(); + projectLibraryRoleRelEO.setProjectLibraryId(projectLibraryBase.getId()); + projectLibraryRoleRelEO.setUserId(projectLibraryBase.getStudioEngineer()); + projectLibraryRoleRelEO.setRoleCode(ProjectRoleEnum.STUDIO_ENGINEER.getValue()); + projectLibraryRoleRelEOService.add(projectLibraryRoleRelEO);*/ + + List projectLibraryRoleRelEOList = new ArrayList<>(); + //初始化当前项目的studio与项目库 法规清单 角色关系 + ProjectLibraryRoleRelEO lawsInventoryRoleRelEO = new ProjectLibraryRoleRelEO(); + lawsInventoryRoleRelEO.setProjectLibraryId(projectLibraryBase.getId()); + lawsInventoryRoleRelEO.setUserId(projectLibraryBase.getStudioEngineer()); + lawsInventoryRoleRelEO.setRoleCode(ProjectRoleEnum.STUDIO_ENGINEER.getValue()); + lawsInventoryRoleRelEO.setModelType(RoleRelModelTypeEnum.LAWS_INVENTORY.getValue()); + projectLibraryRoleRelEOList.add(lawsInventoryRoleRelEO); + + // 初始化当前项目的studio与项目库 认证清单 角色关系 + ProjectLibraryRoleRelEO certificationInventoryRoleRelEO = new ProjectLibraryRoleRelEO(); + certificationInventoryRoleRelEO.setProjectLibraryId(projectLibraryBase.getId()); + certificationInventoryRoleRelEO.setUserId(projectLibraryBase.getStudioEngineer()); + certificationInventoryRoleRelEO.setRoleCode(ProjectRoleEnum.STUDIO_ENGINEER.getValue()); + certificationInventoryRoleRelEO.setModelType(RoleRelModelTypeEnum.CERTIFICATION_INVENTORY.getValue()); + projectLibraryRoleRelEOList.add(certificationInventoryRoleRelEO); + this.projectLibraryRoleRelEOService.saveBatch(projectLibraryRoleRelEOList); + + //重新设置当前项目studio项目权限 + List engineers = new ArrayList<>(); + ProjectUserPermission studioPermission = new ProjectUserPermission(); + studioPermission.setProjectId(projectLibraryBase.getId()); + studioPermission.setUserId(projectLibraryBase.getStudioEngineer()); + studioPermission.setBelong(ProjectUserLocationEnum.PROJECT_ADD_STUDIO.getValue()); + studioPermission.setCreateTime(now); + studioPermission.setUpdateTime(now); + engineers.add(studioPermission); + //重新设置当前项目certification engineer项目权限 + if (ObjectUtils.isNotEmpty(projectLibraryBase.getCertificationEngineer())) { + for (String certificationEngineer : projectLibraryBase.getCertificationEngineer().split(",")) { + ProjectUserPermission certificationPermission = new ProjectUserPermission(); + certificationPermission.setProjectId(projectLibraryBase.getId()); + certificationPermission.setUserId(certificationEngineer); + certificationPermission.setBelong(ProjectUserLocationEnum.PROJECT_ADD_CERTIFICATION.getValue()); + certificationPermission.setCreateTime(now); + certificationPermission.setUpdateTime(now); + engineers.add(certificationPermission); + } + } + if (ObjectUtils.isNotEmpty(engineers)) { + projectUserPermissionService.saveBatch(engineers); + } + + //编辑时如果认证工程师发生变化,同步修改相关人员名单中的认证工程师 + List result = projectRelatedPersonnelMapper.queryPageList(projectLibraryBase.getId(), + DictCodeEnum.DUTY_TERRITORY.getValue(), null, null, null, null,null); + //项目的认证工程师 + String certificationEngineer = projectLibraryBase.getCertificationEngineer(); + //一个都不选的情况下 + if ("".equals(certificationEngineer)) { + //删除当前项目的相关人员名单中认证工程师权限 + QueryWrapper delWrapper = new QueryWrapper<>(); + delWrapper.eq("project_id", projectLibraryBase.getId()) + .eq("belong", ProjectUserLocationEnum.PROJECT_DETAIL_RELEVANT_PERSONNEL_CERTIFICATION.getValue()); + projectUserPermissionService.remove(delWrapper); + //删除当前项目的法规清单中认证工程师权限 + QueryWrapper delLawInventoryWrapper = new QueryWrapper<>(); + delLawInventoryWrapper.eq("project_id", projectLibraryBase.getId()) + .eq("belong", ProjectUserLocationEnum.PROJECT_LAWS_INVENTORY_HOMOLOGATION.getValue()); + projectUserPermissionService.remove(delLawInventoryWrapper); + } + //选择了其他工程师 + if(StringUtils.isNotBlank(certificationEngineer)){ + if(StringUtils.isNotEmpty(original.getCertificationEngineer())){ + for (String id : original.getCertificationEngineer().split(",")) { + if (!certificationEngineer.contains(id)) { + //如果原来的认证工程师被删除了，则需要同步删除当前项目的相关人员名单中该认证工程师权限 + QueryWrapper delWrapper = new QueryWrapper<>(); + delWrapper.eq("project_id", projectLibraryBase.getId()).eq("user_id",id). + eq("belong", ProjectUserLocationEnum.PROJECT_DETAIL_RELEVANT_PERSONNEL_CERTIFICATION.getValue()); + projectUserPermissionService.remove(delWrapper); + //如果原来的认证工程师被删除了，则需要同步删除当前项目的法规清单中该认证工程师权限 + QueryWrapper delLawInventoryWrapper = new QueryWrapper<>(); + delLawInventoryWrapper.eq("project_id", projectLibraryBase.getId()).eq("user_id",id). + eq("belong", ProjectUserLocationEnum.PROJECT_LAWS_INVENTORY_HOMOLOGATION.getValue()); + projectUserPermissionService.remove(delLawInventoryWrapper); + } + } + } + + + for (ProjectRelatedPersonnel projectRelatedPersonnel : result) { + //相关人员名单的认证工程师 + String certificationEngineerTemp = projectRelatedPersonnel.getCertificationEngineer(); + if(StringUtils.isNotBlank(certificationEngineerTemp)){ + StringBuilder sb = new StringBuilder(); + for (String s : certificationEngineerTemp.split(",")) { + if(certificationEngineer.contains(s)){ + sb.append(s + ","); + } + } + String substring = ""; + if(StringUtils.isNotBlank(sb)){ + substring = sb.substring(0, sb.length() - 1); + } + projectRelatedPersonnel.setCertificationEngineer(substring); + } + } + //批量修改相关人员名单信息中的认证工程师 + projectRelatedPersonnelService.updateBatchById(result); + } + /** + *法规清单发起任务前或任务结束后修改studio或者修改认证工程师时， + *如果设计符合性确认、Pre-Homo确认、 验证符合性确认中的发起人跟责任人引用到了这两人， + *而且这两个人不属于相关人员名单的工程接口人和法规工程师,同步删除这两人的权限 + */ + + List belongs = new ArrayList<>(); + belongs.add(ProjectUserLocationEnum.PROJECT_LAWS_INVENTORY_DESIGN_INITIATOR.getValue()); + belongs.add(ProjectUserLocationEnum.PROJECT_LAWS_INVENTORY_DESIGN_DUTY.getValue()); + belongs.add(ProjectUserLocationEnum.PROJECT_LAWS_INVENTORY_PREHOMO_INITIATOR.getValue()); + belongs.add(ProjectUserLocationEnum.PROJECT_LAWS_INVENTORY_PREHOMO_DUTY.getValue()); + belongs.add(ProjectUserLocationEnum.PROJECT_LAWS_INVENTORY_VERIFY_INITIATOR.getValue()); + belongs.add(ProjectUserLocationEnum.PROJECT_LAWS_INVENTORY_VERIFY_DUTY.getValue()); + + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.eq("project_library_id", projectLibraryBase.getId()); + List list = projectLawsInventoryEOService.list(queryWrapper); + if (ObjectUtils.isNotEmpty(list)) { + for (ProjectLawsInventoryEO lawsInventoryEO : list) { + boolean boo = false; + //发起任务前 + if (TaskAffirmStatusEnum.NOT_STARTED.getValue().equals(lawsInventoryEO.getTaskAffirmStatus())) { + boo = true; + } + //任务结束后 + if (!boo) { + int count = 0; + QueryWrapper taskInventoryQueryWrapper = new QueryWrapper<>(); + taskInventoryQueryWrapper.eq("project_laws_inventory_id",lawsInventoryEO.getId()); + List taskInventoryRecords = projectTaskInventoryEOMapper.selectList(taskInventoryQueryWrapper); + for (ProjectTaskInventoryEO taskInventoryRecord : taskInventoryRecords) { + String designStatus = taskInventoryRecord.getDesignStatus(); + String verifyStatus = taskInventoryRecord.getVerifyStatus(); + String prehomoStatus = taskInventoryRecord.getPrehomoStatus(); + boolean designStatusFlag = StringUtils.isBlank(designStatus) || designStatus.equals(DesignComplianceStatusEnum.REVIEW_COMPLETED.getValue()); + boolean verifyStatusFlag = StringUtils.isBlank(verifyStatus) || verifyStatus.equals(DesignComplianceStatusEnum.REVIEW_COMPLETED.getValue()); + boolean prehomoStatusFlag = StringUtils.isBlank(prehomoStatus) || prehomoStatus.equals(DesignComplianceStatusEnum.REVIEW_COMPLETED.getValue()); + if (designStatusFlag && verifyStatusFlag && prehomoStatusFlag) { + count++; + } + } + if (count == 3) { + boo = true; + } + } + if (boo) { + QueryWrapper personnelQueryWrapper = new QueryWrapper<>(); + personnelQueryWrapper.eq("duty_territory", lawsInventoryEO.getDutyTerritory()).eq("project_id", projectLibraryBase.getId()); + List personnels = projectRelatedPersonnelService.list(personnelQueryWrapper); + + if (!original.getStudioEngineer().equals(projectLibraryBase.getStudioEngineer())) { + StringBuilder participator = new StringBuilder(); + if (ObjectUtils.isNotEmpty(personnels)) { + if (ObjectUtils.isNotEmpty(personnels.get(0).getLawEngineer())) { + participator.append(personnels.get(0).getLawEngineer() + ","); + } + if (ObjectUtils.isNotEmpty(personnels.get(0).getCertificationEngineer())) { + participator.append(personnels.get(0).getCertificationEngineer() + ","); + } + if (ObjectUtils.isNotEmpty(personnels.get(0).getEngineeringInterfacePerson())) { + participator.append(personnels.get(0).getEngineeringInterfacePerson() + ","); + } + } + if (!participator.toString().contains(original.getStudioEngineer())) { + //删除当前studio在法规清单中的人员权限 + QueryWrapper del = new QueryWrapper<>(); + del.eq("project_id", projectLibraryBase.getId()).eq("user_id", original.getStudioEngineer()).in("belong",belongs). + eq("description", PermissionDescriptionEnum.PROJECT_LAWS_INVENTORY.getValue() + lawsInventoryEO.getId()); + projectUserPermissionService.remove(del); + } + } + if (ObjectUtils.isNotEmpty(original.getCertificationEngineer())) { + for (String id : original.getCertificationEngineer().split(",")) { + if (!certificationEngineer.contains(id)) { + StringBuilder participator = new StringBuilder(); + if (ObjectUtils.isNotEmpty(personnels)) { + if (ObjectUtils.isNotEmpty(personnels.get(0).getLawEngineer())) { + participator.append(personnels.get(0).getLawEngineer() + ","); + } + if (ObjectUtils.isNotEmpty(personnels.get(0).getEngineeringInterfacePerson())) { + participator.append(personnels.get(0).getEngineeringInterfacePerson() + ","); + } + } + participator.append(original.getStudioEngineer()); + if (!participator.toString().contains(id)) { + //删除当前studio在法规清单中的人员权限 + QueryWrapper del = new QueryWrapper<>(); + del.eq("project_id", projectLibraryBase.getId()).eq("user_id", id).in("belong",belongs). + eq("description", PermissionDescriptionEnum.PROJECT_LAWS_INVENTORY.getValue() + lawsInventoryEO.getId()); + projectUserPermissionService.remove(del); + } + } + } + } + } + } + } + + } + + /** + * 编辑认证工程师逻辑处理 + * @param newPlbEO + * @param oldPlbEO + */ + private void editCertificationEngineer(ProjectLibraryBase newPlbEO, ProjectLibraryBase oldPlbEO) { + List oldCertificationEngineerIdList = Arrays.asList(oldPlbEO.getCertificationEngineer().split(",")); + List newCertificationEngineerIdList = Arrays.asList(newPlbEO.getCertificationEngineer().split(",")); + + oldCertificationEngineerIdList = oldCertificationEngineerIdList.stream().filter(originalCertificationEngineerId -> { + boolean flag = true; + for (String newCertificationEngineerId : newCertificationEngineerIdList) { + // 如果新传进来的 认证工程师id跟现有的认证工程师id一致，不用发消息 + if(StringUtils.equals(newCertificationEngineerId,originalCertificationEngineerId)){ + flag = false; + break; + } + } + return flag; + }).collect(Collectors.toList()); + + if(CollectionUtils.isNotEmpty(oldCertificationEngineerIdList)){ + // 判断当前项目下是否还有需要认证工程师操作的数据 只有清单待校核、结果待审查 这两个状态的数据由认证工程师操作。 + List flowStatusList = new ArrayList<>(); + flowStatusList.add(CertificationInventoryFlowStatusEnum.LIST_TO_BE_CHECKED.getValue()); + flowStatusList.add(CertificationInventoryFlowStatusEnum.RESULTS_TO_BE_REVIEWED.getValue()); + + QueryWrapper certificationInventoryEOQueryWrapper = new QueryWrapper<>(); + certificationInventoryEOQueryWrapper.lambda().eq(ProjectCertificationInventoryEO::getProjectLibraryId, newPlbEO.getId()); + certificationInventoryEOQueryWrapper.lambda().in(ProjectCertificationInventoryEO::getFlowStatus,flowStatusList); + List projectCertificationInventoryEOList = this.projectCertificationInventoryEOService.list(certificationInventoryEOQueryWrapper); + if(CollectionUtils.isNotEmpty(projectCertificationInventoryEOList)){ + this.projectCertificationInventoryEOService.certificationInventoryEOListSortByEndTimeAsc(projectCertificationInventoryEOList); + List userInfoList = this.sysUserService.querySysUserListByIdList(oldCertificationEngineerIdList); + this.projectCertificationInventoryEOService.sendMessageByTemplateId( + projectCertificationInventoryEOList, + TemplateInfoEnum2.CERTIFICATION_MESSAGE13.getValue(), + oldCertificationEngineerIdList, + userInfoList, + projectCertificationInventoryEOList.get(0).getEndTime(),"" + ); + } + } + + this.setRzlcCertificationEngineerTask(newPlbEO); + } + + /** + * 重新设置认证工程师在待办中心的 认证流程的 待办任务。 + * @param projectLibraryBase + */ + private void setRzlcCertificationEngineerTask(ProjectLibraryBase projectLibraryBase) { + if(org.apache.commons.lang3.StringUtils.isNotEmpty(projectLibraryBase.getCertificationEngineer())){ + List certificationEngineerIdList = Arrays.asList(projectLibraryBase.getCertificationEngineer().split(",")); + QueryWrapper pciQueryWrap = new QueryWrapper<>(); + pciQueryWrap.lambda().eq(ProjectCertificationInventoryEO::getProjectLibraryId, projectLibraryBase.getId()); + List pciEOList = this.projectCertificationInventoryEOService.list(pciQueryWrap); + + if(CollectionUtils.isNotEmpty(pciEOList)){ + // 清单待校核的数据 + List pciToBeCheckedList = pciEOList.stream().filter(pci -> { + boolean flag = false; + if(StringUtils.equals(pci.getFlowStatus(),CertificationInventoryFlowStatusEnum.LIST_TO_BE_CHECKED.getValue())){ + flag = true; + } + return flag; + }).collect(Collectors.toList()); + // 如果该项目下清单待校核的数据不为空，给这些认证工程师分配待办任务。 + if(CollectionUtils.isNotEmpty(pciToBeCheckedList)){ + // 删除待办中心（是这个项目库的 pre-Homo流程的待办任务， 认证工程师接受任务节点的数据） + QueryWrapper pidQueryWrap = new QueryWrapper<>(); + pidQueryWrap.lambda().eq(ProcessInfoDetailEO::getProcessInfoId, projectLibraryBase.getId()); + pidQueryWrap.lambda().eq(ProcessInfoDetailEO::getTaskDefinitionKey,CertificationFlowNodeEnum.RZGCSJSRW.getKey()); + pidQueryWrap.lambda().eq(ProcessInfoDetailEO::getFlowType,FlowTypeEnum.CERTIFICATION_LC.getValue()); + pidQueryWrap.orderByAsc("end_time"); + List pidEoList = this.processInfoDetailEOService.list(pidQueryWrap); + if(CollectionUtils.isNotEmpty(pidEoList)){ + List pidEoIdList = pidEoList.stream().map(ProcessInfoDetailEO::getId).distinct().collect(Collectors.toList()); + this.processInfoDetailEOService.deleteByIds(pidEoIdList); + } + + // 获取责任确认截止时间 最早的时间 + this.projectCertificationInventoryEOService.certificationInventoryEOListSortByTaskConfirmEndTimeAsc(pciToBeCheckedList); + Date endTime = pciToBeCheckedList.get(0).getInventoryVerifyEndTime(); + if(ObjectUtils.isEmpty(endTime)){ + endTime = pidEoList.get(0).getEndTime(); + } + + // 给认证工程师分配任务 + List processInfoDetailEOList = new ArrayList<>(); + for (String userId : certificationEngineerIdList) { + ProcessInfoDetailEO processInfoDetailEO = new ProcessInfoDetailEO(); + processInfoDetailEO.setUserId(userId); + processInfoDetailEO.setTaskDefinitionKey(CertificationFlowNodeEnum.RZGCSJSRW.getKey()); + processInfoDetailEO.setCreateTime(new Date()); + processInfoDetailEO.setStatus(TaskStatusEnum.NOT_DONE.getValue()); + processInfoDetailEO.setProcessInfoId(projectLibraryBase.getId()); + processInfoDetailEO.setActiProcInstId(projectLibraryBase.getId()); + processInfoDetailEO.setFlowType(FlowTypeEnum.CERTIFICATION_LC.getValue()); + processInfoDetailEO.setEndTime(endTime); + processInfoDetailEOList.add(processInfoDetailEO); + } + this.processInfoDetailEOService.saveBatch(processInfoDetailEOList); + } + + // 结果待提交的数据 + List pciToBeReviewEDList = pciEOList.stream().filter(pci -> { + boolean flag = false; + if(StringUtils.equals(pci.getFlowStatus(),CertificationInventoryFlowStatusEnum.RESULTS_TO_BE_REVIEWED.getValue())){ + flag = true; + } + return flag; + }).collect(Collectors.toList()); + + if(CollectionUtils.isNotEmpty(pciToBeReviewEDList)){ + // 删除待办中心（是这个项目库的 pre-Homo流程的待办任务， 认证工程师审查 任务节点的数据） + QueryWrapper pidQueryWrap = new QueryWrapper<>(); + pidQueryWrap.lambda().eq(ProcessInfoDetailEO::getProcessInfoId, projectLibraryBase.getId()); + pidQueryWrap.lambda().eq(ProcessInfoDetailEO::getTaskDefinitionKey,CertificationFlowNodeEnum.RZGCSSC.getKey()); + pidQueryWrap.lambda().eq(ProcessInfoDetailEO::getFlowType,FlowTypeEnum.CERTIFICATION_LC.getValue()); + pidQueryWrap.orderByAsc("end_time"); + List pidEoList = this.processInfoDetailEOService.list(pidQueryWrap); + + // 获取截止日期最早的一天。 + this.projectCertificationInventoryEOService.certificationInventoryEOListSortByEndTimeAsc(pciToBeReviewEDList); + Date endTime = pciToBeReviewEDList.get(0).getEndTime(); + if(CollectionUtils.isNotEmpty(pidEoList)){ + endTime = pidEoList.get(0).getEndTime(); + + List pidEoIdList = pidEoList.stream().map(ProcessInfoDetailEO::getId).distinct().collect(Collectors.toList()); + this.processInfoDetailEOService.deleteByIds(pidEoIdList); + } + + // 给认证工程师分配任务 + List processInfoDetailEOList = new ArrayList<>(); + for (String userId : certificationEngineerIdList) { + ProcessInfoDetailEO processInfoDetailEO = new ProcessInfoDetailEO(); + processInfoDetailEO.setUserId(userId); + processInfoDetailEO.setTaskDefinitionKey(CertificationFlowNodeEnum.RZGCSSC.getKey()); + processInfoDetailEO.setCreateTime(new Date()); + processInfoDetailEO.setStatus(TaskStatusEnum.NOT_DONE.getValue()); + processInfoDetailEO.setProcessInfoId(projectLibraryBase.getId()); + processInfoDetailEO.setActiProcInstId(projectLibraryBase.getId()); + processInfoDetailEO.setFlowType(FlowTypeEnum.CERTIFICATION_LC.getValue()); + processInfoDetailEO.setEndTime(endTime); + processInfoDetailEOList.add(processInfoDetailEO); + } + this.processInfoDetailEOService.saveBatch(processInfoDetailEOList); + } + } + } + } + + /** + * 通过id删除 + * + * @param id + * @return + */ + @Override + public void deleteById(String id,String cut) { + checkData(id,cut); + + // 关联删除项目下的所有收集清单 + paramsManifestEOService.deleteByProjectId(id); + + //删除主项目 + removeById(id); + + //删除子项目 + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(ProjectLibraryBase::getParentId,id); + List list = this.list(wrapper); + if(ObjectUtils.isNotEmpty(list)){ + List idList = list.stream().map(ProjectLibraryBase::getId).collect(Collectors.toList()); + this.removeByIds(idList); + } + + //关联删除-相关人员 + QueryWrapper relatedPersonnelQueryWrapper = new QueryWrapper<>(); + relatedPersonnelQueryWrapper.eq("project_id",id); + projectRelatedPersonnelService.remove(relatedPersonnelQueryWrapper); + + //关联删除-任务计划时间轴 + QueryWrapper taskPlanningQueryWrapper = new QueryWrapper<>(); + taskPlanningQueryWrapper.eq("project_id",id); + projectTaskPlanningService.remove(taskPlanningQueryWrapper); + + //关联删除-法规清单 + QueryWrapper lawsInventoryEOQueryWrapper = new QueryWrapper<>(); + lawsInventoryEOQueryWrapper.eq("project_library_id ",id); + projectLawsInventoryEOService.remove(lawsInventoryEOQueryWrapper); + + //关联删除-法规清单log + QueryWrapper logEOQueryWrapper = new QueryWrapper<>(); + logEOQueryWrapper.in("project_library_id",id); + projectLawsInventoryLogEOService.remove(logEOQueryWrapper); + + //删除权限 + QueryWrapper permissionQueryWrapper = new QueryWrapper<>(); + permissionQueryWrapper.eq("project_id", id); + projectUserPermissionService.remove(permissionQueryWrapper); + } + + /* + * 判断是否可以删除 + */ + @Override + public void checkData(String id, String cut) { + //判断该条项目是否是自己创建,如果不是则不能删除 + LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); + List projectLibraryBases = this.queryById(id,null); + //管理员和创建人可以删除,其余人不能删除 + boolean administrator = sysUserService.isAdministrator(); + if(!loginUser.getUsername().equals(projectLibraryBases.get(0).getCreateBy()) && !administrator){ + if(CutEnum.CN.getValue().equals(cut)){ + throw new JeroBootException("该条项目非本人创建,不能删除"); + }else{ + throw new JeroBootException("This item is not created by myself and cannot be deleted"); + } + } + QueryWrapper lawsInventoryQueryWrapper = new QueryWrapper<>(); + lawsInventoryQueryWrapper.eq("project_library_id",id); + List lawsInventoryRecords = projectLawsInventoryEOMapper.selectList(lawsInventoryQueryWrapper); + for(ProjectLawsInventoryEO projectLawsInventoryEO : lawsInventoryRecords){ + String inventoryAffirmStatus = projectLawsInventoryEO.getInventoryAffirmStatus();//清单确认状态 + //清单确认状态(未发起、接受、拒绝） + boolean inventoryAffirmFlag = ( + org.apache.commons.lang3.StringUtils.equals(inventoryAffirmStatus,TaskAffirmStatusEnum.NOT_STARTED.getValue()) || + org.apache.commons.lang3.StringUtils.equals(inventoryAffirmStatus,TaskAffirmStatusEnum.ACCEPTED.getValue()) || + org.apache.commons.lang3.StringUtils.equals(inventoryAffirmStatus,TaskAffirmStatusEnum.REJECTED.getValue()) + ); + + String taskAffirmStatus = projectLawsInventoryEO.getTaskAffirmStatus();//任务确认状态 + //任务确认状态(未发起、接受、拒绝) + boolean taskAffirmFlag = ( + org.apache.commons.lang3.StringUtils.equals(taskAffirmStatus,TaskAffirmStatusEnum.NOT_STARTED.getValue()) || + org.apache.commons.lang3.StringUtils.equals(taskAffirmStatus,TaskAffirmStatusEnum.ACCEPTED.getValue()) || + org.apache.commons.lang3.StringUtils.equals(taskAffirmStatus,TaskAffirmStatusEnum.REJECTED.getValue()) + ); + + if (!(inventoryAffirmFlag && taskAffirmFlag)) { + if (CutEnum.CN.getValue().equals(cut)) { + throw new JeroBootException("当前项目下有未走完的流程，不能删除"); + }else{ + throw new JeroBootException("There are unfinished processes under the current project and cannot be deleted."); + } + } + + String lawsInventoryId = projectLawsInventoryEO.getId(); + + QueryWrapper taskInventoryQueryWrapper = new QueryWrapper<>(); + taskInventoryQueryWrapper.eq("project_laws_inventory_id",lawsInventoryId); + List taskInventoryRecords = projectTaskInventoryEOMapper.selectList(taskInventoryQueryWrapper); + //设计、验证、prehomo流程（流程状态是空 或 审查完成） + for(ProjectTaskInventoryEO projectTaskInventoryEO : taskInventoryRecords){ + String designStatus = projectTaskInventoryEO.getDesignStatus(); + String verifyStatus = projectTaskInventoryEO.getVerifyStatus(); + String prehomoStatus = projectTaskInventoryEO.getPrehomoStatus(); + + boolean designStatusFlag = StringUtils.isBlank(designStatus) || designStatus.equals(DesignComplianceStatusEnum.REVIEW_COMPLETED.getValue()); + boolean verifyStatusFlag = StringUtils.isBlank(verifyStatus) || verifyStatus.equals(DesignComplianceStatusEnum.REVIEW_COMPLETED.getValue()); + boolean prehomoStatusFlag = StringUtils.isBlank(prehomoStatus) || prehomoStatus.equals(DesignComplianceStatusEnum.REVIEW_COMPLETED.getValue()); + + if (!(designStatusFlag && verifyStatusFlag && prehomoStatusFlag)) { + if (CutEnum.CN.getValue().equals(cut)) { + throw new JeroBootException("当前项目下有未走完的流程，不能删除"); + }else{ + throw new JeroBootException("There are unfinished processes under the current project and cannot be deleted."); + } + } + } + } + } + /** + * 批量删除 + * + * @param ids + * @return + */ + @Override + public void deleteByIds(List ids,String cut) { + for(String id :ids){ + checkData(id,cut); + } + removeByIds(ids); + } + + /** + * 通过id查询 + * + * @param id + * @return + */ + @Override + public List queryById(String id,String cut) { + List records = projectLibraryBaseMapper.queryById(id); + disposeData(records,"",false); + //目标市场数据字典 + List targetMarketList = sysDictService.queryDictItemsByCode(DicCodeEnum.REGION.getCode()); + for(ProjectLibraryBase projectLibraryBase: records){ + //历史数据的主版本没有版本号,所以默认给00 + if(StringUtils.isBlank(projectLibraryBase.getParentId()) && StringUtils.isBlank(projectLibraryBase.getProjectVersion())){ + projectLibraryBase.setProjectVersion("00"); + } + //目标市场 + Map param = new HashMap<>(); + param.put("cut",cut); + String targetMarket = getMarket(param, targetMarketList, projectLibraryBase); + //主项目的版本号 + String projectVersion = ""; + if(StringUtils.isBlank(projectLibraryBase.getParentId())){ + projectVersion = "00"; + }else{ + projectVersion = projectLibraryBase.getProjectVersion(); + } + if(StringUtils.isNotBlank(projectLibraryBase.getYearName())){ + projectLibraryBase.setProjectName(projectLibraryBase.getProjectName() + + "-" + projectLibraryBase.getYearName() + + "-" + targetMarket); +// projectLibraryBase.setProjectName(projectLibraryBase.getProjectName() +// + "-" + projectLibraryBase.getYearName() +// + "-" + targetMarket +// + "-" + projectVersion); + } + } + return records; + } + + /** + * 列表查询 + * + * @return + */ + @Override + public List getList(ProjectLibraryBase projectLibraryBase) { + List list = projectLibraryBaseMapper.getList(projectLibraryBase); + return list; + } + + /** + * 分页列表查询 + * + * @return + */ + @Override + public List queryPageList(Map params) { + LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); + Integer isViewer = sysRoleMapper.queryUserRoleByCode(ProjectRoleEnum.VIEWER.getName(), loginUser.getId()); + Set projectIds = new HashSet<>(); + //根据项目用户权限表筛选有权访问的项目 + Set permissionProjectIds = projectUserPermissionMapper.queryProjectIdsByUserId(loginUser.getId()); + if (ObjectUtils.isNotEmpty(permissionProjectIds)) { + projectIds.addAll(permissionProjectIds); + } + if (isViewer > 0) { + //如果是Viewer，根据配置的品牌筛选可访问的项目 + List brandTypes = projectUserBrandService.queryBrandByUserId(loginUser.getId()); + if (ObjectUtils.isNotEmpty(brandTypes)) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.in("brand",brandTypes); + if (ObjectUtils.isNotEmpty(list(queryWrapper))) { + projectIds.addAll(list(queryWrapper).stream().map(ProjectLibraryBase::getId).collect(Collectors.toSet())); + } + } + } + + List result = projectLibraryBaseMapper.queryPageList(params); + disposeData(result,"",false); + //目标市场 + List targetMarketList = sysDictService.queryDictItemsByCode(DicCodeEnum.REGION.getCode()); + + //置顶 + List idList = result.stream().map(ProjectLibraryBase::getId).collect(Collectors.toList()); + List topProjectEOList = new ArrayList<>(); + if(ObjectUtils.isNotEmpty(idList)){ + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.in(TopProjectEO::getCreateBy,loginUser.getUsername()).in(TopProjectEO::getProjectLibraryBaseId,idList).orderByDesc(TopProjectEO::getSort); + topProjectEOList = iTopProjectEOService.list(wrapper); + } + + for(ProjectLibraryBase projectLibraryBase: result){ + //置顶处理 + if(ObjectUtils.isNotEmpty(topProjectEOList)){ + List collect = topProjectEOList.stream() + .filter(e -> projectLibraryBase.getId().equals(e.getProjectLibraryBaseId()) + && loginUser.getUsername().equals(e.getCreateBy())) + .collect(Collectors.toList()); + if(ObjectUtils.isNotEmpty(collect)){ + projectLibraryBase.setFlag(collect.get(0).getFlag()); + projectLibraryBase.setSort(collect.get(0).getSort()); + }else{ + projectLibraryBase.setSort("0"); + } + }else{ + projectLibraryBase.setSort("0"); + } + //目标市场 + String targetMarket = getMarket(params, targetMarketList, projectLibraryBase); + //主项目的版本号 + String projectVersion = ""; + if(StringUtils.isBlank(projectLibraryBase.getParentId())){ + projectVersion = "00"; + }else{ + projectVersion = projectLibraryBase.getProjectVersion(); + } + if(StringUtils.isNotBlank(projectLibraryBase.getYearName())){ + projectLibraryBase.setProjectName(projectLibraryBase.getProjectName() + + "-" + projectLibraryBase.getYearName() + + "-" + targetMarket + + "-" + projectVersion); + } + } + + if(ObjectUtils.isEmpty(params.get("orderByField"))){ + Collections.sort(result, new Comparator() { + @Override + public int compare(ProjectLibraryBase o1, ProjectLibraryBase o2) { + return -o1.getSort().compareTo(o2.getSort()); + } + }); + } + + //所有主项目 + List projectLibraryBaseListParent = projectLibraryBaseMapper.queryMaimList(); + disposeData(projectLibraryBaseListParent,"",false); + for(ProjectLibraryBase projectLibraryBase: projectLibraryBaseListParent){ + //目标市场 + String targetMarket = getMarket(params, targetMarketList, projectLibraryBase); + //主项目的版本号 + String projectVersion = ""; + if(StringUtils.isBlank(projectLibraryBase.getParentId())){ + projectVersion = "00"; + }else{ + projectVersion = projectLibraryBase.getProjectVersion(); + } + if(StringUtils.isNotBlank(projectLibraryBase.getYearName())){ + projectLibraryBase.setProjectName(projectLibraryBase.getProjectName() + + "-" + projectLibraryBase.getYearName() + + "-" + targetMarket + + "-" + projectVersion); + } + } + + //项目名称模糊查询特殊处理(因为项目名称是多字段拼接的) + if(ObjectUtils.isNotEmpty(params.get("projectName"))){ + result = result.stream().filter(e->e.getProjectName().toLowerCase().contains(String.valueOf(params.get("projectName")).toLowerCase())).collect(Collectors.toList()); + } + List projectLibraryBaseParentList = result.stream().filter(e -> StringUtils.isBlank(e.getParentId())).distinct().collect(Collectors.toList()); + //处理搜索版本号,(因为列表展示数据是以主项目为主并绑定子项目, 所以搜索的时候只有子项目这种情况需要特殊处理) + List resultNew = getProjectLibraryBases(result, projectLibraryBaseListParent); + disposeData(resultNew,"",false); + + + //数据组装 +// List resultTemp = new LinkedList<>(); +// for (ProjectLibraryBase projectLibraryBase : result) { +// if(StringUtils.isBlank(projectLibraryBase.getParentId())){ +// resultTemp.add(projectLibraryBase); +// } +// } + + for (ProjectLibraryBase projectLibraryBase : projectLibraryBaseParentList) { + //子项目 + List children = result.stream() + .filter(e -> StringUtils.isNotBlank(e.getParentId()) && projectLibraryBase.getId().equals(e.getParentId())).collect(Collectors.toList()); + if(children.size() != 0){ + //子项目的基础上添加的子项目 + List childrenIdList = children.stream().map(ProjectLibraryBase::getId).distinct().collect(Collectors.toList()); + List childrenList = result.stream() + .filter(e -> StringUtils.isNotBlank(e.getParentId()) && childrenIdList.contains(e.getParentId())).collect(Collectors.toList()); + children.addAll(childrenList); + + //按版本排序 + Collections.sort(children); + projectLibraryBase.setChildren(children); + //最后一个版本号(主项目和主项目都需要设置) + String versionLast = children.get(children.size() - 1).getProjectVersion(); + //主版本设置最后一个版本号(用于项目扩展中的版本号) + projectLibraryBase.setVersionLast(versionLast); + for (ProjectLibraryBase child : children) { + //每个子版本版本设置最后一个版本号(用于项目扩展中的版本号) + child.setVersionLast(versionLast); + } + } + } + + List resultLast = new ArrayList<>(); + //权限筛选 + if (sysUserService.isAdministrator()) { + //管理员查看全部 + if(ObjectUtils.isNotEmpty(projectLibraryBaseParentList)){ + resultLast = projectLibraryBaseParentList; + }else{ + resultLast = resultNew; + } + } else { + for (ProjectLibraryBase projectLibraryBase : projectLibraryBaseParentList) { + //判断父项目是否有权限 + if (!projectIds.contains(projectLibraryBase.getId())) { + //判断子项目是否有权限 + List children = projectLibraryBase.getChildren(); + if (ObjectUtils.isNotEmpty(children)) { + for (ProjectLibraryBase child : children) { + //将有权限的放入最后返回的集合中 + if (projectIds.contains(child.getId())) { + resultLast.add(child); + } + } + } + } else { + List children = projectLibraryBase.getChildren(); + if (ObjectUtils.isNotEmpty(children)) { + List lastChild = new ArrayList<>(); + //判断子项目是否有权限 + for (ProjectLibraryBase child : children) { + if (projectIds.contains(child.getId())) { + lastChild.add(child); + } + } + projectLibraryBase.setChildren(lastChild); + } + resultLast.add(projectLibraryBase); + } + + } + } + //表头排序 + hearSort(params, resultLast); + return resultLast; + } + + private void hearSort(Map params, List resultLast) { + if(ObjectUtils.isNotEmpty(params.get("orderByField"))){ + Collator comparator = Collator.getInstance(Locale.CHINESE); + //项目名称，R&H Studio，车型平台，数字平台 + if("projectName".equals(params.get("orderByField"))){ + if(OrderEnum.POSITIVE.getValue().equals(params.get("orderBy"))){ + Collections.sort(resultLast,(e1, e2)->{ + return comparator.compare(e1.getProjectName(),e2.getProjectName()); + }); + }else if(OrderEnum.REVERSE.getValue().equals(params.get("orderBy"))){ + Collections.sort(resultLast,(e1,e2)->{ + return comparator.compare(e2.getProjectName(),e1.getProjectName()); + }); + } + } + //R&H Studio + if("studioEngineerName".equals(params.get("orderByField"))){ + if(OrderEnum.POSITIVE.getValue().equals(params.get("orderBy"))){ + Collections.sort(resultLast,(e1, e2)->{ + return comparator.compare(e1.getStudioEngineerName(),e2.getStudioEngineerName()); + }); + }else if(OrderEnum.REVERSE.getValue().equals(params.get("orderBy"))){ + Collections.sort(resultLast,(e1,e2)->{ + return comparator.compare(e2.getStudioEngineerName(),e1.getStudioEngineerName()); + }); + } + } + //车型平台 + if("vehiclePlatform".equals(params.get("orderByField"))){ + if(OrderEnum.POSITIVE.getValue().equals(params.get("orderBy"))){ + Collections.sort(resultLast,(e1, e2)->{ + return comparator.compare(e1.getVehiclePlatform(),e2.getVehiclePlatform()); + }); + }else if(OrderEnum.REVERSE.getValue().equals(params.get("orderBy"))){ + Collections.sort(resultLast,(e1,e2)->{ + return comparator.compare(e2.getVehiclePlatform(),e1.getVehiclePlatform()); + }); + } + } + //数字平台 + if("digitalPlatform".equals(params.get("orderByField"))){ + if(OrderEnum.POSITIVE.getValue().equals(params.get("orderBy"))){ + Collections.sort(resultLast,(e1, e2)->{ + return comparator.compare(e1.getDigitalPlatform(),e2.getDigitalPlatform()); + }); + }else if(OrderEnum.REVERSE.getValue().equals(params.get("orderBy"))){ + Collections.sort(resultLast,(e1,e2)->{ + return comparator.compare(e2.getDigitalPlatform(),e1.getDigitalPlatform()); + }); + } + } + } + } + + @NotNull + private List getProjectLibraryBases(List result, List projectLibraryBaseListParent) { + //result中的主项目以及子项目对应的主项目 + List resultParent = new LinkedList<>(); + for (ProjectLibraryBase projectLibraryBase : result) { + if(StringUtils.isBlank(projectLibraryBase.getParentId())){ + resultParent.add(projectLibraryBase); + }else{ + //子项目 + List collect = result.stream() + .filter(e -> projectLibraryBase.getId().equals(e.getParentId())) + .collect(Collectors.toList()); + if(ObjectUtils.isNotEmpty(collect)){ + resultParent.addAll(collect); + } + + } + } + + //搜索结果中子项目的子项目 + List resultChild = new ArrayList<>(); + //所有子项目 + List childrenListTemp = result.stream().filter(e -> StringUtils.isNotBlank(e.getParentId())).collect(Collectors.toList()); + List childrenIdListTemp = childrenListTemp.stream().map(ProjectLibraryBase::getId).collect(Collectors.toList()); + + //子项目的子项目 + List collect3 = result.stream().filter(e -> StringUtils.isNotBlank(e.getParentId()) && childrenIdListTemp.contains(e.getParentId())).collect(Collectors.toList()); + + if(ObjectUtils.isNotEmpty(collect3)){ + //子项目的子项目的父id + List childList = collect3.stream().map(ProjectLibraryBase::getParentId).collect(Collectors.toList()); + //子项目 + resultChild = childrenListTemp.stream().filter(e -> childList.contains(e.getId())).collect(Collectors.toList()); + } + + + //所有的主项目与通过筛选条件查询来的主项目进行过滤 + List resultNew = new LinkedList<>(); + //主项目 + List collect1 = result.stream().filter(e -> StringUtils.isBlank(e.getParentId())).collect(Collectors.toList()); + resultNew.addAll(collect1); + List projectLibraryBaseList = new ArrayList<>(); + for (ProjectLibraryBase projectLibraryBase : projectLibraryBaseListParent) { + List resultNewTemp = new ArrayList<>(); + //子项目 + List collect = result.stream().filter(e -> projectLibraryBase.getId().equals(e.getParentId())).collect(Collectors.toList()); + if(ObjectUtils.isNotEmpty(collect)){ + resultNewTemp.addAll(collect); + } + //子项目的子项目 + if(ObjectUtils.isNotEmpty(resultChild)){ + List collect2 = resultChild.stream().filter(e -> e.getParentId().equals(projectLibraryBase.getId())).collect(Collectors.toList()); + if(ObjectUtils.isNotEmpty(collect2)){ + resultNewTemp.addAll(collect2); + } + } + if(ObjectUtils.isNotEmpty(resultNewTemp)){ + projectLibraryBase.setChildren(resultNewTemp); + projectLibraryBaseList.add(projectLibraryBase); + } + } +// resultNew = resultNew.stream().distinct().collect(Collectors.toList()); + return projectLibraryBaseList; + } +// /** +// * 分页列表查询 +// * +// * @return +// */ +// @Override +// public List queryPageList(Map params) { +// List result = projectLibraryBaseMapper.queryPageList(params); +// disposeData(result,"",false); +// //目标市场 +// List targetMarketList = sysDictService.queryDictItemsByCode(DicCodeEnum.REGION.getCode()); +// +// for(ProjectLibraryBase projectLibraryBase: result){ +// //目标市场 +// String targetMarket = getMarket(params, targetMarketList, projectLibraryBase); +// //主项目的版本号 +// String projectVersion = ""; +// if(StringUtils.isBlank(projectLibraryBase.getParentId())){ +// projectVersion = "00"; +// }else{ +// projectVersion = projectLibraryBase.getProjectVersion(); +// } +// if(StringUtils.isNotBlank(projectLibraryBase.getYearName())){ +// projectLibraryBase.setProjectName(projectLibraryBase.getProjectName() +// + "-" + projectLibraryBase.getYearName() +// + "-" + targetMarket +// + "-" + projectVersion); +// } +// } +// //项目名称模糊查询特殊处理(因为项目名称是多字段拼接的) +// if(ObjectUtils.isNotEmpty(params.get("projectName"))){ +// result = result.stream().filter(e->e.getProjectName().toLowerCase().contains(String.valueOf(params.get("projectName")).toLowerCase())).collect(Collectors.toList()); +// } +// //数据组装 +// List resultTemp = new LinkedList<>(); +// for (ProjectLibraryBase projectLibraryBase : result) { +// if(StringUtils.isBlank(projectLibraryBase.getParentId())){ +// resultTemp.add(projectLibraryBase); +// } +// } +// +// for (ProjectLibraryBase projectLibraryBase : resultTemp) { +// //子项目 +// List children = result.stream() +// .filter(e -> StringUtils.isNotBlank(e.getParentId()) && projectLibraryBase.getId().equals(e.getParentId())).collect(Collectors.toList()); +// if(children.size() != 0){ +// //子项目的基础上添加的子项目 +// List childrenIdList = children.stream().map(ProjectLibraryBase::getId).distinct().collect(Collectors.toList()); +// List childrenList = result.stream() +// .filter(e -> StringUtils.isNotBlank(e.getParentId()) && childrenIdList.contains(e.getParentId())).collect(Collectors.toList()); +// children.addAll(childrenList); +// +// //按版本排序 +// Collections.sort(children); +// projectLibraryBase.setChildren(children); +// //最后一个版本号(主项目和主项目都需要设置) +// String versionLast = children.get(children.size() - 1).getProjectVersion(); +// //主版本设置最后一个版本号(用于项目扩展中的版本号) +// projectLibraryBase.setVersionLast(versionLast); +// for (ProjectLibraryBase child : children) { +// //每个子版本版本设置最后一个版本号(用于项目扩展中的版本号) +// child.setVersionLast(versionLast); +// } +// } +// } +// return resultTemp; +// } + + public String getMarket(Map params, List targetMarketList, ProjectLibraryBase projectLibraryBase) { + List dictModelList = new ArrayList<>(); + if(StringUtils.isNotBlank(projectLibraryBase.getTargetMarket())){ + for (String s : projectLibraryBase.getTargetMarket().split(",")) { + List dictModelListTemp = targetMarketList.stream() + .filter(e -> s.equals(e.getValue())).collect(Collectors.toList()); + dictModelList.addAll(dictModelListTemp); + } + } + String targetMarket = ""; + if(dictModelList.size() != 0){ + StringBuilder sb = new StringBuilder(); + for (DictModel dictModel : dictModelList) { + if(CutEnum.CN.getValue().equals(params.get("cut"))){ + sb.append(dictModel.getText()+","); + }else{ + sb.append(dictModel.getTextEn()+","); + } + } + if(StringUtils.isNotBlank(sb)){ + targetMarket = sb.substring(0,sb.length()-1); + } + } + return targetMarket; + } + + public Page getPages(Integer currentPage, Integer pageSize, List list){ + Page page =new Page(); + if(list==null){ + return null; + } + int size = list.size(); + if(pageSize > size){ + pageSize = size; + } + if(pageSize!=0){ + //求出最⼤页数，防⽌currentPage越界 + int maxPage = size % pageSize ==0? size / pageSize : size / pageSize +1; + if(currentPage > maxPage){ + currentPage = maxPage; + } + } + //当前页第⼀条数据的下标 + int curIdx = currentPage >1?(currentPage -1)* pageSize :0; + List pageList =new ArrayList(); + //将当前页的数据放进pageList + for(int i =0; i < pageSize && curIdx + i < size; i++){ + pageList.add(list.get(curIdx + i)); + } + page.setCurrent(currentPage).setSize(pageSize).setTotal(list.size()).setRecords(pageList); + return page; + } + + +// /** +// * 分页列表查询 +// * +// * @return +// */ +// @Override +// public IPage queryPageList(Map params) { +// Integer pageNo = Integer.parseInt(params.get("pageNo").toString()); +// Integer pageSize = Integer.parseInt(params.get("pageSize").toString()); +// IPage page = new Page(pageNo, pageSize); +// IPage result = projectLibraryBaseMapper.queryPageList(page, params); +// List records = result.getRecords(); +// disposeData(records,"",false); +// for(ProjectLibraryBase projectLibraryBase: records){ +// if(StringUtils.isNotBlank(projectLibraryBase.getYearName())){ +// projectLibraryBase.setProjectName(projectLibraryBase.getProjectName() + "-" + projectLibraryBase.getYearName()); +// } +// } +// return result; +// } + + @Override + public void disposeData(List records,String cut,boolean disposeTargetMarketFlag) { + List targetMarketList = sysDictService.queryDictItemsByCode(DicCodeEnum.REGION.getCode()); + for (ProjectLibraryBase projectLibraryBase : records) { + List sysUsers = new ArrayList<>(); + //认证工程师多个id查询 + if (StringUtils.isNotEmpty(projectLibraryBase.getCertificationEngineer())) { + List certificationEngineerIdList = Arrays.asList(projectLibraryBase.getCertificationEngineer().split(",")); + if (CollectionUtils.isNotEmpty(certificationEngineerIdList)) { + certificationEngineerIdList = certificationEngineerIdList.stream().distinct().collect(Collectors.toList()); + QueryWrapper userqueryWrapper = new QueryWrapper<>(); + userqueryWrapper.in("id ", certificationEngineerIdList); + sysUsers = sysUserMapper.selectList(userqueryWrapper); + } + + if (CollectionUtils.isNotEmpty(sysUsers)) { + String certificationEngineerId = projectLibraryBase.getCertificationEngineer(); + String certificationEngineerName = null; + StringBuilder certificationName = new StringBuilder(); + + for (String data : certificationEngineerIdList) { + if (StringUtils.isNotEmpty(certificationEngineerId)) { + certificationEngineerName = sysUsers.stream().filter(e -> data.equals(e.getId())) + .map(sysUser -> sysUser.getUsername()).collect(Collectors.joining(",")); + } + certificationName.append(certificationEngineerName).append(","); + } + if(StringUtils.isNotBlank(certificationName)){ + String substring = certificationName.substring(0, certificationName.length() - 1); + projectLibraryBase.setCertificationEngineerName(substring); + } + } + } + + if(disposeTargetMarketFlag){ + if(StringUtils.isNotEmpty(projectLibraryBase.getTargetMarket())){ + String targetMarketName = ""; + String[] targetMarketArr = projectLibraryBase.getTargetMarket().split(","); + if(StringUtils.equals(cut,CutEnum.EN.getValue())){ + targetMarketName = targetMarketList.stream().filter(targetMarket -> { + boolean flag = false; + for (String s : targetMarketArr) { + if (StringUtils.equals(s, targetMarket.getValue())) { + flag = true; + } + } + return flag; + }).map(DictModel::getTextEn).collect(Collectors.joining(",")); + }else { + targetMarketName = targetMarketList.stream().filter(targetMarket -> { + boolean flag = false; + for (String s : targetMarketArr) { + if (StringUtils.equals(s, targetMarket.getValue())) { + flag = true; + } + } + return flag; + }).map(DictModel::getText).collect(Collectors.joining(",")); + } + projectLibraryBase.setTargetMarketName(targetMarketName); + } + } + + } + } + + @Override + public Map getProjectDetailsStatistics(String id) { + Map result = new HashMap<>(); + + //当前项目状态 + Map currentProjectStatusMap = new HashMap<>(); + //清单确认 + Map listingToConfirmMap = new HashMap<>(); + //任务确认 + Map taskToConfirmMap = new HashMap<>(); + //设计符合性 + Map designComplianceMap = new HashMap<>(); + //prehomo确认 + Map prehomoMap = new HashMap<>(); + //验证符合性 + Map verifyComplianceMap = new HashMap<>(); + //认证进度 + Map certificationProgressMap = new HashMap<>(); + // 认证任务确认 + Map rzTaskToConfirmMap = new HashMap<>(); + + //清单确认统计 + /*List> listingToConfirmMapList = this.projectLawsInventoryEOMapper.getlistingToConfirmStatistics(id); + listingToConfirmMap.put("listingToConfirmMapList",listingToConfirmMapList); + result.put("listingToConfirmMap",listingToConfirmMap);*/ + + QueryWrapper lawsInventoryEOQueryWrapper = new QueryWrapper<>(); + lawsInventoryEOQueryWrapper.lambda().in(ProjectLawsInventoryEO::getProjectLibraryId,Arrays.asList(id.split(","))); + List projectLawsInventoryEOList = projectLawsInventoryEOMapper.selectList(lawsInventoryEOQueryWrapper); + if(CollectionUtils.isNotEmpty(projectLawsInventoryEOList)){ + List projectLawsInventoryIdList = projectLawsInventoryEOList.stream().distinct().map(ProjectLawsInventoryEO::getId).collect(Collectors.toList()); + + //任务确认统计 + List> taskToConfirmMapList = this.projectLawsInventoryEOService.getTaskToConfirmStatistics(projectLawsInventoryEOList); + int taskAffirmStatusCount = 0; + if(CollectionUtils.isNotEmpty(taskToConfirmMapList)){ + //taskAffirmStatusCount + for (Map taskToConfirm : taskToConfirmMapList) { + taskAffirmStatusCount += (int) taskToConfirm.get("taskAffirmStatusCount"); + } + } + taskToConfirmMap.put("taskToConfirmMapList",taskToConfirmMapList); + taskToConfirmMap.put("count",taskAffirmStatusCount); + result.put("taskToConfirmMap",taskToConfirmMap); + + //当前项目状态统计 获取一个 最差的结果 统计的数据 就是studio看到的数据。 + /*List> currentProjectStatusMapList = new ArrayList<>(); + CurrentProjectStatusEnum[] values = CurrentProjectStatusEnum.values(); + for (CurrentProjectStatusEnum value : values) { + Map map = new HashMap<>(); + map.put("color",value.getValue()); + currentProjectStatusMapList.add(map); + } + int currentProjectStatusTotal; + List projectStatusAssessList = this.conditionAssessmentEOService.getProjectStatusAssessList(projectLawsInventoryIdList); + + for (Map map : currentProjectStatusMapList) { + List collect = projectStatusAssessList.stream().filter( + projectStatusAssess -> StringUtils.equals(projectStatusAssess.getConditionAssessment(),map.get("color").toString()) + ).collect(Collectors.toList()); + map.put("conditionAssessmentCount",collect.size()); + } + + currentProjectStatusTotal = currentProjectStatusMapList.stream().filter( + currentProjectStatus -> Integer.parseInt(currentProjectStatus.get("conditionAssessmentCount").toString()) != 0 + ).mapToInt(currentProjectStatus -> Integer.parseInt(currentProjectStatus.get("conditionAssessmentCount").toString())).sum(); + + currentProjectStatusMap.put("currentProjectStatusMapList",currentProjectStatusMapList); + currentProjectStatusMap.put("currentProjectStatusTotal",currentProjectStatusTotal); + result.put("currentProjectStatusMap",currentProjectStatusMap);*/ + + //设计符合性 + List> designComplianceMapList = this.projectLawsInventoryEOService.getDesignComplianceStatistice(projectLawsInventoryEOList); + int designFlowTaskStatusCount = 0; + if(CollectionUtils.isNotEmpty(designComplianceMapList)){ + for (Map designCompliance : designComplianceMapList) { + designFlowTaskStatusCount += (int) designCompliance.get("designFlowTaskStatusCount"); + } + } + designComplianceMap.put("designComplianceMapList",designComplianceMapList); + designComplianceMap.put("count",designFlowTaskStatusCount); + result.put("designComplianceMap",designComplianceMap); + + //验证符合性 + List> verifyComplianceMapList = this.projectLawsInventoryEOService.getVerifyComplianceStatistice(projectLawsInventoryEOList); + int verifyFlowTaskStatusCount = 0; + if(CollectionUtils.isNotEmpty(verifyComplianceMapList)){ + for (Map verifyCompliance : verifyComplianceMapList) { + verifyFlowTaskStatusCount += (int) verifyCompliance.get("verifyFlowTaskStatusCount"); + } + } + verifyComplianceMap.put("verifyComplianceMapList",verifyComplianceMapList); + verifyComplianceMap.put("count",verifyFlowTaskStatusCount); + result.put("verifyComplianceMap",verifyComplianceMap); + + //认证进度统计 + /*int certificationProgressTotal; + List> certificationProgressMapList = this.projectTaskInventoryEOMapper.getCertificationProgressStatistics(projectLawsInventoryIdList); + certificationProgressTotal = certificationProgressMapList.stream().filter( + certificationProgress -> Integer.parseInt(certificationProgress.get("certificationProgressCount").toString()) != 0 + ).mapToInt(certificationProgress -> Integer.parseInt(certificationProgress.get("certificationProgressCount").toString())).sum(); + + CertificationProgressEnum[] CertificationProgressEnumValues = CertificationProgressEnum.values(); + for (CertificationProgressEnum certificationProgressEnumValue : CertificationProgressEnumValues) { + boolean flag = true; + for (Map map : certificationProgressMapList) { + if(map.get("certificationProgress") != null){ + if(StringUtils.equals(certificationProgressEnumValue.getValue(),map.get("certificationProgress").toString())){ + flag = false; + break; + } + } + } + if(flag){ + Map map = new HashMap<>(); + map.put("certificationProgress",certificationProgressEnumValue.getValue()); + map.put("certificationProgressCount",0); + certificationProgressMapList.add(map); + } + } + + certificationProgressMap.put("certificationProgressTotal",certificationProgressTotal); + certificationProgressMap.put("certificationProgressMapList",certificationProgressMapList); + result.put("certificationProgressMap",certificationProgressMap);*/ + } + + QueryWrapper pciQueryWrap = new QueryWrapper<>(); + pciQueryWrap.lambda().in(ProjectCertificationInventoryEO::getProjectLibraryId,Arrays.asList(id.split(","))); + List pciEoList = this.projectCertificationInventoryEOService.list(pciQueryWrap).stream().filter(pciEo -> { + boolean flag = false; + if (!StringUtils.equals(pciEo.getFlowStatus(), CertificationInventoryFlowStatusEnum.UNINVOLVED.getValue())) { + flag = true; + } + return flag; + }).distinct().collect(Collectors.toList()); + if(CollectionUtils.isNotEmpty(pciEoList)){ + // 认证清单-任务确认统计 + List> rzTaskToConfirmMapList = this.projectCertificationInventoryEOService.getTaskToConfirmStatistics(pciEoList); + int taskAffirmStatusCount = 0; + if(CollectionUtils.isNotEmpty(rzTaskToConfirmMapList)){ + for (Map rzTaskToConfirm : rzTaskToConfirmMapList) { + taskAffirmStatusCount += (int) rzTaskToConfirm.get("taskAffirmStatusCount"); + } + } + rzTaskToConfirmMap.put("rzTaskToConfirmMapList",rzTaskToConfirmMapList); + rzTaskToConfirmMap.put("count",taskAffirmStatusCount); + result.put("rzTaskToConfirmMap",rzTaskToConfirmMap); + + // Pre-Homo 统计 + List> prehomoMapList = this.projectCertificationInventoryEOService.getPrehomoStatistice(pciEoList); + int preHomoCount = 0; + if (CollectionUtils.isNotEmpty(prehomoMapList)) { + for (Map prehomo : prehomoMapList) { + preHomoCount += (int) prehomo.get("taskAffirmStatusCount"); + } + } + prehomoMap.put("prehomoMapList",prehomoMapList); + prehomoMap.put("count",preHomoCount); + result.put("prehomoMap",prehomoMap); + + // 认证进度 统计 + List> allMapList = this.projectCertificationInventoryEOService.getAllCertificationProgressStatistics(pciEoList); + List> carMapList = this.projectCertificationInventoryEOService.getCarCertificationProgressStatistics(pciEoList); + List> partMapList = this.projectCertificationInventoryEOService.getPartCertificationProgressStatistics(pciEoList); + certificationProgressMap.put("allMapList",allMapList);// 全部 + certificationProgressMap.put("carMapList",carMapList);// 整车 + certificationProgressMap.put("partMapList",partMapList);// 零部件 + int allCount = 0; + if(CollectionUtils.isNotEmpty(allMapList)){ + for (Map all : allMapList) { + allCount += (int) all.get("certificationProgressCount"); + } + } + int carCount = 0; + if(CollectionUtils.isNotEmpty(carMapList)){ + for (Map car : carMapList) { + carCount += (int) car.get("certificationProgressCount"); + } + } + int partCount = 0; + if(CollectionUtils.isNotEmpty(partMapList)){ + for (Map part : partMapList) { + partCount += (int) part.get("certificationProgressCount"); + } + } + + certificationProgressMap.put("allCount",allCount);// 全部 + certificationProgressMap.put("carCount",carCount);// 整车 + certificationProgressMap.put("partCount",partCount);// 零部件 + result.put("certificationProgressMap",certificationProgressMap); + } + + return result; + } +// @Override +// public Map getProjectDetailsStatistics(String id) { +// Map result = new HashMap<>(); +// +// //当前项目状态 +// Map currentProjectStatusMap = new HashMap<>(); +// //清单确认 +// Map listingToConfirmMap = new HashMap<>(); +// //任务确认 +// Map taskToConfirmMap = new HashMap<>(); +// //设计符合性 +// Map designComplianceMap = new HashMap<>(); +// //prehomo确认 +// Map prehomoMap = new HashMap<>(); +// //验证符合性 +// Map verifyComplianceMap = new HashMap<>(); +// //认证进度 +// Map certificationProgressMap = new HashMap<>(); +// +// //清单确认统计 +// List> listingToConfirmMapList = this.projectLawsInventoryEOMapper.getlistingToConfirmStatistics(id); +// listingToConfirmMap.put("listingToConfirmMapList",listingToConfirmMapList); +// result.put("listingToConfirmMap",listingToConfirmMap); +// +// //任务确认统计 +// List> taskToConfirmMapList = this.projectLawsInventoryEOMapper.getTaskToConfirmStatistics(id); +// taskToConfirmMap.put("taskToConfirmMapList",taskToConfirmMapList); +// result.put("taskToConfirmMap",taskToConfirmMap); +// +// QueryWrapper lawsInventoryEOQueryWrapper = new QueryWrapper<>(); +// lawsInventoryEOQueryWrapper.lambda().eq(ProjectLawsInventoryEO::getProjectLibraryId,id); +// //lawsInventoryEOQueryWrapper.lambda().eq(ProjectLawsInventoryEO::getInventoryAffirmStatus, InventoryAffirmStatusEnum.ACCEPTED.getValue()); +// //lawsInventoryEOQueryWrapper.lambda().eq(ProjectLawsInventoryEO::getTaskAffirmStatus, TaskAffirmStatusEnum.ACCEPTED.getValue()); +// List projectLawsInventoryEOList = projectLawsInventoryEOMapper.selectList(lawsInventoryEOQueryWrapper); +// if(CollectionUtils.isNotEmpty(projectLawsInventoryEOList)){ +// List projectLawsInventoryIdList = projectLawsInventoryEOList.stream().distinct().map(ProjectLawsInventoryEO::getId).collect(Collectors.toList()); +// +// //当前项目状态统计 获取一个 最差的结果 统计的数据 就是studio看到的数据。 +// List> currentProjectStatusMapList = new ArrayList<>(); +// CurrentProjectStatusEnum[] values = CurrentProjectStatusEnum.values(); +// for (CurrentProjectStatusEnum value : values) { +// Map map = new HashMap<>(); +// map.put("color",value.getValue()); +// currentProjectStatusMapList.add(map); +// } +// int currentProjectStatusTotal; +// List projectStatusAssessList = this.conditionAssessmentEOService.getProjectStatusAssessList(projectLawsInventoryIdList); +// +// for (Map map : currentProjectStatusMapList) { +// List collect = projectStatusAssessList.stream().filter( +// projectStatusAssess -> StringUtils.equals(projectStatusAssess.getConditionAssessment(),map.get("color").toString()) +// ).collect(Collectors.toList()); +// map.put("conditionAssessmentCount",collect.size()); +// } +// +// currentProjectStatusTotal = currentProjectStatusMapList.stream().filter( +// currentProjectStatus -> Integer.parseInt(currentProjectStatus.get("conditionAssessmentCount").toString()) != 0 +// ).mapToInt(currentProjectStatus -> Integer.parseInt(currentProjectStatus.get("conditionAssessmentCount").toString())).sum(); +// +// currentProjectStatusMap.put("currentProjectStatusMapList",currentProjectStatusMapList); +// currentProjectStatusMap.put("currentProjectStatusTotal",currentProjectStatusTotal); +// result.put("currentProjectStatusMap",currentProjectStatusMap); +// +// //设计符合性 +// List> designComplianceMapList = this.projectTaskInventoryEOMapper.getDesignComplianceStatistice(projectLawsInventoryIdList); +// designComplianceMap.put("designComplianceMapList",designComplianceMapList); +// result.put("designComplianceMap",designComplianceMap); +// +// //prehomo确认 +// List> prehomoMapList = this.projectTaskInventoryEOMapper.getPrehomoStatistice(projectLawsInventoryIdList); +// prehomoMap.put("prehomoMapList",prehomoMapList); +// result.put("prehomoMap",prehomoMap); +// +// //验证符合性 +// List> verifyComplianceMapList = this.projectTaskInventoryEOMapper.getVerifyComplianceStatistice(projectLawsInventoryIdList); +// verifyComplianceMap.put("verifyComplianceMapList",verifyComplianceMapList); +// result.put("verifyComplianceMap",verifyComplianceMap); +// +// //认证进度统计 +// int certificationProgressTotal; +// List> certificationProgressMapList = this.projectTaskInventoryEOMapper.getCertificationProgressStatistics(projectLawsInventoryIdList); +// certificationProgressTotal = certificationProgressMapList.stream().filter( +// certificationProgress -> Integer.parseInt(certificationProgress.get("certificationProgressCount").toString()) != 0 +// ).mapToInt(certificationProgress -> Integer.parseInt(certificationProgress.get("certificationProgressCount").toString())).sum(); +// +// CertificationProgressEnum[] CertificationProgressEnumValues = CertificationProgressEnum.values(); +// for (CertificationProgressEnum certificationProgressEnumValue : CertificationProgressEnumValues) { +// boolean flag = true; +// for (Map map : certificationProgressMapList) { +// if(map.get("certificationProgress") != null){ +// if(StringUtils.equals(certificationProgressEnumValue.getValue(),map.get("certificationProgress").toString())){ +// flag = false; +// break; +// } +// } +// } +// if(flag){ +// Map map = new HashMap<>(); +// map.put("certificationProgress",certificationProgressEnumValue.getValue()); +// map.put("certificationProgressCount",0); +// certificationProgressMapList.add(map); +// } +// } +// +// certificationProgressMap.put("certificationProgressTotal",certificationProgressTotal); +// certificationProgressMap.put("certificationProgressMapList",certificationProgressMapList); +// result.put("certificationProgressMap",certificationProgressMap); +// } +// +// return result; +// } + + /** + * 项目详情-统计接口-根据领域分组 + * @param params + * @return + */ + @Override + public Map getProjectDetailsStatisticsGroupByTerritory(Map params) { + String operatorType = (String) params.get("operatorType"); + String projectLibraryId = (String) params.get("projectLibraryId"); + if(StringUtils.isEmpty(projectLibraryId)){ + throw new JeroBootException("项目库id不能为空！"); + } + String cut = (String) params.get("cut"); + Map result = new HashMap<>(); + List> dataList = new ArrayList<>(); + + QueryWrapper lawsInventoryEOQueryWrapper = new QueryWrapper<>(); + lawsInventoryEOQueryWrapper.lambda().eq(ProjectLawsInventoryEO::getProjectLibraryId,projectLibraryId); + List projectLawsInventoryEOList = projectLawsInventoryEOMapper.selectList(lawsInventoryEOQueryWrapper); + + List sysDictItems = new ArrayList<>(); + // 法规清单所有的责任领域 + String pliDutyTerritoryStr = projectLawsInventoryEOList.stream().map(ProjectLawsInventoryEO::getDutyTerritory).collect(Collectors.joining(",")); + if (StringUtils.isNotEmpty(pliDutyTerritoryStr)) { + List pliDutyTerritoryList = Arrays.asList(pliDutyTerritoryStr.split(",")).stream().distinct().collect(Collectors.toList()); + sysDictItems = this.sysDictItemServiceImpl.selectItemsAll().stream().filter(sysDictItem -> { + boolean flag = false; + for (String pliDutyTerritory : pliDutyTerritoryList) { + if(StringUtils.equals(sysDictItem.getItemValue(),pliDutyTerritory)){ + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + } + + Map pliEoMap = new HashMap<>(); + + Map> firstLevelDutyTerritoryMapFG = this.sysDictItemServiceImpl.getFirstLevelSysDictItemByDictCode(DictCodeEnum.DUTY_TERRITORY.getValue(),sysDictItems); + if(ObjectUtils.isNotEmpty(firstLevelDutyTerritoryMapFG)){ + // 根据责任领域组装法规清单数据，后续计算使用 + for (Map.Entry> firstLevelMap : firstLevelDutyTerritoryMapFG.entrySet()) { + String key = firstLevelMap.getKey(); + List dutyTerritoryList = firstLevelMap.getValue(); + if(StringUtils.isEmpty(key) || CollectionUtils.isEmpty(dutyTerritoryList)){ + continue; + } + List pliEoList = projectLawsInventoryEOList.stream().filter(pliEo -> { + boolean flag = false; + for (SysDictItem dutyTerritory : dutyTerritoryList) { + if (StringUtils.contains(pliEo.getDutyTerritory(), dutyTerritory.getItemValue())) { + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + + JSONObject json = new JSONObject(); + json.put("dutyTerritoryList",dutyTerritoryList); + json.put("pliEoList",pliEoList); + pliEoMap.put(key,json); + } + } + String status = (String) params.get("status"); + if (CollectionUtils.isNotEmpty(projectLawsInventoryEOList)) { + for (Map.Entry pliMap : pliEoMap.entrySet()) { + String key = pliMap.getKey(); + JSONObject json = (JSONObject) pliMap.getValue(); + List pliEoList = (List) json.get("pliEoList"); + Map dataMaps = new HashMap<>(); + if(StringUtils.equals(OperatorTypeEnum.QUERY_FG_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + dataMaps = this.projectLibraryStatisticsService.getFGTaskToConfirmStatisticsGroupByTerritory(pliEoList,params); + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_DESIGN_STATISTICS.getValue(),operatorType)){ + dataMaps = this.projectLibraryStatisticsService.getDesignComplianceStatisticeGroupByTerritory(pliEoList,params); + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_VERIFY_STATISTICS.getValue(),operatorType)){ + dataMaps = this.projectLibraryStatisticsService.getVerifyComplianceStatisticeGroupByTerritory(pliEoList,params); + } + if(ObjectUtils.isEmpty(dataMaps)){ + continue; + } + Map dataMap = (Map) dataMaps.get(status); + double amount = (double) dataMap.get("amount"); + if(amount != 0){ + dataMap.put("dutyTerritoryName",key); + dataList.add(dataMap); + } + } + if(CollectionUtils.isNotEmpty(dataList)){ + this.projectDetailsStatisticsGroupByTerritoryHearSort(dataList,params); + result.put("dataList",dataList); + return result; + } +// if(StringUtils.equals(OperatorTypeEnum.QUERY_FG_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ +// if(ObjectUtils.isNotEmpty(pliEoMap)){ +// +// List> dataList = new ArrayList<>(); +// for (Map.Entry pliMap : pliEoMap.entrySet()) { +// String key = pliMap.getKey(); +// JSONObject json = (JSONObject) pliMap.getValue(); +// List pliEoList = (List) json.get("pliEoList"); +// Map dataMaps = this.projectLibraryStatisticsService.getFGTaskToConfirmStatisticsGroupByTerritory(pliEoList,params); +// Map dataMap = (Map) dataMaps.get(status); +// double amount = (double) dataMap.get("amount"); +// if(amount != 0){ +// dataMap.put("dutyTerritoryName",key); +// dataList.add(dataMap); +// } +// } +// result.put("dataList",dataList); +// } +// }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CURRENT_PROJECT_STATUS_STATISTICS.getValue(),operatorType)){ +// params.put("projectLawsInventoryIdList",projectLawsInventoryIdList); +// List> conditionAssessmentMapList = this.conditionAssessmentEOService.getProjectStatusAssessStatisticsGroupByTerritory(params); +// disposeData(conditionAssessmentMapList,cut); +// result.put("dataList",conditionAssessmentMapList); +// }else if(StringUtils.equals(OperatorTypeEnum.QUERY_LISTING_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ +// //清单确认 状态 +// String inventoryAffirmStatus = (String) params.get("inventoryAffirmStatus"); +// List> listingToConfirmList = this.projectLawsInventoryEOMapper.getListingToConfirmStatisticsGroupByTerritory(projectLibraryId,inventoryAffirmStatus); +// disposeData(listingToConfirmList,cut); +// result.put("dataList",listingToConfirmList); +// }else if(StringUtils.equals(OperatorTypeEnum.QUERY_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ +// //任务确认 状态 +// String taskAffirmStatus = (String) params.get("taskAffirmStatus"); +// List> taskToConfirmList = this.projectLawsInventoryEOMapper.getTaskToConfirmStatisticsGroupByTerritory(projectLibraryId,taskAffirmStatus); +// disposeData(taskToConfirmList,cut); +// result.put("dataList",taskToConfirmList); +// }else if(StringUtils.equals(OperatorTypeEnum.QUERY_DESIGN_STATISTICS.getValue(),operatorType)){ +// //设计符合性 +// List> dataList = new ArrayList<>(); +// for (Map.Entry pliMap : pliEoMap.entrySet()) { +// String key = pliMap.getKey(); +// JSONObject json = (JSONObject) pliMap.getValue(); +// List pliEoList = (List) json.get("pliEoList"); +// Map dataMaps = this.projectLibraryStatisticsService.getDesignComplianceStatisticeGroupByTerritory(pliEoList,params); +// Map dataMap = (Map) dataMaps.get(status); +// double amount = (double) dataMap.get("amount"); +// if(amount != 0){ +// dataMap.put("dutyTerritoryName",key); +// dataList.add(dataMap); +// } +// } +// result.put("dataList",dataList); +// }else if(StringUtils.equals(OperatorTypeEnum.QUERY_PREHOMO_STATISTICS.getValue(),operatorType)){ +// //prehomo确认 流程任务状态 +// String prehomoFlowTaskStatus = (String) params.get("prehomoFlowTaskStatus"); +// if(CollectionUtils.isNotEmpty(projectLawsInventoryIdList)){ +// List> prehomoList = this.projectTaskInventoryEOMapper.getPrehomoStatisticeGroupByTerritory(projectLawsInventoryIdList,prehomoFlowTaskStatus); +// disposeData(prehomoList,cut); +// result.put("dataList",prehomoList); +// } +// }else if(StringUtils.equals(OperatorTypeEnum.QUERY_VERIFY_STATISTICS.getValue(),operatorType)){ +// //验证符合性 流程任务状态 +// List> dataList = new ArrayList<>(); +// for (Map.Entry pliMap : pliEoMap.entrySet()) { +// String key = pliMap.getKey(); +// JSONObject json = (JSONObject) pliMap.getValue(); +// List pliEoList = (List) json.get("pliEoList"); +// Map dataMaps = this.projectLibraryStatisticsService.getVerifyComplianceStatisticeGroupByTerritory(pliEoList,params); +// Map dataMap = (Map) dataMaps.get(status); +// double amount = (double) dataMap.get("amount"); +// if(amount != 0){ +// dataMap.put("dutyTerritoryName",key); +// dataList.add(dataMap); +// } +// } +// result.put("dataList",dataList); +// }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS.getValue(),operatorType)){ +// //认证进度 流程任务状态 +// String certificationProgress = (String) params.get("certificationProgress"); +// +// if(CollectionUtils.isNotEmpty(projectLawsInventoryIdList)){ +// List> certificationProgressList = this.projectTaskInventoryEOMapper.getCertificationProgressStatisticsGroupByTerritory(projectLawsInventoryIdList,certificationProgress); +// disposeData(certificationProgressList,cut); +// result.put("dataList",certificationProgressList); +// } +// } + } + + Map pciEoMap = new HashMap<>(); + QueryWrapper pciQueryWrap = new QueryWrapper<>(); + pciQueryWrap.lambda().eq(ProjectCertificationInventoryEO::getProjectLibraryId,projectLibraryId); + List projectCertificationInventoryEOList = this.projectCertificationInventoryEOService.list(pciQueryWrap); + String pciDutyTerritoryStr = projectCertificationInventoryEOList.stream().map(ProjectCertificationInventoryEO::getDutyTerritory).collect(Collectors.joining(",")); + if (StringUtils.isNotEmpty(pciDutyTerritoryStr)) { + List pciDutyTerritoryList = Arrays.asList(pciDutyTerritoryStr.split(",")).stream().distinct().collect(Collectors.toList()); + sysDictItems = this.sysDictItemServiceImpl.selectItemsAll().stream().filter(sysDictItem -> { + boolean flag = false; + for (String pliDutyTerritory : pciDutyTerritoryList) { + if(StringUtils.equals(sysDictItem.getItemValue(),pliDutyTerritory)){ + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + } + Map> firstLevelDutyTerritoryMapRZ = this.sysDictItemServiceImpl.getFirstLevelSysDictItemByDictCode(DictCodeEnum.DUTY_TERRITORY.getValue(),sysDictItems); + if(ObjectUtils.isNotEmpty(firstLevelDutyTerritoryMapRZ)){ + // 根据责任领域组装法规清单数据，后续计算使用 + for (Map.Entry> firstLevelMap : firstLevelDutyTerritoryMapRZ.entrySet()) { + String key = firstLevelMap.getKey(); + List dutyTerritoryList = firstLevelMap.getValue(); + if(StringUtils.isEmpty(key) || CollectionUtils.isEmpty(dutyTerritoryList)){ + continue; + } + List pciEoList = projectCertificationInventoryEOList.stream().filter(pciEo -> { + boolean flag = false; + for (SysDictItem dutyTerritory : dutyTerritoryList) { + if (StringUtils.contains(pciEo.getDutyTerritory(), dutyTerritory.getItemValue())) { + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + + JSONObject json = new JSONObject(); + json.put("dutyTerritoryList",dutyTerritoryList); + json.put("pciEoList",pciEoList); + pciEoMap.put(key,json); + } + } + if (CollectionUtils.isNotEmpty(projectCertificationInventoryEOList) && ObjectUtils.isNotEmpty(pciEoMap)) { + for (Map.Entry pciMap : pciEoMap.entrySet()) { + String key = pciMap.getKey(); + JSONObject json = (JSONObject) pciMap.getValue(); + List pciEoList = (List) json.get("pciEoList"); + Map dataMaps = new HashMap<>(); + if(StringUtils.equals(OperatorTypeEnum.QUERY_RZ_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + dataMaps = this.projectLibraryStatisticsService.getRZTaskToConfirmStatisticsGroupByTerritory(pciEoList,params); + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_PREHOMO_STATISTICS.getValue(),operatorType)){ + dataMaps = this.projectLibraryStatisticsService.getPrehomoStatisticeGroupByTerritory(pciEoList,params); + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_ALL.getValue(),operatorType)){ + dataMaps = this.projectLibraryStatisticsService.getAllCertificationProgressStatisticsGroupByTerritory(pciEoList,params); + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_CAR.getValue(),operatorType)){ + dataMaps = this.projectLibraryStatisticsService.getCarCertificationProgressStatisticsGroupByTerritory(pciEoList,params); + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_PART.getValue(),operatorType)){ + dataMaps = this.projectLibraryStatisticsService.getPartCertificationProgressStatisticsGroupByTerritory(pciEoList,params); + } + if(ObjectUtils.isEmpty(dataMaps)){ + continue; + } + Map dataMap = (Map) dataMaps.get(status); + double amount = (double) dataMap.get("amount"); + if(amount != 0){ + dataMap.put("dutyTerritoryName",key); + dataList.add(dataMap); + } + } + this.projectDetailsStatisticsGroupByTerritoryHearSort(dataList,params); + result.put("dataList",dataList); + } + return result; + } + + /** + * 项目库详情统计-根据责任领域分组统计数据-表头排序 + * @param dataList + * @param params + */ + private void projectDetailsStatisticsGroupByTerritoryHearSort(List> dataList,Map params) { + String orderByField = (String) params.get("orderByField"); + String orderBy = (String) params.get("orderBy"); + if(CollectionUtils.isNotEmpty(dataList)){ + Collator comparator = Collator.getInstance(Locale.CHINESE); + Collections.sort(dataList,(data1,data2)->{ + String param1 = ""; + String param2 = ""; + // 一级责任领域名称 + if("dutyTerritoryName".equals(orderByField)){ + param1 = StringUtils.isNotEmpty((String) data1.get("dutyTerritoryName")) ? (String) data1.get("dutyTerritoryName") : ""; + param2 = StringUtils.isNotEmpty((String) data2.get("dutyTerritoryName")) ? (String) data2.get("dutyTerritoryName") : ""; + if(OrderEnum.POSITIVE.getValue().equals(orderBy)){ + return comparator.compare(param1,param2); + }else if(OrderEnum.REVERSE.getValue().equals(orderBy)){ + return comparator.compare(param2,param1); + } + } + // 数量 + if(StringUtils.isEmpty(orderByField) || "amount".equals(orderByField)){ + double p1 = data1.get("amount") != null ? (double) data1.get("amount") : 0; + double p2 = data2.get("amount") != null ? (double) data2.get("amount") : 0; + if(StringUtils.isEmpty(orderBy) || OrderEnum.POSITIVE.getValue().equals(orderBy)){ + return (int)(p1 - p2); + }else if(OrderEnum.REVERSE.getValue().equals(orderBy)){ + return (int)(p2 - p1); + } + } + // 占比 + if("percentage".equals(orderByField)){ + double p1 = StringUtils.isNotEmpty((String) data1.get("percentage")) ? Double.parseDouble (((String) data1.get("percentage")).replace("%","")) : 0; + double p2 = StringUtils.isNotEmpty((String) data2.get("percentage")) ? Double.parseDouble (((String) data2.get("percentage")).replace("%","")) : 0; + if(OrderEnum.POSITIVE.getValue().equals(orderBy)){ + return (int)(p1 - p2); + }else if(OrderEnum.REVERSE.getValue().equals(orderBy)){ + return (int)(p2 - p1); + } + } + return 0; + }); + } + } + + @Override + public void exportProjectDetailsStatisticsGroupByTerritoryXls(HttpServletResponse response, HttpServletRequest request, Map params) { + Map projectDetailsStatisticsGroupByTerritory = getProjectDetailsStatisticsGroupByTerritory(params); + String operatorType = (String) params.get("operatorType"); + String cut = (String) params.get("cut"); + String sheetName = ""; + String title = ""; + if (StringUtils.equals(cut,CutEnum.CN.getValue())) { + title = "责任领域,数量,责任领域内占比"; + if(StringUtils.equals(OperatorTypeEnum.QUERY_FG_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + sheetName = "法规任务确认"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_DESIGN_STATISTICS.getValue(),operatorType)){ + sheetName = "设计符合性"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_VERIFY_STATISTICS.getValue(),operatorType)){ + sheetName = "验证符合性"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_RZ_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + sheetName = "认证任务确认"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_PREHOMO_STATISTICS.getValue(),operatorType)){ + sheetName = "Pre-Homo流程"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_ALL.getValue(),operatorType)){ + sheetName = "认证进度"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_CAR.getValue(),operatorType)){ + sheetName = "认证进度"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_PART.getValue(),operatorType)){ + sheetName = "认证进度"; + } + /*if(StringUtils.equals(OperatorTypeEnum.QUERY_CURRENT_PROJECT_STATUS_STATISTICS.getValue(),operatorType)){ + sheetName = "项目状态"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_LISTING_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + sheetName = "清单确认"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + sheetName = "任务确认"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_DESIGN_STATISTICS.getValue(),operatorType)){ + sheetName = "设计符合性"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_PREHOMO_STATISTICS.getValue(),operatorType)){ + sheetName = "Pre-homo"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_VERIFY_STATISTICS.getValue(),operatorType)){ + sheetName = "验证符合性"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS.getValue(),operatorType)){ + sheetName = "认证进度"; + }*/ + }else if (StringUtils.equals(cut,CutEnum.EN.getValue())) { + title = "Responsible Field,Quantity,Proportion within the area of responsibility"; + if(StringUtils.equals(OperatorTypeEnum.QUERY_FG_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + sheetName = "Regulation Task Confirmation"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_DESIGN_STATISTICS.getValue(),operatorType)){ + sheetName = "Design Compliance"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_VERIFY_STATISTICS.getValue(),operatorType)){ + sheetName = "Verify Compliance"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_RZ_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + sheetName = "Certification Task Confirmation"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_PREHOMO_STATISTICS.getValue(),operatorType)){ + sheetName = "Pre-Homo flow"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_ALL.getValue(),operatorType)){ + sheetName = "Homologation Progress"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_CAR.getValue(),operatorType)){ + sheetName = "Homologation Progress"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS_PART.getValue(),operatorType)){ + sheetName = "Homologation Progress"; + } + /*if(StringUtils.equals(OperatorTypeEnum.QUERY_CURRENT_PROJECT_STATUS_STATISTICS.getValue(),operatorType)){ + sheetName = "Project status"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_LISTING_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + sheetName = "Listing to confirm"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_TASK_TO_CONFIRM_STATISTICS.getValue(),operatorType)){ + sheetName = "Task to confirm"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_DESIGN_STATISTICS.getValue(),operatorType)){ + sheetName = "Design compliance"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_PREHOMO_STATISTICS.getValue(),operatorType)){ + sheetName = "Pre-homo"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_VERIFY_STATISTICS.getValue(),operatorType)){ + sheetName = "Verify compliance"; + }else if(StringUtils.equals(OperatorTypeEnum.QUERY_CERTIFICATION_PROGRESS_STATISTICS.getValue(),operatorType)){ + sheetName = "Certification progress"; + }*/ + } + + + OutputStream os = null; + HSSFWorkbook workbook = new HSSFWorkbook(); + + try { + String fileName = sheetName + ".xlsx"; + response.setHeader("Content-Disposition", + "attachment; filename=" + fileName); + response.setContentType("application/force-download"); + + HSSFSheet sheet = workbook.createSheet(sheetName); + + String[] titleArr = title.split(","); + Row firstRow = sheet.createRow(0); + + CellStyle cellStyleTitle = workbook.createCellStyle(); + cellStyleTitle.setAlignment(HorizontalAlignment.CENTER); + for (int i = 0; i < 3; i++){ + sheet.setColumnWidth(i, 5000); + Cell cell = firstRow.createCell(i); + cell.setCellStyle(cellStyleTitle); + cell.setCellValue(titleArr[i]); + } + + createSheetData(sheet,projectDetailsStatisticsGroupByTerritory,params); + + os = response.getOutputStream(); + workbook.write(os); + os.flush(); + }catch (IOException ex){ + if(CutEnum.CN.getValue().equals(cut)){ + throw new JeroBootException("下载文件失败"); + }else{ + throw new JeroBootException("Failed to download file"); + } + } + } + + public void createSheetData(HSSFSheet sheet,Map exportDataMap, Map params){ + List> exportDataList = (List>) exportDataMap.get("dataList"); + int rowIndex = 1; + for (int dataIndex = 0; dataIndex < exportDataList.size(); dataIndex++) { + Row dataRow = sheet.createRow(rowIndex); + dataRow.createCell(0).setCellValue(exportDataList.get(dataIndex).get("dutyTerritoryName").toString()); + dataRow.createCell(1).setCellValue(String.valueOf(Math.round((Double) exportDataList.get(dataIndex).get("amount")))); + dataRow.createCell(2).setCellValue(exportDataList.get(dataIndex).get("percentage").toString()); + rowIndex ++; + } + } + + /** + * 处理 根据领域统计的数据 + * @param datas + * @param cut + */ + public void disposeData(List> datas,String cut){ + List dutyTerritoryList = sysDictItemServiceImpl.selectItemsByDictCode("duty_territory"); + if(CollectionUtils.isNotEmpty(datas)){ + for (Map data : datas) { + if(data.get("dutyTerritory") != null){ + String[] dutyTerritorieArr = data.get("dutyTerritory").toString().split(","); + String dutyTerritories = ""; + for (String dutyTerritorie : dutyTerritorieArr) { + List collect = new ArrayList<>(); + if(StringUtils.equals(cut,CutEnum.CN.getValue())){ + collect = dutyTerritoryList.stream() + .filter(e -> StringUtils.equals(dutyTerritorie, e.getItemValue())) + .map(SysDictItem::getItemText) + .collect(Collectors.toList()); + }else if(StringUtils.equals(cut,CutEnum.EN.getValue())){ + collect = dutyTerritoryList.stream() + .filter(e -> StringUtils.equals(dutyTerritorie, e.getItemValue())) + .map(SysDictItem::getEnName) + .collect(Collectors.toList()); + } + if(CollectionUtils.isNotEmpty(collect)){ + dutyTerritories += collect.get(0) + ","; + } + } + + if(StringUtils.isNotEmpty(dutyTerritories)){ + dutyTerritories = dutyTerritories.substring(0,dutyTerritories.length()-1); + } +// data.put("dutyTerritory",dutyTerritories); + data.put("dutyTerritoryName",dutyTerritories); + } + } + } + } + + @Override + public void top(String id, String flag) { + LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal(); + ProjectLibraryBase projectLibraryBase = this.getById(id); + //置顶的时候将取消置顶标识传过来即:flag=1 + if(TopEnum.TOP_CANCEL.getValue().equals(flag)){ + TopProjectEO topProjectEO = new TopProjectEO(); + topProjectEO.setProjectLibraryBaseId(id); + topProjectEO.setFlag(TopEnum.TOP_CANCEL.getValue()); + topProjectEO.setCreateBy(loginUser.getUsername()); + + //置顶 + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.in(TopProjectEO::getCreateBy,loginUser.getUsername()).orderByDesc(TopProjectEO::getSort); + List list = iTopProjectEOService.list(wrapper); + if(list.size() != 0){ + String sort = list.get(0).getSort(); + int sortTemp = Integer.valueOf(sort) + 1; + topProjectEO.setSort(String.valueOf(sortTemp)); + }else{ + //首个置顶的项目排序为1 + topProjectEO.setSort("1"); + } + iTopProjectEOService.save(topProjectEO); + + }else{ + //取消置顶 + LambdaUpdateWrapper wrapper = new LambdaUpdateWrapper<>(); + wrapper.in(TopProjectEO::getCreateBy,loginUser.getUsername()).in(TopProjectEO::getProjectLibraryBaseId,id); + iTopProjectEOService.remove(wrapper); + } + } +// @Override +// public void top(String id, String flag) { +// ProjectLibraryBase projectLibraryBase = this.getById(id); +// //置顶的时候将取消置顶标识传过来即:flag=1 +// if(TopEnum.TOP_CANCEL.getValue().equals(flag)){ +// //置顶 +// LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); +// wrapper.isNotNull(ProjectLibraryBase::getSort).orderByDesc(ProjectLibraryBase::getSort); +// List list = this.list(wrapper); +// if(list.size() != 0){ +// String sort = list.get(list.size() - 1).getSort(); +// int sortTemp = Integer.valueOf(sort) + 1; +// projectLibraryBase.setSort(String.valueOf(sortTemp)); +// }else{ +// //首个置顶的项目排序为1 +// projectLibraryBase.setSort("1"); +// } +// projectLibraryBase.setFlag(TopEnum.TOP_CANCEL.getValue()); +// this.updateById(projectLibraryBase); +// +// }else{ +// //取消置顶 +// LambdaUpdateWrapper updateWrapper = new LambdaUpdateWrapper<>(); +// updateWrapper.in(ProjectLibraryBase::getId,id); +// updateWrapper.set(ProjectLibraryBase::getSort,null).set(ProjectLibraryBase::getFlag,null); +// this.update(projectLibraryBase,updateWrapper); +// } +// } + + @Override + public List getVersionsInfo(String id) { + LambdaUpdateWrapper wrapper = new LambdaUpdateWrapper<>(); + wrapper.in(ProjectLibraryBase::getId,id).or().in(ProjectLibraryBase::getParentId,id); + List list = this.list(wrapper); + List result = new ArrayList<>(); + if(list.size() != 0){ + result = list.stream().map(ProjectLibraryBase::getProjectVersion).collect(Collectors.toList()); + Collections.sort(result); + } + return result; + } + + /** + * 版本统计 + * @param id + * @return + */ + @Override + public List versionStatistics(String id) { + LambdaUpdateWrapper wrapper = new LambdaUpdateWrapper<>(); + wrapper.in(ProjectLibraryBase::getId,id).or().in(ProjectLibraryBase::getParentId,id); + List list = this.list(wrapper); + if(list.size() != 0){ +// Collections.sort(list); + } + return list; + } + + /** + * 通过主项目id和子项目版本号 + * @param version + * @param parentId + * @return + */ + @Override + public String getIdByVersionAndParentId(String version, String parentId) { + if ("00".equals(version)) { + return parentId; + } + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(ProjectLibraryBase::getProjectVersion,version); + wrapper.eq(ProjectLibraryBase::getParentId, parentId); + List list = this.list(wrapper); + if (CollectionUtils.isNotEmpty(list)) { + return list.get(0).getId(); + } else { + return null; + } + + } + + @Override + public List getParentAndChildern(String parentId) { + LambdaQueryWrapper wrapper = new LambdaQueryWrapper<>(); + wrapper.eq(ProjectLibraryBase::getId,parentId); + wrapper.or().eq(ProjectLibraryBase::getParentId, parentId); + List list = this.list(wrapper); + return list; + } + + @Override + public ProjectLibraryBase selectById(String projectLibraryId) { + ProjectLibraryBase result = null; + List records = this.projectLibraryBaseMapper.queryById(projectLibraryId); + if(CollectionUtils.isNotEmpty(records)){ + List studioEngineerUserIdList = records.stream().map(ProjectLibraryBase::getStudioEngineer).distinct().collect(Collectors.toList()); + List studioEngineerUserInfo = this.sysUserService.querySysUserListByIdList(studioEngineerUserIdList); + disposeData(records,"",false); + + List targetMarketList = sysDictService.queryDictItemsByCode(DicCodeEnum.REGION.getCode()); + for(ProjectLibraryBase projectLibraryBase: records){ + //历史数据的主版本没有版本号,所以默认给00 + if(StringUtils.isBlank(projectLibraryBase.getParentId()) && StringUtils.isBlank(projectLibraryBase.getProjectVersion())){ + projectLibraryBase.setProjectVersion("00"); + } + //目标市场 英文 + Map paramEn = new HashMap<>(); + paramEn.put("cut",CutEnum.EN.getValue()); + String targetMarketEn = getMarket(paramEn, targetMarketList, projectLibraryBase); + + //目标市场 中文 + Map paramCn = new HashMap<>(); + paramCn.put("cut",CutEnum.CN.getValue()); + String targetMarketCn = getMarket(paramCn, targetMarketList, projectLibraryBase); + + //主项目的版本号 + String projectVersion = ""; + if(StringUtils.isBlank(projectLibraryBase.getParentId())){ + projectVersion = "00"; + }else{ + projectVersion = projectLibraryBase.getProjectVersion(); + } + if(StringUtils.isNotBlank(projectLibraryBase.getYearName())){ + projectLibraryBase.setProjectNameEn(projectLibraryBase.getProjectName() + + "-" + projectLibraryBase.getYearName() + + "-" + targetMarketEn + + "-" + projectVersion); + + projectLibraryBase.setProjectNameCn(projectLibraryBase.getProjectName() + + "-" + projectLibraryBase.getYearName() + + "-" + targetMarketCn + + "-" + projectVersion); + } + + if(StringUtils.isNotEmpty(projectLibraryBase.getStudioEngineer())){ + if(CollectionUtils.isNotEmpty(studioEngineerUserInfo)){ + String studioEngineerUserName = studioEngineerUserInfo.stream().filter(studioEngineerUser -> { + boolean flag = false; + if (StringUtils.equals(projectLibraryBase.getStudioEngineer(), studioEngineerUser.getId())) { + flag = true; + } + return flag; + }).map(SysUser::getUsername).collect(Collectors.joining(",")); + + projectLibraryBase.setStudioEngineerName(studioEngineerUserName); + } + } + } + + result = records.get(0); + } + return result; + } + + /** + * 对接火山引擎接口-获取项目统计信息 + * @return + */ + @Override + public JSONArray getProjectInfo() { + Date now = new Date(); + List plbList = this.getList(new ProjectLibraryBase()); + JSONArray resList = new JSONArray(); + for (ProjectLibraryBase plb: plbList) { + JSONObject jsonObject = new JSONObject(); + jsonObject.put("projectId",plb.getId()); + jsonObject.put("projectName",plb.getShowName()); + List> TimeNodeVOsList = projectTaskPlanningService.queryByProjectId(plb.getId(),CutEnum.CN.getValue()); + //获取前置节点 + TimeNodeVO preNodeTnVo = null; + //获取后置节点 + TimeNodeVO postNodeTnVo = null; + if (ObjectUtils.isNotEmpty(TimeNodeVOsList) && TimeNodeVOsList.size() > 0) { + List TimeNodeVOList = TimeNodeVOsList.get(0); + for (TimeNodeVO tnVo : TimeNodeVOList) { + if(tnVo.isG()){ + continue; + } + if (null != postNodeTnVo) { + break; + } + tnVo.setProjectId(plb.getId()); + if (now.after(tnVo.getTime())) { + preNodeTnVo = tnVo; + } + if (now.before(tnVo.getTime())) { + postNodeTnVo = tnVo; + } + } + } + JSONArray preNodeList = getNodeList(preNodeTnVo); + jsonObject.put("preNode", preNodeList); + JSONArray postNodeList = getNodeList(postNodeTnVo); + jsonObject.put("postNode",postNodeList); + resList.add(jsonObject); + } + return resList; + } + + @Override + public JSONArray getProjectProgressInfo() { + List plbList = this.getList(new ProjectLibraryBase()); + JSONArray resList = new JSONArray(); + for (ProjectLibraryBase plb: plbList) { + JSONObject jsonObject = new JSONObject(); + jsonObject.put("projectId",plb.getId()); + jsonObject.put("projectName",plb.getShowName()); + jsonObject.put("studio",plb.getStudioEngineerName()); + List> TimeNodeVOsList = projectTaskPlanningService.queryByProjectId(plb.getId(),CutEnum.CN.getValue()); + + JSONArray preNodeList = new JSONArray(); + if (ObjectUtils.isNotEmpty(TimeNodeVOsList) && TimeNodeVOsList.size() > 0) { + List TimeNodeVOList = TimeNodeVOsList.get(0); + for (TimeNodeVO tnVo : TimeNodeVOList) { + if(tnVo.isG()){ + continue; + } + tnVo.setProjectId(plb.getId()); + preNodeList.addAll(getNodeProgressList(tnVo)); + } + } + jsonObject.put("preNode", preNodeList); + resList.add(jsonObject); + } + return resList; + } + + @Override + public void exportProjectProgressStatisticsXls(HttpServletResponse response, HttpServletRequest request, Map params) { + String fileName = ""; + String cut = (String) params.get("cut"); + String projectLibraryId = (String) params.get("projectLibraryId"); + if(StringUtils.isEmpty(projectLibraryId)){ + throw new JeroBootException("项目库id不能为空！"); + } + OutputStream ops = null; + HSSFWorkbook workbook = new HSSFWorkbook(); + this.exportRegulatoryManagement(workbook,params); + this.exportCertificationManagement(workbook,params); + this.exportParameterCollecting(workbook,params); + this.exportOtaCollecting(workbook,params); + try { + response.setHeader("Content-Disposition", + "attachment; filename=" + fileName); + response.setContentType("application/force-download"); + ops = response.getOutputStream(); + workbook.write(ops); + ops.flush(); + }catch (IOException ex){ + if(CutEnum.CN.getValue().equals(cut)){ + throw new JeroBootException("下载文件失败"); + }else{ + throw new JeroBootException("Failed to download file"); + } + } + } + + @Override + public List getUserAllDutyTerritoryList(Map params) { + List result = new ArrayList<>(); + List sysDictItems = this.sysDictItemServiceImpl.selectItemsAll(); + List dutyTerritorySdiList = sysDictItems.stream().filter(sysDictItem -> { + return (StringUtils.equals(sysDictItem.getDictCode(), DicCodeEnum.DUTY_TERRITORY.getCode())); + }).collect(Collectors.toList()); + params.put("dutyTerritorySdiList",dutyTerritorySdiList); + + List userAllDutyTerritorySdiList = new ArrayList<>(); + List prpSdiList = this.projectRelatedPersonnelService.getUserDutyTerritoryList(params); + if(CollectionUtils.isNotEmpty(prpSdiList)){ + userAllDutyTerritorySdiList.addAll(prpSdiList); + } + List pliSdiList = this.projectLawsInventoryEOService.getUserDutyTerritoryList(params); + if(CollectionUtils.isNotEmpty(pliSdiList)){ + userAllDutyTerritorySdiList.addAll(pliSdiList); + } + List pciSdiList = this.projectCertificationInventoryEOService.getUserDutyTerritoryList(params); + if(CollectionUtils.isNotEmpty(pciSdiList)){ + userAllDutyTerritorySdiList.addAll(pciSdiList); + } + String projectLibraryId = (String) params.get("projectLibraryId"); + ProjectLibraryBase projectLibraryBase = this.selectById(projectLibraryId); + params.put("parentId",projectLibraryBase.getParentId()); + List pmSdiList = this.paramsManifestEOService.getUserDutyTerritoryList(params); + if(CollectionUtils.isNotEmpty(pmSdiList)){ + userAllDutyTerritorySdiList.addAll(pmSdiList); + } + + userAllDutyTerritorySdiList = userAllDutyTerritorySdiList.stream().distinct().collect(Collectors.toList()); + if(CollectionUtils.isNotEmpty(userAllDutyTerritorySdiList)){ + for (SysDictItem sysDictItem : userAllDutyTerritorySdiList) { + DictModel dictModel = new DictModel(); + dictModel.setText(sysDictItem.getItemText()); + dictModel.setTextEn(sysDictItem.getEnName()); + dictModel.setValue(sysDictItem.getItemValue()); + result.add(dictModel); + } + } + return result; + } + + /** + * 全局替换用户 + * @param json + * @return + */ + @Override + public Result overallReplacementUser(JSONObject json) { + this.projectRelatedPersonnelService.replacementUser(json); + this.projectLawsInventoryEOService.replacementUser(json); + this.projectCertificationInventoryEOService.replacementUser(json); + String projectLibraryId = json.getString("projectLibraryId"); + ProjectLibraryBase projectLibraryBase = this.selectById(projectLibraryId); + json.put("parentId",projectLibraryBase.getParentId()); + this.paramsManifestEOService.replacementUser(json); + return Result.OK("全局替换成功！"); + } + + /** + * 导出法规符合性管理 + * @param workbook + * @param params + */ + private void exportRegulatoryManagement(HSSFWorkbook workbook,Map params) { + String cut = (String) params.get("cut"); + String sheetName = "法规符合性管理"; + String firstTitle = "法规任务确认," + + "设计符合性确认," + + "验证符合性确认"; + String secondTitle = "责任领域（一级）," + + "未发起,待确认,接受,拒绝,完成度," + + "未发起,待确认,符合,不符合,完成度," + + "未发起,待确认,符合,不符合,完成度"; + if(StringUtils.equals(cut,CutEnum.EN.getValue())){ + sheetName = "Regulatory compliance management"; + firstTitle = "Regulatory task confirmation," + + "Design Conformity Verification," + + "Verification Conformity Confirmation"; + secondTitle = "Area of responsibility (level 1)," + + "Not launched,To be confirmed,Accept,Refuse,Degree of completion," + + "Not launched,To be confirmed,Meet,Not meet,Degree of completion," + + "Not launched,To be confirmed,Meet,Not meet,Degree of completion"; + } + HSSFSheet sheet = workbook.createSheet(sheetName); + //合并单元格 起始行，结束行，起始列，结束列 + CellRangeAddress region1 = new CellRangeAddress(0, 0, 1, 5); + sheet.addMergedRegion(region1); + CellRangeAddress region2 = new CellRangeAddress(0, 0, 6, 10); + sheet.addMergedRegion(region2); + CellRangeAddress region3 = new CellRangeAddress(0, 0, 11, 15); + sheet.addMergedRegion(region3); + + String[] firstTitleArr = firstTitle.split(","); + String[] secondTitleArr = secondTitle.split(","); + Row firstRow = sheet.createRow(0); + Row secondRow = sheet.createRow(1); + + CellStyle cellStyleTitle = workbook.createCellStyle(); + cellStyleTitle.setAlignment(HorizontalAlignment.CENTER); + for (int i = 0; i <= 15; i++){ + sheet.setColumnWidth(i, 3500); + Cell firstRowCell = firstRow.createCell(i); + firstRowCell.setCellStyle(cellStyleTitle); + if(i == 1){ + firstRowCell.setCellValue(firstTitleArr[0]); + }else if(i==6){ + firstRowCell.setCellValue(firstTitleArr[1]); + }else if(i==11){ + firstRowCell.setCellValue(firstTitleArr[2]); + } + + Cell secondRowCell = secondRow.createCell(i); + secondRowCell.setCellValue(secondTitleArr[i]); + } + + String projectLibraryId = (String) params.get("projectLibraryId"); + + QueryWrapper pliQueryWrap = new QueryWrapper<>(); + pliQueryWrap.lambda().eq(ProjectLawsInventoryEO::getProjectLibraryId,projectLibraryId); + List pliEOList = this.projectLawsInventoryEOMapper.selectList(pliQueryWrap); + List sysDictItems = new ArrayList<>(); + String pliDutyTerritoryStr = pliEOList.stream().map(ProjectLawsInventoryEO::getDutyTerritory).collect(Collectors.joining(",")); + if (StringUtils.isNotEmpty(pliDutyTerritoryStr)) { + List pliDutyTerritoryList = Arrays.asList(pliDutyTerritoryStr.split(",")).stream().distinct().collect(Collectors.toList()); + sysDictItems = this.sysDictItemServiceImpl.selectItemsAll().stream().filter(sysDictItem -> { + boolean flag = false; + for (String pliDutyTerritory : pliDutyTerritoryList) { + if(StringUtils.equals(sysDictItem.getItemValue(),pliDutyTerritory)){ + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + } + + Map> firstLevelDutyTerritoryMap = this.sysDictItemServiceImpl.getFirstLevelSysDictItemByDictCode(DictCodeEnum.DUTY_TERRITORY.getValue(),sysDictItems); + if(ObjectUtils.isNotEmpty(firstLevelDutyTerritoryMap)){ + int dataIndex = 2; + for (Map.Entry> firstLevelMap : firstLevelDutyTerritoryMap.entrySet()) { + String key = firstLevelMap.getKey(); + List dutyTerritoryList = firstLevelMap.getValue(); + if(StringUtils.isEmpty(key) || CollectionUtils.isEmpty(dutyTerritoryList)){ + continue; + } + List pliEoList = pliEOList.stream().filter(pliEo -> { + boolean flag = false; + for (SysDictItem dutyTerritory : dutyTerritoryList) { + if (StringUtils.contains(pliEo.getDutyTerritory(), dutyTerritory.getItemValue())) { + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + + this.exportRegulatoryManagementSetData(params, sheet, dataIndex ,key,pliEoList); + dataIndex ++; + } + } + } + + /** + * 导出法规符合性管理-设置数据 + * @param params + * @param sheet + * @param dataIndex + * @param key + * @param pliEoList + */ + private void exportRegulatoryManagementSetData(Map params, HSSFSheet sheet, int dataIndex, String key, List pliEoList) { + Row dataRow = sheet.createRow(dataIndex); + dataRow.createCell(0).setCellValue(key); + + Map taskConfirmMap= this.projectLibraryStatisticsService.getFGTaskToConfirmStatisticsGroupByTerritory(pliEoList, params); + Map taskConfirmNotStartedMap = (Map) taskConfirmMap.get(TaskAffirmStatusEnum.NOT_STARTED.getValue()); + double taskConfirmNotStartedAmount = (double) taskConfirmNotStartedMap.get("amount"); + Map taskConfirmToConfirmMap = (Map) taskConfirmMap.get(TaskAffirmStatusEnum.LIST_TO_CONFIRM.getValue()); + double taskConfirmToConfirmAmount = (double) taskConfirmToConfirmMap.get("amount"); + Map taskConfirmAcceptedMap = (Map) taskConfirmMap.get(TaskAffirmStatusEnum.ACCEPTED.getValue()); + double taskConfirmAcceptedAmount = (double) taskConfirmAcceptedMap.get("amount"); + Map taskConfirmRejectedMap = (Map) taskConfirmMap.get(TaskAffirmStatusEnum.REJECTED.getValue()); + double taskConfirmRejectedAmount = (double) taskConfirmRejectedMap.get("amount"); + dataRow.createCell(1).setCellValue(taskConfirmNotStartedAmount); + dataRow.createCell(2).setCellValue(taskConfirmToConfirmAmount); + dataRow.createCell(3).setCellValue(taskConfirmAcceptedAmount); + dataRow.createCell(4).setCellValue(taskConfirmRejectedAmount); + double taskConfirmCount = taskConfirmNotStartedAmount + taskConfirmToConfirmAmount + taskConfirmAcceptedAmount + taskConfirmRejectedAmount; + double taskConfirmPercentage = (taskConfirmAcceptedAmount / taskConfirmCount) * 100; + String taskConfirmPercentageStr = (taskConfirmPercentage != 0 && (taskConfirmCount !=0 )) ? df.format(taskConfirmPercentage) : "0"; + dataRow.createCell(5).setCellValue(taskConfirmPercentageStr + percentSign); + + Map designMap = this.projectLibraryStatisticsService.getDesignComplianceStatisticeGroupByTerritory(pliEoList, params); + Map designNotStartedMap = (Map) designMap.get(TaskAffirmStatusEnum.NOT_STARTED.getValue()); + double designNotStartedAmount = (double) designNotStartedMap.get("amount"); + Map designToConfirmMap = (Map) designMap.get(TaskAffirmStatusEnum.LIST_TO_CONFIRM.getValue()); + double designToConfirmAmount = (double) designToConfirmMap.get("amount"); + Map designComplianceMap = (Map) designMap.get(ComplianceFlowStatusEnum.CONFORMITY.getValue()); + double designComplianceAmount = (double) designComplianceMap.get("amount"); + Map designNonComplianceMap = (Map) designMap.get(ComplianceFlowStatusEnum.INCONFORMITY.getValue()); + double designNonComplianceAmount = (double) designNonComplianceMap.get("amount"); + dataRow.createCell(6).setCellValue(designNotStartedAmount); + dataRow.createCell(7).setCellValue(designToConfirmAmount); + dataRow.createCell(8).setCellValue(designComplianceAmount); + dataRow.createCell(9).setCellValue(designNonComplianceAmount); + double designCount = designNotStartedAmount + designToConfirmAmount + designComplianceAmount + designNonComplianceAmount; + double designPercentage = (designComplianceAmount / designCount) * 100; + String designPercentageStr = (designPercentage != 0 && (designCount !=0 )) ? df.format(designPercentage) : "0"; + dataRow.createCell(10).setCellValue(designPercentageStr + percentSign); + + Map verifyMap = this.projectLibraryStatisticsService.getVerifyComplianceStatisticeGroupByTerritory(pliEoList, params); + Map verifyNotStartedMap = (Map) verifyMap.get(TaskAffirmStatusEnum.NOT_STARTED.getValue()); + double verifyNotStartedAmount = (double) verifyNotStartedMap.get("amount"); + Map verifyToConfirmMap = (Map) verifyMap.get(TaskAffirmStatusEnum.LIST_TO_CONFIRM.getValue()); + double verifyToConfirmAmount = (double) verifyToConfirmMap.get("amount"); + Map verifyComplianceMap = (Map) verifyMap.get(ComplianceFlowStatusEnum.CONFORMITY.getValue()); + double verifyComplianceAmount = (double) verifyComplianceMap.get("amount"); + Map verifyNonComplianceMap = (Map) verifyMap.get(ComplianceFlowStatusEnum.INCONFORMITY.getValue()); + double verifyNonComplianceAmount = (double) verifyNonComplianceMap.get("amount"); + dataRow.createCell(11).setCellValue(verifyNotStartedAmount); + dataRow.createCell(12).setCellValue(verifyToConfirmAmount); + dataRow.createCell(13).setCellValue(verifyComplianceAmount); + dataRow.createCell(14).setCellValue(verifyNonComplianceAmount); + double verifyCount = verifyNotStartedAmount + verifyToConfirmAmount + verifyComplianceAmount + verifyNonComplianceAmount; + double verifyPercentage = (verifyComplianceAmount / verifyCount) * 100; + String verifyPercentageStr = (verifyPercentage != 0 && (verifyCount !=0 )) ? df.format(verifyPercentage) : "0"; + dataRow.createCell(15).setCellValue(verifyPercentageStr + percentSign); + } + + /** + * 导出认证活动管理 + * @param workbook + * @param params + */ + private void exportCertificationManagement(HSSFWorkbook workbook,Map params){ + String cut = (String) params.get("cut"); + String sheetName = "认证活动管理"; + String firstTitle = "认证任务确认," + + "Pre-Homo," + + "认证进度"; + String secondTitle = "责任领域（一级）," + + "未发起,待确认,接受,拒绝,完成度," + + "未发起,待确认,审查通过,审查退回,完成度," + + "未开始,进行中,实验通过,实验失败,部件报告未上传,部件报告已上传,部件报告已入库,完成度"; + if(StringUtils.equals(cut,CutEnum.EN.getValue())){ + sheetName = "Certification Activity Management"; + firstTitle = "Authentication task confirmation," + + "Pre-Homo," + + "Certification progress"; + secondTitle = "Area of responsibility (level 1)," + + "Not launched,To be confirmed,Accept,Refuse,Degree of completion," + + "Not launched,To be confirmed,Review of the adoption,Review return,Degree of completion," + + "Not started,In progress,Experiment passed,Experiment failed,Parts report not uploaded,Parts report uploaded,Parts report in stock,Degree of completion"; + } + HSSFSheet sheet = workbook.createSheet(sheetName); + + //合并单元格 起始行，结束行，起始列，结束列 + CellRangeAddress region1 = new CellRangeAddress(0, 0, 1, 5); + sheet.addMergedRegion(region1); + CellRangeAddress region2 = new CellRangeAddress(0, 0, 6, 10); + sheet.addMergedRegion(region2); + CellRangeAddress region3 = new CellRangeAddress(0, 0, 11, 18); + sheet.addMergedRegion(region3); + CellRangeAddress region4 = new CellRangeAddress(0, 0, 19, 23); + sheet.addMergedRegion(region4); + + String[] firstTitleArr = firstTitle.split(","); + String[] secondTitleArr = secondTitle.split(","); + Row firstRow = sheet.createRow(0); + Row secondRow = sheet.createRow(1); + + CellStyle cellStyleTitle = workbook.createCellStyle(); + cellStyleTitle.setAlignment(HorizontalAlignment.CENTER); + for (int i = 0; i <= 18; i++){ + sheet.setColumnWidth(i, 3500); + Cell firstRowCell = firstRow.createCell(i); + firstRowCell.setCellStyle(cellStyleTitle); + if(i == 1){ + firstRowCell.setCellValue(firstTitleArr[0]); + }else if(i==6){ + firstRowCell.setCellValue(firstTitleArr[1]); + }else if(i==11){ + firstRowCell.setCellValue(firstTitleArr[2]); + }else if(i==19){ + firstRowCell.setCellValue(firstTitleArr[3]); + } + Cell secondRowCell = secondRow.createCell(i); + secondRowCell.setCellValue(secondTitleArr[i]); + } + + String projectLibraryId = (String) params.get("projectLibraryId"); + QueryWrapper pciQueryWrap = new QueryWrapper<>(); + pciQueryWrap.lambda().eq(ProjectCertificationInventoryEO::getProjectLibraryId,projectLibraryId); + List projectCertificationInventoryEOList = this.projectCertificationInventoryEOService.list(pciQueryWrap).stream().filter(pciEo -> { + boolean flag = false; + if (!StringUtils.equals(pciEo.getFlowStatus(), CertificationInventoryFlowStatusEnum.UNINVOLVED.getValue())) { + flag = true; + } + return flag; + }).distinct().collect(Collectors.toList()); + String pciDutyTerritoryStr = projectCertificationInventoryEOList.stream().map(ProjectCertificationInventoryEO::getDutyTerritory).collect(Collectors.joining(",")); + List sysDictItems = new ArrayList<>(); + if (StringUtils.isNotEmpty(pciDutyTerritoryStr)) { + List pciDutyTerritoryList = Arrays.asList(pciDutyTerritoryStr.split(",")).stream().distinct().collect(Collectors.toList()); + sysDictItems = this.sysDictItemServiceImpl.selectItemsAll().stream().filter(sysDictItem -> { + boolean flag = false; + for (String pliDutyTerritory : pciDutyTerritoryList) { + if(StringUtils.equals(sysDictItem.getItemValue(),pliDutyTerritory)){ + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + } + Map> firstLevelDutyTerritoryMap = this.sysDictItemServiceImpl.getFirstLevelSysDictItemByDictCode(DictCodeEnum.DUTY_TERRITORY.getValue(),sysDictItems); + if(ObjectUtils.isNotEmpty(firstLevelDutyTerritoryMap)){ + int dataIndex = 2; + for (Map.Entry> firstLevelMap : firstLevelDutyTerritoryMap.entrySet()) { + String key = firstLevelMap.getKey(); + List dutyTerritoryList = firstLevelMap.getValue(); + if(StringUtils.isEmpty(key) || CollectionUtils.isEmpty(dutyTerritoryList)){ + continue; + } + List pciEoList = projectCertificationInventoryEOList.stream().filter(pciEo -> { + boolean flag = false; + for (SysDictItem dutyTerritory : dutyTerritoryList) { + if (StringUtils.contains(pciEo.getDutyTerritory(), dutyTerritory.getItemValue())) { + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + this.exportCertificationManagementSetData(params, sheet, dataIndex, key, pciEoList); + + dataIndex ++; + } + } + } + + /** + * 导出认证活动管理-设置数据 + * @param params + * @param sheet + * @param dataIndex + * @param key + * @param pciEoList + */ + private void exportCertificationManagementSetData(Map params, HSSFSheet sheet, int dataIndex, String key, List pciEoList) { + Row dataRow = sheet.createRow(dataIndex); + dataRow.createCell(0).setCellValue(key); + + Map taskConfirmMap = this.projectLibraryStatisticsService.getRZTaskToConfirmStatisticsGroupByTerritory(pciEoList, params); + Map taskConfirmNotStartedMap = (Map) taskConfirmMap.get(TaskAffirmStatusEnum.NOT_STARTED.getValue()); + double taskConfirmNotStartedAmount = (double) taskConfirmNotStartedMap.get("amount"); + Map taskConfirmToConfirmMap = (Map) taskConfirmMap.get(TaskAffirmStatusEnum.LIST_TO_CONFIRM.getValue()); + double taskConfirmToConfirmAmount = (double) taskConfirmToConfirmMap.get("amount"); + Map taskConfirmAcceptedMap = (Map) taskConfirmMap.get(TaskAffirmStatusEnum.ACCEPTED.getValue()); + double taskConfirmAcceptedAmount = (double) taskConfirmAcceptedMap.get("amount"); + Map taskConfirmRejectedMap = (Map) taskConfirmMap.get(TaskAffirmStatusEnum.REJECTED.getValue()); + double taskConfirmRejectedAmount = (double) taskConfirmRejectedMap.get("amount"); + dataRow.createCell(1).setCellValue(taskConfirmNotStartedAmount); + dataRow.createCell(2).setCellValue(taskConfirmToConfirmAmount); + dataRow.createCell(3).setCellValue(taskConfirmAcceptedAmount); + dataRow.createCell(4).setCellValue(taskConfirmRejectedAmount); + double taskConfirmCount = taskConfirmNotStartedAmount + taskConfirmToConfirmAmount + taskConfirmAcceptedAmount + taskConfirmRejectedAmount; + double taskConfirmPercentage = (taskConfirmAcceptedAmount / taskConfirmCount) * 100; + String taskConfirmPercentageStr = (taskConfirmPercentage != 0 && (taskConfirmCount !=0 )) ? df.format(taskConfirmPercentage) : "0"; + dataRow.createCell(5).setCellValue(taskConfirmPercentageStr + percentSign); + + Map prehomoMap = this.projectLibraryStatisticsService.getPrehomoStatisticeGroupByTerritory(pciEoList, params); + Map prehomoNotStartedMap = (Map) prehomoMap.get(TaskAffirmStatusEnum.NOT_STARTED.getValue()); + double prehomoNotStartedAmount = (double) prehomoNotStartedMap.get("amount"); + Map prehomoToConfirmMap = (Map) prehomoMap.get(TaskAffirmStatusEnum.LIST_TO_CONFIRM.getValue()); + double prehomoToConfirmAmount = (double) prehomoToConfirmMap.get("amount"); + Map prehomoAcceptedMap = (Map) prehomoMap.get(CertificationInventoryFlowStatusEnum.REVIEW_AND_PASS.getValue()); + double prehomoAcceptedAmount = (double) prehomoAcceptedMap.get("amount"); + Map prehomoRejectedMap = (Map) prehomoMap.get(CertificationInventoryFlowStatusEnum.REVIEW_AND_RETURN.getValue()); + double prehomoRejectedAmount = (double) prehomoRejectedMap.get("amount"); + dataRow.createCell(6).setCellValue(prehomoNotStartedAmount); + dataRow.createCell(7).setCellValue(prehomoToConfirmAmount); + dataRow.createCell(8).setCellValue(prehomoAcceptedAmount); + dataRow.createCell(9).setCellValue(prehomoRejectedAmount); + double prehomoCount = prehomoNotStartedAmount + prehomoToConfirmAmount + prehomoAcceptedAmount + prehomoRejectedAmount; + double prehomoPercentage = (prehomoAcceptedAmount / prehomoCount) * 100; + String prehomoPercentageStr = (prehomoPercentage != 0 && (prehomoCount !=0 )) ? df.format(prehomoPercentage) : "0"; + dataRow.createCell(10).setCellValue(prehomoPercentageStr + percentSign); + + Map certificationProgressMap = this.projectLibraryStatisticsService.getPartCertificationProgressStatisticsGroupByTerritory(pciEoList, params); + Map certificationProgressNotStartMap = (Map)certificationProgressMap.get(CertificationProgressEnum.NOT_START.getValue()); + double certificationProgressNotStartAmount = (double) certificationProgressNotStartMap.get("amount"); + Map certificationProgressInProgressMap = (Map)certificationProgressMap.get(CertificationProgressEnum.IN_PROGRESS.getValue()); + double certificationProgressInProgressAmount = (double) certificationProgressInProgressMap.get("amount"); + Map certificationProgressTestPassedMap = (Map)certificationProgressMap.get(CertificationProgressEnum.TEST_PASSED.getValue()); + double certificationProgressTestPassedAmount = (double) certificationProgressTestPassedMap.get("amount"); + Map certificationProgressTestFailedMap = (Map)certificationProgressMap.get(CertificationProgressEnum.TEST_FAILED.getValue()); + double certificationProgressTestFailedAmount = (double) certificationProgressTestFailedMap.get("amount"); + Map certificationProgressNotSubmitMap = (Map)certificationProgressMap.get(CertificationProgressEnum.COMPONENT_REPORT_NOT_SUBMITTED.getValue()); + double certificationProgressNotSubmitAmount = (double) certificationProgressNotSubmitMap.get("amount"); + Map certificationProgressSubmitMap = (Map)certificationProgressMap.get(CertificationProgressEnum.COMPONENT_REPORT_SUBMITTED.getValue()); + double certificationProgressSubmitAmount = (double) certificationProgressSubmitMap.get("amount"); + Map certificationProgressStoredMap = (Map)certificationProgressMap.get(CertificationProgressEnum.COMPONENT_REPORT_HAS_BEEN_STORED.getValue()); + double certificationProgressStoredAmount = (double) certificationProgressStoredMap.get("amount"); + dataRow.createCell(11).setCellValue(certificationProgressNotStartAmount); + dataRow.createCell(12).setCellValue(certificationProgressInProgressAmount); + dataRow.createCell(13).setCellValue(certificationProgressTestPassedAmount); + dataRow.createCell(14).setCellValue(certificationProgressTestFailedAmount); + dataRow.createCell(15).setCellValue(certificationProgressNotSubmitAmount); + dataRow.createCell(16).setCellValue(certificationProgressSubmitAmount); + dataRow.createCell(17).setCellValue(certificationProgressStoredAmount); + double certificationProgressCount = certificationProgressNotStartAmount + certificationProgressInProgressAmount + + certificationProgressTestPassedAmount + certificationProgressTestFailedAmount + + certificationProgressNotSubmitAmount + certificationProgressSubmitAmount + + certificationProgressStoredAmount; + double certificationProgressPercentage = (certificationProgressTestPassedAmount / certificationProgressCount) * 100; + String certificationProgressPercentageStr = (certificationProgressPercentage != 0 && (certificationProgressCount !=0 )) ? df.format(certificationProgressPercentage) : "0"; + dataRow.createCell(18).setCellValue(certificationProgressPercentageStr + percentSign); + } + + /** + * 导出认证参数收集 + * @param workbook + * @param params + */ + private void exportParameterCollecting(HSSFWorkbook workbook, Map params) { + String cut = (String) params.get("cut"); + String sheetName = "认证参数收集"; + String firstTitle = "认证参数收集"; + String secondTitle = "责任领域（一级）,未开始,收集中,已提交,已同步至上报库,完成度"; + if(StringUtils.equals(cut,CutEnum.EN.getValue())){ + sheetName = "Authentication parameter collection"; + firstTitle = "Authentication parameter collection"; + secondTitle = "Area of responsibility (level 1),Not started,Collecting,Has submitted,Synced to the report library,Degree of completion"; + } + HSSFSheet sheet = workbook.createSheet(sheetName); + //合并单元格 起始行，结束行，起始列，结束列 + CellRangeAddress region1 = new CellRangeAddress(0, 0, 1, 5); + sheet.addMergedRegion(region1); + + String[] secondTitleArr = secondTitle.split(","); + Row firstRow = sheet.createRow(0); + Row secondRow = sheet.createRow(1); + + CellStyle cellStyleTitle = workbook.createCellStyle(); + cellStyleTitle.setAlignment(HorizontalAlignment.CENTER); + for (int i = 0; i <= 5; i++){ + sheet.setColumnWidth(i, 3500); + Cell firstRowCell = firstRow.createCell(i); + firstRowCell.setCellStyle(cellStyleTitle); + if(i == 1){ + firstRowCell.setCellValue(firstTitle); + } + + Cell secondRowCell = secondRow.createCell(i); + secondRowCell.setCellValue(secondTitleArr[i]); + } + + String projectLibraryId = (String) params.get("projectLibraryId"); + + QueryWrapper pmQueryWrap = new QueryWrapper<>(); + pmQueryWrap.lambda().eq(ParamsManifestEO::getProjectId,projectLibraryId); + List pmEoList = this.paramsManifestEOService.list(pmQueryWrap); + if(CollectionUtils.isNotEmpty(pmEoList)){ + List pmIdList = pmEoList.stream().map(ParamsManifestEO::getId).distinct().collect(Collectors.toList()); + QueryWrapper pcmQueryWrap = new QueryWrapper<>(); + pcmQueryWrap.lambda().in(ParamsCollectManifestEO::getParamsManifestId,pmIdList); + List pcmEoList = this.paramsCollectManifestEOService.list(pcmQueryWrap); + pcmEoList = pcmEoList.stream().filter(pcmEo -> !StringUtils.equals(pcmEo.getControlType(),ControlTypeEnum.Title.getValue())).collect(Collectors.toList()); + + List sysDictItems = new ArrayList<>(); + String pcmDutyTerritoryStr = pcmEoList.stream().map(ParamsCollectManifestEO::getDutyTerritory).collect(Collectors.joining(",")); + if (StringUtils.isNotEmpty(pcmDutyTerritoryStr)) { + List pcmDutyTerritoryList = Arrays.asList(pcmDutyTerritoryStr.split(",")).stream().distinct().collect(Collectors.toList()); + sysDictItems = this.sysDictItemServiceImpl.selectItemsAll().stream().filter(sysDictItem -> { + boolean flag = false; + for (String pcmDutyTerritory : pcmDutyTerritoryList) { + if(StringUtils.equals(sysDictItem.getItemValue(),pcmDutyTerritory)){ + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + } + + Map> firstLevelDutyTerritoryMap = this.sysDictItemServiceImpl.getFirstLevelSysDictItemByDictCode(DictCodeEnum.DUTY_TERRITORY.getValue(),sysDictItems); + if(ObjectUtils.isNotEmpty(firstLevelDutyTerritoryMap)){ + int dataIndex = 2; + for (Map.Entry> firstLevelMap : firstLevelDutyTerritoryMap.entrySet()) { + String key = firstLevelMap.getKey(); + List dutyTerritoryList = firstLevelMap.getValue(); + if(StringUtils.isEmpty(key) || CollectionUtils.isEmpty(dutyTerritoryList)){ + continue; + } + List pcmEos = pcmEoList.stream().filter(pcmEo -> { + boolean flag = false; + for (SysDictItem dutyTerritory : dutyTerritoryList) { + if (StringUtils.contains(pcmEo.getDutyTerritory(), dutyTerritory.getItemValue())) { + flag = true; + break; + } + } + return flag; + }).collect(Collectors.toList()); + if(CollectionUtils.isNotEmpty(pcmEos)){ + this.exportParameterCollectingSetData(params, sheet, dataIndex ,key,pcmEos); + } + dataIndex ++; + } + } + } + } + private void exportOtaCollecting(HSSFWorkbook workbook, Map params) { + String cut = (String) params.get("cut"); + String sheetName = "OTA状态"; + String firstTitle = "匹配状态统计,OTA认证进度统计"; + String secondTitle = "软件版本,待匹配,待审批,锁定,退回,未开始,进行中,实验通过,实验失败,部件报告未提交,部件报告已提交,部件报告已入库"; + if(StringUtils.equals(cut,CutEnum.EN.getValue())){ + sheetName = "OTA status"; + firstTitle = "Matching state statistics,OTA authentication progress statistics"; + secondTitle = "Software version," + + "To be matched," + + "To be approved," + + "lock," + + "Reject,"+ + "Not started," + + "Ongoing," + + "Test Passed," + + "Test Failed," + + "Component report not submitted," + + "Component report submitted," + + "Component report has been stored"; + } + HSSFSheet sheet = workbook.createSheet(sheetName); + //合并单元格 起始行，结束行，起始列，结束列 + CellRangeAddress region1 = new CellRangeAddress(0, 0, 1, 4); + sheet.addMergedRegion(region1); + CellRangeAddress region2 = new CellRangeAddress(0, 0, 5, 11); + sheet.addMergedRegion(region2); + + String[] firstTitleArr = firstTitle.split(","); + String[] secondTitleArr = secondTitle.split(","); + Row firstRow = sheet.createRow(0); + Row secondRow = sheet.createRow(1); + + CellStyle cellStyleTitle = workbook.createCellStyle(); + cellStyleTitle.setAlignment(HorizontalAlignment.CENTER); + for (int i = 0; i <= 11; i++){ + sheet.setColumnWidth(i, 3500); + Cell firstRowCell = firstRow.createCell(i); + firstRowCell.setCellStyle(cellStyleTitle); + if(i == 1){ + firstRowCell.setCellValue(firstTitleArr[0]); + }else if(i==5){ + firstRowCell.setCellValue(firstTitleArr[1]); + } + Cell secondRowCell = secondRow.createCell(i); + secondRowCell.setCellValue(secondTitleArr[i]); + } + + String projectLibraryId = (String) params.get("projectLibraryId"); + List> mapList = otaManageApplyEOService.getStatisticalStatus(projectLibraryId, null, cut,null); + + if(ObjectUtils.isNotEmpty(mapList)){ + int dataIndex = 2; + for (Map map : mapList) { + String plannedBpLaunchBatch = (String) map.get("plannedBpLaunchBatch"); + Map matchStatusMap = (Map)map.get("matchStatusMap"); + Map attestationScheduleMap = (Map)map.get("attestationScheduleMap"); + + String.valueOf(matchStatusMap.get("locked")); + String locked = String.valueOf(matchStatusMap.get("locked")); + String rejected = String.valueOf(matchStatusMap.get("rejected")); + String to_be_approved = String.valueOf(matchStatusMap.get("to_be_approved")); + String to_be_matched = String.valueOf(matchStatusMap.get("to_be_matched")); + String Component_report_has_been_stored = String.valueOf(attestationScheduleMap.get("Component_report_has_been_stored")); + String Component_report_not_submitted = String.valueOf(attestationScheduleMap.get("Component_report_not_submitted")); + String Component_report_submitted = String.valueOf(attestationScheduleMap.get("Component_report_submitted")); + String In_progress = String.valueOf(attestationScheduleMap.get("In_progress")); + String Not_start =String.valueOf(attestationScheduleMap.get("Not_start")); + String Test_failed = String.valueOf(attestationScheduleMap.get("Test_failed")); + String Test_passed = String.valueOf(attestationScheduleMap.get("Test_passed")); + Row dataRow = sheet.createRow(dataIndex); + dataRow.createCell(0).setCellValue(plannedBpLaunchBatch); + dataRow.createCell(1).setCellValue(to_be_matched); + dataRow.createCell(2).setCellValue(to_be_approved); + dataRow.createCell(3).setCellValue(locked); + dataRow.createCell(4).setCellValue(rejected); + dataRow.createCell(5).setCellValue(Not_start); + dataRow.createCell(6).setCellValue(In_progress); + dataRow.createCell(7).setCellValue(Test_passed); + dataRow.createCell(8).setCellValue(Test_failed); + dataRow.createCell(9).setCellValue(Component_report_not_submitted); + dataRow.createCell(10).setCellValue(Component_report_submitted); + dataRow.createCell(11).setCellValue(Component_report_has_been_stored); + dataIndex ++; + } + } + } + + /** + * 导出认证参数收集-设置数据 + * @param params + * @param sheet + * @param dataIndex + * @param key + * @param pcmEos + */ + private void exportParameterCollectingSetData(Map params, HSSFSheet sheet, int dataIndex, String key, List pcmEos) { + Map parameterCollectingMap = this.projectLibraryStatisticsService.getParameterCollectingStatisticsGroupByTerritory(pcmEos,params); + Map notStartMap = (Map) parameterCollectingMap.get(CollectManifestStatisticsStateEnum.NOT_START.getValue()); + double notStartAmount = (double) notStartMap.get("amount"); + Map collectingMap = (Map) parameterCollectingMap.get(CollectManifestStatisticsStateEnum.COLLECTING.getValue()); + double collectingAmount = (double) collectingMap.get("amount"); + Map submitMap = (Map) parameterCollectingMap.get(CollectManifestStatisticsStateEnum.SUBMIT.getValue()); + double submitAmount = (double) submitMap.get("amount"); + Map syncReporMap = (Map) parameterCollectingMap.get(CollectManifestStatisticsStateEnum.SYNC_REPORT.getValue()); + double syncReporAmount = (double) syncReporMap.get("amount"); + + Row dataRow = sheet.createRow(dataIndex); + dataRow.createCell(0).setCellValue(key); + dataRow.createCell(1).setCellValue(notStartAmount); + dataRow.createCell(2).setCellValue(collectingAmount); + dataRow.createCell(3).setCellValue(submitAmount); + dataRow.createCell(4).setCellValue(syncReporAmount); + double parameterCollectingCount = notStartAmount + collectingAmount + submitAmount + syncReporAmount; + double completionCount = submitAmount + syncReporAmount; + double parameterCollectingPercentage = (completionCount / parameterCollectingCount) * 100; + String parameterCollectingPercentageStr = (parameterCollectingPercentage != 0 && (completionCount !=0 )) ? df.format(parameterCollectingPercentage) : "0"; + dataRow.createCell(5).setCellValue(parameterCollectingPercentageStr + percentSign); + } + + private JSONArray getNodeProgressList(TimeNodeVO nodeTnVo) { + //根据节点获取对应进度和时间 + JSONArray nodeList = new JSONArray(); + if(ObjectUtils.isNotEmpty(nodeTnVo)){ + String projectId = nodeTnVo.getProjectId(); + + QueryWrapper pliQueryWrap = new QueryWrapper<>(); + pliQueryWrap.lambda().eq(ProjectLawsInventoryEO::getProjectLibraryId,projectId); + List pliEoList = this.projectLawsInventoryEOService.list(pliQueryWrap); + + QueryWrapper pciQueryWrap = new QueryWrapper<>(); + pciQueryWrap.lambda().eq(ProjectCertificationInventoryEO::getProjectLibraryId,projectId); + List pciEoList = this.projectCertificationInventoryEOService.list(pciQueryWrap); + + QueryWrapper pmQueryWrap = new QueryWrapper<>(); + pmQueryWrap.lambda().eq(ParamsManifestEO::getProjectId,projectId); + List pmEoList = this.paramsManifestEOService.list(pmQueryWrap); + List pcmEoList = new ArrayList<>(); + if(CollectionUtils.isNotEmpty(pmEoList)){ + List pmIdList = pmEoList.stream().map(ParamsManifestEO::getId).distinct().collect(Collectors.toList()); + QueryWrapper pcmQueryWrap = new QueryWrapper<>(); + pcmQueryWrap.lambda().in(ParamsCollectManifestEO::getParamsManifestId,pmIdList); + pcmEoList = this.paramsCollectManifestEOService.list(pcmQueryWrap); + } + + Map getProgressParams = new HashMap<>(); + getProgressParams.put("pliEoList",pliEoList); + getProgressParams.put("pciEoList",pciEoList); + getProgressParams.put("pcmEoList",pcmEoList); + + if(ProjectTaskPlanningNameEnum.LEGAL_TASK_CONFIRMATION.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "法规任务确认"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_FGRWQR.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + + JSONObject preNode1 = new JSONObject(); + preNode1.put("nodeName", "认证任务确认"); + preNode1.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_RZRWQR.getValue(),getProgressParams)); + preNode1.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode1); + }else if(ProjectTaskPlanningNameEnum.DESIGN_DEADLINE.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "设计符合性流程"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_SJFHX.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + }else if(ProjectTaskPlanningNameEnum.VERIFY_DEADLINE.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "验证符合性流程"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_YZFHX.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + }else if(ProjectTaskPlanningNameEnum.ATTESTATION_START_TIME.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "Pre-Homo流程"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_PRE_HOMO.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + + JSONObject preNode1 = new JSONObject(); + preNode1.put("nodeName", "参数收集进度"); + preNode1.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_CSSJJD.getValue(),getProgressParams)); + preNode1.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode1); + }else if(ProjectTaskPlanningNameEnum.ATTESTATION_END_TIME.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "认证进度"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_RZJD.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + } + } + return nodeList; + } + + private JSONArray getNodeList(TimeNodeVO nodeTnVo) { + //根据节点获取对应进度和时间 + JSONArray nodeList = new JSONArray(); + if(ObjectUtils.isNotEmpty(nodeTnVo)){ + String projectId = nodeTnVo.getProjectId(); + + QueryWrapper pliQueryWrap = new QueryWrapper<>(); + pliQueryWrap.lambda().eq(ProjectLawsInventoryEO::getProjectLibraryId,projectId); + List pliEoList = this.projectLawsInventoryEOService.list(pliQueryWrap); + + QueryWrapper pciQueryWrap = new QueryWrapper<>(); + pciQueryWrap.lambda().eq(ProjectCertificationInventoryEO::getProjectLibraryId,projectId); + List pciEoList = this.projectCertificationInventoryEOService.list(pciQueryWrap); + + QueryWrapper pmQueryWrap = new QueryWrapper<>(); + pmQueryWrap.lambda().eq(ParamsManifestEO::getProjectId,projectId); + List pmEoList = this.paramsManifestEOService.list(pmQueryWrap); + List pcmEoList = new ArrayList<>(); + if(CollectionUtils.isNotEmpty(pmEoList)){ + List pmIdList = pmEoList.stream().map(ParamsManifestEO::getId).distinct().collect(Collectors.toList()); + QueryWrapper pcmQueryWrap = new QueryWrapper<>(); + pcmQueryWrap.lambda().in(ParamsCollectManifestEO::getParamsManifestId,pmIdList); + pcmEoList = this.paramsCollectManifestEOService.list(pcmQueryWrap); + } + + Map getProgressParams = new HashMap<>(); + getProgressParams.put("pliEoList",pliEoList); + getProgressParams.put("pciEoList",pciEoList); + getProgressParams.put("pcmEoList",pcmEoList); + + if(ProjectTaskPlanningNameEnum.LIST_CONFIRMATION.getName().equals(nodeTnVo.getName()) || ProjectTaskPlanningNameEnum.LEGAL_TASK_CONFIRMATION.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "法规任务确认"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_FGRWQR.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + + JSONObject preNode1 = new JSONObject(); + preNode1.put("nodeName", "认证任务确认"); + preNode1.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_RZRWQR.getValue(),getProgressParams)); + preNode1.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode1); + }else if(ProjectTaskPlanningNameEnum.DESIGN_DEADLINE.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "设计符合性流程"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_SJFHX.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + }else if(ProjectTaskPlanningNameEnum.PREHOMO_DEADLINE.getName().equals(nodeTnVo.getName()) ||ProjectTaskPlanningNameEnum.ATTESTATION_START_TIME.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "Pre-Homo流程"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_PRE_HOMO.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + + JSONObject preNode1 = new JSONObject(); + preNode1.put("nodeName", "参数收集进度"); + preNode1.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_CSSJJD.getValue(),getProgressParams)); + preNode1.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode1); + }else if(ProjectTaskPlanningNameEnum.CERTIFICATION_SUBMISSION.getName().equals(nodeTnVo.getName()) || ProjectTaskPlanningNameEnum.ATTESTATION_END_TIME.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "认证进度"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_RZJD.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + + JSONObject preNode1 = new JSONObject(); + preNode1.put("nodeName", "参数收集进度"); + preNode1.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_CSSJJD.getValue(),getProgressParams)); + preNode1.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode1); + }else if(ProjectTaskPlanningNameEnum.VERIFY_DEADLINE.getName().equals(nodeTnVo.getName())){ + JSONObject preNode = new JSONObject(); + preNode.put("nodeName", "验证符合性流程"); + preNode.put("progress", this.getProgress(nodeTnVo,HSStatisticalNodesEnum.HS_YZFHX.getValue(),getProgressParams)); + preNode.put("date", sdf.format(nodeTnVo.getTime())); + nodeList.add(preNode); + } + } + return nodeList; + } + + public String getProgress(TimeNodeVO nodeTnVo,String statisticalNode,Map params){ + DecimalFormat df = new DecimalFormat("#.00"); + double result = 0; + List pliEoList = (List) params.get("pliEoList"); + List pciEoList = (List) params.get("pciEoList"); + List pcmEoList = (List) params.get("pcmEoList"); + + if (StringUtils.equals(statisticalNode,HSStatisticalNodesEnum.HS_FGRWQR.getValue())) { + int count = pliEoList.size() * 2; + if (count > 0) { + double designCompleteCount = (double) pliEoList.stream().filter(pliEo -> { + boolean flag = ( + StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.RESULTS_TO_BE_SUBMITTED.getValue()) + || StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.RESULTS_TO_BE_REVIEWED.getValue()) + || StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.CONFORMITY.getValue()) + || StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.INCONFORMITY.getValue()) + || StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.TO_TRACK.getValue()) + || StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.UNINVOLVED.getValue()) + || StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.TERMINATION_OF_TASK.getValue()) + ); + return flag; + }).count(); + + double verifyCompleteCount = (double) pliEoList.stream().filter(pliEo -> { + boolean flag = ( + StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.RESULTS_TO_BE_SUBMITTED.getValue()) + || StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.RESULTS_TO_BE_REVIEWED.getValue()) + || StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.CONFORMITY.getValue()) + || StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.INCONFORMITY.getValue()) + || StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.TO_TRACK.getValue()) + || StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.UNINVOLVED.getValue()) + || StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.TERMINATION_OF_TASK.getValue()) + ); + return flag; + }).count(); + + result = ((designCompleteCount + verifyCompleteCount) / count) * 100; + } + } else if (StringUtils.equals(statisticalNode,HSStatisticalNodesEnum.HS_RZRWQR.getValue())) { + int count = pciEoList.size(); + if (count > 0) { + double completeCount = (double) pciEoList.stream().filter(pciEo -> { + boolean flag = ( + StringUtils.equals(pciEo.getFlowStatus(),CertificationInventoryFlowStatusEnum.RESULTS_TO_BE_SUBMITTED.getValue()) + || StringUtils.equals(pciEo.getFlowStatus(),CertificationInventoryFlowStatusEnum.RESULTS_TO_BE_REVIEWED.getValue()) + || StringUtils.equals(pciEo.getFlowStatus(),CertificationInventoryFlowStatusEnum.REVIEW_AND_PASS.getValue()) + || StringUtils.equals(pciEo.getFlowStatus(),CertificationInventoryFlowStatusEnum.REVIEW_AND_RETURN.getValue()) + || StringUtils.equals(pciEo.getFlowStatus(),CertificationInventoryFlowStatusEnum.UNINVOLVED.getValue()) + ); + return flag; + }).count(); + + result = (completeCount / count) * 100; + } + } else if (StringUtils.equals(statisticalNode,HSStatisticalNodesEnum.HS_SJFHX.getValue())) { + int count = pliEoList.size(); + if (count > 0) { + double completeCount = (double) pliEoList.stream().filter(pliEo -> { + boolean flag = ( + StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.CONFORMITY.getValue()) + || StringUtils.equals(pliEo.getDesignFlowStatus(), ComplianceFlowStatusEnum.UNINVOLVED.getValue()) + ); + return flag; + }).count(); + + result = (completeCount / count) * 100; + } + } else if (StringUtils.equals(statisticalNode,HSStatisticalNodesEnum.HS_PRE_HOMO.getValue())) { + int count = pciEoList.size(); + if (count > 0) { + double completeCount = (double) pciEoList.stream().filter(pciEo -> { + boolean flag = ( + StringUtils.equals(pciEo.getFlowStatus(),CertificationInventoryFlowStatusEnum.REVIEW_AND_PASS.getValue()) + || StringUtils.equals(pciEo.getFlowStatus(),CertificationInventoryFlowStatusEnum.UNINVOLVED.getValue()) + ); + return flag; + }).count(); + + result = (completeCount / count) * 100; + } + } else if (StringUtils.equals(statisticalNode,HSStatisticalNodesEnum.HS_RZJD.getValue())) { + // 认证清单认证进度为 实验通过的是完成。 + int count = pciEoList.size(); + if (count > 0) { + double completeCount = (double)pciEoList.stream().filter(pciEo -> { + boolean flag = ( + StringUtils.equals(pciEo.getCertificationProgress(),CertificationProgressEnum.TEST_PASSED.getValue()) + ); + return flag; + }).count(); + + result = (completeCount / count) * 100; + } + } else if (StringUtils.equals(statisticalNode,HSStatisticalNodesEnum.HS_YZFHX.getValue())) { + int count = pliEoList.size(); + if (count > 0) { + double completeCount = (double) pliEoList.stream().filter(pliEo -> { + boolean flag = ( + StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.CONFORMITY.getValue()) + || StringUtils.equals(pliEo.getVerifyFlowStatus(), ComplianceFlowStatusEnum.UNINVOLVED.getValue()) + ); + return flag; + }).count(); + + result = (completeCount / count) * 100; + } + } else if (StringUtils.equals(statisticalNode,HSStatisticalNodesEnum.HS_CSSJJD.getValue())) { + if(CollectionUtils.isNotEmpty(pcmEoList)){ + int count = pcmEoList.size(); + double completeCount = (double) pcmEoList.stream().filter(pcmEo -> { + boolean flag = ( + StringUtils.equals(pcmEo.getState(), CollectManifestStateEnum.SUBMIT.getValue()) + || StringUtils.equals(pcmEo.getState(),CollectManifestStateEnum.SYNC_REPORT.getValue()) + ); + return flag; + }).count(); + + result = (completeCount / count) * 100; + } + } + + return result != 0 ? df.format(result) : "0"; + } + + + @Override + public List queryList(List projectIdList) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.in("id",projectIdList); + List res = this.list(queryWrapper); + return res; + } + + @Override + public List getListByIds(List projectIdList) { + List res = new ArrayList<>(); + if(CollectionUtils.isNotEmpty(projectIdList)){ + res = this.getBaseMapper().getListByIds(projectIdList); + } + return res; + } +} + +