年度计划和季度计划

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

@@ -70,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);
     }
@@ -144,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-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/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

@@ -92,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/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

@@ -181,7 +181,7 @@ public class PlanYearsServiceImpl implements PlanYearsService {
     @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();
@@ -193,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());
@@ -265,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<>();
@@ -287,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");
@@ -302,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)) {
@@ -328,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/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>
 
 	<!--	计划删除-->