111

blade-service/blade-control/src/main/java/org/springblade/control/mapper/ProjectCostBudgetMapper.java

@@ -110,4 +110,8 @@ public interface ProjectCostBudgetMapper extends BaseMapper<ProjectCostBudget> {
     List<ProjectCostBudgetVO> getDepartmentTimeOutPlan(@Param("costType") Integer costType,@Param("projectId") Long projectId);
 
     List<ProjectCostBudget> getAllMonthBudgetByYear(@Param("year") int y);
+
+    List<ProjectCostBudget> getAllPlanByYear(@Param("year") int y);
+
+    List<ProjectCostBudget> getAllFinishedPlanByYear(@Param("year") int y);
 }

blade-service/blade-control/src/main/java/org/springblade/control/mapper/ProjectCostBudgetMapper.xml

@@ -355,6 +355,16 @@
         WHERE pcb.is_deleted = 0 and pcb.approve = 1
             and DATE_FORMAT(pcb.plan_start_time ,'%Y') = #{year}
     </select>
+    <select id="getAllPlanByYear" resultType="org.springblade.control.entity.ProjectCostBudget">
+        select pcb.* from c_project_cost_budget pcb
+        WHERE (select cdi.dict_value from c_dict_info cdi WHERE cdi.id = pcb.plan_task_type) = 1
+          and (#{year} = DATE_FORMAT(pcb.plan_start_time,'%Y') or #{year} = DATE_FORMAT(pcb.plan_end_time  ,'%Y'))
+    </select>
+    <select id="getAllFinishedPlanByYear" resultType="org.springblade.control.entity.ProjectCostBudget">
+        select pcb.* from c_project_cost_budget pcb
+        WHERE pcb.task_approve = 1 and (select cdi.dict_value from c_dict_info cdi WHERE cdi.id = pcb.plan_task_type) = 1
+          and ('2023' = DATE_FORMAT(pcb.real_plan_start_time ,'%Y') or '2023' = DATE_FORMAT(pcb.practical_finish_time  ,'%Y'))
+    </select>
 
 
 </mapper>

blade-service/blade-control/src/main/java/org/springblade/control/service/IPlanInformService.java

@@ -17,4 +17,5 @@ public interface IPlanInformService extends BaseService<PlanInform> {
 
     //任务完成，传入任务名称.任务人和审批人
     void taskFinishedInform(String taskName,Long taskUser,String appUser,Integer status);
+    void taskFinishedInform2(String taskName,String taskUser,String appUser,Integer status);
 }

blade-service/blade-control/src/main/java/org/springblade/control/service/IProjectCostBudgetService.java

@@ -119,11 +119,18 @@ public interface IProjectCostBudgetService extends BaseService<ProjectCostBudget
     //获取项目的维护预算
     Set<Long> getAllMaintainBudgetId(Long projectId);
 
+    //获取所有项目截至当年的维护支出,分月返回,以费用分类为主键
+    Map<Integer,List<BigDecimal>> getAllMaintainCost9(int year);
+
     //根据年获取已经分配月的计划支出，按12个月返回
     List<BigDecimal> getAllMonthBudgetByYear(int y);
 
-    //获取每月实际的人工支出
+    //根据年获取每月实际的人工支出
     List<BigDecimal> getAllMonthStaffCostByYear(int y);
-    //获取每月实际的维护支出
+    //根据年获取每月实际的维护支出
     List<BigDecimal> getAllMonthMaintainCostByYear(int y);
+    //获取当年所有已经分配时间的固定计划
+    List<ProjectCostBudget> getAllPlanByYear(int y);
+    //获取当年所有已经完成的固定计划
+    List<ProjectCostBudget> getAllFinishedPlanByYear(int y);
 }

blade-service/blade-control/src/main/java/org/springblade/control/service/impl/AnnualBudgetServiceImpl.java

@@ -1069,8 +1069,426 @@ public class AnnualBudgetServiceImpl extends BaseServiceImpl<AnnualBudgetMapper,
      */
     @Override
     public List<BudgetAndPracticalByDeptVO> budgetAndPracticalByDept(String year) {
-        //
-        return null;
+        int y = Integer.parseInt(year.substring(0, 4));
+        //结果集
+        List<BudgetAndPracticalByDeptVO> list = new ArrayList<>();
+        List<String> months = Arrays.asList("一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月");
+        //获取当年所有已经选择时间的固定计划
+        List<ProjectCostBudget> allPlan = budgetService.getAllPlanByYear(y);
+        //如果当年没有计划，则把所有设置为0
+        if (allPlan != null && allPlan.size() > 0){
+            //根据costType分组
+            Map<Integer, List<ProjectCostBudget>> allPlanMap = allPlan.parallelStream()
+                    .collect(Collectors.groupingBy(ProjectCostBudget::getCostType));
+            //获取当年所有已经完成的固定计划
+            //根据costType分组
+            List<ProjectCostBudget> allFinishedPlan = budgetService.getAllFinishedPlanByYear(y);
+            Boolean isFinished = true;
+            Map<Integer, List<ProjectCostBudget>> finishedMap = new HashMap<>();
+            if (allFinishedPlan != null && allFinishedPlan.size() > 0){
+                finishedMap = allFinishedPlan.parallelStream()
+                        .collect(Collectors.groupingBy(ProjectCostBudget::getCostType));
+            }else {
+                isFinished = false;
+            }
+            //维护支出
+
+            //报销支出
+
+            BigDecimal c1 = new BigDecimal(0);
+            BigDecimal c2 = new BigDecimal(0);
+            BigDecimal c3 = new BigDecimal(0);
+            BigDecimal c4 = new BigDecimal(0);
+            BigDecimal c5 = new BigDecimal(0);
+            BigDecimal c6 = new BigDecimal(0);
+            BigDecimal c7 = new BigDecimal(0);
+            BigDecimal c8 = new BigDecimal(0);
+            BigDecimal c9 = new BigDecimal(0);
+            BigDecimal c10 = new BigDecimal(0);
+            //循环12个月,为每个月设置值
+            for (int i = 0; i < 12; i++) {
+                BudgetAndPracticalByDeptVO vo = new BudgetAndPracticalByDeptVO();
+                //设置月份
+                vo.setTime(months.get(i));
+                //设置市场部
+                List<ProjectCostBudget> b1 = allPlanMap.get(1);
+                if (b1 != null && b1.size() > 0){
+                    BigDecimal big = new BigDecimal(0);
+                    //循环市场部每一个预算
+                    for (ProjectCostBudget budget : b1) {
+                        //如果开始时间或结束时间是当月，则添加预算
+                        if ((budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y)
+                            || (budget.getPlanEndTime().getMonthValue() == (i+1) && budget.getPlanEndTime().getYear() == y)){
+                            //如果开始时间和结束时间的月相同，则直接用总预算
+                            if (budget.getPlanIsTwoMonth() == 0){
+                                big = big.add(budget.getPlanStaffCost());
+                            }else {
+                                //如果开始月是当前月，则直接使用开始金额
+                                if (budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y){
+                                    big = big.add(budget.getPlanStartMoney());
+                                }else {
+                                    //结束月是当前月，使用结束金额
+                                    big = big.add(budget.getPlanEndMoney());
+                                }
+                            }
+                        }
+                    }
+                    vo.setBudget1(big);
+                    c1 = c1.add(big);
+                }else {
+                    vo.setBudget1(new BigDecimal(0));
+                }
+                if (isFinished){
+                    List<ProjectCostBudget> d1 = finishedMap.get(1);
+                    if (d1 != null && d1.size() > 0){
+                        BigDecimal big = new BigDecimal(0);
+                        //循环市场部每一个支出
+                        for (ProjectCostBudget budget : d1) {
+                            //如果实际开始时间或实际结束时间是当月，则添加支出
+                            if ((budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y)
+                                    || (budget.getPracticalFinishTime().getMonthValue() == (i+1) && budget.getPracticalFinishTime().getYear() == y)){
+                                //如果开始时间和结束时间的月相同，则直接用总预算
+                                if (budget.getIsTwoMonth() == 0){
+                                    big = big.add(budget.getActualTotalMoney());
+                                }else {
+                                    //如果开始月是当前月，则直接使用开始金额
+                                    if (budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y){
+                                        big = big.add(budget.getPracticalStartMoney());
+                                    }else {
+                                        //结束月是当前月，使用结束金额
+                                        big = big.add(budget.getPracticalEndMoney());
+                                    }
+                                }
+                            }
+                        }
+                        vo.setPractical1(big);
+                        c2 = c2.add(big);
+                    }else {
+                        vo.setBudget1(new BigDecimal(0));
+                    }
+                }
+
+                //设置研发部
+                List<ProjectCostBudget> b2 = allPlanMap.get(2);
+                if (b2 != null && b2.size() > 0){
+                    BigDecimal big = new BigDecimal(0);
+                    //循环研发部每一个预算
+                    for (ProjectCostBudget budget : b2) {
+                        //如果开始时间或结束时间是当月，则添加预算
+                        if ((budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y)
+                                || (budget.getPlanEndTime().getMonthValue() == (i+1) && budget.getPlanEndTime().getYear() == y)){
+                            //如果开始时间和结束时间的月相同，则直接用总预算
+                            if (budget.getPlanIsTwoMonth() == 0){
+                                big = big.add(budget.getPlanStaffCost());
+                            }else {
+                                //如果开始月是当前月，则直接使用开始金额
+                                if (budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y){
+                                    big = big.add(budget.getPlanStartMoney());
+                                }else {
+                                    //结束月是当前月，使用结束金额
+                                    big = big.add(budget.getPlanEndMoney());
+                                }
+                            }
+                        }
+                    }
+                    vo.setBudget2(big);
+                    c3 = c3.add(big);
+                }else {
+                    vo.setBudget2(new BigDecimal(0));
+                }
+                if (isFinished){
+                    List<ProjectCostBudget> d2 = finishedMap.get(2);
+                    if (d2 != null && d2.size() > 0){
+                        BigDecimal big = new BigDecimal(0);
+                        //循环市场部每一个支出
+                        for (ProjectCostBudget budget : d2) {
+                            //如果实际开始时间或实际结束时间是当月，则添加支出
+                            if ((budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y)
+                                    || (budget.getPracticalFinishTime().getMonthValue() == (i+1) && budget.getPracticalFinishTime().getYear() == y)){
+                                //如果开始时间和结束时间的月相同，则直接用总预算
+                                if (budget.getIsTwoMonth() == 0){
+                                    big = big.add(budget.getActualTotalMoney());
+                                }else {
+                                    //如果开始月是当前月，则直接使用开始金额
+                                    if (budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y){
+                                        big = big.add(budget.getPracticalStartMoney());
+                                    }else {
+                                        //结束月是当前月，使用结束金额
+                                        big = big.add(budget.getPracticalEndMoney());
+                                    }
+                                }
+                            }
+                        }
+                        vo.setPractical2(big);
+                        c4 = c4.add(big);
+                    }else {
+                        vo.setPractical2(new BigDecimal(0));
+                    }
+                }
+
+                //设置实施部
+                List<ProjectCostBudget> b3 = allPlanMap.get(3);
+                if (b3 != null && b3.size() > 0){
+                    BigDecimal big = new BigDecimal(0);
+                    //循环研发部每一个预算
+                    for (ProjectCostBudget budget : b3) {
+                        //如果开始时间或结束时间是当月，则添加预算
+                        if ((budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y)
+                                || (budget.getPlanEndTime().getMonthValue() == (i+1) && budget.getPlanEndTime().getYear() == y)){
+                            //如果开始时间和结束时间的月相同，则直接用总预算
+                            if (budget.getPlanIsTwoMonth() == 0){
+                                big = big.add(budget.getPlanStaffCost());
+                            }else {
+                                //如果开始月是当前月，则直接使用开始金额
+                                if (budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y){
+                                    big = big.add(budget.getPlanStartMoney());
+                                }else {
+                                    //结束月是当前月，使用结束金额
+                                    big = big.add(budget.getPlanEndMoney());
+                                }
+                            }
+                        }
+                    }
+                    vo.setBudget3(big);
+                    c5 = c5.add(big);
+                }else {
+                    vo.setBudget3(new BigDecimal(0));
+                }
+                if (isFinished){
+                    List<ProjectCostBudget> d3 = finishedMap.get(3);
+                    if (d3 != null && d3.size() > 0){
+                        BigDecimal big = new BigDecimal(0);
+                        //循环市场部每一个支出
+                        for (ProjectCostBudget budget : d3) {
+                            //如果实际开始时间或实际结束时间是当月，则添加支出
+                            if ((budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y)
+                                    || (budget.getPracticalFinishTime().getMonthValue() == (i+1) && budget.getPracticalFinishTime().getYear() == y)){
+                                //如果开始时间和结束时间的月相同，则直接用总预算
+                                if (budget.getIsTwoMonth() == 0){
+                                    big = big.add(budget.getActualTotalMoney());
+                                }else {
+                                    //如果开始月是当前月，则直接使用开始金额
+                                    if (budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y){
+                                        big = big.add(budget.getPracticalStartMoney());
+                                    }else {
+                                        //结束月是当前月，使用结束金额
+                                        big = big.add(budget.getPracticalEndMoney());
+                                    }
+                                }
+                            }
+                        }
+                        vo.setPractical3(big);
+                        c6 = c6.add(big);
+                    }else {
+                        vo.setPractical3(new BigDecimal(0));
+                    }
+                }
+
+                //设置维护部
+                List<ProjectCostBudget> b4 = allPlanMap.get(4);
+                if (b4 != null && b4.size() > 0){
+                    BigDecimal big = new BigDecimal(0);
+                    //循环研发部每一个预算
+                    for (ProjectCostBudget budget : b4) {
+                        //如果开始时间或结束时间是当月，则添加预算
+                        if ((budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y)
+                                || (budget.getPlanEndTime().getMonthValue() == (i+1) && budget.getPlanEndTime().getYear() == y)){
+                            //如果开始时间和结束时间的月相同，则直接用总预算
+                            if (budget.getPlanIsTwoMonth() == 0){
+                                big = big.add(budget.getPlanStaffCost());
+                            }else {
+                                //如果开始月是当前月，则直接使用开始金额
+                                if (budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y){
+                                    big = big.add(budget.getPlanStartMoney());
+                                }else {
+                                    //结束月是当前月，使用结束金额
+                                    big = big.add(budget.getPlanEndMoney());
+                                }
+                            }
+                        }
+                    }
+                    vo.setBudget4(big);
+                    c7 = c7.add(big);
+                }else {
+                    vo.setBudget4(new BigDecimal(0));
+                }
+                if (isFinished){
+                    List<ProjectCostBudget> d4 = finishedMap.get(4);
+                    if (d4 != null && d4.size() > 0){
+                        BigDecimal big = new BigDecimal(0);
+                        //循环市场部每一个支出
+                        for (ProjectCostBudget budget : d4) {
+                            //如果实际开始时间或实际结束时间是当月，则添加支出
+                            if ((budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y)
+                                    || (budget.getPracticalFinishTime().getMonthValue() == (i+1) && budget.getPracticalFinishTime().getYear() == y)){
+                                //如果开始时间和结束时间的月相同，则直接用总预算
+                                if (budget.getIsTwoMonth() == 0){
+                                    big = big.add(budget.getActualTotalMoney());
+                                }else {
+                                    //如果开始月是当前月，则直接使用开始金额
+                                    if (budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y){
+                                        big = big.add(budget.getPracticalStartMoney());
+                                    }else {
+                                        //结束月是当前月，使用结束金额
+                                        big = big.add(budget.getPracticalEndMoney());
+                                    }
+                                }
+                            }
+                        }
+                        vo.setPractical4(big);
+                        c8 = c8.add(big);
+                    }else {
+                        vo.setPractical4(new BigDecimal(0));
+                    }
+                }
+
+                //设置管理中心 = 管理支出+外包劳务
+                BigDecimal big1 = new BigDecimal(0);
+                BigDecimal big2 = new BigDecimal(0);
+                List<ProjectCostBudget> b5 = allPlanMap.get(5);
+                if (b5 != null && b5.size() > 0){
+                    //循环研发部每一个预算
+                    for (ProjectCostBudget budget : b5) {
+                        //如果开始时间或结束时间是当月，则添加预算
+                        if ((budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y)
+                                || (budget.getPlanEndTime().getMonthValue() == (i+1) && budget.getPlanEndTime().getYear() == y)){
+                            //如果开始时间和结束时间的月相同，则直接用总预算
+                            if (budget.getPlanIsTwoMonth() == 0){
+                                big1 = big1.add(budget.getPlanStaffCost());
+                            }else {
+                                //如果开始月是当前月，则直接使用开始金额
+                                if (budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y){
+                                    big1 = big1.add(budget.getPlanStartMoney());
+                                }else {
+                                    //结束月是当前月，使用结束金额
+                                    big1 = big1.add(budget.getPlanEndMoney());
+                                }
+                            }
+                        }
+                    }
+                }
+                if (isFinished){
+                    List<ProjectCostBudget> d5 = finishedMap.get(5);
+                    if (d5 != null && d5.size() > 0){
+                        //循环市场部每一个支出
+                        for (ProjectCostBudget budget : d5) {
+                            //如果实际开始时间或实际结束时间是当月，则添加支出
+                            if ((budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y)
+                                    || (budget.getPracticalFinishTime().getMonthValue() == (i+1) && budget.getPracticalFinishTime().getYear() == y)){
+                                //如果开始时间和结束时间的月相同，则直接用总预算
+                                if (budget.getIsTwoMonth() == 0){
+                                    big2 = big2.add(budget.getActualTotalMoney());
+                                }else {
+                                    //如果开始月是当前月，则直接使用开始金额
+                                    if (budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y){
+                                        big2 = big2.add(budget.getPracticalStartMoney());
+                                    }else {
+                                        //结束月是当前月，使用结束金额
+                                        big2 = big2.add(budget.getPracticalEndMoney());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                List<ProjectCostBudget> b6 = allPlanMap.get(6);
+                if (b6 != null && b6.size() > 0){
+                    //循环研发部每一个预算
+                    for (ProjectCostBudget budget : b6) {
+                        //如果开始时间或结束时间是当月，则添加预算
+                        if ((budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y)
+                                || (budget.getPlanEndTime().getMonthValue() == (i+1) && budget.getPlanEndTime().getYear() == y)){
+                            //如果开始时间和结束时间的月相同，则直接用总预算
+                            if (budget.getPlanIsTwoMonth() == 0){
+                                big1 = big1.add(budget.getPlanStaffCost());
+                            }else {
+                                //如果开始月是当前月，则直接使用开始金额
+                                if (budget.getPlanStartTime().getMonthValue() == (i+1) && budget.getPlanStartTime().getYear() == y){
+                                    big1 = big1.add(budget.getPlanStartMoney());
+                                }else {
+                                    //结束月是当前月，使用结束金额
+                                    big1 = big1.add(budget.getPlanEndMoney());
+                                }
+                            }
+                        }
+                    }
+                }
+                if (isFinished){
+                    List<ProjectCostBudget> d6 = finishedMap.get(6);
+                    if (d6 != null && d6.size() > 0){
+                        //循环市场部每一个支出
+                        for (ProjectCostBudget budget : d6) {
+                            //如果实际开始时间或实际结束时间是当月，则添加支出
+                            if ((budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y)
+                                    || (budget.getPracticalFinishTime().getMonthValue() == (i+1) && budget.getPracticalFinishTime().getYear() == y)){
+                                //如果开始时间和结束时间的月相同，则直接用总预算
+                                if (budget.getIsTwoMonth() == 0){
+                                    big2 = big2.add(budget.getActualTotalMoney());
+                                }else {
+                                    //如果开始月是当前月，则直接使用开始金额
+                                    if (budget.getRealPlanStartTime().getMonthValue() == (i+1) && budget.getRealPlanStartTime().getYear() == y){
+                                        big2 = big2.add(budget.getPracticalStartMoney());
+                                    }else {
+                                        //结束月是当前月，使用结束金额
+                                        big2 = big2.add(budget.getPracticalEndMoney());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                vo.setBudget5(big1);
+                c9 = c9.add(big1);
+                vo.setPractical5(big2);
+                c10 = c10.add(big2);
+                list.add(vo);
+            }
+            //计算总计
+            BudgetAndPracticalByDeptVO vo2 = new BudgetAndPracticalByDeptVO();
+            vo2.setTime("总计");
+            vo2.setBudget1(c1);
+            vo2.setPractical1(c2);
+            vo2.setBudget2(c3);
+            vo2.setPractical2(c4);
+            vo2.setBudget3(c5);
+            vo2.setPractical3(c6);
+            vo2.setBudget4(c7);
+            vo2.setPractical4(c8);
+            vo2.setBudget5(c9);
+            vo2.setPractical5(c10);
+            list.add(vo2);
+            return list;
+        }else {
+            for (int i = 0; i < 12; i++) {
+                BudgetAndPracticalByDeptVO vo = new BudgetAndPracticalByDeptVO();
+                vo.setTime(months.get(i));
+                vo.setBudget1(new BigDecimal(0));
+                vo.setBudget1(new BigDecimal(0));
+                vo.setBudget1(new BigDecimal(0));
+                vo.setBudget1(new BigDecimal(0));
+                vo.setBudget1(new BigDecimal(0));
+                vo.setPractical1(new BigDecimal(0));
+                vo.setPractical1(new BigDecimal(0));
+                vo.setPractical1(new BigDecimal(0));
+                vo.setPractical1(new BigDecimal(0));
+                vo.setPractical1(new BigDecimal(0));
+                list.add(vo);
+            }
+            BudgetAndPracticalByDeptVO vo = new BudgetAndPracticalByDeptVO();
+            vo.setTime("总计");
+            vo.setBudget1(new BigDecimal(0));
+            vo.setBudget1(new BigDecimal(0));
+            vo.setBudget1(new BigDecimal(0));
+            vo.setBudget1(new BigDecimal(0));
+            vo.setBudget1(new BigDecimal(0));
+            vo.setPractical1(new BigDecimal(0));
+            vo.setPractical1(new BigDecimal(0));
+            vo.setPractical1(new BigDecimal(0));
+            vo.setPractical1(new BigDecimal(0));
+            vo.setPractical1(new BigDecimal(0));
+            list.add(vo);
+            return list;
+        }
     }
 
     /**

blade-service/blade-control/src/main/java/org/springblade/control/service/impl/PlanInformServiceImpl.java

@@ -27,6 +27,7 @@ import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -63,6 +64,8 @@ public class PlanInformServiceImpl extends BaseServiceImpl<PlanInformMapper, Pla
             str.append("《" + taskName + "》" + "已被" + "【" + appUserName + "】" + "变成为已完成状态");
         }else if (status == 3){
             str.append("《" + taskName + "》" + "已被" + "【" + appUserName + "】" + "驳回");
+        }else if (status == 1){
+            str.append("【" + appUserName + "】" + "向您发起《"+taskName+"》审批");
         }
         PlanInform inform = new PlanInform();
         inform.setInformDetails(str.toString());
@@ -70,4 +73,28 @@ public class PlanInformServiceImpl extends BaseServiceImpl<PlanInformMapper, Pla
         inform.setInformDate(LocalDateTime.now());
         baseMapper.insert(inform);
     }
+
+    /**
+     * 任务审批后插入日志信息
+     * @param taskName 任务名称
+     * @param taskUser 任务人Id
+     * @param appUserName 审批人名称
+     * @param status 审批状态 0=未上报 1=待审批 2=已审批 3=已驳回
+     */
+    @Override
+    public void taskFinishedInform2(String taskName, String taskUser, String appUserName,Integer status) {
+        StringBuilder str = new StringBuilder();
+        String[] split = taskUser.split(",");
+        List<PlanInform> list = new ArrayList<>();
+        for (String s : split) {
+            str.append("【" + appUserName + "】" + "向您发起《"+taskName+"》审批");
+            PlanInform inform = new PlanInform();
+            inform.setInformDetails(str.toString());
+            inform.setInformUser(Long.parseLong(s));
+            inform.setInformDate(LocalDateTime.now());
+            list.add(inform);
+        }
+        this.saveBatch(list);
+    }
+
 }

blade-service/blade-control/src/main/java/org/springblade/control/service/impl/ProjectCostBudgetServiceImpl.java

@@ -1706,6 +1706,132 @@ public class ProjectCostBudgetServiceImpl extends BaseServiceImpl<ProjectCostBud
         return null;
     }
 
+    /**
+     * //获取所有项目截至当年的维护支出,分月返回,费用分类为主键
+     * @param year
+     * @return
+     */
+    @Override
+    public Map<Integer,List<BigDecimal>> getAllMaintainCost9(int year) {
+        //获取所有已分配任务人的维护支出，如果没有返回0
+        List<ProjectCostBudget> plans = baseMapper.getAllMaintainPlan();
+        if (plans != null && plans.size() > 0) {
+            //分离出主计划和子计划，建立主计划的id，set集合
+            Set<Long> bab = new HashSet<>();
+            for (ProjectCostBudget plan : plans) {
+                if (plan.getParentId() == 0) {
+                    bab.add(plan.getId());
+                } else {
+                    bab.add(plan.getParentId());
+                }
+            }
+            //查询出所有维护计划，根据项目id分组
+            List<ProjectCostBudget> budgets = this.listByIds(bab);
+            Map<Long, List<ProjectCostBudget>> budgetMap = budgets.parallelStream()
+                    .collect(Collectors.groupingBy(ProjectCostBudget::getProjectId));
+            //查询出所有项目
+            List<ControlProjectInfo> projectInfos = infoMapper.selectList(new LambdaQueryWrapper<ControlProjectInfo>().in(ControlProjectInfo::getId, budgetMap.keySet()));
+            //通过项目id查询出所有的合同，如果项目没有合同则提示，项目没有合同，无法计算维护支出
+            List<ControlContractInfo> contractList = contractService.getContractByYear(year, budgetMap.keySet());
+            if (contractList == null || contractList.size() <= 0){
+                return null;
+            }
+            //把合同根据项目分组
+            Map<Long, List<ControlContractInfo>> contractMap = contractList.parallelStream()
+                    .collect(Collectors.groupingBy(ControlContractInfo::getProjectId));
+            //返回结果
+            Map<Long,List<BigDecimal>> map = new HashMap<>();
+            //循环项目，
+            for (ControlProjectInfo info : projectInfos) {
+                List<ControlContractInfo> infos = contractMap.get(info.getId());
+                if (infos == null || infos.size() == 0){
+                    continue;
+                }
+                //获取合同时间，获取多少个月
+                ControlContractInfo contract = contractMap.get(info.getId()).get(0);
+                LocalDate startTime = contract.getStartTime();
+                LocalDate endTime = contract.getEndTime();
+                int years = endTime.getYear() - startTime.getYear();
+                int months = years * 12 + (endTime.getMonthValue() - startTime.getMonthValue()) + 1;
+                //每个项目的维护总和 / 多少个月 = 该项目每个月的维护费
+                List<ProjectCostBudget> list = budgetMap.get(info.getId());
+                BigDecimal big = new BigDecimal(0);
+                for (ProjectCostBudget l : list) {
+                    big = big.add(l.getBudgetStaffCost());
+                }
+                if (big.compareTo(new BigDecimal(0)) == 0){
+                    continue;
+                }
+                //获得每个月的维护费
+                BigDecimal scale = big.divide(new BigDecimal(months),2,RoundingMode.HALF_UP).setScale(2, RoundingMode.HALF_UP);
+                // 当前日期和合同开始时间比较，相差多少月  月 * 每个月维护费 = 当前项目截至当前的所有维护费
+                if (LocalDate.now().compareTo(startTime) < 0){
+                    continue;
+                }
+                int startMonth = 0;
+                int endMonth = 0;
+                //判断是否查询今年
+                if (LocalDate.now().getYear() == year){
+                    //如果合同开始日期大于今年，则开始时间从一月算起
+                    if (startTime.getYear() < year){
+                        startMonth = 1;
+                    }else {
+                        //如果合同开始日期比今天要大，则不计算维护费
+                        if (startTime.getMonthValue() > LocalDate.now().getMonthValue()){
+                            continue;
+                        }else {
+                            //开始日期比今天小，从开始日期开始计算
+                            startMonth = startTime.getMonthValue();
+                        }
+                    }
+                    //如果合同时间大于当前，就用当前时间，如果合同时间小于当前，就用合同时间 -做结束时间
+                    if (endTime.compareTo(LocalDate.now()) > 0){
+                        endMonth = LocalDate.now().getMonthValue();
+                    }else {
+                        endMonth = endTime.getMonthValue();
+                    }
+                }else {
+                    //不是今年
+                    if (startTime.getYear() > year){
+                        continue;
+                    }else if (startTime.getYear() < year) {
+                        startMonth = 1;
+                    }else {
+                        //如果合同开始月比1月要大，则用开始日期
+                        if (startTime.getMonthValue() > 1){
+                            startMonth = startTime.getMonthValue();
+                        }else {
+                            //开始月比1或者等于1，从1开始计算
+                            startMonth = 1;
+                        }
+                    }
+                    //如果合同时间大于当前，就用当前时间
+                    if (endTime.getYear() > year){
+                        endMonth = 12;
+                    }else {
+                        if (endTime.getMonthValue() < 12) {
+                            endMonth = endTime.getMonthValue();
+                        }else {
+                            endMonth = 12;
+                        }
+                    }
+                }
+                //为项目设置值
+                List<BigDecimal> decimalList = new ArrayList<>();
+                for (int i = 1; i <= 12; i++) {
+                    if (i >= startMonth && i <= endMonth){
+                        decimalList.add(scale);
+                    }else {
+                        decimalList.add(new BigDecimal(0));
+                    }
+                }
+                map.put(info.getId(),decimalList);
+            }
+            return null;
+        }
+        return null;
+    }
+
     /**
      * //获取所有项目截至当年的维护支出,按年返回
      * @param year
@@ -2233,6 +2359,24 @@ public class ProjectCostBudgetServiceImpl extends BaseServiceImpl<ProjectCostBud
         return list;
     }
 
+    /**获取当年所有已经分配时间的固定计划
+     * @param y
+     * @return
+     */
+    @Override
+    public List<ProjectCostBudget> getAllPlanByYear(int y) {
+        return baseMapper.getAllPlanByYear(y);
+    }
+
+    /**获取当年所有已经完成的固定计划
+     * @param y
+     * @return
+     */
+    @Override
+    public List<ProjectCostBudget> getAllFinishedPlanByYear(int y) {
+        return baseMapper.getAllFinishedPlanByYear(y);
+    }
+
     /**
      * 统计一行的几个总金额
      */