This commit is contained in:
jhd
2026-07-08 11:05:10 +08:00
122 changed files with 10782 additions and 212 deletions

View File

@@ -146,6 +146,12 @@
<artifactId>klp-pltcm</artifactId>
</dependency>
<!-- 性能管理模块-->
<dependency>
<groupId>com.klp</groupId>
<artifactId>klp-perf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>

28
klp-perf/pom.xml Normal file
View File

@@ -0,0 +1,28 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>klp-oa</artifactId>
<groupId>com.klp</groupId>
<version>0.8.3</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>klp-perf</artifactId>
<description>
性能管理模块
</description>
<dependencies>
<!-- 通用工具-->
<dependency>
<groupId>com.klp</groupId>
<artifactId>klp-common</artifactId>
</dependency>
</dependencies>
</project>

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfAppraisalVo;
import com.klp.perf.domain.bo.PerfAppraisalBo;
import com.klp.perf.service.IPerfAppraisalService;
import com.klp.common.core.page.TableDataInfo;
/**
* 月度绩效考核记录
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/appraisal")
public class PerfAppraisalController extends BaseController {
private final IPerfAppraisalService iPerfAppraisalService;
/**
* 查询月度绩效考核记录列表
*/
@GetMapping("/list")
public TableDataInfo<PerfAppraisalVo> list(PerfAppraisalBo bo, PageQuery pageQuery) {
return iPerfAppraisalService.queryPageList(bo, pageQuery);
}
/**
* 导出月度绩效考核记录列表
*/
@Log(title = "月度绩效考核记录", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfAppraisalBo bo, HttpServletResponse response) {
List<PerfAppraisalVo> list = iPerfAppraisalService.queryList(bo);
ExcelUtil.exportExcel(list, "月度绩效考核记录", PerfAppraisalVo.class, response);
}
/**
* 获取月度绩效考核记录详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfAppraisalVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfAppraisalService.queryById(id));
}
/**
* 新增月度绩效考核记录
*/
@Log(title = "月度绩效考核记录", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfAppraisalBo bo) {
return toAjax(iPerfAppraisalService.insertByBo(bo));
}
/**
* 修改月度绩效考核记录
*/
@Log(title = "月度绩效考核记录", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfAppraisalBo bo) {
return toAjax(iPerfAppraisalService.updateByBo(bo));
}
/**
* 删除月度绩效考核记录
*
* @param ids 主键串
*/
@Log(title = "月度绩效考核记录", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfAppraisalService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfAppraisalDetailVo;
import com.klp.perf.domain.bo.PerfAppraisalDetailBo;
import com.klp.perf.service.IPerfAppraisalDetailService;
import com.klp.common.core.page.TableDataInfo;
/**
* 考核维度评分明细
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/appraisalDetail")
public class PerfAppraisalDetailController extends BaseController {
private final IPerfAppraisalDetailService iPerfAppraisalDetailService;
/**
* 查询考核维度评分明细列表
*/
@GetMapping("/list")
public TableDataInfo<PerfAppraisalDetailVo> list(PerfAppraisalDetailBo bo, PageQuery pageQuery) {
return iPerfAppraisalDetailService.queryPageList(bo, pageQuery);
}
/**
* 导出考核维度评分明细列表
*/
@Log(title = "考核维度评分明细", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfAppraisalDetailBo bo, HttpServletResponse response) {
List<PerfAppraisalDetailVo> list = iPerfAppraisalDetailService.queryList(bo);
ExcelUtil.exportExcel(list, "考核维度评分明细", PerfAppraisalDetailVo.class, response);
}
/**
* 获取考核维度评分明细详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfAppraisalDetailVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfAppraisalDetailService.queryById(id));
}
/**
* 新增考核维度评分明细
*/
@Log(title = "考核维度评分明细", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfAppraisalDetailBo bo) {
return toAjax(iPerfAppraisalDetailService.insertByBo(bo));
}
/**
* 修改考核维度评分明细
*/
@Log(title = "考核维度评分明细", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfAppraisalDetailBo bo) {
return toAjax(iPerfAppraisalDetailService.updateByBo(bo));
}
/**
* 删除考核维度评分明细
*
* @param ids 主键串
*/
@Log(title = "考核维度评分明细", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfAppraisalDetailService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfCoeffRangeVo;
import com.klp.perf.domain.bo.PerfCoeffRangeBo;
import com.klp.perf.service.IPerfCoeffRangeService;
import com.klp.common.core.page.TableDataInfo;
/**
* 绩效系数换算
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/coeffRange")
public class PerfCoeffRangeController extends BaseController {
private final IPerfCoeffRangeService iPerfCoeffRangeService;
/**
* 查询绩效系数换算列表
*/
@GetMapping("/list")
public TableDataInfo<PerfCoeffRangeVo> list(PerfCoeffRangeBo bo, PageQuery pageQuery) {
return iPerfCoeffRangeService.queryPageList(bo, pageQuery);
}
/**
* 导出绩效系数换算列表
*/
@Log(title = "绩效系数换算", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfCoeffRangeBo bo, HttpServletResponse response) {
List<PerfCoeffRangeVo> list = iPerfCoeffRangeService.queryList(bo);
ExcelUtil.exportExcel(list, "绩效系数换算", PerfCoeffRangeVo.class, response);
}
/**
* 获取绩效系数换算详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfCoeffRangeVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfCoeffRangeService.queryById(id));
}
/**
* 新增绩效系数换算
*/
@Log(title = "绩效系数换算", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfCoeffRangeBo bo) {
return toAjax(iPerfCoeffRangeService.insertByBo(bo));
}
/**
* 修改绩效系数换算
*/
@Log(title = "绩效系数换算", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfCoeffRangeBo bo) {
return toAjax(iPerfCoeffRangeService.updateByBo(bo));
}
/**
* 删除绩效系数换算
*
* @param ids 主键串
*/
@Log(title = "绩效系数换算", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfCoeffRangeService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfDeptConfigVo;
import com.klp.perf.domain.bo.PerfDeptConfigBo;
import com.klp.perf.service.IPerfDeptConfigService;
import com.klp.common.core.page.TableDataInfo;
/**
* 车间考核参数配置
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/deptConfig")
public class PerfDeptConfigController extends BaseController {
private final IPerfDeptConfigService iPerfDeptConfigService;
/**
* 查询车间考核参数配置列表
*/
@GetMapping("/list")
public TableDataInfo<PerfDeptConfigVo> list(PerfDeptConfigBo bo, PageQuery pageQuery) {
return iPerfDeptConfigService.queryPageList(bo, pageQuery);
}
/**
* 导出车间考核参数配置列表
*/
@Log(title = "车间考核参数配置", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfDeptConfigBo bo, HttpServletResponse response) {
List<PerfDeptConfigVo> list = iPerfDeptConfigService.queryList(bo);
ExcelUtil.exportExcel(list, "车间考核参数配置", PerfDeptConfigVo.class, response);
}
/**
* 获取车间考核参数配置详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfDeptConfigVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfDeptConfigService.queryById(id));
}
/**
* 新增车间考核参数配置
*/
@Log(title = "车间考核参数配置", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfDeptConfigBo bo) {
return toAjax(iPerfDeptConfigService.insertByBo(bo));
}
/**
* 修改车间考核参数配置
*/
@Log(title = "车间考核参数配置", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfDeptConfigBo bo) {
return toAjax(iPerfDeptConfigService.updateByBo(bo));
}
/**
* 删除车间考核参数配置
*
* @param ids 主键串
*/
@Log(title = "车间考核参数配置", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfDeptConfigService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfDeptVo;
import com.klp.perf.domain.bo.PerfDeptBo;
import com.klp.perf.service.IPerfDeptService;
import com.klp.common.core.page.TableDataInfo;
/**
* 绩效系统部门
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/dept")
public class PerfDeptController extends BaseController {
private final IPerfDeptService iPerfDeptService;
/**
* 查询绩效系统部门列表
*/
@GetMapping("/list")
public TableDataInfo<PerfDeptVo> list(PerfDeptBo bo, PageQuery pageQuery) {
return iPerfDeptService.queryPageList(bo, pageQuery);
}
/**
* 导出绩效系统部门列表
*/
@Log(title = "绩效系统部门", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfDeptBo bo, HttpServletResponse response) {
List<PerfDeptVo> list = iPerfDeptService.queryList(bo);
ExcelUtil.exportExcel(list, "绩效系统部门", PerfDeptVo.class, response);
}
/**
* 获取绩效系统部门详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfDeptVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfDeptService.queryById(id));
}
/**
* 新增绩效系统部门
*/
@Log(title = "绩效系统部门", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfDeptBo bo) {
return toAjax(iPerfDeptService.insertByBo(bo));
}
/**
* 修改绩效系统部门
*/
@Log(title = "绩效系统部门", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfDeptBo bo) {
return toAjax(iPerfDeptService.updateByBo(bo));
}
/**
* 删除绩效系统部门
*
* @param ids 主键串
*/
@Log(title = "绩效系统部门", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfDeptService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfDeptItemConfigVo;
import com.klp.perf.domain.bo.PerfDeptItemConfigBo;
import com.klp.perf.service.IPerfDeptItemConfigService;
import com.klp.common.core.page.TableDataInfo;
/**
* 车间扣款/奖励项目配置
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/deptItemConfig")
public class PerfDeptItemConfigController extends BaseController {
private final IPerfDeptItemConfigService iPerfDeptItemConfigService;
/**
* 查询车间扣款/奖励项目配置列表
*/
@GetMapping("/list")
public TableDataInfo<PerfDeptItemConfigVo> list(PerfDeptItemConfigBo bo, PageQuery pageQuery) {
return iPerfDeptItemConfigService.queryPageList(bo, pageQuery);
}
/**
* 导出车间扣款/奖励项目配置列表
*/
@Log(title = "车间扣款/奖励项目配置", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfDeptItemConfigBo bo, HttpServletResponse response) {
List<PerfDeptItemConfigVo> list = iPerfDeptItemConfigService.queryList(bo);
ExcelUtil.exportExcel(list, "车间扣款/奖励项目配置", PerfDeptItemConfigVo.class, response);
}
/**
* 获取车间扣款/奖励项目配置详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfDeptItemConfigVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfDeptItemConfigService.queryById(id));
}
/**
* 新增车间扣款/奖励项目配置
*/
@Log(title = "车间扣款/奖励项目配置", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfDeptItemConfigBo bo) {
return toAjax(iPerfDeptItemConfigService.insertByBo(bo));
}
/**
* 修改车间扣款/奖励项目配置
*/
@Log(title = "车间扣款/奖励项目配置", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfDeptItemConfigBo bo) {
return toAjax(iPerfDeptItemConfigService.updateByBo(bo));
}
/**
* 删除车间扣款/奖励项目配置
*
* @param ids 主键串
*/
@Log(title = "车间扣款/奖励项目配置", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfDeptItemConfigService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfDeptSummaryVo;
import com.klp.perf.domain.bo.PerfDeptSummaryBo;
import com.klp.perf.service.IPerfDeptSummaryService;
import com.klp.common.core.page.TableDataInfo;
/**
* 车间月度汇总
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/deptSummary")
public class PerfDeptSummaryController extends BaseController {
private final IPerfDeptSummaryService iPerfDeptSummaryService;
/**
* 查询车间月度汇总列表
*/
@GetMapping("/list")
public TableDataInfo<PerfDeptSummaryVo> list(PerfDeptSummaryBo bo, PageQuery pageQuery) {
return iPerfDeptSummaryService.queryPageList(bo, pageQuery);
}
/**
* 导出车间月度汇总列表
*/
@Log(title = "车间月度汇总", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfDeptSummaryBo bo, HttpServletResponse response) {
List<PerfDeptSummaryVo> list = iPerfDeptSummaryService.queryList(bo);
ExcelUtil.exportExcel(list, "车间月度汇总", PerfDeptSummaryVo.class, response);
}
/**
* 获取车间月度汇总详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfDeptSummaryVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfDeptSummaryService.queryById(id));
}
/**
* 新增车间月度汇总
*/
@Log(title = "车间月度汇总", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfDeptSummaryBo bo) {
return toAjax(iPerfDeptSummaryService.insertByBo(bo));
}
/**
* 修改车间月度汇总
*/
@Log(title = "车间月度汇总", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfDeptSummaryBo bo) {
return toAjax(iPerfDeptSummaryService.updateByBo(bo));
}
/**
* 删除车间月度汇总
*
* @param ids 主键串
*/
@Log(title = "车间月度汇总", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfDeptSummaryService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfEmployeeInfoVo;
import com.klp.perf.domain.bo.PerfEmployeeInfoBo;
import com.klp.perf.service.IPerfEmployeeInfoService;
import com.klp.common.core.page.TableDataInfo;
/**
* 员工绩效薪资基本信息
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/employeeInfo")
public class PerfEmployeeInfoController extends BaseController {
private final IPerfEmployeeInfoService iPerfEmployeeInfoService;
/**
* 查询员工绩效薪资基本信息列表
*/
@GetMapping("/list")
public TableDataInfo<PerfEmployeeInfoVo> list(PerfEmployeeInfoBo bo, PageQuery pageQuery) {
return iPerfEmployeeInfoService.queryPageList(bo, pageQuery);
}
/**
* 导出员工绩效薪资基本信息列表
*/
@Log(title = "员工绩效薪资基本信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfEmployeeInfoBo bo, HttpServletResponse response) {
List<PerfEmployeeInfoVo> list = iPerfEmployeeInfoService.queryList(bo);
ExcelUtil.exportExcel(list, "员工绩效薪资基本信息", PerfEmployeeInfoVo.class, response);
}
/**
* 获取员工绩效薪资基本信息详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfEmployeeInfoVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfEmployeeInfoService.queryById(id));
}
/**
* 新增员工绩效薪资基本信息
*/
@Log(title = "员工绩效薪资基本信息", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfEmployeeInfoBo bo) {
return toAjax(iPerfEmployeeInfoService.insertByBo(bo));
}
/**
* 修改员工绩效薪资基本信息
*/
@Log(title = "员工绩效薪资基本信息", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfEmployeeInfoBo bo) {
return toAjax(iPerfEmployeeInfoService.updateByBo(bo));
}
/**
* 删除员工绩效薪资基本信息
*
* @param ids 主键串
*/
@Log(title = "员工绩效薪资基本信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfEmployeeInfoService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfPositionTemplateVo;
import com.klp.perf.domain.bo.PerfPositionTemplateBo;
import com.klp.perf.service.IPerfPositionTemplateService;
import com.klp.common.core.page.TableDataInfo;
/**
* 岗位绩效考核模板
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/positionTemplate")
public class PerfPositionTemplateController extends BaseController {
private final IPerfPositionTemplateService iPerfPositionTemplateService;
/**
* 查询岗位绩效考核模板列表
*/
@GetMapping("/list")
public TableDataInfo<PerfPositionTemplateVo> list(PerfPositionTemplateBo bo, PageQuery pageQuery) {
return iPerfPositionTemplateService.queryPageList(bo, pageQuery);
}
/**
* 导出岗位绩效考核模板列表
*/
@Log(title = "岗位绩效考核模板", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfPositionTemplateBo bo, HttpServletResponse response) {
List<PerfPositionTemplateVo> list = iPerfPositionTemplateService.queryList(bo);
ExcelUtil.exportExcel(list, "岗位绩效考核模板", PerfPositionTemplateVo.class, response);
}
/**
* 获取岗位绩效考核模板详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfPositionTemplateVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfPositionTemplateService.queryById(id));
}
/**
* 新增岗位绩效考核模板
*/
@Log(title = "岗位绩效考核模板", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfPositionTemplateBo bo) {
return toAjax(iPerfPositionTemplateService.insertByBo(bo));
}
/**
* 修改岗位绩效考核模板
*/
@Log(title = "岗位绩效考核模板", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfPositionTemplateBo bo) {
return toAjax(iPerfPositionTemplateService.updateByBo(bo));
}
/**
* 删除岗位绩效考核模板
*
* @param ids 主键串
*/
@Log(title = "岗位绩效考核模板", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfPositionTemplateService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfSalaryVo;
import com.klp.perf.domain.bo.PerfSalaryBo;
import com.klp.perf.service.IPerfSalaryService;
import com.klp.common.core.page.TableDataInfo;
/**
* 月度薪资计算记录
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/salary")
public class PerfSalaryController extends BaseController {
private final IPerfSalaryService iPerfSalaryService;
/**
* 查询月度薪资计算记录列表
*/
@GetMapping("/list")
public TableDataInfo<PerfSalaryVo> list(PerfSalaryBo bo, PageQuery pageQuery) {
return iPerfSalaryService.queryPageList(bo, pageQuery);
}
/**
* 导出月度薪资计算记录列表
*/
@Log(title = "月度薪资计算记录", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfSalaryBo bo, HttpServletResponse response) {
List<PerfSalaryVo> list = iPerfSalaryService.queryList(bo);
ExcelUtil.exportExcel(list, "月度薪资计算记录", PerfSalaryVo.class, response);
}
/**
* 获取月度薪资计算记录详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfSalaryVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfSalaryService.queryById(id));
}
/**
* 新增月度薪资计算记录
*/
@Log(title = "月度薪资计算记录", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfSalaryBo bo) {
return toAjax(iPerfSalaryService.insertByBo(bo));
}
/**
* 修改月度薪资计算记录
*/
@Log(title = "月度薪资计算记录", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfSalaryBo bo) {
return toAjax(iPerfSalaryService.updateByBo(bo));
}
/**
* 删除月度薪资计算记录
*
* @param ids 主键串
*/
@Log(title = "月度薪资计算记录", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfSalaryService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.controller;
import java.util.List;
import java.util.Arrays;
import lombok.RequiredArgsConstructor;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.klp.common.annotation.RepeatSubmit;
import com.klp.common.annotation.Log;
import com.klp.common.core.controller.BaseController;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.core.domain.R;
import com.klp.common.core.validate.AddGroup;
import com.klp.common.core.validate.EditGroup;
import com.klp.common.enums.BusinessType;
import com.klp.common.utils.poi.ExcelUtil;
import com.klp.perf.domain.vo.PerfTemplateDimensionVo;
import com.klp.perf.domain.bo.PerfTemplateDimensionBo;
import com.klp.perf.service.IPerfTemplateDimensionService;
import com.klp.common.core.page.TableDataInfo;
/**
* 考核维度明细
*
* @author klp
* @date 2026-07-07
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/perf/templateDimension")
public class PerfTemplateDimensionController extends BaseController {
private final IPerfTemplateDimensionService iPerfTemplateDimensionService;
/**
* 查询考核维度明细列表
*/
@GetMapping("/list")
public TableDataInfo<PerfTemplateDimensionVo> list(PerfTemplateDimensionBo bo, PageQuery pageQuery) {
return iPerfTemplateDimensionService.queryPageList(bo, pageQuery);
}
/**
* 导出考核维度明细列表
*/
@Log(title = "考核维度明细", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(PerfTemplateDimensionBo bo, HttpServletResponse response) {
List<PerfTemplateDimensionVo> list = iPerfTemplateDimensionService.queryList(bo);
ExcelUtil.exportExcel(list, "考核维度明细", PerfTemplateDimensionVo.class, response);
}
/**
* 获取考核维度明细详细信息
*
* @param id 主键
*/
@GetMapping("/{id}")
public R<PerfTemplateDimensionVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iPerfTemplateDimensionService.queryById(id));
}
/**
* 新增考核维度明细
*/
@Log(title = "考核维度明细", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody PerfTemplateDimensionBo bo) {
return toAjax(iPerfTemplateDimensionService.insertByBo(bo));
}
/**
* 修改考核维度明细
*/
@Log(title = "考核维度明细", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody PerfTemplateDimensionBo bo) {
return toAjax(iPerfTemplateDimensionService.updateByBo(bo));
}
/**
* 删除考核维度明细
*
* @param ids 主键串
*/
@Log(title = "考核维度明细", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iPerfTemplateDimensionService.deleteWithValidByIds(Arrays.asList(ids), true));
}
}

View File

@@ -0,0 +1,92 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 月度绩效考核记录对象 perf_appraisal
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_appraisal")
public class PerfAppraisal extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联现有员工表主键
*/
private Long employeeId;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 关联 perf_position_template.id (当月使用的模板)
*/
private Long templateId;
/**
* 考核周期 YYYY-MM
*/
private String period;
/**
* 加权得分 = SUM(维度得分)
*/
private BigDecimal weightedScore;
/**
* 总加分
*/
private BigDecimal bonusScore;
/**
* 总扣分
*/
private BigDecimal penaltyScore;
/**
* 最终得分 = MIN(120, 加权得分+加分-扣分)
*/
private BigDecimal finalScore;
/**
* 评级 S/A/B/C/D
*/
private String grade;
/**
* 绩效系数(线性插值换算,自动同步到岗位系数)
*/
private BigDecimal perfCoeff;
/**
* 0=草稿 1=已确认 2=已归档
*/
private Long status;
/**
*
*/
private Date confirmedAt;
/**
* 确认人
*/
private Long confirmedBy;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,86 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.math.BigDecimal;
/**
* 考核维度评分明细对象 perf_appraisal_detail
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_appraisal_detail")
public class PerfAppraisalDetail extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联 perf_appraisal.id
*/
private Long appraisalId;
/**
* 关联 perf_template_dimension.id
*/
private Long dimensionId;
/**
* 序号(从模板快照)
*/
private String seq;
/**
* 维度名称(从模板快照)
*/
private String dimName;
/**
* 权重(从模板快照)
*/
private String weight;
/**
* 目标值(可覆盖模板默认值)
*/
private String targetValue;
/**
* 实际值(考核人填写)
*/
private String actualValue;
/**
* 维度得分(公式计算)
*/
private BigDecimal dimScore;
/**
* 本维度额外加分
*/
private BigDecimal bonus;
/**
* 本维度额外扣分
*/
private BigDecimal penalty;
/**
* 评分公式(从模板快照)
*/
private String scoreFormula;
/**
* 评分规则(从模板快照)
*/
private String scoreRule;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,66 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.math.BigDecimal;
/**
* 绩效系数换算对象 perf_coeff_range
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_coeff_range")
public class PerfCoeffRange extends BaseEntity {
private static final long serialVersionUID=1L;
/**
* 主键
*/
@TableId(value = "id")
private Long id;
/**
* 等级标识 S/A/B/C/D
*/
private String grade;
/**
* 等级名称 卓越/优秀/合格/待改进/不合格
*/
private String gradeLabel;
/**
* 得分下限(含)
*/
private BigDecimal scoreMin;
/**
* 得分上限(含)
*/
private BigDecimal scoreMax;
/**
* 最低绩效系数
*/
private BigDecimal coeffMin;
/**
* 最高绩效系数
*/
private BigDecimal coeffMax;
/**
* 排序(高→低)
*/
private Long sortOrder;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,53 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 绩效系统部门对象 perf_dept
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_dept")
public class PerfDept extends BaseEntity {
private static final long serialVersionUID=1L;
/**
* 主键
*/
@TableId(value = "id")
private Long id;
/**
* 部门/车间名称 如:酸轧车间/技术部
*/
private String deptName;
/**
* 排序
*/
private Long orderNum;
/**
* 是否有保底薪资模式 0=否 1=是
*/
private Integer hasBaoSalary;
/**
* 状态0正常 1停用
*/
private String status;
/**
* 删除标志0=正常 1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,83 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 车间考核参数配置对象 perf_dept_config
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_dept_config")
public class PerfDeptConfig extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 月产量目标(吨) 或 月产长度目标(m)
*/
private BigDecimal monthlyProductionTarget;
/**
* 产量单位: 吨 / m
*/
private String productionUnit;
/**
* 绩效吨钢(元) 或 绩效米钢(元)
*/
private BigDecimal perfUnitPrice;
/**
* 生产班数
*/
private Long productionShifts;
/**
* 停机保底班数
*/
private Long guaranteedShifts;
/**
* 车间系数(默认1.0)
*/
private BigDecimal deptCoeff;
/**
* 薪资模式: 0=普通模式 1=保底模式(hasBaoSalary)
*/
private Long salaryMode;
/**
* 保底薪资除数(底薪÷60=保底每班金额)
*/
private Long baseDivisor;
/**
* 月份
*/
private Date month;
/**
*
*/
private String remark;
/**
*
*/
private Date createdAt;
/**
*
*/
private Date updatedAt;
}

View File

@@ -0,0 +1,63 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 车间扣款/奖励项目配置对象 perf_dept_item_config
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_dept_item_config")
public class PerfDeptItemConfig extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 类型: 1=扣款项目 2=奖励项目
*/
private Long itemType;
/**
* 项目名称 如:质量扣款/节能奖励
*/
private String itemName;
/**
*
*/
private Long sortOrder;
/**
* 月份
*/
private Date month;
/**
*
*/
private Long isEnabled;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,102 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.math.BigDecimal;
/**
* 车间月度汇总对象 perf_dept_summary
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_dept_summary")
public class PerfDeptSummary extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 周期 YYYY-MM
*/
private String period;
/**
* 总人数
*/
private Long totalEmployees;
/**
* 系数总计(所有人员总系数之和)
*/
private BigDecimal totalCoeffSum;
/**
* 平均考核得分
*/
private BigDecimal avgPerfScore;
/**
* 平均绩效系数
*/
private BigDecimal avgPerfCoeff;
/**
* 底薪合计
*/
private BigDecimal totalBaseSalary;
/**
* 月度绩效工资合计
*/
private BigDecimal totalPerfWage;
/**
* 扣款合计
*/
private BigDecimal totalDeductions;
/**
* 奖励合计
*/
private BigDecimal totalBonuses;
/**
* 其他合计
*/
private BigDecimal totalOther;
/**
* 实领薪资合计
*/
private BigDecimal totalActualSalary;
/**
* 人均实领薪资
*/
private BigDecimal avgActualSalary;
/**
* 当月实际产量
*/
private BigDecimal monthlyProduction;
/**
* 系数单价(自动计算) = 月产量×绩效吨钢/系数总计
*/
private BigDecimal unitPrice;
/**
* 0=草稿 1=已确认
*/
private Long status;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,66 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.math.BigDecimal;
/**
* 员工绩效薪资基本信息对象 perf_employee_info
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_employee_info")
public class PerfEmployeeInfo extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联现有员工表主键
*/
private Long employeeId;
/**
* 关联 perf_dept.id (冗余,便于按部门查询)
*/
private Long deptId;
/**
* 岗位/工种
*/
private String positionName;
/**
* 底薪(元)
*/
private BigDecimal baseSalary;
/**
* 岗位绩效基数(元), 默认≈底薪×20%
*/
private BigDecimal perfBase;
/**
* 默认岗位系数(初始值,后续月度由绩效自动覆盖)
*/
private BigDecimal posCoeffDefault;
/**
* 是否在职 1=在职 0=离职
*/
private Long isActive;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,53 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 岗位绩效考核模板对象 perf_position_template
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_position_template")
public class PerfPositionTemplate extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 岗位名称 (与员工表岗位字段匹配)
*/
private String positionName;
/**
* 模板标题 如:轧机主操绩效考核评分表
*/
private String title;
/**
*
*/
private Long isEnabled;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,156 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 月度薪资计算记录对象 perf_salary
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_salary")
public class PerfSalary extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联现有员工表主键
*/
private Long employeeId;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 关联 perf_appraisal.id (可为空=未考核)
*/
private Long appraisalId;
/**
* 薪资周期 YYYY-MM
*/
private String period;
/**
* 底薪
*/
private BigDecimal baseSalary;
/**
* 岗位绩效基数
*/
private BigDecimal perfBase;
/**
* 考核得分(关联 perf_appraisal.final_score)
*/
private BigDecimal perfScore;
/**
* 绩效系数(得分换算,关联 perf_appraisal.perf_coeff)
*/
private BigDecimal perfCoeff;
/**
* 车间系数(来自 perf_dept_config.dept_coeff)
*/
private BigDecimal deptCoeff;
/**
* 月度绩效工资 = perf_base × perf_coeff × dept_coeff
*/
private BigDecimal perfWage;
/**
* 岗位系数 (=绩效系数,自动同步)
*/
private BigDecimal posCoeff;
/**
* 固定系数 = pos_coeff × 0.7
*/
private BigDecimal fixedCoeff;
/**
* 可调系数(手动覆盖,默认=pos_coeff×0.3)
*/
private BigDecimal adjCoeff;
/**
* 可调系数是否手动覆盖: 0=自动 1=手动
*/
private Long adjCoeffManual;
/**
* 总系数 = fixed_coeff + adj_coeff
*/
private BigDecimal totalCoeff;
/**
* 扣款明细 {"质量扣款":0,"倒卷扣款":0,"客诉扣款":0,...}
*/
private String deductionsJson;
/**
* 扣款合计
*/
private BigDecimal deductionsTotal;
/**
* 奖励明细 {"节能奖励":0,...}
*/
private String bonusesJson;
/**
* 奖励合计
*/
private BigDecimal bonusesTotal;
/**
* 其他金额
*/
private BigDecimal otherAmount;
/**
* 实领薪资 = 底薪+月度绩效工资-扣款合计+奖励合计+其他
*/
private BigDecimal actualSalary;
/**
* 固定系数薪资(参考) = fixed_coeff × 系数单价
*/
private BigDecimal fixedSalaryRef;
/**
* 可调系数薪资(参考) = adj_coeff × 系数单价
*/
private BigDecimal adjSalaryRef;
/**
* 保底每班(参考) = base_salary / 60
*/
private BigDecimal baoPerShiftRef;
/**
* 保底薪资(参考) = bao_per_shift × 保底班数
*/
private BigDecimal baoSalaryRef;
/**
* 合计薪资(参考) = fixed_salary_ref+adj_salary_ref+bao_salary_ref
*/
private BigDecimal totalSalaryRef;
/**
* 0=草稿 1=已确认 2=已归档
*/
private Long status;
/**
*
*/
private Date confirmedAt;
/**
*
*/
private Long confirmedBy;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,73 @@
package com.klp.perf.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 考核维度明细对象 perf_template_dimension
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("perf_template_dimension")
public class PerfTemplateDimension extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联 perf_position_template.id
*/
private Long templateId;
/**
* 序号
*/
private String seq;
/**
* 考核维度 如:产量/质量/安全/检测准确性
*/
private String dimName;
/**
* 权重 如:40% 或 0.4
*/
private String weight;
/**
* 量化指标 如:月产量达标率/产品合格率
*/
private String indicator;
/**
* 目标值 如:≥98% / 100% / 0次 / 达标
*/
private String targetValue;
/**
* 评分公式 如:=IF(E4>0,25*(F4/E4),0)
*/
private String scoreFormula;
/**
* 评分规则文字描述
*/
private String scoreRule;
/**
*
*/
private Long isEnabled;
/**
* 删除标志0=正常1=已删除)
*/
@TableLogic
private Integer delFlag;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,99 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 月度绩效考核记录业务对象 perf_appraisal
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfAppraisalBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联现有员工表主键
*/
private Long employeeId;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 关联 perf_position_template.id (当月使用的模板)
*/
private Long templateId;
/**
* 考核周期 YYYY-MM
*/
private String period;
/**
* 加权得分 = SUM(维度得分)
*/
private BigDecimal weightedScore;
/**
* 总加分
*/
private BigDecimal bonusScore;
/**
* 总扣分
*/
private BigDecimal penaltyScore;
/**
* 最终得分 = MIN(120, 加权得分+加分-扣分)
*/
private BigDecimal finalScore;
/**
* 评级 S/A/B/C/D
*/
private String grade;
/**
* 绩效系数(线性插值换算,自动同步到岗位系数)
*/
private BigDecimal perfCoeff;
/**
* 0=草稿 1=已确认 2=已归档
*/
private Long status;
/**
*
*/
private Date confirmedAt;
/**
* 确认人
*/
private Long confirmedBy;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,92 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.math.BigDecimal;
/**
* 考核维度评分明细业务对象 perf_appraisal_detail
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfAppraisalDetailBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联 perf_appraisal.id
*/
private Long appraisalId;
/**
* 关联 perf_template_dimension.id
*/
private Long dimensionId;
/**
* 序号(从模板快照)
*/
private String seq;
/**
* 维度名称(从模板快照)
*/
private String dimName;
/**
* 权重(从模板快照)
*/
private String weight;
/**
* 目标值(可覆盖模板默认值)
*/
private String targetValue;
/**
* 实际值(考核人填写)
*/
private String actualValue;
/**
* 维度得分(公式计算)
*/
private BigDecimal dimScore;
/**
* 本维度额外加分
*/
private BigDecimal bonus;
/**
* 本维度额外扣分
*/
private BigDecimal penalty;
/**
* 评分公式(从模板快照)
*/
private String scoreFormula;
/**
* 评分规则(从模板快照)
*/
private String scoreRule;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,67 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.math.BigDecimal;
/**
* 绩效系数换算业务对象 perf_coeff_range
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfCoeffRangeBo extends BaseEntity {
/**
* 主键
*/
private Long id;
/**
* 等级标识 S/A/B/C/D
*/
private String grade;
/**
* 等级名称 卓越/优秀/合格/待改进/不合格
*/
private String gradeLabel;
/**
* 得分下限(含)
*/
private BigDecimal scoreMin;
/**
* 得分上限(含)
*/
private BigDecimal scoreMax;
/**
* 最低绩效系数
*/
private BigDecimal coeffMin;
/**
* 最高绩效系数
*/
private BigDecimal coeffMax;
/**
* 排序(高→低)
*/
private Long sortOrder;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,51 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
/**
* 绩效系统部门业务对象 perf_dept
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfDeptBo extends BaseEntity {
/**
* 主键
*/
private Long id;
/**
* 部门/车间名称 如:酸轧车间/技术部
*/
private String deptName;
/**
* 排序
*/
private Long orderNum;
/**
* 是否有保底薪资模式 0=否 1=是
*/
private Integer hasBaoSalary;
/**
* 状态0正常 1停用
*/
private String status;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,94 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 车间考核参数配置业务对象 perf_dept_config
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfDeptConfigBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 月产量目标(吨) 或 月产长度目标(m)
*/
private BigDecimal monthlyProductionTarget;
/**
* 产量单位: 吨 / m
*/
private String productionUnit;
/**
* 绩效吨钢(元) 或 绩效米钢(元)
*/
private BigDecimal perfUnitPrice;
/**
* 生产班数
*/
private Long productionShifts;
/**
* 停机保底班数
*/
private Long guaranteedShifts;
/**
* 车间系数(默认1.0)
*/
private BigDecimal deptCoeff;
/**
* 薪资模式: 0=普通模式 1=保底模式(hasBaoSalary)
*/
private Long salaryMode;
/**
* 保底薪资除数(底薪÷60=保底每班金额)
*/
private Long baseDivisor;
/**
* 月份
*/
private Date month;
/**
*
*/
private String remark;
/**
*
*/
private Date createdAt;
/**
*
*/
private Date updatedAt;
}

View File

@@ -0,0 +1,63 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 车间扣款/奖励项目配置业务对象 perf_dept_item_config
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfDeptItemConfigBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 类型: 1=扣款项目 2=奖励项目
*/
private Long itemType;
/**
* 项目名称 如:质量扣款/节能奖励
*/
private String itemName;
/**
*
*/
private Long sortOrder;
/**
* 月份
*/
private Date month;
/**
*
*/
private Long isEnabled;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,112 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.math.BigDecimal;
/**
* 车间月度汇总业务对象 perf_dept_summary
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfDeptSummaryBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 周期 YYYY-MM
*/
private String period;
/**
* 总人数
*/
private Long totalEmployees;
/**
* 系数总计(所有人员总系数之和)
*/
private BigDecimal totalCoeffSum;
/**
* 平均考核得分
*/
private BigDecimal avgPerfScore;
/**
* 平均绩效系数
*/
private BigDecimal avgPerfCoeff;
/**
* 底薪合计
*/
private BigDecimal totalBaseSalary;
/**
* 月度绩效工资合计
*/
private BigDecimal totalPerfWage;
/**
* 扣款合计
*/
private BigDecimal totalDeductions;
/**
* 奖励合计
*/
private BigDecimal totalBonuses;
/**
* 其他合计
*/
private BigDecimal totalOther;
/**
* 实领薪资合计
*/
private BigDecimal totalActualSalary;
/**
* 人均实领薪资
*/
private BigDecimal avgActualSalary;
/**
* 当月实际产量
*/
private BigDecimal monthlyProduction;
/**
* 系数单价(自动计算) = 月产量×绩效吨钢/系数总计
*/
private BigDecimal unitPrice;
/**
* 0=草稿 1=已确认
*/
private Long status;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,67 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.math.BigDecimal;
/**
* 员工绩效薪资基本信息业务对象 perf_employee_info
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfEmployeeInfoBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联现有员工表主键
*/
private Long employeeId;
/**
* 关联 perf_dept.id (冗余,便于按部门查询)
*/
private Long deptId;
/**
* 岗位/工种
*/
private String positionName;
/**
* 底薪(元)
*/
private BigDecimal baseSalary;
/**
* 岗位绩效基数(元), 默认≈底薪×20%
*/
private BigDecimal perfBase;
/**
* 默认岗位系数(初始值,后续月度由绩效自动覆盖)
*/
private BigDecimal posCoeffDefault;
/**
* 是否在职 1=在职 0=离职
*/
private Long isActive;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,51 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
/**
* 岗位绩效考核模板业务对象 perf_position_template
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfPositionTemplateBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 岗位名称 (与员工表岗位字段匹配)
*/
private String positionName;
/**
* 模板标题 如:轧机主操绩效考核评分表
*/
private String title;
/**
*
*/
private Long isEnabled;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,179 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 月度薪资计算记录业务对象 perf_salary
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfSalaryBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联现有员工表主键
*/
private Long employeeId;
/**
* 关联 perf_dept.id
*/
private Long deptId;
/**
* 关联 perf_appraisal.id (可为空=未考核)
*/
private Long appraisalId;
/**
* 薪资周期 YYYY-MM
*/
private String period;
/**
* 底薪
*/
private BigDecimal baseSalary;
/**
* 岗位绩效基数
*/
private BigDecimal perfBase;
/**
* 考核得分(关联 perf_appraisal.final_score)
*/
private BigDecimal perfScore;
/**
* 绩效系数(得分换算,关联 perf_appraisal.perf_coeff)
*/
private BigDecimal perfCoeff;
/**
* 车间系数(来自 perf_dept_config.dept_coeff)
*/
private BigDecimal deptCoeff;
/**
* 月度绩效工资 = perf_base × perf_coeff × dept_coeff
*/
private BigDecimal perfWage;
/**
* 岗位系数 (=绩效系数,自动同步)
*/
private BigDecimal posCoeff;
/**
* 固定系数 = pos_coeff × 0.7
*/
private BigDecimal fixedCoeff;
/**
* 可调系数(手动覆盖,默认=pos_coeff×0.3)
*/
private BigDecimal adjCoeff;
/**
* 可调系数是否手动覆盖: 0=自动 1=手动
*/
private Long adjCoeffManual;
/**
* 总系数 = fixed_coeff + adj_coeff
*/
private BigDecimal totalCoeff;
/**
* 扣款明细 {"质量扣款":0,"倒卷扣款":0,"客诉扣款":0,...}
*/
private String deductionsJson;
/**
* 扣款合计
*/
private BigDecimal deductionsTotal;
/**
* 奖励明细 {"节能奖励":0,...}
*/
private String bonusesJson;
/**
* 奖励合计
*/
private BigDecimal bonusesTotal;
/**
* 其他金额
*/
private BigDecimal otherAmount;
/**
* 实领薪资 = 底薪+月度绩效工资-扣款合计+奖励合计+其他
*/
private BigDecimal actualSalary;
/**
* 固定系数薪资(参考) = fixed_coeff × 系数单价
*/
private BigDecimal fixedSalaryRef;
/**
* 可调系数薪资(参考) = adj_coeff × 系数单价
*/
private BigDecimal adjSalaryRef;
/**
* 保底每班(参考) = base_salary / 60
*/
private BigDecimal baoPerShiftRef;
/**
* 保底薪资(参考) = bao_per_shift × 保底班数
*/
private BigDecimal baoSalaryRef;
/**
* 合计薪资(参考) = fixed_salary_ref+adj_salary_ref+bao_salary_ref
*/
private BigDecimal totalSalaryRef;
/**
* 0=草稿 1=已确认 2=已归档
*/
private Long status;
/**
*
*/
private Date confirmedAt;
/**
*
*/
private Long confirmedBy;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,76 @@
package com.klp.perf.domain.bo;
import com.klp.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
/**
* 考核维度明细业务对象 perf_template_dimension
*
* @author klp
* @date 2026-07-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class PerfTemplateDimensionBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 关联 perf_position_template.id
*/
private Long templateId;
/**
* 序号
*/
private String seq;
/**
* 考核维度 如:产量/质量/安全/检测准确性
*/
private String dimName;
/**
* 权重 如:40% 或 0.4
*/
private String weight;
/**
* 量化指标 如:月产量达标率/产品合格率
*/
private String indicator;
/**
* 目标值 如:≥98% / 100% / 0次 / 达标
*/
private String targetValue;
/**
* 评分公式 如:=IF(E4>0,25*(F4/E4),0)
*/
private String scoreFormula;
/**
* 评分规则文字描述
*/
private String scoreRule;
/**
*
*/
private Long isEnabled;
/**
* 备注
*/
private String remark;
}

View File

@@ -0,0 +1,108 @@
package com.klp.perf.domain.vo;
import java.math.BigDecimal;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 考核维度评分明细视图对象 perf_appraisal_detail
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfAppraisalDetailVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联 perf_appraisal.id
*/
@ExcelProperty(value = "关联 perf_appraisal.id")
private Long appraisalId;
/**
* 关联 perf_template_dimension.id
*/
@ExcelProperty(value = "关联 perf_template_dimension.id")
private Long dimensionId;
/**
* 序号(从模板快照)
*/
@ExcelProperty(value = "序号(从模板快照)")
private String seq;
/**
* 维度名称(从模板快照)
*/
@ExcelProperty(value = "维度名称(从模板快照)")
private String dimName;
/**
* 权重(从模板快照)
*/
@ExcelProperty(value = "权重(从模板快照)")
private String weight;
/**
* 目标值(可覆盖模板默认值)
*/
@ExcelProperty(value = "目标值(可覆盖模板默认值)")
private String targetValue;
/**
* 实际值(考核人填写)
*/
@ExcelProperty(value = "实际值(考核人填写)")
private String actualValue;
/**
* 维度得分(公式计算)
*/
@ExcelProperty(value = "维度得分(公式计算)")
private BigDecimal dimScore;
/**
* 本维度额外加分
*/
@ExcelProperty(value = "本维度额外加分")
private BigDecimal bonus;
/**
* 本维度额外扣分
*/
@ExcelProperty(value = "本维度额外扣分")
private BigDecimal penalty;
/**
* 评分公式(从模板快照)
*/
@ExcelProperty(value = "评分公式(从模板快照)")
private String scoreFormula;
/**
* 评分规则(从模板快照)
*/
@ExcelProperty(value = "评分规则(从模板快照)")
private String scoreRule;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,116 @@
package com.klp.perf.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 月度绩效考核记录视图对象 perf_appraisal
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfAppraisalVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联现有员工表主键
*/
@ExcelProperty(value = "关联现有员工表主键")
private Long employeeId;
/**
* 关联 perf_dept.id
*/
@ExcelProperty(value = "关联 perf_dept.id")
private Long deptId;
/**
* 关联 perf_position_template.id (当月使用的模板)
*/
@ExcelProperty(value = "关联 perf_position_template.id (当月使用的模板)")
private Long templateId;
/**
* 考核周期 YYYY-MM
*/
@ExcelProperty(value = "考核周期 YYYY-MM")
private String period;
/**
* 加权得分 = SUM(维度得分)
*/
@ExcelProperty(value = "加权得分 = SUM(维度得分)")
private BigDecimal weightedScore;
/**
* 总加分
*/
@ExcelProperty(value = "总加分")
private BigDecimal bonusScore;
/**
* 总扣分
*/
@ExcelProperty(value = "总扣分")
private BigDecimal penaltyScore;
/**
* 最终得分 = MIN(120, 加权得分+加分-扣分)
*/
@ExcelProperty(value = "最终得分 = MIN(120, 加权得分+加分-扣分)")
private BigDecimal finalScore;
/**
* 评级 S/A/B/C/D
*/
@ExcelProperty(value = "评级 S/A/B/C/D")
private String grade;
/**
* 绩效系数(线性插值换算,自动同步到岗位系数)
*/
@ExcelProperty(value = "绩效系数(线性插值换算,自动同步到岗位系数)")
private BigDecimal perfCoeff;
/**
* 0=草稿 1=已确认 2=已归档
*/
@ExcelProperty(value = "0=草稿 1=已确认 2=已归档")
private Long status;
/**
*
*/
@ExcelProperty(value = "")
private Date confirmedAt;
/**
* 确认人
*/
@ExcelProperty(value = "确认人")
private Long confirmedBy;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,78 @@
package com.klp.perf.domain.vo;
import java.math.BigDecimal;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 绩效系数换算视图对象 perf_coeff_range
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfCoeffRangeVo {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@ExcelProperty(value = "主键")
private Long id;
/**
* 等级标识 S/A/B/C/D
*/
@ExcelProperty(value = "等级标识 S/A/B/C/D")
private String grade;
/**
* 等级名称 卓越/优秀/合格/待改进/不合格
*/
@ExcelProperty(value = "等级名称 卓越/优秀/合格/待改进/不合格")
private String gradeLabel;
/**
* 得分下限(含)
*/
@ExcelProperty(value = "得分下限(含)")
private BigDecimal scoreMin;
/**
* 得分上限(含)
*/
@ExcelProperty(value = "得分上限(含)")
private BigDecimal scoreMax;
/**
* 最低绩效系数
*/
@ExcelProperty(value = "最低绩效系数")
private BigDecimal coeffMin;
/**
* 最高绩效系数
*/
@ExcelProperty(value = "最高绩效系数")
private BigDecimal coeffMax;
/**
* 排序(高→低)
*/
@ExcelProperty(value = "排序(高→低)")
private Long sortOrder;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,110 @@
package com.klp.perf.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 车间考核参数配置视图对象 perf_dept_config
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfDeptConfigVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联 perf_dept.id
*/
@ExcelProperty(value = "关联 perf_dept.id")
private Long deptId;
/**
* 月产量目标(吨) 或 月产长度目标(m)
*/
@ExcelProperty(value = "月产量目标(吨) 或 月产长度目标(m)")
private BigDecimal monthlyProductionTarget;
/**
* 产量单位: 吨 / m
*/
@ExcelProperty(value = "产量单位: 吨 / m")
private String productionUnit;
/**
* 绩效吨钢(元) 或 绩效米钢(元)
*/
@ExcelProperty(value = "绩效吨钢(元) 或 绩效米钢(元)")
private BigDecimal perfUnitPrice;
/**
* 生产班数
*/
@ExcelProperty(value = "生产班数")
private Long productionShifts;
/**
* 停机保底班数
*/
@ExcelProperty(value = "停机保底班数")
private Long guaranteedShifts;
/**
* 车间系数(默认1.0)
*/
@ExcelProperty(value = "车间系数(默认1.0)")
private BigDecimal deptCoeff;
/**
* 薪资模式: 0=普通模式 1=保底模式(hasBaoSalary)
*/
@ExcelProperty(value = "薪资模式: 0=普通模式 1=保底模式(hasBaoSalary)")
private Long salaryMode;
/**
* 保底薪资除数(底薪÷60=保底每班金额)
*/
@ExcelProperty(value = "保底薪资除数(底薪÷60=保底每班金额)")
private Long baseDivisor;
/**
* 月份
*/
@ExcelProperty(value = "月份")
private Date month;
/**
*
*/
@ExcelProperty(value = "")
private String remark;
/**
*
*/
@ExcelProperty(value = "")
private Date createdAt;
/**
*
*/
@ExcelProperty(value = "")
private Date updatedAt;
}

View File

@@ -0,0 +1,73 @@
package com.klp.perf.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 车间扣款/奖励项目配置视图对象 perf_dept_item_config
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfDeptItemConfigVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联 perf_dept.id
*/
@ExcelProperty(value = "关联 perf_dept.id")
private Long deptId;
/**
* 类型: 1=扣款项目 2=奖励项目
*/
@ExcelProperty(value = "类型: 1=扣款项目 2=奖励项目")
private Long itemType;
/**
* 项目名称 如:质量扣款/节能奖励
*/
@ExcelProperty(value = "项目名称 如:质量扣款/节能奖励")
private String itemName;
/**
*
*/
@ExcelProperty(value = "")
private Long sortOrder;
/**
* 月份
*/
@ExcelProperty(value = "月份")
private Date month;
/**
*
*/
@ExcelProperty(value = "")
private Long isEnabled;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,132 @@
package com.klp.perf.domain.vo;
import java.math.BigDecimal;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 车间月度汇总视图对象 perf_dept_summary
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfDeptSummaryVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联 perf_dept.id
*/
@ExcelProperty(value = "关联 perf_dept.id")
private Long deptId;
/**
* 周期 YYYY-MM
*/
@ExcelProperty(value = "周期 YYYY-MM")
private String period;
/**
* 总人数
*/
@ExcelProperty(value = "总人数")
private Long totalEmployees;
/**
* 系数总计(所有人员总系数之和)
*/
@ExcelProperty(value = "系数总计(所有人员总系数之和)")
private BigDecimal totalCoeffSum;
/**
* 平均考核得分
*/
@ExcelProperty(value = "平均考核得分")
private BigDecimal avgPerfScore;
/**
* 平均绩效系数
*/
@ExcelProperty(value = "平均绩效系数")
private BigDecimal avgPerfCoeff;
/**
* 底薪合计
*/
@ExcelProperty(value = "底薪合计")
private BigDecimal totalBaseSalary;
/**
* 月度绩效工资合计
*/
@ExcelProperty(value = "月度绩效工资合计")
private BigDecimal totalPerfWage;
/**
* 扣款合计
*/
@ExcelProperty(value = "扣款合计")
private BigDecimal totalDeductions;
/**
* 奖励合计
*/
@ExcelProperty(value = "奖励合计")
private BigDecimal totalBonuses;
/**
* 其他合计
*/
@ExcelProperty(value = "其他合计")
private BigDecimal totalOther;
/**
* 实领薪资合计
*/
@ExcelProperty(value = "实领薪资合计")
private BigDecimal totalActualSalary;
/**
* 人均实领薪资
*/
@ExcelProperty(value = "人均实领薪资")
private BigDecimal avgActualSalary;
/**
* 当月实际产量
*/
@ExcelProperty(value = "当月实际产量")
private BigDecimal monthlyProduction;
/**
* 系数单价(自动计算) = 月产量×绩效吨钢/系数总计
*/
@ExcelProperty(value = "系数单价(自动计算) = 月产量×绩效吨钢/系数总计")
private BigDecimal unitPrice;
/**
* 0=草稿 1=已确认
*/
@ExcelProperty(value = "0=草稿 1=已确认")
private Long status;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,60 @@
package com.klp.perf.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 绩效系统部门视图对象 perf_dept
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfDeptVo {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@ExcelProperty(value = "主键")
private Long id;
/**
* 部门/车间名称 如:酸轧车间/技术部
*/
@ExcelProperty(value = "部门/车间名称 如:酸轧车间/技术部")
private String deptName;
/**
* 排序
*/
@ExcelProperty(value = "排序")
private Long orderNum;
/**
* 是否有保底薪资模式 0=否 1=是
*/
@ExcelProperty(value = "是否有保底薪资模式 0=否 1=是")
private Integer hasBaoSalary;
/**
* 状态0正常 1停用
*/
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "0=正常,1=停用")
private String status;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,78 @@
package com.klp.perf.domain.vo;
import java.math.BigDecimal;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 员工绩效薪资基本信息视图对象 perf_employee_info
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfEmployeeInfoVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联现有员工表主键
*/
@ExcelProperty(value = "关联现有员工表主键")
private Long employeeId;
/**
* 关联 perf_dept.id (冗余,便于按部门查询)
*/
@ExcelProperty(value = "关联 perf_dept.id (冗余,便于按部门查询)")
private Long deptId;
/**
* 岗位/工种
*/
@ExcelProperty(value = "岗位/工种")
private String positionName;
/**
* 底薪(元)
*/
@ExcelProperty(value = "底薪(元)")
private BigDecimal baseSalary;
/**
* 岗位绩效基数(元), 默认≈底薪×20%
*/
@ExcelProperty(value = "岗位绩效基数(元), 默认≈底薪×20%")
private BigDecimal perfBase;
/**
* 默认岗位系数(初始值,后续月度由绩效自动覆盖)
*/
@ExcelProperty(value = "默认岗位系数(初始值,后续月度由绩效自动覆盖)")
private BigDecimal posCoeffDefault;
/**
* 是否在职 1=在职 0=离职
*/
@ExcelProperty(value = "是否在职 1=在职 0=离职")
private Long isActive;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,59 @@
package com.klp.perf.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 岗位绩效考核模板视图对象 perf_position_template
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfPositionTemplateVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联 perf_dept.id
*/
@ExcelProperty(value = "关联 perf_dept.id")
private Long deptId;
/**
* 岗位名称 (与员工表岗位字段匹配)
*/
@ExcelProperty(value = "岗位名称 (与员工表岗位字段匹配)")
private String positionName;
/**
* 模板标题 如:轧机主操绩效考核评分表
*/
@ExcelProperty(value = "模板标题 如:轧机主操绩效考核评分表")
private String title;
/**
*
*/
@ExcelProperty(value = "")
private Long isEnabled;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,212 @@
package com.klp.perf.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 月度薪资计算记录视图对象 perf_salary
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfSalaryVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联现有员工表主键
*/
@ExcelProperty(value = "关联现有员工表主键")
private Long employeeId;
/**
* 关联 perf_dept.id
*/
@ExcelProperty(value = "关联 perf_dept.id")
private Long deptId;
/**
* 关联 perf_appraisal.id (可为空=未考核)
*/
@ExcelProperty(value = "关联 perf_appraisal.id (可为空=未考核)")
private Long appraisalId;
/**
* 薪资周期 YYYY-MM
*/
@ExcelProperty(value = "薪资周期 YYYY-MM")
private String period;
/**
* 底薪
*/
@ExcelProperty(value = "底薪")
private BigDecimal baseSalary;
/**
* 岗位绩效基数
*/
@ExcelProperty(value = "岗位绩效基数")
private BigDecimal perfBase;
/**
* 考核得分(关联 perf_appraisal.final_score)
*/
@ExcelProperty(value = "考核得分(关联 perf_appraisal.final_score)")
private BigDecimal perfScore;
/**
* 绩效系数(得分换算,关联 perf_appraisal.perf_coeff)
*/
@ExcelProperty(value = "绩效系数(得分换算,关联 perf_appraisal.perf_coeff)")
private BigDecimal perfCoeff;
/**
* 车间系数(来自 perf_dept_config.dept_coeff)
*/
@ExcelProperty(value = "车间系数(来自 perf_dept_config.dept_coeff)")
private BigDecimal deptCoeff;
/**
* 月度绩效工资 = perf_base × perf_coeff × dept_coeff
*/
@ExcelProperty(value = "月度绩效工资 = perf_base × perf_coeff × dept_coeff")
private BigDecimal perfWage;
/**
* 岗位系数 (=绩效系数,自动同步)
*/
@ExcelProperty(value = "岗位系数 (=绩效系数,自动同步)")
private BigDecimal posCoeff;
/**
* 固定系数 = pos_coeff × 0.7
*/
@ExcelProperty(value = "固定系数 = pos_coeff × 0.7")
private BigDecimal fixedCoeff;
/**
* 可调系数(手动覆盖,默认=pos_coeff×0.3)
*/
@ExcelProperty(value = "可调系数(手动覆盖,默认=pos_coeff×0.3)")
private BigDecimal adjCoeff;
/**
* 可调系数是否手动覆盖: 0=自动 1=手动
*/
@ExcelProperty(value = "可调系数是否手动覆盖: 0=自动 1=手动")
private Long adjCoeffManual;
/**
* 总系数 = fixed_coeff + adj_coeff
*/
@ExcelProperty(value = "总系数 = fixed_coeff + adj_coeff")
private BigDecimal totalCoeff;
/**
* 扣款明细 {"质量扣款":0,"倒卷扣款":0,"客诉扣款":0,...}
*/
@ExcelProperty(value = "扣款明细")
private String deductionsJson;
/**
* 扣款合计
*/
@ExcelProperty(value = "扣款合计")
private BigDecimal deductionsTotal;
/**
* 奖励明细 {"节能奖励":0,...}
*/
@ExcelProperty(value = "奖励明细")
private String bonusesJson;
/**
* 奖励合计
*/
@ExcelProperty(value = "奖励合计")
private BigDecimal bonusesTotal;
/**
* 其他金额
*/
@ExcelProperty(value = "其他金额")
private BigDecimal otherAmount;
/**
* 实领薪资 = 底薪+月度绩效工资-扣款合计+奖励合计+其他
*/
@ExcelProperty(value = "实领薪资 = 底薪+月度绩效工资-扣款合计+奖励合计+其他")
private BigDecimal actualSalary;
/**
* 固定系数薪资(参考) = fixed_coeff × 系数单价
*/
@ExcelProperty(value = "固定系数薪资(参考) = fixed_coeff × 系数单价")
private BigDecimal fixedSalaryRef;
/**
* 可调系数薪资(参考) = adj_coeff × 系数单价
*/
@ExcelProperty(value = "可调系数薪资(参考) = adj_coeff × 系数单价")
private BigDecimal adjSalaryRef;
/**
* 保底每班(参考) = base_salary / 60
*/
@ExcelProperty(value = "保底每班(参考) = base_salary / 60")
private BigDecimal baoPerShiftRef;
/**
* 保底薪资(参考) = bao_per_shift × 保底班数
*/
@ExcelProperty(value = "保底薪资(参考) = bao_per_shift × 保底班数")
private BigDecimal baoSalaryRef;
/**
* 合计薪资(参考) = fixed_salary_ref+adj_salary_ref+bao_salary_ref
*/
@ExcelProperty(value = "合计薪资(参考) = fixed_salary_ref+adj_salary_ref+bao_salary_ref")
private BigDecimal totalSalaryRef;
/**
* 0=草稿 1=已确认 2=已归档
*/
@ExcelProperty(value = "0=草稿 1=已确认 2=已归档")
private Long status;
/**
*
*/
@ExcelProperty(value = "")
private Date confirmedAt;
/**
*
*/
@ExcelProperty(value = "")
private Long confirmedBy;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,89 @@
package com.klp.perf.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.klp.common.annotation.ExcelDictFormat;
import com.klp.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 考核维度明细视图对象 perf_template_dimension
*
* @author klp
* @date 2026-07-07
*/
@Data
@ExcelIgnoreUnannotated
public class PerfTemplateDimensionVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联 perf_position_template.id
*/
@ExcelProperty(value = "关联 perf_position_template.id")
private Long templateId;
/**
* 序号
*/
@ExcelProperty(value = "序号")
private String seq;
/**
* 考核维度 如:产量/质量/安全/检测准确性
*/
@ExcelProperty(value = "考核维度 如:产量/质量/安全/检测准确性")
private String dimName;
/**
* 权重 如:40% 或 0.4
*/
@ExcelProperty(value = "权重 如:40% 或 0.4")
private String weight;
/**
* 量化指标 如:月产量达标率/产品合格率
*/
@ExcelProperty(value = "量化指标 如:月产量达标率/产品合格率")
private String indicator;
/**
* 目标值 如:≥98% / 100% / 0次 / 达标
*/
@ExcelProperty(value = "目标值 如:≥98% / 100% / 0次 / 达标")
private String targetValue;
/**
* 评分公式 如:=IF(E4>0,25*(F4/E4),0)
*/
@ExcelProperty(value = "评分公式 如:=IF(E4>0,25*(F4/E4),0)")
private String scoreFormula;
/**
* 评分规则文字描述
*/
@ExcelProperty(value = "评分规则文字描述")
private String scoreRule;
/**
*
*/
@ExcelProperty(value = "")
private Long isEnabled;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfAppraisalDetail;
import com.klp.perf.domain.vo.PerfAppraisalDetailVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 考核维度评分明细Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfAppraisalDetailMapper extends BaseMapperPlus<PerfAppraisalDetailMapper, PerfAppraisalDetail, PerfAppraisalDetailVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfAppraisal;
import com.klp.perf.domain.vo.PerfAppraisalVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 月度绩效考核记录Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfAppraisalMapper extends BaseMapperPlus<PerfAppraisalMapper, PerfAppraisal, PerfAppraisalVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfCoeffRange;
import com.klp.perf.domain.vo.PerfCoeffRangeVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 绩效系数换算Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfCoeffRangeMapper extends BaseMapperPlus<PerfCoeffRangeMapper, PerfCoeffRange, PerfCoeffRangeVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfDeptConfig;
import com.klp.perf.domain.vo.PerfDeptConfigVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 车间考核参数配置Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfDeptConfigMapper extends BaseMapperPlus<PerfDeptConfigMapper, PerfDeptConfig, PerfDeptConfigVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfDeptItemConfig;
import com.klp.perf.domain.vo.PerfDeptItemConfigVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 车间扣款/奖励项目配置Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfDeptItemConfigMapper extends BaseMapperPlus<PerfDeptItemConfigMapper, PerfDeptItemConfig, PerfDeptItemConfigVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfDept;
import com.klp.perf.domain.vo.PerfDeptVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 绩效系统部门Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfDeptMapper extends BaseMapperPlus<PerfDeptMapper, PerfDept, PerfDeptVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfDeptSummary;
import com.klp.perf.domain.vo.PerfDeptSummaryVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 车间月度汇总Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfDeptSummaryMapper extends BaseMapperPlus<PerfDeptSummaryMapper, PerfDeptSummary, PerfDeptSummaryVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfEmployeeInfo;
import com.klp.perf.domain.vo.PerfEmployeeInfoVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 员工绩效薪资基本信息Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfEmployeeInfoMapper extends BaseMapperPlus<PerfEmployeeInfoMapper, PerfEmployeeInfo, PerfEmployeeInfoVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfPositionTemplate;
import com.klp.perf.domain.vo.PerfPositionTemplateVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 岗位绩效考核模板Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfPositionTemplateMapper extends BaseMapperPlus<PerfPositionTemplateMapper, PerfPositionTemplate, PerfPositionTemplateVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfSalary;
import com.klp.perf.domain.vo.PerfSalaryVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 月度薪资计算记录Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfSalaryMapper extends BaseMapperPlus<PerfSalaryMapper, PerfSalary, PerfSalaryVo> {
}

View File

@@ -0,0 +1,15 @@
package com.klp.perf.mapper;
import com.klp.perf.domain.PerfTemplateDimension;
import com.klp.perf.domain.vo.PerfTemplateDimensionVo;
import com.klp.common.core.mapper.BaseMapperPlus;
/**
* 考核维度明细Mapper接口
*
* @author klp
* @date 2026-07-07
*/
public interface PerfTemplateDimensionMapper extends BaseMapperPlus<PerfTemplateDimensionMapper, PerfTemplateDimension, PerfTemplateDimensionVo> {
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfAppraisalDetail;
import com.klp.perf.domain.vo.PerfAppraisalDetailVo;
import com.klp.perf.domain.bo.PerfAppraisalDetailBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 考核维度评分明细Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfAppraisalDetailService {
/**
* 查询考核维度评分明细
*/
PerfAppraisalDetailVo queryById(Long id);
/**
* 查询考核维度评分明细列表
*/
TableDataInfo<PerfAppraisalDetailVo> queryPageList(PerfAppraisalDetailBo bo, PageQuery pageQuery);
/**
* 查询考核维度评分明细列表
*/
List<PerfAppraisalDetailVo> queryList(PerfAppraisalDetailBo bo);
/**
* 新增考核维度评分明细
*/
Boolean insertByBo(PerfAppraisalDetailBo bo);
/**
* 修改考核维度评分明细
*/
Boolean updateByBo(PerfAppraisalDetailBo bo);
/**
* 校验并批量删除考核维度评分明细信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfAppraisal;
import com.klp.perf.domain.vo.PerfAppraisalVo;
import com.klp.perf.domain.bo.PerfAppraisalBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 月度绩效考核记录Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfAppraisalService {
/**
* 查询月度绩效考核记录
*/
PerfAppraisalVo queryById(Long id);
/**
* 查询月度绩效考核记录列表
*/
TableDataInfo<PerfAppraisalVo> queryPageList(PerfAppraisalBo bo, PageQuery pageQuery);
/**
* 查询月度绩效考核记录列表
*/
List<PerfAppraisalVo> queryList(PerfAppraisalBo bo);
/**
* 新增月度绩效考核记录
*/
Boolean insertByBo(PerfAppraisalBo bo);
/**
* 修改月度绩效考核记录
*/
Boolean updateByBo(PerfAppraisalBo bo);
/**
* 校验并批量删除月度绩效考核记录信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfCoeffRange;
import com.klp.perf.domain.vo.PerfCoeffRangeVo;
import com.klp.perf.domain.bo.PerfCoeffRangeBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 绩效系数换算Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfCoeffRangeService {
/**
* 查询绩效系数换算
*/
PerfCoeffRangeVo queryById(Long id);
/**
* 查询绩效系数换算列表
*/
TableDataInfo<PerfCoeffRangeVo> queryPageList(PerfCoeffRangeBo bo, PageQuery pageQuery);
/**
* 查询绩效系数换算列表
*/
List<PerfCoeffRangeVo> queryList(PerfCoeffRangeBo bo);
/**
* 新增绩效系数换算
*/
Boolean insertByBo(PerfCoeffRangeBo bo);
/**
* 修改绩效系数换算
*/
Boolean updateByBo(PerfCoeffRangeBo bo);
/**
* 校验并批量删除绩效系数换算信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfDeptConfig;
import com.klp.perf.domain.vo.PerfDeptConfigVo;
import com.klp.perf.domain.bo.PerfDeptConfigBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 车间考核参数配置Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfDeptConfigService {
/**
* 查询车间考核参数配置
*/
PerfDeptConfigVo queryById(Long id);
/**
* 查询车间考核参数配置列表
*/
TableDataInfo<PerfDeptConfigVo> queryPageList(PerfDeptConfigBo bo, PageQuery pageQuery);
/**
* 查询车间考核参数配置列表
*/
List<PerfDeptConfigVo> queryList(PerfDeptConfigBo bo);
/**
* 新增车间考核参数配置
*/
Boolean insertByBo(PerfDeptConfigBo bo);
/**
* 修改车间考核参数配置
*/
Boolean updateByBo(PerfDeptConfigBo bo);
/**
* 校验并批量删除车间考核参数配置信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfDeptItemConfig;
import com.klp.perf.domain.vo.PerfDeptItemConfigVo;
import com.klp.perf.domain.bo.PerfDeptItemConfigBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 车间扣款/奖励项目配置Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfDeptItemConfigService {
/**
* 查询车间扣款/奖励项目配置
*/
PerfDeptItemConfigVo queryById(Long id);
/**
* 查询车间扣款/奖励项目配置列表
*/
TableDataInfo<PerfDeptItemConfigVo> queryPageList(PerfDeptItemConfigBo bo, PageQuery pageQuery);
/**
* 查询车间扣款/奖励项目配置列表
*/
List<PerfDeptItemConfigVo> queryList(PerfDeptItemConfigBo bo);
/**
* 新增车间扣款/奖励项目配置
*/
Boolean insertByBo(PerfDeptItemConfigBo bo);
/**
* 修改车间扣款/奖励项目配置
*/
Boolean updateByBo(PerfDeptItemConfigBo bo);
/**
* 校验并批量删除车间扣款/奖励项目配置信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfDept;
import com.klp.perf.domain.vo.PerfDeptVo;
import com.klp.perf.domain.bo.PerfDeptBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 绩效系统部门Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfDeptService {
/**
* 查询绩效系统部门
*/
PerfDeptVo queryById(Long id);
/**
* 查询绩效系统部门列表
*/
TableDataInfo<PerfDeptVo> queryPageList(PerfDeptBo bo, PageQuery pageQuery);
/**
* 查询绩效系统部门列表
*/
List<PerfDeptVo> queryList(PerfDeptBo bo);
/**
* 新增绩效系统部门
*/
Boolean insertByBo(PerfDeptBo bo);
/**
* 修改绩效系统部门
*/
Boolean updateByBo(PerfDeptBo bo);
/**
* 校验并批量删除绩效系统部门信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfDeptSummary;
import com.klp.perf.domain.vo.PerfDeptSummaryVo;
import com.klp.perf.domain.bo.PerfDeptSummaryBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 车间月度汇总Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfDeptSummaryService {
/**
* 查询车间月度汇总
*/
PerfDeptSummaryVo queryById(Long id);
/**
* 查询车间月度汇总列表
*/
TableDataInfo<PerfDeptSummaryVo> queryPageList(PerfDeptSummaryBo bo, PageQuery pageQuery);
/**
* 查询车间月度汇总列表
*/
List<PerfDeptSummaryVo> queryList(PerfDeptSummaryBo bo);
/**
* 新增车间月度汇总
*/
Boolean insertByBo(PerfDeptSummaryBo bo);
/**
* 修改车间月度汇总
*/
Boolean updateByBo(PerfDeptSummaryBo bo);
/**
* 校验并批量删除车间月度汇总信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfEmployeeInfo;
import com.klp.perf.domain.vo.PerfEmployeeInfoVo;
import com.klp.perf.domain.bo.PerfEmployeeInfoBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 员工绩效薪资基本信息Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfEmployeeInfoService {
/**
* 查询员工绩效薪资基本信息
*/
PerfEmployeeInfoVo queryById(Long id);
/**
* 查询员工绩效薪资基本信息列表
*/
TableDataInfo<PerfEmployeeInfoVo> queryPageList(PerfEmployeeInfoBo bo, PageQuery pageQuery);
/**
* 查询员工绩效薪资基本信息列表
*/
List<PerfEmployeeInfoVo> queryList(PerfEmployeeInfoBo bo);
/**
* 新增员工绩效薪资基本信息
*/
Boolean insertByBo(PerfEmployeeInfoBo bo);
/**
* 修改员工绩效薪资基本信息
*/
Boolean updateByBo(PerfEmployeeInfoBo bo);
/**
* 校验并批量删除员工绩效薪资基本信息信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfPositionTemplate;
import com.klp.perf.domain.vo.PerfPositionTemplateVo;
import com.klp.perf.domain.bo.PerfPositionTemplateBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 岗位绩效考核模板Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfPositionTemplateService {
/**
* 查询岗位绩效考核模板
*/
PerfPositionTemplateVo queryById(Long id);
/**
* 查询岗位绩效考核模板列表
*/
TableDataInfo<PerfPositionTemplateVo> queryPageList(PerfPositionTemplateBo bo, PageQuery pageQuery);
/**
* 查询岗位绩效考核模板列表
*/
List<PerfPositionTemplateVo> queryList(PerfPositionTemplateBo bo);
/**
* 新增岗位绩效考核模板
*/
Boolean insertByBo(PerfPositionTemplateBo bo);
/**
* 修改岗位绩效考核模板
*/
Boolean updateByBo(PerfPositionTemplateBo bo);
/**
* 校验并批量删除岗位绩效考核模板信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfSalary;
import com.klp.perf.domain.vo.PerfSalaryVo;
import com.klp.perf.domain.bo.PerfSalaryBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 月度薪资计算记录Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfSalaryService {
/**
* 查询月度薪资计算记录
*/
PerfSalaryVo queryById(Long id);
/**
* 查询月度薪资计算记录列表
*/
TableDataInfo<PerfSalaryVo> queryPageList(PerfSalaryBo bo, PageQuery pageQuery);
/**
* 查询月度薪资计算记录列表
*/
List<PerfSalaryVo> queryList(PerfSalaryBo bo);
/**
* 新增月度薪资计算记录
*/
Boolean insertByBo(PerfSalaryBo bo);
/**
* 修改月度薪资计算记录
*/
Boolean updateByBo(PerfSalaryBo bo);
/**
* 校验并批量删除月度薪资计算记录信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,49 @@
package com.klp.perf.service;
import com.klp.perf.domain.PerfTemplateDimension;
import com.klp.perf.domain.vo.PerfTemplateDimensionVo;
import com.klp.perf.domain.bo.PerfTemplateDimensionBo;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 考核维度明细Service接口
*
* @author klp
* @date 2026-07-07
*/
public interface IPerfTemplateDimensionService {
/**
* 查询考核维度明细
*/
PerfTemplateDimensionVo queryById(Long id);
/**
* 查询考核维度明细列表
*/
TableDataInfo<PerfTemplateDimensionVo> queryPageList(PerfTemplateDimensionBo bo, PageQuery pageQuery);
/**
* 查询考核维度明细列表
*/
List<PerfTemplateDimensionVo> queryList(PerfTemplateDimensionBo bo);
/**
* 新增考核维度明细
*/
Boolean insertByBo(PerfTemplateDimensionBo bo);
/**
* 修改考核维度明细
*/
Boolean updateByBo(PerfTemplateDimensionBo bo);
/**
* 校验并批量删除考核维度明细信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@@ -0,0 +1,120 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfAppraisalDetailBo;
import com.klp.perf.domain.vo.PerfAppraisalDetailVo;
import com.klp.perf.domain.PerfAppraisalDetail;
import com.klp.perf.mapper.PerfAppraisalDetailMapper;
import com.klp.perf.service.IPerfAppraisalDetailService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 考核维度评分明细Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfAppraisalDetailServiceImpl implements IPerfAppraisalDetailService {
private final PerfAppraisalDetailMapper baseMapper;
/**
* 查询考核维度评分明细
*/
@Override
public PerfAppraisalDetailVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询考核维度评分明细列表
*/
@Override
public TableDataInfo<PerfAppraisalDetailVo> queryPageList(PerfAppraisalDetailBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfAppraisalDetail> lqw = buildQueryWrapper(bo);
Page<PerfAppraisalDetailVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询考核维度评分明细列表
*/
@Override
public List<PerfAppraisalDetailVo> queryList(PerfAppraisalDetailBo bo) {
LambdaQueryWrapper<PerfAppraisalDetail> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfAppraisalDetail> buildQueryWrapper(PerfAppraisalDetailBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfAppraisalDetail> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getAppraisalId() != null, PerfAppraisalDetail::getAppraisalId, bo.getAppraisalId());
lqw.eq(bo.getDimensionId() != null, PerfAppraisalDetail::getDimensionId, bo.getDimensionId());
lqw.eq(StringUtils.isNotBlank(bo.getSeq()), PerfAppraisalDetail::getSeq, bo.getSeq());
lqw.like(StringUtils.isNotBlank(bo.getDimName()), PerfAppraisalDetail::getDimName, bo.getDimName());
lqw.eq(StringUtils.isNotBlank(bo.getWeight()), PerfAppraisalDetail::getWeight, bo.getWeight());
lqw.eq(StringUtils.isNotBlank(bo.getTargetValue()), PerfAppraisalDetail::getTargetValue, bo.getTargetValue());
lqw.eq(StringUtils.isNotBlank(bo.getActualValue()), PerfAppraisalDetail::getActualValue, bo.getActualValue());
lqw.eq(bo.getDimScore() != null, PerfAppraisalDetail::getDimScore, bo.getDimScore());
lqw.eq(bo.getBonus() != null, PerfAppraisalDetail::getBonus, bo.getBonus());
lqw.eq(bo.getPenalty() != null, PerfAppraisalDetail::getPenalty, bo.getPenalty());
lqw.eq(StringUtils.isNotBlank(bo.getScoreFormula()), PerfAppraisalDetail::getScoreFormula, bo.getScoreFormula());
lqw.eq(StringUtils.isNotBlank(bo.getScoreRule()), PerfAppraisalDetail::getScoreRule, bo.getScoreRule());
return lqw;
}
/**
* 新增考核维度评分明细
*/
@Override
public Boolean insertByBo(PerfAppraisalDetailBo bo) {
PerfAppraisalDetail add = BeanUtil.toBean(bo, PerfAppraisalDetail.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改考核维度评分明细
*/
@Override
public Boolean updateByBo(PerfAppraisalDetailBo bo) {
PerfAppraisalDetail update = BeanUtil.toBean(bo, PerfAppraisalDetail.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfAppraisalDetail entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除考核维度评分明细
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,121 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfAppraisalBo;
import com.klp.perf.domain.vo.PerfAppraisalVo;
import com.klp.perf.domain.PerfAppraisal;
import com.klp.perf.mapper.PerfAppraisalMapper;
import com.klp.perf.service.IPerfAppraisalService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 月度绩效考核记录Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfAppraisalServiceImpl implements IPerfAppraisalService {
private final PerfAppraisalMapper baseMapper;
/**
* 查询月度绩效考核记录
*/
@Override
public PerfAppraisalVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询月度绩效考核记录列表
*/
@Override
public TableDataInfo<PerfAppraisalVo> queryPageList(PerfAppraisalBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfAppraisal> lqw = buildQueryWrapper(bo);
Page<PerfAppraisalVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询月度绩效考核记录列表
*/
@Override
public List<PerfAppraisalVo> queryList(PerfAppraisalBo bo) {
LambdaQueryWrapper<PerfAppraisal> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfAppraisal> buildQueryWrapper(PerfAppraisalBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfAppraisal> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getEmployeeId() != null, PerfAppraisal::getEmployeeId, bo.getEmployeeId());
lqw.eq(bo.getDeptId() != null, PerfAppraisal::getDeptId, bo.getDeptId());
lqw.eq(bo.getTemplateId() != null, PerfAppraisal::getTemplateId, bo.getTemplateId());
lqw.eq(StringUtils.isNotBlank(bo.getPeriod()), PerfAppraisal::getPeriod, bo.getPeriod());
lqw.eq(bo.getWeightedScore() != null, PerfAppraisal::getWeightedScore, bo.getWeightedScore());
lqw.eq(bo.getBonusScore() != null, PerfAppraisal::getBonusScore, bo.getBonusScore());
lqw.eq(bo.getPenaltyScore() != null, PerfAppraisal::getPenaltyScore, bo.getPenaltyScore());
lqw.eq(bo.getFinalScore() != null, PerfAppraisal::getFinalScore, bo.getFinalScore());
lqw.eq(StringUtils.isNotBlank(bo.getGrade()), PerfAppraisal::getGrade, bo.getGrade());
lqw.eq(bo.getPerfCoeff() != null, PerfAppraisal::getPerfCoeff, bo.getPerfCoeff());
lqw.eq(bo.getStatus() != null, PerfAppraisal::getStatus, bo.getStatus());
lqw.eq(bo.getConfirmedAt() != null, PerfAppraisal::getConfirmedAt, bo.getConfirmedAt());
lqw.eq(bo.getConfirmedBy() != null, PerfAppraisal::getConfirmedBy, bo.getConfirmedBy());
return lqw;
}
/**
* 新增月度绩效考核记录
*/
@Override
public Boolean insertByBo(PerfAppraisalBo bo) {
PerfAppraisal add = BeanUtil.toBean(bo, PerfAppraisal.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改月度绩效考核记录
*/
@Override
public Boolean updateByBo(PerfAppraisalBo bo) {
PerfAppraisal update = BeanUtil.toBean(bo, PerfAppraisal.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfAppraisal entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除月度绩效考核记录
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,115 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfCoeffRangeBo;
import com.klp.perf.domain.vo.PerfCoeffRangeVo;
import com.klp.perf.domain.PerfCoeffRange;
import com.klp.perf.mapper.PerfCoeffRangeMapper;
import com.klp.perf.service.IPerfCoeffRangeService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 绩效系数换算Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfCoeffRangeServiceImpl implements IPerfCoeffRangeService {
private final PerfCoeffRangeMapper baseMapper;
/**
* 查询绩效系数换算
*/
@Override
public PerfCoeffRangeVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询绩效系数换算列表
*/
@Override
public TableDataInfo<PerfCoeffRangeVo> queryPageList(PerfCoeffRangeBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfCoeffRange> lqw = buildQueryWrapper(bo);
Page<PerfCoeffRangeVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询绩效系数换算列表
*/
@Override
public List<PerfCoeffRangeVo> queryList(PerfCoeffRangeBo bo) {
LambdaQueryWrapper<PerfCoeffRange> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfCoeffRange> buildQueryWrapper(PerfCoeffRangeBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfCoeffRange> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getGrade()), PerfCoeffRange::getGrade, bo.getGrade());
lqw.eq(StringUtils.isNotBlank(bo.getGradeLabel()), PerfCoeffRange::getGradeLabel, bo.getGradeLabel());
lqw.eq(bo.getScoreMin() != null, PerfCoeffRange::getScoreMin, bo.getScoreMin());
lqw.eq(bo.getScoreMax() != null, PerfCoeffRange::getScoreMax, bo.getScoreMax());
lqw.eq(bo.getCoeffMin() != null, PerfCoeffRange::getCoeffMin, bo.getCoeffMin());
lqw.eq(bo.getCoeffMax() != null, PerfCoeffRange::getCoeffMax, bo.getCoeffMax());
lqw.eq(bo.getSortOrder() != null, PerfCoeffRange::getSortOrder, bo.getSortOrder());
return lqw;
}
/**
* 新增绩效系数换算
*/
@Override
public Boolean insertByBo(PerfCoeffRangeBo bo) {
PerfCoeffRange add = BeanUtil.toBean(bo, PerfCoeffRange.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改绩效系数换算
*/
@Override
public Boolean updateByBo(PerfCoeffRangeBo bo) {
PerfCoeffRange update = BeanUtil.toBean(bo, PerfCoeffRange.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfCoeffRange entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除绩效系数换算
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,120 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfDeptConfigBo;
import com.klp.perf.domain.vo.PerfDeptConfigVo;
import com.klp.perf.domain.PerfDeptConfig;
import com.klp.perf.mapper.PerfDeptConfigMapper;
import com.klp.perf.service.IPerfDeptConfigService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 车间考核参数配置Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfDeptConfigServiceImpl implements IPerfDeptConfigService {
private final PerfDeptConfigMapper baseMapper;
/**
* 查询车间考核参数配置
*/
@Override
public PerfDeptConfigVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询车间考核参数配置列表
*/
@Override
public TableDataInfo<PerfDeptConfigVo> queryPageList(PerfDeptConfigBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfDeptConfig> lqw = buildQueryWrapper(bo);
Page<PerfDeptConfigVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询车间考核参数配置列表
*/
@Override
public List<PerfDeptConfigVo> queryList(PerfDeptConfigBo bo) {
LambdaQueryWrapper<PerfDeptConfig> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfDeptConfig> buildQueryWrapper(PerfDeptConfigBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfDeptConfig> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getDeptId() != null, PerfDeptConfig::getDeptId, bo.getDeptId());
lqw.eq(bo.getMonthlyProductionTarget() != null, PerfDeptConfig::getMonthlyProductionTarget, bo.getMonthlyProductionTarget());
lqw.eq(StringUtils.isNotBlank(bo.getProductionUnit()), PerfDeptConfig::getProductionUnit, bo.getProductionUnit());
lqw.eq(bo.getPerfUnitPrice() != null, PerfDeptConfig::getPerfUnitPrice, bo.getPerfUnitPrice());
lqw.eq(bo.getProductionShifts() != null, PerfDeptConfig::getProductionShifts, bo.getProductionShifts());
lqw.eq(bo.getGuaranteedShifts() != null, PerfDeptConfig::getGuaranteedShifts, bo.getGuaranteedShifts());
lqw.eq(bo.getDeptCoeff() != null, PerfDeptConfig::getDeptCoeff, bo.getDeptCoeff());
lqw.eq(bo.getSalaryMode() != null, PerfDeptConfig::getSalaryMode, bo.getSalaryMode());
lqw.eq(bo.getBaseDivisor() != null, PerfDeptConfig::getBaseDivisor, bo.getBaseDivisor());
lqw.eq(bo.getMonth() != null, PerfDeptConfig::getMonth, bo.getMonth());
lqw.eq(bo.getCreatedAt() != null, PerfDeptConfig::getCreatedAt, bo.getCreatedAt());
lqw.eq(bo.getUpdatedAt() != null, PerfDeptConfig::getUpdatedAt, bo.getUpdatedAt());
return lqw;
}
/**
* 新增车间考核参数配置
*/
@Override
public Boolean insertByBo(PerfDeptConfigBo bo) {
PerfDeptConfig add = BeanUtil.toBean(bo, PerfDeptConfig.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改车间考核参数配置
*/
@Override
public Boolean updateByBo(PerfDeptConfigBo bo) {
PerfDeptConfig update = BeanUtil.toBean(bo, PerfDeptConfig.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfDeptConfig entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除车间考核参数配置
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,114 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfDeptItemConfigBo;
import com.klp.perf.domain.vo.PerfDeptItemConfigVo;
import com.klp.perf.domain.PerfDeptItemConfig;
import com.klp.perf.mapper.PerfDeptItemConfigMapper;
import com.klp.perf.service.IPerfDeptItemConfigService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 车间扣款/奖励项目配置Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfDeptItemConfigServiceImpl implements IPerfDeptItemConfigService {
private final PerfDeptItemConfigMapper baseMapper;
/**
* 查询车间扣款/奖励项目配置
*/
@Override
public PerfDeptItemConfigVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询车间扣款/奖励项目配置列表
*/
@Override
public TableDataInfo<PerfDeptItemConfigVo> queryPageList(PerfDeptItemConfigBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfDeptItemConfig> lqw = buildQueryWrapper(bo);
Page<PerfDeptItemConfigVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询车间扣款/奖励项目配置列表
*/
@Override
public List<PerfDeptItemConfigVo> queryList(PerfDeptItemConfigBo bo) {
LambdaQueryWrapper<PerfDeptItemConfig> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfDeptItemConfig> buildQueryWrapper(PerfDeptItemConfigBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfDeptItemConfig> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getDeptId() != null, PerfDeptItemConfig::getDeptId, bo.getDeptId());
lqw.eq(bo.getItemType() != null, PerfDeptItemConfig::getItemType, bo.getItemType());
lqw.like(StringUtils.isNotBlank(bo.getItemName()), PerfDeptItemConfig::getItemName, bo.getItemName());
lqw.eq(bo.getSortOrder() != null, PerfDeptItemConfig::getSortOrder, bo.getSortOrder());
lqw.eq(bo.getMonth() != null, PerfDeptItemConfig::getMonth, bo.getMonth());
lqw.eq(bo.getIsEnabled() != null, PerfDeptItemConfig::getIsEnabled, bo.getIsEnabled());
return lqw;
}
/**
* 新增车间扣款/奖励项目配置
*/
@Override
public Boolean insertByBo(PerfDeptItemConfigBo bo) {
PerfDeptItemConfig add = BeanUtil.toBean(bo, PerfDeptItemConfig.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改车间扣款/奖励项目配置
*/
@Override
public Boolean updateByBo(PerfDeptItemConfigBo bo) {
PerfDeptItemConfig update = BeanUtil.toBean(bo, PerfDeptItemConfig.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfDeptItemConfig entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除车间扣款/奖励项目配置
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,112 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfDeptBo;
import com.klp.perf.domain.vo.PerfDeptVo;
import com.klp.perf.domain.PerfDept;
import com.klp.perf.mapper.PerfDeptMapper;
import com.klp.perf.service.IPerfDeptService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 绩效系统部门Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfDeptServiceImpl implements IPerfDeptService {
private final PerfDeptMapper baseMapper;
/**
* 查询绩效系统部门
*/
@Override
public PerfDeptVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询绩效系统部门列表
*/
@Override
public TableDataInfo<PerfDeptVo> queryPageList(PerfDeptBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfDept> lqw = buildQueryWrapper(bo);
Page<PerfDeptVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询绩效系统部门列表
*/
@Override
public List<PerfDeptVo> queryList(PerfDeptBo bo) {
LambdaQueryWrapper<PerfDept> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfDept> buildQueryWrapper(PerfDeptBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfDept> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getDeptName()), PerfDept::getDeptName, bo.getDeptName());
lqw.eq(bo.getOrderNum() != null, PerfDept::getOrderNum, bo.getOrderNum());
lqw.eq(bo.getHasBaoSalary() != null, PerfDept::getHasBaoSalary, bo.getHasBaoSalary());
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), PerfDept::getStatus, bo.getStatus());
return lqw;
}
/**
* 新增绩效系统部门
*/
@Override
public Boolean insertByBo(PerfDeptBo bo) {
PerfDept add = BeanUtil.toBean(bo, PerfDept.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改绩效系统部门
*/
@Override
public Boolean updateByBo(PerfDeptBo bo) {
PerfDept update = BeanUtil.toBean(bo, PerfDept.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfDept entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除绩效系统部门
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,124 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfDeptSummaryBo;
import com.klp.perf.domain.vo.PerfDeptSummaryVo;
import com.klp.perf.domain.PerfDeptSummary;
import com.klp.perf.mapper.PerfDeptSummaryMapper;
import com.klp.perf.service.IPerfDeptSummaryService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 车间月度汇总Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfDeptSummaryServiceImpl implements IPerfDeptSummaryService {
private final PerfDeptSummaryMapper baseMapper;
/**
* 查询车间月度汇总
*/
@Override
public PerfDeptSummaryVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询车间月度汇总列表
*/
@Override
public TableDataInfo<PerfDeptSummaryVo> queryPageList(PerfDeptSummaryBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfDeptSummary> lqw = buildQueryWrapper(bo);
Page<PerfDeptSummaryVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询车间月度汇总列表
*/
@Override
public List<PerfDeptSummaryVo> queryList(PerfDeptSummaryBo bo) {
LambdaQueryWrapper<PerfDeptSummary> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfDeptSummary> buildQueryWrapper(PerfDeptSummaryBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfDeptSummary> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getDeptId() != null, PerfDeptSummary::getDeptId, bo.getDeptId());
lqw.eq(StringUtils.isNotBlank(bo.getPeriod()), PerfDeptSummary::getPeriod, bo.getPeriod());
lqw.eq(bo.getTotalEmployees() != null, PerfDeptSummary::getTotalEmployees, bo.getTotalEmployees());
lqw.eq(bo.getTotalCoeffSum() != null, PerfDeptSummary::getTotalCoeffSum, bo.getTotalCoeffSum());
lqw.eq(bo.getAvgPerfScore() != null, PerfDeptSummary::getAvgPerfScore, bo.getAvgPerfScore());
lqw.eq(bo.getAvgPerfCoeff() != null, PerfDeptSummary::getAvgPerfCoeff, bo.getAvgPerfCoeff());
lqw.eq(bo.getTotalBaseSalary() != null, PerfDeptSummary::getTotalBaseSalary, bo.getTotalBaseSalary());
lqw.eq(bo.getTotalPerfWage() != null, PerfDeptSummary::getTotalPerfWage, bo.getTotalPerfWage());
lqw.eq(bo.getTotalDeductions() != null, PerfDeptSummary::getTotalDeductions, bo.getTotalDeductions());
lqw.eq(bo.getTotalBonuses() != null, PerfDeptSummary::getTotalBonuses, bo.getTotalBonuses());
lqw.eq(bo.getTotalOther() != null, PerfDeptSummary::getTotalOther, bo.getTotalOther());
lqw.eq(bo.getTotalActualSalary() != null, PerfDeptSummary::getTotalActualSalary, bo.getTotalActualSalary());
lqw.eq(bo.getAvgActualSalary() != null, PerfDeptSummary::getAvgActualSalary, bo.getAvgActualSalary());
lqw.eq(bo.getMonthlyProduction() != null, PerfDeptSummary::getMonthlyProduction, bo.getMonthlyProduction());
lqw.eq(bo.getUnitPrice() != null, PerfDeptSummary::getUnitPrice, bo.getUnitPrice());
lqw.eq(bo.getStatus() != null, PerfDeptSummary::getStatus, bo.getStatus());
return lqw;
}
/**
* 新增车间月度汇总
*/
@Override
public Boolean insertByBo(PerfDeptSummaryBo bo) {
PerfDeptSummary add = BeanUtil.toBean(bo, PerfDeptSummary.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改车间月度汇总
*/
@Override
public Boolean updateByBo(PerfDeptSummaryBo bo) {
PerfDeptSummary update = BeanUtil.toBean(bo, PerfDeptSummary.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfDeptSummary entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除车间月度汇总
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,115 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfEmployeeInfoBo;
import com.klp.perf.domain.vo.PerfEmployeeInfoVo;
import com.klp.perf.domain.PerfEmployeeInfo;
import com.klp.perf.mapper.PerfEmployeeInfoMapper;
import com.klp.perf.service.IPerfEmployeeInfoService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 员工绩效薪资基本信息Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfEmployeeInfoServiceImpl implements IPerfEmployeeInfoService {
private final PerfEmployeeInfoMapper baseMapper;
/**
* 查询员工绩效薪资基本信息
*/
@Override
public PerfEmployeeInfoVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询员工绩效薪资基本信息列表
*/
@Override
public TableDataInfo<PerfEmployeeInfoVo> queryPageList(PerfEmployeeInfoBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfEmployeeInfo> lqw = buildQueryWrapper(bo);
Page<PerfEmployeeInfoVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询员工绩效薪资基本信息列表
*/
@Override
public List<PerfEmployeeInfoVo> queryList(PerfEmployeeInfoBo bo) {
LambdaQueryWrapper<PerfEmployeeInfo> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfEmployeeInfo> buildQueryWrapper(PerfEmployeeInfoBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfEmployeeInfo> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getEmployeeId() != null, PerfEmployeeInfo::getEmployeeId, bo.getEmployeeId());
lqw.eq(bo.getDeptId() != null, PerfEmployeeInfo::getDeptId, bo.getDeptId());
lqw.like(StringUtils.isNotBlank(bo.getPositionName()), PerfEmployeeInfo::getPositionName, bo.getPositionName());
lqw.eq(bo.getBaseSalary() != null, PerfEmployeeInfo::getBaseSalary, bo.getBaseSalary());
lqw.eq(bo.getPerfBase() != null, PerfEmployeeInfo::getPerfBase, bo.getPerfBase());
lqw.eq(bo.getPosCoeffDefault() != null, PerfEmployeeInfo::getPosCoeffDefault, bo.getPosCoeffDefault());
lqw.eq(bo.getIsActive() != null, PerfEmployeeInfo::getIsActive, bo.getIsActive());
return lqw;
}
/**
* 新增员工绩效薪资基本信息
*/
@Override
public Boolean insertByBo(PerfEmployeeInfoBo bo) {
PerfEmployeeInfo add = BeanUtil.toBean(bo, PerfEmployeeInfo.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改员工绩效薪资基本信息
*/
@Override
public Boolean updateByBo(PerfEmployeeInfoBo bo) {
PerfEmployeeInfo update = BeanUtil.toBean(bo, PerfEmployeeInfo.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfEmployeeInfo entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除员工绩效薪资基本信息
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,112 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfPositionTemplateBo;
import com.klp.perf.domain.vo.PerfPositionTemplateVo;
import com.klp.perf.domain.PerfPositionTemplate;
import com.klp.perf.mapper.PerfPositionTemplateMapper;
import com.klp.perf.service.IPerfPositionTemplateService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 岗位绩效考核模板Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfPositionTemplateServiceImpl implements IPerfPositionTemplateService {
private final PerfPositionTemplateMapper baseMapper;
/**
* 查询岗位绩效考核模板
*/
@Override
public PerfPositionTemplateVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询岗位绩效考核模板列表
*/
@Override
public TableDataInfo<PerfPositionTemplateVo> queryPageList(PerfPositionTemplateBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfPositionTemplate> lqw = buildQueryWrapper(bo);
Page<PerfPositionTemplateVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询岗位绩效考核模板列表
*/
@Override
public List<PerfPositionTemplateVo> queryList(PerfPositionTemplateBo bo) {
LambdaQueryWrapper<PerfPositionTemplate> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfPositionTemplate> buildQueryWrapper(PerfPositionTemplateBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfPositionTemplate> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getDeptId() != null, PerfPositionTemplate::getDeptId, bo.getDeptId());
lqw.like(StringUtils.isNotBlank(bo.getPositionName()), PerfPositionTemplate::getPositionName, bo.getPositionName());
lqw.eq(StringUtils.isNotBlank(bo.getTitle()), PerfPositionTemplate::getTitle, bo.getTitle());
lqw.eq(bo.getIsEnabled() != null, PerfPositionTemplate::getIsEnabled, bo.getIsEnabled());
return lqw;
}
/**
* 新增岗位绩效考核模板
*/
@Override
public Boolean insertByBo(PerfPositionTemplateBo bo) {
PerfPositionTemplate add = BeanUtil.toBean(bo, PerfPositionTemplate.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改岗位绩效考核模板
*/
@Override
public Boolean updateByBo(PerfPositionTemplateBo bo) {
PerfPositionTemplate update = BeanUtil.toBean(bo, PerfPositionTemplate.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfPositionTemplate entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除岗位绩效考核模板
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,137 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfSalaryBo;
import com.klp.perf.domain.vo.PerfSalaryVo;
import com.klp.perf.domain.PerfSalary;
import com.klp.perf.mapper.PerfSalaryMapper;
import com.klp.perf.service.IPerfSalaryService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 月度薪资计算记录Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfSalaryServiceImpl implements IPerfSalaryService {
private final PerfSalaryMapper baseMapper;
/**
* 查询月度薪资计算记录
*/
@Override
public PerfSalaryVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询月度薪资计算记录列表
*/
@Override
public TableDataInfo<PerfSalaryVo> queryPageList(PerfSalaryBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfSalary> lqw = buildQueryWrapper(bo);
Page<PerfSalaryVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询月度薪资计算记录列表
*/
@Override
public List<PerfSalaryVo> queryList(PerfSalaryBo bo) {
LambdaQueryWrapper<PerfSalary> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfSalary> buildQueryWrapper(PerfSalaryBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfSalary> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getEmployeeId() != null, PerfSalary::getEmployeeId, bo.getEmployeeId());
lqw.eq(bo.getDeptId() != null, PerfSalary::getDeptId, bo.getDeptId());
lqw.eq(bo.getAppraisalId() != null, PerfSalary::getAppraisalId, bo.getAppraisalId());
lqw.eq(StringUtils.isNotBlank(bo.getPeriod()), PerfSalary::getPeriod, bo.getPeriod());
lqw.eq(bo.getBaseSalary() != null, PerfSalary::getBaseSalary, bo.getBaseSalary());
lqw.eq(bo.getPerfBase() != null, PerfSalary::getPerfBase, bo.getPerfBase());
lqw.eq(bo.getPerfScore() != null, PerfSalary::getPerfScore, bo.getPerfScore());
lqw.eq(bo.getPerfCoeff() != null, PerfSalary::getPerfCoeff, bo.getPerfCoeff());
lqw.eq(bo.getDeptCoeff() != null, PerfSalary::getDeptCoeff, bo.getDeptCoeff());
lqw.eq(bo.getPerfWage() != null, PerfSalary::getPerfWage, bo.getPerfWage());
lqw.eq(bo.getPosCoeff() != null, PerfSalary::getPosCoeff, bo.getPosCoeff());
lqw.eq(bo.getFixedCoeff() != null, PerfSalary::getFixedCoeff, bo.getFixedCoeff());
lqw.eq(bo.getAdjCoeff() != null, PerfSalary::getAdjCoeff, bo.getAdjCoeff());
lqw.eq(bo.getAdjCoeffManual() != null, PerfSalary::getAdjCoeffManual, bo.getAdjCoeffManual());
lqw.eq(bo.getTotalCoeff() != null, PerfSalary::getTotalCoeff, bo.getTotalCoeff());
lqw.eq(StringUtils.isNotBlank(bo.getDeductionsJson()), PerfSalary::getDeductionsJson, bo.getDeductionsJson());
lqw.eq(bo.getDeductionsTotal() != null, PerfSalary::getDeductionsTotal, bo.getDeductionsTotal());
lqw.eq(StringUtils.isNotBlank(bo.getBonusesJson()), PerfSalary::getBonusesJson, bo.getBonusesJson());
lqw.eq(bo.getBonusesTotal() != null, PerfSalary::getBonusesTotal, bo.getBonusesTotal());
lqw.eq(bo.getOtherAmount() != null, PerfSalary::getOtherAmount, bo.getOtherAmount());
lqw.eq(bo.getActualSalary() != null, PerfSalary::getActualSalary, bo.getActualSalary());
lqw.eq(bo.getFixedSalaryRef() != null, PerfSalary::getFixedSalaryRef, bo.getFixedSalaryRef());
lqw.eq(bo.getAdjSalaryRef() != null, PerfSalary::getAdjSalaryRef, bo.getAdjSalaryRef());
lqw.eq(bo.getBaoPerShiftRef() != null, PerfSalary::getBaoPerShiftRef, bo.getBaoPerShiftRef());
lqw.eq(bo.getBaoSalaryRef() != null, PerfSalary::getBaoSalaryRef, bo.getBaoSalaryRef());
lqw.eq(bo.getTotalSalaryRef() != null, PerfSalary::getTotalSalaryRef, bo.getTotalSalaryRef());
lqw.eq(bo.getStatus() != null, PerfSalary::getStatus, bo.getStatus());
lqw.eq(bo.getConfirmedAt() != null, PerfSalary::getConfirmedAt, bo.getConfirmedAt());
lqw.eq(bo.getConfirmedBy() != null, PerfSalary::getConfirmedBy, bo.getConfirmedBy());
return lqw;
}
/**
* 新增月度薪资计算记录
*/
@Override
public Boolean insertByBo(PerfSalaryBo bo) {
PerfSalary add = BeanUtil.toBean(bo, PerfSalary.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改月度薪资计算记录
*/
@Override
public Boolean updateByBo(PerfSalaryBo bo) {
PerfSalary update = BeanUtil.toBean(bo, PerfSalary.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfSalary entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除月度薪资计算记录
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,117 @@
package com.klp.perf.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.perf.domain.bo.PerfTemplateDimensionBo;
import com.klp.perf.domain.vo.PerfTemplateDimensionVo;
import com.klp.perf.domain.PerfTemplateDimension;
import com.klp.perf.mapper.PerfTemplateDimensionMapper;
import com.klp.perf.service.IPerfTemplateDimensionService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 考核维度明细Service业务层处理
*
* @author klp
* @date 2026-07-07
*/
@RequiredArgsConstructor
@Service
public class PerfTemplateDimensionServiceImpl implements IPerfTemplateDimensionService {
private final PerfTemplateDimensionMapper baseMapper;
/**
* 查询考核维度明细
*/
@Override
public PerfTemplateDimensionVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询考核维度明细列表
*/
@Override
public TableDataInfo<PerfTemplateDimensionVo> queryPageList(PerfTemplateDimensionBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<PerfTemplateDimension> lqw = buildQueryWrapper(bo);
Page<PerfTemplateDimensionVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询考核维度明细列表
*/
@Override
public List<PerfTemplateDimensionVo> queryList(PerfTemplateDimensionBo bo) {
LambdaQueryWrapper<PerfTemplateDimension> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<PerfTemplateDimension> buildQueryWrapper(PerfTemplateDimensionBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<PerfTemplateDimension> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getTemplateId() != null, PerfTemplateDimension::getTemplateId, bo.getTemplateId());
lqw.eq(StringUtils.isNotBlank(bo.getSeq()), PerfTemplateDimension::getSeq, bo.getSeq());
lqw.like(StringUtils.isNotBlank(bo.getDimName()), PerfTemplateDimension::getDimName, bo.getDimName());
lqw.eq(StringUtils.isNotBlank(bo.getWeight()), PerfTemplateDimension::getWeight, bo.getWeight());
lqw.eq(StringUtils.isNotBlank(bo.getIndicator()), PerfTemplateDimension::getIndicator, bo.getIndicator());
lqw.eq(StringUtils.isNotBlank(bo.getTargetValue()), PerfTemplateDimension::getTargetValue, bo.getTargetValue());
lqw.eq(StringUtils.isNotBlank(bo.getScoreFormula()), PerfTemplateDimension::getScoreFormula, bo.getScoreFormula());
lqw.eq(StringUtils.isNotBlank(bo.getScoreRule()), PerfTemplateDimension::getScoreRule, bo.getScoreRule());
lqw.eq(bo.getIsEnabled() != null, PerfTemplateDimension::getIsEnabled, bo.getIsEnabled());
return lqw;
}
/**
* 新增考核维度明细
*/
@Override
public Boolean insertByBo(PerfTemplateDimensionBo bo) {
PerfTemplateDimension add = BeanUtil.toBean(bo, PerfTemplateDimension.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改考核维度明细
*/
@Override
public Boolean updateByBo(PerfTemplateDimensionBo bo) {
PerfTemplateDimension update = BeanUtil.toBean(bo, PerfTemplateDimension.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(PerfTemplateDimension entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除考核维度明细
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@@ -0,0 +1,30 @@
<?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.klp.perf.mapper.PerfAppraisalDetailMapper">
<resultMap type="com.klp.perf.domain.PerfAppraisalDetail" id="PerfAppraisalDetailResult">
<result property="id" column="id"/>
<result property="appraisalId" column="appraisal_id"/>
<result property="dimensionId" column="dimension_id"/>
<result property="seq" column="seq"/>
<result property="dimName" column="dim_name"/>
<result property="weight" column="weight"/>
<result property="targetValue" column="target_value"/>
<result property="actualValue" column="actual_value"/>
<result property="dimScore" column="dim_score"/>
<result property="bonus" column="bonus"/>
<result property="penalty" column="penalty"/>
<result property="scoreFormula" column="score_formula"/>
<result property="scoreRule" column="score_rule"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,31 @@
<?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.klp.perf.mapper.PerfAppraisalMapper">
<resultMap type="com.klp.perf.domain.PerfAppraisal" id="PerfAppraisalResult">
<result property="id" column="id"/>
<result property="employeeId" column="employee_id"/>
<result property="deptId" column="dept_id"/>
<result property="templateId" column="template_id"/>
<result property="period" column="period"/>
<result property="weightedScore" column="weighted_score"/>
<result property="bonusScore" column="bonus_score"/>
<result property="penaltyScore" column="penalty_score"/>
<result property="finalScore" column="final_score"/>
<result property="grade" column="grade"/>
<result property="perfCoeff" column="perf_coeff"/>
<result property="status" column="status"/>
<result property="confirmedAt" column="confirmed_at"/>
<result property="confirmedBy" column="confirmed_by"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,25 @@
<?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.klp.perf.mapper.PerfCoeffRangeMapper">
<resultMap type="com.klp.perf.domain.PerfCoeffRange" id="PerfCoeffRangeResult">
<result property="id" column="id"/>
<result property="grade" column="grade"/>
<result property="gradeLabel" column="grade_label"/>
<result property="scoreMin" column="score_min"/>
<result property="scoreMax" column="score_max"/>
<result property="coeffMin" column="coeff_min"/>
<result property="coeffMax" column="coeff_max"/>
<result property="sortOrder" column="sort_order"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,25 @@
<?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.klp.perf.mapper.PerfDeptConfigMapper">
<resultMap type="com.klp.perf.domain.PerfDeptConfig" id="PerfDeptConfigResult">
<result property="id" column="id"/>
<result property="deptId" column="dept_id"/>
<result property="monthlyProductionTarget" column="monthly_production_target"/>
<result property="productionUnit" column="production_unit"/>
<result property="perfUnitPrice" column="perf_unit_price"/>
<result property="productionShifts" column="production_shifts"/>
<result property="guaranteedShifts" column="guaranteed_shifts"/>
<result property="deptCoeff" column="dept_coeff"/>
<result property="salaryMode" column="salary_mode"/>
<result property="baseDivisor" column="base_divisor"/>
<result property="month" column="month"/>
<result property="remark" column="remark"/>
<result property="createdAt" column="created_at"/>
<result property="updatedAt" column="updated_at"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,24 @@
<?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.klp.perf.mapper.PerfDeptItemConfigMapper">
<resultMap type="com.klp.perf.domain.PerfDeptItemConfig" id="PerfDeptItemConfigResult">
<result property="id" column="id"/>
<result property="deptId" column="dept_id"/>
<result property="itemType" column="item_type"/>
<result property="itemName" column="item_name"/>
<result property="sortOrder" column="sort_order"/>
<result property="month" column="month"/>
<result property="isEnabled" column="is_enabled"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,22 @@
<?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.klp.perf.mapper.PerfDeptMapper">
<resultMap type="com.klp.perf.domain.PerfDept" id="PerfDeptResult">
<result property="id" column="id"/>
<result property="deptName" column="dept_name"/>
<result property="orderNum" column="order_num"/>
<result property="hasBaoSalary" column="has_bao_salary"/>
<result property="status" column="status"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createBy" column="create_by"/>
<result property="createTime" column="create_time"/>
<result property="updateBy" column="update_by"/>
<result property="updateTime" column="update_time"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,34 @@
<?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.klp.perf.mapper.PerfDeptSummaryMapper">
<resultMap type="com.klp.perf.domain.PerfDeptSummary" id="PerfDeptSummaryResult">
<result property="id" column="id"/>
<result property="deptId" column="dept_id"/>
<result property="period" column="period"/>
<result property="totalEmployees" column="total_employees"/>
<result property="totalCoeffSum" column="total_coeff_sum"/>
<result property="avgPerfScore" column="avg_perf_score"/>
<result property="avgPerfCoeff" column="avg_perf_coeff"/>
<result property="totalBaseSalary" column="total_base_salary"/>
<result property="totalPerfWage" column="total_perf_wage"/>
<result property="totalDeductions" column="total_deductions"/>
<result property="totalBonuses" column="total_bonuses"/>
<result property="totalOther" column="total_other"/>
<result property="totalActualSalary" column="total_actual_salary"/>
<result property="avgActualSalary" column="avg_actual_salary"/>
<result property="monthlyProduction" column="monthly_production"/>
<result property="unitPrice" column="unit_price"/>
<result property="status" column="status"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,25 @@
<?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.klp.perf.mapper.PerfEmployeeInfoMapper">
<resultMap type="com.klp.perf.domain.PerfEmployeeInfo" id="PerfEmployeeInfoResult">
<result property="id" column="id"/>
<result property="employeeId" column="employee_id"/>
<result property="deptId" column="dept_id"/>
<result property="positionName" column="position_name"/>
<result property="baseSalary" column="base_salary"/>
<result property="perfBase" column="perf_base"/>
<result property="posCoeffDefault" column="pos_coeff_default"/>
<result property="isActive" column="is_active"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,22 @@
<?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.klp.perf.mapper.PerfPositionTemplateMapper">
<resultMap type="com.klp.perf.domain.PerfPositionTemplate" id="PerfPositionTemplateResult">
<result property="id" column="id"/>
<result property="deptId" column="dept_id"/>
<result property="positionName" column="position_name"/>
<result property="title" column="title"/>
<result property="isEnabled" column="is_enabled"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,47 @@
<?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.klp.perf.mapper.PerfSalaryMapper">
<resultMap type="com.klp.perf.domain.PerfSalary" id="PerfSalaryResult">
<result property="id" column="id"/>
<result property="employeeId" column="employee_id"/>
<result property="deptId" column="dept_id"/>
<result property="appraisalId" column="appraisal_id"/>
<result property="period" column="period"/>
<result property="baseSalary" column="base_salary"/>
<result property="perfBase" column="perf_base"/>
<result property="perfScore" column="perf_score"/>
<result property="perfCoeff" column="perf_coeff"/>
<result property="deptCoeff" column="dept_coeff"/>
<result property="perfWage" column="perf_wage"/>
<result property="posCoeff" column="pos_coeff"/>
<result property="fixedCoeff" column="fixed_coeff"/>
<result property="adjCoeff" column="adj_coeff"/>
<result property="adjCoeffManual" column="adj_coeff_manual"/>
<result property="totalCoeff" column="total_coeff"/>
<result property="deductionsJson" column="deductions_json"/>
<result property="deductionsTotal" column="deductions_total"/>
<result property="bonusesJson" column="bonuses_json"/>
<result property="bonusesTotal" column="bonuses_total"/>
<result property="otherAmount" column="other_amount"/>
<result property="actualSalary" column="actual_salary"/>
<result property="fixedSalaryRef" column="fixed_salary_ref"/>
<result property="adjSalaryRef" column="adj_salary_ref"/>
<result property="baoPerShiftRef" column="bao_per_shift_ref"/>
<result property="baoSalaryRef" column="bao_salary_ref"/>
<result property="totalSalaryRef" column="total_salary_ref"/>
<result property="status" column="status"/>
<result property="confirmedAt" column="confirmed_at"/>
<result property="confirmedBy" column="confirmed_by"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,27 @@
<?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.klp.perf.mapper.PerfTemplateDimensionMapper">
<resultMap type="com.klp.perf.domain.PerfTemplateDimension" id="PerfTemplateDimensionResult">
<result property="id" column="id"/>
<result property="templateId" column="template_id"/>
<result property="seq" column="seq"/>
<result property="dimName" column="dim_name"/>
<result property="weight" column="weight"/>
<result property="indicator" column="indicator"/>
<result property="targetValue" column="target_value"/>
<result property="scoreFormula" column="score_formula"/>
<result property="scoreRule" column="score_rule"/>
<result property="isEnabled" column="is_enabled"/>
<result property="delFlag" column="del_flag"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@@ -0,0 +1,154 @@
import request from '@/utils/request'
// ═══════════════════════════════════════
// 厚度分类
// ═══════════════════════════════════════
export function listThickClass(query) {
return request({ url: '/pltcm/thickClass/list', method: 'get', params: query })
}
export function getThickClass(classId) {
return request({ url: '/pltcm/thickClass/' + classId, method: 'get' })
}
export function addThickClass(data) {
return request({ url: '/pltcm/thickClass', method: 'post', data })
}
export function updateThickClass(data) {
return request({ url: '/pltcm/thickClass', method: 'put', data })
}
export function delThickClass(classIds) {
return request({ url: '/pltcm/thickClass/' + classIds, method: 'delete' })
}
// ═══════════════════════════════════════
// 宽度分类
// ═══════════════════════════════════════
export function listWidthClass(query) {
return request({ url: '/pltcm/widthClass/list', method: 'get', params: query })
}
export function getWidthClass(classId) {
return request({ url: '/pltcm/widthClass/' + classId, method: 'get' })
}
export function addWidthClass(data) {
return request({ url: '/pltcm/widthClass', method: 'post', data })
}
export function updateWidthClass(data) {
return request({ url: '/pltcm/widthClass', method: 'put', data })
}
export function delWidthClass(classIds) {
return request({ url: '/pltcm/widthClass/' + classIds, method: 'delete' })
}
// ═══════════════════════════════════════
// 屈服强度分类
// ═══════════════════════════════════════
export function listYieldStressClass(query) {
return request({ url: '/pltcm/yieldStressClass/list', method: 'get', params: query })
}
export function getYieldStressClass(classId) {
return request({ url: '/pltcm/yieldStressClass/' + classId, method: 'get' })
}
export function addYieldStressClass(data) {
return request({ url: '/pltcm/yieldStressClass', method: 'post', data })
}
export function updateYieldStressClass(data) {
return request({ url: '/pltcm/yieldStressClass', method: 'put', data })
}
export function delYieldStressClass(classIds) {
return request({ url: '/pltcm/yieldStressClass/' + classIds, method: 'delete' })
}
// ═══════════════════════════════════════
// 策略关联
// ═══════════════════════════════════════
export function listStrategy(query) {
return request({ url: '/pltcm/strategy/list', method: 'get', params: query })
}
export function getStrategy(id) {
return request({ url: '/pltcm/strategy/' + id, method: 'get' })
}
export function addStrategy(data) {
return request({ url: '/pltcm/strategy', method: 'post', data })
}
export function updateStrategy(data) {
return request({ url: '/pltcm/strategy', method: 'put', data })
}
export function delStrategy(ids) {
return request({ url: '/pltcm/strategy/' + ids, method: 'delete' })
}
// ═══════════════════════════════════════
// 屈服强度与钢种对应关系
// ═══════════════════════════════════════
export function listSteelgrade(query) {
return request({ url: '/pltcm/steelgrade/list', method: 'get', params: query })
}
export function getSteelgrade(steelGrade) {
return request({ url: '/pltcm/steelgrade/' + steelGrade, method: 'get' })
}
export function addSteelgrade(data) {
return request({ url: '/pltcm/steelgrade', method: 'post', data })
}
export function updateSteelgrade(data) {
return request({ url: '/pltcm/steelgrade', method: 'put', data })
}
export function delSteelgrade(steelGrades) {
return request({ url: '/pltcm/steelgrade/' + steelGrades, method: 'delete' })
}
// ═══════════════════════════════════════
// 比例标准表
// ═══════════════════════════════════════
export function listRatio(query) {
return request({ url: '/pltcm/ratio/list', method: 'get', params: query })
}
export function getRatio(id) {
return request({ url: '/pltcm/ratio/' + id, method: 'get' })
}
export function addRatio(data) {
return request({ url: '/pltcm/ratio', method: 'post', data })
}
export function updateRatio(data) {
return request({ url: '/pltcm/ratio', method: 'put', data })
}
export function delRatio(ids) {
return request({ url: '/pltcm/ratio/' + ids, method: 'delete' })
}
// ═══════════════════════════════════════
// 设备启用状态
// ═══════════════════════════════════════
export function listDeviceEnable(query) {
return request({ url: '/pltcm/deviceEnable/list', method: 'get', params: query })
}
export function getDeviceEnable(id) {
return request({ url: '/pltcm/deviceEnable/' + id, method: 'get' })
}
export function updateDeviceEnable(data) {
return request({ url: '/pltcm/deviceEnable', method: 'put', data })
}

View File

@@ -84,7 +84,10 @@
</el-form-item>
<el-form-item label="业务员" prop="saleName" v-if="orderBy">
<el-input v-model="queryParams.saleName" placeholder="请输入业务员" clearable size="small" />
<el-select v-model="queryParams.saleName" placeholder="请选择业务员" clearable size="small" filterable allow-create>
<el-option v-for="item in dict.type.wip_pack_saleman" :key="item.value" :label="item.label"
:value="item.value" />
</el-select>
</el-form-item>
<el-form-item label="合同号" prop="contractNo" v-if="orderBy">
@@ -303,7 +306,7 @@ export default {
DragResizePanel,
OrderDetail
},
dicts: ['coil_itemname', 'coil_material', 'coil_manufacturer', 'coil_quality_status'],
dicts: ['coil_itemname', 'coil_material', 'coil_manufacturer', 'coil_quality_status', 'wip_pack_saleman'],
props: {
// 非触发器模式下,外部控制显隐(触发器模式下无效)
visible: {

File diff suppressed because it is too large Load Diff

View File

@@ -58,6 +58,12 @@ export default {
disabled: {
type: Boolean,
default: false
},
// 下拉最多展示条数默认6条
maxSuggestions: {
type: Number,
default: 6,
validator: (value) => value > 0
}
},
data() {
@@ -118,7 +124,7 @@ export default {
});
}
cb(results); // 回调返回匹配结果
cb(results.slice(0, this.maxSuggestions)); // 回调返回匹配结果(限制条数)
},
/**

View File

@@ -23,7 +23,7 @@
<span class="top-menu-title">{{ (menu.meta && menu.meta.title) || menu.name }}</span>
</div>
</div>
<div slot="reference" class="sidebar-section-title" :class="{ 'is-collapse': isCollapse }">
<div ref="topMenuTrigger" slot="reference" class="sidebar-section-title" :class="{ 'is-collapse': isCollapse }" tabindex="0">
<div class="section-title-inner">
<div class="section-icon">
<svg-icon v-if="activeTopMenuIcon" :icon-class="activeTopMenuIcon" />
@@ -141,6 +141,11 @@ export default {
}
},
watch: {
sectionPopoverVisible: {
handler(val) {
if (!val) this.releasePopoverFocus()
}
},
$route: {
immediate: true,
handler(newRoute) {
@@ -165,8 +170,16 @@ export default {
this.$router.push('/')
this.$nextTick(() => {
this.sectionPopoverVisible = false
this.releasePopoverFocus()
})
},
releasePopoverFocus() {
if (typeof document === 'undefined') return
const el = document.activeElement
if (el && typeof el.blur === 'function') el.blur()
const trigger = this.$refs && this.$refs.topMenuTrigger
if (trigger && typeof trigger.focus === 'function') trigger.focus()
},
autoSelectTopMenu(currentPath) {
const topMenus = this.$store.state.permission.topMenuList
if (topMenus.length === 0) return

View File

@@ -42,7 +42,7 @@
<el-table-column label="逻辑库位" align="center" prop="warehouseName" />
<el-table-column label="实际库区" align="center" prop="actualWarehouseName" />
<el-table-column label="物料类型" align="center" prop="materialType" />
<el-table-column label="产品类型" align="center" width="180">
<el-table-column label="产品类型" align="center" width="140">
<template slot-scope="scope">
<ProductInfo v-if="scope.row.itemType == 'product'" :product="scope.row" />
<RawMaterialInfo v-else-if="scope.row.itemType === 'raw_material'" :material="scope.row" />

View File

@@ -1,51 +1,91 @@
<template>
<div class="contract-tabs">
<div v-if="orderId" class="tabs-content">
<el-tabs v-model="activeTab" type="border-card">
<el-tab-pane label="财务状态" name="finance" v-hasPermi="['crm:order:finance']">
<div class="order-finance" v-if="activeTab === 'finance'">
<!-- 财务状态内容 -->
<ReceiveTable :order="currentOrder" />
</div>
</el-tab-pane>
<!-- 自定义Tab头部 -->
<div class="tab-header">
<span
class="tab-item"
:class="{ active: activeTab === 'contract' }"
@click="activeTab = 'contract'"
>合同信息</span>
<span
class="tab-item"
:class="{ active: activeTab === 'finance' }"
@click="activeTab = 'finance'"
>财务状态</span>
<span
class="tab-item"
:class="{ active: activeTab === 'dispute' }"
@click="activeTab = 'dispute'"
>订单异议</span>
<span
class="tab-item"
:class="{ active: activeTab === 'product' }"
@click="activeTab = 'product'"
>生产成果</span>
<span
class="tab-item"
:class="{ active: activeTab === 'coil' }"
@click="activeTab = 'coil'"
>发货配卷</span>
<span
class="tab-item"
:class="{ active: activeTab === 'delivery' }"
@click="activeTab = 'delivery'"
>发货单据</span>
<span
class="tab-item"
:class="{ active: activeTab === 'attachment' }"
@click="activeTab = 'attachment'"
>合同附件</span>
</div>
<el-tab-pane label="订单异议" name="dispute" v-hasPermi="['crm:order:objection']">
<div class="order-dispute" v-if="activeTab === 'dispute'">
<!-- 订单异议内容 -->
<OrderObjection :order="currentOrder" />
</div>
</el-tab-pane>
<el-tab-pane label="生产成果" name="product">
<div class="order-record" v-if="activeTab === 'product'" v-loading="productCoilLoading">
<!-- 生产成果内容 -->
<CoilTable ref="productCoilTable" :data="productCoilList || []" :showSelection="true"
:pagination="productPagination" :total-statistics="productTotalStatistics"
@selection-change="handleProductSelectionChange"
@page-change="handleProductPageChange">
<template slot="filter-actions" slot-scope="{ selectedRows }">
<el-button type="primary" size="mini" icon="el-icon-refresh"
:disabled="!selectedRows.length" @click="handleBatchTransferContract(selectedRows)">
批量转单
</el-button>
</template>
</CoilTable>
</div>
</el-tab-pane>
<el-tab-pane label="发货配卷" name="coil">
<div class="order-record" v-if="activeTab === 'coil'" v-loading="deliveryCoilLoading">
<!-- 发货配卷内容 -->
<CoilTable :data="deliveryCoilList || []"
:pagination="deliveryPagination" :total-statistics="deliveryTotalStatistics"
@page-change="handleDeliveryPageChange" />
</div>
</el-tab-pane>
<el-tab-pane label="发货单据" name="delivery">
<div class="order-record" v-if="activeTab === 'delivery'">
<!-- 发货单内容 -->
<DeliveryTable :data="deliveryWaybillList || []" />
</div>
</el-tab-pane>
<el-tab-pane label="合同附件" name="attachment" v-hasPermi="['crm:order:record']">
<!-- Tab内容区域可滚动 -->
<div class="tab-body">
<!-- 合同信息 -->
<div v-show="activeTab === 'contract'">
<ContractPreview :contract="currentOrder" @updateStatus="$emit('updateStatus', $event)" />
</div>
<!-- 财务状态 -->
<div v-show="activeTab === 'finance'">
<ReceiveTable :order="currentOrder" />
</div>
<!-- 订单异议 -->
<div v-show="activeTab === 'dispute'">
<OrderObjection :order="currentOrder" />
</div>
<!-- 生产成果 -->
<div v-show="activeTab === 'product'" v-loading="productCoilLoading">
<CoilTable ref="productCoilTable" :data="productCoilList || []" :showSelection="true"
:pagination="productPagination" :total-statistics="productTotalStatistics"
@selection-change="handleProductSelectionChange"
@page-change="handleProductPageChange">
<template slot="filter-actions" slot-scope="{ selectedRows }">
<el-button type="primary" size="mini" icon="el-icon-refresh"
:disabled="!selectedRows.length" @click="handleBatchTransferContract(selectedRows)">
批量转单
</el-button>
</template>
</CoilTable>
</div>
<!-- 发货配卷 -->
<div v-show="activeTab === 'coil'" v-loading="deliveryCoilLoading">
<CoilTable :data="deliveryCoilList || []"
:pagination="deliveryPagination" :total-statistics="deliveryTotalStatistics"
@page-change="handleDeliveryPageChange" />
</div>
<!-- 发货单据 -->
<div v-show="activeTab === 'delivery'">
<DeliveryTable :data="deliveryWaybillList || []" />
</div>
<!-- 合同附件 -->
<div v-show="activeTab === 'attachment'">
<div class="attachment-item">
<h4>商务附件</h4>
<FileList :oss-ids="contractAttachment" />
@@ -62,8 +102,8 @@
<h4>其他附件</h4>
<FileList :oss-ids="form.annexFiles" />
</div>
</el-tab-pane>
</el-tabs>
</div>
</div>
<!-- 批量转单 - 选择目标合同弹窗 -->
<el-dialog title="批量转单" :visible.sync="batchTransferDialogVisible" width="500px" append-to-body
@@ -79,7 +119,7 @@
</span>
</el-dialog>
</div>
<div v-else class="no-selection" style="display: flex; align-items: center; justify-content: center; height: 100%;">
<div v-else class="no-selection">
<el-empty description="请先选择合同" />
</div>
</div>
@@ -91,6 +131,7 @@ import ContractSelect from "@/components/KLPService/ContractSelect";
import { batchUpdateContractCoil } from "@/api/wms/coil";
import FileList from "@/components/FileList";
import DeliveryTable from "../../components/DeliveryTable.vue";
import ContractPreview from "./ContractPreview.vue";
// 导入可能需要的组件
import OrderDetail from "../../components/OrderDetail.vue";
@@ -108,6 +149,7 @@ export default {
ContractSelect,
FileList,
DeliveryTable,
ContractPreview,
OrderDetail,
OrderEdit,
ReceiveTable,
@@ -153,7 +195,7 @@ export default {
data() {
return {
// 活动tab
activeTab: "finance",
activeTab: "contract",
selectedProductRows: [],
batchTransferDialogVisible: false,
batchTargetContractId: '',
@@ -304,4 +346,57 @@ export default {
},
}
};
</script>
</script>
<style scoped>
.contract-tabs {
height: 100%;
display: flex;
flex-direction: column;
}
.tabs-content {
height: 100%;
display: flex;
flex-direction: column;
}
.tab-header {
flex-shrink: 0;
display: flex;
border-bottom: 2px solid #e4e7ed;
background: #fff;
}
.tab-item {
padding: 10px 20px;
cursor: pointer;
color: #606266;
font-size: 14px;
border-bottom: 2px solid transparent;
margin-bottom: -2px;
transition: color .3s, border-color .3s;
user-select: none;
}
.tab-item:hover {
color: #409eff;
}
.tab-item.active {
color: #409eff;
border-bottom-color: #409eff;
}
.tab-body {
flex: 1;
overflow-y: auto;
}
.no-selection {
display: flex;
align-items: center;
justify-content: center;
height: 100%;
}
</style>

View File

@@ -11,24 +11,11 @@
<!-- 右侧内容区域 -->
<div class="right-panel" v-if="form.orderId" style="flex: 1; display: flex; flex-direction: column;">
<!-- 右侧上方合同内容信息预览 -->
<div class="preview-panel" ref="previewPanel"
style="flex: 1; overflow-y: auto; border-bottom: 1px solid #e4e7ed;">
<ContractPreview :contract="form" @updateStatus="handleStatusChange" />
</div>
<!-- 拖拽调整条 -->
<div class="resize-handle" ref="resizeHandle"
style="height: 8px; background-color: #f5f7fa; cursor: row-resize; display: flex; align-items: center; justify-content: center;"
@mousedown="startResize">
<div style="width: 40px; height: 2px; background-color: #dcdfe6;"></div>
</div>
<!-- 右侧下方Tab标签页 -->
<div class="tab-panel" ref="tabPanel" style="flex: 1; overflow-y: auto;">
<div class="tab-panel" style="flex: 1; overflow: hidden;">
<ContractTabs :orderId="form.orderId" :deliveryWaybillList="wmsDeliveryWaybills"
:contract-attachment="form.businessAnnex" :technical-agreement="form.techAnnex"
:other-attachment="form.productionSchedule" :currentOrder="form" />
:other-attachment="form.productionSchedule" :currentOrder="form"
@updateStatus="handleStatusChange" />
</div>
</div>
<div v-else style="flex: 1; display: flex; flex-direction: column;">
@@ -234,7 +221,6 @@ import { addCustomer } from "@/api/crm/customer";
import { listDeliveryWaybill } from "@/api/wms/deliveryWaybill";
import dayjs from "dayjs";
import ContractList from "./components/ContractList.vue";
import ContractPreview from "./components/ContractPreview.vue";
import ContractTabs from "./components/ContractTabs.vue";
import ContractExportDialog from "./components/ContractExportDialog.vue";
import ProductContent from "./components/ProductContent.vue";
@@ -246,7 +232,6 @@ export default {
name: "Contract",
components: {
ContractList,
ContractPreview,
ContractTabs,
ContractExportDialog,
ProductContent,
@@ -706,34 +691,6 @@ export default {
this.customerOpen = false;
this.customerForm = {};
},
/** 开始拖拽调整 */
startResize(e) {
e.preventDefault();
const previewPanel = this.$refs.previewPanel;
const tabPanel = this.$refs.tabPanel;
const startY = e.clientY;
const startPreviewHeight = previewPanel.offsetHeight;
const parentHeight = previewPanel.parentElement.offsetHeight;
const handleMouseMove = (event) => {
const deltaY = event.clientY - startY;
const newPreviewHeight = startPreviewHeight + deltaY;
const newTabHeight = parentHeight - newPreviewHeight - 8; // 8是拖拽条的高度
if (newPreviewHeight > 100 && newTabHeight > 100) { // 最小高度限制
previewPanel.style.flex = `0 0 ${newPreviewHeight}px`;
tabPanel.style.flex = `0 0 ${newTabHeight}px`;
}
};
const handleMouseUp = () => {
document.removeEventListener('mousemove', handleMouseMove);
document.removeEventListener('mouseup', handleMouseUp);
};
document.addEventListener('mousemove', handleMouseMove);
document.addEventListener('mouseup', handleMouseUp);
}
}
};
</script>
@@ -756,11 +713,7 @@ export default {
overflow: hidden;
}
.preview-panel {
overflow-y: auto;
}
.tab-panel {
overflow-y: auto;
overflow: hidden;
}
</style>

View File

@@ -19,7 +19,7 @@
</p>
</div>
<statistic-group />
<quick-access-group />
</el-col>
<!-- 右栏 -->
@@ -37,10 +37,6 @@
</el-row>
</div>
<!-- <div>
<statistic-group />
</div> -->
<!-- <AllApplications />
<el-row :gutter="10">
<el-col :span="18">
@@ -54,7 +50,7 @@
</template>
<script>
import StatisticGroup from '@/components/HomeModules/StatisticGroup.vue'
import QuickAccessGroup from '@/components/HomeModules/QuickAccessGroup.vue'
// import AllApplications from '@/components/HomeModules/AllApplications.vue'
// import MiniCalendar from '@/components/HomeModules/MiniCalendar.vue'
@@ -62,7 +58,7 @@ export default {
name: 'Index',
components: {
// PanelGroup,
StatisticGroup,
QuickAccessGroup,
// AllApplications,
// MiniCalendar,
},
@@ -193,4 +189,4 @@ export default {
}
}
}
</style>
</style>

View File

@@ -344,27 +344,24 @@ export default {
loadMainDetails() {
if (this.mainList.length === 0) return
const promises = this.mainList.map(main => {
return listInspectionDetail({ mainId: main.mainId, pageNum: 1, pageSize: 9999 }).then(response => {
const details = response.rows || []
details.forEach(detail => {
if (main._items[detail.itemName]) {
main._items[detail.itemName] = {
detailId: detail.detailId,
mainId: detail.mainId,
itemName: detail.itemName,
itemValue: detail.itemValue || '',
itemUnit: detail.itemUnit || main._items[detail.itemName].itemUnit,
upperLimit: detail.upperLimit,
lowerLimit: detail.lowerLimit,
rangeDesc: detail.rangeDesc
}
this.mainList.forEach(main => {
const details = main.detailList || []
details.forEach(detail => {
if (main._items[detail.itemName]) {
main._items[detail.itemName] = {
detailId: detail.detailId,
mainId: detail.mainId,
itemName: detail.itemName,
itemValue: detail.itemValue || '',
itemUnit: detail.itemUnit || main._items[detail.itemName].itemUnit,
upperLimit: detail.upperLimit,
lowerLimit: detail.lowerLimit,
rangeDesc: detail.rangeDesc
}
})
main._originalItems = JSON.parse(JSON.stringify(main._items))
}).catch(() => {})
}
})
main._originalItems = JSON.parse(JSON.stringify(main._items))
})
return Promise.all(promises)
},
handleAddMain() {

Some files were not shown because too many files have changed in this diff Show More