合同中心模块开发v4: 合同管理-合同模板&条款管理开发1

pull/1/head
ccongli 1 year ago
parent b761caa1df
commit 57e48cd3d1

@ -103,10 +103,17 @@ public interface ErrorCodeConstants {
// ========== 合同信息 500100001 ==========
ErrorCode CONTRACT_NOT_EXISTS = new ErrorCode(1005000001, "合同信息不存在");
// ========== 合同详情信息 500100001 ==========
ErrorCode CONTRACT_INFO_NOT_EXISTS = new ErrorCode(1005000002, "合同详情信息不存在");
// ========== 合同条款 TODO 补充编号 ==========
ErrorCode CONTRACT_CLAUSE_NOT_EXISTS = new ErrorCode(1005000012, "合同条款不存在");
// ========== 合同模板 TODO 补充编号 ==========
ErrorCode CONTRACT_TEMPLATE_NOT_EXISTS = new ErrorCode(1005000013, "合同模板不存在");
// ========== 主体负责人转移 TODO 补充编号 ==========
ErrorCode SUBJECT_TRANSFER_NOT_EXISTS = new ErrorCode(1005000003, "主体负责人转移不存在");

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import com.yunxi.scm.module.xxjj.convert.contractclause.ContractClauseConvert;
import com.yunxi.scm.module.xxjj.service.contractclause.ContractClauseService;
@Tag(name = "管理后台 - 合同条款")
@RestController
@RequestMapping("/xxjj/contract-clause")
@Validated
public class ContractClauseController {
@Resource
private ContractClauseService contractClauseService;
@PostMapping("/create")
@Operation(summary = "创建合同条款")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:create')")
public CommonResult<Long> createContractClause(@Valid @RequestBody ContractClauseCreateReqVO createReqVO) {
return success(contractClauseService.createContractClause(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新合同条款")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:update')")
public CommonResult<Boolean> updateContractClause(@Valid @RequestBody ContractClauseUpdateReqVO updateReqVO) {
contractClauseService.updateContractClause(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除合同条款")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:delete')")
public CommonResult<Boolean> deleteContractClause(@RequestParam("id") Long id) {
contractClauseService.deleteContractClause(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得合同条款")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:query')")
public CommonResult<ContractClauseRespVO> getContractClause(@RequestParam("id") Long id) {
ContractClauseDO contractClause = contractClauseService.getContractClause(id);
return success(ContractClauseConvert.INSTANCE.convert(contractClause));
}
@GetMapping("/list")
@Operation(summary = "获得合同条款列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:query')")
public CommonResult<List<ContractClauseRespVO>> getContractClauseList(@RequestParam("ids") Collection<Long> ids) {
List<ContractClauseDO> list = contractClauseService.getContractClauseList(ids);
return success(ContractClauseConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得合同条款分页")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:query')")
public CommonResult<PageResult<ContractClauseRespVO>> getContractClausePage(@Valid ContractClausePageReqVO pageVO) {
PageResult<ContractClauseDO> pageResult = contractClauseService.getContractClausePage(pageVO);
return success(ContractClauseConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出合同条款 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:contract-clause:export')")
@OperateLog(type = EXPORT)
public void exportContractClauseExcel(@Valid ContractClauseExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<ContractClauseDO> list = contractClauseService.getContractClauseList(exportReqVO);
// 导出 Excel
List<ContractClauseExcelVO> datas = ContractClauseConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "合同条款.xls", "数据", ContractClauseExcelVO.class, datas);
}
}

@ -0,0 +1,42 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class ContractClauseBaseVO {
@Schema(description = "条款标题", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "条款标题不能为空")
private String title;
@Schema(description = "条款类型 参考字典contract_clause_type", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotNull(message = "条款类型 参考字典contract_clause_type不能为空")
private String type;
@Schema(description = "状态 参考字典contract_clause_status", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
@NotNull(message = "状态 参考字典contract_clause_status不能为空")
private String status;
@Schema(description = "条款内容", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "条款内容不能为空")
private String content;
@Schema(description = "权重值")
private Short weight;
@Schema(description = "备注", example = "随便")
private String remark;
@Schema(description = "附件")
private String attachment;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 合同条款创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractClauseCreateReqVO extends ContractClauseBaseVO {
}

@ -0,0 +1,51 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
/**
* Excel VO
*
* @author
*/
@Data
public class ContractClauseExcelVO {
@ExcelProperty("编号")
private Long id;
@ExcelProperty("条款标题")
private String title;
@ExcelProperty(value = "条款类型 参考字典contract_clause_type", converter = DictConvert.class)
@DictFormat("contract_clause_type") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String type;
@ExcelProperty(value = "状态 参考字典contract_clause_status", converter = DictConvert.class)
@DictFormat("contract_clause_status") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String status;
@ExcelProperty("条款内容")
private String content;
@ExcelProperty("权重值")
private Short weight;
@ExcelProperty("备注")
private String remark;
@ExcelProperty("附件")
private String attachment;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,29 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 合同条款 Excel 导出 Request VO参数和 ContractClausePageReqVO 是一致的")
@Data
public class ContractClauseExportReqVO {
@Schema(description = "条款标题")
private String title;
@Schema(description = "条款类型 参考字典contract_clause_type", example = "1")
private String type;
@Schema(description = "状态 参考字典contract_clause_status", example = "2")
private String status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 合同条款分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractClausePageReqVO extends PageParam {
@Schema(description = "条款标题")
private String title;
@Schema(description = "条款类型 参考字典contract_clause_type", example = "1")
private String type;
@Schema(description = "状态 参考字典contract_clause_status", example = "2")
private String status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 合同条款 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractClauseRespVO extends ContractClauseBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "7146")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 合同条款更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractClauseUpdateReqVO extends ContractClauseBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "7146")
@NotNull(message = "编号不能为空")
private Long id;
}

@ -0,0 +1,102 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.common.pojo.CommonResult;
import static com.yunxi.scm.framework.common.pojo.CommonResult.success;
import com.yunxi.scm.framework.excel.core.util.ExcelUtils;
import com.yunxi.scm.framework.operatelog.core.annotations.OperateLog;
import static com.yunxi.scm.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import com.yunxi.scm.module.xxjj.convert.contracttemplate.ContractTemplateConvert;
import com.yunxi.scm.module.xxjj.service.contracttemplate.ContractTemplateService;
@Tag(name = "管理后台 - 合同模板")
@RestController
@RequestMapping("/xxjj/contract-template")
@Validated
public class ContractTemplateController {
@Resource
private ContractTemplateService contractTemplateService;
@PostMapping("/create")
@Operation(summary = "创建合同模板")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:create')")
public CommonResult<Long> createContractTemplate(@Valid @RequestBody ContractTemplateCreateReqVO createReqVO) {
return success(contractTemplateService.createContractTemplate(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新合同模板")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:update')")
public CommonResult<Boolean> updateContractTemplate(@Valid @RequestBody ContractTemplateUpdateReqVO updateReqVO) {
contractTemplateService.updateContractTemplate(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除合同模板")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:delete')")
public CommonResult<Boolean> deleteContractTemplate(@RequestParam("id") Long id) {
contractTemplateService.deleteContractTemplate(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得合同模板")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:query')")
public CommonResult<ContractTemplateRespVO> getContractTemplate(@RequestParam("id") Long id) {
ContractTemplateDO contractTemplate = contractTemplateService.getContractTemplate(id);
return success(ContractTemplateConvert.INSTANCE.convert(contractTemplate));
}
@GetMapping("/list")
@Operation(summary = "获得合同模板列表")
@Parameter(name = "ids", description = "编号列表", required = true, example = "1024,2048")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:query')")
public CommonResult<List<ContractTemplateRespVO>> getContractTemplateList(@RequestParam("ids") Collection<Long> ids) {
List<ContractTemplateDO> list = contractTemplateService.getContractTemplateList(ids);
return success(ContractTemplateConvert.INSTANCE.convertList(list));
}
@GetMapping("/page")
@Operation(summary = "获得合同模板分页")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:query')")
public CommonResult<PageResult<ContractTemplateRespVO>> getContractTemplatePage(@Valid ContractTemplatePageReqVO pageVO) {
PageResult<ContractTemplateDO> pageResult = contractTemplateService.getContractTemplatePage(pageVO);
return success(ContractTemplateConvert.INSTANCE.convertPage(pageResult));
}
@GetMapping("/export-excel")
@Operation(summary = "导出合同模板 Excel")
@PreAuthorize("@ss.hasPermission('xxjj:contract-template:export')")
@OperateLog(type = EXPORT)
public void exportContractTemplateExcel(@Valid ContractTemplateExportReqVO exportReqVO,
HttpServletResponse response) throws IOException {
List<ContractTemplateDO> list = contractTemplateService.getContractTemplateList(exportReqVO);
// 导出 Excel
List<ContractTemplateExcelVO> datas = ContractTemplateConvert.INSTANCE.convertList02(list);
ExcelUtils.write(response, "合同模板.xls", "数据", ContractTemplateExcelVO.class, datas);
}
}

@ -0,0 +1,37 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import javax.validation.constraints.*;
/**
* Base VO VO 使
* VO Swagger
*/
@Data
public class ContractTemplateBaseVO {
@Schema(description = "模板名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "李四")
@NotNull(message = "模板名称不能为空")
private String name;
@Schema(description = "合同模板类型 参考字典contract_template_type", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotNull(message = "合同模板类型 参考字典contract_template_type不能为空")
private String type;
@Schema(description = "状态 参考字典contract_template_status", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotNull(message = "状态 参考字典contract_template_status不能为空")
private String status;
@Schema(description = "模板描述", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "模板描述不能为空")
private String describe;
@Schema(description = "配置项 json格式", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "配置项 json格式不能为空")
private String options;
}

@ -0,0 +1,14 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 合同模板创建 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractTemplateCreateReqVO extends ContractTemplateBaseVO {
}

@ -0,0 +1,45 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.ExcelProperty;
import com.yunxi.scm.framework.excel.core.annotations.DictFormat;
import com.yunxi.scm.framework.excel.core.convert.DictConvert;
/**
* Excel VO
*
* @author
*/
@Data
public class ContractTemplateExcelVO {
@ExcelProperty("编号")
private Long id;
@ExcelProperty("模板名称")
private String name;
@ExcelProperty(value = "合同模板类型 参考字典contract_template_type", converter = DictConvert.class)
@DictFormat("contract_template_type") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String type;
@ExcelProperty(value = "状态 参考字典contract_template_status", converter = DictConvert.class)
@DictFormat("contract_template_status") // TODO 代码优化:建议设置到对应的 XXXDictTypeConstants 枚举类中
private String status;
@ExcelProperty("模板描述")
private String describe;
@ExcelProperty("配置项 json格式")
private String options;
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,29 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import java.time.LocalDateTime;
import org.springframework.format.annotation.DateTimeFormat;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 合同模板 Excel 导出 Request VO参数和 ContractTemplatePageReqVO 是一致的")
@Data
public class ContractTemplateExportReqVO {
@Schema(description = "模板名称", example = "李四")
private String name;
@Schema(description = "合同模板类型 参考字典contract_template_type", example = "1")
private String type;
@Schema(description = "状态 参考字典contract_template_status", example = "1")
private String status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,31 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yunxi.scm.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.yunxi.scm.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 合同模板分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractTemplatePageReqVO extends PageParam {
@Schema(description = "模板名称", example = "李四")
private String name;
@Schema(description = "合同模板类型 参考字典contract_template_type", example = "1")
private String type;
@Schema(description = "状态 参考字典contract_template_status", example = "1")
private String status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,19 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 合同模板 Response VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractTemplateRespVO extends ContractTemplateBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "21453")
private Long id;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
private LocalDateTime createTime;
}

@ -0,0 +1,18 @@
package com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 合同模板更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ContractTemplateUpdateReqVO extends ContractTemplateBaseVO {
@Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "21453")
@NotNull(message = "编号不能为空")
private Long id;
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.contractclause;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface ContractClauseConvert {
ContractClauseConvert INSTANCE = Mappers.getMapper(ContractClauseConvert.class);
ContractClauseDO convert(ContractClauseCreateReqVO bean);
ContractClauseDO convert(ContractClauseUpdateReqVO bean);
ContractClauseRespVO convert(ContractClauseDO bean);
List<ContractClauseRespVO> convertList(List<ContractClauseDO> list);
PageResult<ContractClauseRespVO> convertPage(PageResult<ContractClauseDO> page);
List<ContractClauseExcelVO> convertList02(List<ContractClauseDO> list);
}

@ -0,0 +1,34 @@
package com.yunxi.scm.module.xxjj.convert.contracttemplate;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
/**
* Convert
*
* @author
*/
@Mapper
public interface ContractTemplateConvert {
ContractTemplateConvert INSTANCE = Mappers.getMapper(ContractTemplateConvert.class);
ContractTemplateDO convert(ContractTemplateCreateReqVO bean);
ContractTemplateDO convert(ContractTemplateUpdateReqVO bean);
ContractTemplateRespVO convert(ContractTemplateDO bean);
List<ContractTemplateRespVO> convertList(List<ContractTemplateDO> list);
PageResult<ContractTemplateRespVO> convertPage(PageResult<ContractTemplateDO> page);
List<ContractTemplateExcelVO> convertList02(List<ContractTemplateDO> list);
}

@ -0,0 +1,63 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.contractclause;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("xxjj_contract_clause")
@KeySequence("xxjj_contract_clause_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ContractClauseDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
*
*/
private String title;
/**
* contract_clause_type
*
* {@link TODO contract_clause_type }
*/
private String type;
/**
* contract_clause_status
*
* {@link TODO contract_clause_status }
*/
private String status;
/**
*
*/
private String content;
/**
*
*/
private Short weight;
/**
*
*/
private String remark;
/**
*
*/
private String attachment;
}

@ -0,0 +1,55 @@
package com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.yunxi.scm.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("xxjj_contract_template")
@KeySequence("xxjj_contract_template_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ContractTemplateDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
*
*/
private String name;
/**
* contract_template_type
*
* {@link TODO contract_template_type }
*/
private String type;
/**
* contract_template_status
*
* {@link TODO contract_template_status }
*/
private String status;
/**
*
*/
private String describe;
/**
* json
*/
private String options;
}

@ -0,0 +1,38 @@
package com.yunxi.scm.module.xxjj.dal.mysql.contractclause;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface ContractClauseMapper extends BaseMapperX<ContractClauseDO> {
default PageResult<ContractClauseDO> selectPage(ContractClausePageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ContractClauseDO>()
.eqIfPresent(ContractClauseDO::getTitle, reqVO.getTitle())
.eqIfPresent(ContractClauseDO::getType, reqVO.getType())
.eqIfPresent(ContractClauseDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ContractClauseDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ContractClauseDO::getId));
}
default List<ContractClauseDO> selectList(ContractClauseExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<ContractClauseDO>()
.eqIfPresent(ContractClauseDO::getTitle, reqVO.getTitle())
.eqIfPresent(ContractClauseDO::getType, reqVO.getType())
.eqIfPresent(ContractClauseDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ContractClauseDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ContractClauseDO::getId));
}
}

@ -0,0 +1,38 @@
package com.yunxi.scm.module.xxjj.dal.mysql.contracttemplate;
import java.util.*;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.yunxi.scm.framework.mybatis.core.mapper.BaseMapperX;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import org.apache.ibatis.annotations.Mapper;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface ContractTemplateMapper extends BaseMapperX<ContractTemplateDO> {
default PageResult<ContractTemplateDO> selectPage(ContractTemplatePageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ContractTemplateDO>()
.likeIfPresent(ContractTemplateDO::getName, reqVO.getName())
.eqIfPresent(ContractTemplateDO::getType, reqVO.getType())
.eqIfPresent(ContractTemplateDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ContractTemplateDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ContractTemplateDO::getId));
}
default List<ContractTemplateDO> selectList(ContractTemplateExportReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<ContractTemplateDO>()
.likeIfPresent(ContractTemplateDO::getName, reqVO.getName())
.eqIfPresent(ContractTemplateDO::getType, reqVO.getType())
.eqIfPresent(ContractTemplateDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ContractTemplateDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ContractTemplateDO::getId));
}
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.xxjj.service.contractclause;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface ContractClauseService {
/**
*
*
* @param createReqVO
* @return
*/
Long createContractClause(@Valid ContractClauseCreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateContractClause(@Valid ContractClauseUpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteContractClause(Long id);
/**
*
*
* @param id
* @return
*/
ContractClauseDO getContractClause(Long id);
/**
*
*
* @param ids
* @return
*/
List<ContractClauseDO> getContractClauseList(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<ContractClauseDO> getContractClausePage(ContractClausePageReqVO pageReqVO);
/**
* , Excel
*
* @param exportReqVO
* @return
*/
List<ContractClauseDO> getContractClauseList(ContractClauseExportReqVO exportReqVO);
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.xxjj.service.contractclause;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.xxjj.convert.contractclause.ContractClauseConvert;
import com.yunxi.scm.module.xxjj.dal.mysql.contractclause.ContractClauseMapper;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class ContractClauseServiceImpl implements ContractClauseService {
@Resource
private ContractClauseMapper contractClauseMapper;
@Override
public Long createContractClause(ContractClauseCreateReqVO createReqVO) {
// 插入
ContractClauseDO contractClause = ContractClauseConvert.INSTANCE.convert(createReqVO);
contractClauseMapper.insert(contractClause);
// 返回
return contractClause.getId();
}
@Override
public void updateContractClause(ContractClauseUpdateReqVO updateReqVO) {
// 校验存在
validateContractClauseExists(updateReqVO.getId());
// 更新
ContractClauseDO updateObj = ContractClauseConvert.INSTANCE.convert(updateReqVO);
contractClauseMapper.updateById(updateObj);
}
@Override
public void deleteContractClause(Long id) {
// 校验存在
validateContractClauseExists(id);
// 删除
contractClauseMapper.deleteById(id);
}
private void validateContractClauseExists(Long id) {
if (contractClauseMapper.selectById(id) == null) {
throw exception(CONTRACT_CLAUSE_NOT_EXISTS);
}
}
@Override
public ContractClauseDO getContractClause(Long id) {
return contractClauseMapper.selectById(id);
}
@Override
public List<ContractClauseDO> getContractClauseList(Collection<Long> ids) {
return contractClauseMapper.selectBatchIds(ids);
}
@Override
public PageResult<ContractClauseDO> getContractClausePage(ContractClausePageReqVO pageReqVO) {
return contractClauseMapper.selectPage(pageReqVO);
}
@Override
public List<ContractClauseDO> getContractClauseList(ContractClauseExportReqVO exportReqVO) {
return contractClauseMapper.selectList(exportReqVO);
}
}

@ -0,0 +1,70 @@
package com.yunxi.scm.module.xxjj.service.contracttemplate;
import java.util.*;
import javax.validation.*;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface ContractTemplateService {
/**
*
*
* @param createReqVO
* @return
*/
Long createContractTemplate(@Valid ContractTemplateCreateReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateContractTemplate(@Valid ContractTemplateUpdateReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteContractTemplate(Long id);
/**
*
*
* @param id
* @return
*/
ContractTemplateDO getContractTemplate(Long id);
/**
*
*
* @param ids
* @return
*/
List<ContractTemplateDO> getContractTemplateList(Collection<Long> ids);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<ContractTemplateDO> getContractTemplatePage(ContractTemplatePageReqVO pageReqVO);
/**
* , Excel
*
* @param exportReqVO
* @return
*/
List<ContractTemplateDO> getContractTemplateList(ContractTemplateExportReqVO exportReqVO);
}

@ -0,0 +1,82 @@
package com.yunxi.scm.module.xxjj.service.contracttemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import com.yunxi.scm.framework.common.pojo.PageResult;
import com.yunxi.scm.module.xxjj.convert.contracttemplate.ContractTemplateConvert;
import com.yunxi.scm.module.xxjj.dal.mysql.contracttemplate.ContractTemplateMapper;
import static com.yunxi.scm.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class ContractTemplateServiceImpl implements ContractTemplateService {
@Resource
private ContractTemplateMapper contractTemplateMapper;
@Override
public Long createContractTemplate(ContractTemplateCreateReqVO createReqVO) {
// 插入
ContractTemplateDO contractTemplate = ContractTemplateConvert.INSTANCE.convert(createReqVO);
contractTemplateMapper.insert(contractTemplate);
// 返回
return contractTemplate.getId();
}
@Override
public void updateContractTemplate(ContractTemplateUpdateReqVO updateReqVO) {
// 校验存在
validateContractTemplateExists(updateReqVO.getId());
// 更新
ContractTemplateDO updateObj = ContractTemplateConvert.INSTANCE.convert(updateReqVO);
contractTemplateMapper.updateById(updateObj);
}
@Override
public void deleteContractTemplate(Long id) {
// 校验存在
validateContractTemplateExists(id);
// 删除
contractTemplateMapper.deleteById(id);
}
private void validateContractTemplateExists(Long id) {
if (contractTemplateMapper.selectById(id) == null) {
throw exception(CONTRACT_TEMPLATE_NOT_EXISTS);
}
}
@Override
public ContractTemplateDO getContractTemplate(Long id) {
return contractTemplateMapper.selectById(id);
}
@Override
public List<ContractTemplateDO> getContractTemplateList(Collection<Long> ids) {
return contractTemplateMapper.selectBatchIds(ids);
}
@Override
public PageResult<ContractTemplateDO> getContractTemplatePage(ContractTemplatePageReqVO pageReqVO) {
return contractTemplateMapper.selectPage(pageReqVO);
}
@Override
public List<ContractTemplateDO> getContractTemplateList(ContractTemplateExportReqVO exportReqVO) {
return contractTemplateMapper.selectList(exportReqVO);
}
}

@ -0,0 +1,12 @@
<?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.yunxi.scm.module.xxjj.dal.mysql.contractclause.ContractClauseMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -0,0 +1,12 @@
<?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.yunxi.scm.module.xxjj.dal.mysql.contracttemplate.ContractTemplateMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -0,0 +1,175 @@
package com.yunxi.scm.module.xxjj.service.contractclause;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.mock.mockito.MockBean;
import javax.annotation.Resource;
import com.yunxi.scm.framework.test.core.ut.BaseDbUnitTest;
import com.yunxi.scm.module.xxjj.controller.admin.contractclause.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contractclause.ContractClauseDO;
import com.yunxi.scm.module.xxjj.dal.mysql.contractclause.ContractClauseMapper;
import com.yunxi.scm.framework.common.pojo.PageResult;
import javax.annotation.Resource;
import org.springframework.context.annotation.Import;
import java.util.*;
import java.time.LocalDateTime;
import static cn.hutool.core.util.RandomUtil.*;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
import static com.yunxi.scm.framework.test.core.util.AssertUtils.*;
import static com.yunxi.scm.framework.test.core.util.RandomUtils.*;
import static com.yunxi.scm.framework.common.util.date.LocalDateTimeUtils.*;
import static com.yunxi.scm.framework.common.util.object.ObjectUtils.*;
import static com.yunxi.scm.framework.common.util.date.DateUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* {@link ContractClauseServiceImpl}
*
* @author
*/
@Import(ContractClauseServiceImpl.class)
public class ContractClauseServiceImplTest extends BaseDbUnitTest {
@Resource
private ContractClauseServiceImpl contractClauseService;
@Resource
private ContractClauseMapper contractClauseMapper;
@Test
public void testCreateContractClause_success() {
// 准备参数
ContractClauseCreateReqVO reqVO = randomPojo(ContractClauseCreateReqVO.class);
// 调用
Long contractClauseId = contractClauseService.createContractClause(reqVO);
// 断言
assertNotNull(contractClauseId);
// 校验记录的属性是否正确
ContractClauseDO contractClause = contractClauseMapper.selectById(contractClauseId);
assertPojoEquals(reqVO, contractClause);
}
@Test
public void testUpdateContractClause_success() {
// mock 数据
ContractClauseDO dbContractClause = randomPojo(ContractClauseDO.class);
contractClauseMapper.insert(dbContractClause);// @Sql: 先插入出一条存在的数据
// 准备参数
ContractClauseUpdateReqVO reqVO = randomPojo(ContractClauseUpdateReqVO.class, o -> {
o.setId(dbContractClause.getId()); // 设置更新的 ID
});
// 调用
contractClauseService.updateContractClause(reqVO);
// 校验是否更新正确
ContractClauseDO contractClause = contractClauseMapper.selectById(reqVO.getId()); // 获取最新的
assertPojoEquals(reqVO, contractClause);
}
@Test
public void testUpdateContractClause_notExists() {
// 准备参数
ContractClauseUpdateReqVO reqVO = randomPojo(ContractClauseUpdateReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> contractClauseService.updateContractClause(reqVO), CONTRACT_CLAUSE_NOT_EXISTS);
}
@Test
public void testDeleteContractClause_success() {
// mock 数据
ContractClauseDO dbContractClause = randomPojo(ContractClauseDO.class);
contractClauseMapper.insert(dbContractClause);// @Sql: 先插入出一条存在的数据
// 准备参数
Long id = dbContractClause.getId();
// 调用
contractClauseService.deleteContractClause(id);
// 校验数据不存在了
assertNull(contractClauseMapper.selectById(id));
}
@Test
public void testDeleteContractClause_notExists() {
// 准备参数
Long id = randomLongId();
// 调用, 并断言异常
assertServiceException(() -> contractClauseService.deleteContractClause(id), CONTRACT_CLAUSE_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值,然后删除 @Disabled 注解
public void testGetContractClausePage() {
// mock 数据
ContractClauseDO dbContractClause = randomPojo(ContractClauseDO.class, o -> { // 等会查询到
o.setTitle(null);
o.setType(null);
o.setStatus(null);
o.setCreateTime(null);
});
contractClauseMapper.insert(dbContractClause);
// 测试 title 不匹配
contractClauseMapper.insert(cloneIgnoreId(dbContractClause, o -> o.setTitle(null)));
// 测试 type 不匹配
contractClauseMapper.insert(cloneIgnoreId(dbContractClause, o -> o.setType(null)));
// 测试 status 不匹配
contractClauseMapper.insert(cloneIgnoreId(dbContractClause, o -> o.setStatus(null)));
// 测试 createTime 不匹配
contractClauseMapper.insert(cloneIgnoreId(dbContractClause, o -> o.setCreateTime(null)));
// 准备参数
ContractClausePageReqVO reqVO = new ContractClausePageReqVO();
reqVO.setTitle(null);
reqVO.setType(null);
reqVO.setStatus(null);
reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
// 调用
PageResult<ContractClauseDO> pageResult = contractClauseService.getContractClausePage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbContractClause, pageResult.getList().get(0));
}
@Test
@Disabled // TODO 请修改 null 为需要的值,然后删除 @Disabled 注解
public void testGetContractClauseList() {
// mock 数据
ContractClauseDO dbContractClause = randomPojo(ContractClauseDO.class, o -> { // 等会查询到
o.setTitle(null);
o.setType(null);
o.setStatus(null);
o.setCreateTime(null);
});
contractClauseMapper.insert(dbContractClause);
// 测试 title 不匹配
contractClauseMapper.insert(cloneIgnoreId(dbContractClause, o -> o.setTitle(null)));
// 测试 type 不匹配
contractClauseMapper.insert(cloneIgnoreId(dbContractClause, o -> o.setType(null)));
// 测试 status 不匹配
contractClauseMapper.insert(cloneIgnoreId(dbContractClause, o -> o.setStatus(null)));
// 测试 createTime 不匹配
contractClauseMapper.insert(cloneIgnoreId(dbContractClause, o -> o.setCreateTime(null)));
// 准备参数
ContractClauseExportReqVO reqVO = new ContractClauseExportReqVO();
reqVO.setTitle(null);
reqVO.setType(null);
reqVO.setStatus(null);
reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
// 调用
List<ContractClauseDO> list = contractClauseService.getContractClauseList(reqVO);
// 断言
assertEquals(1, list.size());
assertPojoEquals(dbContractClause, list.get(0));
}
}

@ -0,0 +1,175 @@
package com.yunxi.scm.module.xxjj.service.contracttemplate;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.mock.mockito.MockBean;
import javax.annotation.Resource;
import com.yunxi.scm.framework.test.core.ut.BaseDbUnitTest;
import com.yunxi.scm.module.xxjj.controller.admin.contracttemplate.vo.*;
import com.yunxi.scm.module.xxjj.dal.dataobject.contracttemplate.ContractTemplateDO;
import com.yunxi.scm.module.xxjj.dal.mysql.contracttemplate.ContractTemplateMapper;
import com.yunxi.scm.framework.common.pojo.PageResult;
import javax.annotation.Resource;
import org.springframework.context.annotation.Import;
import java.util.*;
import java.time.LocalDateTime;
import static cn.hutool.core.util.RandomUtil.*;
import static com.yunxi.scm.module.xxjj.enums.ErrorCodeConstants.*;
import static com.yunxi.scm.framework.test.core.util.AssertUtils.*;
import static com.yunxi.scm.framework.test.core.util.RandomUtils.*;
import static com.yunxi.scm.framework.common.util.date.LocalDateTimeUtils.*;
import static com.yunxi.scm.framework.common.util.object.ObjectUtils.*;
import static com.yunxi.scm.framework.common.util.date.DateUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
/**
* {@link ContractTemplateServiceImpl}
*
* @author
*/
@Import(ContractTemplateServiceImpl.class)
public class ContractTemplateServiceImplTest extends BaseDbUnitTest {
@Resource
private ContractTemplateServiceImpl contractTemplateService;
@Resource
private ContractTemplateMapper contractTemplateMapper;
@Test
public void testCreateContractTemplate_success() {
// 准备参数
ContractTemplateCreateReqVO reqVO = randomPojo(ContractTemplateCreateReqVO.class);
// 调用
Long contractTemplateId = contractTemplateService.createContractTemplate(reqVO);
// 断言
assertNotNull(contractTemplateId);
// 校验记录的属性是否正确
ContractTemplateDO contractTemplate = contractTemplateMapper.selectById(contractTemplateId);
assertPojoEquals(reqVO, contractTemplate);
}
@Test
public void testUpdateContractTemplate_success() {
// mock 数据
ContractTemplateDO dbContractTemplate = randomPojo(ContractTemplateDO.class);
contractTemplateMapper.insert(dbContractTemplate);// @Sql: 先插入出一条存在的数据
// 准备参数
ContractTemplateUpdateReqVO reqVO = randomPojo(ContractTemplateUpdateReqVO.class, o -> {
o.setId(dbContractTemplate.getId()); // 设置更新的 ID
});
// 调用
contractTemplateService.updateContractTemplate(reqVO);
// 校验是否更新正确
ContractTemplateDO contractTemplate = contractTemplateMapper.selectById(reqVO.getId()); // 获取最新的
assertPojoEquals(reqVO, contractTemplate);
}
@Test
public void testUpdateContractTemplate_notExists() {
// 准备参数
ContractTemplateUpdateReqVO reqVO = randomPojo(ContractTemplateUpdateReqVO.class);
// 调用, 并断言异常
assertServiceException(() -> contractTemplateService.updateContractTemplate(reqVO), CONTRACT_TEMPLATE_NOT_EXISTS);
}
@Test
public void testDeleteContractTemplate_success() {
// mock 数据
ContractTemplateDO dbContractTemplate = randomPojo(ContractTemplateDO.class);
contractTemplateMapper.insert(dbContractTemplate);// @Sql: 先插入出一条存在的数据
// 准备参数
Long id = dbContractTemplate.getId();
// 调用
contractTemplateService.deleteContractTemplate(id);
// 校验数据不存在了
assertNull(contractTemplateMapper.selectById(id));
}
@Test
public void testDeleteContractTemplate_notExists() {
// 准备参数
Long id = randomLongId();
// 调用, 并断言异常
assertServiceException(() -> contractTemplateService.deleteContractTemplate(id), CONTRACT_TEMPLATE_NOT_EXISTS);
}
@Test
@Disabled // TODO 请修改 null 为需要的值,然后删除 @Disabled 注解
public void testGetContractTemplatePage() {
// mock 数据
ContractTemplateDO dbContractTemplate = randomPojo(ContractTemplateDO.class, o -> { // 等会查询到
o.setName(null);
o.setType(null);
o.setStatus(null);
o.setCreateTime(null);
});
contractTemplateMapper.insert(dbContractTemplate);
// 测试 name 不匹配
contractTemplateMapper.insert(cloneIgnoreId(dbContractTemplate, o -> o.setName(null)));
// 测试 type 不匹配
contractTemplateMapper.insert(cloneIgnoreId(dbContractTemplate, o -> o.setType(null)));
// 测试 status 不匹配
contractTemplateMapper.insert(cloneIgnoreId(dbContractTemplate, o -> o.setStatus(null)));
// 测试 createTime 不匹配
contractTemplateMapper.insert(cloneIgnoreId(dbContractTemplate, o -> o.setCreateTime(null)));
// 准备参数
ContractTemplatePageReqVO reqVO = new ContractTemplatePageReqVO();
reqVO.setName(null);
reqVO.setType(null);
reqVO.setStatus(null);
reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
// 调用
PageResult<ContractTemplateDO> pageResult = contractTemplateService.getContractTemplatePage(reqVO);
// 断言
assertEquals(1, pageResult.getTotal());
assertEquals(1, pageResult.getList().size());
assertPojoEquals(dbContractTemplate, pageResult.getList().get(0));
}
@Test
@Disabled // TODO 请修改 null 为需要的值,然后删除 @Disabled 注解
public void testGetContractTemplateList() {
// mock 数据
ContractTemplateDO dbContractTemplate = randomPojo(ContractTemplateDO.class, o -> { // 等会查询到
o.setName(null);
o.setType(null);
o.setStatus(null);
o.setCreateTime(null);
});
contractTemplateMapper.insert(dbContractTemplate);
// 测试 name 不匹配
contractTemplateMapper.insert(cloneIgnoreId(dbContractTemplate, o -> o.setName(null)));
// 测试 type 不匹配
contractTemplateMapper.insert(cloneIgnoreId(dbContractTemplate, o -> o.setType(null)));
// 测试 status 不匹配
contractTemplateMapper.insert(cloneIgnoreId(dbContractTemplate, o -> o.setStatus(null)));
// 测试 createTime 不匹配
contractTemplateMapper.insert(cloneIgnoreId(dbContractTemplate, o -> o.setCreateTime(null)));
// 准备参数
ContractTemplateExportReqVO reqVO = new ContractTemplateExportReqVO();
reqVO.setName(null);
reqVO.setType(null);
reqVO.setStatus(null);
reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
// 调用
List<ContractTemplateDO> list = contractTemplateService.getContractTemplateList(reqVO);
// 断言
assertEquals(1, list.size());
assertPojoEquals(dbContractTemplate, list.get(0));
}
}

@ -1,3 +1,5 @@
-- SQL yunxi-module-xxjj-biz test/resources/sql/clean.sql
DELETE FROM "xxjj_contract";
DELETE FROM "xxjj_contract_info";
DELETE FROM "xxjj_contract_info";
DELETE FROM "xxjj_contract_clause";
DELETE FROM "xxjj_contract_template";

@ -56,4 +56,38 @@ CREATE TABLE IF NOT EXISTS "xxjj_contract_info" (
"deleted" bit NOT NULL DEFAULT FALSE,
"tenant_id" bigint NOT NULL,
PRIMARY KEY ("id")
) COMMENT '';
) COMMENT '';
CREATE TABLE IF NOT EXISTS "xxjj_contract_template" (
"id" bigint NOT NULL GENERATED BY DEFAULT AS IDENTITY,
"name" varchar NOT NULL,
"type" varchar NOT NULL,
"status" varchar NOT NULL,
"describe" varchar NOT NULL,
"options" varchar NOT NULL,
"creator" varchar DEFAULT '',
"create_time" datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updater" varchar DEFAULT '',
"update_time" datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
"deleted" bit NOT NULL DEFAULT FALSE,
"tenant_id" bigint NOT NULL,
PRIMARY KEY ("id")
) COMMENT '';
CREATE TABLE IF NOT EXISTS "xxjj_contract_clause" (
"id" bigint NOT NULL GENERATED BY DEFAULT AS IDENTITY,
"title" varchar NOT NULL,
"type" varchar NOT NULL,
"status" varchar NOT NULL,
"content" varchar NOT NULL,
"weight" varchar,
"remark" varchar,
"attachment" varchar,
"creator" varchar DEFAULT '',
"create_time" datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
"updater" varchar DEFAULT '',
"update_time" datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
"deleted" bit NOT NULL DEFAULT FALSE,
"tenant_id" bigint NOT NULL,
PRIMARY KEY ("id")
) COMMENT '';

@ -0,0 +1,42 @@
import request from '@/config/axios'
export interface ContractClauseVO {
id: number
title: string
type: string
status: string
content: string
weight: number
remark: string
attachment: string
}
// 查询合同条款列表
export const getContractClausePage = async (params) => {
return await request.get({ url: `/xxjj/contract-clause/page`, params })
}
// 查询合同条款详情
export const getContractClause = async (id: number) => {
return await request.get({ url: `/xxjj/contract-clause/get?id=` + id })
}
// 新增合同条款
export const createContractClause = async (data: ContractClauseVO) => {
return await request.post({ url: `/xxjj/contract-clause/create`, data })
}
// 修改合同条款
export const updateContractClause = async (data: ContractClauseVO) => {
return await request.put({ url: `/xxjj/contract-clause/update`, data })
}
// 删除合同条款
export const deleteContractClause = async (id: number) => {
return await request.delete({ url: `/xxjj/contract-clause/delete?id=` + id })
}
// 导出合同条款 Excel
export const exportContractClause = async (params) => {
return await request.download({ url: `/xxjj/contract-clause/export-excel`, params })
}

@ -0,0 +1,40 @@
import request from '@/config/axios'
export interface ContractTemplateVO {
id: number
name: string
type: string
status: string
describe: string
options: string
}
// 查询合同模板列表
export const getContractTemplatePage = async (params) => {
return await request.get({ url: `/xxjj/contract-template/page`, params })
}
// 查询合同模板详情
export const getContractTemplate = async (id: number) => {
return await request.get({ url: `/xxjj/contract-template/get?id=` + id })
}
// 新增合同模板
export const createContractTemplate = async (data: ContractTemplateVO) => {
return await request.post({ url: `/xxjj/contract-template/create`, data })
}
// 修改合同模板
export const updateContractTemplate = async (data: ContractTemplateVO) => {
return await request.put({ url: `/xxjj/contract-template/update`, data })
}
// 删除合同模板
export const deleteContractTemplate = async (id: number) => {
return await request.delete({ url: `/xxjj/contract-template/delete?id=` + id })
}
// 导出合同模板 Excel
export const exportContractTemplate = async (params) => {
return await request.download({ url: `/xxjj/contract-template/export-excel`, params })
}

@ -254,6 +254,13 @@ export enum DICT_TYPE {
CONTRACT_COST_MAIN = 'contract_cost_main', // 合同费用承担主体
CONTRACT_BIDDING_STATUS = 'contract_bidding_status', // 合同招投标状态
CONTRACT_LONGTERM_STATUS = 'contract_longterm_status', // 合同长协
CONTRACT_MAIN_BODY_TYPE = 'contract_main_body_type', // 合同主体类型
CONTRACT_PAYMENT_METHOD = 'contract_payment_method', // 合同付款方式
CONTRACT_COOPERATION_METHOD = 'contract_cooperation_method', // 合同合作方式
CONTRACT_SETTLEMENT_METHOD = 'contract_settlement_method', // 合同结算方式
CONTRACT_PAYMENT_NODE = 'contract_payment_node', // 合同收付款节点
CONTRACT_CLAUSE_TYPE = 'contract_clause_type', // 合同条款类型
CONTRACT_TEMPLATE_TYPE = 'contract_template_type', // 合同模板类型
CONTRACT_CLAUSE_STATUS = 'contract_clause_status', // 合同条款状态
CONTRACT_TEMPLATE_STATUS = 'contract_clause_status', // 合同模板状态
}

@ -0,0 +1,127 @@
<template>
<Dialog :title="dialogTitle" v-model="dialogVisible">
<el-form ref="formRef" :model="formData" :rules="formRules" label-width="100px" v-loading="formLoading">
<el-form-item label="条款标题" prop="title">
<el-input v-model="formData.title" placeholder="请输入条款标题" />
</el-form-item>
<el-form-item label="条款类型" prop="type">
<el-select v-model="formData.type" placeholder="请选择条款类型">
<el-option v-for="dict in getStrDictOptions(DICT_TYPE.CONTRACT_CLAUSE_TYPE)" :key="dict.value"
:label="dict.label" :value="dict.value" />
</el-select>
</el-form-item>
<el-form-item label="状态" prop="status">
<el-radio-group v-model="formData.status">
<el-radio v-for="dict in getStrDictOptions(DICT_TYPE.CONTRACT_CLAUSE_STATUS)" :key="dict.value"
:label="dict.value">
{{ dict.label }}
</el-radio>
</el-radio-group>
</el-form-item>
<el-form-item label="条款内容">
<Editor v-model="formData.content" height="150px" />
</el-form-item>
<el-form-item label="权重值" prop="weight">
<el-input v-model="formData.weight" placeholder="请输入权重值" />
</el-form-item>
<el-form-item label="备注" prop="remark">
<el-input v-model="formData.remark" placeholder="请输入备注" />
</el-form-item>
<el-form-item label="附件" prop="attachment">
<el-input v-model="formData.attachment" placeholder="请输入附件" />
</el-form-item>
</el-form>
<template #footer>
<el-button @click="submitForm" type="primary" :disabled="formLoading"> </el-button>
<el-button @click="dialogVisible = false"> </el-button>
</template>
</Dialog>
</template>
<script setup lang="ts">
import { DICT_TYPE, getStrDictOptions } from '@/utils/dict'
import * as ContractClauseApi from '@/api/xxjj/contractClause'
const { t } = useI18n() //
const message = useMessage() //
const dialogVisible = ref(false) //
const dialogTitle = ref('') //
const formLoading = ref(false) // 12
const formType = ref('') // create - update -
const formData = ref({
id: undefined,
title: undefined,
type: undefined,
status: undefined,
content: undefined,
weight: undefined,
remark: undefined,
attachment: undefined
})
const formRules = reactive({
title: [{ required: true, message: '条款标题不能为空', trigger: 'blur' }],
type: [{ required: true, message: '条款类型', trigger: 'change' }],
status: [{ required: true, message: '状态', trigger: 'blur' }],
content: [{ required: true, message: '条款内容不能为空', trigger: 'blur' }]
})
const formRef = ref() // Ref
/** 打开弹窗 */
const open = async (type: string, id?: number) => {
dialogVisible.value = true
dialogTitle.value = t('action.' + type)
formType.value = type
resetForm()
//
if (id) {
formLoading.value = true
try {
formData.value = await ContractClauseApi.getContractClause(id)
} finally {
formLoading.value = false
}
}
}
defineExpose({ open }) // open
/** 提交表单 */
const emit = defineEmits(['success']) // success
const submitForm = async () => {
//
if (!formRef) return
const valid = await formRef.value.validate()
if (!valid) return
//
formLoading.value = true
try {
const data = formData.value as unknown as ContractClauseApi.ContractClauseVO
if (formType.value === 'create') {
await ContractClauseApi.createContractClause(data)
message.success(t('common.createSuccess'))
} else {
await ContractClauseApi.updateContractClause(data)
message.success(t('common.updateSuccess'))
}
dialogVisible.value = false
//
emit('success')
} finally {
formLoading.value = false
}
}
/** 重置表单 */
const resetForm = () => {
formData.value = {
id: undefined,
title: undefined,
type: undefined,
status: undefined,
content: undefined,
weight: undefined,
remark: undefined,
attachment: undefined
}
formRef.value?.resetFields()
}
</script>

@ -0,0 +1,171 @@
<template>
<ContentWrap>
<!-- 搜索工作栏 -->
<el-form class="-mb-15px" :model="queryParams" ref="queryFormRef" :inline="true" label-width="120px">
<el-form-item label="条款标题" prop="title">
<el-input v-model="queryParams.title" placeholder="请输入条款标题" clearable @keyup.enter="handleQuery"
class="!w-240px" />
</el-form-item>
<el-form-item label="条款类型" prop="type">
<el-select v-model="queryParams.type" placeholder="请选择条款类型" clearable class="!w-240px">
<el-option v-for="dict in getStrDictOptions(DICT_TYPE.CONTRACT_CLAUSE_TYPE)" :key="dict.value"
:label="dict.label" :value="dict.value" />
</el-select>
</el-form-item>
<el-form-item label="状态" prop="status">
<el-select v-model="queryParams.status" placeholder="请选择状态" clearable class="!w-240px">
<el-option v-for="dict in getStrDictOptions(DICT_TYPE.CONTRACT_CLAUSE_STATUS)" :key="dict.value"
:label="dict.label" :value="dict.value" />
</el-select>
</el-form-item>
<el-form-item label="创建时间" prop="createTime">
<el-date-picker v-model="queryParams.createTime" value-format="YYYY-MM-DD HH:mm:ss" type="daterange"
start-placeholder="开始日期" end-placeholder="结束日期" :default-time="[new Date('1 00:00:00'), new Date('1 23:59:59')]"
class="!w-240px" />
</el-form-item>
<el-form-item>
<el-button @click="handleQuery">
<Icon icon="ep:search" class="mr-5px" /> 搜索
</el-button>
<el-button @click="resetQuery">
<Icon icon="ep:refresh" class="mr-5px" /> 重置
</el-button>
<el-button type="primary" plain @click="openForm('create')" v-hasPermi="['xxjj:contract-clause:create']">
<Icon icon="ep:plus" class="mr-5px" /> 新增
</el-button>
<el-button type="success" plain @click="handleExport" :loading="exportLoading"
v-hasPermi="['xxjj:contract-clause:export']">
<Icon icon="ep:download" class="mr-5px" /> 导出
</el-button>
</el-form-item>
</el-form>
</ContentWrap>
<!-- 列表 -->
<ContentWrap>
<el-table v-loading="loading" :data="list" :stripe="true" :show-overflow-tooltip="true">
<el-table-column label="序号" type="index" width="70px" />
<el-table-column label="编号" align="center" prop="id" width="150px" />
<el-table-column label="条款标题" align="center" prop="title" width="150px" />
<el-table-column label="条款类型" align="center" prop="type" width="150px">
<template #default="scope">
<dict-tag :type="DICT_TYPE.CONTRACT_CLAUSE_TYPE" :value="scope.row.type" />
</template>
</el-table-column>
<el-table-column label="状态" align="center" prop="status" width="150px">
<template #default="scope">
<dict-tag :type="DICT_TYPE.CONTRACT_CLAUSE_STATUS" :value="scope.row.status" />
</template>
</el-table-column>
<el-table-column label="条款内容" align="center" prop="content" width="150px" />
<el-table-column label="权重值" align="center" prop="weight" width="150px" />
<el-table-column label="备注" align="center" prop="remark" width="150px" />
<el-table-column label="附件" align="center" prop="attachment" width="150px" />
<el-table-column label="创建时间" align="center" prop="createTime" :formatter="dateFormatter" width="150px" />
<el-table-column label="操作" align="center" width="150px">
<template #default="scope">
<el-button link type="primary" @click="openForm('update', scope.row.id)"
v-hasPermi="['xxjj:contract-clause:update']">
编辑
</el-button>
<el-button link type="danger" @click="handleDelete(scope.row.id)" v-hasPermi="['xxjj:contract-clause:delete']">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<!-- 分页 -->
<Pagination :total="total" v-model:page="queryParams.pageNo" v-model:limit="queryParams.pageSize"
@pagination="getList" />
</ContentWrap>
<!-- 表单弹窗添加/修改 -->
<ContractClauseForm ref="formRef" @success="getList" />
</template>
<script setup lang="ts" name="ContractClause">
import { DICT_TYPE, getStrDictOptions } from '@/utils/dict'
import { dateFormatter } from '@/utils/formatTime'
import download from '@/utils/download'
import * as ContractClauseApi from '@/api/xxjj/contractClause'
import ContractClauseForm from './ContractClauseForm.vue'
const message = useMessage() //
const { t } = useI18n() //
const loading = ref(true) //
const total = ref(0) //
const list = ref([]) //
const queryParams = reactive({
pageNo: 1,
pageSize: 10,
title: null,
type: null,
status: null,
createTime: []
})
const queryFormRef = ref() //
const exportLoading = ref(false) //
/** 查询列表 */
const getList = async () => {
loading.value = true
try {
const data = await ContractClauseApi.getContractClausePage(queryParams)
list.value = data.list
total.value = data.total
} finally {
loading.value = false
}
}
/** 搜索按钮操作 */
const handleQuery = () => {
queryParams.pageNo = 1
getList()
}
/** 重置按钮操作 */
const resetQuery = () => {
queryFormRef.value.resetFields()
handleQuery()
}
/** 添加/修改操作 */
const formRef = ref()
const openForm = (type: string, id?: number) => {
formRef.value.open(type, id)
}
/** 删除按钮操作 */
const handleDelete = async (id: number) => {
try {
//
await message.delConfirm()
//
await ContractClauseApi.deleteContractClause(id)
message.success(t('common.delSuccess'))
//
await getList()
} catch { }
}
/** 导出按钮操作 */
const handleExport = async () => {
try {
//
await message.exportConfirm()
//
exportLoading.value = true
const data = await ContractClauseApi.exportContractClause(queryParams)
download.excel(data, '合同条款.xls')
} catch {
} finally {
exportLoading.value = false
}
}
/** 初始化 **/
onMounted(() => {
getList()
})
</script>

@ -0,0 +1,118 @@
<template>
<Dialog :title="dialogTitle" v-model="dialogVisible">
<el-form ref="formRef" :model="formData" :rules="formRules" label-width="120px" v-loading="formLoading">
<el-form-item label="模板名称" prop="name">
<el-input v-model="formData.name" placeholder="请输入模板名称" />
</el-form-item>
<el-form-item label="合同模板类型" prop="type">
<el-select v-model="formData.type" placeholder="请选择合同模板类型">
<el-option v-for="dict in getStrDictOptions(DICT_TYPE.CONTRACT_TEMPLATE_TYPE)" :key="dict.value"
:label="dict.label" :value="dict.value" />
</el-select>
</el-form-item>
<el-form-item label="状态" prop="status">
<el-radio-group v-model="formData.status">
<el-radio v-for="dict in getStrDictOptions(DICT_TYPE.CONTRACT_TEMPLATE_STATUS)" :key="dict.value"
:label="dict.value">
{{ dict.label }}
</el-radio>
</el-radio-group>
</el-form-item>
<el-form-item label="模板描述" prop="describe">
<el-input v-model="formData.describe" placeholder="请输入模板描述" />
</el-form-item>
<el-form-item label="配置项" prop="options">
<el-input v-model="formData.options" placeholder="请输入配置项" />
</el-form-item>
</el-form>
<template #footer>
<el-button @click="submitForm" type="primary" :disabled="formLoading"> </el-button>
<el-button @click="dialogVisible = false"> </el-button>
</template>
</Dialog>
</template>
<script setup lang="ts">
import { DICT_TYPE, getStrDictOptions } from '@/utils/dict'
import * as ContractTemplateApi from '@/api/xxjj/contractTemplate'
const { t } = useI18n() //
const message = useMessage() //
const dialogVisible = ref(false) //
const dialogTitle = ref('') //
const formLoading = ref(false) // 12
const formType = ref('') // create - update -
const formData = ref({
id: undefined,
name: undefined,
type: undefined,
status: undefined,
describe: undefined,
options: undefined
})
const formRules = reactive({
name: [{ required: true, message: '模板名称不能为空', trigger: 'blur' }],
type: [{ required: true, message: '合同模板类型 参考字典contract_template_type不能为空', trigger: 'change' }],
status: [{ required: true, message: '状态 参考字典contract_template_status不能为空', trigger: 'blur' }],
describe: [{ required: true, message: '模板描述不能为空', trigger: 'blur' }],
options: [{ required: true, message: '配置项 json格式不能为空', trigger: 'blur' }]
})
const formRef = ref() // Ref
/** 打开弹窗 */
const open = async (type: string, id?: number) => {
dialogVisible.value = true
dialogTitle.value = t('action.' + type)
formType.value = type
resetForm()
//
if (id) {
formLoading.value = true
try {
formData.value = await ContractTemplateApi.getContractTemplate(id)
} finally {
formLoading.value = false
}
}
}
defineExpose({ open }) // open
/** 提交表单 */
const emit = defineEmits(['success']) // success
const submitForm = async () => {
//
if (!formRef) return
const valid = await formRef.value.validate()
if (!valid) return
//
formLoading.value = true
try {
const data = formData.value as unknown as ContractTemplateApi.ContractTemplateVO
if (formType.value === 'create') {
await ContractTemplateApi.createContractTemplate(data)
message.success(t('common.createSuccess'))
} else {
await ContractTemplateApi.updateContractTemplate(data)
message.success(t('common.updateSuccess'))
}
dialogVisible.value = false
//
emit('success')
} finally {
formLoading.value = false
}
}
/** 重置表单 */
const resetForm = () => {
formData.value = {
id: undefined,
name: undefined,
type: undefined,
status: undefined,
describe: undefined,
options: undefined
}
formRef.value?.resetFields()
}
</script>

@ -0,0 +1,172 @@
<template>
<ContentWrap>
<!-- 搜索工作栏 -->
<el-form class="-mb-15px" :model="queryParams" ref="queryFormRef" :inline="true" label-width="120px">
<el-form-item label="模板名称" prop="name">
<el-input v-model="queryParams.name" placeholder="请输入模板名称" clearable @keyup.enter="handleQuery"
class="!w-240px" />
</el-form-item>
<el-form-item label="合同模板类型" prop="type">
<el-select v-model="queryParams.type" placeholder="请选择合同模板类型" clearable
class="!w-240px">
<el-option v-for="dict in getStrDictOptions(DICT_TYPE.CONTRACT_TEMPLATE_TYPE)" :key="dict.value"
:label="dict.label" :value="dict.value" />
</el-select>
</el-form-item>
<el-form-item label="状态" prop="status">
<el-select v-model="queryParams.status" placeholder="请选择状态" clearable
class="!w-240px">
<el-option v-for="dict in getStrDictOptions(DICT_TYPE.CONTRACT_TEMPLATE_STATUS)" :key="dict.value"
:label="dict.label" :value="dict.value" />
</el-select>
</el-form-item>
<el-form-item label="创建时间" prop="createTime">
<el-date-picker v-model="queryParams.createTime" value-format="YYYY-MM-DD HH:mm:ss" type="daterange"
start-placeholder="开始日期" end-placeholder="结束日期" :default-time="[new Date('1 00:00:00'), new Date('1 23:59:59')]"
class="!w-240px" />
</el-form-item>
<el-form-item>
<el-button @click="handleQuery">
<Icon icon="ep:search" class="mr-5px" /> 搜索
</el-button>
<el-button @click="resetQuery">
<Icon icon="ep:refresh" class="mr-5px" /> 重置
</el-button>
<el-button type="primary" plain @click="openForm('create')" v-hasPermi="['xxjj:contract-template:create']">
<Icon icon="ep:plus" class="mr-5px" /> 新增
</el-button>
<el-button type="success" plain @click="handleExport" :loading="exportLoading"
v-hasPermi="['xxjj:contract-template:export']">
<Icon icon="ep:download" class="mr-5px" /> 导出
</el-button>
</el-form-item>
</el-form>
</ContentWrap>
<!-- 列表 -->
<ContentWrap>
<el-table v-loading="loading" :data="list" :stripe="true" :show-overflow-tooltip="true" fit>
<el-table-column label="序号" type="index" width="70px" />
<el-table-column label="编号" align="center" prop="id" width="150px" />
<el-table-column label="模板名称" align="center" prop="name" />
<el-table-column label="合同模板类型" align="center" prop="type" width="150px">
<template #default="scope">
<dict-tag :type="DICT_TYPE.CONTRACT_TEMPLATE_TYPE" :value="scope.row.type" />
</template>
</el-table-column>
<el-table-column label="状态" align="center" prop="status" width="150px">
<template #default="scope">
<dict-tag :type="DICT_TYPE.CONTRACT_TEMPLATE_STATUS" :value="scope.row.status" />
</template>
</el-table-column>
<!-- <el-table-column label="模板描述" align="center" prop="describe" width="150px" /> -->
<!-- <el-table-column label="配置项 json格式" align="center" prop="options" width="150px" /> -->
<el-table-column label="创建时间" align="center" prop="createTime" :formatter="dateFormatter" width="210px" />
<el-table-column label="操作" align="center" width="150px">
<template #default="scope">
<el-button link type="primary" @click="openForm('update', scope.row.id)"
v-hasPermi="['xxjj:contract-template:update']">
编辑
</el-button>
<el-button link type="danger" @click="handleDelete(scope.row.id)"
v-hasPermi="['xxjj:contract-template:delete']">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<!-- 分页 -->
<Pagination :total="total" v-model:page="queryParams.pageNo" v-model:limit="queryParams.pageSize"
@pagination="getList" />
</ContentWrap>
<!-- 表单弹窗添加/修改 -->
<ContractTemplateForm ref="formRef" @success="getList" />
</template>
<script setup lang="ts" name="ContractTemplate">
import { DICT_TYPE, getStrDictOptions } from '@/utils/dict'
import { dateFormatter } from '@/utils/formatTime'
import download from '@/utils/download'
import * as ContractTemplateApi from '@/api/xxjj/contractTemplate'
import ContractTemplateForm from './ContractTemplateForm.vue'
const message = useMessage() //
const { t } = useI18n() //
const loading = ref(true) //
const total = ref(0) //
const list = ref([]) //
const queryParams = reactive({
pageNo: 1,
pageSize: 10,
name: null,
type: null,
status: null,
createTime: []
})
const queryFormRef = ref() //
const exportLoading = ref(false) //
/** 查询列表 */
const getList = async () => {
loading.value = true
try {
const data = await ContractTemplateApi.getContractTemplatePage(queryParams)
list.value = data.list
total.value = data.total
} finally {
loading.value = false
}
}
/** 搜索按钮操作 */
const handleQuery = () => {
queryParams.pageNo = 1
getList()
}
/** 重置按钮操作 */
const resetQuery = () => {
queryFormRef.value.resetFields()
handleQuery()
}
/** 添加/修改操作 */
const formRef = ref()
const openForm = (type: string, id?: number) => {
formRef.value.open(type, id)
}
/** 删除按钮操作 */
const handleDelete = async (id: number) => {
try {
//
await message.delConfirm()
//
await ContractTemplateApi.deleteContractTemplate(id)
message.success(t('common.delSuccess'))
//
await getList()
} catch { }
}
/** 导出按钮操作 */
const handleExport = async () => {
try {
//
await message.exportConfirm()
//
exportLoading.value = true
const data = await ContractTemplateApi.exportContractTemplate(queryParams)
download.excel(data, '合同模板.xls')
} catch {
} finally {
exportLoading.value = false
}
}
/** 初始化 **/
onMounted(() => {
getList()
})
</script>
Loading…
Cancel
Save