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

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

@@ -0,0 +1,102 @@
+package com.ozs.web.controller.base;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.ozs.base.domain.BaseAgency;
+import com.ozs.base.domain.BaseExpert;
+import com.ozs.base.domain.BaseProfessional;
+import com.ozs.base.domain.BaseSupplier;
+import com.ozs.base.domain.vo.BaseExpertVo;
+import com.ozs.base.domain.vo.BaseProfessionalVo;
+import com.ozs.base.service.BaseExpertService;
+import com.ozs.base.service.BaseProfessionalService;
+import com.ozs.base.vo.BaseAgentPageReqVo;
+import com.ozs.common.core.controller.BaseController;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.common.utils.StringUtils;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.util.ObjectUtils;
+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.validation.constraints.NotEmpty;
+import java.util.List;
+
+/**
+ * 专业库管理
+ *
+ * @author sunhh
+ */
+@Api(tags = "专家库管理")
+@RestController
+@RequestMapping("/base/expert")
+public class BaseExpertController extends BaseController {
+
+    @Autowired
+    private BaseExpertService baseExpertService;
+
+    @ApiOperation(value = "新增专家库", notes = "必传 专家库名称")
+    @PostMapping("/insertExpert")
+    public AjaxResult insertExpert(BaseExpert baseExpert) {
+        if (StringUtils.isNull(baseExpert) || StringUtils.isNull(baseExpert.getExpertName())) {
+            return error("专家库名称不能为空");
+        }
+        return toAjax(baseExpertService.save(baseExpert));
+    }
+
+    @ApiOperation(value = "删除专家库", notes = "必传 id")
+    @PostMapping("/deleteExpert")
+    public AjaxResult deleteExpert(BaseExpert baseExpert) {
+        if (StringUtils.isNull(baseExpert) || StringUtils.isNull(baseExpert.getId())) {
+            return error("专家库id不能为空");
+        }
+        return toAjax(baseExpertService.removeById(baseExpert.getId()));
+    }
+
+    @ApiOperation(value = "修改专家库", notes = "必传 id 及修改数据")
+    @PostMapping("/updateExpert")
+    public AjaxResult updateProfessional(BaseExpert baseExpert) {
+        if (StringUtils.isNull(baseExpert) || StringUtils.isNull(baseExpert.getId())) {
+            return error("专家库id和修改数据不能为空");
+        }
+        return toAjax(baseExpertService.updateById(baseExpert));
+    }
+
+    @ApiOperation(value = "查询专家库树结构", notes = "非必传 查询条件：品目名称")
+    @PostMapping("/selectExpert")
+    public AjaxResult selectExpert(@NotEmpty(message = "数据为空") @RequestBody BaseExpertVo baseExpertVo) {
+        LambdaQueryWrapper<BaseExpert> lw = new LambdaQueryWrapper<BaseExpert>();
+        if (!StringUtils.isBlank(baseExpertVo.getExpertName())) {
+            lw.like(BaseExpert::getExpertName, baseExpertVo.getExpertName());
+        }
+        if (!StringUtils.isBlank(baseExpertVo.getMajorType())) {
+            lw.eq(BaseExpert::getMajorType, baseExpertVo.getMajorType());
+        }
+        if (!ObjectUtils.isEmpty(baseExpertVo.getMajorGrade())) {
+            lw.eq(BaseExpert::getMajorGrade, baseExpertVo.getMajorGrade());
+        }
+        IPage<BaseExpert> page = baseExpertService.page(new Page<BaseExpert>(baseExpertVo.getPageNum(), baseExpertVo.getPageSize()), lw);
+        return success(page);
+    }
+
+    @ApiOperation(value = "黑白名单开关", notes = "必传id,supplierType 其他字段不传； 黑名单传0，白名单传1")
+    @PostMapping("/updateSupplierType")
+    public AjaxResult updateSupplierType(BaseExpert baseExpert) {
+        if (StringUtils.isNull(baseExpert) || StringUtils.isNull(baseExpert.getId()) || StringUtils.isNotNull(baseExpert.getStatus())) {
+            return error("状态及ID不能为空");
+        }
+        LambdaQueryWrapper<BaseExpert> lw = new LambdaQueryWrapper<BaseExpert>();
+        if (!StringUtils.isNull(baseExpert.getId())) {
+            lw.eq(BaseExpert::getId, baseExpert.getId());
+        }
+        if (!StringUtils.isBlank(baseExpert.getStatus())) {
+            lw.like(BaseExpert::getStatus, baseExpert.getStatus());
+        }
+        return toAjax(baseExpertService.update(lw));
+    }
+}

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

@@ -5,12 +5,16 @@ 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.exception.ServiceException;
 import com.ozs.common.utils.StringUtils;
+import com.ozs.common.utils.poi.ExcelUtil;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
+import javax.servlet.http.HttpServletResponse;
 import java.util.List;
 
 /**
@@ -67,4 +71,25 @@ public class BaseProfessionalController extends BaseController {
         List<BaseProfessionalVo> baseSupplierList = baseProfessionalService.selectBaseProfessional(baseProfessionalVo);
         return success(baseSupplierList);
     }
+
+    @ApiOperation(value = "导入专业库", notes = "导入表格")
+    @PostMapping("/importBaseProfessional")
+    public AjaxResult importBaseProfessional(MultipartFile file) throws Exception {
+        ExcelUtil<BaseProfessional> util = new ExcelUtil<BaseProfessional>(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);
+        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, "参数数据");
+    }
 }

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

@@ -0,0 +1,35 @@
+package com.ozs.web.controller.plan;
+
+import com.ozs.common.core.controller.BaseController;
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.system.service.ISysDictTypeService;
+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.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 年度计划信息中的枚举类信息
+ *
+ * @author buzhanyi
+ */
+@RestController
+@RequestMapping("/plan/about")
+public class PlanEnumsController extends BaseController {
+
+    @Autowired
+    private ISysDictTypeService dictTypeService;
+
+    /**
+     * 获取年度计划信息中的枚举类信息(下拉框数据)
+     *
+     * @return 年度计划信息中的枚举类信息(下拉框数据)
+     */
+    @ApiOperation(value = "年度计划信息中的枚举类信息(下拉框数据)")
+    @PostMapping("/getAboutEnums")
+    public AjaxResult getAboutEnums() {
+        return AjaxResult.success(dictTypeService.getAboutEnums());
+    }
+
+}

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

@@ -2,14 +2,13 @@ package com.ozs.web.controller.plan;
 
 import com.ozs.common.core.controller.BaseController;
 import com.ozs.common.core.domain.AjaxResult;
-import com.ozs.common.core.domain.entity.SysUser;
 import com.ozs.common.core.domain.model.LoginUser;
 import com.ozs.common.core.page.TableDataInfo;
 import com.ozs.common.utils.poi.ExcelUtil;
 import com.ozs.framework.web.service.TokenService;
-import com.ozs.plan.doman.PlanOfYears;
-import com.ozs.plan.doman.vo.requestVo.PlanOfYearsStandardVo;
-import com.ozs.plan.service.PlanOfYearsService;
+import com.ozs.plan.doman.PlanYears;
+import com.ozs.plan.doman.vo.requestVo.PlanYearsStandardVo;
+import com.ozs.plan.service.PlanYearsService;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -28,73 +27,73 @@ import java.util.List;
  */
 @RestController
 @RequestMapping("/plan/planOfYears")
-public class PlanOfYearsController extends BaseController {
+public class PlanYearsController extends BaseController {
     @Autowired
-    private PlanOfYearsService planOfYearsService;
+    private PlanYearsService planYearsService;
     @Autowired
     private TokenService tokenService;
 
     @ApiOperation(value = "查询年度计划")
     @PostMapping("/list")
-    public TableDataInfo list(@RequestBody PlanOfYearsStandardVo yearsStandardVo) {
+    public TableDataInfo list(@RequestBody PlanYearsStandardVo yearsStandardVo) {
         startPage();
-        List<PlanOfYears> list = planOfYearsService.selectPlanOfYearsList(yearsStandardVo);
+        List<PlanYears> list = planYearsService.selectPlanOfYearsList(yearsStandardVo);
         return getDataTable(list);
     }
 
     @ApiOperation(value = "创建年度计划")
     @PostMapping("/add")
-    public AjaxResult add(@RequestBody PlanOfYearsStandardVo yearsStandardVo, HttpServletRequest request) {
+    public AjaxResult add(@RequestBody PlanYearsStandardVo yearsStandardVo, HttpServletRequest request) {
         //获取采购单位-
         LoginUser loginUser = tokenService.getLoginUser(request);
         yearsStandardVo.setPurchaseUnit(loginUser.getDeptId());
         yearsStandardVo.setCreateBy(String.valueOf(loginUser.getUserId()));
-        return planOfYearsService.insertPlanOfYears(yearsStandardVo);
+        return planYearsService.insertPlanOfYears(yearsStandardVo);
     }
 
     @ApiOperation(value = "修改年度计划")
     @PostMapping("/update")
-    public AjaxResult update(@RequestBody PlanOfYearsStandardVo yearsStandardVo) {
-        return planOfYearsService.update(yearsStandardVo);
+    public AjaxResult update(@RequestBody PlanYearsStandardVo yearsStandardVo) {
+        return planYearsService.update(yearsStandardVo);
     }
 
     @ApiOperation(value = "提交年度计划")
     @PostMapping("/commit")
-    public AjaxResult commit(@RequestBody PlanOfYearsStandardVo yearsStandardVo) {
-        return planOfYearsService.commit(yearsStandardVo);
+    public AjaxResult commit(@RequestBody PlanYearsStandardVo yearsStandardVo) {
+        return planYearsService.commit(yearsStandardVo);
     }
 
     @ApiOperation(value = "删除年度计划")
     @PostMapping("/delete")
-    public AjaxResult delete(@RequestBody PlanOfYearsStandardVo yearsStandardVo) {
-        return planOfYearsService.deletePlanOfYearsById(yearsStandardVo.getPlanYearId());
+    public AjaxResult delete(@RequestBody PlanYearsStandardVo yearsStandardVo) {
+        return planYearsService.deletePlanOfYearsById(yearsStandardVo.getPlanYearId());
     }
 
     @ApiOperation(value = "根据id获取年度计划信息")
     @PostMapping("/view")
-    public AjaxResult view(@RequestBody PlanOfYearsStandardVo yearsStandardVo) {
-        return planOfYearsService.view(yearsStandardVo);
+    public AjaxResult view(@RequestBody PlanYearsStandardVo yearsStandardVo) {
+        return planYearsService.view(yearsStandardVo);
     }
 
     @ApiOperation(value = "审核年度计划通过")
     @PostMapping("/reviewTo")
-    public AjaxResult reviewTo(@RequestBody PlanOfYearsStandardVo yearsStandardVo) {
-        return planOfYearsService.reviewTo(yearsStandardVo);
+    public AjaxResult reviewTo(@RequestBody PlanYearsStandardVo yearsStandardVo) {
+        return planYearsService.reviewTo(yearsStandardVo);
     }
 
     @ApiOperation(value = "审核年度计划退回")
     @PostMapping("/reviewReturn")
-    public AjaxResult reviewReturn(@RequestBody PlanOfYearsStandardVo yearsStandardVo) {
-        return planOfYearsService.reviewReturn(yearsStandardVo);
+    public AjaxResult reviewReturn(@RequestBody PlanYearsStandardVo yearsStandardVo) {
+        return planYearsService.reviewReturn(yearsStandardVo);
     }
 
     @ApiOperation(value = "导入年度计划数据")
     @PostMapping("/importData")
     public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception {
-        ExcelUtil<PlanOfYears> util = new ExcelUtil<>(PlanOfYears.class);
-        List<PlanOfYears> planOfYears = util.importExcel(file.getInputStream());
+        ExcelUtil<PlanYears> util = new ExcelUtil<>(PlanYears.class);
+        List<PlanYears> planYears = util.importExcel(file.getInputStream());
         String operName = getUsername();
-        String message = planOfYearsService.importPlanOfYears(planOfYears, updateSupport, operName);
+        String message = planYearsService.importPlanOfYears(planYears, updateSupport, operName);
         return success(message);
     }
 

purchase-admin/src/main/resources/application-dev.yml

@@ -9,8 +9,8 @@ purchase:
   # 实例演示开关
   demoEnabled: true
   # 文件路径 示例（ Windows配置D:/purchase/uploadPath，Linux配置 /home/purchase/uploadPath）
-  profile: C:/purchase/uploadPath
-#  profile: /Users/sunhuanhuan/Documents/project/106/文档/purchase/uploadPath
+  #  profile: C:/purchase/uploadPath
+  profile: /Users/sunhuanhuan/Documents/project/106/文档/purchase/uploadPath
   # 获取ip地址开关
   addressEnabled: false
   # 验证码类型 math 数组计算 char 字符验证

purchase-admin/src/main/resources/logback.xml

@@ -1,32 +1,32 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <configuration>
     <!-- 日志存放路径 -->
-    <property name="log.path" value="/home/purchase/logs" />
-
+    <!--    <property name="log.path" value="/home/purchase/logs" />-->
+    <property name="log.path" value="/Users/sunhuanhuan/Documents/project/106/文档/purchase/logs"/>
     <!-- 日志输出格式 -->
-	<property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />
+    <property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n"/>
 
-	<!-- 控制台输出 -->
-	<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
-		<encoder>
-			<pattern>${log.pattern}</pattern>
-		</encoder>
-	</appender>
+    <!-- 控制台输出 -->
+    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>${log.pattern}</pattern>
+        </encoder>
+    </appender>
 
-	<!-- 系统日志输出 -->
-	<appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender">
-	    <file>${log.path}/sys-info.log</file>
+    <!-- 系统日志输出 -->
+    <appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${log.path}/sys-info.log</file>
         <!-- 循环政策：基于时间创建日志文件 -->
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
             <!-- 日志文件名格式 -->
-			<fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.log</fileNamePattern>
-			<!-- 日志最大的历史 60天 -->
-			<maxHistory>60</maxHistory>
-		</rollingPolicy>
-		<encoder>
-			<pattern>${log.pattern}</pattern>
-		</encoder>
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
+            <fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.log</fileNamePattern>
+            <!-- 日志最大的历史 60天 -->
+            <maxHistory>60</maxHistory>
+        </rollingPolicy>
+        <encoder>
+            <pattern>${log.pattern}</pattern>
+        </encoder>
+        <filter class="ch.qos.logback.classic.filter.LevelFilter">
             <!-- 过滤的级别 -->
             <level>INFO</level>
             <!-- 匹配时的操作：接收（记录） -->
@@ -34,16 +34,16 @@
             <!-- 不匹配时的操作：拒绝（不记录） -->
             <onMismatch>DENY</onMismatch>
         </filter>
-	</appender>
+    </appender>
 
-	<appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender">
-	    <file>${log.path}/sys-error.log</file>
+    <appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${log.path}/sys-error.log</file>
         <!-- 循环政策：基于时间创建日志文件 -->
         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
             <!-- 日志文件名格式 -->
             <fileNamePattern>${log.path}/sys-error.%d{yyyy-MM-dd}.log</fileNamePattern>
-			<!-- 日志最大的历史 60天 -->
-			<maxHistory>60</maxHistory>
+            <!-- 日志最大的历史 60天 -->
+            <maxHistory>60</maxHistory>
         </rollingPolicy>
         <encoder>
             <pattern>${log.pattern}</pattern>
@@ -51,16 +51,16 @@
         <filter class="ch.qos.logback.classic.filter.LevelFilter">
             <!-- 过滤的级别 -->
             <level>ERROR</level>
-			<!-- 匹配时的操作：接收（记录） -->
+            <!-- 匹配时的操作：接收（记录） -->
             <onMatch>ACCEPT</onMatch>
-			<!-- 不匹配时的操作：拒绝（不记录） -->
+            <!-- 不匹配时的操作：拒绝（不记录） -->
             <onMismatch>DENY</onMismatch>
         </filter>
     </appender>
 
-	<!-- 用户访问日志输出  -->
+    <!-- 用户访问日志输出  -->
     <appender name="sys-user" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<file>${log.path}/sys-user.log</file>
+        <file>${log.path}/sys-user.log</file>
         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
             <!-- 按天回滚 daily -->
             <fileNamePattern>${log.path}/sys-user.%d{yyyy-MM-dd}.log</fileNamePattern>
@@ -72,22 +72,22 @@
         </encoder>
     </appender>
 
-	<!-- 系统模块日志级别控制  -->
-	<logger name="com.ozs" level="info" />
-	<!-- Spring日志级别控制  -->
-	<logger name="org.springframework" level="warn" />
+    <!-- 系统模块日志级别控制  -->
+    <logger name="com.ozs" level="info"/>
+    <!-- Spring日志级别控制  -->
+    <logger name="org.springframework" level="warn"/>
 
-	<root level="info">
-		<appender-ref ref="console" />
-	</root>
+    <root level="info">
+        <appender-ref ref="console"/>
+    </root>
 
-	<!--系统操作日志-->
+    <!--系统操作日志-->
     <root level="info">
-        <appender-ref ref="file_info" />
-        <appender-ref ref="file_error" />
+        <appender-ref ref="file_info"/>
+        <appender-ref ref="file_error"/>
     </root>
 
-	<!--系统用户操作日志-->
+    <!--系统用户操作日志-->
     <logger name="sys-user" level="info">
         <appender-ref ref="sys-user"/>
     </logger>

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

@@ -1,7 +1,7 @@
 package com.ozs.common.enums;
 
 /**
- * 项目类型
+ * 项目属性
  *
  * @author buzhanyi
  */

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

@@ -0,0 +1,90 @@
+package com.ozs.base.domain;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.ozs.base.domain.vo.BaseExpertVo;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.joda.time.DateTime;
+
+@Data
+@TableName("base_supplier")
+public class BaseExpert extends BaseExpertVo {
+
+    /**
+     * 主键ID
+     */
+    @ApiModelProperty(value = "id")
+    @TableField("id")
+    private Integer id;
+
+    /**
+     * 专家名称
+     */
+    @ApiModelProperty(value = "专家名称")
+    @TableField("expert_name")
+    private String expertName;
+
+    /**
+     * 专家性别
+     */
+    @ApiModelProperty(value = "专家性别")
+    @TableField("expert_gender")
+    private String expertGender;
+
+    /**
+     * 出生年月
+     */
+    @ApiModelProperty(value = "出生年月")
+    @TableField("expert_date_birth")
+    private DateTime expertDate_Birth;
+
+    /**
+     * 联系方式
+     */
+    @ApiModelProperty(value = "联系方式")
+    @TableField("expert_tel")
+    private String expertTel;
+
+    /**
+     * 专业类型
+     */
+    @ApiModelProperty(value = "专业类型")
+    @TableField("major_type")
+    private String majorType;
+
+    /**
+     * 单位信息
+     */
+    @ApiModelProperty(value = "单位信息")
+    @TableField("unit_information")
+    private String unitInformation;
+
+    /**
+     * 专业等级
+     */
+    @ApiModelProperty(value = "专业等级")
+    @TableField("major_grade")
+    private String majorGrade;
+
+    /**
+     * 采购品种
+     */
+    @ApiModelProperty(value = "采购品种")
+    @TableField("variety_purchase")
+    private String varietyPurchase;
+
+    /**
+     * 职称
+     */
+    @ApiModelProperty(value = "职称")
+    @TableField("professional_title")
+    private String professionalTitle;
+
+    /**
+     * 状态 黑白名单
+     */
+    @ApiModelProperty(value = "状态 黑白名单")
+    @TableField("status")
+    private String status;
+}

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

@@ -6,7 +6,6 @@ import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 
 import java.io.Serializable;
-import java.util.List;
 
 @Data
 @TableName("base_professional")

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

@@ -0,0 +1,23 @@
+package com.ozs.base.domain.vo;
+
+import com.ozs.common.vo.PageVo;
+import io.swagger.annotations.ApiModel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@ApiModel(value = "BaseAgentPageReqVo", description = "专家库分页查询")
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class BaseExpertVo extends PageVo {
+
+    // 专家姓名
+    private String expertName;
+    // 专业类型
+    private String majorType;
+    // 专业等级
+    private String majorGrade;
+    // 采购品种
+    private String varietyPurchase;
+}

purchase-system/src/main/java/com/ozs/base/mapper/BaseExpertMapper.java

@@ -0,0 +1,9 @@
+package com.ozs.base.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.ozs.base.domain.BaseExpert;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface BaseExpertMapper extends BaseMapper<BaseExpert> {
+}

purchase-system/src/main/java/com/ozs/base/mapper/BaseProfessionalMapper.java

@@ -19,8 +19,17 @@ public interface BaseProfessionalMapper extends BaseMapper<BaseProfessional> {
     List<BaseProfessional> selectoneGradeList(String professionalCode);
 
     List<BaseProfessional> selectBaseProfessional(BaseProfessionalVo baseProfessionalVo);
+    List<BaseProfessional> selectBaseProfessional(BaseProfessional baseProfessional);
 
     int countByParentCode(@Param("professionalCode") String professionalCode);
 
     List<BaseProfessional> selectByParentCode(String professionalCode);
+
+    List<BaseProfessional> selectProfessional(BaseProfessional baseProfessional);
+
+    List<BaseProfessional> selectByProfessionalCode(BaseProfessional baseProfessional);
+
+    List<BaseProfessional> selectByProfessionalName(BaseProfessional baseProfessional);
+
+    List<BaseProfessional> selectByParentCodes(BaseProfessional baseProfessional);
 }

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

@@ -0,0 +1,7 @@
+package com.ozs.base.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.ozs.base.domain.BaseExpert;
+
+public interface BaseExpertService extends IService<BaseExpert> {
+}

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

@@ -8,6 +8,9 @@ import java.util.List;
 
 public interface BaseProfessionalService extends IService<BaseProfessional> {
     List<BaseProfessionalVo> selectBaseProfessional(BaseProfessionalVo baseProfessional);
+    List<BaseProfessional> selectBaseProfessional(BaseProfessional baseProfessional);
 
     void deleteIds(List<Integer> deleteIds);
+
+    String importBaseProfessional(List<BaseProfessional> userList);
 }

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

@@ -0,0 +1,11 @@
+package com.ozs.base.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.ozs.base.domain.BaseExpert;
+import com.ozs.base.mapper.BaseExpertMapper;
+import com.ozs.base.service.BaseExpertService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BaseExpertServiceImpl extends ServiceImpl<BaseExpertMapper, BaseExpert> implements BaseExpertService {
+}

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

@@ -6,12 +6,15 @@ import com.ozs.base.domain.vo.BaseProfessionalVo;
 import com.ozs.base.mapper.BaseProfessionalMapper;
 import com.ozs.base.service.BaseProfessionalService;
 import com.ozs.common.core.domain.entity.SysDictType;
+import com.ozs.common.core.domain.entity.SysUser;
 import com.ozs.common.exception.ServiceException;
 import com.ozs.common.utils.DictUtils;
 import com.ozs.common.utils.bean.BeanUtils;
+import com.ozs.common.utils.bean.BeanValidators;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import javax.validation.Validator;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -20,10 +23,12 @@ public class BaseProfessionalServiceImpl extends ServiceImpl<BaseProfessionalMap
 
     @Autowired
     private BaseProfessionalMapper baseProfessionalMapper;
+    @Autowired
+    protected Validator validator;
 
     @Override
     public void deleteIds(List<Integer> deleteIds) {
-        for (Integer  deleteId : deleteIds) {
+        for (Integer deleteId : deleteIds) {
             BaseProfessional baseProfessional = baseProfessionalMapper.selectById(deleteId);
             List<BaseProfessional> baseProfessionalList = baseProfessionalMapper.selectByParentCode(baseProfessional.getProfessionalCode());
 //            int ii = baseProfessionalMapper.countByParentCode(baseProfessional.getProfessionalCode());
@@ -34,6 +39,44 @@ public class BaseProfessionalServiceImpl extends ServiceImpl<BaseProfessionalMap
         }
     }
 
+    @Override
+    public String importBaseProfessional(List<BaseProfessional> userList) {
+        int successNum = 0;
+        int failureNum = 0;
+        StringBuilder successMsg = new StringBuilder();
+        StringBuilder failureMsg = new StringBuilder();
+        for (BaseProfessional baseProfessional : userList) {
+            try {
+                // 判断编码是否存在
+                List<BaseProfessional> professionalCode = baseProfessionalMapper.selectByProfessionalCode(baseProfessional);
+                List<BaseProfessional> professionalName = baseProfessionalMapper.selectByProfessionalName(baseProfessional);
+                //List<BaseProfessional> parentCode = baseProfessionalMapper.selectByParentCodes(baseProfessional);
+                if (professionalCode.size() > 0 || professionalName.size() > 0) {
+                    failureNum++;
+                    failureMsg.append("<br/>" + failureNum + "、编码或专业名称" + baseProfessional.getProfessionalCode() + "、" + baseProfessional.getProfessionalName() + " 已存在");
+                } else {
+                    // bean对象属性认证
+                    BeanValidators.validateWithException(validator, baseProfessional);
+                    baseProfessionalMapper.insert(baseProfessional);
+                    successNum++;
+                    successMsg.append("<br/>" + successNum + "、专业名称 " + baseProfessional.getProfessionalName() + " 导入成功");
+                }
+            } catch (Exception e) {
+                failureNum++;
+                String msg = "<br/>" + failureNum + "、专业名称 " + baseProfessional.getProfessionalName() + " 导入失败：";
+                failureMsg.append(msg + e.getMessage());
+                log.error(msg, e);
+            }
+        }
+        if (failureNum > 0) {
+            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
+            throw new ServiceException(failureMsg.toString());
+        } else {
+            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
+        }
+        return successMsg.toString();
+    }
+
     @Override
     public List<BaseProfessionalVo> selectBaseProfessional(BaseProfessionalVo baseProfessionalVo) {
         List<BaseProfessional> allList = baseProfessionalMapper.selectBaseProfessional(baseProfessionalVo);
@@ -43,6 +86,12 @@ public class BaseProfessionalServiceImpl extends ServiceImpl<BaseProfessionalMap
         return treeList;
     }
 
+    @Override
+    public List<BaseProfessional> selectBaseProfessional(BaseProfessional baseProfessional) {
+        List<BaseProfessional> allList = baseProfessionalMapper.selectBaseProfessional(baseProfessional);
+        return allList;
+    }
+
     /**
      * 构建树形结构
      *

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

@@ -14,7 +14,7 @@ import java.util.Date;
  * @author buzhanyi
  */
 @Data
-public class PlanOfYears extends BaseEntity {
+public class PlanYears extends BaseEntity {
 
     /**
      * 主键编号
@@ -53,7 +53,6 @@ public class PlanOfYears extends BaseEntity {
     /**
      * 是否为超限额计划(0:未超额，1:超额)
      */
-    @Excel(name = "是否为超限额计划")
     @NotNull(message = "是否为超限额计划不能为空")
     private String isExcess;
     /**
@@ -111,13 +110,15 @@ public class PlanOfYears extends BaseEntity {
      * 项目状态--->包括计划待提交、计划待审核、计划已退回、计划已审核
      * (0:计划待提交，1:计划待审核，2:计划已退回，3:计划已审核)
      */
-    @Excel(name = "项目状态")
     private String projectStatus;
     /**
      * 退回原因--->审核不通过就是退回
      */
-    @Excel(name = "退回原因")
     private String reasonOfReturn;
+    /**
+     * 项目附件
+     */
+    private String projectFiles;
     /**
      * 创建者
      */

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

@@ -13,7 +13,7 @@ import java.util.Date;
  * @author buzhanyi
  */
 @Data
-public class PlanOfYearsStandardVo extends BaseEntity {
+public class PlanYearsStandardVo extends BaseEntity {
 
     /**
      * 主键编号
@@ -107,7 +107,11 @@ public class PlanOfYearsStandardVo extends BaseEntity {
      */
     @ApiModelProperty(value = "备注")
     private String remarks;
-
+    /**
+     * 项目附件
+     */
+    @ApiModelProperty(value = "项目附件")
+    private String projectFiles;
     /**
      * 退回原因--->审核不通过就是退回
      */

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

@@ -5,7 +5,6 @@ import com.fasterxml.jackson.annotation.JsonFormat;
 import com.ozs.common.annotation.Excel;
 import lombok.Data;
 
-import javax.validation.constraints.NotNull;
 import java.math.BigDecimal;
 import java.util.Date;
 
@@ -13,7 +12,7 @@ import java.util.Date;
  * @author buzhanyi
  */
 @Data
-public class PlanOfYearsResponseVo {
+public class PlanYearsResponseVo {
 
     /**
      * 主键编号
@@ -98,5 +97,9 @@ public class PlanOfYearsResponseVo {
      */
     @Excel(name = "项目状态")
     private String projectStatus;
+    /**
+     * 项目附件
+     */
+    private String projectFiles;
 
 }

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

@@ -1,8 +1,7 @@
 package com.ozs.plan.mapper;
 
 
-import com.ozs.base.mapper.BaseSupplierMapper;
-import com.ozs.plan.doman.PlanOfYears;
+import com.ozs.plan.doman.PlanYears;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
@@ -14,22 +13,22 @@ import java.util.List;
  * @author bu
  */
 @Mapper
-public interface PlanOfYearsMapper {
+public interface PlanYearsMapper {
 
     /**
      * 查询年度计划记录集合
      *
-     * @param planOfYears 年度计划请求对象
+     * @param planYears 年度计划请求对象
      * @return 年度计划记录集合
      */
-    public List<PlanOfYears> selectPlanOfYearsList(PlanOfYears planOfYears);
+    public List<PlanYears> selectPlanYearsList(PlanYears planYears);
 
     /**
      * 创建年度计划
      *
-     * @param planOfYears 年度计划请求对象
+     * @param planYears 年度计划请求对象
      */
-    public int insertPlanOfYears(PlanOfYears planOfYears);
+    public int insertPlanYears(PlanYears planYears);
 
     /**
      * 批量删除年度计划
@@ -37,7 +36,7 @@ public interface PlanOfYearsMapper {
      * @param planIds 需要删除的年度计划ID
      * @return 结果
      */
-    public int deletePlanOfYearsByIds(Long[] planIds);
+    public int deletePlanYearsByIds(Long[] planIds);
 
     /**
      * 查询项目名称是否存在
@@ -45,7 +44,7 @@ public interface PlanOfYearsMapper {
      * @param projectName 项目名称
      * @return 结果
      */
-    public List<PlanOfYears> countProjectName(String projectName);
+    public List<PlanYears> countProjectName(String projectName);
 
     /**
      * 查询年度计划
@@ -53,7 +52,7 @@ public interface PlanOfYearsMapper {
      * @param planYearId 年度计划ID
      * @return 结果
      */
-    public PlanOfYears getById(Long planYearId);
+    public PlanYears getById(Long planYearId);
 
     /**
      * 查询项目名称是否存在(除自己以外)
@@ -69,11 +68,11 @@ public interface PlanOfYearsMapper {
      * @param ofYears 年度计划
      * @return 结果
      */
-    public int updateById(PlanOfYears ofYears);
+    public int updateById(PlanYears ofYears);
 
-    public int deletePlanOfYearsById(Long planId);
+    public int deletePlanYearsById(Long planId);
 
     public int commit(Long planYearId);
 
-    public int review(PlanOfYears ofYears);
+    public int review(PlanYears ofYears);
 }

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

@@ -2,9 +2,8 @@ package com.ozs.plan.service;
 
 
 import com.ozs.common.core.domain.AjaxResult;
-import com.ozs.plan.doman.PlanOfYears;
-import com.ozs.plan.doman.vo.requestVo.PlanOfYearsStandardVo;
-import com.ozs.plan.doman.vo.responseVo.PlanOfYearsResponseVo;
+import com.ozs.plan.doman.PlanYears;
+import com.ozs.plan.doman.vo.requestVo.PlanYearsStandardVo;
 
 import java.util.List;
 
@@ -13,7 +12,7 @@ import java.util.List;
  *
  * @author bu
  */
-public interface PlanOfYearsService {
+public interface PlanYearsService {
 
     /**
      * 查询年度计划记录集合
@@ -21,14 +20,14 @@ public interface PlanOfYearsService {
      * @param vo 年度计划请求对象
      * @return 年度计划记录集合
      */
-    public List<PlanOfYears> selectPlanOfYearsList(PlanOfYearsStandardVo vo);
+    public List<PlanYears> selectPlanOfYearsList(PlanYearsStandardVo vo);
 
     /**
      * 创建年度计划
      *
      * @param yearsStandardVo 年度计划请求对象
      */
-    public AjaxResult insertPlanOfYears(PlanOfYearsStandardVo yearsStandardVo);
+    public AjaxResult insertPlanOfYears(PlanYearsStandardVo yearsStandardVo);
 
     /**
      * 批量删除年度计划
@@ -52,7 +51,7 @@ public interface PlanOfYearsService {
      * @param yearsStandardVo 年度计划请求对象
      * @return 结果
      */
-    public AjaxResult view(PlanOfYearsStandardVo yearsStandardVo);
+    public AjaxResult view(PlanYearsStandardVo yearsStandardVo);
 
     /**
      * 修改年度计划
@@ -60,14 +59,14 @@ public interface PlanOfYearsService {
      * @param yearsStandardVo 修改年度计划请求对象
      * @return 结果
      */
-    public AjaxResult update(PlanOfYearsStandardVo yearsStandardVo);
+    public AjaxResult update(PlanYearsStandardVo yearsStandardVo);
 
     /**
      * 导入年度计划数据
      *
      * @return 结果
      */
-    public String importPlanOfYears(List<PlanOfYears> planOfYears, boolean isUpdateSupport, String operName);
+    public String importPlanOfYears(List<PlanYears> planYears, boolean isUpdateSupport, String operName);
 
     /**
      * 提交年度计划
@@ -75,7 +74,7 @@ public interface PlanOfYearsService {
      * @param yearsStandardVo 提交年度计划请求对象
      * @return 结果
      */
-    public AjaxResult commit(PlanOfYearsStandardVo yearsStandardVo);
+    public AjaxResult commit(PlanYearsStandardVo yearsStandardVo);
 
     /**
      * 审核年度计划
@@ -83,7 +82,7 @@ public interface PlanOfYearsService {
      * @param yearsStandardVo 需要审核的年度计划
      * @return 结果
      */
-    public AjaxResult reviewTo(PlanOfYearsStandardVo yearsStandardVo);
+    public AjaxResult reviewTo(PlanYearsStandardVo yearsStandardVo);
 
     /**
      * 审核年度计划退回
@@ -91,5 +90,5 @@ public interface PlanOfYearsService {
      * @param yearsStandardVo 需要审核的年度计划
      * @return 结果
      */
-    public AjaxResult reviewReturn(PlanOfYearsStandardVo yearsStandardVo);
+    public AjaxResult reviewReturn(PlanYearsStandardVo yearsStandardVo);
 }

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

@@ -1,187 +0,0 @@
-package com.ozs.plan.service.impl;
-
-import com.ozs.common.core.domain.AjaxResult;
-import com.ozs.common.enums.ProjectStatus;
-import com.ozs.common.exception.ServiceException;
-import com.ozs.common.utils.StringUtils;
-import com.ozs.common.utils.bean.BeanUtils;
-import com.ozs.common.utils.bean.BeanValidators;
-import com.ozs.plan.doman.PlanOfYears;
-import com.ozs.plan.doman.vo.requestVo.PlanOfYearsStandardVo;
-import com.ozs.plan.doman.vo.responseVo.PlanOfYearsResponseVo;
-import com.ozs.plan.mapper.PlanOfYearsMapper;
-import com.ozs.plan.service.PlanOfYearsService;
-import com.ozs.system.service.impl.SysUserServiceImpl;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import javax.validation.Validator;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-
-/**
- * @author buzhanyi
- */
-@Service
-public class PlanOfYearsServiceImpl implements PlanOfYearsService {
-    private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
-
-    @Autowired
-    PlanOfYearsMapper planOfYearsMapper;
-    @Autowired
-    protected Validator validator;
-
-    @Override
-    public List<PlanOfYears> selectPlanOfYearsList(PlanOfYearsStandardVo vo) {
-        PlanOfYears ofYears = new PlanOfYears();
-        List<PlanOfYears> planOfYears = new ArrayList<>();
-        try {
-            BeanUtils.copyProperties(vo, ofYears);
-            planOfYears = planOfYearsMapper.selectPlanOfYearsList(ofYears);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return planOfYears;
-    }
-
-    @Override
-    public AjaxResult insertPlanOfYears(PlanOfYearsStandardVo yearsStandardVo) {
-        if (planOfYearsMapper.countProjectName(yearsStandardVo.getProjectName()).size() > 0) {
-            return AjaxResult.error("该项目名称已经存在");
-        }
-        PlanOfYears ofYears = new PlanOfYears();
-        try {
-            BeanUtils.copyProperties(yearsStandardVo, ofYears);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        //判断是否为超额计划---
-
-        ofYears.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
-        ofYears.setCreateTime(new Date());
-        planOfYearsMapper.insertPlanOfYears(ofYears);
-        return AjaxResult.success();
-    }
-
-    @Override
-    public AjaxResult deletePlanOfYearsByIds(Long[] planIds) {
-        planOfYearsMapper.deletePlanOfYearsByIds(planIds);
-        return AjaxResult.success();
-    }
-
-    @Override
-    public AjaxResult deletePlanOfYearsById(Long planId) {
-        planOfYearsMapper.deletePlanOfYearsById(planId);
-        return AjaxResult.success();
-    }
-
-    @Override
-    public AjaxResult view(PlanOfYearsStandardVo yearsStandardVo) {
-        PlanOfYearsResponseVo planOfYearsResponseVo = new PlanOfYearsResponseVo();
-        PlanOfYears byId = planOfYearsMapper.getById(yearsStandardVo.getPlanYearId());
-        if (byId == null) {
-            return AjaxResult.error("数据查询失败");
-        }
-        BeanUtils.copyProperties(byId, planOfYearsResponseVo);
-        return AjaxResult.success(planOfYearsResponseVo);
-    }
-
-    @Override
-    public AjaxResult update(PlanOfYearsStandardVo yearsStandardVo) {
-        if (planOfYearsMapper.countProjectNameOther(yearsStandardVo.getProjectName(), String.valueOf(yearsStandardVo.getPlanYearId())) > 0) {
-            return AjaxResult.error("该项目名称已经存在");
-        }
-        PlanOfYears ofYears = new PlanOfYears();
-        try {
-            BeanUtils.copyProperties(yearsStandardVo, ofYears);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        planOfYearsMapper.updateById(ofYears);
-        return AjaxResult.success();
-    }
-
-    @Override
-    public String importPlanOfYears(List<PlanOfYears> planOfYears, boolean isUpdateSupport, String operName) {
-        if (StringUtils.isNull(planOfYears) || planOfYears.size() == 0) {
-            throw new ServiceException("导入年度计划数据不能为空！");
-        }
-        int successNum = 0;
-        int failureNum = 0;
-        StringBuilder successMsg = new StringBuilder();
-        StringBuilder failureMsg = new StringBuilder();
-        for (PlanOfYears ofYear : planOfYears) {
-            try {
-                //验证项目名称是否重复导入
-                List<PlanOfYears> plan = planOfYearsMapper.countProjectName(ofYear.getProjectName());
-                if (plan.size() == 0) {
-                    planOfYearsMapper.insertPlanOfYears(ofYear);
-                    successNum++;
-                    successMsg.append("<br/>" + successNum + "、项目 " + ofYear.getProjectName() + " 导入成功");
-                } else if (isUpdateSupport) {
-                    PlanOfYears years = plan.get(0);
-                    BeanValidators.validateWithException(validator, ofYear);
-                    years.setCreateBy(operName);
-                    years.setCreateTime(new Date());
-                    years.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
-                    planOfYearsMapper.updateById(years);
-                    successNum++;
-                    successMsg.append("<br/>" + successNum + "、项目 " + ofYear.getProjectName() + " 更新成功");
-                } else {
-                    failureNum++;
-                    successMsg.append("<br/>" + successNum + "、项目 " + ofYear.getProjectName() + " 已存在");
-                }
-            } catch (Exception exc) {
-                failureNum++;
-                String msg = "<br/>" + 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(PlanOfYearsStandardVo yearsStandardVo) {
-
-        int commit = planOfYearsMapper.commit(yearsStandardVo.getPlanYearId());
-        if (commit != 1) {
-            return AjaxResult.error("项目状态数据异常");
-        }
-        return AjaxResult.success();
-    }
-
-    @Override
-    public AjaxResult reviewTo(PlanOfYearsStandardVo vo) {
-        PlanOfYears ofYears = new PlanOfYears();
-        ofYears.setPlanYearId(vo.getPlanYearId());
-        ofYears.setProjectStatus(ProjectStatus.PLANTOEXAMINE.getCode());
-        int review = planOfYearsMapper.review(ofYears);
-        if (review != 1) {
-            return AjaxResult.error("项目状态数据异常");
-        }
-        return AjaxResult.success();
-    }
-
-    @Override
-    public AjaxResult reviewReturn(PlanOfYearsStandardVo vo) {
-        PlanOfYears ofYears = new PlanOfYears();
-        BeanUtils.copyProperties(vo, ofYears);
-        ofYears.setProjectStatus(ProjectStatus.PLANTOBACK.getCode());
-        int review = planOfYearsMapper.review(ofYears);
-        if (review != 1) {
-            return AjaxResult.error("项目状态数据异常");
-        }
-        return AjaxResult.success();
-    }
-
-}

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

@@ -0,0 +1,272 @@
+package com.ozs.plan.service.impl;
+
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.common.core.domain.entity.SysDictData;
+import com.ozs.common.enums.ProjectStatus;
+import com.ozs.common.enums.ProjectTypes;
+import com.ozs.common.exception.ServiceException;
+import com.ozs.common.utils.StringUtils;
+import com.ozs.common.utils.bean.BeanUtils;
+import com.ozs.common.utils.bean.BeanValidators;
+import com.ozs.plan.doman.PlanYears;
+import com.ozs.plan.doman.vo.requestVo.PlanYearsStandardVo;
+import com.ozs.plan.doman.vo.responseVo.PlanYearsResponseVo;
+import com.ozs.plan.mapper.PlanYearsMapper;
+import com.ozs.plan.service.PlanYearsService;
+import com.ozs.system.service.ISysDictTypeService;
+import com.ozs.system.service.impl.SysUserServiceImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+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;
+
+/**
+ * @author buzhanyi
+ */
+@Service
+public class PlanYearsServiceImpl implements PlanYearsService {
+    private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
+
+    @Autowired
+    PlanYearsMapper planYearsMapper;
+    @Autowired
+    protected Validator validator;
+    @Autowired
+    private ISysDictTypeService dictTypeService;
+
+    @Override
+    public List<PlanYears> selectPlanOfYearsList(PlanYearsStandardVo vo) {
+        PlanYears ofYears = new PlanYears();
+        List<PlanYears> planYears = new ArrayList<>();
+        try {
+            BeanUtils.copyProperties(vo, ofYears);
+            planYears = planYearsMapper.selectPlanOfYearsList(ofYears);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return planYears;
+    }
+
+    @Override
+    public AjaxResult insertPlanOfYears(PlanYearsStandardVo yearsStandardVo) {
+        if (planYearsMapper.countProjectName(yearsStandardVo.getProjectName()).size() > 0) {
+            return AjaxResult.error("该项目名称已经存在");
+        }
+        PlanYears ofYears = new PlanYears();
+        try {
+            BeanUtils.copyProperties(yearsStandardVo, ofYears);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        //判断是否为超额计划
+        BigDecimal evaluation = yearsStandardVo.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 (yearsStandardVo.getProjectType().equals(value.getCode())) {
+                threshold = BigDecimal.valueOf(Long.parseLong(thresholdMap.get(value.getInfo())));
+            }
+            break;
+        }
+        if (evaluation.compareTo(threshold) == 1) {
+            //是超额项目
+            ofYears.setIsExcess("1");
+        } else {
+            ofYears.setIsExcess("0");
+        }
+        ofYears.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
+        ofYears.setCreateTime(new Date());
+        planYearsMapper.insertPlanOfYears(ofYears);
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult deletePlanOfYearsByIds(Long[] planIds) {
+        planYearsMapper.deletePlanOfYearsByIds(planIds);
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult deletePlanOfYearsById(Long planId) {
+        planYearsMapper.deletePlanOfYearsById(planId);
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult view(PlanYearsStandardVo yearsStandardVo) {
+        PlanYearsResponseVo planYearsResponseVo = new PlanYearsResponseVo();
+        PlanYears byId = planYearsMapper.getById(yearsStandardVo.getPlanYearId());
+        if (byId == null) {
+            return AjaxResult.error("数据查询失败");
+        }
+        BeanUtils.copyProperties(byId, planYearsResponseVo);
+        return AjaxResult.success(planYearsResponseVo);
+    }
+
+    @Override
+    public AjaxResult update(PlanYearsStandardVo yearsStandardVo) {
+        if (planYearsMapper.countProjectNameOther(yearsStandardVo.getProjectName(), String.valueOf(yearsStandardVo.getPlanYearId())) > 0) {
+            return AjaxResult.error("该项目名称已经存在");
+        }
+        PlanYears ofYears = new PlanYears();
+        try {
+            BeanUtils.copyProperties(yearsStandardVo, ofYears);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        BigDecimal evaluation = ofYears.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 (ofYears.getProjectType().equals(value.getCode())) {
+                threshold = BigDecimal.valueOf(Long.parseLong(thresholdMap.get(value.getInfo())));
+            }
+            break;
+        }
+
+        if (evaluation.compareTo(threshold) == 1) {
+            //是超额项目
+            ofYears.setIsExcess("1");
+        } else {
+            ofYears.setIsExcess("0");
+        }
+
+        planYearsMapper.updateById(ofYears);
+        return AjaxResult.success();
+    }
+
+    @Override
+    public String importPlanOfYears(List<PlanYears> planYears, boolean isUpdateSupport, String operName) {
+        if (StringUtils.isNull(planYears) || planYears.size() == 0) {
+            throw new ServiceException("导入年度计划数据不能为空！");
+        }
+        HashMap<String, HashMap<String, String>> planEnums = dictTypeService.getAboutEnums();
+        HashMap<String, String> projectTypesMap = planEnums.get("ProjectTypes");
+        HashMap<String, String> projectStatusMap = planEnums.get("ProjectStatus");
+        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();
+        for (PlanYears ofYear : planYears) {
+            try {
+                //验证项目名称是否重复导入
+                List<PlanYears> plan = planYearsMapper.countProjectName(ofYear.getProjectName());
+                if (plan.size() == 0) {
+                    //将录入信息中的值更改为要保存的数据
+
+                    planYearsMapper.insertPlanOfYears(ofYear);
+                    successNum++;
+                    successMsg.append("<br/>" + successNum + "、项目 " + ofYear.getProjectName() + " 导入成功");
+                } else if (isUpdateSupport) {
+                    PlanYears years = plan.get(0);
+                    BeanValidators.validateWithException(validator, ofYear);
+                    years.setCreateBy(operName);
+                    years.setCreateTime(new Date());
+                    years.setProjectStatus(ProjectStatus.PLANWAITCOMMIT.getCode());
+                    planYearsMapper.updateById(years);
+                    successNum++;
+                    successMsg.append("<br/>" + successNum + "、项目 " + ofYear.getProjectName() + " 更新成功");
+                } else {
+                    failureNum++;
+                    successMsg.append("<br/>" + successNum + "、项目 " + ofYear.getProjectName() + " 已存在");
+                }
+            } catch (Exception exc) {
+                failureNum++;
+                String msg = "<br/>" + 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(PlanYearsStandardVo yearsStandardVo) {
+        //PlanOfYears byId = planOfYearsMapper.getById(yearsStandardVo.getPlanYearId());
+        //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 = planYearsMapper.commit(yearsStandardVo.getPlanYearId());
+        if (commit != 1) {
+            return AjaxResult.error("项目状态数据异常");
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult reviewTo(PlanYearsStandardVo vo) {
+        PlanYears ofYears = new PlanYears();
+        ofYears.setPlanYearId(vo.getPlanYearId());
+        ofYears.setProjectStatus(ProjectStatus.PLANTOEXAMINE.getCode());
+        int review = planYearsMapper.review(ofYears);
+        if (review != 1) {
+            return AjaxResult.error("项目状态数据异常");
+        }
+        return AjaxResult.success();
+    }
+
+    @Override
+    public AjaxResult reviewReturn(PlanYearsStandardVo vo) {
+        PlanYears ofYears = new PlanYears();
+        BeanUtils.copyProperties(vo, ofYears);
+        ofYears.setProjectStatus(ProjectStatus.PLANTOBACK.getCode());
+        int review = planYearsMapper.review(ofYears);
+        if (review != 1) {
+            return AjaxResult.error("项目状态数据异常");
+        }
+        return AjaxResult.success();
+    }
+
+}

purchase-system/src/main/java/com/ozs/system/service/ISysDictTypeService.java

@@ -1,6 +1,9 @@
 package com.ozs.system.service;
 
+import java.util.HashMap;
 import java.util.List;
+
+import com.ozs.common.core.domain.AjaxResult;
 import com.ozs.common.core.domain.entity.SysDictData;
 import com.ozs.common.core.domain.entity.SysDictType;
 
@@ -9,8 +12,7 @@ import com.ozs.common.core.domain.entity.SysDictType;
  *
  * @author ruoyi
  */
-public interface ISysDictTypeService
-{
+public interface ISysDictTypeService {
     /**
      * 根据条件分页查询字典类型
      *
@@ -95,4 +97,11 @@ public interface ISysDictTypeService
      * @return 结果
      */
     public String checkDictTypeUnique(SysDictType dictType);
+
+    /**
+     * 获取年度计划信息中的枚举类信息(下拉框数据)
+     *
+     * @return 年度计划信息中的枚举类信息(下拉框数据)
+     */
+    public HashMap<String, HashMap<String, String>> getAboutEnums();
 }

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

@@ -1,11 +1,18 @@
 package com.ozs.system.service.impl;
 
 import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import javax.annotation.PostConstruct;
 
+import com.ozs.common.core.domain.AjaxResult;
+import com.ozs.common.enums.PlanPurchaseMode;
+import com.ozs.common.enums.ProjectAttribute;
+import com.ozs.common.enums.ProjectStatus;
+import com.ozs.common.enums.ProjectTypes;
 import com.ozs.system.service.ISysDictTypeService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -25,8 +32,7 @@ import com.ozs.system.mapper.SysDictTypeMapper;
  * @author ruoyi
  */
 @Service
-public class SysDictTypeServiceImpl implements ISysDictTypeService
-{
+public class SysDictTypeServiceImpl implements ISysDictTypeService {
     @Autowired
     private SysDictTypeMapper dictTypeMapper;
 
@@ -37,8 +43,7 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * 项目启动时，初始化字典到缓存
      */
     @PostConstruct
-    public void init()
-    {
+    public void init() {
         loadingDictCache();
     }
 
@@ -49,8 +54,7 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * @return 字典类型集合信息
      */
     @Override
-    public List<SysDictType> selectDictTypeList(SysDictType dictType)
-    {
+    public List<SysDictType> selectDictTypeList(SysDictType dictType) {
         return dictTypeMapper.selectDictTypeList(dictType);
     }
 
@@ -60,8 +64,7 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * @return 字典类型集合信息
      */
     @Override
-    public List<SysDictType> selectDictTypeAll()
-    {
+    public List<SysDictType> selectDictTypeAll() {
         return dictTypeMapper.selectDictTypeAll();
     }
 
@@ -72,16 +75,13 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * @return 字典数据集合信息
      */
     @Override
-    public List<SysDictData> selectDictDataByType(String dictType)
-    {
+    public List<SysDictData> selectDictDataByType(String dictType) {
         List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
-        if (StringUtils.isNotEmpty(dictDatas))
-        {
+        if (StringUtils.isNotEmpty(dictDatas)) {
             return dictDatas;
         }
         dictDatas = dictDataMapper.selectDictDataByType(dictType);
-        if (StringUtils.isNotEmpty(dictDatas))
-        {
+        if (StringUtils.isNotEmpty(dictDatas)) {
             DictUtils.setDictCache(dictType, dictDatas);
             return dictDatas;
         }
@@ -95,8 +95,7 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * @return 字典类型
      */
     @Override
-    public SysDictType selectDictTypeById(Long dictId)
-    {
+    public SysDictType selectDictTypeById(Long dictId) {
         return dictTypeMapper.selectDictTypeById(dictId);
     }
 
@@ -107,8 +106,7 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * @return 字典类型
      */
     @Override
-    public SysDictType selectDictTypeByType(String dictType)
-    {
+    public SysDictType selectDictTypeByType(String dictType) {
         return dictTypeMapper.selectDictTypeByType(dictType);
     }
 
@@ -118,13 +116,10 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * @param dictIds 需要删除的字典ID
      */
     @Override
-    public void deleteDictTypeByIds(Long[] dictIds)
-    {
-        for (Long dictId : dictIds)
-        {
+    public void deleteDictTypeByIds(Long[] dictIds) {
+        for (Long dictId : dictIds) {
             SysDictType dictType = selectDictTypeById(dictId);
-            if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0)
-            {
+            if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0) {
                 throw new ServiceException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
             }
             dictTypeMapper.deleteDictTypeById(dictId);
@@ -136,13 +131,11 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * 加载字典缓存数据
      */
     @Override
-    public void loadingDictCache()
-    {
+    public void loadingDictCache() {
         SysDictData dictData = new SysDictData();
         dictData.setStatus("0");
         Map<String, List<SysDictData>> dictDataMap = dictDataMapper.selectDictDataList(dictData).stream().collect(Collectors.groupingBy(SysDictData::getDictType));
-        for (Map.Entry<String, List<SysDictData>> entry : dictDataMap.entrySet())
-        {
+        for (Map.Entry<String, List<SysDictData>> entry : dictDataMap.entrySet()) {
             DictUtils.setDictCache(entry.getKey(), entry.getValue().stream().sorted(Comparator.comparing(SysDictData::getDictSort)).collect(Collectors.toList()));
         }
     }
@@ -151,8 +144,7 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * 清空字典缓存数据
      */
     @Override
-    public void clearDictCache()
-    {
+    public void clearDictCache() {
         DictUtils.clearDictCache();
     }
 
@@ -160,8 +152,7 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * 重置字典缓存数据
      */
     @Override
-    public void resetDictCache()
-    {
+    public void resetDictCache() {
         clearDictCache();
         loadingDictCache();
     }
@@ -173,11 +164,9 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * @return 结果
      */
     @Override
-    public int insertDictType(SysDictType dict)
-    {
+    public int insertDictType(SysDictType dict) {
         int row = dictTypeMapper.insertDictType(dict);
-        if (row > 0)
-        {
+        if (row > 0) {
             DictUtils.setDictCache(dict.getDictType(), null);
         }
         return row;
@@ -191,13 +180,11 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      */
     @Override
     @Transactional
-    public int updateDictType(SysDictType dict)
-    {
+    public int updateDictType(SysDictType dict) {
         SysDictType oldDict = dictTypeMapper.selectDictTypeById(dict.getDictId());
         dictDataMapper.updateDictDataType(oldDict.getDictType(), dict.getDictType());
         int row = dictTypeMapper.updateDictType(dict);
-        if (row > 0)
-        {
+        if (row > 0) {
             List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
             DictUtils.setDictCache(dict.getDictType(), dictDatas);
         }
@@ -211,14 +198,50 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService
      * @return 结果
      */
     @Override
-    public String checkDictTypeUnique(SysDictType dict)
-    {
+    public String checkDictTypeUnique(SysDictType dict) {
         Long dictId = StringUtils.isNull(dict.getDictId()) ? -1L : dict.getDictId();
         SysDictType dictType = dictTypeMapper.checkDictTypeUnique(dict.getDictType());
-        if (StringUtils.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue())
-        {
+        if (StringUtils.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) {
             return UserConstants.NOT_UNIQUE;
         }
         return UserConstants.UNIQUE;
     }
+
+    @Override
+    public HashMap<String, HashMap<String, String>> getAboutEnums() {
+        HashMap<String, HashMap<String, String>> hashMap = new HashMap<>();
+        HashMap<String, String> projectTypesMap = new LinkedHashMap<>();
+        HashMap<String, String> projectStatusMap = new LinkedHashMap<>();
+        HashMap<String, String> planPurchaseModesMap = new LinkedHashMap<>();
+        HashMap<String, String> projectAttributes = new LinkedHashMap<>();
+        HashMap<String, String> purchaseServices = new LinkedHashMap<>();
+        //项目类型
+        for (ProjectTypes value : ProjectTypes.values()) {
+            projectTypesMap.put(value.getInfo(), value.getCode());
+        }
+        //项目审核状态
+        for (ProjectStatus value : ProjectStatus.values()) {
+            projectStatusMap.put(value.getInfo(), value.getCode());
+        }
+        //采购方式
+        for (PlanPurchaseMode value : PlanPurchaseMode.values()) {
+            planPurchaseModesMap.put(value.getInfo(), value.getCode());
+        }
+        //项目属性
+        for (ProjectAttribute value : ProjectAttribute.values()) {
+            projectAttributes.put(value.getInfo(), value.getCode());
+        }
+        List<SysDictData> data = dictDataMapper.selectDictDataByType("purchase_services");
+        //采购服务站
+        for (SysDictData dictData : data) {
+            purchaseServices.put(dictData.getDictLabel(), dictData.getDictValue());
+        }
+
+        hashMap.put("projectTypes", projectTypesMap);
+        hashMap.put("projectStatus", projectStatusMap);
+        hashMap.put("planPurchaseModes", planPurchaseModesMap);
+        hashMap.put("projectAttributes", projectAttributes);
+        hashMap.put("purchaseServices", purchaseServices);
+        return hashMap;
+    }
 }

purchase-system/src/main/resources/mapper/base/BaseProfessionalMapper.xml

@@ -28,6 +28,21 @@
         </where>
     </select>
 
+    <select id="selectBaseProfessional" parameterType="com.ozs.base.domain.BaseProfessional" resultMap="BaseProfessionalResult">
+        select * from base_professional
+        <where>
+            <if test="professionalName != null and professionalName != ''">
+                professional_name like '% +' #{professionalName} '+ %',
+            </if>
+            <if test="professionalCode != null and professionalCode != ''">
+                professional_code = #{professionalCode},
+            </if>
+            <if test="professionalGrade != null and professionalGrade != ''">
+                professional_grade = #{professionalGrade}
+            </if>
+        </where>
+    </select>
+
     <select id="selectoneGradeList" parameterType="com.ozs.base.domain.BaseProfessional" resultMap="BaseProfessionalResult">
         select * from base_professional where professional_code = #{professionalCode}
     </select>
@@ -40,4 +55,42 @@
         select * from base_professional where parent_code = #{professionalCode}
     </select>
 
+    <select id="selectProfessional" parameterType="com.ozs.base.domain.BaseProfessional" resultMap="BaseProfessionalResult">
+        select * from base_professional
+        <where>
+            <if test="professionalName != null and professionalName != ''">
+                professional_name = #{professionalName},
+            </if>
+            <if test="professionalCode != null and professionalCode != ''">
+                parent_code = #{professionalCode},
+            </if>
+        </where>
+    </select>
+
+    <select id="selectByProfessionalCode" parameterType="com.ozs.base.domain.BaseProfessional" resultMap="BaseProfessionalResult">
+        select * from base_professional
+        <where>
+            <if test="professionalCode != null and professionalCode != ''">
+                professional_code = #{professionalCode}
+            </if>
+        </where>
+    </select>
+
+    <select id="selectByProfessionalName" parameterType="com.ozs.base.domain.BaseProfessional" resultMap="BaseProfessionalResult">
+        select * from base_professional
+        <where>
+            <if test="professionalName != null and professionalName != ''">
+                professional_name = #{professionalName}
+            </if>
+        </where>
+    </select>
+
+    <select id="selectByParentCodes" parameterType="com.ozs.base.domain.BaseProfessional" resultMap="BaseProfessionalResult">
+        select * from base_professional
+        <where>
+            <if test="parentCode != null and parentCode != ''">
+                parent_code = #{parentCode}
+            </if>
+        </where>
+    </select>
 </mapper>

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

@@ -2,9 +2,9 @@
 <!DOCTYPE mapper
 		PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 		"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.ozs.plan.mapper.PlanOfYearsMapper">
+<mapper namespace="com.ozs.plan.mapper.PlanYearsMapper">
 
-	<resultMap type="com.ozs.plan.doman.PlanOfYears" id="PlanOfYearsResult">
+	<resultMap type="com.ozs.plan.doman.PlanYears" id="PlanYearsResult">
 		<id property="plan_year_id" column="planYearId"/>
 		<result property="purchase_unit" column="purchaseUnit"/>
 		<result property="project_name" column="projectName"/>
@@ -27,8 +27,8 @@
 		<result property="is_delete" column="isDelete"/>
 	</resultMap>
 
-	<update id="updateById" parameterType="com.ozs.plan.doman.PlanOfYears">
-		update plan_of_years
+	<update id="updateById" parameterType="com.ozs.plan.doman.PlanYears">
+		update plan_years
 		set purchase_unit=#{purchaseUnit},
 			project_name=#{projectName},
 			project_type=#{projectType},
@@ -47,8 +47,8 @@
 		where plan_year_id = #{planYearId}
 	</update>
 
-	<select id="selectPlanOfYearsList" parameterType="com.ozs.plan.doman.PlanOfYears" resultMap="PlanOfYearsResult">
-		select * from plan_of_years
+	<select id="selectPlanYearsList" parameterType="com.ozs.plan.doman.PlanYears" resultMap="PlanYearsResult">
+		select * from plan_years
 		<where>
 			<if test="projectName != null and projectName != ''">
 				AND project_name like concat('%', #{projectName}, '%')
@@ -73,63 +73,63 @@
 		order by create_time desc
 	</select>
 
-	<select id="countProjectName" resultType="com.ozs.plan.doman.PlanOfYears" parameterType="java.lang.String">
+	<select id="countProjectName" resultType="com.ozs.plan.doman.PlanYears" parameterType="java.lang.String">
 		select *
-		from plan_of_years
+		from plan_years
 		where project_name = #{projectName}
 		  and is_delete = 0
 	</select>
 
-	<select id="getById" resultType="com.ozs.plan.doman.PlanOfYears" parameterType="java.lang.Long">
+	<select id="getById" resultType="com.ozs.plan.doman.PlanYears" parameterType="java.lang.Long">
 		select *
-		from plan_of_years
+		from plan_years
 		where plan_year_id = #{planYearId}
 		  and is_delete = 0
 	</select>
 
 	<select id="countProjectNameOther" resultType="java.lang.Integer" parameterType="java.lang.String">
-		select count(plan_of_years.plan_year_id)
-		from plan_of_years
+		select count(plan_years.plan_year_id)
+		from plan_years
 		where project_name = #{projectName}
 		  and plan_year_id != #{planYearId}
 		  and is_delete = 0
 	</select>
 
 	<!--	创建计划信息-->
-	<insert id="insertPlanOfYears" parameterType="com.ozs.plan.doman.PlanOfYears">
-		insert into plan_of_years (purchase_unit, project_name, project_type, demand_overview, evaluation, is_excess,
-								   purchase_services, purchase_mode, demand_commit_time, purchase_finish_time,
-								   deliver_time, project_attribute, readjust_of_plan, remarks, project_status,
-								   create_by, create_time, is_delete)
+	<insert id="insertPlanYears" parameterType="com.ozs.plan.doman.PlanYears">
+		insert into plan_years (purchase_unit, project_name, project_type, demand_overview, evaluation, is_excess,
+								purchase_services, purchase_mode, demand_commit_time, purchase_finish_time,
+								deliver_time, project_attribute, readjust_of_plan, remarks, project_status,
+								create_by, create_time, is_delete)
 		values (#{purchaseUnit}, #{projectName}, #{projectType}, #{demandOverview}, #{evaluation}, #{isExcess},
 				#{purchaseServices}, #{purchaseMode}, #{demandCommitTime}, #{purchaseFinishTime}, #{deliverTime},
 				#{projectAttribute}, #{readjustOfPlan}, #{remarks}, #{projectStatus}, #{createBy}, #{createTime}, 0)
 	</insert>
 
 	<!--	计划删除-->
-	<update id="deletePlanOfYearsByIds" parameterType="java.lang.Long">
-		update plan_of_years set is_delete=1 where plan_year_id in
+	<update id="deletePlanYearsByIds" parameterType="java.lang.Long">
+		update plan_years set is_delete=1 where plan_year_id in
 		<foreach collection="array" item="item" open="(" separator="," close=")">
 			#{item}
 		</foreach>
 	</update>
 
-	<update id="deletePlanOfYearsById" parameterType="java.lang.Long">
-		update plan_of_years
+	<update id="deletePlanYearsById" parameterType="java.lang.Long">
+		update plan_years
 		set is_delete=1
 		where plan_year_id = #{plan_year_id}
 	</update>
 
 	<!--	计划提交-->
 	<update id="commit" parameterType="java.lang.Long">
-		update plan_of_years
+		update plan_years
 		set project_status=1
 		where plan_year_id = #{plan_year_id}
 	</update>
 
 	<!--	计划审核-->
-	<update id="review" parameterType="com.ozs.plan.doman.PlanOfYears">
-		update plan_of_years
+	<update id="review" parameterType="com.ozs.plan.doman.PlanYears">
+		update plan_years
 		set reason_of_return=#{reasonOfReturn},
 			project_status=#{projectStatus}
 		where plan_year_id = #{planYearId}