Merge branch 'master' of http://124.70.58.209:3000/ytrd-project-management/purchase

purchase-admin/src/main/java/com/ozs/web/controller/base/BaseProfessionalController.java

@@ -5,9 +5,12 @@ import com.ozs.base.domain.vo.BaseProfessionalVo;
 import com.ozs.base.service.BaseProfessionalService;
 import com.ozs.common.core.controller.BaseController;
 import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.common.core.domain.model.LoginUser;
 import com.ozs.common.exception.ServiceException;
 import com.ozs.common.utils.StringUtils;
 import com.ozs.common.utils.poi.ExcelUtil;
+import com.ozs.plan.doman.ProvisionalPlan;
+import com.ozs.plan.doman.vo.requestVo.ProvisionalPlanVo;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -36,8 +39,9 @@ public class BaseProfessionalController extends BaseController {
         if (StringUtils.isNull(baseProfessional)
                 || StringUtils.isNull(baseProfessional.getProfessionalName())
                 || StringUtils.isNull(baseProfessional.getProfessionalCode())
-                || StringUtils.isNull(baseProfessional.getProfessionalGrade())) {
-            return error("专业库名称、编码、一级分类不能为空");
+                || StringUtils.isNull(baseProfessional.getProfessionalGrade())
+                || StringUtils.isNull(baseProfessional.getParentCode())) {
+            return error("专业库名称、编码、一级分类、父级ID 不能为空");
         }
         return toAjax(baseProfessionalService.save(baseProfessional));
     }
@@ -70,28 +74,28 @@ public class BaseProfessionalController extends BaseController {
     @ApiOperation(value = "查询专业库树结构", notes = "非必传 查询条件：品目名称")
     @PostMapping("/selectBaseProfessional")
     public AjaxResult selectBaseProfessional(@RequestBody BaseProfessionalVo baseProfessionalVo) {
-        List<BaseProfessionalVo> baseSupplierList = baseProfessionalService.selectBaseProfessional(baseProfessionalVo);
+        List<BaseProfessionalVo> baseSupplierList = baseProfessionalService.selectBaseProfessionalVo(baseProfessionalVo);
         return success(baseSupplierList);
     }
 
     @ApiOperation(value = "导入专业库", notes = "导入表格")
     @PostMapping("/importBaseProfessional")
-    public AjaxResult importBaseProfessional(@RequestBody MultipartFile file) throws Exception {
-        ExcelUtil<BaseProfessional> util = new ExcelUtil<BaseProfessional>(BaseProfessional.class);
+    public AjaxResult importBaseProfessional(MultipartFile file, boolean updateSupport) throws Exception {
+        ExcelUtil<BaseProfessional> util = new ExcelUtil<>(BaseProfessional.class);
         List<BaseProfessional> baseProfessionalList = util.importExcel(file.getInputStream());
         if (StringUtils.isNull(baseProfessionalList) || baseProfessionalList.size() == 0) {
             throw new ServiceException("导入专业库数据不能为空！");
         }
         // String operName = getUsername();
-        String message = baseProfessionalService.importBaseProfessional(baseProfessionalList);
+        String message = baseProfessionalService.importBaseProfessional(baseProfessionalList, updateSupport);
         return success(message);
     }
 
     @ApiOperation("导出专业库")
     @PostMapping("/exportBaseProfessional")
-    public void exportBaseProfessional(HttpServletResponse response, BaseProfessional baseProfessional) {
-        List<BaseProfessional> list = baseProfessionalService.selectBaseProfessional(baseProfessional);
-        ExcelUtil<BaseProfessional> util = new ExcelUtil<BaseProfessional>(BaseProfessional.class);
-        util.exportExcel(response, list, "参数数据");
+    public void exportBaseProfessional(HttpServletResponse response, @RequestBody BaseProfessionalVo baseProfessionalVo) {
+        List<BaseProfessional> list = baseProfessionalService.selectBaseProfessional(baseProfessionalVo);
+        ExcelUtil<BaseProfessional> util = new ExcelUtil<>(BaseProfessional.class);
+        util.exportExcel(response, list, "专业库数据");
     }
 }

purchase-admin/src/main/java/com/ozs/web/controller/plan/PlanQuarterController.java

@@ -0,0 +1,156 @@
+package com.ozs.web.controller.plan;
+
+import com.github.pagehelper.PageInfo;
+import com.ozs.common.core.controller.BaseController;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.common.core.domain.model.LoginUser;
+import com.ozs.common.utils.poi.ExcelUtil;
+import com.ozs.framework.web.service.TokenService;
+import com.ozs.plan.doman.PlanQuarter;
+import com.ozs.plan.doman.vo.requestVo.PlanQuarterStandardVo;
+import com.ozs.plan.doman.vo.requestVo.PlanYearsStandardVo;
+import com.ozs.plan.service.PlanQuarterService;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.List;
+
+/**
+ * 季度计划信息控制层
+ *
+ * @author buzhanyi
+ */
+@RestController
+@RequestMapping("/plan/quarter")
+public class PlanQuarterController extends BaseController {
+    @Autowired
+    private PlanQuarterService quarterService;
+    @Autowired
+    private TokenService tokenService;
+
+    @ApiOperation(value = "查询季度计划")
+    @PostMapping("/list")
+    public AjaxResult list(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+        PageInfo<PlanQuarter> page = quarterService.selectPlanQuarterList(quarterStandardVo);
+        return AjaxResult.success(page);
+    }
+
+    @ApiOperation(value = "审核单位查询季度计划")
+    @PostMapping("/examineList")
+    public AjaxResult examineList(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+        PageInfo<PlanQuarter> page = quarterService.selectPlanQuarterExamineList(quarterStandardVo);
+        return AjaxResult.success(page);
+    }
+
+    @ApiOperation(value = "导出季度计划数据")
+    @PostMapping("/exportPlan")
+    public void exportPlan(HttpServletResponse response, @RequestBody PlanQuarterStandardVo quarterStandardVo) throws Exception {
+        List<PlanQuarter> list = quarterService.selectPlanQuarterListEXP(quarterStandardVo);
+        ExcelUtil<PlanQuarter> util = new ExcelUtil<>(PlanQuarter.class);
+        util.exportExcel(response, list, "季度计划数据");
+    }
+
+    @ApiOperation(value = "导出季度计划数据(审核单位)")
+    @PostMapping("/exportPlanExamine")
+    public void exportPlanExamine(HttpServletResponse response, @RequestBody PlanQuarterStandardVo quarterStandardVo) throws Exception {
+        List<PlanQuarter> list = quarterService.selectPlanQuarterExamineListEXP(quarterStandardVo);
+        ExcelUtil<PlanQuarter> util = new ExcelUtil<>(PlanQuarter.class);
+        util.exportExcel(response, list, "季度计划数据(审核单位)");
+    }
+
+    @ApiOperation(value = "创建季度计划")
+    @PostMapping("/add")
+    public AjaxResult add(@RequestBody PlanQuarterStandardVo quarterStandardVo, HttpServletRequest request) {
+        //获取采购单位-
+        LoginUser loginUser = tokenService.getLoginUser(request);
+        quarterStandardVo.setPurchaseDeptId(String.valueOf(loginUser.getDeptId()));
+        quarterStandardVo.setCreated(String.valueOf(loginUser.getUserId()));
+        return quarterService.insertPlanQuarter(quarterStandardVo);
+    }
+
+    @ApiOperation(value = "修改季度计划")
+    @PostMapping("/update")
+    public AjaxResult update(@RequestBody PlanQuarterStandardVo quarterStandardVo, HttpServletRequest request) {
+        LoginUser loginUser = tokenService.getLoginUser(request);
+        quarterStandardVo.setUpdated(String.valueOf(loginUser.getUserId()));
+        return quarterService.update(quarterStandardVo);
+    }
+
+    @ApiOperation(value = "提交季度计划")
+    @PostMapping("/commit")
+    public AjaxResult commit(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+        return quarterService.commit(quarterStandardVo);
+    }
+
+    @ApiOperation(value = "删除季度计划")
+    @PostMapping("/delete")
+    public AjaxResult delete(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+        return quarterService.deletePlanQuarterById(quarterStandardVo.getPlanPracticalId());
+    }
+
+    @ApiOperation(value = "根据id获取季度计划信息")
+    @PostMapping("/view")
+    public AjaxResult view(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+        return quarterService.view(quarterStandardVo);
+    }
+
+    @ApiOperation(value = "审核季度计划通过")
+    @PostMapping("/reviewTo")
+    public AjaxResult reviewTo(@RequestBody PlanQuarterStandardVo quarterStandardVo, HttpServletRequest request) {
+        LoginUser loginUser = tokenService.getLoginUser(request);
+        quarterStandardVo.setUpdated(String.valueOf(loginUser.getUserId()));
+        return quarterService.reviewTo(quarterStandardVo);
+    }
+
+    @ApiOperation(value = "审核季度计划退回")
+    @PostMapping("/reviewReturn")
+    public AjaxResult reviewReturn(@RequestBody PlanQuarterStandardVo quarterStandardVo, HttpServletRequest request) {
+        LoginUser loginUser = tokenService.getLoginUser(request);
+        quarterStandardVo.setUpdated(String.valueOf(loginUser.getUserId()));
+        return quarterService.reviewReturn(quarterStandardVo);
+    }
+
+    @ApiOperation(value = "申请修改季度计划")
+    @PostMapping("/appUpdate")
+    public AjaxResult appUpdate(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+        return quarterService.appUpdate(quarterStandardVo);
+    }
+
+    @ApiOperation(value = "发函催告")
+    @PostMapping("/sendLetter")
+    public AjaxResult sendLetter(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+        return quarterService.sendLetter(quarterStandardVo);
+    }
+
+    @ApiOperation(value = "上传计划关联文件后保存文件信息")
+    @PostMapping("/upLoadPlanFile")
+    public AjaxResult upLoadPlanFile(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+        return quarterService.upLoadPlanFile(quarterStandardVo);
+    }
+    //
+    //@ApiOperation(value = "下载计划关联文件")
+    //@PostMapping("/downLoadPlanFile")
+    //public AjaxResult downLoadPlanFile(@RequestBody PlanQuarterStandardVo quarterStandardVo) {
+    //    return quarterService.downLoadPlanFile(quarterStandardVo);
+    //}
+
+    @ApiOperation(value = "导入季度计划数据")
+    @PostMapping("/importData")
+    public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception {
+        ExcelUtil<PlanQuarterStandardVo> util = new ExcelUtil<>(PlanQuarterStandardVo.class);
+        List<PlanQuarterStandardVo> quarter = util.importExcel(file.getInputStream());
+        //获取采购单位-
+        LoginUser loginUser = getLoginUser();
+        String message = quarterService.importPlanQuarter(quarter, updateSupport, loginUser);
+        return success(message);
+    }
+
+
+}

purchase-admin/src/main/java/com/ozs/web/controller/plan/PlanYearsController.java

@@ -60,9 +60,8 @@ public class PlanYearsController extends BaseController {
     @ApiOperation(value = "导出年度计划数据(审核单位)")
     @PostMapping("/exportPlanExamine")
     public void exportPlanExamine(HttpServletResponse response, @RequestBody PlanYearsStandardVo yearsStandardVo) throws Exception {
-        PageInfo<PlanYears> page = planYearsService.selectPlanYearsExamineList(yearsStandardVo);
-        List<PlanYears> list = page.getList();
-        ExcelUtil<PlanYears> util = new ExcelUtil<PlanYears>(PlanYears.class);
+        List<PlanYears> list = planYearsService.selectPlanYearsExamineListEXP(yearsStandardVo);
+        ExcelUtil<PlanYears> util = new ExcelUtil<>(PlanYears.class);
         util.exportExcel(response, list, "年度计划数据(审核单位)");
     }
 
@@ -71,7 +70,7 @@ public class PlanYearsController extends BaseController {
     public AjaxResult add(@RequestBody PlanYearsStandardVo yearsStandardVo, HttpServletRequest request) {
         //获取采购单位-
         LoginUser loginUser = tokenService.getLoginUser(request);
-        yearsStandardVo.setPurchaseDeptId(loginUser.getDeptId());
+        yearsStandardVo.setPurchaseDeptId(String.valueOf(loginUser.getDeptId()));
         yearsStandardVo.setCreated(String.valueOf(loginUser.getUserId()));
         return planYearsService.insertPlanYears(yearsStandardVo);
     }
@@ -145,8 +144,8 @@ public class PlanYearsController extends BaseController {
     @ApiOperation(value = "导入年度计划数据")
     @PostMapping("/importData")
     public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception {
-        ExcelUtil<PlanYears> util = new ExcelUtil<>(PlanYears.class);
-        List<PlanYears> planYears = util.importExcel(file.getInputStream());
+        ExcelUtil<PlanYearsStandardVo> util = new ExcelUtil<>(PlanYearsStandardVo.class);
+        List<PlanYearsStandardVo> planYears = util.importExcel(file.getInputStream());
         //获取采购单位-
         LoginUser loginUser = getLoginUser();
         String message = planYearsService.importPlanYears(planYears, updateSupport, loginUser);

purchase-admin/src/main/java/com/ozs/web/controller/plan/ProvisionalPlanController.java

@@ -15,6 +15,7 @@ import com.ozs.common.utils.poi.ExcelUtil;
 import com.ozs.framework.web.service.TokenService;
 import com.ozs.plan.doman.PlanYears;
 import com.ozs.plan.doman.ProvisionalPlan;
+import com.ozs.plan.doman.vo.requestVo.PlanYearsStandardVo;
 import com.ozs.plan.doman.vo.requestVo.ProvisionalPlanVo;
 import com.ozs.plan.service.ProvisionalPlanService;
 import io.swagger.annotations.Api;
@@ -29,6 +30,7 @@ import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.multipart.MultipartFile;
 
 import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
 import java.util.Date;
 import java.util.List;
 
@@ -116,4 +118,12 @@ public class ProvisionalPlanController extends BaseController {
         String message = provisionalPlanService.importProvisionalPlan(provisionalPlans, updateSupport, loginUser);
         return success(message);
     }
+
+    @ApiOperation(value = "导出临时计划")
+    @PostMapping("/exportProvisionalPlan")
+    public void exportProvisionalPlan(HttpServletResponse response, @RequestBody ProvisionalPlanVo provisionalPlanVo) throws Exception {
+        List<ProvisionalPlan> list = provisionalPlanService.selectProvisionalPlanExport(provisionalPlanVo);
+        ExcelUtil<ProvisionalPlan> util = new ExcelUtil<>(ProvisionalPlan.class);
+        util.exportExcel(response, list, "临时计划数据");
+    }
 }

purchase-admin/src/main/java/com/ozs/web/controller/pm/PmContractInfoController.java

@@ -0,0 +1,43 @@
+package com.ozs.web.controller.pm;
+
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.ozs.common.core.controller.BaseController;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.framework.web.service.TokenService;
+import com.ozs.pm.doman.vo.requestVo.PmDemandReqVo;
+import com.ozs.pm.doman.vo.responseVo.PmDemandResVo;
+import com.ozs.pm.service.IPmDemandService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 合同信息Controller
+ *
+ * @author ruoyi
+ * @date 2023-01-16
+ */
+@Api(tags = "合同信息")
+@RestController
+@RequestMapping("/pm/contractInfo")
+public class PmContractInfoController extends BaseController {
+    @Autowired
+    private IPmDemandService pmDemandService;
+    @Autowired
+    private TokenService tokenService;
+
+    /**
+     * 合同信息查询列表
+     */
+    @ApiOperation(value = "合同信息查询列表", notes = "参数非必传")
+    @PostMapping("/list")
+    public AjaxResult list(@RequestBody PmDemandReqVo pmDemandReqVo) {
+        IPage<PmDemandResVo> page  = pmDemandService.selectPmDemandList(pmDemandReqVo,4);
+        return success(page);
+    }
+}

purchase-admin/src/main/java/com/ozs/web/controller/pm/PmDemandController.java

@@ -1,9 +1,7 @@
 package com.ozs.web.controller.pm;
 
-import java.util.List;
 
 import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.github.pagehelper.PageInfo;
 import com.ozs.common.core.domain.model.LoginUser;
 import com.ozs.framework.web.service.TokenService;
 import com.ozs.pm.doman.vo.requestVo.PmBookBuildingReqVo;
@@ -43,7 +41,7 @@ public class PmDemandController extends BaseController {
     @ApiOperation(value = "查询采购需求列表", notes = "参数非必传")
     @PostMapping("/list")
     public AjaxResult list(@RequestBody PmDemandReqVo pmDemandReqVo) {
-        IPage<PmDemandResVo> page  = pmDemandService.selectPmDemandList(pmDemandReqVo);
+        IPage<PmDemandResVo> page  = pmDemandService.selectPmDemandList(pmDemandReqVo,0);
         return success(page);
 
     }
@@ -68,6 +66,14 @@ public class PmDemandController extends BaseController {
         return toAjax(pmDemandService.bookBuilding(pmBookBuildingReqVo));
     }
 
+    @ApiOperation(value = "提交采购需求", notes = "必传demandId,其他字段不传")
+    @PostMapping("/commit")
+    public AjaxResult commit(@RequestBody PmDemandReqVo pmDemandReqVo, HttpServletRequest request) {
+        LoginUser loginUser = tokenService.getLoginUser(request);
+        pmDemandReqVo.setUpdateBy(String.valueOf(loginUser.getUserId()));
+        return toAjax(pmDemandService.commit(pmDemandReqVo));
+    }
+
     /**
      * 查看流程图，获取当前阶段名字
      */
@@ -86,23 +92,15 @@ public class PmDemandController extends BaseController {
         return success(pmDemandService.getModuleInfo(pmRequestVo.getDemandId(),pmRequestVo.getModuleName()));
     }
 
-    @ApiOperation(value = "提交采购需求", notes = "必传demandId,其他字段不传")
-    @PostMapping("/commit")
-    public AjaxResult commit(@RequestBody PmDemandReqVo pmDemandReqVo, HttpServletRequest request) {
-        LoginUser loginUser = tokenService.getLoginUser(request);
-        pmDemandReqVo.setUpdateBy(String.valueOf(loginUser.getUserId()));
-        return toAjax(pmDemandService.commit(pmDemandReqVo));
-    }
 
     /**
-     * 查询采购需求列表
+     * 审核单位查询采购需求列表
      */
     @ApiOperation(value = "审核单位查询采购需求列表", notes = "参数非必传")
     @PostMapping("/examineList")
     public AjaxResult examineList(@RequestBody PmDemandReqVo pmDemandReqVo) {
-        IPage<PmDemandResVo> page  = pmDemandService.selectPmDemanDexamineList(pmDemandReqVo);
+        IPage<PmDemandResVo> page  = pmDemandService.selectPmDemandList(pmDemandReqVo,1);
         return success(page);
-
     }
 
     @ApiOperation(value = "审核采购需求通过", notes = "必传demandId和上传附件，其他字段不传")

purchase-admin/src/main/java/com/ozs/web/controller/pm/PmProjectConstructionController.java

@@ -0,0 +1,43 @@
+package com.ozs.web.controller.pm;
+
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.ozs.common.core.controller.BaseController;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.framework.web.service.TokenService;
+import com.ozs.pm.doman.vo.requestVo.PmDemandReqVo;
+import com.ozs.pm.doman.vo.responseVo.PmDemandResVo;
+import com.ozs.pm.service.IPmDemandService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 项目建设Controller
+ *
+ * @author ruoyi
+ * @date 2023-01-16
+ */
+@Api(tags = "项目建设")
+@RestController
+@RequestMapping("/pm/projectConstruction")
+public class PmProjectConstructionController extends BaseController {
+    @Autowired
+    private IPmDemandService pmDemandService;
+    @Autowired
+    private TokenService tokenService;
+
+    /**
+     * 项目建设查询列表
+     */
+    @ApiOperation(value = "项目建设查询列表", notes = "参数非必传")
+    @PostMapping("/list")
+    public AjaxResult list(@RequestBody PmDemandReqVo pmDemandReqVo) {
+        IPage<PmDemandResVo> page  = pmDemandService.selectPmDemandList(pmDemandReqVo,5);
+        return success(page);
+    }
+}

purchase-admin/src/main/java/com/ozs/web/controller/pm/PmPurchaseExecutionController.java

@@ -0,0 +1,43 @@
+package com.ozs.web.controller.pm;
+
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.ozs.common.core.controller.BaseController;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.framework.web.service.TokenService;
+import com.ozs.pm.doman.vo.requestVo.PmDemandReqVo;
+import com.ozs.pm.doman.vo.responseVo.PmDemandResVo;
+import com.ozs.pm.service.IPmDemandService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 采购执行Controller
+ *
+ * @author ruoyi
+ * @date 2023-01-16
+ */
+@Api(tags = "采购执行")
+@RestController
+@RequestMapping("/pm/purchaseExecution")
+public class PmPurchaseExecutionController extends BaseController {
+    @Autowired
+    private IPmDemandService pmDemandService;
+    @Autowired
+    private TokenService tokenService;
+
+    /**
+     * 采购执行查询列表
+     */
+    @ApiOperation(value = "采购执行查询列表", notes = "参数非必传")
+    @PostMapping("/list")
+    public AjaxResult list(@RequestBody PmDemandReqVo pmDemandReqVo) {
+        IPage<PmDemandResVo> page  = pmDemandService.selectPmDemandList(pmDemandReqVo,3);
+        return success(page);
+    }
+}

purchase-admin/src/main/java/com/ozs/web/controller/pm/PmTaskReleaseController.java

@@ -0,0 +1,64 @@
+package com.ozs.web.controller.pm;
+
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.ozs.common.core.controller.BaseController;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.common.core.domain.model.LoginUser;
+import com.ozs.framework.web.service.TokenService;
+import com.ozs.pm.doman.vo.requestVo.PmBookBuildingReqVo;
+import com.ozs.pm.doman.vo.requestVo.PmDemandReqVo;
+import com.ozs.pm.doman.vo.responseVo.PmDemandResVo;
+import com.ozs.pm.service.IPmDemandService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * 任务下达Controller
+ *
+ * @author ruoyi
+ * @date 2023-01-16
+ */
+@Api(tags = "任务下达")
+@RestController
+@RequestMapping("/pm/taskRelease")
+public class PmTaskReleaseController extends BaseController {
+    @Autowired
+    private IPmDemandService pmDemandService;
+    @Autowired
+    private TokenService tokenService;
+
+    /**
+     * 任务下达查询列表
+     */
+    @ApiOperation(value = "任务下达查询列表", notes = "参数非必传")
+    @PostMapping("/list")
+    public AjaxResult list(@RequestBody PmDemandReqVo pmDemandReqVo) {
+        IPage<PmDemandResVo> page  = pmDemandService.selectPmDemandList(pmDemandReqVo,2);
+        return success(page);
+    }
+
+    @ApiOperation(value = "下达任务", notes = "必传demandId和上传附件，其他字段不传")
+    @PostMapping("/releaseTask")
+    public AjaxResult releaseTask(@RequestBody PmDemandReqVo pmDemandReqVo, HttpServletRequest request) {
+        LoginUser loginUser = tokenService.getLoginUser(request);
+        pmDemandReqVo.setUpdateBy(String.valueOf(loginUser.getUserId()));
+        return toAjax(pmDemandService.releaseTask(pmDemandReqVo));
+    }
+
+    /**
+     * 获取采购需求详细信息
+     */
+    @ApiOperation(value = "获取采购需求详细信息", notes = "必传demandId,其他字段不传")
+    @PostMapping("/view")
+    public AjaxResult view(@RequestBody PmDemandReqVo pmDemandReqVo) {
+        return success(pmDemandService.selectPmDemandByDemandId(pmDemandReqVo.getDemandId()));
+    }
+}

purchase-common/src/main/java/com/ozs/common/enums/SysFileRefEnum.java

@@ -17,7 +17,8 @@ public enum SysFileRefEnum {
     PM_DEMAND_MATERIALS(6, "采购需求物资类附件"),
     PM_DEMAND_SERVE(7, "采购需求服务类附件"),
     PM_DEMAND_ENGINEERING(8, "采购需求工程类附件"),
-    PM_DEMAND_EXAMINE(9, "采购需求审核文件")
+    PM_DEMAND_EXAMINE(9, "采购需求审核文件"),
+    PM_TAST_RELEASE(10, "任务下达文件")
     ;
 
     private Integer type;

purchase-system/src/main/java/com/ozs/base/domain/BaseProfessional.java

@@ -2,6 +2,7 @@ package com.ozs.base.domain;
 
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
+import com.ozs.common.annotation.Excel;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 
@@ -19,6 +20,7 @@ public class BaseProfessional {
     /**
      * 品目名称
      */
+    @Excel(name = "品目名称")
     @ApiModelProperty(value = "品目名称")
     @TableField("professional_name")
     private String professionalName;
@@ -26,6 +28,7 @@ public class BaseProfessional {
     /**
      * 编码
      */
+    @Excel(name = "编码")
     @ApiModelProperty(value = "编码")
     @TableField("professional_code")
     private String professionalCode;
@@ -33,6 +36,7 @@ public class BaseProfessional {
     /**
      * 说明
      */
+    @Excel(name = "说明")
     @ApiModelProperty(value = "说明")
     @TableField("purchase_state")
     private String purchaseState;
@@ -40,6 +44,7 @@ public class BaseProfessional {
     /**
      * 一级分类
      */
+    @Excel(name = "一级分类")
     @ApiModelProperty(value = "一级分类")
     @TableField("professional_grade")
     private String professionalGrade;
@@ -47,6 +52,7 @@ public class BaseProfessional {
     /**
      * 父级编码
      */
+    @Excel(name = "父级编码")
     @ApiModelProperty(value = "父级编码")
     @TableField("parent_code")
     private String parentCode;

purchase-system/src/main/java/com/ozs/base/domain/vo/BaseProfessionalVo.java

@@ -1,6 +1,9 @@
 package com.ozs.base.domain.vo;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.ozs.base.domain.BaseProfessional;
+import com.ozs.common.annotation.Excel;
+import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 
 import java.io.Serializable;
@@ -8,12 +11,47 @@ import java.util.List;
 
 @Data
 public class BaseProfessionalVo extends BaseProfessional {
-//    private Integer id;
-//    private String professionalName;
-//    private String professionalCode;
-//    private String purchaseState;
-//    private String professionalGrade;
-//    private String parentCode;
+    /**
+     * 主键ID
+     */
+    @ApiModelProperty(value = "id")
+    private Integer id;
+
+    /**
+     * 品目名称
+     */
+    @Excel(name = "品目名称")
+    @ApiModelProperty(value = "品目名称")
+    private String professionalName;
+
+    /**
+     * 编码
+     */
+    @Excel(name = "编码")
+    @ApiModelProperty(value = "编码")
+    private String professionalCode;
+
+    /**
+     * 说明
+     */
+    @Excel(name = "说明")
+    @ApiModelProperty(value = "说明")
+    private String purchaseState;
+
+    /**
+     * 一级分类
+     */
+    @Excel(name = "一级分类")
+    @ApiModelProperty(value = "一级分类")
+    private String professionalGrade;
+
+    /**
+     * 父级编码
+     */
+    @Excel(name = "父级编码")
+    @ApiModelProperty(value = "父级编码")
+    private String parentCode;
+
     private List<BaseProfessionalVo> baseProfessionalVoList;
     private List<Integer> deleteIds;
 }

purchase-system/src/main/java/com/ozs/base/service/BaseProfessionalService.java

@@ -7,10 +7,10 @@ import com.ozs.base.domain.vo.BaseProfessionalVo;
 import java.util.List;
 
 public interface BaseProfessionalService extends IService<BaseProfessional> {
-    List<BaseProfessionalVo> selectBaseProfessional(BaseProfessionalVo baseProfessional);
-    List<BaseProfessional> selectBaseProfessional(BaseProfessional baseProfessional);
+    List<BaseProfessionalVo> selectBaseProfessionalVo(BaseProfessionalVo baseProfessional);
+    List<BaseProfessional> selectBaseProfessional(BaseProfessionalVo baseProfessionalVo);
 
     void deleteIds(List<Integer> deleteIds);
 
-    String importBaseProfessional(List<BaseProfessional> userList);
+    String importBaseProfessional(List<BaseProfessional> userList, boolean updateSupport);
 }

purchase-system/src/main/java/com/ozs/base/service/impl/BaseProfessionalServiceImpl.java

@@ -40,12 +40,12 @@ public class BaseProfessionalServiceImpl extends ServiceImpl<BaseProfessionalMap
     }
 
     @Override
-    public String importBaseProfessional(List<BaseProfessional> userList) {
+    public String importBaseProfessional(List<BaseProfessional> baseProfessionalList, boolean updateSupport) {
         int successNum = 0;
         int failureNum = 0;
         StringBuilder successMsg = new StringBuilder();
         StringBuilder failureMsg = new StringBuilder();
-        for (BaseProfessional baseProfessional : userList) {
+        for (BaseProfessional baseProfessional : baseProfessionalList) {
             try {
                 // 判断编码是否存在
                 List<BaseProfessional> professionalCode = baseProfessionalMapper.selectByProfessionalCode(baseProfessional);
@@ -59,7 +59,7 @@ public class BaseProfessionalServiceImpl extends ServiceImpl<BaseProfessionalMap
                     BeanValidators.validateWithException(validator, baseProfessional);
                     baseProfessionalMapper.insert(baseProfessional);
                     successNum++;
-                    successMsg.append("<br/>" + successNum + "、专业名称 " + baseProfessional.getProfessionalName() + " 导入成功");
+                    // successMsg.append("<br/>" + successNum + "、专业名称 " + baseProfessional.getProfessionalName() + " 导入成功");
                 }
             } catch (Exception e) {
                 failureNum++;
@@ -72,13 +72,13 @@ public class BaseProfessionalServiceImpl extends ServiceImpl<BaseProfessionalMap
             failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
             throw new ServiceException(failureMsg.toString());
         } else {
-            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
+            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条。");
         }
         return successMsg.toString();
     }
 
     @Override
-    public List<BaseProfessionalVo> selectBaseProfessional(BaseProfessionalVo baseProfessionalVo) {
+    public List<BaseProfessionalVo> selectBaseProfessionalVo(BaseProfessionalVo baseProfessionalVo) {
         List<BaseProfessional> allList = baseProfessionalMapper.selectBaseProfessional(baseProfessionalVo);
         // 将实体类转换为Vo类
         List<BaseProfessionalVo> allListVo = BeanUtils.entityListToVOList(allList, BaseProfessionalVo.class);
@@ -87,8 +87,8 @@ public class BaseProfessionalServiceImpl extends ServiceImpl<BaseProfessionalMap
     }
 
     @Override
-    public List<BaseProfessional> selectBaseProfessional(BaseProfessional baseProfessional) {
-        List<BaseProfessional> allList = baseProfessionalMapper.selectBaseProfessional(baseProfessional);
+    public List<BaseProfessional> selectBaseProfessional(BaseProfessionalVo baseProfessionalVo) {
+        List<BaseProfessional> allList = baseProfessionalMapper.selectBaseProfessional(baseProfessionalVo);
         return allList;
     }
 

purchase-system/src/main/java/com/ozs/plan/doman/PlanQuarter.java

@@ -0,0 +1,185 @@
+package com.ozs.plan.doman;
+
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.ozs.common.annotation.Excel;
+import lombok.Data;
+import nonapi.io.github.classgraph.json.Id;
+
+import javax.validation.constraints.NotNull;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 季度计划
+ *
+ * @author buzhanyi
+ */
+@Data
+@TableName("plan_practical")
+public class PlanQuarter {
+
+    /**
+     * 主键编号
+     */
+    @Id
+    @TableId(type = IdType.AUTO)
+    private Long planPracticalId;
+    /**
+     * 年度计划id（年度计划审批后同步到季度计划）
+     */
+    private Long planYearId;
+    /**
+     * 采购单位（登录账号的单位）
+     */
+    @NotNull(message = "采购单位不能为空")
+    private Long purchaseDeptId;
+
+    @Excel(name = "采购单位")
+    @TableField(exist = false)
+    private String purchaseDeptName;
+    /**
+     * 项目名称
+     */
+    @Excel(name = "项目名称")
+    @NotNull(message = "项目名称不能为空")
+    private String projectName;
+    /**
+     * 项目类型（0：装备类；1：物资类；2：服务类；3：工程类）
+     */
+    @NotNull(message = "项目类型不能为空")
+    private String projectType;
+    @Excel(name = "项目类型")
+    @TableField(exist = false)
+    private String projectTypeStr;
+    /**
+     * 需求概况
+     */
+    @Excel(name = "需求概况")
+    @NotNull(message = "需求概况不能为空")
+    private String demandOverview;
+    /**
+     * 概算金额(万元（保留小数点后两位）
+     */
+    @Excel(name = "概算金额（万元）")
+    @NotNull(message = "概算金额不能为空")
+    private BigDecimal evaluation;
+    /**
+     * 是否为超限额计划(0:未超额，1:超额)
+     */
+    @NotNull(message = "是否为超限额计划不能为空")
+    private String isExcess;
+    /**
+     * 采购服务站
+     */
+    @NotNull(message = "采购服务站不能为空")
+    private String purchaseServices;
+    @Excel(name = "采购服务站")
+    @TableField(exist = false)
+    private String purchaseServicesStr;
+    /**
+     * 采购方式 (0:公开招标, 1:单一来源,2:邀请招标,3:竞争式谈判,4:询价)
+     */
+    @NotNull(message = "采购方式不能为空")
+    private String purchaseMode;
+    @Excel(name = "采购方式")
+    @TableField(exist = false)
+    private String purchaseModeStr;
+    /**
+     * 计划提报需求时间--->需求单位成功提报采购需求的日期（具体到月）
+     */
+    @Excel(name = "提报需求时间", dateFormat = "yyyy-MM-dd")
+    @NotNull(message = "计划提报需求时间不能为空")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planDemandSubTime;
+    /**
+     * 计划完成采购时间--->公示中标结果的日期，即填制中标信息的日期（具体到月）
+     */
+    @Excel(name = "完成采购时间", dateFormat = "yyyy-MM-dd")
+    @NotNull(message = "计划完成采购时间不能为空")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planPurchaseFinishTime;
+    /**
+     * 计划交付时间--->供应商完成并交付后，使用单位收到标的日期，即填制建设文档的日期
+     */
+    @Excel(name = "交付（实施）时间", dateFormat = "yyyy-MM-dd")
+    @NotNull(message = "计划交付时间不能为空")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planDeliverTime;
+    /**
+     * 项目属性--->应急应战项目、重大规划任务项目、规划任务项目或一般项目
+     */
+    @NotNull(message = "项目属性不能为空")
+    private String projectAttr;
+
+    @Excel(name = "项目属性")
+    @TableField(exist = false)
+    private String projectAttrStr;
+    /**
+     * 退回原因--->审核不通过就是退回
+     */
+    @Excel(name = "退回原因")
+    private String refuseReason;
+    /**
+     * 计划调整情况及理由--->如计划需要变更，在填写申请修改时需填写调整情况及理由，审核单位审核通过后显示
+     */
+    @Excel(name = "计划调整情况及理由")
+    @NotNull(message = "计划调整情况及理由不能为空")
+    private String adjustReason;
+    /**
+     * 备注
+     */
+    @Excel(name = "备注")
+    private String remarks;
+
+    /**
+     * 项目状态--->包括计划待提交、计划待审核、计划已退回、计划已审核
+     * (0:计划待提交，1:计划待审核，2:计划已退回，3:计划已审核)
+     */
+    private String projectStatus;
+    /**
+     * 发函状态（0：未发函或已处理，1：确认发函）
+     */
+    private String sendLetter;
+
+    /**
+     * 创建者
+     */
+    private String created;
+    /**
+     * 创建时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private Date createTime;
+    /**
+     * 更改者
+     */
+    private String updated;
+    /**
+     * 更改时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private Date updateTime;
+    /**
+     * 逻辑删除字段--->（0：正常，1：已删除）
+     */
+    private Integer delFlay;
+    /**
+     * 计划类型（0：季度计划，1：临时计划）
+     */
+    private Integer planType;
+
+    /**
+     * 查询参数开始时间和结束时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    @TableField(exist = false)
+    private Date beginTime;
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    @TableField(exist = false)
+    private Date endTime;
+}

purchase-system/src/main/java/com/ozs/plan/doman/PlanYears.java

@@ -10,7 +10,6 @@ import lombok.Data;
 import nonapi.io.github.classgraph.json.Id;
 
 import javax.validation.constraints.NotNull;
-import java.io.Serializable;
 import java.math.BigDecimal;
 import java.util.Date;
 
@@ -112,6 +111,11 @@ public class PlanYears {
     @Excel(name = "项目属性")
     @TableField(exist = false)
     private String projectAttrStr;
+    /**
+     * 退回原因--->审核不通过就是退回
+     */
+    @Excel(name = "退回原因")
+    private String refuseReason;
     /**
      * 计划调整情况及理由--->如计划需要变更，在填写申请修改时需填写调整情况及理由，审核单位审核通过后显示
      */
@@ -133,10 +137,7 @@ public class PlanYears {
      * 发函状态（0：未发函或已处理，1：确认发函）
      */
     private String sendLetter;
-    /**
-     * 退回原因--->审核不通过就是退回
-     */
-    private String refuseReason;
+
 
     /**
      * 创建者

purchase-system/src/main/java/com/ozs/plan/doman/ProvisionalPlan.java

@@ -38,6 +38,8 @@ public class ProvisionalPlan {
     @ApiModelProperty(value = "项目类型（0：装备类；1：物资类；2：服务类；3：工程类）")
     @TableField("project_type")
     private String projectType;
+    @TableField(exist = false)
+    private String projectTypeStr;
 
     @Excel(name = "需求概况")
     @ApiModelProperty(value = "需求概况")
@@ -53,15 +55,19 @@ public class ProvisionalPlan {
     @TableField("is_excess")
     private String isExcess;
 
-    @Excel(name = "采购服务站")
     @ApiModelProperty(value = "采购服务站")
     @TableField("purchase_services")
-    private String purchaseServices;
+    private String  purchaseServices;
+    @Excel(name = "采购服务站")
+    @TableField(exist = false)
+    private String purchaseServicesStr;
 
     @Excel(name = "采购方式")
     @ApiModelProperty(value = "采购方式  (0:公开招标, 1:单一来源,2:邀请招标,3:竞争式谈判,4:询价)")
     @TableField("purchase_mode")
     private String purchaseMode;
+    @TableField(exist = false)
+    private String purchaseModeStr;
 
     @Excel(name = "提报需求时间")
     @JsonFormat(pattern = "yyyy-MM-dd")
@@ -81,10 +87,12 @@ public class ProvisionalPlan {
     @TableField("plan_deliver_time")
     private Date planDeliverTime;
 
-    @Excel(name = "项目属性")
     @ApiModelProperty(value = "项目属性（0:应急应战项目， 1:重大规划任务项目， 2:规划任务项目， 3:一般项目）")
     @TableField("project_attr")
     private String projectAttr;
+    @Excel(name = "项目属性")
+    @TableField(exist = false)
+    private String projectAttrStr;
 
     @Excel(name = "计划调整情况及理由")
     @ApiModelProperty(value = "计划调整情况及理由--->如计划需要变更，在填写申请修改时需填写调整情况及理由，审核单位审核通过后显示该信息")

purchase-system/src/main/java/com/ozs/plan/doman/vo/requestVo/PlanQuarterStandardVo.java

@@ -0,0 +1,164 @@
+package com.ozs.plan.doman.vo.requestVo;
+
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.ozs.common.annotation.Excel;
+import com.ozs.common.vo.PageVo;
+import com.ozs.system.domain.SysFileRef;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author buzhanyi
+ */
+@Data
+public class PlanQuarterStandardVo extends PageVo {
+
+    /**
+     * 主键编号
+     */
+    @ApiModelProperty(value = "主键编号")
+    private Long planPracticalId;
+    /**
+     * 年度计划id（年度计划审批后同步到季度计划）
+     */
+    private Long planYearId;
+
+    /**
+     * 采购单位（登录账号的单位）
+     */
+    @Excel(name = "采购单位")
+    @ApiModelProperty(value = "采购单位")
+    private String purchaseDeptId;
+
+    /**
+     * 项目名称
+     */
+    @Excel(name = "项目名称")
+    @ApiModelProperty(value = "项目名称")
+    private String projectName;
+
+    /**
+     * 项目类型（1：装备类；2：物资类；3：服务类；）
+     */
+    @Excel(name = "项目类型")
+    @ApiModelProperty(value = "项目类型不能为空（1：装备类；2：物资类；3：服务类；）")
+    private String projectType;
+
+    /**
+     * 需求概况
+     */
+    @Excel(name = "需求概况")
+    @ApiModelProperty(value = "需求概况")
+    private String demandOverview;
+
+    /**
+     * 概算金额(万元（保留小数点后两位）
+     */
+    @Excel(name = "概算金额（万元）")
+    @ApiModelProperty(value = "概算金额")
+    private BigDecimal evaluation;
+
+    /**
+     * 是否为超限额计划(0:未超额，1:超额)
+     */
+    @ApiModelProperty(value = "是否为超限额计划(0:未超额，1:超额)")
+    private String isExcess;
+
+    /**
+     * 采购服务站
+     */
+    @Excel(name = "采购服务站")
+    @ApiModelProperty(value = "采购服务站")
+    private String purchaseServices;
+
+    /**
+     * 采购方式 (0:公开招标, 1:单一来源,2:邀请招标,3:竞争式谈判,4:询价)
+     */
+    @Excel(name = "采购方式")
+    @ApiModelProperty(value = "采购方式 (0:公开招标, 1:单一来源,2:邀请招标,3:竞争式谈判,4:询价)")
+    private String purchaseMode;
+
+    /**
+     * 计划提报需求时间--->需求单位成功提报采购需求的日期（具体到月）
+     */
+    @Excel(name = "提报需求时间", dateFormat = "yyyy-MM-dd")
+    @ApiModelProperty(value = "计划提报需求时间")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planDemandSubTime;
+
+    /**
+     * 计划完成采购时间--->公示中标结果的日期，即填制中标信息的日期（具体到月）
+     */
+    @Excel(name = "完成采购时间", dateFormat = "yyyy-MM-dd")
+    @ApiModelProperty(value = "计划完成采购时间")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planPurchaseFinishTime;
+
+    /**
+     * 计划交付时间--->供应商完成并交付后，使用单位收到标的日期，即填制建设文档的日期
+     */
+    @Excel(name = "交付（实施）时间", dateFormat = "yyyy-MM-dd")
+    @ApiModelProperty(value = "计划交付时间")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planDeliverTime;
+
+    /**
+     * 项目属性--->应急应战项目、重大规划任务项目、规划任务项目或一般项目
+     */
+    @Excel(name = "项目属性")
+    @ApiModelProperty(value = "项目属性")
+    private String projectAttr;
+
+    /**
+     * 项目状态--->包括计划待提交、计划待审核、计划已退回、计划已审核
+     */
+    @ApiModelProperty(value = "项目状态(0:计划待提交，1:计划待审核，2:计划已退回，3:计划已审核)")
+    private String projectStatus;
+
+    /**
+     * 退回原因--->审核不通过就是退回
+     */
+    private String refuseReason;
+
+    /**
+     * 备注
+     */
+    @Excel(name = "备注")
+    @ApiModelProperty(value = "备注")
+    private String remarks;
+
+    /**
+     * 退回原因--->审核不通过就是退回
+     */
+    @ApiModelProperty(value = "退回原因")
+    private String reasonOfReturn;
+
+    /**
+     * 创建者
+     */
+    private String created;
+
+    /**
+     * 更改者
+     */
+    private String updated;
+
+    /**
+     * 上传附件
+     */
+    List<SysFileRef> sysFileRefs;
+
+    /**
+     * 查询参数开始时间和结束时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date beginTime;
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date endTime;
+
+}

purchase-system/src/main/java/com/ozs/plan/doman/vo/requestVo/PlanYearsStandardVo.java

@@ -2,6 +2,7 @@ package com.ozs.plan.doman.vo.requestVo;
 
 
 import com.fasterxml.jackson.annotation.JsonFormat;
+import com.ozs.common.annotation.Excel;
 import com.ozs.common.vo.PageVo;
 import com.ozs.system.domain.SysFileRef;
 import io.swagger.annotations.ApiModelProperty;
@@ -26,30 +27,35 @@ public class PlanYearsStandardVo extends PageVo {
     /**
      * 采购单位（登录账号的单位）
      */
+    @Excel(name = "采购单位")
     @ApiModelProperty(value = "采购单位")
-    private Long purchaseDeptId;
+    private String purchaseDeptId;
 
     /**
      * 项目名称
      */
+    @Excel(name = "项目名称")
     @ApiModelProperty(value = "项目名称")
     private String projectName;
 
     /**
      * 项目类型（1：装备类；2：物资类；3：服务类；）
      */
+    @Excel(name = "项目类型")
     @ApiModelProperty(value = "项目类型不能为空（1：装备类；2：物资类；3：服务类；）")
     private String projectType;
 
     /**
      * 需求概况
      */
+    @Excel(name = "需求概况")
     @ApiModelProperty(value = "需求概况")
     private String demandOverview;
 
     /**
      * 概算金额(万元（保留小数点后两位）
      */
+    @Excel(name = "概算金额（万元）")
     @ApiModelProperty(value = "概算金额")
     private BigDecimal evaluation;
 
@@ -62,18 +68,21 @@ public class PlanYearsStandardVo extends PageVo {
     /**
      * 采购服务站
      */
+    @Excel(name = "采购服务站")
     @ApiModelProperty(value = "采购服务站")
     private String purchaseServices;
 
     /**
      * 采购方式 (0:公开招标, 1:单一来源,2:邀请招标,3:竞争式谈判,4:询价)
      */
+    @Excel(name = "采购方式")
     @ApiModelProperty(value = "采购方式 (0:公开招标, 1:单一来源,2:邀请招标,3:竞争式谈判,4:询价)")
     private String purchaseMode;
 
     /**
      * 计划提报需求时间--->需求单位成功提报采购需求的日期（具体到月）
      */
+    @Excel(name = "提报需求时间", dateFormat = "yyyy-MM-dd")
     @ApiModelProperty(value = "计划提报需求时间")
     @JsonFormat(pattern = "yyyy-MM-dd")
     private Date planDemandSubTime;
@@ -81,6 +90,7 @@ public class PlanYearsStandardVo extends PageVo {
     /**
      * 计划完成采购时间--->公示中标结果的日期，即填制中标信息的日期（具体到月）
      */
+    @Excel(name = "完成采购时间", dateFormat = "yyyy-MM-dd")
     @ApiModelProperty(value = "计划完成采购时间")
     @JsonFormat(pattern = "yyyy-MM-dd")
     private Date planPurchaseFinishTime;
@@ -88,6 +98,7 @@ public class PlanYearsStandardVo extends PageVo {
     /**
      * 计划交付时间--->供应商完成并交付后，使用单位收到标的日期，即填制建设文档的日期
      */
+    @Excel(name = "交付（实施）时间", dateFormat = "yyyy-MM-dd")
     @ApiModelProperty(value = "计划交付时间")
     @JsonFormat(pattern = "yyyy-MM-dd")
     private Date planDeliverTime;
@@ -95,6 +106,7 @@ public class PlanYearsStandardVo extends PageVo {
     /**
      * 项目属性--->应急应战项目、重大规划任务项目、规划任务项目或一般项目
      */
+    @Excel(name = "项目属性")
     @ApiModelProperty(value = "项目属性")
     private String projectAttr;
 
@@ -112,6 +124,7 @@ public class PlanYearsStandardVo extends PageVo {
     /**
      * 备注
      */
+    @Excel(name = "备注")
     @ApiModelProperty(value = "备注")
     private String remarks;
 

purchase-system/src/main/java/com/ozs/plan/doman/vo/responseVo/PlanQuarterResponseVo.java

@@ -0,0 +1,126 @@
+package com.ozs.plan.doman.vo.responseVo;
+
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.ozs.common.annotation.Excel;
+import com.ozs.system.domain.SysFileInfo;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author buzhanyi
+ */
+@Data
+public class PlanQuarterResponseVo implements Serializable {
+
+    /**
+     * 主键编号
+     */
+    private Long planPracticalId;
+    /**
+     * 年度计划id（年度计划审批后同步到季度计划）
+     */
+    private Long planYearId;
+    /**
+     * 采购单位（登录账号的单位）
+     */
+    @Excel(name = "采购单位")
+    private Long purchaseDeptId;
+    /**
+     * 项目名称
+     */
+    @Excel(name = "项目名称")
+    private String projectName;
+    /**
+     * 项目名称
+     */
+    @Excel(name = "项目类型")
+    private String projectType;
+    /**
+     * 需求概况
+     */
+    @Excel(name = "需求概况")
+    private String demandOverview;
+    /**
+     * 概算金额(万元（保留小数点后两位）
+     */
+    @Excel(name = "概算金额")
+    private BigDecimal evaluation;
+    /**
+     * 是否为超限额计划(0:未超额，1:超额)
+     */
+    @Excel(name = "是否为超限额计划")
+    private String isExcess;
+    /**
+     * 采购服务站
+     */
+    @Excel(name = "采购服务站")
+    private String purchaseServices;
+    /**
+     * 采购方式 (0:公开招标, 1:单一来源,2:邀请招标,3:竞争式谈判,4:询价)
+     */
+    @Excel(name = "采购方式")
+    private String purchaseMode;
+    /**
+     * 计划提报需求时间--->需求单位成功提报采购需求的日期（具体到月）
+     */
+    @Excel(name = "计划提报需求时间")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planDemandSubTime;
+    /**
+     * 计划完成采购时间--->公示中标结果的日期，即填制中标信息的日期（具体到月）
+     */
+    @Excel(name = "计划完成采购时间")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planPurchaseFinishTime;
+    /**
+     * 计划交付时间--->供应商完成并交付后，使用单位收到标的日期，即填制建设文档的日期
+     */
+    @Excel(name = "计划交付时间")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private Date planDeliverTime;
+    /**
+     * 项目属性--->应急应战项目、重大规划任务项目、规划任务项目或一般项目
+     */
+    @Excel(name = "项目属性")
+    private String projectAttr;
+    /**
+     * 计划调整情况及理由--->如计划需要变更，在填写申请修改时需填写调整情况及理由，审核单位审核通过后显示
+     */
+    @Excel(name = "计划调整情况及理由")
+    private String adjustReason;
+    /**
+     * 备注
+     */
+    @Excel(name = "备注")
+    private String remarks;
+    /**
+     * 项目状态--->包括计划待提交、计划待审核、计划已退回、计划已审核
+     * (0:计划待提交，1:计划待审核，2:计划已退回，3:计划已审核)
+     */
+    @Excel(name = "项目状态")
+    private String projectStatus;
+
+    /**
+     * 发函状态（0：未发函或已处理，1：确认发函）
+     */
+    private String sendLetter;
+    /**
+     * 计划类型（0：季度计划，1：临时计划）
+     */
+    private Integer planType;
+    /**
+     * 退回原因--->审核不通过就是退回
+     */
+    private String refuseReason;
+
+    /**
+     * 已上传的关联附件信息
+     */
+    List<SysFileInfo> fileInfos;
+
+}

purchase-system/src/main/java/com/ozs/plan/mapper/PlanQuarterMapper.java

@@ -0,0 +1,90 @@
+package com.ozs.plan.mapper;
+
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.ozs.plan.doman.PlanQuarter;
+import com.ozs.plan.doman.PlanQuarter;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 用户与角色关联表 数据层
+ *
+ * @author bu
+ */
+@Mapper
+public interface PlanQuarterMapper extends BaseMapper<PlanQuarter> {
+
+    /**
+     * 查询季度计划记录集合
+     *
+     * @param PlanQuarter 季度计划请求对象
+     * @return 季度计划记录集合
+     */
+    public List<PlanQuarter> selectPlanQuarterList(PlanQuarter PlanQuarter);
+
+    /**
+     * 查询季度计划记录集合(审核单位)
+     *
+     * @param PlanQuarter 季度计划请求对象
+     * @return 季度计划记录集合
+     */
+    public List<PlanQuarter> selectPlanQuarterExamineList(PlanQuarter PlanQuarter);
+
+    /**
+     * 创建季度计划
+     *
+     * @param PlanQuarter 季度计划请求对象
+     */
+    public Integer insertPlanQuarter(PlanQuarter PlanQuarter);
+
+    /**
+     * 批量删除季度计划
+     *
+     * @param planIds 需要删除的季度计划ID
+     * @return 结果
+     */
+    public Integer deletePlanQuarterByIds(Long[] planIds);
+
+    /**
+     * 查询项目名称是否存在
+     *
+     * @param projectName 项目名称
+     * @return 结果
+     */
+    public Integer countProjectName(String projectName);
+
+    /**
+     * 查询季度计划
+     *
+     * @param planPracticalId 季度计划ID
+     * @return 结果
+     */
+    public PlanQuarter getById(Long planPracticalId);
+
+    /**
+     * 查询项目名称是否存在(除自己以外)
+     *
+     * @param projectName 项目名称
+     * @return 结果
+     */
+    public Integer countProjectNameOther(@Param("projectName") String projectName, @Param("planPracticalId") String planPracticalId);
+
+    /**
+     * 修改季度计划
+     *
+     * @param ofYears 季度计划
+     * @return 结果
+     */
+    public Integer updateInfoById(PlanQuarter ofYears);
+
+    public Integer deletePlanQuarterById(Long planPracticalId);
+
+    public Integer commit(Long planPracticalId);
+
+    public Integer review(PlanQuarter ofYears);
+
+    Integer sendLetter(Long planPracticalId);
+}

purchase-system/src/main/java/com/ozs/plan/mapper/PlanYearsMapper.java

@@ -53,7 +53,7 @@ public interface PlanYearsMapper extends BaseMapper<PlanYears> {
      * @param projectName 项目名称
      * @return 结果
      */
-    public List<PlanYears> countProjectName(String projectName);
+    public Integer countProjectName(String projectName);
 
     /**
      * 查询年度计划

purchase-system/src/main/java/com/ozs/plan/service/PlanQuarterService.java

@@ -0,0 +1,153 @@
+package com.ozs.plan.service;
+
+
+import com.github.pagehelper.PageInfo;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.common.core.domain.model.LoginUser;
+import com.ozs.plan.doman.PlanQuarter;
+import com.ozs.plan.doman.vo.requestVo.PlanQuarterStandardVo;
+import com.ozs.plan.doman.vo.requestVo.PlanYearsStandardVo;
+
+import java.util.List;
+
+/**
+ * 季度计划 服务层
+ *
+ * @author bu
+ */
+public interface PlanQuarterService {
+
+    /**
+     * 查询季度计划记录集合
+     *
+     * @param vo 季度计划请求对象
+     * @return 季度计划记录集合
+     */
+    public PageInfo<PlanQuarter> selectPlanQuarterList(PlanQuarterStandardVo vo);
+
+    /**
+     * 查询季度计划记录集合--导出
+     *
+     * @param vo 季度计划请求对象
+     * @return 季度计划记录集合
+     */
+    public List<PlanQuarter> selectPlanQuarterListEXP(PlanQuarterStandardVo vo);
+
+    /**
+     * 查询季度计划记录集合(审核单位)
+     *
+     * @param vo 季度计划请求对象
+     * @return 季度计划记录集合
+     */
+    public PageInfo<PlanQuarter> selectPlanQuarterExamineList(PlanQuarterStandardVo vo);
+
+    /**
+     * 查询季度计划记录集合(审核单位--导出）
+     *
+     * @param vo 季度计划请求对象
+     * @return 季度计划记录集合
+     */
+    public List<PlanQuarter> selectPlanQuarterExamineListEXP(PlanQuarterStandardVo vo);
+
+    /**
+     * 创建季度计划
+     *
+     * @param quarterStandardVo 季度计划请求对象
+     */
+    public AjaxResult insertPlanQuarter(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 批量删除季度计划
+     *
+     * @param planIds 需要删除的季度计划ID
+     * @return 结果
+     */
+    public AjaxResult deletePlanQuarterByIds(Long[] planIds);
+
+    /**
+     * 批量删除季度计划
+     *
+     * @param planYearId 需要删除的季度计划ID
+     * @return 结果
+     */
+    public AjaxResult deletePlanQuarterById(Long planYearId);
+
+    /**
+     * 根据id获取季度计划信息
+     *
+     * @param quarterStandardVo 季度计划请求对象
+     * @return 结果
+     */
+    public AjaxResult view(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 修改季度计划
+     *
+     * @param quarterStandardVo 修改季度计划请求对象
+     * @return 结果
+     */
+    public AjaxResult update(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 导入季度计划数据
+     *
+     * @return 结果
+     */
+    public String importPlanQuarter(List<PlanQuarterStandardVo> planquarter, boolean isUpdateSupport, LoginUser loginUser);
+
+    /**
+     * 提交季度计划
+     *
+     * @param quarterStandardVo 提交季度计划请求对象
+     * @return 结果
+     */
+    public AjaxResult commit(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 审核季度计划
+     *
+     * @param quarterStandardVo 需要审核的季度计划
+     * @return 结果
+     */
+    public AjaxResult reviewTo(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 审核季度计划退回
+     *
+     * @param quarterStandardVo 需要审核的季度计划
+     * @return 结果
+     */
+    public AjaxResult reviewReturn(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 申请修改季度计划
+     *
+     * @param quarterStandardVo 需要修改的季度计划
+     * @return 结果
+     */
+    public AjaxResult appUpdate(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 发函催告
+     *
+     * @param quarterStandardVo 季度计划
+     * @return 结果
+     */
+    AjaxResult sendLetter(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 上传计划关联文件后保存文件信息
+     *
+     * @param quarterStandardVo 季度计划
+     * @return 结果
+     */
+    AjaxResult upLoadPlanFile(PlanQuarterStandardVo quarterStandardVo);
+
+    /**
+     * 下载计划关联文件
+     *
+     * @param quarterStandardVo 季度计划
+     * @return 结果
+     */
+    AjaxResult downLoadPlanFile(PlanQuarterStandardVo quarterStandardVo);
+}

purchase-system/src/main/java/com/ozs/plan/service/PlanYearsService.java

@@ -25,7 +25,7 @@ public interface PlanYearsService {
     public PageInfo<PlanYears> selectPlanYearsList(PlanYearsStandardVo vo);
 
     /**
-     * 查询年度计划记录集合（导出）
+     * 查询年度计划记录集合--导出
      *
      * @param vo 年度计划请求对象
      * @return 年度计划记录集合
@@ -40,6 +40,14 @@ public interface PlanYearsService {
      */
     public PageInfo<PlanYears> selectPlanYearsExamineList(PlanYearsStandardVo vo);
 
+    /**
+     * 查询年度计划记录集合(审核单位--导出）
+     *
+     * @param vo 年度计划请求对象
+     * @return 年度计划记录集合
+     */
+    public List<PlanYears> selectPlanYearsExamineListEXP(PlanYearsStandardVo vo);
+
     /**
      * 创建年度计划
      *
@@ -84,7 +92,7 @@ public interface PlanYearsService {
      *
      * @return 结果
      */
-    public String importPlanYears(List<PlanYears> planYears, boolean isUpdateSupport, LoginUser loginUser);
+    public String importPlanYears(List<PlanYearsStandardVo> planYears, boolean isUpdateSupport, LoginUser loginUser);
 
     /**
      * 提交年度计划

purchase-system/src/main/java/com/ozs/plan/service/ProvisionalPlanService.java

@@ -2,7 +2,9 @@ package com.ozs.plan.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.ozs.common.core.domain.model.LoginUser;
+import com.ozs.plan.doman.PlanYears;
 import com.ozs.plan.doman.ProvisionalPlan;
+import com.ozs.plan.doman.vo.requestVo.ProvisionalPlanVo;
 
 import java.util.List;
 
@@ -12,4 +14,6 @@ public interface ProvisionalPlanService extends IService<ProvisionalPlan> {
     int updateProvisionalPlanById(ProvisionalPlan provisionalPlan);
 
     String importProvisionalPlan(List<ProvisionalPlan> provisionalPlans, boolean updateSupport, LoginUser loginUser);
+
+    List<ProvisionalPlan> selectProvisionalPlanExport(ProvisionalPlanVo provisionalPlanVo);
 }

purchase-system/src/main/java/com/ozs/plan/service/impl/PlanQuarterServiceImpl.java

@@ -0,0 +1,564 @@
+package com.ozs.plan.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.common.core.domain.entity.SysDept;
+import com.ozs.common.core.domain.entity.SysDictData;
+import com.ozs.common.core.domain.model.LoginUser;
+import com.ozs.common.enums.ProjectStatus;
+import com.ozs.common.enums.ProjectTypes;
+import com.ozs.common.enums.SysFileRefEnum;
+import com.ozs.common.exception.ServiceException;
+import com.ozs.common.utils.StringUtils;
+import com.ozs.common.utils.bean.BeanUtils;
+import com.ozs.plan.doman.PlanQuarter;
+import com.ozs.plan.doman.PlanYears;
+import com.ozs.plan.doman.vo.requestVo.PlanQuarterStandardVo;
+import com.ozs.plan.doman.vo.requestVo.PlanYearsStandardVo;
+import com.ozs.plan.doman.vo.responseVo.PlanQuarterResponseVo;
+import com.ozs.plan.mapper.PlanQuarterMapper;
+import com.ozs.plan.service.PlanQuarterService;
+import com.ozs.system.domain.SysFileInfo;
+import com.ozs.system.domain.SysFileRef;
+import com.ozs.system.domain.vo.responseVo.SysDeptResponseVo;
+import com.ozs.system.mapper.SysDeptMapper;
+import com.ozs.system.mapper.SysFileRefMapper;
+import com.ozs.system.service.ISysDeptService;
+import com.ozs.system.service.ISysDictTypeService;
+import com.ozs.system.service.SysFileService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.ObjectUtils;
+
+import javax.validation.Validator;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author buzhanyi
+ */
+@Service
+@Slf4j
+public class PlanQuarterServiceImpl implements PlanQuarterService {
+
+    @Autowired
+    PlanQuarterMapper planQuarterMapper;
+    @Autowired
+    protected Validator validator;
+    @Autowired
+    private ISysDictTypeService dictTypeService;
+    @Autowired
+    private ISysDeptService deptService;
+    @Autowired
+    SysFileRefMapper sysFileRefMapper;
+    @Autowired
+    private SysDeptMapper deptMapper;
+    @Autowired
+    private SysFileService fileService;
+
+    @Override
+    public PageInfo<PlanQuarter> selectPlanQuarterList(PlanQuarterStandardVo vo) {
+        PlanQuarter quarters = new PlanQuarter();
+        List<PlanQuarter> planQuarter;
+        List<PlanQuarter> planQuarterList = new ArrayList<>();
+        PageHelper.startPage(vo.getPageNum().intValue(), vo.getPageSize().intValue());
+        try {
+            BeanUtils.copyProperties(vo, quarters);
+            planQuarter = planQuarterMapper.selectPlanQuarterList(quarters);
+            planQuarterList = changeTo(planQuarter);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        PageInfo<PlanQuarter> pageInfo = new PageInfo<PlanQuarter>(planQuarterList);
+        return pageInfo;
+    }
+
+    @Override
+    public List<PlanQuarter> selectPlanQuarterListEXP(PlanQuarterStandardVo vo) {
+        List<PlanQuarter> list = new ArrayList<>();
+        List<PlanQuarter> planQuarterList = new ArrayList<>();
+        try {
+            int num = 1;
+            int size = 200;
+            while (size == 200) {
+                LambdaQueryWrapper<PlanQuarter> lw = new LambdaQueryWrapper<PlanQuarter>();
+                if (!ObjectUtils.isEmpty(vo.getProjectName())) {
+                    lw.like(PlanQuarter::getProjectName, vo.getProjectName());
+                }
+                if (!ObjectUtils.isEmpty(vo.getPurchaseServices())) {
+                    lw.eq(PlanQuarter::getPurchaseServices, vo.getPurchaseServices());
+                }
+                if (!ObjectUtils.isEmpty(vo.getIsExcess())) {
+                    lw.eq(PlanQuarter::getIsExcess, vo.getIsExcess());
+                }
+                if (!ObjectUtils.isEmpty(vo.getProjectStatus())) {
+                    lw.eq(PlanQuarter::getProjectStatus, vo.getProjectStatus());
+                }
+                if (!ObjectUtils.isEmpty(vo.getBeginTime())) {
+                    lw.ge(PlanQuarter::getPlanDemandSubTime, vo.getBeginTime());
+                }
+                if (!ObjectUtils.isEmpty(vo.getEndTime())) {
+                    lw.le(PlanQuarter::getPlanDemandSubTime, vo.getEndTime());
+                }
+                Page<PlanQuarter> page = planQuarterMapper.selectPage(new Page<PlanQuarter>(num, size, false), lw);
+                list.addAll(page.getRecords());
+                size = page.getRecords().size();
+                num++;
+            }
+            planQuarterList = changeTo(list);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return planQuarterList;
+    }
+
+    @Override
+    public PageInfo<PlanQuarter> selectPlanQuarterExamineList(PlanQuarterStandardVo vo) {
+        PlanQuarter quarters = new PlanQuarter();
+        PageHelper.startPage(vo.getPageNum().intValue(), vo.getPageSize().intValue());
+        List<PlanQuarter> planQuarter;
+        List<PlanQuarter> planQuarterList = new ArrayList<>();
+        try {
+            BeanUtils.copyProperties(vo, quarters);
+            planQuarter = planQuarterMapper.selectPlanQuarterExamineList(quarters);
+            planQuarterList = changeTo(planQuarter);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        PageInfo<PlanQuarter> pageInfo = new PageInfo<PlanQuarter>(planQuarterList);
+        return pageInfo;
+    }
+
+    @Override
+    public List<PlanQuarter> selectPlanQuarterExamineListEXP(PlanQuarterStandardVo vo) {
+        List<PlanQuarter> list = new ArrayList<>();
+        List<PlanQuarter> planQuarterList = new ArrayList<>();
+        try {
+            int num = 1;
+            int size = 200;
+            while (size == 200) {
+                LambdaQueryWrapper<PlanQuarter> lw = new LambdaQueryWrapper<PlanQuarter>();
+                if (!ObjectUtils.isEmpty(vo.getProjectName())) {
+                    lw.like(PlanQuarter::getProjectName, vo.getProjectName());
+                }
+                if (!ObjectUtils.isEmpty(vo.getPurchaseServices())) {
+                    lw.eq(PlanQuarter::getPurchaseServices, vo.getPurchaseServices());
+                }
+                if (!ObjectUtils.isEmpty(vo.getIsExcess())) {
+                    lw.eq(PlanQuarter::getIsExcess, vo.getIsExcess());
+                }
+                if (!ObjectUtils.isEmpty(vo.getProjectStatus())) {
+                    lw.eq(PlanQuarter::getProjectStatus, vo.getProjectStatus());
+                } else {
+                    lw.in(PlanQuarter::getProjectStatus, "1,3");
+                }
+                if (!ObjectUtils.isEmpty(vo.getBeginTime())) {
+                    lw.ge(PlanQuarter::getPlanDemandSubTime, vo.getBeginTime());
+                }
+                if (!ObjectUtils.isEmpty(vo.getEndTime())) {
+                    lw.le(PlanQuarter::getPlanDemandSubTime, vo.getEndTime());
+                }
+                Page<PlanQuarter> page = planQuarterMapper.selectPage(new Page<PlanQuarter>(num, size, false), lw);
+                list.addAll(page.getRecords());
+                size = page.getRecords().size();
+                num++;
+            }
+            planQuarterList = changeTo(list);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return planQuarterList;
+    }
+
+    @Transactional
+    @Override
+    public AjaxResult insertPlanQuarter(PlanQuarterStandardVo quarterStandardVo) {
+        if (planQuarterMapper.countProjectName(quarterStandardVo.getProjectName()) > 0) {
+            return AjaxResult.error("该项目名称已经存在");
+        }
+        PlanQuarter quarters = new PlanQuarter();
+        try {
+            BeanUtils.copyProperties(quarterStandardVo, quarters);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        //判断是否为超额计划
+        quarters.setIsExcess(isExcessOrNo(quarters.getProjectType(), quarters.getEvaluation()));
+        quarters.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
+        quarters.setCreateTime(new Date());
+        planQuarterMapper.insertPlanQuarter(quarters);
+        log.info("id:{}", quarters.getPlanPracticalId());
+        List<SysFileRef> sysFileRefs = quarterStandardVo.getSysFileRefs();
+        if (!ObjectUtils.isEmpty(sysFileRefs)) {
+            for (SysFileRef ref : sysFileRefs) {
+                ref.setRedId(quarters.getPlanPracticalId());
+                ref.setType(SysFileRefEnum.PLAN_TEMPORARY.getType());
+                ref.setCreated(quarters.getCreated());
+                ref.setCreateTime(new Date());
+                ref.setUpdated(quarters.getCreated());
+                ref.setUpdateTime(new Date());
+                sysFileRefMapper.insert(ref);
+            }
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult deletePlanQuarterByIds(Long[] planIds) {
+        planQuarterMapper.deletePlanQuarterByIds(planIds);
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult deletePlanQuarterById(Long planId) {
+        planQuarterMapper.deletePlanQuarterById(planId);
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult view(PlanQuarterStandardVo quarterStandardVo) {
+
+        PlanQuarterResponseVo responseVo = new PlanQuarterResponseVo();
+        PlanQuarter byId = planQuarterMapper.getById(quarterStandardVo.getPlanPracticalId());
+        if (byId == null) {
+            return AjaxResult.error("数据查询失败");
+        }
+        SysDeptResponseVo sysDeptResponseVo = (SysDeptResponseVo) deptService.selectDeptById(byId.getPurchaseDeptId()).get("sysDept");
+        byId.setPurchaseDeptName(sysDeptResponseVo.getDeptName());
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("red_id", byId.getPlanPracticalId());
+        map.put("type", "1");
+        List<SysFileRef> fileRefs = sysFileRefMapper.selectByMap(map);
+        List<SysFileInfo> fileInfos = new ArrayList<>();
+        BeanUtils.copyProperties(byId, responseVo);
+        if (!ObjectUtils.isEmpty(fileRefs)) {
+            for (SysFileRef ref : fileRefs) {
+                SysFileInfo fileInfo = fileService.getById(ref.getFileId());
+                fileInfos.add(fileInfo);
+            }
+            responseVo.setFileInfos(fileInfos);
+        }
+        return AjaxResult.success(responseVo);
+    }
+
+    @Transactional
+    @Override
+    public AjaxResult update(PlanQuarterStandardVo quarterStandardVo) {
+        if (planQuarterMapper.countProjectNameOther(quarterStandardVo.getProjectName(), String.valueOf(quarterStandardVo.getPlanPracticalId())) > 0) {
+            return AjaxResult.error("该项目名称已经存在");
+        }
+        PlanQuarter quarters = new PlanQuarter();
+        try {
+            BeanUtils.copyProperties(quarterStandardVo, quarters);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        quarters.setIsExcess(isExcessOrNo(quarters.getProjectType(), quarters.getEvaluation()));
+        quarters.setUpdateTime(new Date());
+        planQuarterMapper.updateInfoById(quarters);
+        List<SysFileRef> sysFileRefs = quarterStandardVo.getSysFileRefs();
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("red_id", quarters.getPlanPracticalId());
+        map.put("type", "1");
+        sysFileRefMapper.deleteByMap(map);
+        if (!ObjectUtils.isEmpty(sysFileRefs)) {
+            for (SysFileRef ref : sysFileRefs) {
+                ref.setRedId(quarters.getPlanPracticalId());
+                ref.setType(SysFileRefEnum.PLAN_TEMPORARY.getType());
+                ref.setCreated(quarterStandardVo.getUpdated());
+                ref.setCreateTime(new Date());
+                ref.setUpdated(quarterStandardVo.getUpdated());
+                ref.setUpdateTime(new Date());
+                sysFileRefMapper.insert(ref);
+            }
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public String importPlanQuarter(List<PlanQuarterStandardVo> planQuarters, boolean isUpdateSupport, LoginUser loginUser) {
+        if (StringUtils.isNull(planQuarters) || planQuarters.size() == 0) {
+            throw new ServiceException("导入季度计划数据不能为空！");
+        }
+        List<PlanQuarter> list = new ArrayList<>();
+        for (PlanQuarterStandardVo standardVo : planQuarters) {
+            PlanQuarter quarter = new PlanQuarter();
+            BeanUtils.copyProperties(standardVo, quarter);
+            quarter.setPurchaseDeptName(standardVo.getPurchaseDeptId());
+            list.add(quarter);
+        }
+        HashMap<String, HashMap<String, String>> planEnums = dictTypeService.getAboutEnums();
+        HashMap<String, String> projectTypesMap = planEnums.get("projectTypes");
+        HashMap<String, String> planPurchaseModesMap = planEnums.get("planPurchaseModes");
+        HashMap<String, String> projectAttributes = planEnums.get("projectAttributes");
+        HashMap<String, String> purchaseServices = planEnums.get("purchaseServices");
+
+        int successNum = 0;
+        int failureNum = 0;
+        StringBuilder successMsg = new StringBuilder();
+        StringBuilder failureMsg = new StringBuilder();
+        //deptService
+        for (PlanQuarter ofYear : list) {
+            try {
+                //验证项目名称是否重复导入
+                //将录入信息中的值更改为要保存的数据
+                if (planQuarterMapper.countProjectName(ofYear.getProjectName()) == 0) {
+                    //采购单位
+                    SysDept info = deptMapper.checkDeptNameOnlyOne(ofYear.getPurchaseDeptName());
+                    if (StringUtils.isNotNull(info)) {
+                        ofYear.setPurchaseDeptId(info.getDeptId());
+                    }
+                    ofYear.setProjectType(projectTypesMap.get(ofYear.getProjectType()));
+                    ofYear.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
+                    ofYear.setPurchaseMode(planPurchaseModesMap.get(ofYear.getPurchaseMode()));
+                    //项目属性是多选字段
+                    StringBuilder builder = new StringBuilder();
+                    if (ofYear.getProjectAttr().contains("，")) {
+                        String[] split = ofYear.getProjectAttr().split("，");
+                        for (String s : split) {
+                            builder.append(projectAttributes.get(s) + "，");
+                        }
+                    } else {
+                        builder.append(projectAttributes.get(ofYear.getProjectAttr()));
+                    }
+                    ofYear.setProjectAttr(builder.toString());
+                    ofYear.setPurchaseServices(purchaseServices.get(ofYear.getPurchaseServices()));
+                    ofYear.setIsExcess(isExcessOrNo(ofYear.getProjectType(), ofYear.getEvaluation()));
+                    ofYear.setCreated(String.valueOf(loginUser.getUserId()));
+                    ofYear.setCreateTime(new Date());
+                    planQuarterMapper.insertPlanQuarter(ofYear);
+                    successNum++;
+                    successMsg.append("*" + successNum + "、项目 " + ofYear.getProjectName() + " 导入成功!");
+                    //} else if (isUpdateSupport) {
+                    //    PlanQuarter quarter = plan.get(0);
+                    //    BeanValidators.validateWithException(validator, ofYear);
+                    //    quarter.setCreateTime(new Date());
+                    //    quarter.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
+                    //    planQuarterMapper.updateById(quarter);
+                    //    successNum++;
+                    //    successMsg.append("<br/>" + successNum + "、项目 " + ofYear.getProjectName() + " 更新成功");
+                } else {
+                    failureNum++;
+                    failureMsg.append("*" + successNum + "、项目 " + ofYear.getProjectName() + " 已存在");
+                }
+            } catch (Exception exc) {
+                failureNum++;
+                String msg = "*" + successNum + "、项目 " + ofYear.getProjectName() + " 导入失败";
+                failureMsg.append(msg + exc.getMessage());
+                log.error(msg, exc);
+            }
+        }
+        if (failureNum > 0) {
+            failureMsg.insert(0, "导入失败！共 " + failureNum + " 条数据格式不正确：");
+            throw new ServiceException(failureMsg.toString());
+        } else {
+            successMsg.insert(0, "导入成功！共 " + successNum + " 条。");
+        }
+        return successMsg.toString();
+    }
+
+    @Override
+    public AjaxResult commit(PlanQuarterStandardVo quarterStandardVo) {
+        //PlanQuarter byId = PlanQuarterMapper.getById(quarterStandardVo.getPlanPracticalId());
+        //BigDecimal evaluation = byId.getEvaluation();
+        //BigDecimal threshold = new BigDecimal(0);
+        ////获取各个项目类型设定的概算金额阈值
+        //List<SysDictData> data = dictTypeService.selectDictDataByType("sys_over_limit_threshold");
+        //HashMap<String, String> thresholdMap = new LinkedHashMap<>();
+        ////各个类型的概算金额阈值
+        //for (SysDictData dictData : data) {
+        //    //    类型----阈值
+        //    thresholdMap.put(dictData.getDictLabel(), dictData.getDictValue());
+        //}
+        ////项目类型
+        //for (ProjectTypes value : ProjectTypes.values()) {
+        //    if (byId.getProjectType().equals(value.getCode())) {
+        //        threshold = BigDecimal.valueOf(Long.parseLong(thresholdMap.get(value.getInfo())));
+        //    }
+        //    break;
+        //}
+        //
+        //if (evaluation.compareTo(threshold) == 1) {
+        //    //是超额项目
+        //}
+
+        int commit = planQuarterMapper.commit(quarterStandardVo.getPlanPracticalId());
+        if (commit != 1) {
+            return AjaxResult.error("项目状态数据异常");
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    @Transactional
+    public AjaxResult reviewTo(PlanQuarterStandardVo vo) {
+        PlanQuarter quarters = new PlanQuarter();
+        BeanUtils.copyProperties(vo, quarters);
+        quarters.setProjectStatus(ProjectStatus.PLANTOEXAMINE.getCode());
+        return review(vo, quarters);
+    }
+
+    @Override
+    @Transactional
+    public AjaxResult reviewReturn(PlanQuarterStandardVo vo) {
+        PlanQuarter quarters = new PlanQuarter();
+        BeanUtils.copyProperties(vo, quarters);
+        quarters.setProjectStatus(ProjectStatus.PLANTOBACK.getCode());
+        return review(vo, quarters);
+    }
+
+    private AjaxResult review(PlanQuarterStandardVo vo, PlanQuarter quarters) {
+        List<SysFileRef> sysFileRefs = vo.getSysFileRefs();
+        if (!ObjectUtils.isEmpty(sysFileRefs)) {
+            for (SysFileRef ref : sysFileRefs) {
+                ref.setRedId(vo.getPlanPracticalId());
+                ref.setType(SysFileRefEnum.PLAN_TEMPORARY.getType());
+                ref.setCreated(vo.getUpdated());
+                ref.setCreateTime(new Date());
+                ref.setUpdated(vo.getUpdated());
+                ref.setUpdateTime(new Date());
+                sysFileRefMapper.insert(ref);
+            }
+        }
+        int review = planQuarterMapper.review(quarters);
+        if (review != 1) {
+            return AjaxResult.error("项目状态数据异常");
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult appUpdate(PlanQuarterStandardVo vo) {
+        PlanQuarter quarters = new PlanQuarter();
+        BeanUtils.copyProperties(vo, quarters);
+        //申请后会成为未提交的状态，可以进行修改
+        quarters.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
+        int review = planQuarterMapper.review(quarters);
+        if (review != 1) {
+            return AjaxResult.error("项目状态数据异常");
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult sendLetter(PlanQuarterStandardVo quarterStandardVo) {
+        int review = planQuarterMapper.sendLetter(quarterStandardVo.getPlanPracticalId());
+        if (review != 1) {
+            return AjaxResult.error("项目状态数据异常");
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult upLoadPlanFile(PlanQuarterStandardVo quarterStandardVo) {
+        List<SysFileRef> sysFileRefs = quarterStandardVo.getSysFileRefs();
+        if (!ObjectUtils.isEmpty(sysFileRefs)) {
+            for (SysFileRef ref : sysFileRefs) {
+                ref.setRedId(quarterStandardVo.getPlanPracticalId());
+                ref.setType(SysFileRefEnum.PLAN_TEMPORARY.getType());
+                sysFileRefMapper.insert(ref);
+            }
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult downLoadPlanFile(PlanQuarterStandardVo quarterStandardVo) {
+
+        return AjaxResult.success();
+    }
+
+    //判断是否为超额计划
+    public String isExcessOrNo(String projectType, BigDecimal evaluation) {
+        BigDecimal threshold = new BigDecimal(0);
+        //获取各个项目类型设定的概算金额阈值
+        List<SysDictData> data = dictTypeService.selectDictDataByType("sys_over_limit_threshold");
+        HashMap<String, String> thresholdMap = new LinkedHashMap<>();
+        //各个类型的概算金额阈值
+        for (SysDictData dictData : data) {
+            //    类型----阈值
+            thresholdMap.put(dictData.getDictLabel(), dictData.getDictValue());
+        }
+        //项目类型
+        for (ProjectTypes value : ProjectTypes.values()) {
+            if (projectType.equals(value.getCode())) {
+                threshold = BigDecimal.valueOf(Long.parseLong(thresholdMap.get(value.getInfo())));
+            }
+            break;
+        }
+        if (evaluation.compareTo(threshold) == 1) {
+            //是超额计划
+            return ("1");
+        } else {
+            return ("0");
+        }
+    }
+
+    //字段赋值对应的名称
+    public List<PlanQuarter> changeTo(List<PlanQuarter> planQuarter) {
+
+        HashMap<String, HashMap<String, String>> planEnums = dictTypeService.getAboutEnums();
+        HashMap<String, String> projectTypesMap = planEnums.get("projectTypes");
+        HashMap<String, String> planPurchaseModesMap = planEnums.get("planPurchaseModes");
+        HashMap<String, String> projectAttributes = planEnums.get("projectAttributes");
+        HashMap<String, String> purchaseServices = planEnums.get("purchaseServices");
+        List<PlanQuarter> list = new ArrayList<PlanQuarter>();
+        for (PlanQuarter planYear : planQuarter) {
+            SysDeptResponseVo sysDeptResponseVo = (SysDeptResponseVo) deptService.selectDeptById(planYear.getPurchaseDeptId()).get("sysDept");
+            planYear.setPurchaseDeptName(sysDeptResponseVo.getDeptName());
+
+            for (Map.Entry<String, String> entry : projectTypesMap.entrySet()) {
+                if (planYear.getProjectType().equals(entry.getValue())) {
+                    planYear.setProjectTypeStr(entry.getKey());
+                    break;
+                }
+            }
+            for (Map.Entry<String, String> entry : planPurchaseModesMap.entrySet()) {
+                if (planYear.getPurchaseMode().equals(entry.getValue())) {
+                    planYear.setPurchaseModeStr(entry.getKey());
+                    break;
+                }
+            }
+            //项目属性是拼接的
+            if (planYear.getProjectAttr().length() > 1) {
+                StringBuilder builder = new StringBuilder();
+                String[] split = planYear.getProjectAttr().split("，");
+                for (String s : split) {
+                    for (Map.Entry<String, String> entry : projectAttributes.entrySet()) {
+                        if (s.equals(entry.getValue())) {
+                            builder.append(entry.getKey() + "，");
+                            break;
+                        }
+                    }
+                }
+                planYear.setProjectAttrStr(builder.toString());
+            } else {
+                for (Map.Entry<String, String> entry : projectAttributes.entrySet()) {
+                    if (planYear.getProjectAttr().equals(entry.getValue())) {
+                        planYear.setProjectAttrStr(entry.getKey());
+                        break;
+                    }
+                }
+            }
+            for (Map.Entry<String, String> entry : purchaseServices.entrySet()) {
+                if (planYear.getPurchaseServices().equals(entry.getValue())) {
+                    planYear.setPurchaseServicesStr(entry.getKey());
+                    break;
+                }
+            }
+
+            list.add(planYear);
+        }
+        return list;
+    }
+}

purchase-system/src/main/java/com/ozs/plan/service/impl/PlanYearsServiceImpl.java

@@ -137,10 +137,51 @@ public class PlanYearsServiceImpl implements PlanYearsService {
         return pageInfo;
     }
 
+    @Override
+    public List<PlanYears> selectPlanYearsExamineListEXP(PlanYearsStandardVo vo) {
+        List<PlanYears> list = new ArrayList<>();
+        List<PlanYears> planYearsList = new ArrayList<>();
+        try {
+            int num = 1;
+            int size = 200;
+            while (size == 200) {
+                LambdaQueryWrapper<PlanYears> lw = new LambdaQueryWrapper<PlanYears>();
+                if (!ObjectUtils.isEmpty(vo.getProjectName())) {
+                    lw.like(PlanYears::getProjectName, vo.getProjectName());
+                }
+                if (!ObjectUtils.isEmpty(vo.getPurchaseServices())) {
+                    lw.eq(PlanYears::getPurchaseServices, vo.getPurchaseServices());
+                }
+                if (!ObjectUtils.isEmpty(vo.getIsExcess())) {
+                    lw.eq(PlanYears::getIsExcess, vo.getIsExcess());
+                }
+                if (!ObjectUtils.isEmpty(vo.getProjectStatus())) {
+                    lw.eq(PlanYears::getProjectStatus, vo.getProjectStatus());
+                } else {
+                    lw.in(PlanYears::getProjectStatus, "1,3");
+                }
+                if (!ObjectUtils.isEmpty(vo.getBeginTime())) {
+                    lw.ge(PlanYears::getPlanDemandSubTime, vo.getBeginTime());
+                }
+                if (!ObjectUtils.isEmpty(vo.getEndTime())) {
+                    lw.le(PlanYears::getPlanDemandSubTime, vo.getEndTime());
+                }
+                Page<PlanYears> page = planYearsMapper.selectPage(new Page<PlanYears>(num, size, false), lw);
+                list.addAll(page.getRecords());
+                size = page.getRecords().size();
+                num++;
+            }
+            planYearsList = changeTo(list);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return planYearsList;
+    }
+
     @Transactional
     @Override
     public AjaxResult insertPlanYears(PlanYearsStandardVo yearsStandardVo) {
-        if (planYearsMapper.countProjectName(yearsStandardVo.getProjectName()).size() > 0) {
+        if (planYearsMapper.countProjectName(yearsStandardVo.getProjectName()) > 0) {
             return AjaxResult.error("该项目名称已经存在");
         }
         PlanYears ofYears = new PlanYears();
@@ -152,7 +193,6 @@ public class PlanYearsServiceImpl implements PlanYearsService {
         //判断是否为超额计划
         ofYears.setIsExcess(isExcessOrNo(ofYears.getProjectType(), ofYears.getEvaluation()));
         ofYears.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
-        ofYears.setSendLetter("0");
         ofYears.setCreateTime(new Date());
         planYearsMapper.insertPlanYears(ofYears);
         log.info("id:{}", ofYears.getPlanYearId());
@@ -224,7 +264,6 @@ public class PlanYearsServiceImpl implements PlanYearsService {
         }
         ofYears.setIsExcess(isExcessOrNo(ofYears.getProjectType(), ofYears.getEvaluation()));
         ofYears.setUpdateTime(new Date());
-        ofYears.setSendLetter("0");
         planYearsMapper.updateInfoById(ofYears);
         List<SysFileRef> sysFileRefs = yearsStandardVo.getSysFileRefs();
         HashMap<String, Object> map = new HashMap<>();
@@ -246,10 +285,17 @@ public class PlanYearsServiceImpl implements PlanYearsService {
     }
 
     @Override
-    public String importPlanYears(List<PlanYears> planYears, boolean isUpdateSupport, LoginUser loginUser) {
+    public String importPlanYears(List<PlanYearsStandardVo> planYears, boolean isUpdateSupport, LoginUser loginUser) {
         if (StringUtils.isNull(planYears) || planYears.size() == 0) {
             throw new ServiceException("导入年度计划数据不能为空！");
         }
+        List<PlanYears> plans = new ArrayList<>();
+        for (PlanYearsStandardVo yearsStandardVo : planYears) {
+            PlanYears ofYears = new PlanYears();
+            BeanUtils.copyProperties(yearsStandardVo, ofYears);
+            ofYears.setPurchaseDeptName(yearsStandardVo.getPurchaseDeptId());
+            plans.add(ofYears);
+        }
         HashMap<String, HashMap<String, String>> planEnums = dictTypeService.getAboutEnums();
         HashMap<String, String> projectTypesMap = planEnums.get("projectTypes");
         HashMap<String, String> planPurchaseModesMap = planEnums.get("planPurchaseModes");
@@ -261,12 +307,11 @@ public class PlanYearsServiceImpl implements PlanYearsService {
         StringBuilder successMsg = new StringBuilder();
         StringBuilder failureMsg = new StringBuilder();
         //deptService
-        for (PlanYears ofYear : planYears) {
+        for (PlanYears ofYear : plans) {
             try {
                 //验证项目名称是否重复导入
-                List<PlanYears> plan = planYearsMapper.countProjectName(ofYear.getProjectName());
                 //将录入信息中的值更改为要保存的数据
-                if (plan.size() == 0) {
+                if (planYearsMapper.countProjectName(ofYear.getProjectName()) == 0) {
                     //采购单位
                     SysDept info = deptMapper.checkDeptNameOnlyOne(ofYear.getPurchaseDeptName());
                     if (StringUtils.isNotNull(info)) {
@@ -287,7 +332,6 @@ public class PlanYearsServiceImpl implements PlanYearsService {
                     }
                     ofYear.setProjectAttr(builder.toString());
                     ofYear.setPurchaseServices(purchaseServices.get(ofYear.getPurchaseServices()));
-                    ofYear.setSendLetter("0");
                     ofYear.setIsExcess(isExcessOrNo(ofYear.getProjectType(), ofYear.getEvaluation()));
                     ofYear.setCreated(String.valueOf(loginUser.getUserId()));
                     ofYear.setCreateTime(new Date());

purchase-system/src/main/java/com/ozs/plan/service/impl/ProvisionalPlanServiceImpl.java

@@ -1,5 +1,7 @@
 package com.ozs.plan.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.ozs.common.core.domain.entity.SysDept;
 import com.ozs.common.core.domain.entity.SysDictData;
@@ -10,19 +12,20 @@ import com.ozs.common.exception.ServiceException;
 import com.ozs.common.utils.StringUtils;
 import com.ozs.plan.doman.PlanYears;
 import com.ozs.plan.doman.ProvisionalPlan;
+import com.ozs.plan.doman.vo.requestVo.ProvisionalPlanVo;
 import com.ozs.plan.mapper.PlanYearsMapper;
 import com.ozs.plan.mapper.ProvisionalPlanMapper;
 import com.ozs.plan.service.ProvisionalPlanService;
+import com.ozs.system.domain.vo.responseVo.SysDeptResponseVo;
 import com.ozs.system.mapper.SysDeptMapper;
+import com.ozs.system.service.ISysDeptService;
 import com.ozs.system.service.ISysDictTypeService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.util.ObjectUtils;
 
 import java.math.BigDecimal;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
+import java.util.*;
 
 @Service
 public class ProvisionalPlanServiceImpl extends ServiceImpl<ProvisionalPlanMapper, ProvisionalPlan> implements ProvisionalPlanService {
@@ -33,6 +36,8 @@ public class ProvisionalPlanServiceImpl extends ServiceImpl<ProvisionalPlanMappe
     private ISysDictTypeService dictTypeService;
     @Autowired
     private SysDeptMapper deptMapper;
+    @Autowired
+    private ISysDeptService deptService;
 
     @Override
     public int deleteProvisionalPlanById(Integer planYearId) {
@@ -87,17 +92,10 @@ public class ProvisionalPlanServiceImpl extends ServiceImpl<ProvisionalPlanMappe
                     ofProvisionalPlan.setIsExcess(isExcessOrNo(ofProvisionalPlan.getProjectType(), ofProvisionalPlan.getEvaluation()));
                     ofProvisionalPlan.setCreated(String.valueOf(loginUser.getUserId()));
                     ofProvisionalPlan.setCreateTime(new Date());
+                    ofProvisionalPlan.setPlanType("1");
                     provisionalPlanMapper.insert(ofProvisionalPlan);
                     successNum++;
                     successMsg.append("*" + successNum + "、项目 " + ofProvisionalPlan.getProjectName() + " 导入成功!");
-                    //} else if (isUpdateSupport) {
-                    //    PlanYears years = plan.get(0);
-                    //    BeanValidators.validateWithException(validator, ofYear);
-                    //    years.setCreateTime(new Date());
-                    //    years.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
-                    //    planYearsMapper.updateById(years);
-                    //    successNum++;
-                    //    successMsg.append("<br/>" + successNum + "、项目 " + ofYear.getProjectName() + " 更新成功");
                 } else {
                     failureNum++;
                     failureMsg.append("*" + successNum + "、项目 " + ofProvisionalPlan.getProjectName() + " 已存在");
@@ -118,6 +116,45 @@ public class ProvisionalPlanServiceImpl extends ServiceImpl<ProvisionalPlanMappe
         return successMsg.toString();
     }
 
+    @Override
+    public List<ProvisionalPlan> selectProvisionalPlanExport(ProvisionalPlanVo vo) {
+        List<ProvisionalPlan> list = new ArrayList<>();
+        List<ProvisionalPlan> provisionalPlanList = new ArrayList<>();
+        try {
+            int num = 1;
+            int size = 200;
+            while (size == 200) {
+                LambdaQueryWrapper<ProvisionalPlan> lw = new LambdaQueryWrapper<ProvisionalPlan>();
+                if (!ObjectUtils.isEmpty(vo.getProjectName())) {
+                    lw.like(ProvisionalPlan::getProjectName, vo.getProjectName());
+                }
+                if (!ObjectUtils.isEmpty(vo.getPurchaseServices())) {
+                    lw.eq(ProvisionalPlan::getPurchaseServices, vo.getPurchaseServices());
+                }
+                if (!ObjectUtils.isEmpty(vo.getIsExcess())) {
+                    lw.eq(ProvisionalPlan::getIsExcess, vo.getIsExcess());
+                }
+                if (!ObjectUtils.isEmpty(vo.getProjectStatus())) {
+                    lw.eq(ProvisionalPlan::getProjectStatus, vo.getProjectStatus());
+                }
+                if (!ObjectUtils.isEmpty(vo.getStartTime())) {
+                    lw.ge(ProvisionalPlan::getPlanDemandSubTime, vo.getStartTime());
+                }
+                if (!ObjectUtils.isEmpty(vo.getEndTime())) {
+                    lw.le(ProvisionalPlan::getPlanDemandSubTime, vo.getEndTime());
+                }
+                Page<ProvisionalPlan> page = provisionalPlanMapper.selectPage(new Page<ProvisionalPlan>(num, size, false), lw);
+                list.addAll(page.getRecords());
+                size = page.getRecords().size();
+                num++;
+            }
+            provisionalPlanList = changeTo(list);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return provisionalPlanList;
+    }
+
     //判断是否为超额计划
     public String isExcessOrNo(String projectType, BigDecimal evaluation) {
         BigDecimal threshold = new BigDecimal(0);
@@ -143,4 +180,62 @@ public class ProvisionalPlanServiceImpl extends ServiceImpl<ProvisionalPlanMappe
             return ("0");
         }
     }
+
+    //字段赋值对应的名称
+    public List<ProvisionalPlan> changeTo(List<ProvisionalPlan> provisionalPlans) {
+        HashMap<String, HashMap<String, String>> planEnums = dictTypeService.getAboutEnums();
+        HashMap<String, String> projectTypesMap = planEnums.get("projectTypes");
+        HashMap<String, String> planPurchaseModesMap = planEnums.get("planPurchaseModes");
+        HashMap<String, String> projectAttributes = planEnums.get("projectAttributes");
+        HashMap<String, String> purchaseServices = planEnums.get("purchaseServices");
+        List<ProvisionalPlan> list = new ArrayList<ProvisionalPlan>();
+        for (ProvisionalPlan provisionalPlan : provisionalPlans) {
+            if (provisionalPlan.getPurchaseDeptId() != null) {
+                SysDeptResponseVo sysDeptResponseVo = (SysDeptResponseVo) deptService.selectDeptById(provisionalPlan.getPurchaseDeptId()).get("sysDept");
+                provisionalPlan.setPurchaseDeptName(sysDeptResponseVo.getDeptName());
+            }
+            for (Map.Entry<String, String> entry : projectTypesMap.entrySet()) {
+                if (provisionalPlan.getProjectType() != null && provisionalPlan.getProjectType().equals(entry.getValue())) {
+                    provisionalPlan.setProjectTypeStr(entry.getKey());
+                    break;
+                }
+            }
+            for (Map.Entry<String, String> entry : planPurchaseModesMap.entrySet()) {
+                if (provisionalPlan.getPurchaseMode() != null && provisionalPlan.getPurchaseMode().equals(entry.getValue())) {
+                    provisionalPlan.setPurchaseModeStr(entry.getKey());
+                    break;
+                }
+            }
+            //项目属性是拼接的
+            if (provisionalPlan.getProjectAttr().length() > 1) {
+                StringBuilder builder = new StringBuilder();
+                String[] split = provisionalPlan.getProjectAttr().split("，");
+                for (String s : split) {
+                    for (Map.Entry<String, String> entry : projectAttributes.entrySet()) {
+                        if (s.equals(entry.getValue())) {
+                            builder.append(entry.getKey() + "，");
+                            break;
+                        }
+                    }
+                }
+                provisionalPlan.setProjectAttrStr(builder.toString());
+            } else {
+                for (Map.Entry<String, String> entry : projectAttributes.entrySet()) {
+                    if (provisionalPlan.getProjectAttr() != null && provisionalPlan.getProjectAttr().equals(entry.getValue())) {
+                        provisionalPlan.setProjectAttrStr(entry.getKey());
+                        break;
+                    }
+                }
+            }
+            for (Map.Entry<String, String> entry : purchaseServices.entrySet()) {
+                if (provisionalPlan.getPurchaseServices() != null && provisionalPlan.getPurchaseServices().equals(entry.getValue())) {
+                    provisionalPlan.setPurchaseServicesStr(entry.getKey());
+                    break;
+                }
+            }
+
+            list.add(provisionalPlan);
+        }
+        return list;
+    }
 }

purchase-system/src/main/java/com/ozs/pm/doman/vo/responseVo/PmDemandResVo.java

@@ -227,4 +227,10 @@ public class PmDemandResVo extends BaseEntity
      */
     @ApiModelProperty("采购需求审核文件")
     HashMap<String, String> auditFileMap;
+
+    /**
+     * 任务下达文件
+     */
+    @ApiModelProperty("任务下达文件")
+    HashMap<String, String> taskReleaseFileMap;
 }

purchase-system/src/main/java/com/ozs/pm/service/IPmDemandService.java

@@ -33,15 +33,8 @@ public interface IPmDemandService extends IService<PmDemand>
      * @param pmDemandReqVo 采购需求
      * @return 采购需求集合
      */
-    public IPage<PmDemandResVo> selectPmDemandList(PmDemandReqVo pmDemandReqVo);
+    public IPage<PmDemandResVo> selectPmDemandList(PmDemandReqVo pmDemandReqVo,int reqType);
 
-    /**
-     * 审核单位查询采购需求列表
-     *
-     * @param pmDemandReqVo 采购需求
-     * @return 采购需求集合
-     */
-    public IPage<PmDemandResVo> selectPmDemanDexamineList(PmDemandReqVo pmDemandReqVo);
 
     /**
      * 新增采购需求
@@ -105,4 +98,12 @@ public interface IPmDemandService extends IService<PmDemand>
      * @return 结果
      */
     public int reviewReturn(PmDemandReqVo pmDemandReqVo);
+
+    /**
+     * 下达任务
+     *
+     * @param pmDemandReqVo
+     * @return 结果
+     */
+    public int releaseTask(PmDemandReqVo pmDemandReqVo);
 }

purchase-system/src/main/java/com/ozs/pm/service/impl/PmDemandServiceImpl.java

@@ -82,16 +82,24 @@ public class PmDemandServiceImpl extends ServiceImpl<PmDemandMapper, PmDemand> i
                 vo.setPurchaseServicesName(purchaseServicesName);
             }
 
+            //采购需求附件
             HashMap<String, String> demandFileMap = getFileMap(vo.getDemandId(),SysFileRefEnum.PM_DEMAND.getType());
             if(demandFileMap != null){
                 vo.setDemandFileMap(demandFileMap);
             }
 
+            //采购需求审核文件
             HashMap<String, String> auditFileMap = getFileMap(vo.getDemandId(),SysFileRefEnum.PM_DEMAND_EXAMINE.getType());
             if(auditFileMap != null){
                 vo.setAuditFileMap(auditFileMap);
             }
 
+            //任务下达文件
+            HashMap<String, String> taskReleaseFileMap = getFileMap(vo.getDemandId(),SysFileRefEnum.PM_TAST_RELEASE.getType());
+            if(taskReleaseFileMap != null){
+                vo.setTaskReleaseFileMap(taskReleaseFileMap);
+            }
+
             //项目类型
             for (ProjectTypes value : ProjectTypes.values()) {
                 if (vo.getProjectType() != null && vo.getProjectType().equals(value.getCode())) {
@@ -255,7 +263,7 @@ public class PmDemandServiceImpl extends ServiceImpl<PmDemandMapper, PmDemand> i
      * @return 采购需求
      */
     @Override
-    public IPage<PmDemandResVo> selectPmDemandList(PmDemandReqVo pmDemandReqVo) {
+    public IPage<PmDemandResVo> selectPmDemandList(PmDemandReqVo pmDemandReqVo, int reqType) {
 
         LambdaQueryWrapper<PmDemand> lw = new LambdaQueryWrapper<>();
         if (!StringUtils.isBlank(pmDemandReqVo.getProjectName())) {
@@ -277,111 +285,18 @@ public class PmDemandServiceImpl extends ServiceImpl<PmDemandMapper, PmDemand> i
             lw.apply("(plan_demand_sub_time <= '" + pmDemandReqVo.getEndDate() +"' or plan_purchase_finish_time <= '" + pmDemandReqVo.getEndDate() + "' or plan_deliver_time <=  '" + pmDemandReqVo.getEndDate() +"' )");
         }
 
-        IPage<PmDemand> pageRes = this.page(new Page<>(pmDemandReqVo.getPageNum(), pmDemandReqVo.getPageSize()), lw);
-        IPage<PmDemandResVo> results = new Page<>(pageRes.getCurrent(), pageRes.getSize(), pageRes.getTotal());
-        if(pageRes.getRecords() != null && pageRes.getRecords().size() > 0){
-            List<PmDemandResVo> pmDemandResponseVoList = new ArrayList<>();
-            for(PmDemand pmDemand1 : pageRes.getRecords()){
-                PmDemandResVo vo = new PmDemandResVo();
-                BeanUtils.copyProperties(pmDemand1,vo);
-                if(vo.getPurchaseDeptId() != null){
-                    Map<String, Object> deptMap =  deptService.selectDeptById(vo.getPurchaseDeptId());
-                    if(deptMap!= null){
-                        SysDeptResponseVo sysDeptResponseVo = (SysDeptResponseVo)deptMap.get("sysDept");
-                        if(sysDeptResponseVo != null){
-                            vo.setPurchaseDeptName(sysDeptResponseVo.getDeptName());
-                        }
-                    }
-                }
-
-                String purchaseServicesName = dictDataService.selectDictLabel("purchase_services",vo.getPurchaseServices());
-                if(StringUtils.isNotEmpty(purchaseServicesName)){
-                    vo.setPurchaseServicesName(purchaseServicesName);
-                }
-
-                //项目类型
-                for (ProjectTypes value : ProjectTypes.values()) {
-                    if (vo.getProjectType() != null && vo.getProjectType().equals(value.getCode())) {
-                        vo.setProjectTypeName(value.getInfo());
-                        break;
-                    }
-                }
-                //是否为超限额计划
-                for (IsExcess value : IsExcess.values()) {
-                    if (vo.getIsExcess() != null && vo.getIsExcess().equals(value.getCode())) {
-                        vo.setIsExcessName(value.getInfo());
-                        break;
-                    }
-                }
-
-                //采购方式
-                for (PlanPurchaseMode value : PlanPurchaseMode.values()) {
-                    if (vo.getPurchaseMode() != null && vo.getPurchaseMode().equals(value.getCode())) {
-                        vo.setPurchaseModeName(value.getInfo());
-                        break;
-                    }
-                }
-                //项目属性
-                for (ProjectAttribute value : ProjectAttribute.values()) {
-                    if (vo.getProjectAttr() != null && vo.getProjectAttr().equals(value.getCode())) {
-                        vo.setProjectAttrName(value.getInfo());
-                        break;
-                    }
-                }
-                //预警状态
-                for (WarnStatus value : WarnStatus.values()) {
-                    if (vo.getWarnStatus() != null && vo.getWarnStatus().equals(value.getCode())) {
-                        vo.setWarnStatusName(value.getInfo());
-                        break;
-                    }
-                }
-
-                //项目状态
-                for (PmProjectStatus value : PmProjectStatus.values()) {
-                    if (vo.getProjectStatus() != null && vo.getProjectStatus().equals(value.getCode())) {
-                        vo.setProjectStatusName(value.getInfo());
-                        break;
-                    }
-                }
-                pmDemandResponseVoList.add(vo);
-            }
-            results.setRecords(pmDemandResponseVoList);
-        }
-
-        return results;
-    }
-
-    /**
-     * 审核单位查询采购需求列表
-     *
-     * @param pmDemandReqVo
-     * @return 采购需求
-     */
-    @Override
-    public IPage<PmDemandResVo> selectPmDemanDexamineList(PmDemandReqVo pmDemandReqVo) {
-
-        LambdaQueryWrapper<PmDemand> lw = new LambdaQueryWrapper<>();
-        if (!StringUtils.isBlank(pmDemandReqVo.getProjectName())) {
-            lw.like(PmDemand::getProjectName, "%" + pmDemandReqVo.getProjectName() + "%");
-        }
-        if (!StringUtils.isBlank(pmDemandReqVo.getPurchaseServices())) {
-            lw.eq(PmDemand::getPurchaseServices, pmDemandReqVo.getPurchaseServices());
-        }
-        if (pmDemandReqVo.getProjectStatus() != null) {
-            lw.eq(PmDemand::getProjectStatus, pmDemandReqVo.getProjectStatus());
-        }
-        if (pmDemandReqVo.getIsExcess() != null) {
-            lw.eq(PmDemand::getIsExcess, pmDemandReqVo.getIsExcess());
-        }
-        if (!StringUtils.isBlank(pmDemandReqVo.getBeginDate())) {
-            lw.apply("(plan_demand_sub_time >= '" + pmDemandReqVo.getBeginDate() +"' or plan_purchase_finish_time >= '" + pmDemandReqVo.getBeginDate() + "' or plan_deliver_time >=  '" + pmDemandReqVo.getBeginDate() +"' )");
-        }
-        if (!StringUtils.isBlank(pmDemandReqVo.getEndDate())) {
-            lw.apply("(plan_demand_sub_time <= '" + pmDemandReqVo.getEndDate() +"' or plan_purchase_finish_time <= '" + pmDemandReqVo.getEndDate() + "' or plan_deliver_time <=  '" + pmDemandReqVo.getEndDate() +"' )");
+        if(reqType== 1) { //需求审核单位列表
+            lw.eq(PmDemand::getProjectStatus, PmProjectStatus.DEMAND_WAIT_AUDIT.getCode());
+        } else  if(reqType== 2) { //任务下达列表
+            lw.apply("(project_status = 8 or project_status = 9 )");
+        } else  if(reqType== 3) { //采购执行列表
+            lw.apply("(project_status = 9 or project_status = 10 )");
+        } else  if(reqType== 4) { //合同信息列表
+            lw.apply("(project_status = 10 or project_status = 11 )");
+        }  else  if(reqType== 5) { //项目建设列表
+            lw.apply("(project_status = 11 or project_status = 12 )");
         }
 
-        lw.eq(PmDemand::getProjectStatus, PmProjectStatus.DEMAND_WAIT_AUDIT.getCode());
-
         IPage<PmDemand> pageRes = this.page(new Page<>(pmDemandReqVo.getPageNum(), pmDemandReqVo.getPageSize()), lw);
         IPage<PmDemandResVo> results = new Page<>(pageRes.getCurrent(), pageRes.getSize(), pageRes.getTotal());
         if(pageRes.getRecords() != null && pageRes.getRecords().size() > 0){
@@ -456,6 +371,7 @@ public class PmDemandServiceImpl extends ServiceImpl<PmDemandMapper, PmDemand> i
         return results;
     }
 
+
     /**
      * 新增采购需求
      *
@@ -793,4 +709,34 @@ public class PmDemandServiceImpl extends ServiceImpl<PmDemandMapper, PmDemand> i
         pmDemand.setAuditTime(DateUtils.getNowDate());
         return pmDemandMapper.updatePmDemand(pmDemand);
     }
+
+    /**
+     * 下达任务
+     *
+     * @param pmDemandReqVo
+     * @return 结果
+     */
+    @Override
+    public int releaseTask(PmDemandReqVo pmDemandReqVo) {
+        PmDemand pmDemand = new PmDemand();
+        pmDemand.setDemandId(pmDemandReqVo.getDemandId());
+        pmDemand.setProjectStatus(Long.parseLong(PmProjectStatus.BID_INFO_WAIT_FILL.getCode()));
+        List<SysFileRef> sysFileRefs = pmDemandReqVo.getSysFileRefs();
+        if (!ObjectUtils.isEmpty(sysFileRefs)) {
+            for (SysFileRef ref : sysFileRefs) {
+                ref.setRedId(pmDemandReqVo.getDemandId());
+                ref.setType(SysFileRefEnum.PM_TAST_RELEASE.getType());
+                ref.setCreated(pmDemandReqVo.getUpdateBy());
+                ref.setCreateTime(new Date());
+                ref.setUpdated(pmDemandReqVo.getUpdateBy());
+                ref.setUpdateTime(new Date());
+                sysFileRefService.save(ref);
+            }
+        }
+        pmDemand.setUpdateBy(pmDemandReqVo.getUpdateBy());
+        pmDemand.setUpdateTime(DateUtils.getNowDate());
+        pmDemand.setAuditTime(DateUtils.getNowDate());
+        return pmDemandMapper.updatePmDemand(pmDemand);
+    }
+
 }

purchase-system/src/main/resources/mapper/plan/PlanQuarterMapper.xml

@@ -0,0 +1,187 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+		PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+		"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.ozs.plan.mapper.PlanQuarterMapper">
+
+	<resultMap type="com.ozs.plan.doman.PlanQuarter" id="PlanQuarterResult">
+		<id property="plan_practical_id" column="planPracticalId"/>
+		<result property="plan_year_id" column="planYearId"/>
+		<result property="purchase_dept_id" column="purchaseDeptId"/>
+		<result property="project_name" column="projectName"/>
+		<result property="project_type" column="projectType"/>
+		<result property="demand_overview" column="demandOverview"/>
+		<result property="evaluation" column="evaluation"/>
+		<result property="is_excess" column="isExcess"/>
+		<result property="purchase_services" column="purchaseServices"/>
+		<result property="purchase_mode" column="purchaseMode"/>
+		<result property="plan_demand_sub_time" column="planDemandSubTime"/>
+		<result property="plan_purchase_finish_time" column="planPurchaseFinishTime"/>
+		<result property="plan_deliver_time" column="planDeliverTime"/>
+		<result property="project_attr" column="projectAttr"/>
+		<result property="adjust_reason" column="adjustReason"/>
+		<result property="remarks" column="remarks"/>
+		<result property="project_status" column="projectStatus"/>
+		<result property="send_letter" column="sendLetter"/>
+		<result property="created" column="created"/>
+		<result property="create_time" column="createTime"/>
+		<result property="updated" column="updated"/>
+		<result property="update_time" column="updateTime"/>
+		<result property="refuse_reason" column="refuseReason"/>
+		<result property="del_flay" column="delFlay"/>
+		<result property="plan_type" column="planType"/>
+	</resultMap>
+
+	<update id="updateInfoById" parameterType="com.ozs.plan.doman.PlanQuarter">
+		update plan_practical
+		set project_name=#{projectName},
+			project_type=#{projectType},
+			demand_overview=#{demandOverview},
+			evaluation=#{evaluation},
+			is_excess=#{isExcess},
+			purchase_services=#{purchaseServices},
+			purchase_mode=#{purchaseMode},
+			plan_demand_sub_time=#{planDemandSubTime},
+			plan_purchase_finish_time=#{planPurchaseFinishTime},
+			plan_deliver_time=#{planDeliverTime},
+			project_attr=#{projectAttr},
+			adjust_reason=#{adjustReason},
+			remarks=#{remarks},
+			updated=#{updated},
+			update_time=#{updateTime}
+		where plan_practical_id = #{planPracticalId}
+	</update>
+
+	<select id="selectPlanQuarterList" parameterType="com.ozs.plan.doman.PlanQuarter" resultMap="PlanQuarterResult">
+		select * from plan_practical
+		<where>
+			<if test="projectName != null and projectName != ''">
+				AND project_name like concat('%', #{projectName}, '%')
+			</if>
+			<if test="purchaseServices != null and purchaseServices != ''">
+				AND purchase_services = #{purchaseServices}
+			</if>
+			<if test="isExcess != null and isExcess != ''">
+				AND is_excess = #{isExcess}
+			</if>
+			<if test="projectStatus != null and projectStatus != ''">
+				AND project_status = #{projectStatus}
+			</if>
+			<if test="beginTime != null  "><!-- 开始时间检索 -->
+				and date_format(plan_demand_sub_time,'%y%m%d') &gt;= date_format(#{beginTime},'%y%m%d')
+			</if>
+			<if test="endTime != null  "><!-- 结束时间检索 -->
+				and date_format(plan_demand_sub_time,'%y%m%d') &lt;= date_format(#{endTime},'%y%m%d')
+			</if>
+			and plan_type=0
+			and del_flay=0
+		</where>
+		order by create_time desc
+	</select>
+
+	<select id="selectPlanQuarterExamineList" parameterType="com.ozs.plan.doman.PlanQuarter"
+			resultMap="PlanQuarterResult">
+		select * from plan_practical
+		<where>
+			<if test="projectName != null and projectName != ''">
+				AND project_name like concat('%', #{projectName}, '%')
+			</if>
+			<if test="purchaseServices != null and purchaseServices != ''">
+				AND purchase_services = #{purchaseServices}
+			</if>
+			<if test="isExcess != null and isExcess != ''">
+				AND is_excess = #{isExcess}
+			</if>
+			<if test="projectStatus == null or projectStatus ==''">
+				AND project_status in (1,3)
+			</if>
+			<if test="projectStatus != null and projectStatus != ''">
+				AND project_status = #{projectStatus}
+			</if>
+			<if test="beginTime != null "><!-- 开始时间检索 -->
+				and date_format(plan_demand_sub_time,'%y%m%d') &gt;= date_format(#{beginTime},'%y%m%d')
+			</if>
+			<if test="endTime != null "><!-- 结束时间检索 -->
+				and date_format(plan_demand_sub_time,'%y%m%d') &lt;= date_format(#{endTime},'%y%m%d')
+			</if>
+			and plan_type=0
+			and del_flay=0
+		</where>
+		order by create_time desc
+	</select>
+
+	<select id="countProjectName" resultType="java.lang.Integer" parameterType="java.lang.String">
+		select count(plan_practical.plan_practical_id)
+		from plan_practical
+		where project_name = #{projectName}
+		  and plan_type = 0
+		  and del_flay = 0
+	</select>
+
+	<select id="getById" resultType="com.ozs.plan.doman.PlanQuarter" parameterType="java.lang.Long">
+		select *
+		from plan_practical
+		where plan_practical_id = #{planPracticalId}
+		  and del_flay = 0
+	</select>
+
+	<select id="countProjectNameOther" resultType="java.lang.Integer" parameterType="java.lang.String">
+		select count(plan_practical.plan_practical_id)
+		from plan_practical
+		where project_name = #{projectName}
+		  and plan_practical_id != #{planPracticalId}
+		  and plan_type = 0
+		  and del_flay = 0
+	</select>
+
+	<!--	创建计划信息-->
+	<insert id="insertPlanQuarter" parameterType="com.ozs.plan.doman.PlanQuarter" useGeneratedKeys="true"
+			keyProperty="planYearId">
+		insert into plan_practical (purchase_dept_id, project_name, project_type, demand_overview, evaluation,
+									is_excess,
+									purchase_services, purchase_mode, plan_demand_sub_time, plan_purchase_finish_time,
+									plan_deliver_time, project_attr, adjust_reason, remarks, project_status,
+									created, create_time, del_flay, plan_type, send_letter)
+		values (#{purchaseDeptId}, #{projectName}, #{projectType}, #{demandOverview}, #{evaluation}, #{isExcess},
+				#{purchaseServices}, #{purchaseMode}, #{planDemandSubTime}, #{planPurchaseFinishTime},
+				#{planDeliverTime},
+				#{projectAttr}, #{adjustReason}, #{remarks}, #{projectStatus}, #{created}, #{createTime}, 0, 0, 0)
+	</insert>
+
+	<!--	计划删除-->
+	<update id="deletePlanQuarterByIds" parameterType="java.lang.Long">
+		update plan_practical set del_flay=1 where plan_practical_id in
+		<foreach collection="array" item="item" open="(" separator="," close=")">
+			#{item}
+		</foreach>
+	</update>
+
+	<update id="deletePlanQuarterById" parameterType="java.lang.Long">
+		update plan_practical
+		set del_flay=1
+		where plan_practical_id = #{planPracticalId}
+	</update>
+
+	<!--	计划提交-->
+	<update id="commit" parameterType="java.lang.Long">
+		update plan_practical
+		set project_status=1
+		where plan_practical_id = #{planPracticalId}
+	</update>
+
+	<!--	计划审核-->
+	<update id="review" parameterType="com.ozs.plan.doman.PlanQuarter">
+		update plan_practical
+		set refuse_reason=#{refuseReason},
+			project_status=#{projectStatus}
+		where plan_practical_id = #{planPracticalId}
+	</update>
+
+	<update id="sendLetter" parameterType="java.lang.Long">
+		update plan_practical
+		set send_letter= 1
+		where plan_practical_id = #{planPracticalId}
+	</update>
+
+
+</mapper>

purchase-system/src/main/resources/mapper/plan/PlanYearsMapper.xml

@@ -105,8 +105,8 @@
 		order by create_time desc
 	</select>
 
-	<select id="countProjectName" resultType="com.ozs.plan.doman.PlanYears" parameterType="java.lang.String">
-		select *
+	<select id="countProjectName" resultType="java.lang.Integer" parameterType="java.lang.String">
+		select count(plan_years.plan_year_id)
 		from plan_years
 		where project_name = #{projectName}
 		  and del_flay = 0
@@ -133,11 +133,11 @@
 		insert into plan_years (purchase_dept_id, project_name, project_type, demand_overview, evaluation, is_excess,
 								purchase_services, purchase_mode, plan_demand_sub_time, plan_purchase_finish_time,
 								plan_deliver_time, project_attr, adjust_reason, remarks, project_status,
-								created, create_time, del_flay)
+								created, create_time, del_flay, send_letter)
 		values (#{purchaseDeptId}, #{projectName}, #{projectType}, #{demandOverview}, #{evaluation}, #{isExcess},
 				#{purchaseServices}, #{purchaseMode}, #{planDemandSubTime}, #{planPurchaseFinishTime},
 				#{planDeliverTime},
-				#{projectAttr}, #{adjustReason}, #{remarks}, #{projectStatus}, #{created}, #{createTime}, 0)
+				#{projectAttr}, #{adjustReason}, #{remarks}, #{projectStatus}, #{created}, #{createTime}, 0, 0)
 	</insert>
 
 	<!--	计划删除-->

purchase-system/src/main/resources/mapper/plan/ProvisionalPlanMapper.xml

@@ -102,6 +102,6 @@
 	</update>
 
 	<select id="selectProjectName" resultType="com.ozs.plan.doman.ProvisionalPlan" parameterType="java.lang.String">
-		select * from plan_practical where project_name = #{projectName} and del_flay = 0 and plan_type = 1
+		select * from plan_practical where project_name = #{projectName} and del_flay = 0 and plan_type = "1"
 	</select>
 </mapper>