1、首先创建四张表agreement_type（系统协议类型表）、agreement_relation_detail（系统协议表与协议详情关系表）、agreement_list（系统协议清单表）、agreement_detail（系统协议详情）
agreement_type（系统协议类型表）：
DROP TABLE IF EXISTS `agreement_type`;
CREATE TABLE `agreement_type` (
`id` bigint(64) NOT NULL COMMENT '主键',
`tenant_id` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NULL DEFAULT NULL COMMENT '租户ID',
`is_deleted` int(2) NOT NULL DEFAULT 0 COMMENT '是否删除',
`status` int(2) NOT NULL DEFAULT 1 COMMENT '状态',
`create_user` bigint(64) NOT NULL DEFAULT -1 COMMENT '创建人',
`create_dept` bigint(64) NOT NULL DEFAULT -1 COMMENT '创建部门',
`create_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
`update_user` bigint(64) NOT NULL DEFAULT -1 COMMENT '修改人',
`update_time` datetime NULL DEFAULT NULL COMMENT '修改时间',
`code` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NOT NULL DEFAULT '' COMMENT '前端编码',
`name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NOT NULL DEFAULT '' COMMENT '类型名称',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_german2_ci COMMENT = '系统协议类型表' ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;agreement_relation_detail（系统协议表与协议详情关系表）：
DROP TABLE IF EXISTS `agreement_relation_detail`;
CREATE TABLE `agreement_relation_detail` (
`agreement_list_id` bigint(64) NOT NULL COMMENT '系统协议清单id',
`agreement_detail_id` bigint(64) NOT NULL COMMENT '系统协议详情id',
PRIMARY KEY (`agreement_list_id`, `agreement_detail_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_german2_ci COMMENT = '系统协议表与协议详情关系表' ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;
agreement_list（系统协议清单表）：
DROP TABLE IF EXISTS `agreement_list`;
CREATE TABLE `agreement_list` (
`id` bigint(64) NOT NULL COMMENT '主键',
`tenant_id` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NULL DEFAULT NULL COMMENT '租户ID',
`is_deleted` int(2) NOT NULL DEFAULT 0 COMMENT '是否删除',
`status` int(2) NOT NULL DEFAULT 1 COMMENT '状态',
`create_user` bigint(64) NOT NULL DEFAULT -1 COMMENT '创建人',
`create_dept` bigint(64) NOT NULL DEFAULT -1 COMMENT '创建部门',
`create_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
`update_user` bigint(64) NOT NULL DEFAULT -1 COMMENT '修改人',
`update_time` datetime NULL DEFAULT NULL COMMENT '修改时间',
`agreement_type_id` bigint(64) NOT NULL COMMENT '协议类型id',
`name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NOT NULL COMMENT '协议名称',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_german2_ci COMMENT = '系统协议清单表' ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;agreement_detail（系统协议详情）：
DROP TABLE IF EXISTS `agreement_detail`;
CREATE TABLE `agreement_detail` (
`id` bigint(64) NOT NULL COMMENT '主键',
`tenant_id` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NULL DEFAULT NULL COMMENT '租户ID',
`is_deleted` int(2) NOT NULL DEFAULT 0 COMMENT '是否删除',
`status` int(2) NOT NULL DEFAULT 1 COMMENT '状态 1：生效中(有且只有一个),0:已失效,默认为0',
`create_user` bigint(64) NOT NULL DEFAULT -1 COMMENT '创建人',
`create_dept` bigint(64) NOT NULL DEFAULT -1 COMMENT '创建部门',
`create_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
`update_user` bigint(64) NOT NULL DEFAULT -1 COMMENT '修改人',
`update_time` datetime NULL DEFAULT NULL COMMENT '修改时间',
`name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NOT NULL COMMENT '协议标题',
`agreement_version_number` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NOT NULL COMMENT '协议版本号',
`content` mediumtext CHARACTER SET utf8mb4 COLLATE utf8mb4_german2_ci NOT NULL COMMENT '富文本内容',
`effect_time` datetime NULL DEFAULT NULL COMMENT '生效时间',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_german2_ci COMMENT = '系统协议详情' ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;2、AgreementTypeController（系统协议类型表接口）
package com.sicpay.system.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.sicpay.system.dto.AgreementTypeSaveDTO;
import com.sicpay.system.dto.AgreementTypeUpdateDTO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import lombok.AllArgsConstructor;
import javax.validation.Valid;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.RequestParam;
import com.sicpay.system.vo.AgreementTypeVO;
import com.sicpay.system.service.IAgreementTypeService;
import org.springblade.core.boot.ctrl.BladeController;
import java.util.List;
/**
* 系统协议类型表 控制器
*
*/
@RestController
@AllArgsConstructor
@RequestMapping("/agreementtype")
@Api(value = "系统协议类型表", tags = "系统协议类型表接口")
public class AgreementTypeController {
private final IAgreementTypeService agreementTypeService;
/**
* 列表 系统协议类型表
*/
@GetMapping("/list")
@ApiOperationSupport(order = 1)
@ApiOperation(value = "列表", notes = "")
public R<List<AgreementTypeVO>> list() {
return R.data(agreementTypeService.listAgreementType());
}
/**
* 详情
*/
@GetMapping("/detail")
@ApiOperationSupport(order = 2)
@ApiOperation(value = "详情", notes = "传入id")
public R<AgreementTypeVO> detail(@ApiParam(value = "id", required = true) @RequestParam Long id) {
return R.data(agreementTypeService.detail(id));
}
/**
* 修改 系统协议类型表
*/
@PostMapping("/update")
@ApiOperationSupport(order = 3)
@ApiOperation(value = "修改", notes = "传入agreementTypeUpdateDTO")
public R<Boolean> update(@Valid @RequestBody AgreementTypeUpdateDTO agreementTypeUpdateDTO) {
return R.status(agreementTypeService.update(agreementTypeUpdateDTO));
}
/**
* 新增 系统协议类型表
*/
@PostMapping("/save")
@ApiOperationSupport(order = 4)
@ApiOperation(value = "新增", notes = "传入agreementTypeSaveDTO")
public R<Boolean> save(@Valid @RequestBody AgreementTypeSaveDTO agreementTypeSaveDTO) {
return R.status(agreementTypeService.save(agreementTypeSaveDTO));
}
/**
* 分页 系统协议类型表
*/
@GetMapping("/page")
@ApiOperationSupport(order = 1)
@ApiOperation(value = "分页", notes = "传入query")
public R<IPage<AgreementTypeVO>> page(Query query) {
return R.data(agreementTypeService.page(query));
}
}
3、AgreementListController（系统协议清单表接口）
package com.sicpay.system.controller;
import com.sicpay.system.dto.AgreementDetailSaveDTO;
import com.sicpay.system.dto.AgreementDetailUpdateDTO;
import com.sicpay.system.dto.AgreementDetailUpdateStatusDTO;
import com.sicpay.system.vo.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import lombok.AllArgsConstructor;
import javax.validation.Valid;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.RequestParam;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.sicpay.system.service.IAgreementListService;
import org.springblade.core.boot.ctrl.BladeController;
import java.util.List;
/**
* 系统协议清单表 控制器
*
*/
@RestController
@AllArgsConstructor
@RequestMapping("/agreementlist")
@Api(value = "系统协议清单表", tags = "系统协议清单表接口")
public class AgreementListController {
private final IAgreementListService agreementListService;
/**
* 分页 系统协议清单表
*/
@GetMapping("/page")
@ApiOperationSupport(order = 1)
@ApiOperation(value = "分页", notes = "传入query")
public R<IPage<AgreementListVO>> page(Query query) {
IPage<AgreementListVO> pages = agreementListService.page(query);
return R.data(pages);
}
/**
* 详情
*/
@GetMapping("/detail")
@ApiOperationSupport(order = 2)
@ApiOperation(value = "详情", notes = "传入id")
public R<AgreementListDetailVO> detail(@ApiParam(value = "id", required = true) @RequestParam Long id) {
return R.data(agreementListService.detail(id));
}
/**
* 分页 历史
*/
@GetMapping("/history")
@ApiOperationSupport(order = 3)
@ApiOperation(value = "历史", notes = "传入query")
public R<IPage<AgreementHistoryListVO>> history(Query query, @ApiParam(value = "id", required = true) @RequestParam Long id) {
IPage<AgreementHistoryListVO> pages = agreementListService.history(query,id);
return R.data(pages);
}
/**
* 新增 系统协议清单表
*/
@PostMapping("/save")
@ApiOperationSupport(order = 4)
@ApiOperation(value = "新增", notes = "传入agreementList")
public R<Boolean> save(@Valid @RequestBody AgreementDetailSaveDTO agreementDetailSaveDTO) {
return R.status(agreementListService.save(agreementDetailSaveDTO));
}
/**
* 修改状态
*/
@PostMapping("/updateStatus")
@ApiOperationSupport(order = 5)
@ApiOperation(value = "修改状态", notes = "传入caseTypeUpdateStatusDTO")
public R<Boolean> updateStatus(@Valid @RequestBody AgreementDetailUpdateStatusDTO agreementDetailUpdateStatusDTO) {
return R.status(agreementListService.updateStatus(agreementDetailUpdateStatusDTO));
}
/**
* 编辑系统协议
*/
@PostMapping("/update")
@ApiOperationSupport(order = 6)
@ApiOperation(value = "编辑系统协议", notes = "传入agreementList")
public R<Boolean> update(@Valid @RequestBody AgreementDetailUpdateDTO agreementDetailUpdateDTO) {
return R.status(agreementListService.update(agreementDetailUpdateDTO));
}
/**
* 历史版本详情
*/
@GetMapping("/historyDetail")
@ApiOperationSupport(order = 7)
@ApiOperation(value = "历史版本详情", notes = "agreementDetailId")
public R<AgreementHistoryDetailVO> historyDetail(@ApiParam(value = "协议详情id", required = true) @RequestParam Long agreementDetailId) {
return R.data(agreementListService.historyDetail(agreementDetailId));
}
/**
* 根据协议类型的前端编码获取协议名称
*/
@GetMapping("/agreementNameList")
@ApiOperationSupport(order = 8)
@ApiOperation(value = "根据协议类型的前端编码获取协议名称", notes = "根据协议类型的前端编码获取协议名称")
public R<List<AgreementTypeNameVO>> agreementNameList(@ApiParam(value = "前端编码", required = true) @RequestParam String code,@ApiParam(value = "租户id", required = false) @RequestParam(required = false) String tenantId) {
return R.data(agreementListService.agreementNameList(code,tenantId));
}
/**
* 根据协议清单id获取协议内容
*/
@GetMapping("/agreementNameDetail")
@ApiOperationSupport(order = 9)
@ApiOperation(value = "根据协议清单id获取协议内容", notes = "根据协议清单id获取协议内容")
public R<String> agreementNameDetail(@ApiParam(value = "协议清单id", required = true) @RequestParam Long agreementListId,@ApiParam(value = "租户id", required = false) @RequestParam(required = false) String tenantId) {
return R.data(agreementListService.agreementNameDetail(agreementListId,tenantId));
}
}
4、IAgreementTypeService接口：
package com.sicpay.system.service;
import com.sicpay.system.dto.AgreementTypeSaveDTO;
import com.sicpay.system.dto.AgreementTypeUpdateDTO;
import com.sicpay.system.entity.AgreementType;
import com.sicpay.system.vo.AgreementTypeVO;
import org.springblade.core.mp.base.BaseService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springblade.core.mp.support.Query;
import java.util.List;
/**
* 系统协议类型表 服务类
*
*/
public interface IAgreementTypeService extends BaseService<AgreementType> {
/**
* 系统协议类型列表
* @return
*/
List<AgreementTypeVO> listAgreementType();
/**
* 详情
* @param id
* @return
*/
AgreementTypeVO detail(Long id);
/**
* 修改协议类型
* @param agreementTypeUpdateDTO 修改请求对象
* @return 是否修改成功
*/
boolean update(AgreementTypeUpdateDTO agreementTypeUpdateDTO);
/**
* 新增修改协议类型
* @param agreementTypeSaveDTO 新增协议类型
* @return 是否新增陈工
*/
boolean save(AgreementTypeSaveDTO agreementTypeSaveDTO);
/**
* 分页查询协议内容
* @param query 查询条件
* @return 分页数据
*/
IPage<AgreementTypeVO> page(Query query);
}
5、AgreementTypeServiceImpl实现
package com.sicpay.system.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.sicpay.system.dto.AgreementTypeSaveDTO;
import com.sicpay.system.dto.AgreementTypeUpdateDTO;
import com.sicpay.system.entity.AgreementType;
import com.sicpay.system.vo.AgreementTypeVO;
import com.sicpay.system.mapper.AgreementTypeMapper;
import com.sicpay.system.service.IAgreementTypeService;
import com.sicpay.system.wrapper.AgreementTypeWrapper;
import org.springblade.common.exception.ResultCodeEnum;
import org.springblade.core.log.exception.BusinessException;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.CollectionUtil;
import org.springblade.core.tool.utils.ObjectUtil;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Objects;
/**
* 系统协议类型表 服务实现类
*
*/
@Service
public class AgreementTypeServiceImpl extends BaseServiceImpl<AgreementTypeMapper, AgreementType> implements IAgreementTypeService {
@Override
public List<AgreementTypeVO> listAgreementType() {
List<AgreementType> list = this.list(Wrappers.<AgreementType>lambdaQuery()
.orderByDesc(AgreementType::getId)
);
if (CollectionUtil.isNotEmpty(list)) {
return BeanUtil.copy(list, AgreementTypeVO.class);
}
return null;
}
@Override
public AgreementTypeVO detail(Long id) {
AgreementType detail = this.getById(id);
if (ObjectUtil.isNotEmpty(detail)) {
return AgreementTypeWrapper.build().entityVO(detail);
}
return null;
}
@Override
public boolean update(AgreementTypeUpdateDTO agreementTypeUpdateDTO) {
checkAgreementTypeRepeat(agreementTypeUpdateDTO.getCode(),agreementTypeUpdateDTO.getName(),agreementTypeUpdateDTO.getId());
AgreementType agreementType = Objects.requireNonNull(BeanUtil.copy(agreementTypeUpdateDTO, AgreementType.class));
this.updateById(agreementType);
return true;
}
@Override
public boolean save(AgreementTypeSaveDTO agreementTypeSaveDTO) {
checkAgreementTypeRepeat(agreementTypeSaveDTO.getCode(),agreementTypeSaveDTO.getName(),null);
AgreementType agreementType = Objects.requireNonNull(BeanUtil.copy(agreementTypeSaveDTO, AgreementType.class));
this.save(agreementType);
return true;
}
@Override
public IPage<AgreementTypeVO> page(Query query) {
IPage<AgreementType> pages = this.page(Condition.getPage(query));
return AgreementTypeWrapper.build().pageVO(pages);
}
/**
* 校验是否存在相同协议类型前端编码以及类型名称
* @param code 前端编码
* @param name 协议类型名称
* @param agreementId 协议类型id
*/
private void checkAgreementTypeRepeat(String code,String name,Long agreementId) {
boolean isSave = ObjectUtil.isEmpty(agreementId);
if (isSave) {
exitAgreementTypeRepeatCode(code);
exitAgreementTypeRepeatName(name);
} else {
AgreementType agreementType = this.getById(agreementId);
if (ObjectUtil.isEmpty(agreementType)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_TYPE_EXIT);
}
// 过滤自己 进行校验
if(!agreementType.getCode().equals(code)) {
exitAgreementTypeRepeatCode(code);
}
// 过滤自己 进行校验
if(!agreementType.getName().equals(name)) {
exitAgreementTypeRepeatName(name);
}
}
}
/**
* 校验是否存在相同协议类型前端编码
* @param code 前端编码
*/
private void exitAgreementTypeRepeatCode(String code) {
int count = this.count(Wrappers.<AgreementType>lambdaQuery()
.eq(AgreementType::getCode, code)
);
if (count > 0) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_TYPE_CODE_REPEAT);
}
}
/**
* 校验是否存在相同协议类型名称
* @param name 协议类型名称
*/
private void exitAgreementTypeRepeatName(String name) {
int count = this.count(Wrappers.<AgreementType>lambdaQuery()
.eq(AgreementType::getName, name)
);
if (count > 0) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_TYPE_NAME_REPEAT);
}
}
}
6、IAgreementRelationDetailService接口
package com.sicpay.system.service;
import com.sicpay.system.entity.AgreementRelationDetail;
import com.sicpay.system.vo.AgreementRelationDetailVO;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.List;
/**
* 系统协议表与协议详情关系表 服务类
*
*/
public interface IAgreementRelationDetailService extends IService<AgreementRelationDetail> {
/**
* 根据清单id查询关系表
* @param agreementListId 协议清单id
* @return 关系表数据
*/
List<AgreementRelationDetail> getAgreementRelationDetailsByAgreementListId(Long agreementListId);
}
7、AgreementRelationDetailServiceImpl实现
package com.sicpay.system.service.impl;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.sicpay.system.entity.AgreementRelationDetail;
import com.sicpay.system.vo.AgreementRelationDetailVO;
import com.sicpay.system.mapper.AgreementRelationDetailMapper;
import com.sicpay.system.service.IAgreementRelationDetailService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.List;
/**
* 系统协议表与协议详情关系表 服务实现类
*
*/
@Service
public class AgreementRelationDetailServiceImpl extends ServiceImpl<AgreementRelationDetailMapper, AgreementRelationDetail> implements IAgreementRelationDetailService {
@Override
public List<AgreementRelationDetail> getAgreementRelationDetailsByAgreementListId(Long agreementListId) {
// 根据清单id查询关系表
return this.list(Wrappers.<AgreementRelationDetail>lambdaQuery()
.eq(AgreementRelationDetail::getAgreementListId, agreementListId)
);
}
}
8、IAgreementListService接口
package com.sicpay.system.service;
import com.sicpay.system.dto.AgreementDetailSaveDTO;
import com.sicpay.system.dto.AgreementDetailUpdateDTO;
import com.sicpay.system.dto.AgreementDetailUpdateStatusDTO;
import com.sicpay.system.dto.AgreementTypeNameDTO;
import com.sicpay.system.entity.AgreementList;
import com.sicpay.system.vo.*;
import org.springblade.core.mp.base.BaseService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springblade.core.mp.support.Query;
import java.util.List;
/**
* 系统协议清单表 服务类
*
*/
public interface IAgreementListService extends BaseService<AgreementList> {
/**
* 分页查询
* @param query
* @return
*/
IPage<AgreementListVO> page(Query query);
/**
* 详情
* @param id 协议清单id
* @return 协议详情
*/
AgreementListDetailVO detail(Long id);
/**
* 历史协议分页数据
* @param query 查询对象
* @param id 协议清单id
* @return 历史协议分页数据
*/
IPage<AgreementHistoryListVO> history(Query query, Long id);
/**
* 保存协议信息
* @param agreementDetailSaveDTO
* @return 是否保存成功
*/
Boolean save(AgreementDetailSaveDTO agreementDetailSaveDTO);
/**
* 修改协议清单状态
* @param agreementDetailUpdateStatusDTO 修改协议状态清单请求对象
* @return 是否修改成功
*/
Boolean updateStatus(AgreementDetailUpdateStatusDTO agreementDetailUpdateStatusDTO);
/**
* 编辑系统协议
* @param agreementDetailUpdateDTO 编辑系统协议请求对象
* @return 是否修改成功
*/
Boolean update (AgreementDetailUpdateDTO agreementDetailUpdateDTO);
/**
* 历史版本详情
* @param agreementDetailId 协议详情id
* @return 历史版本详情
*/
AgreementHistoryDetailVO historyDetail(Long agreementDetailId);
/**
* 根据协议类型的前端编码获取协议名称
* @param code 前端编码
* @param tenantId 租户id
* @return
*/
List<AgreementTypeNameVO> agreementNameList(String code, String tenantId);
/**
* 根据协议id获取协议的内容
* @param agreementListId 协议清单id
* @param tenantId 租户id
* @return
*/
String agreementNameDetail(Long agreementListId,String tenantId);
}
9、AgreementListServiceImpl实现
package com.sicpay.system.service.impl;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.sicpay.api.constant.SicpayStatusEnum;
import com.sicpay.system.dto.AgreementDetailSaveDTO;
import com.sicpay.system.dto.AgreementDetailUpdateDTO;
import com.sicpay.system.dto.AgreementDetailUpdateStatusDTO;
import com.sicpay.system.entity.AgreementDetail;
import com.sicpay.system.entity.AgreementList;
import com.sicpay.system.entity.AgreementRelationDetail;
import com.sicpay.system.entity.AgreementType;
import com.sicpay.system.service.IAgreementDetailService;
import com.sicpay.system.service.IAgreementRelationDetailService;
import com.sicpay.system.service.IAgreementTypeService;
import com.sicpay.system.vo.*;
import com.sicpay.system.mapper.AgreementListMapper;
import com.sicpay.system.service.IAgreementListService;
import com.sicpay.system.wrapper.AgreementDetailHistoryWrapper;
import com.sicpay.system.wrapper.AgreementListDetailWrapper;
import com.sicpay.system.wrapper.AgreementListWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springblade.common.constant.TenantConstant;
import org.springblade.common.exception.ResultCodeEnum;
import org.springblade.core.log.exception.BusinessException;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.utils.*;
import org.springblade.system.entity.Tenant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* 系统协议清单表 服务实现类
*
*/
@Service
@Slf4j
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class AgreementListServiceImpl extends BaseServiceImpl<AgreementListMapper, AgreementList> implements IAgreementListService {
private final IAgreementTypeService agreementTypeService;
private final IAgreementDetailService agreementDetailService;
private final IAgreementRelationDetailService agreementRelationDetailService;
private final String DEFAULT_TENANT_ID = "000000";
@Override
public IPage<AgreementListVO> page(Query query) {
IPage<AgreementList> pages = this.page(Condition.getPage(query));
return AgreementListWrapper.build(agreementTypeService,pages.getRecords()).pageVO(pages);
}
@Override
public AgreementListDetailVO detail(Long id) {
AgreementList agreementList = this.getById(id);
if (ObjectUtil.isEmpty(agreementList)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_EXIT);
}
SicpayStatusEnum statusEnum = SicpayStatusEnum.getStatusEnum(agreementList.getStatus());
if (statusEnum == SicpayStatusEnum.INVALID) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_DISABLE);
}
agreementDetailService.updateStatus(id);
return AgreementListDetailWrapper.build(agreementTypeService,agreementDetailService,agreementRelationDetailService).entityVO(agreementList);
}
@Override
public IPage<AgreementHistoryListVO> history(Query query, Long id) {
AgreementList agreementList = this.getById(id);
if (ObjectUtil.isEmpty(agreementList)) {
return null;
}
SicpayStatusEnum statusEnum = SicpayStatusEnum.getStatusEnum(agreementList.getStatus());
if (statusEnum == SicpayStatusEnum.INVALID) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_DISABLE);
}
// 根据清单id查询关系表
List<AgreementRelationDetail> agreementRelationDetails = agreementRelationDetailService.getAgreementRelationDetailsByAgreementListId(agreementList.getId());
log.info("AgreementListServiceImpl-history-根据清单id【{}】查询关系表【{}】",agreementList.getId(),agreementRelationDetails);
if (CollectionUtil.isEmpty(agreementRelationDetails)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_EXIT);
}
List<Long> agreementDetailIds = agreementRelationDetails.stream()
.map(AgreementRelationDetail::getAgreementDetailId)
.collect(Collectors.toList());
IPage<AgreementDetail> page = agreementDetailService.page(Condition.getPage(query), Wrappers.<AgreementDetail>lambdaQuery()
// 刷选出的协议详情id
.in(AgreementDetail::getId, agreementDetailIds)
// 生效时间小于当前时间，即已生效过的
.le(AgreementDetail::getEffectTime,DateUtil.now())
// 按照详情id进行倒序
.orderByDesc(AgreementDetail::getId)
);
return AgreementDetailHistoryWrapper.build().pageVO(page);
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean save(AgreementDetailSaveDTO agreementDetailSaveDTO) {
AgreementType agreementType = agreementTypeService.getById(agreementDetailSaveDTO.getAgreementTypeId());
if (ObjectUtil.isEmpty(agreementType)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_TYPE_EXIT);
}
AgreementList agreementList = Objects.requireNonNull(BeanUtil.copy(agreementDetailSaveDTO, AgreementList.class));
// 将数据保存到协议清单
this.save(agreementList);
Long agreementListId = agreementList.getId();
agreementDetailSaveDTO.setAgreementListId(agreementListId);
// 将数据保存到协议详情表
Long agreementDetailId = agreementDetailService.save(agreementDetailSaveDTO);
// 将数据保存到清单详情关系表
if (ObjectUtil.isNotEmpty(agreementListId) && ObjectUtil.isNotEmpty(agreementDetailId)) {
AgreementRelationDetail agreementRelationDetail = new AgreementRelationDetail();
agreementRelationDetail.setAgreementListId(agreementListId);
agreementRelationDetail.setAgreementDetailId(agreementDetailId);
agreementRelationDetailService.save(agreementRelationDetail);
return true;
}
return false;
}
@Override
public Boolean updateStatus(AgreementDetailUpdateStatusDTO agreementDetailUpdateStatusDTO) {
this.update(Wrappers.<AgreementList>lambdaUpdate()
.set(AgreementList::getStatus,agreementDetailUpdateStatusDTO.getStatus())
.eq(AgreementList::getId,agreementDetailUpdateStatusDTO.getId())
);
return true;
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean update(AgreementDetailUpdateDTO agreementDetailUpdateDTO) {
AgreementList agreementList = this.getById(agreementDetailUpdateDTO.getId());
if (ObjectUtil.isEmpty(agreementList)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_EXIT);
}
// 修改协议清单表中的数据
agreementList.setName(agreementDetailUpdateDTO.getName());
this.updateById(agreementList);
// 根据查询清单与详情的关系表
List<AgreementRelationDetail> agreementRelationDetails = agreementRelationDetailService.getAgreementRelationDetailsByAgreementListId(agreementList.getId());
log.info("AgreementListServiceImpl-history-根据清单id【{}】查询关系表【{}】",agreementList.getId(),agreementRelationDetails);
if (CollectionUtil.isEmpty(agreementRelationDetails)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_EXIT);
}
// 根据id的集合查询详情表中的数据，并通过生效时间(尚未到生效时间)、生效状态(已生效)进行刷选 即，刷选草稿状态的协议数据
List<Long> detailIds = agreementRelationDetails.stream()
.map(AgreementRelationDetail::getAgreementDetailId)
.collect(Collectors.toList());
List<AgreementDetail> agreementDetails = agreementDetailService.getValidAgreementDetailByDetailIds(detailIds);
if (CollectionUtil.isNotEmpty(agreementDetails)) {
// 设置协议详情id
agreementDetailUpdateDTO.setAgreementDetailId(agreementDetails.get(0).getId());
// 协议详情表中存在数据时，做修改操作
agreementDetailService.update(agreementDetailUpdateDTO);
} else {
// 协议详情表中不存在数据时，做新增操作
AgreementDetailSaveDTO agreementDetailSaveDTO = Objects.requireNonNull(BeanUtil.copy(agreementDetailUpdateDTO, AgreementDetailSaveDTO.class));
agreementDetailSaveDTO.setAgreementTypeId(agreementList.getAgreementTypeId());
agreementDetailSaveDTO.setAgreementListId(agreementList.getId());
// 将数据保存到协议详情表
Long agreementDetailId = agreementDetailService.save(agreementDetailSaveDTO);
AgreementRelationDetail agreementRelationDetail = new AgreementRelationDetail();
agreementRelationDetail.setAgreementListId(agreementList.getId());
agreementRelationDetail.setAgreementDetailId(agreementDetailId);
agreementRelationDetailService.save(agreementRelationDetail);
}
return true;
}
@Override
public AgreementHistoryDetailVO historyDetail(Long agreementDetailId) {
AgreementDetail agreementDetail = agreementDetailService.getById(agreementDetailId);
if (ObjectUtil.isEmpty(agreementDetail)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_EXIT);
}
return Objects.requireNonNull(BeanUtil.copy(agreementDetail, AgreementHistoryDetailVO.class));
}
@Override
public List<AgreementTypeNameVO> agreementNameList(String code, String tenantId) {
if (StringUtil.isBlank(tenantId)) {
tenantId = DEFAULT_TENANT_ID;
}
List<AgreementTypeNameVO> result = new ArrayList<>();
AgreementType agreementType = agreementTypeService.getOne(Wrappers.<AgreementType>lambdaQuery()
.eq(AgreementType::getCode, code)
.eq(AgreementType::getTenantId,tenantId)
);
if (ObjectUtil.isEmpty(agreementType)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_CODE_ERROR);
}
List<AgreementList> list = this.list(Wrappers.<AgreementList>lambdaQuery()
.eq(AgreementList::getAgreementTypeId, agreementType.getId())
.eq(AgreementList::getStatus,SicpayStatusEnum.VALID.getCode())
.orderByAsc(AgreementList::getId)
);
if (CollectionUtil.isNotEmpty(list)) {
list.forEach(agreementList -> {
agreementDetailService.updateStatus(agreementList.getId());
// 根据清单id查询关系表
List<AgreementRelationDetail> agreementRelationDetails = agreementRelationDetailService.getAgreementRelationDetailsByAgreementListId(agreementList.getId());
log.info("AgreementListServiceImpl-agreementNameList-根据清单id【{}】查询关系表【{}】",agreementList.getId(),agreementRelationDetails);
if (CollectionUtil.isNotEmpty(agreementRelationDetails)) {
// 根据id的集合查询详情表中的数据
List<Long> detailIds = agreementRelationDetails.stream()
.map(AgreementRelationDetail::getAgreementDetailId)
.collect(Collectors.toList());
// 获取状态为生效，且已到生效时间 id倒序
List<AgreementDetail> agreementDetails = agreementDetailService.getEffectValidAgreementDetailByDetailIds(detailIds);
AgreementTypeNameVO agreementTypeNameVO = new AgreementTypeNameVO();
agreementTypeNameVO.setAgreementName(agreementDetails.get(0).getName());
agreementTypeNameVO.setAgreementListId(agreementList.getId());
agreementTypeNameVO.setCode(agreementType.getCode());
result.add(agreementTypeNameVO);
}
});
}
return result;
}
@Override
public String agreementNameDetail(Long agreementListId,String tenantId) {
if (StringUtil.isBlank(tenantId)) {
tenantId = DEFAULT_TENANT_ID;
}
AgreementList agreementList = this.getOne(Wrappers.<AgreementList>lambdaQuery()
.eq(AgreementList::getId,agreementListId)
.eq(AgreementList::getTenantId,tenantId)
);
if (ObjectUtil.isNotEmpty(agreementList)) {
SicpayStatusEnum statusEnum = SicpayStatusEnum.getStatusEnum(agreementList.getStatus());
if (statusEnum == SicpayStatusEnum.INVALID) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_DISABLE);
}
// 修改协议详情状态
agreementDetailService.updateStatus(agreementListId);
// 根据查询清单与详情的关系表
List<AgreementRelationDetail> agreementRelationDetails = agreementRelationDetailService.getAgreementRelationDetailsByAgreementListId(agreementList.getId());
log.info("AgreementListServiceImpl-agreementNameDetail-根据清单id【{}】查询关系表【{}】",agreementList.getId(),agreementRelationDetails);
if (CollectionUtil.isNotEmpty(agreementRelationDetails)) {
// 根据id的集合查询详情表中的数据
List<Long> detailIds = agreementRelationDetails.stream()
.map(AgreementRelationDetail::getAgreementDetailId)
.collect(Collectors.toList());
// 获取状态为生效，且已到生效时间 id倒序
List<AgreementDetail> effectValidAgreementDetailByDetailIds = agreementDetailService.getEffectValidAgreementDetailByDetailIds(detailIds);
if (CollectionUtil.isNotEmpty(effectValidAgreementDetailByDetailIds)) {
return effectValidAgreementDetailByDetailIds.get(0).getContent();
}
}
}
return null;
}
}
10、IAgreementDetailService接口
package com.sicpay.system.service;
import com.sicpay.system.dto.AgreementDetailSaveDTO;
import com.sicpay.system.dto.AgreementDetailUpdateDTO;
import com.sicpay.system.entity.AgreementDetail;
import com.sicpay.system.vo.AgreementDetailVO;
import org.springblade.core.mp.base.BaseService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.List;
/**
* 系统协议详情 服务类
*
*/
public interface IAgreementDetailService extends BaseService<AgreementDetail> {
/**
* 保存到协议详情表
* @param agreementDetailSaveDTO 协议数据
* @return
*/
Long save(AgreementDetailSaveDTO agreementDetailSaveDTO);
/**
* 修改协议详情
* @param agreementDetailUpdateDTO 修改协议详情
* @return
*/
Boolean update (AgreementDetailUpdateDTO agreementDetailUpdateDTO);
/**
* 更新协议详情中的状态
* @param agreementListId 协议清单id
* @return
*/
Boolean updateStatus(Long agreementListId);
/**
* 获取状态为生效，但尚未到生效时间的协议详情 id倒序
* @param detailIds 详情id集合
* @return 协议详情集合
*/
List<AgreementDetail> getValidAgreementDetailByDetailIds(List<Long> detailIds);
/**
* 获取状态为生效，且已到生效时间 id倒序
* @param detailIds 详情id集合
* @return 协议详情集合
*/
List<AgreementDetail> getEffectValidAgreementDetailByDetailIds(List<Long> detailIds);
}
11、AgreementDetailServiceImpl实现
package com.sicpay.system.service.impl;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.sicpay.api.constant.SicpayStatusEnum;
import com.sicpay.system.dto.AgreementDetailSaveDTO;
import com.sicpay.system.dto.AgreementDetailUpdateDTO;
import com.sicpay.system.entity.AgreementDetail;
import com.sicpay.system.entity.AgreementRelationDetail;
import com.sicpay.system.mapper.AgreementDetailMapper;
import com.sicpay.system.service.IAgreementDetailService;
import com.sicpay.system.service.IAgreementRelationDetailService;
import lombok.RequiredArgsConstructor;
import org.springblade.common.constant.SwitchConstant;
import org.springblade.common.exception.ResultCodeEnum;
import org.springblade.core.log.exception.BusinessException;
import org.springblade.core.mp.base.BaseServiceImpl;
import org.springblade.core.tool.utils.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
/**
* 系统协议详情 服务实现类
*
* @author liuhaijin
* @since 2022-06-09
*/
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class AgreementDetailServiceImpl extends BaseServiceImpl<AgreementDetailMapper, AgreementDetail> implements IAgreementDetailService {
private final IAgreementRelationDetailService agreementRelationDetailService;
@Override
@Transactional(rollbackFor = Exception.class)
public Long save(AgreementDetailSaveDTO agreementDetailSaveDTO) {
checkAgreementDetailRepeat(agreementDetailSaveDTO.getAgreementVersionNumber(),null,agreementDetailSaveDTO.getAgreementListId());
AgreementDetail agreementDetail = Objects.requireNonNull(BeanUtil.copy(agreementDetailSaveDTO, AgreementDetail.class));
// 是否立即生效
Integer effectiveImmediately = agreementDetailSaveDTO.getEffectiveImmediately();
if (SwitchConstant.ON.equals(effectiveImmediately)) {
agreementDetail.setEffectTime(DateUtil.now());
} else {
Date effectTime = agreementDetailSaveDTO.getEffectTime();
checkEffectDate(effectTime);
}
boolean save = this.save(agreementDetail);
if (save) {
return agreementDetail.getId();
}
return null;
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean update(AgreementDetailUpdateDTO agreementDetailUpdateDTO) {
checkAgreementDetailRepeat(agreementDetailUpdateDTO.getAgreementVersionNumber(),agreementDetailUpdateDTO.getAgreementDetailId(),agreementDetailUpdateDTO.getId());
AgreementDetail agreementDetail = Objects.requireNonNull(BeanUtil.copy(agreementDetailUpdateDTO, AgreementDetail.class));
agreementDetail.setId(agreementDetailUpdateDTO.getAgreementDetailId());
// 是否立即生效
Integer effectiveImmediately = agreementDetailUpdateDTO.getEffectiveImmediately();
if (SwitchConstant.ON.equals(effectiveImmediately)) {
agreementDetail.setEffectTime(DateUtil.now());
} else {
Date effectTime = agreementDetailUpdateDTO.getEffectTime();
checkEffectDate(effectTime);
}
return this.updateById(agreementDetail);
}
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean updateStatus(Long agreementListId) {
// 根据清单id查询关系表
List<AgreementRelationDetail> agreementRelationDetails = agreementRelationDetailService.getAgreementRelationDetailsByAgreementListId(agreementListId);
if (CollectionUtil.isNotEmpty(agreementRelationDetails)) {
// 刷选出关系表中的协议详情id
List<Long> detailIds = agreementRelationDetails.stream()
.map(AgreementRelationDetail::getAgreementDetailId)
.collect(Collectors.toList());
// 将刷选出的元素设置为已失效
if (CollectionUtil.isNotEmpty(detailIds)) {
// 刷选出关系表数据中已经生效的协议
List<AgreementDetail> agreementDetails = this.list(Wrappers.<AgreementDetail>lambdaQuery()
.in(AgreementDetail::getId, detailIds)
// 已生效
.le(AgreementDetail::getEffectTime, DateUtil.now())
);
// 将协议详情表中的详情id进行倒序，并跳过第一个元素（第一个元素为当前正在使用的版本）
List<Long> agreementDetailIds = agreementDetails.stream()
.sorted(Comparator.comparing(AgreementDetail::getId).reversed())
.map(AgreementDetail::getId)
.skip(1)
.collect(Collectors.toList());
// 将除第一个元素外的其他的所有元素设置为已失效
if (CollectionUtil.isNotEmpty(agreementDetailIds)) {
this.update(Wrappers.<AgreementDetail>lambdaUpdate()
.set(AgreementDetail::getStatus,SicpayStatusEnum.INVALID.getCode())
.in(AgreementDetail::getId,agreementDetailIds)
);
}
}
}
return true;
}
@Override
public List<AgreementDetail> getValidAgreementDetailByDetailIds(List<Long> detailIds) {
return this.list(Wrappers.<AgreementDetail>lambdaQuery()
.in(AgreementDetail::getId, detailIds)
// 生效时间大于当前时间，即尚未生效
.ge(AgreementDetail::getEffectTime, DateUtil.now())
// 状态为已生效
.eq(AgreementDetail::getStatus, SicpayStatusEnum.VALID.getCode())
// 通过id进行倒序
.orderByDesc(AgreementDetail::getId)
);
}
@Override
public List<AgreementDetail> getEffectValidAgreementDetailByDetailIds(List<Long> detailIds) {
return this.list(Wrappers.<AgreementDetail>lambdaQuery()
.in(AgreementDetail::getId, detailIds)
// 生效时间小于当前时间，即已生效
.le(AgreementDetail::getEffectTime, DateUtil.now())
// 状态为已生效
.eq(AgreementDetail::getStatus, SicpayStatusEnum.VALID.getCode())
// 通过id进行倒序
.orderByDesc(AgreementDetail::getId)
);
}
/**
* 校验是否存在相同的协议版本号
* @param agreementVersionNumber 协议版本号
* @param agreementDetailId 协议详情id
* @param agreementListId 协议清单id
*/
private void checkAgreementDetailRepeat(String agreementVersionNumber,Long agreementDetailId,Long agreementListId) {
boolean isSave = ObjectUtil.isEmpty(agreementDetailId);
if (isSave) {
exitAgreementDetailRepeatVersion(agreementVersionNumber,agreementListId);
} else {
AgreementDetail agreementDetail = this.getById(agreementDetailId);
if (ObjectUtil.isEmpty(agreementDetail)) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_EXIT);
}
// 过滤自己 进行校验
if(!agreementDetail.getAgreementVersionNumber().equals(agreementVersionNumber)) {
exitAgreementDetailRepeatVersion(agreementVersionNumber,agreementListId);
}
}
}
/**
* 校验是否存在相同的协议版本号
* @param agreementVersionNumber 协议版本号
* @param agreementListId 协议清单id
*/
private void exitAgreementDetailRepeatVersion(String agreementVersionNumber,Long agreementListId) {
List<AgreementRelationDetail> list = agreementRelationDetailService.list(Wrappers.<AgreementRelationDetail>lambdaQuery()
.eq(AgreementRelationDetail::getAgreementListId, agreementListId)
);
if (CollectionUtil.isNotEmpty(list)) {
List<Long> agreementDetailIds = list.stream().map(AgreementRelationDetail::getAgreementDetailId).collect(Collectors.toList());
int count = this.count(Wrappers.<AgreementDetail>lambdaQuery()
.eq(AgreementDetail::getAgreementVersionNumber, agreementVersionNumber)
.in(AgreementDetail::getId,agreementDetailIds)
);
if (count > 0) {
throw new BusinessException(ResultCodeEnum.AGREEMENT_VERSION_REPEAT);
}
}
}
/**
* 校验起始时间是否小于当前时间，起始时间是否大于终止时间
* @param effectTime 生效时间
*/
public static void checkEffectDate(Date effectTime){
if (effectTime == null) {
throw new BusinessException(ResultCodeEnum.EFFECT_TIME_BLANK);
}
// 获取当前的时间
Date today = DateUtil.now();
// compareTo()方法的返回值，第一个时间小于第二个时间返回-1，第一个时间大于第二个时间返回返回1，相等返回0
int compare = today.compareTo(effectTime);
// 生效时间小于当前时间，抛出异常
if (compare > 0) {
throw new BusinessException(ResultCodeEnum.EFFECT_TIME_ERROR);
}
}
}