Commit 31c41312 authored by fangxinjiang's avatar fangxinjiang

Merge remote-tracking branch 'origin/MVP1.7.5' into MVP1.7.5

parents f79e37a3 3076dea4
......@@ -114,6 +114,7 @@
<module>yifu-msg</module>
<module>yifu-permission</module>
<module>yifu-ekp</module>
<module>yifu-process</module>
</modules>
<dependencyManagement>
......
......@@ -42,5 +42,6 @@
<module>yifu-common-swagger</module>
<module>yifu-common-ldap</module>
<module>yifu-common-ekp</module>
<module>yifu-common-process</module>
</modules>
</project>
......@@ -108,6 +108,8 @@ public interface CacheConstants {
**/
String EVERYDAY_DISPATCH_CODE = "everyday_dispatch_code";
String EVERYDAY_UNBUY_CODE = "everyday_unbuy_code";
/**
* 区域数据--标签
*/
......@@ -202,4 +204,7 @@ public interface CacheConstants {
public static final String MVP_TOC_PHONE_CODE_PREFIX = "MVP_TOC_PHONE_CODE_";
public static final String WX_JSAPI_TICKET = "WX_JSAPI_TICKET";
// 商险不购买审批流分布式锁key InsuranceUnpurchase
public static final String INSURANCEUNPURCHASE_PROCESS_CACHE = ServiceNameConstants.SERVICE_NAME_MVP + "_" + "ProcessCache:InsuranceUnpurchase";
}
......@@ -636,4 +636,18 @@ public interface CommonConstants {
String USER_DIR = "user.dir";
String DOUBLE_LINE = "//";
public static final int THIRTY_INT = 30;
public static final int TWENTY_SEVEN_INT = 27;
/**
*未删除标志
**/
public static final String NOT_DELETE_FLAG = "0";
/**
*已删除标志
**/
public static final String DELETE_FLAG = "1";
//单条数据检索SQL
public static final String SQL_LIMIT_ONE = " limit 1 ";
}
......@@ -50,4 +50,6 @@ public interface ServiceNameConstants {
* hr b端Client id
**/
String CLIENT_ID_HR_B = "hrCustomer";
String SERVICE_NAME_MVP = "mvp";
}
......@@ -93,6 +93,37 @@ public class Common {
return false;
}
/**
* 集合不为空
*
* @param collection
* @return
*/
public static boolean isNotKong(Collection collection) {
return null != collection && collection.size() > 0;
}
/**
* obj不是null
*
* @param obj
* @return
* @author: fxj
*/
public static boolean isNotKong(Object obj) {
return null != obj;
}
/**
* 集合为空
*
* @param collection
* @return
*/
public static boolean isEmpty(Collection collection) {
return null == collection || collection.size() == 0;
}
// 金额验证
public static boolean isNumber(String str) {
// 判断小数点后2位的数字的正则表达式
......
package com.yifu.cloud.plus.v1.yifu.common.core.util.bean;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
import java.util.HashSet;
import java.util.Set;
/**
* @auther wangan
* @date 2019/12/3
* bean复制,忽视空串
*/
public class BeanCopyUtils {
public static String[] getNullPropertyNames(Object source) {
final BeanWrapper src = new BeanWrapperImpl(source);
java.beans.PropertyDescriptor[] pds = src.getPropertyDescriptors();
Set<String> emptyNames = new HashSet<>();
for (java.beans.PropertyDescriptor pd : pds) {
Object srcValue = src.getPropertyValue(pd.getName());
if (srcValue == null) {
emptyNames.add(pd.getName());
}
}
String[] result = new String[emptyNames.size()];
return emptyNames.toArray(result);
}
public static void copyProperties(Object src, Object target) {
BeanUtils.copyProperties(src, target, getNullPropertyNames(src));
}
}
......@@ -62,6 +62,18 @@
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-process-api</artifactId>
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-process</artifactId>
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
</dependencies>
<properties>
......@@ -69,4 +81,4 @@
<maven.compiler.target>8</maven.compiler.target>
</properties>
</project>
\ No newline at end of file
</project>
package com.yifu.cloud.plus.v1.yifu.common.dapr.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
/**
* @author chenyuxi
* @date 2025/01/09
* @version 1.7.5
*/
@Data
@Component
@PropertySource("classpath:daprConfig.properties")
@ConfigurationProperties(value = "dapr.process", ignoreInvalidFields = false)
public class DaprProcessProperties {
String appUrl;
String appId;
String appPort;
String httpPort;
String grpcPort;
String metricsPort;
}
package com.yifu.cloud.plus.v1.yifu.common.dapr.util;
import com.yifu.cloud.plus.v1.yifu.common.dapr.config.DaprProcessProperties;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
/**
* @Author huyc
* @Date 2022-07-18
* @Description
* @Version 1.0
*/
@Log4j2
@EnableConfigurationProperties(DaprProcessProperties.class)
public class ProcessDaprUtils {
@Autowired
private DaprProcessProperties daprProcessProperties;
}
......@@ -7,6 +7,7 @@ import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.dapr.config.DaprSocialProperties;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.EkpInsuranceViewVo;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.EkpSocialViewVo;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonCardVo;
import com.yifu.cloud.plus.v1.yifu.salary.vo.HaveSalaryNoSocialSearchVo;
import com.yifu.cloud.plus.v1.yifu.salary.vo.HaveSalaryNoSocialVo;
import com.yifu.cloud.plus.v1.yifu.salary.vo.TPaymentVo;
......@@ -157,4 +158,15 @@ public class SocialDaprUtils {
public R<Boolean> updateIncomeSettleStatus(List<EkpInsuranceViewVo> infoVo) {
return HttpDaprUtil.invokeMethodPost(daprProperties.getAppUrl(),daprProperties.getAppId(),"/tincome/inner/updateIncomeSettleStatus", JSON.toJSONString(infoVo), Boolean.class, SecurityConstants.FROM_IN);
}
/**
* @Author huyc
* @Description 更新结算信息
* @Date 17:38 2022/12/26
* @Param
* @return
**/
public R<Boolean> selectExitSocialInjury(TInsuranceUnpurchasePersonCardVo cardVo) {
return HttpDaprUtil.invokeMethodPost(daprProperties.getAppUrl(),daprProperties.getAppId(),"/tsocialfundinfo/inner/selectExitSocialInjury", JSON.toJSONString(cardVo), Boolean.class, SecurityConstants.FROM_IN);
}
}
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common</artifactId>
<version>1.0.0</version>
</parent>
<artifactId>yifu-common-process</artifactId>
<packaging>jar</packaging>
<description>审批流程-工具类</description>
<dependencies>
<!-- core 工具类 -->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-core</artifactId>
</dependency>
<!--UPMS API-->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-upms-api</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot</artifactId>
</dependency>
<!--swagger 注解-->
<dependency>
<groupId>io.swagger.core.v3</groupId>
<artifactId>swagger-annotations</artifactId>
</dependency>
<!--mybatis 依赖-->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-mybatis</artifactId>
</dependency>
<!-- 编译表达式 -->
<dependency>
<groupId>com.googlecode.aviator</groupId>
<artifactId>aviator</artifactId>
<version>2.0</version>
</dependency>
</dependencies>
</project>
package com.yifu.cloud.plus.v1.yifu.process.constant;
/**
* @auther wangan
* @date 2020/9/17
*/
public class ProcessConstants {
//审批中心各个节点类型
public static final String PROCESS_NODE_TYPE_CHOICE = "choice";
public static final String PROCESS_NODE_BEGIN = "begin";
public static final String PROCESS_NODE_END = "end";
public static final String PROCESS_NODE_EMBED = "embed";
public static final String PROCESS_NODE_SERVICE = "service";
// 【含风险项目商险不购买申请流程】条件判断审批节点名称
public static final String PROCESS_NODE_INSURANCEUNPURCHASE_REASON_TYPE = "是否为已购买社保";
public static final String PROCESS_NODE_INSURANCEUNPURCHASE_DEPT_PROPERTY = "是否属于子分公司";
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
/**
* 流程处理权限表(允许多个,多个代表有主办和经办)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_node_primission")
@Schema(description = "流程处理权限表(允许多个,多个代表有主办和经办)")
public class TNodePrimission extends Model<TNodePrimission> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@Length(max = 255, message = "指定用户处理节点不能超过255个字符")
@Schema(description = "指定用户处理节点")
private String user;
@Length(max = 255, message = "指定权限处理节点不能超过255个字符")
@Schema(description = "指定权限处理节点")
private String role;
@Length(max = 255, message = "指定职位处理节点不能超过255个字符")
@Schema(description = "指定职位处理节点")
private String post;
@Length(max = 255, message = "指定组织处理节点不能超过255个字符")
@Schema(description = "指定组织处理节点")
private String organization;
@NotBlank(message = "与流程申请人关系(0发起人部门主管/1同区域最高级/2所在单位最高级)不能为空")
@Length(max = 1, message = "与流程申请人关系(0发起人部门主管/1同区域最高级/2所在单位最高级)不能超过1个字符")
@Schema(description = "与流程申请人关系(0发起人部门主管/1同区域最高级/2所在单位最高级)")
private String realationCreateUser;
@NotBlank(message = "标识(系统自动生成MD5串)不能为空")
@Length(max = 255, message = "标识(系统自动生成MD5串)不能超过255个字符")
@Schema(description = "标识(系统自动生成MD5串)")
private String logoTitle;
@NotBlank(message = "节点ID不能为空")
@Length(max = 255, message = "节点ID不能超过255个字符")
@Schema(description = "节点ID")
private String nodeId;
@NotBlank(message = "办理类型(0主办/1经办;如果为经办,则必须有主办权限存在)不能为空")
@Length(max = 1, message = "办理类型(0主办/1经办;如果为经办,则必须有主办权限存在)不能超过1个字符")
@Schema(description = "办理类型(0主办/1经办;如果为经办,则必须有主办权限存在)")
private String dealType;
@NotBlank(message = "流程ID不能为空")
@Length(max = 255, message = "流程ID不能超过255个字符")
@Schema(description = "流程ID")
private String processId;
@NotBlank(message = "节点编码不能为空")
@Length(max = 255, message = "节点编码不能超过255个字符")
@Schema(description = "节点编码-关联节点")
private String nodeLogoTitle;
@Length(max = 1, message = "类型:不能超过1个字符")
@Schema(description = "类型:0指定职位;1与申请人关系;2指定权限;3指定用户;4指定组织;5指定角色(crm);6指定事业部配置表")
private Integer type;
@Length(max = 20, message = "指定角色id不能超过20个字符")
@Schema(description = "指定角色id")
private String approvalRole;
@Length(max = 10, message = "指定事业部配置表负责人标识不能超过10个字符")
@Schema(description = "指定事业部配置表负责人标识")
private String divisionIdentification;
@Length(max = 1, message = "是否允许直接通过不能超过1个字符")
@Schema(description = "是否允许直接通过(0:不允许,1允许)")
private String isPass;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
/**
* 流程审阅权限表(抄送/仅有查看权限)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_node_reader_promission")
@Schema(description = "流程审阅权限表(抄送/仅有查看权限)")
public class TNodeReaderPromission extends Model<TNodeReaderPromission> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@Length(max = 255, message = "指定用户处理节点不能超过255个字符")
@Schema(description = "指定用户处理节点")
private String user;
@Length(max = 255, message = "指定权限处理节点不能超过255个字符")
@Schema(description = "指定权限处理节点")
private String role;
@Length(max = 255, message = "指定职位处理节点不能超过255个字符")
@Schema(description = "指定职位处理节点")
private String post;
@Length(max = 255, message = "指定组织处理节点不能超过255个字符")
@Schema(description = "指定组织处理节点")
private String organization;
@NotBlank(message = "与流程申请人关系(0上级/1同区域最高级/2同部门最高级)不能为空")
@Length(max = 1, message = "与流程申请人关系(0上级/1同区域最高级/2同部门最高级)不能超过1个字符")
@Schema(description = "与流程申请人关系(0上级/1同区域最高级/2同部门最高级)")
private String realationCreateUser;
@NotBlank(message = "标识(系统自动生成MD5串)不能为空")
@Length(max = 255, message = "标识(系统自动生成MD5串)不能超过255个字符")
@Schema(description = "标识(系统自动生成MD5串)")
private String logoTitle;
@NotBlank(message = "节点ID不能为空")
@Length(max = 255, message = "节点ID不能超过255个字符")
@Schema(description = "节点ID")
private String nodeId;
@NotBlank(message = "流程ID不能为空")
@Length(max = 255, message = "流程ID不能超过255个字符")
@Schema(description = "流程ID")
private String processId;
@NotBlank(message = "节点编码不能为空")
@Length(max = 255, message = "节点编码不能超过255个字符")
@Schema(description = "节点编码")
private String nodeLogoTitle;
@Length(max = 1, message = "类型:不能超过1个字符")
@Schema(description = "类型:0指定职位;1与申请人关系;2指定权限;3指定用户;4指定组织;5指定角色(crm)")
private Integer type;
@Length(max = 20, message = "指定角色id不能超过20个字符")
@Schema(description = "指定角色id")
private String approvalRole;
@Length(max = 20, message = "指定使用的代码自定义判断的标识字段不能超过20个字符")
@Schema(description = "指定使用的代码自定义判断的标识字段")
private String customizeField;
@Schema(description = "是否代码自定义")
private String isCustomize;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.time.LocalDateTime;
import java.util.List;
/**
* 流程路由表(节点与节点之间的路由关系)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_node_route")
@Schema(description = "流程路由表(节点与节点之间的路由关系)")
public class TNodeRoute extends Model<TNodeRoute> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "流程ID不能为空")
@Length(max = 255, message = "流程ID不能超过255个字符")
@Schema(description = "流程ID")
private String processId;
@Length(max = 255, message = "前置节点不能超过255个字符")
@Schema(description = "前置节点")
private String prewNode;
@NotBlank(message = "下个节点不能为空")
@Length(max = 255, message = "下个节点不能超过255个字符")
@Schema(description = "下个节点")
private String nextNode;
@Length(max = 1, message = "连线起点位置不能超过1个字符")
@Schema(description = "连线起点位置")
private String preNodeAnchor;
@Length(max = 1, message = "连线终点位置不能超过1个字符")
@Schema(description = "连线终点位置")
private String nextNodeAnchor;
@Length(max = 100, message = "元素的图形:不能超过100个字符")
@Schema(description = "元素的图形")
private String shape;
@Length(max = 255, message = "标识(系统自动生成MD5串)不能超过255个字符")
@Schema(description = "标识(系统自动生成MD5串)")
private String logoTitle;
@NotBlank(message = "创建人不能为空")
@Length(max = 255, message = "创建人不能超过255个字符")
@Schema(description = "创建人")
private String createUser;
@Schema(description = "创建时间")
private LocalDateTime createDate;
@Length(max = 255, message = "更新人不能超过255个字符")
@Schema(description = "更新人")
private String updateUser;
@Schema(description = "更新时间")
private LocalDateTime updateDate;
@NotBlank(message = "路由名称(默认为“未命名”,添加时需要保存格式为:前置节点名称(to:下一节点名称))不能为空")
@Length(max = 255, message = "路由名称(默认为“未命名”,添加时需要保存格式为:前置节点名称(to:下一节点名称))不能超过255个字符")
@Schema(description = "路由名称(默认为“未命名”,添加时需要保存格式为:前置节点名称(to:下一节点名称))")
private String name;
@Length(max = 255, message = "描述不能超过255个字符")
@Schema(description = "描述")
private String description;
@Schema(description = "顺序号")
private Integer sequenceNo;
@Length(max = 255, message = "默认意见不能超过255个字符")
@Schema(description = "默认意见")
private String opinion;
@NotBlank(message = "意见是否必填(0是/1否)不能为空")
@Length(max = 1, message = "意见是否必填(0是/1否)不能超过1个字符")
@Schema(description = "意见是否必填(0是/1否)")
private String opinionMustFlag;
@NotBlank(message = "路由类型(1默认路由/2回退路由/3转交(转交不触发活动事件))不能为空")
@Length(max = 1, message = "路由类型(1默认路由/2回退路由/3转交(转交不触发活动事件))不能超过1个字符")
@Schema(description = "路由类型(1默认路由/2回退路由/3转交(转交不触发活动事件))")
private String routeType;
@NotBlank(message = "是否优先(0是/1否:仅在分支/并列下使用,单节点路由不存在优先级)不能为空")
@Length(max = 1, message = "是否优先(0是/1否:仅在分支/并列下使用,单节点路由不存在优先级)不能超过1个字符")
@Schema(description = "是否优先(0是/1否:仅在分支/并列下使用,单节点路由不存在优先级)")
private String priorityFlag;
@NotBlank(message = "活动超时时自动流转(0是/1否)不能为空")
@Length(max = 1, message = "活动超时时自动流转(0是/1否)不能超过1个字符")
@Schema(description = "活动超时时自动流转(0是/1否)")
private String timeoutRoam;
@NotBlank(message = "与上一活动处理人相同时自动流转(0是/1否)不能为空")
@Length(max = 1, message = "与上一活动处理人相同时自动流转(0是/1否)不能超过1个字符")
@Schema(description = "与上一活动处理人相同时自动流转(0是/1否)")
private String sameForPrew;
@TableField(exist = false)
List<TNodeRouteCondition> nodeRouteConditionList;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
/**
* 流程路由条件
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_node_route_condition")
@Schema(description = "流程路由条件")
public class TNodeRouteCondition extends Model<TNodeRouteCondition> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "条件字段不能为空")
@Length(max = 255, message = "条件字段不能超过255个字符")
@Schema(description = "条件字段")
private String field;
@NotBlank(message = "判断条件:大于/等于/大于等于/小于/小于等于/不等于/包含/不包含不能为空")
@Length(max = 255, message = "判断条件:大于/等于/大于等于/小于/小于等于/不等于/包含/不包含不能超过255个字符")
@Schema(description = "判断条件:大于/等于/大于等于/小于/小于等于/不等于/包含/不包含")
private String conditions;
@NotBlank(message = "参与判定的值(可能存在类型转换)不能为空")
@Length(max = 255, message = "参与判定的值(可能存在类型转换)不能超过255个字符")
@Schema(description = "参与判定的值(可能存在类型转换)")
private String conditionValue;
@NotBlank(message = "与其他条件之间的关系(0没有关系或单独条件/1或的关系/2并且关系)不能为空")
@Length(max = 1, message = "与其他条件之间的关系(0没有关系或单独条件/1或的关系/2并且关系)不能超过1个字符")
@Schema(description = "与其他条件之间的关系(0没有关系或单独条件/1或的关系/2并且关系)")
private String realation;
@NotBlank(message = "流程路由ID不能为空")
@Length(max = 255, message = "流程路由ID不能超过255个字符")
@Schema(description = "流程路由ID")
private String nodeRouteId;
@NotBlank(message = "类型:1.正常条件 2.正则表达式'不能为空")
@Length(max = 255, message = "类型:1.正常条件 2.正则表达式255个字符")
@Schema(description = "类型:1.正常条件 2.正则表达式")
private String type;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
/**
* 流程调用配置(子流程调用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_node_transfer_config")
@Schema(description = "流程调用配置(子流程调用)")
public class TNodeTransferConfig extends Model<TNodeTransferConfig> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "流程节点ID不能为空")
@Length(max = 255, message = "流程节点ID不能超过255个字符")
@Schema(description = "流程节点ID")
private String nodeId;
@NotBlank(message = "流程ID不能为空")
@Length(max = 255, message = "流程ID不能超过255个字符")
@Schema(description = "流程ID")
private String processId;
@NotBlank(message = "调用方式(0同步/1异步)不能为空")
@Length(max = 1, message = "调用方式(0同步/1异步)不能超过1个字符")
@Schema(description = "调用方式(0同步/1异步)")
private String transferType;
@NotBlank(message = "是否拷贝数据(0是/1否)不能为空")
@Length(max = 1, message = "是否拷贝数据(0是/1否)不能超过1个字符")
@Schema(description = "是否拷贝数据(0是/1否)")
private String copyData;
@NotBlank(message = "是否拷贝附件(0是/1否)不能为空")
@Length(max = 1, message = "是否拷贝附件(0是/1否)不能超过1个字符")
@Schema(description = "是否拷贝附件(0是/1否)")
private String copyAtta;
@NotBlank(message = "启动者(0当前流程的启动者/1上一个活动的处理人/2指定一个启动者)不能为空")
@Length(max = 1, message = "启动者(0当前流程的启动者/1上一个活动的处理人/2指定一个启动者)不能超过1个字符")
@Schema(description = "启动者(0当前流程的启动者/1上一个活动的处理人/2指定一个启动者)")
private String starterType;
@Length(max = 255, message = "启动者(STARTER_TYPE 为2时启用)不能超过255个字符")
@Schema(description = "启动者(STARTER_TYPE 为2时启用)")
private String starter;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.util.ArrayList;
import java.util.List;
/**
* 流程节点表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_process_node")
@Schema(description = "流程节点表")
public class TProcessNode extends Model<TProcessNode> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
/**
* 类型:{
* begin:开始
* end:结束
* cancel:取消
* choice:选择
* split:拆分
* parallel:并行
* merge:合并
* embed:流程调用
* delay:定时
* invoke:服务调用
* service:服务
* agent:脚本
* }
*/
@NotBlank(message = "类型:不能为空")
@Length(max = 20, message = "类型:不能超过20个字符")
@Schema(description = "类型")
private String type;
@NotBlank(message = "标识(自动生成MD5串)不能为空")
@Length(max = 255, message = "标识(自动生成MD5串)不能超过255个字符")
@Schema(description = "标识(自动生成MD5串)")
private String logoTitle;
@NotBlank(message = "节点名称不能为空")
@Length(max = 255, message = "节点名称不能超过255个字符")
@Schema(description = "节点名称")
private String name;
@Length(max = 255, message = "节点描述不能超过255个字符")
@Schema(description = "节点描述")
private String description;
@Length(max = 255, message = "表单ID不能超过255个字符")
@Schema(description = "表单ID", name = "form")
private String form;
@NotBlank(message = "是否允许调度(0是/1否)不能为空")
@Length(max = 1, message = "是否允许调度(0是/1否)不能超过1个字符")
@Schema(description = "是否允许调度(0是/1否)")
private String allowDispatch;
@NotBlank(message = "是否允许调度到此活动不能为空")
@Length(max = 1, message = "是否允许调度到此活动不能超过1个字符")
@Schema(description = "是否允许调度到此活动")
private String allowThis;
@NotBlank(message = "流程ID不能为空")
@Length(max = 255, message = "流程ID不能超过255个字符")
@Schema(description = "流程ID")
private String processId;
@NotBlank(message = "经办人是否允许办理完成后进入下一步(0允许/1不允许)不能为空")
@Length(max = 1, message = "经办人是否允许办理完成后进入下一步(0允许/1不允许)不能超过1个字符")
@Schema(description = "经办人是否允许办理完成后进入下一步(0允许/1不允许)")
private String handleAllowNext;
@NotBlank(message = "会签方式(0允许会签/1强制会签/2禁止会签)不能为空")
@Length(max = 1, message = "会签方式(0允许会签/1强制会签/2禁止会签)不能超过1个字符")
@Schema(description = "会签方式(0允许会签/1强制会签/2禁止会签)")
private String countersign;
@NotBlank(message = "回退方式(0不允许/1回退上一步/2回退至起点)不能为空")
@Length(max = 1, message = "回退方式(0不允许/1回退上一步/2回退至起点)不能超过1个字符")
@Schema(description = "回退方式(0不允许/1回退上一步/2回退至起点)")
private String backType;
@Length(max = 100, message = "元素的图形:不能超过100个字符")
@Schema(description = "元素的图形")
private String shape;
@Length(max = 100, message = "节点大小:不能超过100个字符")
@Schema(description = "节点大小")
private String size;
@Length(max = 20, message = "X坐标:不能超过20个字符")
@Schema(description = "X坐标")
private String coordinatex;
@Length(max = 20, message = "Y坐标:不能超过20个字符")
@Schema(description = "Y坐标")
private String coordinatey;
@Length(max = 50, message = "颜色:不能超过50个字符")
@Schema(description = "颜色")
private String color;
@TableField(exist = false)
private List<TNodePrimission> nodePrimissionList = new ArrayList<>();
@TableField(exist = false)
private List<TNodeReaderPromission> nodeReaderPromissionList = new ArrayList<>();
@TableField(exist = false)
private List<TNodeTransferConfig> nodeTransferConfigs;
@Schema(description = "允许加签")
private String allowAddSign;
/**
* 节点抄送权限列表(流程预览使用,将当前节点的抄送权限绑定在下一个节点上,因为当前的代码逻辑不返回抄送节点,有冲突)
* 【之后优化@TableField注解,不能在实体类里面直接用@TableField,要建一个包装类】
*/
@TableField(exist = false)
private List<TNodeReaderPromission> preNodeReaderPromissionList = new ArrayList<>();
}
package com.yifu.cloud.plus.v1.yifu.process.util;
import com.yifu.cloud.plus.v1.yifu.admin.api.entity.SysUser;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.exception.CheckedException;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodePrimission;
import java.util.ArrayList;
import java.util.List;
/**
* @author chenyuxi
* @date 2020/9/22
* 通用流程工具类
*/
public class CommonProcessUserUtil {
private CommonProcessUserUtil() {
}
public static final String FEGIN_USER_FAIL = "调用用户服务失败";
public static final String FEGIN_USER_RETURN_FAIL = "调用用户服务回失败";
/**
* 获取crm部门审核人
* @param nodePrimission
* @param departId
* @return List<SysUser>
**/
public static List<SysUser> getDepartAuditUser(TNodePrimission nodePrimission, String departId) {
SysUser remoteSysUser = null;
List<SysUser> remoteSysUserList = new ArrayList<>();
if (CommonConstants.THREE_INT == nodePrimission.getType().intValue()) {
//3.指定用户
if (Common.isEmpty(nodePrimission.getUser())) {
throw new CheckedException("未查询当前流程权限对应的用户");
}
// 查找当前用户
// todo 通过用户id查询用户角色
// remoteSysUser = RemoteRequestUtil.getSysUser(remoteUserService, Integer.parseInt(nodePrimission.getUser()));
remoteSysUserList.add(remoteSysUser);
} else if (CommonConstants.TWO_INT == nodePrimission.getType().intValue()) {
//2.指定角色
if (Common.isEmpty(nodePrimission.getRole())) {
throw new CheckedException("未查询当前流程对应的组织权限");
}
//如果下个节点是角色这要取下个角色是否存在
// remoteSysUser = RemoteRequestUtil.getUserManagerByRoleAndDepartId(remoteUserService, departId, nodePrimission.getRole());
remoteSysUserList.add(remoteSysUser);
} else if (CommonConstants.FIVE_INT == nodePrimission.getType().intValue()){
// 5.指定角色(crm)
if (Common.isEmpty(nodePrimission.getApprovalRole())) {
throw new CheckedException("未查询当前节点配置的审核角色");
}
// remoteSysUserList = RemoteRequestUtil.getUserByRoleIdForCrm(remoteUserService, departId, nodePrimission.getApprovalRole());
}
return remoteSysUserList;
}
}
package com.yifu.cloud.plus.v1.yifu.process.util;
import com.alibaba.fastjson.JSON;
import com.googlecode.aviator.AviatorEvaluator;
import com.yifu.cloud.plus.v1.yifu.common.core.exception.CheckedException;
import lombok.extern.slf4j.Slf4j;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
/**
* @auther wangan
* @date 2020/9/2
* goole表达式
*/
@Slf4j
public class ExpressionUtil {
private ExpressionUtil() {
}
/**
* @param expression
* @param obj
* @Author: wangan
* @Date: 2020/9/2
* @Description: 根据表达式判断数据大小
* @return: boolean
**/
public static boolean isMatchExpression(String expression, Object obj) {
Map<String, Object> env = new HashMap<>();
if (obj instanceof BigDecimal) {
env.put("x", Double.parseDouble(obj.toString()));
} else {
env.put("x", obj.toString());
}
try {
return (Boolean) AviatorEvaluator.execute(expression, env);
} catch (Exception e) {
log.error("表达式数据{},表达式{}",expression, JSON.toJSONString(env));
log.error("执行异常",e);
throw new CheckedException("表达式执行出错");
}
}
/**
* @param expression
* @param obj1
* @param obj2
* @Author: wangan
* @Date: 2020/9/2
* @Description: 根据表达式判断数据大小
* @return: boolean
**/
public static boolean isMatchExpression(String expression, Object obj1,Object obj2) {
Map<String, Object> env = new HashMap<>();
if (obj1 instanceof BigDecimal) {
env.put("x", Double.parseDouble(obj1.toString()));
} else {
env.put("x", obj1.toString());
}
if (obj2 instanceof BigDecimal) {
env.put("y", Double.parseDouble(obj2.toString()));
} else {
env.put("y", obj2.toString());
}
try {
return (Boolean) AviatorEvaluator.execute(expression, env);
} catch (Exception e) {
log.error("表达式数据{},表达式{}",expression, JSON.toJSONString(env));
log.error("执行异常",e);
throw new CheckedException("表达式执行出错");
}
}
}
package com.yifu.cloud.plus.v1.yifu.process.util;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.exception.CheckedException;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.process.constant.ProcessConstants;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRoute;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRouteCondition;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessNode;
import com.yifu.cloud.plus.v1.yifu.process.vo.ProcessVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
/**
* @auther wangan
* @date 2020/9/17
*/
@Slf4j
public class ProcessAuditUtil {
private ProcessAuditUtil() {
}
public static final String END_NODE_NO_FOUND = "未找到结束节点";
public static final String END_PRE_NODE_NO_FOUND = "未找到结束节点前一个节点";
public static final String BEGIN_NODE_NO_FOUND = "未找到开始节点";
/**
* @param
* @param processId
* @Author: wangan
* @Date: 2020/9/21
* @Description: 获通过流程id, 获取流程
* @return: com.yifu.cloud.plus.v1.process.api.vo.ProcessVo
**/
public static ProcessVo getProcessVo(String processId) {
// todo 改成dapr请求
//R<ProcessVo> processVoR = remoteProcessService.getProcessVoByName(processId, SecurityConstants.FROM_IN);
R<ProcessVo> processVoR = new R<>();
if (processVoR == null) {
throw new CheckedException("调用流程服务返回为空");
}
if (CommonConstants.SUCCESS != processVoR.getCode()) {
throw new CheckedException("调用流程服务返回失败");
}
ProcessVo processVo = processVoR.getData();
if (processVo == null) {
throw new CheckedException("调用流程服务返回数据为空");
}
return processVo;
}
/**
* @param nodeRouteList
* @param nodeRouteConditionList
* @param object
* @Author: wangan
* @Date: 2020/9/17
* @Description: 条件节点:通过条件表达式判断路由的下一个节点
* @return: com.yifu.cloud.plus.v1.process.api.entity.TNodeRoute
**/
public static TNodeRoute getTNodeRoteByExpress(List<TNodeRoute> nodeRouteList, List<TNodeRouteCondition> nodeRouteConditionList, Object object, Class<?> parameterTypes) {
TNodeRoute matchNodeRoute = null;
for (TNodeRouteCondition nodeRouteCondition : nodeRouteConditionList) {
if (StringUtils.equals(CommonConstants.dingleDigitStrArray[2], nodeRouteCondition.getType())
&& object != null && ExpressionUtil.isMatchExpression(nodeRouteCondition.getField(), object)) {
//满足正则表达式条件
String nextNodeRouteId = nodeRouteCondition.getNodeRouteId();
matchNodeRoute = gettNodeRoute(nodeRouteList, matchNodeRoute, nextNodeRouteId);
} else if (StringUtils.equals(CommonConstants.dingleDigitStrArray[1], nodeRouteCondition.getType())) {
//满足正常条件
if (StringUtils.equals(CommonConstants.ZERO_STRING, nodeRouteCondition.getRealation())) {
if(object==null){
if (object == null && StringUtils.equals("<>", nodeRouteCondition.getConditions())) {
//防止其他异常问题,找不到节点,则取不等于节点
matchNodeRoute = gettNodeRoute(nodeRouteList, matchNodeRoute, nodeRouteCondition.getNodeRouteId());
}
}else {
//与其他条件之间的关系(0没有关系或单独条件)
for (Field field : parameterTypes.getDeclaredFields()) {
String fieldName = field.getName();
if (fieldName != null && StringUtils.equals(fieldName, nodeRouteCondition.getField())) {
String methodName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
try {
Method method = parameterTypes.getDeclaredMethod("get" + methodName);
String value = String.valueOf(method.invoke(object));
if (StringUtils.equals("=", nodeRouteCondition.getConditions()) && StringUtils.equals(value, nodeRouteCondition.getConditionValue())) {
matchNodeRoute = gettNodeRoute(nodeRouteList, matchNodeRoute, nodeRouteCondition.getNodeRouteId());
} else if (StringUtils.equals("<>", nodeRouteCondition.getConditions()) && !StringUtils.equals(value, nodeRouteCondition.getConditionValue())) {
matchNodeRoute = gettNodeRoute(nodeRouteList, matchNodeRoute, nodeRouteCondition.getNodeRouteId());
}
} catch (Exception e) {
log.error("执行失败:{}", e);
}
}
}
}
}
}
}
if (matchNodeRoute == null) {
log.error("未找到匹配条件判断的节点:{}", nodeRouteList.get(CommonConstants.ZERO_INT).getPrewNode());
throw new CheckedException("未找到匹配条件判断的节点");
}
return matchNodeRoute;
}
private static TNodeRoute gettNodeRoute(List<TNodeRoute> nodeRouteList, TNodeRoute matchNodeRoute, String nodeRouteId) {
for (TNodeRoute nodeRoute : nodeRouteList) {
if (StringUtils.equals(nodeRouteId, nodeRoute.getId())) {
matchNodeRoute = nodeRoute;
}
}
return matchNodeRoute;
}
/**
* @param processVo
* @Author: wangan
* @Date: 2020/9/17
* @Description: 获取最后一个节点的前一个节点
* @return: com.yifu.cloud.plus.v1.process.api.entity.TProcessNode
**/
public static TProcessNode getPreEndTProcessNode(ProcessVo processVo, TProcessNode endNode) {
List<TNodeRoute> nodeRouteList = processVo.getNodeRouteList();
List<TProcessNode> processNodeList = processVo.getProcessNodeList();
//结束节点前一个节点
String preEndNode = null;
TProcessNode preEndTProcessNode = null;
for (TNodeRoute nodeRoute : nodeRouteList) {
if (StringUtils.equals(endNode.getLogoTitle(), nodeRoute.getNextNode())) {
preEndNode = nodeRoute.getPrewNode();
}
}
for (TProcessNode processNode : processNodeList) {
if (StringUtils.equals(processNode.getLogoTitle(), preEndNode)) {
preEndTProcessNode = processNode;
}
}
if (preEndTProcessNode == null) {
throw new CheckedException(END_PRE_NODE_NO_FOUND);
}
return preEndTProcessNode;
}
/**
* @param processVo
* @Author: wangan
* @Date: 2020/9/17
* @Description: 获取开始节点
* @return: com.yifu.cloud.plus.v1.process.api.entity.TProcessNode
**/
public static TProcessNode getBeginProcessNode(ProcessVo processVo) {
//获取当前节点的下个节点
List<TProcessNode> processNodeList = processVo.getProcessNodeList();
//开始节点
TProcessNode startTProcessNode = null;
for (TProcessNode processNode : processNodeList) {
if (StringUtils.equals(ProcessConstants.PROCESS_NODE_BEGIN, processNode.getType())) {
startTProcessNode = processNode;
}
}
if (startTProcessNode == null) {
throw new CheckedException(BEGIN_NODE_NO_FOUND);
}
return startTProcessNode;
}
/**
* @param processVo
* @Author: wangan
* @Date: 2020/9/17
* @Description: 获取结束节点
* @return: com.yifu.cloud.plus.v1.process.api.entity.TProcessNode
**/
public static TProcessNode getEndProcessNode(ProcessVo processVo) {
List<TProcessNode> processNodeList = processVo.getProcessNodeList();
TProcessNode endNode = null;
for (TProcessNode processNode : processNodeList) {
if (StringUtils.equals(ProcessConstants.PROCESS_NODE_END, processNode.getType())) {
endNode = processNode;
}
}
if (endNode == null) {
throw new CheckedException(END_NODE_NO_FOUND);
}
return endNode;
}
/**
* @param processVo
* @Author: wangan
* @Date: 2020/9/17
* @Description: 获取当前流程节点
* @return: com.yifu.cloud.plus.v1.process.api.entity.TProcessNode
**/
public static TProcessNode getCurrentProcessNode(ProcessVo processVo, String currentNodeString) {
TProcessNode currentTProcessNode = null;
for (TProcessNode processNode : processVo.getProcessNodeList()) {
if (StringUtils.equals(processNode.getId(), currentNodeString)) {
currentTProcessNode = processNode;
}
}
if (currentTProcessNode == null) {
log.error("流程封装类:", processVo);
log.error("当前流程节点ID:", currentNodeString);
throw new CheckedException("未找到当前节点"+currentNodeString);
}
return currentTProcessNode;
}
/**
* @param
* @Author: wangan
* @Date: 2020/9/21
* @Description:
* @return: 当前节点为服务调用或者结束节点, 获取下一个节点路由类型
**/
public static TNodeRoute getNexTNodeRoute(List<TNodeRoute> nodeRouteList, String currentNodeString) {
TNodeRoute reNodeRoute = null;
for (TNodeRoute nodeRoute : nodeRouteList) {
if (StringUtils.equals(currentNodeString, nodeRoute.getPrewNode())) {
reNodeRoute = nodeRoute;
}
}
if (reNodeRoute == null) {
throw new CheckedException("未获取到服务节点的下一个节点路由");
}
return reNodeRoute;
}
}
package com.yifu.cloud.plus.v1.yifu.process.vo;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
/**
* @Description: 流程需要删除的idsVo
* @Author: hgw
* @Date: 2020-7-27 11:04:13
* @return:
**/
@Getter
@Setter
public class DeleteProcessIdsVo implements Serializable {
private static final long serialVersionUID = 1L;
// 节点ids
private String[] nodeIds;
// 子流程ids
private String[] nodeTransferConfigIds;
// 线ids
private String[] roteIds;
// 线权限ids
private String[] roteConditionIds;
// 权限ids
private String[] primissionIds;
// 抄送ids
private String[] readPrimissionIds;
}
package com.yifu.cloud.plus.v1.yifu.process.vo;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRoute;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessNode;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
import java.util.List;
/**
* @Description: 流程Vo
* @Author: hgw
* @Date: 2019/10/23 15:40
* @return:
**/
@Getter
@Setter
public class ProcessVo implements Serializable {
private static final long serialVersionUID = 1L;
// 主流程id
private String processId;
private String name;
// 节点list
private List<TProcessNode> processNodeList;
// 流程路由list
private List<TNodeRoute> nodeRouteList;
// 删除的ids
private DeleteProcessIdsVo deleteIdsVo;
// 标志是否是流程预览 0是 1否
private String isPreview;
}
package com.yifu.cloud.plus.v1.yifu.process.vo;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodePrimission;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serializable;
/**
* @program: yifu_cloud
* @description: 流程处理权限vo类
* @author: wangdayu
* @create: 2023-10-23 17:28
* @since:
*/
@Data
public class TNodePrimissionVo extends TNodePrimission implements Serializable {
@Schema(description = "审核人姓名")
private String userName;
}
package com.yifu.cloud.plus.v1.yifu.process.vo;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeReaderPromission;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serializable;
/**
* @program: yifu_cloud
* @description: 抄送权限vo类
* @author: wangdayu
* @create: 2023-10-23 17:30
* @since:
*/
@Data
public class TNodeReaderPromissionVo extends TNodeReaderPromission implements Serializable {
@Schema(description = "审核人姓名")
private String userName;
}
package com.yifu.cloud.plus.v1.yifu.insurances.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.yifu.cloud.plus.v1.yifu.common.mybatis.base.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.time.LocalDateTime;
/**
* 审批记录表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@Data
@TableName("t_approval_record")
@EqualsAndHashCode(callSuper = true)
@Schema(description = "审批记录表")
public class TApprovalRecord extends BaseEntity {
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "流程id不能为空")
@Length(max = 32, message = "流程id不能超过32个字符")
@Schema(description = "流程id")
private String flowId;
@NotBlank(message = "实体id不能为空")
@Length(max = 32, message = "实体id不能超过32个字符")
@Schema(description = "实体id")
private String domainId;
@NotBlank(message = "节点id不能为空")
@Length(max = 32, message = "节点id不能超过32个字符")
@Schema(description = "节点id")
private String nodeId;
@NotBlank(message = "审核人id不能为空")
@Length(max = 32, message = "审核人id不能超过32个字符")
@Schema(description = "审核人id")
private String approvalMan;
@NotBlank(message = "审核人姓名不能为空")
@Length(max = 50, message = "审核人姓名不能超过50个字符")
@Schema(description = "审核人姓名")
private String approvalManName;
@Schema(description = "审核时间")
private LocalDateTime approvalTime;
@Length(max = 1, message = "审核结果0:通过1:不通过 2 待审核不能超过1个字符")
@Schema(description = "审核结果0:通过1:不通过 2 待审核 3提交")
private String approvalResult;
@Length(max = 500, message = "审核意见不能超过500个字符")
@Schema(description = "审核意见")
private String approvalOpinion;
@Length(max = 1, message = "删除表示 0未删除 1删除不能超过1个字符")
@Schema(description = "删除表示 0未删除 1删除")
@TableLogic
private String deleteFlag;
@Length(max = 1, message = "之前审核记录标识不能超过1个字符")
@Schema(description = "之前审核记录标识 0之前记录 1当前审核记录。用于当前审核流程过滤判断")
private String preFlag;
@Length(max = 32, message = "提交人id不能超过32个字符")
@Schema(description = "提交人id")
private String submitMan;
@Length(max = 32, message = "提交人姓名不能超过32个字符")
@Schema(description = "提交人姓名")
private String submitManName;
@Length(max = 500, message = "申请原因不能超过500个字符")
@Schema(description = "申请原因")
private String reason;
@Length(max = 2, message = "审核类型 0不购买商险审核不能超过2个字符")
@Schema(description = "审核类型 0不购买商险审核")
private String auditType;
@Schema(description = "创建时间")
private LocalDateTime createTime;
@Length(max = 50, message = "节点名称不能超过50个字符")
@Schema(description = "节点名称")
private String nodeName;
@Length(max = 300, message = "实体名称不能超过300个字符")
@Schema(description = "实体名称")
private String entityName;
@Schema(description = "提交时间")
private LocalDateTime submitCreateTime;
@Length(max = 1, message = "退回状态 0 未退回 1已退回不能超过1个字符")
@Schema(description = "退回状态 0 未退回 1已退回")
private String backFlag;
@Length(max = 50, message = "退回节点名称不能超过50个字符")
@Schema(description = "退回节点名称")
private String backNodeName;
@Length(max = 32, message = "退回节点Id不能超过32个字符")
@Schema(description = "退回节点Id")
private String backNodeId;
@Length(max = 32, message = "加签节点的id不能超过32个字符")
@Schema(description = "加签节点的id")
private String addSignNodeId;
}
package com.yifu.cloud.plus.v1.yifu.insurances.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.yifu.cloud.plus.v1.yifu.common.mybatis.base.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.time.LocalDateTime;
/**
* 审批抄送记录信息表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@Data
@TableName("t_audit_copy_info")
@EqualsAndHashCode(callSuper = true)
@Schema(description = "审批抄送记录信息表")
public class TAuditCopyInfo extends BaseEntity {
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "抄送人id不能为空")
@Length(max = 32, message = "抄送人id不能超过32个字符")
@Schema(description = "抄送人id")
private String auditUserId;
@NotBlank(message = "抄送人姓名不能为空")
@Length(max = 32, message = "抄送人姓名不能超过32个字符")
@Schema(description = "抄送人姓名")
private String auditUser;
@Length(max = 32, message = "实体id不能超过32个字符")
@Schema(description = "实体id")
private String domainId;
@Schema(description = "创建时间")
private LocalDateTime createTime;
@Length(max = 32, message = "流程id不能超过32个字符")
@Schema(description = "流程id")
private String flowId;
@Length(max = 32, message = "节点id不能超过32个字符")
@Schema(description = "节点id")
private String nodeId;
@Length(max = 1, message = "删除表示 0未删除 1删除不能超过1个字符")
@Schema(description = "删除表示 0未删除 1删除")
@TableLogic
private String deleteFlag;
@Length(max = 50, message = "节点名称不能超过50个字符")
@Schema(description = "节点名称")
private String nodeName;
@Length(max = 2, message = "审核类型 0不购买商险审核不能超过2个字符")
@Schema(description = "审核类型 0不购买商险审核")
private String auditType;
@Length(max = 1, message = "之前审核记录标识 不能超过1个字符")
@Schema(description = "之前审核记录标识 0之前记录 1当前审核记录。用于当前审核流程过滤判断")
private String preFlag;
@Length(max = 32, message = "提交人id不能超过32个字符")
@Schema(description = "提交人id")
private String submitMan;
@Length(max = 32, message = "提交人姓名不能超过32个字符")
@Schema(description = "提交人姓名")
private String submitManName;
@Schema(description = "提交时间")
private LocalDateTime submitCreateTime;
}
package com.yifu.cloud.plus.v1.yifu.insurances.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import com.yifu.cloud.plus.v1.yifu.common.mybatis.base.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.time.LocalDateTime;
/**
* 审批主流程记录表节点表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@Data
@TableName("t_audit_node_proocess")
@EqualsAndHashCode(callSuper = true)
@Schema(description = "审批主流程记录表节点表")
public class TAuditNodeProocess extends BaseEntity {
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "流程id不能为空")
@Length(max = 32, message = "流程id不能超过32个字符")
@Schema(description = "流程id")
private String processId;
@NotBlank(message = "节点id不能为空")
@Length(max = 32, message = "节点id不能超过32个字符")
@Schema(description = "节点id")
private String nodeId;
@NotBlank(message = "节点类型不能为空")
@Length(max = 32, message = "节点类型不能超过32个字符")
@Schema(description = "节点类型")
private String nodeType;
@Schema(description = "创建时间")
private LocalDateTime createTime;
@Length(max = 32, message = "实体id不能超过32个字符")
@Schema(description = "实体id")
private String domainId;
@NotBlank(message = "0主流程,1子流程不能为空")
@Length(max = 1, message = "0主流程,1子流程不能超过1个字符")
@Schema(description = "0主流程,1子流程")
private String mainType;
@Length(max = 255, message = "节点标识不能超过255个字符")
@Schema(description = "节点标识")
private String logoTitle;
@Length(max = 32, message = "节点名称不能超过32个字符")
@Schema(description = "节点名称")
private String nodeName;
@Length(max = 32, message = "流程名称不能超过32个字符")
@Schema(description = "流程名称")
private String processName;
@Length(max = 32, message = "父流程id不能超过32个字符")
@Schema(description = "父流程id")
private String parentProcessId;
@Length(max = 1, message = "删除表示 0未删除 1删除不能超过1个字符")
@Schema(description = "删除表示 0未删除 1删除")
@TableLogic
private String deleteFlag;
@Length(max = 2, message = "审核类型 0客户新增 1.客户信息变更 2合同审核流程 3合同办理 4商机审核 5报价单 6团队共享不能超过2个字符")
@Schema(description = "审核类型 0客户新增 1.客户信息变更 2合同审核流程 3合同办理 4商机审核 5报价单 6团队共享")
private String type;
@Length(max = 32, message = "加签节点的父节点id(不是加签节点的默认设置为0)不能超过32个字符")
@Schema(description = "加签节点的父节点id(不是加签节点的默认设置为0)")
private String addSignParentNodeId;
@Length(max = 32, message = "加签节点的审核部门id(不是加签节点的默认设置为0)不能超过32个字符")
@Schema(description = "加签节点的审核部门id(不是加签节点的默认设置为0)")
private String addSignDepartmentId;
@Length(max = 32, message = "实体名称不能超过32个字符")
@Schema(description = "实体名称")
private String domainName;
@Length(max = 255, message = "加签人id不能超过255个字符")
@Schema(description = "加签人id")
private String addSignApprovalMan;
@Length(max = 255, message = "加签人名字不能超过255个字符")
@Schema(description = "加签人名字")
private String addSignApprovalManName;
}
package com.yifu.cloud.plus.v1.yifu.insurances.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.*;
import com.yifu.cloud.plus.v1.yifu.common.mybatis.base.BaseEntity;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonAddVo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
......@@ -58,6 +56,7 @@ public class TInsuranceUnpurchaseApply extends BaseEntity {
private String companyFlag;
@Schema(description = "是否删除 0未删除/1删除")
@TableLogic
private String deleteFlag;
@Schema(description = "申请状态 0 草稿 1待提交 2 待审核 3 审核通过 4 审核不通过")
......@@ -81,7 +80,28 @@ public class TInsuranceUnpurchaseApply extends BaseEntity {
@Schema(description ="当前审核人ID")
private String auditUserId;
@Schema(description ="当前审核人ID")
private String unbuyNum;
@Schema(description ="明细数据集")
@TableField(exist = false)
private List<TInsuranceUnpurchasePerson> personList;
private List<TInsuranceUnpurchasePersonAddVo> personList;
/**
* 附件Id
*/
@TableField(exist = false)
private List<String> attaIdList;
/**
* 暂存,提交,编辑区分
*/
@TableField(exist = false)
private String saveFlag;
// /**
// * 印章附件
// */
// @TableField(exist = false)
// private List<TAttaInfo> attaInfoList;
}
......@@ -80,5 +80,4 @@ public class TInsuranceUnpurchasePerson extends BaseEntity {
@Schema(description ="服务项是否勾选商险 0 是 1 否")
private String insuranceFlag;
}
package com.yifu.cloud.plus.v1.yifu.insurances.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 审批记录表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
*/
@Data
public class TApprovalRecordSearchVo extends TApprovalRecord {
/**
* 多选导出或删除等操作
*/
@Schema(description = "选中ID,多个逗号分割")
private String ids;
/**
* 创建时间区间 [开始时间,结束时间]
*/
@Schema(description = "创建时间区间")
private LocalDateTime[] createTimes;
/**
* @Author fxj
* 查询数据起
**/
@Schema(description = "查询limit 开始")
private int limitStart;
/**
* @Author fxj
* 查询数据止
**/
@Schema(description = "查询limit 数据条数")
private int limitEnd;
}
package com.yifu.cloud.plus.v1.yifu.insurances.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.ExcelAttribute;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.RowIndex;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 含风险项目不购买申请表
......@@ -19,113 +17,76 @@ import java.io.Serializable;
* @date 2025-01-10 11:24:38
*/
@Data
public class TInsuranceUnpurchaseApplyVo extends RowIndex implements Serializable {
public class TInsuranceUnpurchaseApplyVo implements Serializable {
/**
* id
* 申请编号
*/
@TableId(type = IdType.ASSIGN_ID)
@NotBlank(message = "id 不能为空")
@Length(max = 36, message = "id 不能超过36 个字符")
@ExcelAttribute(name = "id", isNotEmpty = true, errorInfo = "id 不能为空", maxLength = 36)
@Schema(description = "id")
@ExcelProperty("id")
private String id;
@ExcelAttribute(name = "申请编号")
@Schema(description = "申请编号")
@ExcelProperty("申请编号")
private String applyNo;
/**
* 项目ID
* 项目名称
*/
@Length(max = 32, message = "项目ID 不能超过32 个字符")
@ExcelAttribute(name = "项目ID", maxLength = 32)
@Schema(description = "项目ID")
@ExcelProperty("项目ID")
private String deptId;
@ExcelAttribute(name = "项目名称")
@Schema(description = "项目名称")
@ExcelProperty("项目名称")
private String deptName;
/**
* 项目编码
*/
@Length(max = 30, message = "项目编码 不能超过30 个字符")
@ExcelAttribute(name = "项目编码", maxLength = 30)
@ExcelAttribute(name = "项目编码")
@Schema(description = "项目编码")
@ExcelProperty("项目编码")
private String deptNo;
/**
* 项目名称
*/
@Length(max = 50, message = "项目名称 不能超过50 个字符")
@ExcelAttribute(name = "项目名称", maxLength = 50)
@Schema(description = "项目名称")
@ExcelProperty("项目名称")
private String deptName;
/**
* 申请人所在部门
* 创建者-姓名
*/
@Length(max = 36, message = "申请人所在部门 不能超过36 个字符")
@ExcelAttribute(name = "申请人所在部门", maxLength = 36)
@Schema(description = "申请人所在部门")
@ExcelProperty("申请人所在部门")
private String createUserDeptId;
@ExcelAttribute(name = "申请人")
@Schema(description = "申请人")
@ExcelProperty("申请人")
private String createName;
/**
* 申请人所在部门名称
*/
@Length(max = 50, message = "申请人所在部门名称 不能超过50 个字符")
@ExcelAttribute(name = "申请人所在部门名称", maxLength = 50)
@Schema(description = "申请人所在部门名称")
@ExcelProperty("申请人所在部门名称")
@ExcelAttribute(name = "所属部门")
@Schema(description = "所属部门")
@ExcelProperty("所属部门")
private String createUserDeptName;
/**
* 不购买原因 1 已购买社保 2 人员已离职
*/
@Length(max = 1, message = "不购买原因 1 已购买社保 2 人员已离职 不能超过1 个字符")
@ExcelAttribute(name = "不购买原因 1 已购买社保 2 人员已离职", maxLength = 1)
@Schema(description = "不购买原因 1 已购买社保 2 人员已离职")
@ExcelProperty("不购买原因 1 已购买社保 2 人员已离职")
private String reasonType;
/**
* 原因说明
*/
@Length(max = 50, message = "原因说明 不能超过50 个字符")
@ExcelAttribute(name = "原因说明", maxLength = 50)
@Schema(description = "原因说明")
@ExcelProperty("原因说明")
private String reasonInfo;
/**
* 申请编号
*/
@Length(max = 20, message = "申请编号 不能超过20 个字符")
@ExcelAttribute(name = "申请编号", maxLength = 20)
@Schema(description = "申请编号")
@ExcelProperty("申请编号")
private String applyNo;
/**
* 项目是否有审批通过记录 0 是 1 否
*/
@Length(max = 1, message = "项目是否有审批通过记录 0 是 1 否 不能超过1 个字符")
@ExcelAttribute(name = "项目是否有审批通过记录 0 是 1 否", maxLength = 1)
@Schema(description = "项目是否有审批通过记录 0 是 1 否")
@ExcelProperty("项目是否有审批通过记录 0 是 1 否")
private String auditFlag;
/**
* 申请人是否属于子分公司 0 是 1 否
* 申请时间
*/
@Length(max = 1, message = "申请人是否属于子分公司 0 是 1 否 不能超过1 个字符")
@ExcelAttribute(name = "申请人是否属于子分公司 0 是 1 否", maxLength = 1)
@Schema(description = "申请人是否属于子分公司 0 是 1 否")
@ExcelProperty("申请人是否属于子分公司 0 是 1 否")
private String companyFlag;
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss")
@ExcelAttribute(name = "申请时间")
@Schema(description = "申请时间")
@ExcelProperty("申请时间")
private LocalDateTime createTime;
@ExcelAttribute(name = "当前审核人")
@Schema(description = "当前审核人")
@ExcelProperty("当前审核人")
private String auditUser;
/**
* 是否删除 0未删除/1删除
* 不购买原因 1 已购买社保 2 人员已离职
*/
@Length(max = 1, message = "是否删除 0未删除/1删除 不能超过1 个字符")
@ExcelAttribute(name = "是否删除 0未删除/1删除", maxLength = 1)
@Schema(description = "是否删除 0未删除/1删除")
@ExcelProperty("是否删除 0未删除/1删除")
private String deleteFlag;
@ExcelAttribute(name = "不购买原因")
@Schema(description = "不购买原因")
@ExcelProperty("不购买原因")
private String reasonType;
/**
* 申请状态 0 草稿 1待提交 2 待审核 3 审核通过 4 审核不通过
*/
@Length(max = 1, message = "申请状态 0 草稿 1待提交 2 待审核 3 审核通过 4 审核不通过 不能超过1 个字符")
@ExcelAttribute(name = "申请状态 0 草稿 1待提交 2 待审核 3 审核通过 4 审核不通过", maxLength = 1)
@Schema(description = "申请状态 0 草稿 1待提交 2 待审核 3 审核通过 4 审核不通过")
@ExcelProperty("申请状态 0 草稿 1待提交 2 待审核 3 审核通过 4 审核不通过")
@ExcelAttribute(name = "审核状态")
@Schema(description = "审核状态")
@ExcelProperty("审核状态")
private String status;
}
package com.yifu.cloud.plus.v1.yifu.insurances.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serializable;
/**
* 含风险项目不购买申请明细表
*
* @author huych
* @date 2025-01-10 11:23:21
*/
@Data
public class TInsuranceUnpurchasePersonAddVo implements Serializable {
@Schema(description = "行号")
private String rowIndex;
@Schema(description = "id")
private String id;
/**
* 姓名
*/
@ExcelProperty("员工姓名")
private String empName;
@Schema(description = "身份证号")
private String empIdcardNo;
@Schema(description = "就职岗位")
private String post;
@Schema(description = "code码区分报错")
private String code;
@Schema(description = "错误信息")
private String message;
}
package com.yifu.cloud.plus.v1.yifu.insurances.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serializable;
/**
* 含风险项目不购买申请明细表
*
* @author huych
* @date 2025-01-10 11:23:21
*/
@Data
public class TInsuranceUnpurchasePersonCardVo implements Serializable {
/**
* 姓名
*/
@ExcelProperty("员工姓名")
private String empName;
@Schema(description = "身份证号")
private String empIdcardNo;
}
package com.yifu.cloud.plus.v1.yifu.insurances.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.ExcelAttribute;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.RowIndex;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 含风险项目不购买申请明细表
......@@ -19,130 +16,82 @@ import java.io.Serializable;
* @date 2025-01-10 11:23:21
*/
@Data
public class TInsuranceUnpurchasePersonVo extends RowIndex implements Serializable {
public class TInsuranceUnpurchasePersonVo implements Serializable {
/**
* id
* 明细单号
*/
@TableId(type = IdType.ASSIGN_ID)
@NotBlank(message = "id 不能为空")
@Length(max = 36, message = "id 不能超过36 个字符")
@ExcelAttribute(name = "id", isNotEmpty = true, errorInfo = "id 不能为空", maxLength = 36)
@Schema(description = "id")
@ExcelProperty("id")
private String id;
/**
* 父级id
*/
@Length(max = 36, message = "父级id 不能超过36 个字符")
@ExcelAttribute(name = "父级id", maxLength = 36)
@Schema(description = "父级id")
@ExcelProperty("父级id")
private String parnetId;
/**
* 姓名
*/
@Length(max = 32, message = "姓名 不能超过32 个字符")
@ExcelAttribute(name = "姓名", maxLength = 32)
@Schema(description = "姓名")
@ExcelProperty("姓名")
private String empName;
/**
* 身份证号
*/
@Length(max = 32, message = "身份证号 不能超过32 个字符")
@ExcelAttribute(name = "身份证号", maxLength = 32)
@Schema(description = "身份证号")
@ExcelProperty("身份证号")
private String empIdcardNo;
/**
* 就职岗位
*/
@Length(max = 50, message = "就职岗位 不能超过50 个字符")
@ExcelAttribute(name = "就职岗位", maxLength = 50)
@Schema(description = "就职岗位")
@ExcelProperty("就职岗位")
private String post;
@ExcelAttribute(name = "明细单号")
@Schema(description = "明细单号")
@ExcelProperty("明细单号")
private String applyNoDetail;
/**
* 明细申请编
* 不购买申请流程单
*/
@Length(max = 20, message = "明细申请编号 不能超过20 个字符")
@ExcelAttribute(name = "明细申请编号", maxLength = 20)
@Schema(description = "明细申请编号")
@ExcelProperty("明细申请编号")
private String applyNoDetail;
@ExcelAttribute(name = "不购买申请流程单号")
@Schema(description = "不购买申请流程单号")
@ExcelProperty("不购买申请流程单号")
private String applyNo;
/**
* 项目ID
* 项目名称
*/
@Length(max = 32, message = "项目ID 不能超过32 个字符")
@ExcelAttribute(name = "项目ID", maxLength = 32)
@Schema(description = "项目ID")
@ExcelProperty("项目ID")
private String deptId;
@ExcelAttribute(name = "项目名称")
@Schema(description = "项目名称")
@ExcelProperty("项目名称")
private String deptName;
/**
* 项目编码
*/
@Length(max = 30, message = "项目编码 不能超过30 个字符")
@ExcelAttribute(name = "项目编码", maxLength = 30)
@ExcelAttribute(name = "项目编码")
@Schema(description = "项目编码")
@ExcelProperty("项目编码")
private String deptNo;
@ExcelAttribute(name = "事业部")
@Schema(description = "事业部")
@ExcelProperty("事业部")
private String division;
@ExcelAttribute(name = "事业部条线")
@Schema(description = "事业部条线")
@ExcelProperty("事业部条线")
private String newLine;
/**
* 项目名称
*/
@Length(max = 50, message = "项目名称 不能超过50 个字符")
@ExcelAttribute(name = "项目名称", maxLength = 50)
@Schema(description = "项目名称")
@ExcelProperty("项目名称")
private String deptName;
/**
* 申请人所在部门
* 姓名
*/
@Length(max = 36, message = "申请人所在部门 不能超过36 个字符")
@ExcelAttribute(name = "申请人所在部门", maxLength = 36)
@Schema(description = "申请人所在部门")
@ExcelProperty("申请人所在部门")
private String createUserDeptId;
@ExcelAttribute(name = "员工姓名")
@Schema(description = "员工姓名")
@ExcelProperty("员工姓名")
private String empName;
/**
* 申请人所在部门名称
* 身份证号
*/
@Length(max = 50, message = "申请人所在部门名称 不能超过50 个字符")
@ExcelAttribute(name = "申请人所在部门名称", maxLength = 50)
@Schema(description = "申请人所在部门名称")
@ExcelProperty("申请人所在部门名称")
private String createUserDeptName;
@ExcelAttribute(name = "身份证号")
@Schema(description = "身份证号")
@ExcelProperty("身份证号")
private String empIdcardNo;
/**
* 不购买原因 1 已购买社保 2 人员已离职
*/
@Length(max = 1, message = "不购买原因 1 已购买社保 2 人员已离职 不能超过1 个字符")
@ExcelAttribute(name = "不购买原因 1 已购买社保 2 人员已离职", maxLength = 1)
@Schema(description = "不购买原因 1 已购买社保 2 人员已离职")
@ExcelProperty("不购买原因 1 已购买社保 2 人员已离职")
@ExcelAttribute(name = "不购买原因")
@Schema(description = "不购买原因")
@ExcelProperty("不购买原因")
private String reasonType;
/**
* 原因说明
*/
@Length(max = 50, message = "原因说明 不能超过50 个字符")
@ExcelAttribute(name = "原因说明", maxLength = 50)
@Schema(description = "原因说明")
@ExcelProperty("原因说明")
private String reasonInfo;
/**
* 主表申请编号
*/
@Length(max = 20, message = "主表申请编号 不能超过20 个字符")
@ExcelAttribute(name = "主表申请编号", maxLength = 20)
@Schema(description = "主表申请编号")
@ExcelProperty("主表申请编号")
private String applyNo;
/**
* 社保是否在保 0 是 1 否
*/
@Length(max = 1, message = "社保是否在保 0 是 1 否 不能超过1 个字符")
@ExcelAttribute(name = "社保是否在保 0 是 1 否", maxLength = 1)
@Schema(description = "社保是否在保 0 是 1 否")
@ExcelProperty("社保是否在保 0 是 1 否")
@ExcelAttribute(name = "社保是否在保")
@Schema(description = "社保是否在保")
@ExcelProperty("社保是否在保")
private String socialStatus;
/**
* 发薪次数
*/
......@@ -151,4 +100,21 @@ public class TInsuranceUnpurchasePersonVo extends RowIndex implements Serializab
@ExcelProperty("发薪次数")
private Integer salaryNum;
/**
* 创建者-姓名
*/
@ExcelAttribute(name = "申请人")
@Schema(description = "申请人")
@ExcelProperty("申请人")
private String createName;
/**
* 申请时间
*/
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss")
@ExcelAttribute(name = "申请时间")
@Schema(description = "申请时间")
@ExcelProperty("申请时间")
private LocalDateTime createTime;
}
package com.yifu.cloud.plus.v1.yifu.insurances.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CacheConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.ResultConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.redis.RedisDistributedLock;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.common.security.util.SecurityUtils;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TApprovalRecordService;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TApprovalRecordSearchVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
/**
* 审批记录表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tapprovalrecord" )
@Tag(name = "审批记录表管理")
public class TApprovalRecordController {
private final TApprovalRecordService tApprovalRecordService;
/**
* 简单分页查询
* @param page 分页对象
* @param tApprovalRecord 审批记录表
* @return
*/
@Operation(description = "简单分页查询")
@GetMapping("/page")
public R<IPage<TApprovalRecord>> getTApprovalRecordPage(Page<TApprovalRecord> page, TApprovalRecordSearchVo tApprovalRecord) {
return new R<>(tApprovalRecordService.getTApprovalRecordPage(page,tApprovalRecord));
}
/**
* 通过实体id和审核类型查询所有的审核记录
* @param domainId 实体id
* @param auditType 审核类型 0不购买商险审核
* @return R<Map<String, Object>> key=auditInfo表示审批记录列表
**/
@Operation(description = "通过实体id查询所有的审核记录")
@GetMapping("/getAuditInfoByDomainIdAndAuditType")
public R<Map<String, Object>> getAuditInfoByDomainIdAndAuditType(@RequestParam String domainId, @RequestParam String auditType) {
if (Common.isEmpty(domainId) || Common.isEmpty(auditType)) {
return R.failed("实体id或审核类型不能为空");
}
return tApprovalRecordService.getAuditInfoByDomainIdAndAuditType(domainId, auditType);
}
/**
* 通过id查询审批记录表
* @param id id
* @return R
*/
@Operation(summary = "通过id查询", description = "通过id查询:hasPermission('insurances_tapprovalrecord_get')")
@GetMapping("/{id}" )
@PreAuthorize("@pms.hasPermission('insurances_tapprovalrecord_get')" )
public R<TApprovalRecord> getById(@PathVariable("id" ) String id) {
return R.ok(tApprovalRecordService.getById(id));
}
/**
* 新增审批记录表
* @param tApprovalRecord 审批记录表
* @return R
*/
@Operation(summary = "新增审批记录表", description = "新增审批记录表:hasPermission('insurances_tapprovalrecord_add')")
@SysLog("新增审批记录表" )
@PostMapping
@PreAuthorize("@pms.hasPermission('insurances_tapprovalrecord_add')" )
public R<Boolean> save(@RequestBody TApprovalRecord tApprovalRecord) {
return R.ok(tApprovalRecordService.save(tApprovalRecord));
}
/**
* 修改审批记录表
* @param tApprovalRecord 审批记录表
* @return R
*/
@Operation(summary = "修改审批记录表", description = "修改审批记录表:hasPermission('insurances_tapprovalrecord_edit')")
@SysLog("修改审批记录表" )
@PutMapping
@PreAuthorize("@pms.hasPermission('insurances_tapprovalrecord_edit')" )
public R<Boolean> updateById(@RequestBody TApprovalRecord tApprovalRecord) {
return R.ok(tApprovalRecordService.updateById(tApprovalRecord));
}
/**
* 通过id删除审批记录表
* @param id id
* @return R
*/
@Operation(summary = "通过id删除审批记录表", description = "通过id删除审批记录表:hasPermission('insurances_tapprovalrecord_del')")
@SysLog("通过id删除审批记录表" )
@DeleteMapping("/{id}" )
@PreAuthorize("@pms.hasPermission('insurances_tapprovalrecord_del')" )
public R<Boolean> removeById(@PathVariable String id) {
return R.ok(tApprovalRecordService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.insurances.controller;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditCopyInfo;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TAuditCopyInfoService;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
/**
* 审批抄送记录信息表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tauditcopyinfo" )
@Tag(name = "审批抄送记录信息表管理")
public class TAuditCopyInfoController {
private final TAuditCopyInfoService tAuditCopyInfoService;
/**
* 通过id查询审批抄送记录信息表
* @param id id
* @return R
*/
@Operation(summary = "通过id查询", description = "通过id查询:hasPermission('insurances_tauditcopyinfo_get')")
@GetMapping("/{id}" )
@PreAuthorize("@pms.hasPermission('insurances_tauditcopyinfo_get')" )
public R<TAuditCopyInfo> getById(@PathVariable("id" ) String id) {
return R.ok(tAuditCopyInfoService.getById(id));
}
/**
* 新增审批抄送记录信息表
* @param tAuditCopyInfo 审批抄送记录信息表
* @return R
*/
@Operation(summary = "新增审批抄送记录信息表", description = "新增审批抄送记录信息表:hasPermission('insurances_tauditcopyinfo_add')")
@SysLog("新增审批抄送记录信息表" )
@PostMapping
@PreAuthorize("@pms.hasPermission('insurances_tauditcopyinfo_add')" )
public R<Boolean> save(@RequestBody TAuditCopyInfo tAuditCopyInfo) {
return R.ok(tAuditCopyInfoService.save(tAuditCopyInfo));
}
/**
* 修改审批抄送记录信息表
* @param tAuditCopyInfo 审批抄送记录信息表
* @return R
*/
@Operation(summary = "修改审批抄送记录信息表", description = "修改审批抄送记录信息表:hasPermission('insurances_tauditcopyinfo_edit')")
@SysLog("修改审批抄送记录信息表" )
@PutMapping
@PreAuthorize("@pms.hasPermission('insurances_tauditcopyinfo_edit')" )
public R<Boolean> updateById(@RequestBody TAuditCopyInfo tAuditCopyInfo) {
return R.ok(tAuditCopyInfoService.updateById(tAuditCopyInfo));
}
/**
* 通过id删除审批抄送记录信息表
* @param id id
* @return R
*/
@Operation(summary = "通过id删除审批抄送记录信息表", description = "通过id删除审批抄送记录信息表:hasPermission('insurances_tauditcopyinfo_del')")
@SysLog("通过id删除审批抄送记录信息表" )
@DeleteMapping("/{id}" )
@PreAuthorize("@pms.hasPermission('insurances_tauditcopyinfo_del')" )
public R<Boolean> removeById(@PathVariable String id) {
return R.ok(tAuditCopyInfoService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.insurances.controller;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditNodeProocess;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TAuditNodeProocessService;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
/**
* 审批主流程记录表节点表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tauditnodeproocess" )
@Tag(name = "审批主流程记录表节点表管理")
public class TAuditNodeProocessController {
private final TAuditNodeProocessService tAuditNodeProocessService;
/**
* 通过id查询审批主流程记录表节点表
* @param id id
* @return R
*/
@Operation(summary = "通过id查询", description = "通过id查询:hasPermission('insurances_tauditnodeproocess_get')")
@GetMapping("/{id}" )
@PreAuthorize("@pms.hasPermission('insurances_tauditnodeproocess_get')" )
public R<TAuditNodeProocess> getById(@PathVariable("id" ) String id) {
return R.ok(tAuditNodeProocessService.getById(id));
}
/**
* 新增审批主流程记录表节点表
* @param tAuditNodeProocess 审批主流程记录表节点表
* @return R
*/
@Operation(summary = "新增审批主流程记录表节点表", description = "新增审批主流程记录表节点表:hasPermission('insurances_tauditnodeproocess_add')")
@SysLog("新增审批主流程记录表节点表" )
@PostMapping
@PreAuthorize("@pms.hasPermission('insurances_tauditnodeproocess_add')" )
public R<Boolean> save(@RequestBody TAuditNodeProocess tAuditNodeProocess) {
return R.ok(tAuditNodeProocessService.save(tAuditNodeProocess));
}
/**
* 修改审批主流程记录表节点表
* @param tAuditNodeProocess 审批主流程记录表节点表
* @return R
*/
@Operation(summary = "修改审批主流程记录表节点表", description = "修改审批主流程记录表节点表:hasPermission('insurances_tauditnodeproocess_edit')")
@SysLog("修改审批主流程记录表节点表" )
@PutMapping
@PreAuthorize("@pms.hasPermission('insurances_tauditnodeproocess_edit')" )
public R<Boolean> updateById(@RequestBody TAuditNodeProocess tAuditNodeProocess) {
return R.ok(tAuditNodeProocessService.updateById(tAuditNodeProocess));
}
/**
* 通过id删除审批主流程记录表节点表
* @param id id
* @return R
*/
@Operation(summary = "通过id删除审批主流程记录表节点表", description = "通过id删除审批主流程记录表节点表:hasPermission('insurances_tauditnodeproocess_del')")
@SysLog("通过id删除审批主流程记录表节点表" )
@DeleteMapping("/{id}" )
@PreAuthorize("@pms.hasPermission('insurances_tauditnodeproocess_del')" )
public R<Boolean> removeById(@PathVariable String id) {
return R.ok(tAuditNodeProocessService.removeById(id));
}
}
......@@ -2,21 +2,29 @@ package com.yifu.cloud.plus.v1.yifu.insurances.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CacheConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.ResultConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.redis.RedisDistributedLock;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.common.dapr.util.MenuUtil;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.common.security.util.SecurityUtils;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchaseApply;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TInsuranceUnpurchaseApplyService;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchaseApplySearchVo;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
/**
......@@ -29,6 +37,7 @@ import javax.servlet.http.HttpServletResponse;
@RequiredArgsConstructor
@RequestMapping("/tinsuranceunpurchaseapply")
@Tag(name = "含风险项目不购买申请表管理")
@Slf4j
public class TInsuranceUnpurchaseApplyController {
private final TInsuranceUnpurchaseApplyService tInsuranceUnpurchaseApplyService;
......@@ -59,7 +68,7 @@ public class TInsuranceUnpurchaseApplyController {
@Operation(summary = "通过id查询", description = "通过id查询")
@GetMapping("/{id}")
public R<TInsuranceUnpurchaseApply> getById(@PathVariable("id") String id) {
return R.ok(tInsuranceUnpurchaseApplyService.getById(id));
return tInsuranceUnpurchaseApplyService.getDetailInfoById(id);
}
/**
......@@ -72,7 +81,7 @@ public class TInsuranceUnpurchaseApplyController {
@SysLog("新增含风险项目不购买申请表")
@PostMapping("/add")
public R save(@RequestBody TInsuranceUnpurchaseApply tInsuranceUnpurchaseApply) {
return new R<>(tInsuranceUnpurchaseApplyService.save(tInsuranceUnpurchaseApply));
return new R<>(tInsuranceUnpurchaseApplyService.addApply(tInsuranceUnpurchaseApply));
}
/**
......@@ -116,4 +125,118 @@ public class TInsuranceUnpurchaseApplyController {
menuUtil.setAuthSql(user, searchVo);
tInsuranceUnpurchaseApplyService.listExport(response, searchVo);
}
/**
* 审核分页查询
*
* @param page 分页对象
* @param unpurchaseApplySearchVo 不购买申请查询信息
* @param type 0待审核、1已处理、2抄送我
*
* @return R
*/
@Operation(description = "审核分页查询")
@GetMapping("/getAuditPage")
public R<IPage<TInsuranceUnpurchaseApply>> getAuditPage(Page<TInsuranceUnpurchaseApply> page,
TInsuranceUnpurchaseApplySearchVo unpurchaseApplySearchVo,String type) {
YifuUser user = SecurityUtils.getUser();
if(null == user){
return R.failed(ResultConstants.NO_USER);
}
String userId = String.valueOf(user.getId());
return R.ok(tInsuranceUnpurchaseApplyService.getAuditPage(page, unpurchaseApplySearchVo, userId, type));
}
/**
* 审核数量
*
* @return R
*/
@Operation(description = "审核数量查询")
@GetMapping("/getAuditCount")
public R<Map<String,Integer>> getAuditCount() {
YifuUser user = SecurityUtils.getUser();
if(null == user){
return R.failed(ResultConstants.NO_USER);
}
String userId = String.valueOf(user.getId());
return R.ok(tInsuranceUnpurchaseApplyService.getAuditCount(userId));
}
/**
* 提交审核
* @param id 实体id
* @return R<String>
**/
@Operation(description = "提交审核")
@SysLog("提交审核")
@PostMapping("/commitOne")
public R<String> commitOne(@RequestParam String id) {
YifuUser user = SecurityUtils.getUser();
if (Common.isEmpty(user)){
return R.failed(CommonConstants.USER_FAIL);
}
if (Common.isNotKong(id)) {
String requestId;
String redisKey = CacheConstants.INSURANCEUNPURCHASE_PROCESS_CACHE.concat(id);
try {
requestId = RedisDistributedLock.getLock(redisKey,"10");
} catch (Exception e) {
log.error("获取锁失败:{}", e);
return R.failed(ResultConstants.NO_GETLOCK_DATA);
}
if (Common.isNotKong(requestId)) {
R<String> saveR = tInsuranceUnpurchaseApplyService.commitOne(id);
//主动释放锁
RedisDistributedLock.unlock(redisKey, requestId);
return saveR;
} else {
return R.failed(ResultConstants.NO_GETLOCK_DATA);
}
} else {
return R.failed("请选择提交的记录!");
}
}
/**
* 审核
* @param tApprovalRecord 审批信息
* @return R<String>
**/
@Operation(description = "审核")
@SysLog("审核")
@PostMapping("/audit")
public R<String> audit(@RequestBody TApprovalRecord tApprovalRecord) {
if (Common.isEmpty(tApprovalRecord.getApprovalResult())) {
return R.failed("审核结果不能为空!");
}
if (Common.isNotNull(tApprovalRecord.getApprovalOpinion()) && tApprovalRecord.getApprovalOpinion().length()> 100) {
return R.failed("审核意见不能超过100个字");
}
if (Common.isEmpty(tApprovalRecord.getDomainId())) {
return R.failed("id不能为空!");
}
YifuUser user = SecurityUtils.getUser();
if (Common.isEmpty(user)){
return R.failed(CommonConstants.USER_FAIL);
}
TInsuranceUnpurchaseApply insuranceUnpurchaseApply = tInsuranceUnpurchaseApplyService.getById(tApprovalRecord.getDomainId());
if (Common.isEmpty(insuranceUnpurchaseApply)){
return R.failed("该实体信息不存在!");
}
String requestId;
String redisKey = CacheConstants.INSURANCEUNPURCHASE_PROCESS_CACHE.concat(tApprovalRecord.getDomainId());
try {
requestId = RedisDistributedLock.tryLockAndTime(redisKey, "10");
} catch (Exception e) {
return R.failed(ResultConstants.REQUEST_LOCK_FAIL);
}
if (Common.isNotKong(requestId)) {
return tInsuranceUnpurchaseApplyService.auditAndCommit(insuranceUnpurchaseApply, tApprovalRecord.getApprovalResult(),
tApprovalRecord.getApprovalOpinion(), user);
}
return R.failed(ResultConstants.REQUEST_LOCK_FAIL);
}
}
......@@ -5,7 +5,6 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.common.dapr.util.MenuUtil;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.common.security.util.SecurityUtils;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchasePerson;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TInsuranceUnpurchasePersonService;
......@@ -13,7 +12,6 @@ import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonSearc
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
......@@ -60,51 +58,13 @@ public class TInsuranceUnpurchasePersonController {
return R.ok(tInsuranceUnpurchasePersonService.getById(id));
}
/**
* 新增含风险项目不购买申请明细表
* @param tInsuranceUnpurchasePerson 含风险项目不购买申请明细表
* @return R
*/
@Operation(summary = "新增含风险项目不购买申请明细表", description = "新增含风险项目不购买申请明细表")
@SysLog("新增含风险项目不购买申请明细表")
@PostMapping
public R<Boolean> save(@RequestBody TInsuranceUnpurchasePerson tInsuranceUnpurchasePerson) {
return R.ok(tInsuranceUnpurchasePersonService.save(tInsuranceUnpurchasePerson));
}
/**
* 修改含风险项目不购买申请明细表
* @param tInsuranceUnpurchasePerson 含风险项目不购买申请明细表
* @return R
*/
@Operation(summary = "修改含风险项目不购买申请明细表", description = "修改含风险项目不购买申请明细表")
@SysLog("修改含风险项目不购买申请明细表")
@PutMapping
public R<Boolean> updateById(@RequestBody TInsuranceUnpurchasePerson tInsuranceUnpurchasePerson) {
return R.ok(tInsuranceUnpurchasePersonService.updateById(tInsuranceUnpurchasePerson));
}
/**
* 通过id删除含风险项目不购买申请明细表
* @param id id
* @return R
*/
@Operation(summary = "通过id删除含风险项目不购买申请明细表", description = "通过id删除含风险项目不购买申请明细表:hasPermission('insurances_tinsuranceunpurchaseperson_del')")
@SysLog("通过id删除含风险项目不购买申请明细表" )
@DeleteMapping("/{id}" )
@PreAuthorize("@pms.hasPermission('insurances_tinsuranceunpurchaseperson_del')" )
public R<Boolean> removeById(@PathVariable String id) {
return R.ok(tInsuranceUnpurchasePersonService.removeById(id));
}
/**
* 含风险项目不购买申请明细表 批量导出
* @author huych
* @date 2025-01-10 11:23:21
**/
@Operation(description = "导出含风险项目不购买申请明细表 hasPermission('insurances_tinsuranceunpurchaseperson-export')")
@Operation(description = "导出含风险项目不购买申请明细表")
@PostMapping("/export")
@PreAuthorize("@pms.hasPermission('insurances_tinsuranceunpurchaseperson-export')")
public void export(HttpServletResponse response, @RequestBody TInsuranceUnpurchasePersonSearchVo searchVo) {
YifuUser user = SecurityUtils.getUser();
menuUtil.setAuthSql(user, searchVo);
......
package com.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 审批记录表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@Mapper
public interface TApprovalRecordMapper extends BaseMapper<TApprovalRecord> {
/**
* 审批记录表简单分页查询
* @param tApprovalRecord 审批记录表
* @return
*/
IPage<TApprovalRecord> getTApprovalRecordPage(Page<TApprovalRecord> page, @Param("tApprovalRecord") TApprovalRecord tApprovalRecord);
/**
* 通过实体id和审核类型查询所有的审核记录
*
* @param domainId 实体id
* @param auditType 审核类型 0不购买商险审核
* @return List<TApprovalRecord>
**/
List<TApprovalRecord> getApprovalRecordList(@Param("domainId") String domainId, @Param("auditType") String auditType);
}
package com.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditCopyInfo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 审批抄送记录信息表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@Mapper
public interface TAuditCopyInfoMapper extends BaseMapper<TAuditCopyInfo> {
}
package com.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditNodeProocess;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 审批主流程记录表节点表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@Mapper
public interface TAuditNodeProocessMapper extends BaseMapper<TAuditNodeProocess> {
}
......@@ -5,6 +5,7 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchaseApply;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchaseApplySearchVo;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchaseApplyVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
......@@ -38,6 +39,56 @@ public interface TInsuranceUnpurchaseApplyMapper extends BaseMapper<TInsuranceUn
* @param tInsuranceUnpurchaseApply 含风险项目不购买申请表
* @return
*/
List<TInsuranceUnpurchaseApply> getTInsuranceUnpurchaseApplyExportList(@Param("tInsuranceUnpurchaseApply") TInsuranceUnpurchaseApplySearchVo tInsuranceUnpurchaseApply);
List<TInsuranceUnpurchaseApplyVo> getTInsuranceUnpurchaseApplyExportList(@Param("tInsuranceUnpurchaseApply") TInsuranceUnpurchaseApplySearchVo tInsuranceUnpurchaseApply);
String getMaxInusuranceCode();
String getMaxInusuranceDetailCode();
/**
* 待审核分页查询
* @param page 分页信息
* @param tInsuranceUnpurchaseApply 不购买申请查询信息
* @param userId 登录用户id
* @return IPage
*/
IPage<TInsuranceUnpurchaseApply> getAuditPage(Page<TInsuranceUnpurchaseApply> page,
@Param("tInsuranceUnpurchaseApply") TInsuranceUnpurchaseApplySearchVo tInsuranceUnpurchaseApply,
@Param("userId") String userId);
/**
* 已审核分页查询
* @param page 分页信息
* @param tInsuranceUnpurchaseApply 不购买申请查询信息
* @param userId 登录用户id
* @return IPage
*/
IPage<TInsuranceUnpurchaseApply> getHistoryHandlePage(Page<TInsuranceUnpurchaseApply> page,
@Param("tInsuranceUnpurchaseApply") TInsuranceUnpurchaseApplySearchVo tInsuranceUnpurchaseApply,
@Param("userId") String userId);
/**
* 待审核数量
* @param userId 登录用户id
* @return IPage
*/
Integer getAuditCount(@Param("userId") String userId);
/**
* 已审核数量
* @param userId 登录用户id
* @return IPage
*/
Integer getHistoryHandleCount(@Param("userId") String userId);
/**
* 抄送分页查询
* @param page 分页信息
* @param tInsuranceUnpurchaseApply 不购买申请查询信息
* @param userId 登录用户id
* @return IPage
*/
IPage<TInsuranceUnpurchaseApply> getCopyPage(Page<TInsuranceUnpurchaseApply> page,
@Param("tInsuranceUnpurchaseApply") TInsuranceUnpurchaseApplySearchVo tInsuranceUnpurchaseApply,
@Param("userId") String userId);
}
......@@ -5,9 +5,12 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchasePerson;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonSearchVo;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 含风险项目不购买申请明细表
*
......@@ -23,4 +26,18 @@ public interface TInsuranceUnpurchasePersonMapper extends BaseMapper<TInsuranceU
*/
IPage<TInsuranceUnpurchasePerson> getTInsuranceUnpurchasePersonPage(Page<TInsuranceUnpurchasePerson> page
, @Param("tInsuranceUnpurchasePerson") TInsuranceUnpurchasePersonSearchVo tInsuranceUnpurchasePerson);
/**
* 含风险项目不购买申请表简单分页查询
* @param tInsuranceUnpurchasePerson 含风险项目不购买申请表
* @return
*/
long getTInsuranceUnpurchaseInfoExportCount(@Param("tInsuranceUnpurchasePerson") TInsuranceUnpurchasePersonSearchVo tInsuranceUnpurchasePerson);
/**
* 含风险项目不购买申请表简单导出查询
* @param tInsuranceUnpurchasePerson 含风险项目不购买申请表
* @return
*/
List<TInsuranceUnpurchasePersonVo> getTInsuranceUnpurchaseInfoExportList(@Param("tInsuranceUnpurchasePerson") TInsuranceUnpurchasePersonSearchVo tInsuranceUnpurchasePerson);
}
package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.common.core.exception.CheckedException;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.ErrorMessage;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TApprovalRecordSearchVo;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
/**
* 审批记录表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
public interface TApprovalRecordService extends IService<TApprovalRecord> {
/**
* 审批记录表简单分页查询
* @param tApprovalRecord 审批记录表
* @return
*/
IPage<TApprovalRecord> getTApprovalRecordPage(Page<TApprovalRecord> page, TApprovalRecordSearchVo tApprovalRecord);
/**
* 通过实体id和审核类型查询所有的审核记录
* @param domainId 实体id
* @param auditType 审核类型 0不购买商险审核
* @return R<Map<String, Object>> key=auditInfo表示审批记录列表
**/
R<Map<String, Object>> getAuditInfoByDomainIdAndAuditType(String domainId, String auditType);
}
package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditCopyInfo;
/**
* 审批抄送记录信息表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
public interface TAuditCopyInfoService extends IService<TAuditCopyInfo> {
}
package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditNodeProocess;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
* 审批主流程记录表节点表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
public interface TAuditNodeProocessService extends IService<TAuditNodeProocess> {
}
......@@ -3,11 +3,15 @@ package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.common.core.exception.CheckedException;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchaseApply;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchaseApplySearchVo;
import org.springframework.transaction.annotation.Transactional;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
/**
* 含风险项目不购买申请表
......@@ -27,5 +31,43 @@ public interface TInsuranceUnpurchaseApplyService extends IService<TInsuranceUnp
void listExport(HttpServletResponse response, TInsuranceUnpurchaseApplySearchVo searchVo);
/**
* 审核分页
* @param page 分页信息
* @param unpurchaseApplySearchVo 不购买申请查询信息
* @param userId 登录用户id
* @param type 0待审核、1已处理、2抄送我
* @return IPage
*/
IPage<TInsuranceUnpurchaseApply> getAuditPage(Page<TInsuranceUnpurchaseApply> page,
TInsuranceUnpurchaseApplySearchVo unpurchaseApplySearchVo,
String userId, String type);
/**
* 审核数量
* @param userId 登录用户id
* @return IPage
*/
Map<String,Integer> getAuditCount(String userId);
/**
* 提交审核
* @param id 实体id
* @return R<String>
**/
R<String> commitOne(String id) throws CheckedException;
/**
* 审核
* @param insuranceUnpurchaseApply 审批信息
* @return R<String>
**/
R<String> auditAndCommit(TInsuranceUnpurchaseApply insuranceUnpurchaseApply, String approvalResult, String approvalOpinion, YifuUser user)
throws CheckedException;
@Transactional
R addApply(TInsuranceUnpurchaseApply tInsuranceUnpurchaseApply);
R<TInsuranceUnpurchaseApply> getDetailInfoById(String id);
}
package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.impl;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import com.yifu.cloud.plus.v1.yifu.admin.api.entity.SysUser;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.exception.CheckedException;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditNodeProocess;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchaseApply;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TApprovalRecordService;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TAuditNodeProocessService;
import com.yifu.cloud.plus.v1.yifu.process.constant.ProcessConstants;
import com.yifu.cloud.plus.v1.yifu.process.entity.*;
import com.yifu.cloud.plus.v1.yifu.process.util.CommonProcessUserUtil;
import com.yifu.cloud.plus.v1.yifu.process.util.ProcessAuditUtil;
import com.yifu.cloud.plus.v1.yifu.process.vo.ProcessVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.*;
/**
* 流程审批抽象类——仿照crm流程处理
* @author 陈宇茜
* @date 2025/01/13
* @since 1.7.5
*/
@Slf4j
public abstract class AbastractAuditProcess<T,E extends T> {
@Resource
protected TAuditNodeProocessService auditNodeProocessService;
@Resource
protected TApprovalRecordService approvalRecordService;
public static final String BIGIN_NODE_NO_FOUND = "未找到开始审批节点,请联系管理员";
public static final String NEXT_NODE_USER_NULL = "未查询到下个节点的用户,请联系管理员";
public static final String NEXT_AUDIT_NODE_NOT_FOUND = "未查询到下一个审核节点,请联系管理员";
/**
* 审核成功并结束逻辑
* @param entity 业务实体
* @param approvalRecord 审批记录
* @param loginUser 当前登录用户
* @return R<String>
**/
abstract public R<String> auditSuccess(T entity, TApprovalRecord approvalRecord, YifuUser loginUser);
/**
* 审核成功并结束逻辑
* @param entity 业务实体
* @param approvalRecord 审批记录
* @param remoteSysUserList 当前登录用户
* @return R<String>
**/
abstract public R<String> auditSuccessAndNex(T entity, List<SysUser> remoteSysUserList, TApprovalRecord approvalRecord);
/**
* 审核不通过处理逻辑
* @param entity 业务实体
* @param approvalRecord 审批记录
* @return R<String>
**/
abstract public R<String> auditFail(T entity, TApprovalRecord approvalRecord);
/**
* 选择节点。不同类型可能有不同选择节点
* @param entity 业务实体
* @return TProcessNode
**/
abstract public TProcessNode choiceGetNode(ProcessVo processVo, List<TNodeRoute> nodeRouteList, List<TNodeRouteCondition> nodeRouteConditionList,
TProcessNode currentNode, T entity, String type, YifuUser loginUser);
/**
* 审批发消息
* @param users 发送人
* @param entity 实体信息
* @param type 1发送审批消息 2发送抄送消息
* @return R<String>
**/
abstract public R<String> sendMessage(List<SysUser> users, T entity, String type, TApprovalRecord approvalRecord);
/**
* 根据事业部条线获取审批用户
* @param nodePrimission
* @param entity
* @return List<SysUser>
**/
abstract public List<SysUser> getDivisionAuditUser(TNodePrimission nodePrimission, T entity);
/**
* 获取当前节点的审批人
* @param sysUserTprocessNode 当前节点
* @param departId 部门id
* @param entityId 实体id
* @return List<SysUser>
**/
private List<SysUser> getAuditUserByTprocessNode(TProcessNode sysUserTprocessNode, String departId, String entityId, String auditType,
T entity,TApprovalRecord approvalRecord) {
// todo 获取当前流程 改成dapr写法
R<ProcessVo> processVoByName = null;
// remoteProcessService.getProcessVoByName(sysUserTprocessNode.getProcessId());
// todo 临时
if(processVoByName == null){
throw new CheckedException("未找到审批节点,请联系管理员");
}
ProcessVo processVo = processVoByName.getData();
List<TNodePrimission> nodePrimissions = null;
for (TProcessNode processNode : processVo.getProcessNodeList()) {
if (StringUtils.equals(sysUserTprocessNode.getLogoTitle(), processNode.getLogoTitle())) {
List<TNodePrimission> nodePrimissionList = processNode.getNodePrimissionList();
if (nodePrimissionList != null && !nodePrimissionList.isEmpty()) {
nodePrimissions = nodePrimissionList;
}
}
}
if (nodePrimissions == null) {
throw new CheckedException("未找到审批节点,请联系管理员");
}
// 获取所有审批用户
List<SysUser> sysUserList = new ArrayList<>();
// 节点是否允许跳过(0:不允许,1允许)
Integer isPass = CommonConstants.ZERO_INT;
for (TNodePrimission nodePrimission : nodePrimissions) {
// 审核用户改造; 2指定权限;3指定用户;5指定角色(crm);6指定事业部配置表
if (CommonConstants.THREE_INT == nodePrimission.getType().intValue()
|| CommonConstants.TWO_INT == nodePrimission.getType().intValue()
|| CommonConstants.FIVE_INT == nodePrimission.getType().intValue()) {
// todo
sysUserList = CommonProcessUserUtil.getDepartAuditUser(nodePrimission, departId);
}
if (CommonConstants.SIX_INT == nodePrimission.getType().intValue()) {
// todo 根据事业部条线获取审批用户
sysUserList = this.getDivisionAuditUser(nodePrimission, entity);
}
if (Common.isEmpty(sysUserList)) {
throw new CheckedException("未找到审批用户,请联系管理员");
}
// 事业部条线没有审批人直接审核通过,配置了可以跳过
if(Common.isEmpty(sysUserList) && CommonConstants.ONE_STRING.equals(nodePrimission.getIsPass())){
// 标记节点可以跳过
isPass = CommonConstants.ONE_INT;
// todo 系统自动给当前节点完成审核,将审核通过
// sysAutoAudit(sysUserTprocessNode,entity,processVo);
} else {
if (Common.isEmpty(sysUserList)) {
throw new CheckedException("未找到审批用户");
}
//微信审批通知发送
//发送审批消息
sendMessage(sysUserList,entity,CommonConstants.ONE_STRING,approvalRecord);
for (SysUser sysUser : sysUserList) {
// 新增指派审核流程记录
TApprovalRecord newEntity = new TApprovalRecord();
newEntity.setDomainId(entityId);
newEntity.setFlowId(sysUserTprocessNode.getProcessId());
newEntity.setNodeId(sysUserTprocessNode.getId());
newEntity.setApprovalMan(String.valueOf(sysUser.getUserId()));
newEntity.setApprovalManName(sysUser.getNickname());
newEntity.setDeleteFlag(CommonConstants.NOT_DELETE_FLAG);
newEntity.setPreFlag(CommonConstants.ONE_STRING);
newEntity.setApprovalResult(CommonConstants.TWO_STRING);
newEntity.setNodeName(sysUserTprocessNode.getName());
// 获取提交人信息
TApprovalRecord tApprovalRecord = approvalRecordService.getOne(Wrappers.<TApprovalRecord>query().lambda().eq(TApprovalRecord::getDomainId, entityId)
.eq(TApprovalRecord::getAuditType, auditType)
.eq(TApprovalRecord::getPreFlag, CommonConstants.ONE_STRING)
.eq(TApprovalRecord::getApprovalResult, CommonConstants.THREE_STRING)
.orderByDesc(TApprovalRecord::getId).last(CommonConstants.SQL_LIMIT_ONE));
if(Common.isNotNull(tApprovalRecord)) {
newEntity.setSubmitMan(tApprovalRecord.getSubmitMan());
newEntity.setSubmitManName(tApprovalRecord.getSubmitManName());
newEntity.setSubmitCreateTime(tApprovalRecord.getSubmitCreateTime());
newEntity.setReason(tApprovalRecord.getReason());
newEntity.setEntityName(tApprovalRecord.getEntityName());
newEntity.setAuditType(tApprovalRecord.getAuditType());
}
newEntity.setCreateTime(LocalDateTime.now());
approvalRecordService.save(newEntity);
}
// todo 存当前审核人信息[AUDIT_USER]多个用逗号隔开
}
}
// 事业部条线没有审批人直接审核通过,配置了可以跳过
if(Common.isEmpty(sysUserList) && isPass == CommonConstants.ONE_INT){
sysUserList = new ArrayList<>();
SysUser sysUserTemp = new SysUser();
sysUserList.add(sysUserTemp);
}
return sysUserList;
}
/**
* 提交审核:获取审核人
* @param id 实体id
* @param loginUser 当前登录人
* @param departId 部门id 通过该部门获取审批流程
* @param processType 流程类型 1不购买商险申请
* @param auditType 审核类型 0不购买商险审核
* @return R<List<SysUser>>
**/
public R<List<SysUser>> commitAuditUserList(String id, YifuUser loginUser, String departId, String processType, String auditType,
String reason, String entityName, T entity, Class<T> clazz) {
//获取合同审批流程与下一个审核人节点
ProcessVo processVo = null;
//获取正确流程
TProcessApprovalConf processApprovalConf = getProcessApprovalConf(processType);
// todo 改成dapr获取
//processVo = ProcessAuditUtil.getProcessVo(remoteProcessService, processApprovalConf.getProcessId());
if (processVo == null) {
throw new CheckedException("未找到满足条件的主流程,请联系管理员");
}
//获取开始节点
TProcessNode startTProcessNode = ProcessAuditUtil.getBeginProcessNode(processVo);
if (startTProcessNode == null) {
return R.failed(BIGIN_NODE_NO_FOUND);
}
String currentNode = startTProcessNode.getLogoTitle();
// 保存TAuditNodeProocess节点信息
saveNodeProcess(processVo, currentNode, id, auditType);
// 获取开始节点下一个审核节点
TProcessNode sysUserTprocessNode = getNextNode(processVo, currentNode, id, auditType, entity, loginUser);
if (sysUserTprocessNode == null) {
throw new CheckedException(NEXT_AUDIT_NODE_NOT_FOUND);
}
// 记录提交审核日志
TApprovalRecord submitApprovalRecord = new TApprovalRecord();
submitApprovalRecord.setDomainId(id);
submitApprovalRecord.setFlowId(startTProcessNode.getProcessId());
submitApprovalRecord.setNodeId(startTProcessNode.getId());
submitApprovalRecord.setApprovalMan(String.valueOf(loginUser.getId()));
submitApprovalRecord.setApprovalManName(loginUser.getNickname());
// 审批结果为“提交”
submitApprovalRecord.setApprovalResult(CommonConstants.dingleDigitStrArray[3]);
submitApprovalRecord.setDeleteFlag(CommonConstants.NOT_DELETE_FLAG);
submitApprovalRecord.setApprovalTime(LocalDateTime.now());
// 审核记录标识 1当前审核记录
submitApprovalRecord.setPreFlag(CommonConstants.ONE_STRING);
submitApprovalRecord.setSubmitMan(String.valueOf(loginUser.getId()));
submitApprovalRecord.setSubmitManName(loginUser.getNickname());
//申请原因
submitApprovalRecord.setReason(reason);
//审核类型
submitApprovalRecord.setAuditType(auditType);
submitApprovalRecord.setCreateTime(LocalDateTime.now());
submitApprovalRecord.setNodeName("提交");
submitApprovalRecord.setSubmitCreateTime(LocalDateTime.now());
submitApprovalRecord.setEntityName(entityName);
approvalRecordService.save(submitApprovalRecord);
// 获取节点审核人
List<SysUser> remoteSysUserList = getAuditUserByTprocessNode(sysUserTprocessNode, departId, id, auditType,entity,submitApprovalRecord);
if (remoteSysUserList == null) {
throw new CheckedException(NEXT_NODE_USER_NULL);
}
return new R<>(remoteSysUserList);
}
/**
* 审核并提交下一个节点:获取下一个审核人
* @param id 实体id
* @param approvalResult 审核标识 0审核通过 其他审核不通过
* @param approvalOpinion 审核意见
* @param loginUser 当前登录人
* @param auditType 审核类型 0不购买商险审核
* @param entity 实体类:用于审核通过逻辑
* @return R<String>
**/
public R<String> auditUserList(String id, String approvalResult, String approvalOpinion, YifuUser loginUser,
String auditType, T entity, String departId) {
String loginUserId = loginUser.getId();
// 判断当前审核是否为最新待审核记录
List<TApprovalRecord> approvalRecords = approvalRecordService.list
(Wrappers.<TApprovalRecord>query().lambda().eq(TApprovalRecord::getDomainId, id)
.eq(TApprovalRecord::getAuditType, auditType)
.eq(TApprovalRecord::getDeleteFlag, CommonConstants.NOT_DELETE_FLAG)
.eq(TApprovalRecord::getApprovalResult, CommonConstants.TWO_STRING)
.eq(TApprovalRecord::getApprovalMan, loginUserId));
if (approvalRecords.size() != CommonConstants.ONE_INT) {
return R.failed("当前用户不能审核该记录");
}
// 更新审核记录信息
TApprovalRecord approvalRecord = approvalRecords.get(0);
approvalRecord.setApprovalResult(approvalResult);
approvalRecord.setApprovalOpinion(approvalOpinion);
approvalRecord.setApprovalTime(LocalDateTime.now());
approvalRecordService.updateById(approvalRecord);
// 移除同一个节点的另外审批人。多个节点一个人审批就够了,其他都移除
approvalRecordService.remove(Wrappers.<TApprovalRecord>query().lambda()
.eq(TApprovalRecord::getDomainId, id)
.eq(TApprovalRecord::getAuditType, auditType)
.isNull(TApprovalRecord::getApprovalTime));
// 审核通过处理
if (CommonConstants.ZERO_STRING.equals(approvalResult)) {
// 获取流程,并判断是否是最后一个节点
// 获取流程的主流程
TAuditNodeProocess auditNodeProocess = auditNodeProocessService.getOne(Wrappers.<TAuditNodeProocess>query().lambda()
.eq(TAuditNodeProocess::getDomainId, id)
.eq(TAuditNodeProocess::getType, auditType)
.eq(TAuditNodeProocess::getMainType, CommonConstants.ZERO_STRING)
.eq(TAuditNodeProocess::getDeleteFlag, CommonConstants.NOT_DELETE_FLAG)
.orderByDesc(TAuditNodeProocess::getId)
.last(CommonConstants.SQL_LIMIT_ONE));
if (auditNodeProocess == null) {
throw new CheckedException("未获取到审批记录流程数据");
}
// todo 改成dapr获取
ProcessVo processVo = null;
// ProcessAuditUtil.getProcessVo(remoteProcessService, auditNodeProocess.getProcessId());
// todo 临时
if (processVo == null) {
throw new CheckedException("未获取到结束节点");
}
TProcessNode endProcessNode = ProcessAuditUtil.getEndProcessNode(processVo);
if (endProcessNode == null) {
throw new CheckedException("未获取到结束节点");
}
TProcessNode preEndTProcessNode = ProcessAuditUtil.getPreEndTProcessNode(processVo, endProcessNode);
if (preEndTProcessNode == null) {
throw new CheckedException("未找到结束节点前一个节点");
}
// 当前是结束节点前的一个节点
if (StringUtils.equals(preEndTProcessNode.getId(), approvalRecord.getNodeId())) {
// 走审核通过处理
return auditSuccess(entity, approvalRecord, loginUser);
} else {
// todo 改成dapr——获取自动下一个审核人
// 获取流程的下一个节点,可能下一个节点是子流程,也可能是主节点,所以重新获取当前执行审批的流程和节点
ProcessVo processVoByApproval = null;
// ProcessAuditUtil.getProcessVo(remoteProcessService, approvalRecord.getFlowId());
// todo 临时
if (processVoByApproval == null) {
throw new CheckedException("未获取到下一个审核人节点");
}
// todo 判断当前是否是当前审核节点到下一个审核节点前的加签节点
TProcessNode currentProcessNode = ProcessAuditUtil.getCurrentProcessNode(processVoByApproval, approvalRecord.getNodeId());
TProcessNode sysUserTprocessNode = getNextNode(processVoByApproval, currentProcessNode.getLogoTitle(), id, auditType, entity, loginUser);
if (sysUserTprocessNode == null) {
throw new CheckedException(NEXT_AUDIT_NODE_NOT_FOUND);
}
auditNodeProocess = auditNodeProocessService.getOne(Wrappers.<TAuditNodeProocess>query().lambda()
.eq(TAuditNodeProocess::getDomainId, id)
.eq(TAuditNodeProocess::getType, auditType)
.eq(TAuditNodeProocess::getMainType, CommonConstants.ZERO_STRING)
.eq(TAuditNodeProocess::getDeleteFlag, CommonConstants.NOT_DELETE_FLAG)
.orderByDesc(TAuditNodeProocess::getId)
.last(CommonConstants.SQL_LIMIT_ONE));
// 如果返回的是end节点:判断是不是返回的是不是主流程结束节点
if (StringUtils.equals(ProcessConstants.PROCESS_NODE_END, sysUserTprocessNode.getType())
&& StringUtils.equals(auditNodeProocess.getProcessId(), sysUserTprocessNode.getProcessId())) {
//审核通过流程
return auditSuccess(entity, approvalRecord, loginUser);
}
// 获取审批用户
List<SysUser> remoteSysUserList = getAuditUserByTprocessNode(sysUserTprocessNode, departId, id, auditType, entity, approvalRecord);
if (remoteSysUserList == null) {
throw new CheckedException(NEXT_NODE_USER_NULL);
}
// 流程中的审核结束,继续下一个节点
return auditSuccessAndNex(entity, remoteSysUserList, approvalRecord);
}
} else {
//审核不通过处理
return auditFail(entity, approvalRecord);
}
}
/**
* 获取下一个节点
* @param processVo 流程记录
* @param currentNodeString 当前节点
* @param id 实体id
**/
private TProcessNode getNextNode(ProcessVo processVo, String currentNodeString, String id, String auditType, T entity, YifuUser loginUser) {
// 判断进行到的节点当前流程是主流程还是子流程,如果是主流程,则进行主流程,如果是子流程,则进行子流程判断
TAuditNodeProocess auditNodeProocess = auditNodeProocessService.getOne(Wrappers.<TAuditNodeProocess>query().lambda()
.eq(TAuditNodeProocess::getDomainId, id)
.eq(TAuditNodeProocess::getType, auditType)
.eq(TAuditNodeProocess::getDeleteFlag, CommonConstants.ZERO_STRING)
.isNotNull(TAuditNodeProocess::getLogoTitle)
.orderByDesc(TAuditNodeProocess::getId).last(CommonConstants.SQL_LIMIT_ONE));
// 流程预览功能无需判断当前节点是否一致
if (auditNodeProocess != null && !StringUtils.equals(currentNodeString, auditNodeProocess.getLogoTitle())) {
throw new CheckedException("记录的流程节点和当前执行节点不匹配");
}
List<TProcessNode> processNodeList = processVo.getProcessNodeList();
List<TNodeRoute> nodeRouteList = processVo.getNodeRouteList();
//判断当前节点类型,如果是选择节点则进行条件表达式判断判断
TProcessNode currentNode = null;
for (TProcessNode processNode : processNodeList) {
if (StringUtils.equals(currentNodeString, processNode.getLogoTitle())) {
currentNode = processNode;
}
}
if (currentNode == null) {
throw new CheckedException("未获取到当前节点");
}
if (StringUtils.equals(ProcessConstants.PROCESS_NODE_TYPE_CHOICE, currentNode.getType())) {
// 当前节点为选择节点,获取当前节点路由类型
List<TNodeRouteCondition> nodeRouteConditionList = Lists.newArrayList();
for (TNodeRoute nodeRoute : nodeRouteList) {
if (StringUtils.equals(currentNode.getLogoTitle(), nodeRoute.getPrewNode())) {
nodeRouteConditionList.addAll(nodeRoute.getNodeRouteConditionList());
}
}
return choiceGetNode(processVo, nodeRouteList, nodeRouteConditionList, currentNode, entity, auditType, loginUser);
} else if (StringUtils.equals(ProcessConstants.PROCESS_NODE_END, currentNode.getType())) {
TProcessNode endNode = ProcessAuditUtil.getEndProcessNode(processVo);
if (StringUtils.equals(currentNode.getId(), endNode.getId())) {
return endNode;
} else {
throw new CheckedException("当前不是结束节点");
}
} else if (StringUtils.equals(ProcessConstants.PROCESS_NODE_BEGIN, currentNode.getType()) || StringUtils.equals(ProcessConstants.PROCESS_NODE_SERVICE, currentNode.getType())) {
//查找下个节点
try {
TNodeRoute nexTNodeRoute = ProcessAuditUtil.getNexTNodeRoute(nodeRouteList, currentNodeString);
saveNodeProcess(processVo, nexTNodeRoute.getNextNode(), id, auditType);
return validateTwoNextNode(processVo, nexTNodeRoute.getNextNode(), id, nexTNodeRoute.getRouteType(), auditType, entity, loginUser);
}catch (Exception e){
if (Common.isEmpty(processVo.getIsPreview())){
throw e;
}
return null;
}
} else {
throw new CheckedException("未知的流程节点类型");
}
}
/**
* 通过表中配置的字段名称去取对应判断条件
* @param type 流程类型:类型 1不购买商险申请
* @return TProcessApprovalConf
**/
private TProcessApprovalConf getProcessApprovalConf(String type) {
return null;
// todo 找到对应的流程查看判断的类名和字段名
// R<TProcessApprovalConf> processApprovalConfR = remoteProcessService.getRecordbyTypeAndParentId(type);
// if (processApprovalConfR != null && processApprovalConfR.getData() != null && CommonConstants.SUCCESS == processApprovalConfR.getCode()) {
// return processApprovalConfR.getData();
// } else {
// throw new CheckedException("未获取到对应流程配置");
// }
// throw new CheckedException("调用流程服务返回数据为空");
}
/**
* 校验下一个节点
* @param processVo 流程配置信息
* @param currentNodeString 当前节点
* @param id 实体id
* @param routeType 上一个路由类型
* @return TProcessNode
**/
protected TProcessNode validateTwoNextNode(ProcessVo processVo, String currentNodeString, String id, String routeType, String auditType,
T entity, YifuUser loginUser) {
List<TProcessNode> processNodeList = processVo.getProcessNodeList();
// 判断当前节点类型,如果是选择节点则进行条件表达式判断判断
TProcessNode currentNode = null;
for (TProcessNode processNode : processNodeList) {
if (StringUtils.equals(currentNodeString, processNode.getLogoTitle())) {
currentNode = processNode;
}
}
if(Common.isEmpty(currentNode)){
throw new CheckedException("未获取到当前节点,请联系管理员处理");
}
// 1.7.5 未引入抄送逻辑:获取下个抄送节点信息(暂未引入)
if (StringUtils.equals(ProcessConstants.PROCESS_NODE_TYPE_CHOICE, currentNode.getType())) {
return getNextNode(processVo, currentNodeString, id, auditType, entity, loginUser);
} else if (StringUtils.equals(ProcessConstants.PROCESS_NODE_SERVICE, currentNode.getType())) {
if (StringUtils.equals(routeType, CommonConstants.ONE_STRING)) {
// 是审批节点
return currentNode;
} else if (StringUtils.equals(routeType, CommonConstants.THREE_STRING)) {
// 1.7.5 未引入抄送逻辑
// 继续找下一个节点
return getNextNode(processVo, currentNode.getLogoTitle(), id, auditType, entity, loginUser);
} else {
throw new CheckedException("未知的节点");
}
} else if (StringUtils.equals(ProcessConstants.PROCESS_NODE_BEGIN, currentNode.getType())) {
return getNextNode(processVo, currentNode.getLogoTitle(), id, auditType, entity, loginUser);
} else if (StringUtils.equals(ProcessConstants.PROCESS_NODE_END, currentNode.getType())) {
return getNextNode(processVo, currentNode.getLogoTitle(), id, auditType, entity, loginUser);
} else if (StringUtils.equals(ProcessConstants.PROCESS_NODE_EMBED, currentNode.getType())) {
return getNextNode(processVo, currentNode.getLogoTitle(), id, auditType, entity, loginUser);
} else {
throw new CheckedException("未知的节点");
}
}
/**
* 保存经过流程节点记录
* @param processVo
* @param nextNodeString
* @param entityId
**/
protected void saveNodeProcess(ProcessVo processVo, String nextNodeString, String entityId, String type) {
TProcessNode processNode = null;
for (TProcessNode node : processVo.getProcessNodeList()) {
if (StringUtils.equals(nextNodeString, node.getLogoTitle())) {
processNode = node;
}
}
if (processNode == null) {
throw new CheckedException("节点id为空");
}
TAuditNodeProocess auditNodeProocess = new TAuditNodeProocess();
saveProcessNodeProcess(processVo, entityId, type, processNode, auditNodeProocess);
}
/**
* 保存经过流程节点记录
* @param processVo
* @param entityId
* @param processNode
* @param auditNodeProocess
**/
private void saveProcessNodeProcess(ProcessVo processVo, String entityId, String type, TProcessNode processNode, TAuditNodeProocess auditNodeProocess) {
auditNodeProocess.setDomainId(entityId);
auditNodeProocess.setNodeId(processNode.getId());
auditNodeProocess.setProcessId(processNode.getProcessId());
auditNodeProocess.setCreateTime(LocalDateTime.now());
// todo 新版流程审批默认主节点
auditNodeProocess.setMainType(CommonConstants.ZERO_STRING);
auditNodeProocess.setLogoTitle(processNode.getLogoTitle());
auditNodeProocess.setNodeType(processNode.getType());
auditNodeProocess.setNodeName(processNode.getName());
auditNodeProocess.setProcessName(processVo.getName());
auditNodeProocess.setDeleteFlag(CommonConstants.ZERO_STRING);
auditNodeProocess.setType(type);
auditNodeProocessService.save(auditNodeProocess);
}
}
package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord;
import com.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances.TApprovalRecordMapper;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TApprovalRecordService;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Service;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TApprovalRecordSearchVo;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.util.List;
import java.util.Map;
/**
* 审批记录表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@Log4j2
@Service
public class TApprovalRecordServiceImpl extends ServiceImpl<TApprovalRecordMapper, TApprovalRecord> implements TApprovalRecordService {
/**
* 审批记录表简单分页查询
* @param tApprovalRecord 审批记录表
* @return
*/
@Override
public IPage<TApprovalRecord> getTApprovalRecordPage(Page<TApprovalRecord> page, TApprovalRecordSearchVo tApprovalRecord){
return baseMapper.getTApprovalRecordPage(page,tApprovalRecord);
}
/**
* 通过实体id和审核类型查询所有的审核记录
*
* @param domainId 实体id
* @param auditType 审核类型 0不购买商险审核
* @return R<Map < String, Object>> key=auditInfo表示审批记录列表
**/
@Override
public R<Map<String, Object>> getAuditInfoByDomainIdAndAuditType(String domainId, String auditType) {
Map<String, Object> resultMap = Maps.newHashMap();
// 获取审批列表
List<TApprovalRecord> auditInfoList = baseMapper.getApprovalRecordList(domainId, auditType);
resultMap.put("auditInfo", auditInfoList);
return new R<>(resultMap);
}
}
package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditCopyInfo;
import com.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances.TAuditCopyInfoMapper;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TAuditCopyInfoService;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Service;
/**
* 审批抄送记录信息表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
*/
@Log4j2
@Service
public class TAuditCopyInfoServiceImpl extends ServiceImpl<TAuditCopyInfoMapper, TAuditCopyInfo> implements TAuditCopyInfoService {
}
package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditNodeProocess;
import com.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances.TAuditNodeProocessMapper;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TAuditNodeProocessService;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
* 审批主流程记录表节点表
*
* @author chenyuxi
* @date 2025-01-10 17:47:32
* @since 1.7.5
*/
@Log4j2
@Service
public class TAuditNodeProocessServiceImpl extends ServiceImpl<TAuditNodeProocessMapper, TAuditNodeProocess> implements TAuditNodeProocessService {
}
......@@ -3,25 +3,49 @@ package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.impl;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.baomidou.lock.annotation.Lock4j;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CacheConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.ResultConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.common.core.util.DateUtil;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.common.dapr.util.SocialDaprUtils;
import com.yifu.cloud.plus.v1.yifu.common.security.util.SecurityUtils;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchaseApply;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchasePerson;
import com.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances.TInsuranceUnpurchaseApplyMapper;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TInsuranceUnpurchaseApplyService;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TInsuranceUnpurchasePersonService;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.impl.process.TInsuranceUnpurchaseApplyAuditProcess;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchaseApplySearchVo;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchaseApplyVo;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonAddVo;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonCardVo;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.support.SimpleValueWrapper;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.net.URLEncoder;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 含风险项目不购买申请表
......@@ -32,6 +56,21 @@ import java.util.List;
@Log4j2
@Service
public class TInsuranceUnpurchaseApplyServiceImpl extends ServiceImpl<TInsuranceUnpurchaseApplyMapper, TInsuranceUnpurchaseApply> implements TInsuranceUnpurchaseApplyService {
@Resource
private TInsuranceUnpurchasePersonService personService;
@Resource
private SocialDaprUtils socialDaprUtil;
@Resource
private CacheManager cacheManager;
@Resource
@Lazy
private TInsuranceUnpurchaseApplyAuditProcess tInsuranceUnpurchaseApplyAuditProcess;
/**
* 含风险项目不购买申请表简单分页查询
*
......@@ -64,14 +103,14 @@ public class TInsuranceUnpurchaseApplyServiceImpl extends ServiceImpl<TInsurance
public void listExport(HttpServletResponse response, TInsuranceUnpurchaseApplySearchVo searchVo) {
String fileName = "含风险项目不购买申请表批量导出" + DateUtil.getThisTime() + ".xlsx";
//获取要导出的列表
List<TInsuranceUnpurchaseApply> list = new ArrayList<>();
List<TInsuranceUnpurchaseApplyVo> list = new ArrayList<>();
long count = baseMapper.getTInsuranceUnpurchaseApplyExportCount(searchVo);
try(ServletOutputStream out = response.getOutputStream();) {
response.setContentType(CommonConstants.MULTIPART_FORM_DATA);
response.setCharacterEncoding("utf-8");
response.setHeader(CommonConstants.CONTENT_DISPOSITION, CommonConstants.ATTACHMENT_FILENAME + URLEncoder.encode(fileName, CommonConstants.UTF8));
// 这里 需要指定写用哪个class去写,然后写到第一个sheet,然后文件流会自动关闭
ExcelWriter excelWriter = EasyExcel.write(out, TInsuranceUnpurchaseApply.class).build();
ExcelWriter excelWriter = EasyExcel.write(out, TInsuranceUnpurchaseApplyVo.class).build();
int index = 0;
if (count > CommonConstants.ZERO_INT) {
for (int i = 0; i <= count; i = i + CommonConstants.EXCEL_EXPORT_LIMIT) {
......@@ -100,4 +139,329 @@ public class TInsuranceUnpurchaseApplyServiceImpl extends ServiceImpl<TInsurance
log.error("执行异常", e);
}
}
@Override
public R addApply(TInsuranceUnpurchaseApply tInsuranceUnpurchaseApply) {
YifuUser user = SecurityUtils.getUser();
//字段长度校验
if (Common.isNotNull(tInsuranceUnpurchaseApply.getReasonInfo()) && tInsuranceUnpurchaseApply.getReasonInfo().length() > 200) {
return R.failed("原因说明不能超过两百个字符");
}
try {
//申请编号
String applyNo = getCode();
//获取明细当日最大申请编号
String applyDetail = baseMapper.getMaxInusuranceDetailCode();
//暂存不做校验
if (CommonConstants.ONE_STRING.equals(tInsuranceUnpurchaseApply.getSaveFlag())) {
tInsuranceUnpurchaseApply.setApplyNo(applyNo);
tInsuranceUnpurchaseApply.setCreateBy(user.getId());
tInsuranceUnpurchaseApply.setCreateName(user.getNickname());
tInsuranceUnpurchaseApply.setCreateUserDeptName(user.getDeptName());
tInsuranceUnpurchaseApply.setCreateUserDeptId(user.getDeptId().toString());
tInsuranceUnpurchaseApply.setCreateTime(null);
tInsuranceUnpurchaseApply.setUpdateTime(null);
baseMapper.insert(tInsuranceUnpurchaseApply);
List<TInsuranceUnpurchasePerson> personList = new ArrayList<>();
if (Common.isNotNull(tInsuranceUnpurchaseApply.getPersonList())) {
for (TInsuranceUnpurchasePersonAddVo vo : tInsuranceUnpurchaseApply.getPersonList()) {
TInsuranceUnpurchasePerson person = new TInsuranceUnpurchasePerson();
person.setEmpIdcardNo(vo.getEmpIdcardNo());
person.setEmpName(vo.getEmpName());
person.setPost(vo.getPost());
person.setApplyNoDetail(getDetailCode(applyDetail,vo.getRowIndex()));
initValue(tInsuranceUnpurchaseApply, person);
personList.add(person);
}
personService.saveBatch(personList);
}
} else if (CommonConstants.TWO_STRING.equals(tInsuranceUnpurchaseApply.getSaveFlag())) {
//校验若该项目&该人员身份证号是否已经有过“已购买社保”的不购买商险明细,若有也会禁止重复提交!提示:姓名+身份证号、姓名+身份证号、已有申请记录,无需重复提交,可删除后再提交;
//校验该身份证&姓名组合的数据能否找到在途或在保的社保-工伤险数据,即是否为-“工伤”险正常参保的人员,不受项目限制,若“工伤”险皆正常在保或有在途“待审核、待办理”,则可正常提交,若未正常参保或无在途的参保数据,则提示“姓名+身份证号、姓名+身份证号无正常参保或派单中的数据,禁止提交!”
List<TInsuranceUnpurchasePersonAddVo> personList = addAndUpdCheck(tInsuranceUnpurchaseApply);
if (Common.isNotNull(personList) && !personList.isEmpty() &&
personList.stream().noneMatch(e -> CommonConstants.ONE_STRING.equals(e.getCode()))) {
tInsuranceUnpurchaseApply.setCreateBy(user.getId());
tInsuranceUnpurchaseApply.setCreateName(user.getNickname());
tInsuranceUnpurchaseApply.setCreateUserDeptName(user.getDeptName());
tInsuranceUnpurchaseApply.setCreateUserDeptId(user.getDeptId().toString());
tInsuranceUnpurchaseApply.setApplyNo(applyNo);
baseMapper.insert(tInsuranceUnpurchaseApply);
List<TInsuranceUnpurchasePerson> personInfoList = new ArrayList<>();
for (TInsuranceUnpurchasePersonAddVo vo : personList) {
TInsuranceUnpurchasePerson person = new TInsuranceUnpurchasePerson();
person.setEmpIdcardNo(vo.getEmpIdcardNo());
person.setEmpName(vo.getEmpName());
person.setPost(vo.getPost());
person.setApplyNoDetail(getDetailCode(applyDetail,vo.getRowIndex()));
initValue(tInsuranceUnpurchaseApply, person);
personInfoList.add(person);
}
personService.saveBatch(personInfoList);
} else {
return R.failed(personList);
}
} else if (CommonConstants.THREE_STRING.equals(tInsuranceUnpurchaseApply.getSaveFlag())) {
List<TInsuranceUnpurchasePersonAddVo> personList = addAndUpdCheck(tInsuranceUnpurchaseApply);
if (Common.isNotNull(personList) && !personList.isEmpty() &&
personList.stream().noneMatch(e -> CommonConstants.ONE_STRING.equals(e.getCode()))) {
//同倩倩确认申请时间实时更新
tInsuranceUnpurchaseApply.setCreateTime(LocalDateTime.now());
baseMapper.updateById(tInsuranceUnpurchaseApply);
//先删除明细表数据再重新生成
personService.remove(Wrappers.<TInsuranceUnpurchasePerson>lambdaQuery()
.eq(TInsuranceUnpurchasePerson::getParnetId, tInsuranceUnpurchaseApply.getId()));
List<TInsuranceUnpurchasePerson> personInfoList = new ArrayList<>();
for (TInsuranceUnpurchasePersonAddVo vo : personList) {
TInsuranceUnpurchasePerson person = new TInsuranceUnpurchasePerson();
person.setEmpIdcardNo(vo.getEmpIdcardNo());
person.setEmpName(vo.getEmpName());
person.setPost(vo.getPost());
person.setApplyNoDetail(getDetailCode(applyDetail,vo.getRowIndex()));
initValue(tInsuranceUnpurchaseApply, person);
personInfoList.add(person);
}
personService.saveBatch(personInfoList);
} else {
return R.failed(personList);
}
}
return R.ok();
} catch (Exception e) {
e.printStackTrace();
return R.failed("系统异常,保存、更新失败!");
}
}
@Override
public R<TInsuranceUnpurchaseApply> getDetailInfoById(String id) {
TInsuranceUnpurchaseApply apply = baseMapper.selectById(id);
if (Common.isEmpty(apply)) {
return R.failed(CommonConstants.NO_DATA_TO_HANDLE);
}
return R.ok();
}
public List<TInsuranceUnpurchasePersonAddVo> addAndUpdCheck(TInsuranceUnpurchaseApply tInsuranceUnpurchaseApply) {
Map<String,String> sameCheckMap = new HashMap<>();
TInsuranceUnpurchasePerson exit;
List<TInsuranceUnpurchasePersonAddVo> personList = tInsuranceUnpurchaseApply.getPersonList();
if (Common.isNotNull(personList) && !personList.isEmpty()) {
for (TInsuranceUnpurchasePersonAddVo vo : personList) {
StringBuilder sameCheck = new StringBuilder();
sameCheck.append(vo.getEmpIdcardNo());
sameCheck.append("_");
sameCheck.append(vo.getEmpName());
sameCheck.append("_");
sameCheck.append(vo.getPost());
if (null == sameCheckMap.get(sameCheck.toString())) {
sameCheckMap.put(sameCheck.toString(), "1");
} else {
vo.setCode(CommonConstants.ONE_STRING);
vo.setMessage(vo.getEmpName() + "_" + vo.getEmpIdcardNo() + ":已有申请记录,无需重复提交,可删除后再提交");
}
exit = personService.getOne(Wrappers.<TInsuranceUnpurchasePerson>query().lambda()
.eq(TInsuranceUnpurchasePerson::getDeptNo, tInsuranceUnpurchaseApply.getDeptNo())
.eq(TInsuranceUnpurchasePerson::getEmpIdcardNo, vo.getEmpIdcardNo())
.last(CommonConstants.LAST_ONE_SQL));
if (Common.isNotNull(exit)) {
vo.setCode(CommonConstants.ONE_STRING);
vo.setMessage(vo.getEmpName() + "_" + vo.getEmpIdcardNo() + ":已有申请记录,无需重复提交,可删除后再提交");
continue;
}
TInsuranceUnpurchasePersonCardVo cardVo = new TInsuranceUnpurchasePersonCardVo();
cardVo.setEmpIdcardNo(vo.getEmpIdcardNo());
cardVo.setEmpName(vo.getEmpName());
R<Boolean> flag = socialDaprUtil.selectExitSocialInjury(cardVo);
if (Common.isEmpty(flag) || Boolean.TRUE.equals(!flag.getData())) {
vo.setCode(CommonConstants.ONE_STRING);
vo.setMessage(vo.getEmpName() + "_" + vo.getEmpIdcardNo() + ":无正常参保或派单中的数据,禁止提交!");
}
}
}
return personList;
}
private void initValue(TInsuranceUnpurchaseApply tInsuranceUnpurchaseApply,TInsuranceUnpurchasePerson person) {
person.setParnetId(tInsuranceUnpurchaseApply.getId());
person.setApplyNo(tInsuranceUnpurchaseApply.getApplyNo());
person.setDeptId(tInsuranceUnpurchaseApply.getDeptId());
person.setDeptNo(tInsuranceUnpurchaseApply.getDeptNo());
person.setDivision(tInsuranceUnpurchaseApply.getDivision());
person.setNewLine(tInsuranceUnpurchaseApply.getNewLine());
person.setReasonInfo(tInsuranceUnpurchaseApply.getReasonInfo());
person.setCreateBy(tInsuranceUnpurchaseApply.getCreateBy());
person.setCreateName(tInsuranceUnpurchaseApply.getCreateName());
person.setCreateUserDeptName(tInsuranceUnpurchaseApply.getCreateUserDeptName());
person.setCreateUserDeptId(tInsuranceUnpurchaseApply.getCreateUserDeptId());
}
//获取申请编码
@Lock4j(expire = 60000, acquireTimeout = 1000)
public String getCode() {
String nowDay = DateUtil.getThisDay();
Cache cache = cacheManager.getCache(CacheConstants.EVERYDAY_UNBUY_CODE);
assert cache != null;
Object nowNumObj = cache.get(nowDay);
int nowNums = 1;
if (Common.isNotNull(nowNumObj)) {
SimpleValueWrapper value = (SimpleValueWrapper) nowNumObj;
nowNums = (Integer) value.get() + 1;
} else {
String empCode = null;
try {
empCode = baseMapper.getMaxInusuranceCode();
nowNums = Integer.parseInt(empCode) + 1;
} catch (NumberFormatException e) {
log.error("获取含风险项目不购买商险申请时出错:" + empCode);
}
}
cache.put(nowDay, nowNums);
return "SXBGM" + nowDay + this.getThreeNum(String.valueOf(nowNums));
}
//获取申请编码
public String getDetailCode(String empCode,String row) {
String nowDay = DateUtil.getThisDay();
int nowNums = 1;
try {
nowNums = Integer.parseInt(empCode) + Integer.parseInt(row);
} catch (NumberFormatException e) {
log.error("获取含风险项目不购买商险申请明细时出错:" + empCode);
}
return "SXBGMMX" + nowDay + this.getFiveNum(String.valueOf(nowNums));
}
/**
* @param nowNums 数字
* @Description: 获取三位字符型数字
* @Author: huych
* @Date: 2025/1/14 17:35
* @return: 三位字符型数字
**/
private String getThreeNum(String nowNums) {
if (nowNums.length() >= 3) {
return nowNums.substring(0, 3);
}
String[] zeroArr = {"0", "00", "000", "0000"};
int num = 2 - nowNums.length();
return zeroArr[num] + nowNums;
}
/**
* @param nowNums 数字
* @Description: 获取五位字符型数字
* @Author: huych
* @Date: 2025/1/14 17:35
* @return: 五位字符型数字
**/
private String getFiveNum(String nowNums) {
if (nowNums.length() >= 5) {
return nowNums.substring(0, 5);
}
String[] zeroArr = {"0", "00", "000", "0000"};
int num = 4 - nowNums.length();
return zeroArr[num] + nowNums;
}
/**
* 报价单审核分页
*
* @param page 分页信息
* @param unpurchaseApplySearchVo 不购买申请查询信息
* @param userId 登录用户id
* @param type 0待审核、1已处理、2抄送我
* @return IPage
*/
@Override
public IPage<TInsuranceUnpurchaseApply> getAuditPage(Page<TInsuranceUnpurchaseApply> page, TInsuranceUnpurchaseApplySearchVo unpurchaseApplySearchVo, String userId, String type) {
IPage<TInsuranceUnpurchaseApply> auditUnpurchaseIPage;
if (StringUtils.equals(CommonConstants.ZERO_STRING, type)) {
auditUnpurchaseIPage = baseMapper.getAuditPage(page, unpurchaseApplySearchVo, userId);
} else if (StringUtils.equals(CommonConstants.ONE_STRING, type)) {
auditUnpurchaseIPage = baseMapper.getHistoryHandlePage(page, unpurchaseApplySearchVo, userId);
} else if (StringUtils.equals(CommonConstants.TWO_STRING, type)) {
auditUnpurchaseIPage = baseMapper.getCopyPage(page, unpurchaseApplySearchVo, userId);
}else {
return null;
}
return auditUnpurchaseIPage;
}
/**
* 审核数量
*
* @param userId 登录用户id
* @return IPage
*/
@Override
public Map<String, Integer> getAuditCount(String userId) {
Map<String, Integer> auditCountMap = new HashMap<>();
Integer pendingCount = baseMapper.getAuditCount(userId);
Integer processedCount = baseMapper.getHistoryHandleCount(userId);
auditCountMap.put("pending", pendingCount);
auditCountMap.put("processed", processedCount);
auditCountMap.put("copy",0);
return auditCountMap;
}
/**
* 提交审核
* @param id 实体id
* @return R<String>
**/
@Transactional
@Override
public R<String> commitOne(String id) {
YifuUser user = SecurityUtils.getUser();
if (user == null || Common.isEmpty(user.getId())) {
return R.failed(CommonConstants.PLEASE_LOG_IN);
}
TInsuranceUnpurchaseApply entity = this.getById(id);
if(entity==null){
return R.failed(ResultConstants.FAIL_INFO_NO_MODEL);
}
if(!StringUtils.equals(entity.getStatus(),CommonConstants.ONE_STRING)){
return R.failed("当前记录不为待提交状态");
}
String[] reasonType = {"1", "2"};
if(!ArrayUtils.contains(reasonType, entity.getReasonType())) {
return R.failed("未维护【不购买原因】选项,请联系管理员");
}
// “已购买社保" 并且“项目有审批通过记录”,无需发起审核流程
if(CommonConstants.ONE_STRING.equals(entity.getReasonType()) && CommonConstants.ZERO_STRING.equals(entity.getAuditFlag())){
return R.failed("【已购买社保】并且【项目有审批通过记录】,无需发起审核流程");
}
String[] companyFlag = {"0", "1"};
if(!ArrayUtils.contains(companyFlag, entity.getCompanyFlag())) {
return R.failed("未维护【申请人是否属于子分公司】,请联系管理员");
}
if(Common.isEmpty(entity.getCreateUserDeptId())){
return R.failed("申请人所属部门id不能为空");
}
// 传流程类型 1不购买商险申请,审核类型 0不购买商险审核
// R<List<SysUser>> auditUserListR = tInsuranceUnpurchaseApplyAuditProcess.commitAuditUserList(id, user, entity.getCreateUserDeptId(), CommonConstants.ONE_STRING, CommonConstants.ZERO_STRING,
// "",entity.getApplyNo(),entity,TInsuranceUnpurchaseApply.class);
// if (auditUserListR == null || auditUserListR.getCode() != CommonConstants.SUCCESS || auditUserListR.getData() == null) {
// throw new CheckedException("获取审批人失败,请联系管理员");
// }
entity.setStatus(CommonConstants.TWO_STRING);
this.updateById(entity);
return R.ok(null,"提交成功");
}
@Override
@Transactional
public R<String> auditAndCommit(TInsuranceUnpurchaseApply insuranceUnpurchaseApply, String approvalResult, String approvalOpinion, YifuUser user) {
return R.ok("审核完毕");
// return tInsuranceUnpurchaseApplyAuditProcess.auditUserList(insuranceUnpurchaseApply.getId(), approvalResult, approvalOpinion, user, CommonConstants.ZERO_STRING,
// insuranceUnpurchaseApply, insuranceUnpurchaseApply.getCreateUserDeptId());
}
}
......@@ -13,6 +13,7 @@ import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchasePerson;
import com.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances.TInsuranceUnpurchasePersonMapper;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TInsuranceUnpurchasePersonService;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonSearchVo;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonVo;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Service;
......@@ -49,23 +50,21 @@ public class TInsuranceUnpurchasePersonServiceImpl extends ServiceImpl<TInsuranc
public void listExport(HttpServletResponse response, TInsuranceUnpurchasePersonSearchVo searchVo){
String fileName = "含风险项目商险不购买导出" + DateUtil.getThisTime() + ".xlsx";
//获取要导出的列表
List<TInsuranceUnpurchasePerson> list = new ArrayList<>();
// long count = noPageCountDiy(searchVo);
long count = 0l;
List<TInsuranceUnpurchasePersonVo> list = new ArrayList<>();
long count = baseMapper.getTInsuranceUnpurchaseInfoExportCount(searchVo);
try (ServletOutputStream out = response.getOutputStream();){
response.setContentType(CommonConstants.MULTIPART_FORM_DATA);
response.setCharacterEncoding("utf-8");
response.setHeader(CommonConstants.CONTENT_DISPOSITION, CommonConstants.ATTACHMENT_FILENAME + URLEncoder.encode(fileName , CommonConstants.UTF8));
// 这里 需要指定写用哪个class去写,然后写到第一个sheet,然后文件流会自动关闭
//EasyExcel.write(out, TEmpBadRecord.class).sheet("不良记录").doWrite(list);
ExcelWriter excelWriter = EasyExcel.write(out, TInsuranceUnpurchasePerson.class).build();
ExcelWriter excelWriter = EasyExcel.write(out, TInsuranceUnpurchasePersonVo.class).build();
int index = 0;
if (count > CommonConstants.ZERO_INT){
if (count > CommonConstants.ZERO_INT){
for (int i = 0; i <= count; i = i + CommonConstants.EXCEL_EXPORT_LIMIT) {
// 获取实际记录
searchVo.setLimitStart(i);
searchVo.setLimitEnd(CommonConstants.EXCEL_EXPORT_LIMIT);
// list = noPageDiy(searchVo);
list = baseMapper.getTInsuranceUnpurchaseInfoExportList(searchVo);
if (Common.isNotNull(list)){
WriteSheet writeSheet = EasyExcel.writerSheet("含风险项目不购买申请明细表"+index).build();
excelWriter.write(list,writeSheet);
......
package com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.impl.process;
import cn.hutool.core.date.DatePattern;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.yifu.cloud.plus.v1.yifu.admin.api.entity.SysUser;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.ResultConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.exception.CheckedException;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditCopyInfo;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditNodeProocess;
import com.yifu.cloud.plus.v1.yifu.insurances.entity.TInsuranceUnpurchaseApply;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.TInsuranceUnpurchaseApplyService;
import com.yifu.cloud.plus.v1.yifu.insurances.service.insurance.impl.AbastractAuditProcess;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchaseApplySearchVo;
import com.yifu.cloud.plus.v1.yifu.process.constant.ProcessConstants;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodePrimission;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRoute;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRouteCondition;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessNode;
import com.yifu.cloud.plus.v1.yifu.process.util.ProcessAuditUtil;
import com.yifu.cloud.plus.v1.yifu.process.vo.ProcessVo;
import org.apache.commons.lang.StringUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @auther wangan
* @date 2021/4/26
* 商机审核
*/
@Component
public class TInsuranceUnpurchaseApplyAuditProcess extends AbastractAuditProcess<TInsuranceUnpurchaseApply, TInsuranceUnpurchaseApplySearchVo> {
@Resource
private TInsuranceUnpurchaseApplyService tInsuranceUnpurchaseApplyService;
@Override
public R<String> auditSuccess(TInsuranceUnpurchaseApply entity, TApprovalRecord approvalRecord, YifuUser loginUser) {
// 改实体审核状态为审核通过
entity.setAuditFlag(CommonConstants.THREE_STRING);
boolean res = tInsuranceUnpurchaseApplyService.updateById(entity);
if (res) {
// todo 删除当前实体所有的流程节点,数据量太大影响审批效率
// 防止死锁,先查询再删除
TAuditNodeProocess auditNodeProocessInfo = auditNodeProocessService.getOne(Wrappers.<TAuditNodeProocess>query().lambda()
.eq(TAuditNodeProocess::getDomainId, entity.getId())
.in(TAuditNodeProocess::getType, approvalRecord.getAuditType())
.last(CommonConstants.SQL_LIMIT_ONE));
if(Common.isNotKong(auditNodeProocessInfo)) {
auditNodeProocessService.remove(Wrappers.<TAuditNodeProocess>query().lambda().eq(TAuditNodeProocess::getDomainId, entity.getId())
.in(TAuditNodeProocess::getType, approvalRecord.getAuditType()));
}
//记录末尾节点审核
//sysMessageInfoService.saveApprovalLastAgree(CrmConstants.OPPORTUNITY_MODUL_TYPE, approvalRecord);
}
return R.ok("审核通过");
}
@Override
public R<String> auditSuccessAndNex(TInsuranceUnpurchaseApply entity, List<SysUser> remoteSysUserList, TApprovalRecord approvalRecord) {
return R.ok("审核通过");
}
@Override
public R<String> auditFail(TInsuranceUnpurchaseApply entity, TApprovalRecord approvalRecord) {
// 以后有抄送再加逻辑:参照crm-更改之前抄送记录状态为0
// 改实体审核状态为审核不通过
entity.setAuditFlag(CommonConstants.FOUR_STRING);
tInsuranceUnpurchaseApplyService.updateById(entity);
// todo 删除当前实体所有的流程节点,数据量太大影响审批效率
// 防止死锁,先查询再删除
TAuditNodeProocess auditNodeProocessInfo = auditNodeProocessService.getOne(Wrappers.<TAuditNodeProocess>query().lambda()
.eq(TAuditNodeProocess::getDomainId, entity.getId())
.in(TAuditNodeProocess::getType, approvalRecord.getAuditType())
.last(CommonConstants.SQL_LIMIT_ONE));
if(Common.isNotKong(auditNodeProocessInfo)) {
auditNodeProocessService.remove(Wrappers.<TAuditNodeProocess>query().lambda()
.eq(TAuditNodeProocess::getDomainId, entity.getId())
.in(TAuditNodeProocess::getType, approvalRecord.getAuditType()));
}
//记录末尾节点审核
//sysMessageInfoService.saveApprovalRejectToSubmit(CrmConstants.OPPORTUNITY_MODUL_TYPE, approvalRecord);
return R.ok("审核成功");
}
@Override
public TProcessNode choiceGetNode(ProcessVo processVo, List<TNodeRoute> nodeRouteList, List<TNodeRouteCondition> nodeRouteConditionList,
TProcessNode currentNode, TInsuranceUnpurchaseApply entity, String type, YifuUser loginUser) {
// 根据不购买原因判断 1 已购买社保 2 人员已离职选择
if (StringUtils.equals(ProcessConstants.PROCESS_NODE_INSURANCEUNPURCHASE_REASON_TYPE,currentNode.getName())){
TNodeRoute nodeRoute = ProcessAuditUtil.getTNodeRoteByExpress(nodeRouteList, nodeRouteConditionList, entity.getReasonType(), null);
saveNodeProcess(processVo, nodeRoute.getNextNode(), entity.getId(), type);
return validateTwoNextNode(processVo, nodeRoute.getNextNode(), entity.getId(), nodeRoute.getRouteType(), type, entity, loginUser);
}else if (StringUtils.equals(ProcessConstants.PROCESS_NODE_INSURANCEUNPURCHASE_DEPT_PROPERTY,currentNode.getName())){
// 根据申请部门 是否属于子分公司
TNodeRoute nodeRoute = ProcessAuditUtil.getTNodeRoteByExpress(nodeRouteList, nodeRouteConditionList, entity.getCompanyFlag(), null);
saveNodeProcess(processVo, nodeRoute.getNextNode(), entity.getId(), type);
return validateTwoNextNode(processVo, nodeRoute.getNextNode(), entity.getId(), nodeRoute.getRouteType(), type, entity, loginUser);
} else{
throw new CheckedException("未知的条件节点类型,请联系管理员");
}
}
@Override
public R<String> sendMessage(List<SysUser> users, TInsuranceUnpurchaseApply entity, String type, TApprovalRecord approvalRecord) {
sendMessageToWx(users,entity,type, approvalRecord);
return R.ok(null, ResultConstants.SUCCESS_INFO);
}
/**
* 根据事业部条线获取审批用户
* @param nodePrimission
* @param entity
* @return List<SysUser>
**/
@Override
public List<SysUser> getDivisionAuditUser(TNodePrimission nodePrimission, TInsuranceUnpurchaseApply entity) {
SysUser remoteSysUser = null;
List<SysUser> remoteSysUserList = new ArrayList<>();
if (CommonConstants.SIX_INT == nodePrimission.getType().intValue()) {
// 6.指定事业部审批
if (Common.isEmpty(nodePrimission.getDivisionIdentification())) {
throw new CheckedException("未查询当前节点配置的事业部审批人标识");
}
// todo 根据配置条件查找用户
// remoteSysUserList = RemoteRequestUtil.getUserByDivisionConfig(remoteUserService, advancePaymentEntity.getDivision(), advancePaymentEntity.getDivisionLine(), nodePrimission.getDivisionIdentification());
}
return remoteSysUserList;
}
/**
* 功能描述: 企业微信发送通知
* @Param: [users, customerContract, type 发送提示类型 1审批 2抄送]
*/
private void sendMessageToWx(List<SysUser> users, TInsuranceUnpurchaseApply insuranceUnpurchaseApply, String type, TApprovalRecord approvalRecord) {
StringBuilder sendUser = null;
for (SysUser user : users) {
if (Common.isNotKong(user.getWxMessage())) {
if (sendUser == null) {
sendUser = new StringBuilder(user.getWxMessage());
} else {
sendUser = sendUser.append("|").append(user.getWxMessage());
}
}
}
if (sendUser != null) {
RestTemplate restTemplate = new RestTemplate();
Map<String, Object> requestMap = new HashMap<>();
Map<String, Object> textcard = new HashMap<>();
textcard.put("title", "含风险项目不购买商险申请");
// todo
textcard.put("page", "pages/sale/page/businessAuditDetail/businessAuditDetail?businessId="+insuranceUnpurchaseApply.getId());
// todo
textcard.put("appid", "111");
textcard.put("emphasis_first_item", false);
List<Map<String,String>> contentItemList = new ArrayList<>();
Map<String,String> contentItemMap = new HashMap<>();
contentItemMap.put("key", "申请人:");
contentItemMap.put("value", insuranceUnpurchaseApply.getCreateName().length()>CommonConstants.THIRTY_INT?insuranceUnpurchaseApply.getCreateName().substring(CommonConstants.ZERO_INT,CommonConstants.TWENTY_SEVEN_INT)+"...":insuranceUnpurchaseApply.getCreateName());
contentItemList.add(contentItemMap);
contentItemMap = new HashMap<>();
contentItemMap.put("key", "项目编码:");
contentItemMap.put("value", insuranceUnpurchaseApply.getDeptNo());
contentItemList.add(contentItemMap);
contentItemMap = new HashMap<>();
contentItemMap.put("key", "项目名称:");
contentItemMap.put("value", insuranceUnpurchaseApply.getDeptName().length()>CommonConstants.THIRTY_INT?insuranceUnpurchaseApply.getDeptName().substring(CommonConstants.ZERO_INT,CommonConstants.TWENTY_SEVEN_INT)+"...":insuranceUnpurchaseApply.getDeptName());
contentItemList.add(contentItemMap);
// 不购买原因 1 已购买社保 2 人员已离职
Map<String,String> reasonTypeMap = new HashMap<>();
reasonTypeMap.put("1", "已购买社保");
reasonTypeMap.put("2", "人员已离职");
contentItemMap = new HashMap<>();
contentItemMap.put("key", "不购买原因:");
contentItemMap.put("value", reasonTypeMap.get(insuranceUnpurchaseApply.getReasonType()));
contentItemList.add(contentItemMap);
contentItemMap = new HashMap<>();
contentItemMap.put("key", "不购买人数:");
// todo 等雨辰的字段
contentItemMap.put("value", insuranceUnpurchaseApply.getDeptNo());
contentItemList.add(contentItemMap);
textcard.put("content_item", contentItemList);
requestMap.put("touser", sendUser);
requestMap.put("msgtype", "miniprogram_notice");
requestMap.put("miniprogram_notice", textcard);
requestMap.put("enable_id_trans", 0);
requestMap.put("enable_duplicate_check", 0);
requestMap.put("duplicate_check_interval", 1800);
// todo 必须加上header说明 等房哥的企微
// if (!wxConfig.sendAppTextCard(restTemplate, requestMap)) {
// wxConfig.sendAppTextCard(restTemplate, requestMap);
// }
}
}
}
......@@ -34,4 +34,21 @@ ekp:
fdFlowId: '18267f206233f29cbd3c5ee425c9408a'
docStatus: '20'
LoginName: 'admin'
docSubject : '接口发起流程'
\ No newline at end of file
docSubject : '接口发起流程'
# spring security 配置
security:
oauth2:
resource:
loadBalanced: true
token-info-uri: http://yifu-auth/oauth/check_token
ignore: # 通用放行URL,服务个性化,请在对应配置文件覆盖
urls:
- /v3/api-docs
- /swagger-ui/**
- /tapprovalrecord/getAuditInfoByDomainIdAndAuditType
- /tinsuranceunpurchaseapply/getAuditPage
- /tinsuranceunpurchaseapply/getAuditCount
- /tinsuranceunpurchaseapply/commitOne
- /tinsuranceunpurchaseapply/audit
<?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.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances.TApprovalRecordMapper">
<resultMap id="tApprovalRecordMap" type="com.yifu.cloud.plus.v1.yifu.insurances.entity.TApprovalRecord">
<id property="id" column="id"/>
<result property="flowId" column="flow_id"/>
<result property="domainId" column="domain_id"/>
<result property="nodeId" column="node_id"/>
<result property="approvalMan" column="approval_man"/>
<result property="approvalManName" column="approval_man_name"/>
<result property="approvalTime" column="approval_time"/>
<result property="approvalResult" column="approval_result"/>
<result property="approvalOpinion" column="approval_opinion"/>
<result property="deleteFlag" column="delete_flag"/>
<result property="preFlag" column="pre_flag"/>
<result property="submitMan" column="submit_man"/>
<result property="submitManName" column="submit_man_name"/>
<result property="reason" column="reason"/>
<result property="auditType" column="audit_type"/>
<result property="createTime" column="create_time"/>
<result property="nodeName" column="node_name"/>
<result property="entityName" column="entity_name"/>
<result property="submitCreateTime" column="submit_create_time"/>
<result property="backFlag" column="back_flag"/>
<result property="backNodeName" column="back_node_name"/>
<result property="backNodeId" column="back_node_id"/>
<result property="addSignNodeId" column="add_sign_node_id"/>
</resultMap>
<sql id="Base_Column_List">
a.id,
a.flow_id,
a.domain_id,
a.node_id,
a.approval_man,
a.approval_man_name,
a.approval_time,
a.approval_result,
a.approval_opinion,
a.delete_flag,
a.pre_flag,
a.submit_man,
a.submit_man_name,
a.reason,
a.audit_type,
a.create_time,
a.node_name,
a.entity_name,
a.submit_create_time,
a.back_flag,
a.back_node_name,
a.back_node_id,
a.add_sign_node_id
</sql>
<sql id="tApprovalRecord_where">
<if test="tApprovalRecord != null">
<if test="tApprovalRecord.id != null and tApprovalRecord.id.trim() != ''">
AND a.id = #{tApprovalRecord.id}
</if>
<if test="tApprovalRecord.flowId != null and tApprovalRecord.flowId.trim() != ''">
AND a.flow_id = #{tApprovalRecord.flowId}
</if>
<if test="tApprovalRecord.domainId != null and tApprovalRecord.domainId.trim() != ''">
AND a.domain_id = #{tApprovalRecord.domainId}
</if>
<if test="tApprovalRecord.nodeId != null and tApprovalRecord.nodeId.trim() != ''">
AND a.node_id = #{tApprovalRecord.nodeId}
</if>
<if test="tApprovalRecord.approvalMan != null and tApprovalRecord.approvalMan.trim() != ''">
AND a.approval_man = #{tApprovalRecord.approvalMan}
</if>
<if test="tApprovalRecord.approvalManName != null and tApprovalRecord.approvalManName.trim() != ''">
AND a.approval_man_name = #{tApprovalRecord.approvalManName}
</if>
<if test="tApprovalRecord.approvalTime != null">
AND a.approval_time = #{tApprovalRecord.approvalTime}
</if>
<if test="tApprovalRecord.approvalResult != null and tApprovalRecord.approvalResult.trim() != ''">
AND a.approval_result = #{tApprovalRecord.approvalResult}
</if>
<if test="tApprovalRecord.approvalOpinion != null and tApprovalRecord.approvalOpinion.trim() != ''">
AND a.approval_opinion = #{tApprovalRecord.approvalOpinion}
</if>
<if test="tApprovalRecord.deleteFlag != null and tApprovalRecord.deleteFlag.trim() != ''">
AND a.delete_flag = #{tApprovalRecord.deleteFlag}
</if>
<if test="tApprovalRecord.preFlag != null and tApprovalRecord.preFlag.trim() != ''">
AND a.pre_flag = #{tApprovalRecord.preFlag}
</if>
<if test="tApprovalRecord.submitMan != null and tApprovalRecord.submitMan.trim() != ''">
AND a.submit_man = #{tApprovalRecord.submitMan}
</if>
<if test="tApprovalRecord.submitManName != null and tApprovalRecord.submitManName.trim() != ''">
AND a.submit_man_name = #{tApprovalRecord.submitManName}
</if>
<if test="tApprovalRecord.reason != null and tApprovalRecord.reason.trim() != ''">
AND a.reason = #{tApprovalRecord.reason}
</if>
<if test="tApprovalRecord.auditType != null and tApprovalRecord.auditType.trim() != ''">
AND a.audit_type = #{tApprovalRecord.auditType}
</if>
<if test="tApprovalRecord.createTime != null">
AND a.create_time = #{tApprovalRecord.createTime}
</if>
<if test="tApprovalRecord.nodeName != null and tApprovalRecord.nodeName.trim() != ''">
AND a.node_name = #{tApprovalRecord.nodeName}
</if>
<if test="tApprovalRecord.entityName != null and tApprovalRecord.entityName.trim() != ''">
AND a.entity_name = #{tApprovalRecord.entityName}
</if>
<if test="tApprovalRecord.submitCreateTime != null">
AND a.submit_create_time = #{tApprovalRecord.submitCreateTime}
</if>
<if test="tApprovalRecord.backFlag != null and tApprovalRecord.backFlag.trim() != ''">
AND a.back_flag = #{tApprovalRecord.backFlag}
</if>
<if test="tApprovalRecord.backNodeName != null and tApprovalRecord.backNodeName.trim() != ''">
AND a.back_node_name = #{tApprovalRecord.backNodeName}
</if>
<if test="tApprovalRecord.backNodeId != null and tApprovalRecord.backNodeId.trim() != ''">
AND a.back_node_id = #{tApprovalRecord.backNodeId}
</if>
<if test="tApprovalRecord.addSignNodeId != null and tApprovalRecord.addSignNodeId.trim() != ''">
AND a.add_sign_node_id = #{tApprovalRecord.addSignNodeId}
</if>
</if>
</sql>
<!--tApprovalRecord简单分页查询-->
<select id="getTApprovalRecordPage" resultMap="tApprovalRecordMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_approval_record a
<where>
1=1
<include refid="tApprovalRecord_where"/>
</where>
</select>
<!--查询审核记录数据-->
<select id="getApprovalRecordList" resultMap="tApprovalRecordMap">
SELECT
a.id,
a.flow_id,
a.domain_id,
a.node_id,
a.approval_man,
a.approval_man_name,
a.approval_time,
a.approval_result,
a.approval_opinion,
a.submit_man,
a.submit_man_name,
a.reason,
a.create_time,
a.node_name,
a.entity_name,
a.submit_create_time
FROM t_approval_record a
<where>
a.domain_id = #{domainId} AND a.audit_type = #{auditType}
AND a.delete_flag = '0'
order by a.create_time,a.id
</where>
</select>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances.TAuditCopyInfoMapper">
<resultMap id="tAuditCopyInfoMap" type="com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditCopyInfo">
<id property="id" column="id"/>
<result property="auditUserId" column="audit_user_id"/>
<result property="auditUser" column="audit_user"/>
<result property="domainId" column="domain_id"/>
<result property="createTime" column="create_time"/>
<result property="flowId" column="flow_id"/>
<result property="nodeId" column="node_id"/>
<result property="deleteFlag" column="delete_flag"/>
<result property="nodeName" column="node_name"/>
<result property="auditType" column="audit_type"/>
<result property="preFlag" column="pre_flag"/>
<result property="submitMan" column="submit_man"/>
<result property="submitManName" column="submit_man_name"/>
<result property="submitCreateTime" column="submit_create_time"/>
</resultMap>
<sql id="Base_Column_List">
a.id,
a.audit_user_id,
a.audit_user,
a.domain_id,
a.create_time,
a.flow_id,
a.node_id,
a.delete_flag,
a.node_name,
a.audit_type,
a.pre_flag,
a.submit_man,
a.submit_man_name,
a.submit_create_time
</sql>
<sql id="tAuditCopyInfo_where">
<if test="tAuditCopyInfo != null">
<if test="tAuditCopyInfo.id != null and tAuditCopyInfo.id.trim() != ''">
AND a.id = #{tAuditCopyInfo.id}
</if>
<if test="tAuditCopyInfo.auditUserId != null and tAuditCopyInfo.auditUserId.trim() != ''">
AND a.audit_user_id = #{tAuditCopyInfo.auditUserId}
</if>
<if test="tAuditCopyInfo.auditUser != null and tAuditCopyInfo.auditUser.trim() != ''">
AND a.audit_user = #{tAuditCopyInfo.auditUser}
</if>
<if test="tAuditCopyInfo.domainId != null and tAuditCopyInfo.domainId.trim() != ''">
AND a.domain_id = #{tAuditCopyInfo.domainId}
</if>
<if test="tAuditCopyInfo.createTime != null">
AND a.create_time = #{tAuditCopyInfo.createTime}
</if>
<if test="tAuditCopyInfo.flowId != null and tAuditCopyInfo.flowId.trim() != ''">
AND a.flow_id = #{tAuditCopyInfo.flowId}
</if>
<if test="tAuditCopyInfo.nodeId != null and tAuditCopyInfo.nodeId.trim() != ''">
AND a.node_id = #{tAuditCopyInfo.nodeId}
</if>
<if test="tAuditCopyInfo.deleteFlag != null and tAuditCopyInfo.deleteFlag.trim() != ''">
AND a.delete_flag = #{tAuditCopyInfo.deleteFlag}
</if>
<if test="tAuditCopyInfo.nodeName != null and tAuditCopyInfo.nodeName.trim() != ''">
AND a.node_name = #{tAuditCopyInfo.nodeName}
</if>
<if test="tAuditCopyInfo.auditType != null and tAuditCopyInfo.auditType.trim() != ''">
AND a.audit_type = #{tAuditCopyInfo.auditType}
</if>
<if test="tAuditCopyInfo.preFlag != null and tAuditCopyInfo.preFlag.trim() != ''">
AND a.pre_flag = #{tAuditCopyInfo.preFlag}
</if>
<if test="tAuditCopyInfo.submitMan != null and tAuditCopyInfo.submitMan.trim() != ''">
AND a.submit_man = #{tAuditCopyInfo.submitMan}
</if>
<if test="tAuditCopyInfo.submitManName != null and tAuditCopyInfo.submitManName.trim() != ''">
AND a.submit_man_name = #{tAuditCopyInfo.submitManName}
</if>
<if test="tAuditCopyInfo.submitCreateTime != null">
AND a.submit_create_time = #{tAuditCopyInfo.submitCreateTime}
</if>
</if>
</sql>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.insurances.mapper.insurances.TAuditNodeProocessMapper">
<resultMap id="tAuditNodeProocessMap" type="com.yifu.cloud.plus.v1.yifu.insurances.entity.TAuditNodeProocess">
<id property="id" column="id"/>
<result property="processId" column="process_id"/>
<result property="nodeId" column="node_id"/>
<result property="nodeType" column="node_type"/>
<result property="createTime" column="create_time"/>
<result property="domainId" column="domain_id"/>
<result property="mainType" column="main_type"/>
<result property="logoTitle" column="logo_title"/>
<result property="nodeName" column="node_name"/>
<result property="processName" column="process_name"/>
<result property="parentProcessId" column="parent_process_id"/>
<result property="deleteFlag" column="delete_flag"/>
<result property="type" column="type"/>
<result property="addSignParentNodeId" column="add_sign_parent_node_id"/>
<result property="addSignDepartmentId" column="add_sign_department_id"/>
<result property="domainName" column="domain_name"/>
<result property="addSignApprovalMan" column="add_sign_approval_man"/>
<result property="addSignApprovalManName" column="add_sign_approval_man_name"/>
</resultMap>
<sql id="Base_Column_List">
a.id,
a.process_id,
a.node_id,
a.node_type,
a.create_time,
a.domain_id,
a.main_type,
a.logo_title,
a.node_name,
a.process_name,
a.parent_process_id,
a.delete_flag,
a.type,
a.add_sign_parent_node_id,
a.add_sign_department_id,
a.domain_name,
a.add_sign_approval_man,
a.add_sign_approval_man_name
</sql>
<sql id="tAuditNodeProocess_where">
<if test="tAuditNodeProocess != null">
<if test="tAuditNodeProocess.id != null and tAuditNodeProocess.id.trim() != ''">
AND a.id = #{tAuditNodeProocess.id}
</if>
<if test="tAuditNodeProocess.processId != null and tAuditNodeProocess.processId.trim() != ''">
AND a.process_id = #{tAuditNodeProocess.processId}
</if>
<if test="tAuditNodeProocess.nodeId != null and tAuditNodeProocess.nodeId.trim() != ''">
AND a.node_id = #{tAuditNodeProocess.nodeId}
</if>
<if test="tAuditNodeProocess.nodeType != null and tAuditNodeProocess.nodeType.trim() != ''">
AND a.node_type = #{tAuditNodeProocess.nodeType}
</if>
<if test="tAuditNodeProocess.createTime != null">
AND a.create_time = #{tAuditNodeProocess.createTime}
</if>
<if test="tAuditNodeProocess.domainId != null and tAuditNodeProocess.domainId.trim() != ''">
AND a.domain_id = #{tAuditNodeProocess.domainId}
</if>
<if test="tAuditNodeProocess.mainType != null and tAuditNodeProocess.mainType.trim() != ''">
AND a.main_type = #{tAuditNodeProocess.mainType}
</if>
<if test="tAuditNodeProocess.logoTitle != null and tAuditNodeProocess.logoTitle.trim() != ''">
AND a.logo_title = #{tAuditNodeProocess.logoTitle}
</if>
<if test="tAuditNodeProocess.nodeName != null and tAuditNodeProocess.nodeName.trim() != ''">
AND a.node_name = #{tAuditNodeProocess.nodeName}
</if>
<if test="tAuditNodeProocess.processName != null and tAuditNodeProocess.processName.trim() != ''">
AND a.process_name = #{tAuditNodeProocess.processName}
</if>
<if test="tAuditNodeProocess.parentProcessId != null and tAuditNodeProocess.parentProcessId.trim() != ''">
AND a.parent_process_id = #{tAuditNodeProocess.parentProcessId}
</if>
<if test="tAuditNodeProocess.deleteFlag != null and tAuditNodeProocess.deleteFlag.trim() != ''">
AND a.delete_flag = #{tAuditNodeProocess.deleteFlag}
</if>
<if test="tAuditNodeProocess.type != null and tAuditNodeProocess.type.trim() != ''">
AND a.type = #{tAuditNodeProocess.type}
</if>
<if test="tAuditNodeProocess.addSignParentNodeId != null and tAuditNodeProocess.addSignParentNodeId.trim() != ''">
AND a.add_sign_parent_node_id = #{tAuditNodeProocess.addSignParentNodeId}
</if>
<if test="tAuditNodeProocess.addSignDepartmentId != null and tAuditNodeProocess.addSignDepartmentId.trim() != ''">
AND a.add_sign_department_id = #{tAuditNodeProocess.addSignDepartmentId}
</if>
<if test="tAuditNodeProocess.domainName != null and tAuditNodeProocess.domainName.trim() != ''">
AND a.domain_name = #{tAuditNodeProocess.domainName}
</if>
<if test="tAuditNodeProocess.addSignApprovalMan != null and tAuditNodeProocess.addSignApprovalMan.trim() != ''">
AND a.add_sign_approval_man = #{tAuditNodeProocess.addSignApprovalMan}
</if>
<if test="tAuditNodeProocess.addSignApprovalManName != null and tAuditNodeProocess.addSignApprovalManName.trim() != ''">
AND a.add_sign_approval_man_name = #{tAuditNodeProocess.addSignApprovalManName}
</if>
</if>
</sql>
</mapper>
......@@ -30,6 +30,20 @@
<result property="auditUser" column="AUDIT_USER"/>
<result property="auditUserId" column="AUDIT_USER_ID"/>
</resultMap>
<resultMap id="tInsuranceUnpurchaseApplyExportMap"
type="com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchaseApplyVo">
<result property="deptNo" column="DEPT_NO"/>
<result property="deptName" column="DEPT_NAME"/>
<result property="createUserDeptName" column="CREATE_USER_DEPT_NAME"/>
<result property="reasonType" column="REASON_TYPE"/>
<result property="applyNo" column="APPLY_NO"/>
<result property="createName" column="CREATE_NAME"/>
<result property="createTime" column="CREATE_TIME"/>
<result property="status" column="STATUS"/>
<result property="auditUser" column="AUDIT_USER"/>
</resultMap>
<sql id="Base_Column_List">
a.ID, a.DEPT_ID, a.DEPT_NO, a.DEPT_NAME, a.CREATE_USER_DEPT_ID,
a.CREATE_USER_DEPT_NAME, a.REASON_TYPE, a.REASON_INFO, a.APPLY_NO,
......@@ -101,7 +115,7 @@
</select>
<!-- tInsuranceUnpurchaseApply简单分页查询 -->
<select id="getTInsuranceUnpurchaseApplyExportList" resultMap="tInsuranceUnpurchaseApplyMap">
<select id="getTInsuranceUnpurchaseApplyExportList" resultMap="tInsuranceUnpurchaseApplyExportMap">
SELECT
a.APPLY_NO,
a.DEPT_NAME,
......@@ -109,8 +123,8 @@
a.CREATE_NAME,
a.CREATE_USER_DEPT_NAME,
a.CREATE_TIME,
a.AUDIT_USER,
if(a.REASON_TYPE = '1','已购买社保','人员已离职') REASON_TYPE,
a.REASON_INFO,
CASE WHEN a.STATUS=0 THEN "草稿"
WHEN a.STATUS =1 THEN "待提交"
WHEN a.STATUS =2 THEN "待审核"
......@@ -119,8 +133,89 @@
ELSE a.STATUS END as "STATUS"
FROM t_insurance_unpurchase_apply a
<where>
1=1 and a.DELETE_FLAG = '0'
a.DELETE_FLAG = '0'
<include refid="tInsuranceUnpurchaseApply_where"/>
</where>
</select>
</mapper>
\ No newline at end of file
<select id="getAuditPage" resultMap="tInsuranceUnpurchaseApplyMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_insurance_unpurchase_apply a
left join t_approval_record r on a.id=r.domain_id
<where>
a.DELETE_FLAG='0' and r.approval_man= #{userId} and r.audit_type='0' and r.approval_result = '2' and r.delete_flag='0'
<include refid="tInsuranceUnpurchaseApply_where"/>
</where>
order by r.CREATE_TIME asc
</select>
<select id="getHistoryHandlePage" resultMap="tInsuranceUnpurchaseApplyMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_insurance_unpurchase_apply a
left join (
select min(approval_time) approval_time,domain_id,approval_man from t_approval_record
where approval_result in('0','1') and audit_type = '0' and delete_flag='0'
group by domain_id,approval_man
) r on a.id=r.domain_id
<where>
a.DELETE_FLAG='0' and r.approval_man= #{userId}
<include refid="tInsuranceUnpurchaseApply_where"/>
</where>
order by r.approval_time desc
</select>
<select id="getAuditCount" resultType="integer">
SELECT count(1) FROM t_insurance_unpurchase_apply a
left join t_approval_record r on a.id=r.domain_id
<where>
a.DELETE_FLAG='0' and r.approval_man= #{userId} and r.audit_type='0' and r.approval_result = '2' and r.delete_flag='0'
</where>
</select>
<select id="getHistoryHandleCount" resultType="integer">
SELECT count(1) FROM t_insurance_unpurchase_apply a
left join (
select min(approval_time) approval_time,domain_id,approval_man from t_approval_record
where approval_result in('0','1') and audit_type = '0' and delete_flag='0'
group by domain_id,approval_man
) r on a.id=r.domain_id
<where>
a.DELETE_FLAG='0' and r.approval_man= #{userId}
</where>
</select>
<select id="getCopyPage" resultMap="tInsuranceUnpurchaseApplyMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_insurance_unpurchase_apply a
left join (
select min(create_time) create_time,domain_id,audit_user_id from t_audit_copy_info
where audit_type = '0' and delete_flag = '0'
group by domain_id,audit_user_id
) r on a.id=r.domain_id
<where>
a.DELETE_FLAG='0' and r.audit_user_id= #{userId}
<include refid="tInsuranceUnpurchaseApply_where"/>
</where>
order by r.create_time desc
</select>
<!-- 获取当日最大的编码 -->
<select id="getMaxInusuranceCode" resultType="java.lang.String">
SELECT ifnull(max(right (e.APPLY_NO, 3)), 0) EMP_CODE
FROM t_insurance_unpurchase_apply e
where e.DELETE_FLAG = '0'
and e.CREATE_TIME > DATE_FORMAT(now(), '%Y-%m-%d')
</select>
<!-- 获取当日最大的编码 -->
<select id="getMaxInusuranceDetailCode" resultType="java.lang.String">
SELECT ifnull(max(right (e.APPLY_NO_DETAIL, 5)), 0) EMP_CODE
FROM t_insurance_unpurchase_person e
where e.CREATE_TIME > DATE_FORMAT(now(), '%Y-%m-%d')
</select>
</mapper>
......@@ -31,6 +31,23 @@
<result property="division" column="DIVISION"/>
<result property="insuranceFlag" column="INSURANCE_FLAG"/>
</resultMap>
<resultMap id="tInsuranceUnpurchasePersonExportMap" type="com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonVo">
<result property="empName" column="EMP_NAME"/>
<result property="empIdcardNo" column="EMP_IDCARD_NO"/>
<result property="applyNoDetail" column="APPLY_NO_DETAIL"/>
<result property="deptNo" column="DEPT_NO"/>
<result property="deptName" column="DEPT_NAME"/>
<result property="reasonType" column="REASON_TYPE"/>
<result property="applyNo" column="APPLY_NO"/>
<result property="socialStatus" column="SOCIAL_STATUS"/>
<result property="salaryNum" column="SALARY_NUM"/>
<result property="createName" column="CREATE_NAME"/>
<result property="createTime" column="CREATE_TIME"/>
<result property="newLine" column="NEW_LINE"/>
<result property="division" column="DIVISION"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.PARNET_ID,
......@@ -116,8 +133,42 @@
<include refid="Base_Column_List"/>
FROM t_insurance_unpurchase_person a
<where>
1=1
1=1 and STATUS = '3'
<include refid="tInsuranceUnpurchasePerson_where"/>
</where>
</select>
<!--tInsuranceUnpurchasePerson导出条数查询-->
<select id="getTInsuranceUnpurchaseInfoExportCount" resultType="java.lang.Long">
SELECT
count(1)
FROM t_insurance_unpurchase_person a
<where>
1=1 and STATUS = '3'
<include refid="tInsuranceUnpurchasePerson_where"/>
</where>
</select>
<!--tInsuranceUnpurchasePerson导出查询-->
<select id="getTInsuranceUnpurchaseInfoExportList" resultMap="tInsuranceUnpurchasePersonExportMap">
SELECT
APPLY_NO_DETAIL,
APPLY_NO,
DEPT_NAME,
DEPT_NO,
DIVISION,
NEW_LINE,
EMP_NAME,
EMP_IDCARD_NO,
if(a.REASON_TYPE = '1','已购买社保','人员已离职') REASON_TYPE,
if(a.SOCIAL_STATUS='0','是','否') SOCIAL_STATUS,
SALARY_NUM,
CREATE_NAME,
CREATE_TIME
FROM t_insurance_unpurchase_person a
<where>
1=1 and STATUS = '3'
<include refid="tInsuranceUnpurchasePerson_where"/>
</where>
</select>
</mapper>
# 忽略匹配下列规则的Git 提交 V2.1.0
### gradle ###
.gradle
/build/
!gradle/wrapper/gradle-wrapper.jar
### STS ###
.settings/
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
bin/
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
*.lock
rebel.xml
### NetBeans ###
nbproject/private/
build/
nbbuild/
nbdist/
.nb-gradle/
### maven ###
target/
*.war
*.ear
*.zip
*.tar
*.tar.gz
### logs ####
/logs/
*.log
### temp ignore ###
*.cache
*.diff
*.patch
*.tmp
*.java~
*.properties~
*.xml~
### system ignore ###
.DS_Store
Thumbs.db
Servers
.metadata
upload
gen_code
### node ###
node_modules
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<artifactId>yifu</artifactId>
<groupId>com.yifu.cloud.plus.v1</groupId>
<version>1.0.0</version>
</parent>
<artifactId>yifu-process</artifactId>
<description>审批流程</description>
<packaging>pom</packaging>
<!--项目子模块-->
<modules>
<module>yifu-process-api</module>
<module>yifu-process-biz</module>
</modules>
</project>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<artifactId>yifu</artifactId>
<groupId>com.yifu.cloud.plus.v1</groupId>
<version>1.0.0</version>
</parent>
<artifactId>yifu-process-api</artifactId>
<packaging>jar</packaging>
<description>审批流程服务 接口模块</description>
<dependencies>
<!-- core 工具类 -->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-core</artifactId>
</dependency>
<!--swagger 注解-->
<dependency>
<groupId>io.swagger.core.v3</groupId>
<artifactId>swagger-annotations</artifactId>
</dependency>
<!--mybatis 依赖-->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-mybatis</artifactId>
</dependency>
</dependencies>
</project>
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.time.LocalDateTime;
/**
* 定时流程节点配置
*
* @author hgw
* @date 2020-07-16 17:48:52
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_delay_node_config")
@Schema(description = "定时流程节点配置")
public class TDelayNodeConfig extends Model<TDelayNodeConfig> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "定时方式(0延时指定的分钟后执行/1指定一个时间点执行)不能为空")
@Length(max = 1, message = "定时方式(0延时指定的分钟后执行/1指定一个时间点执行)不能超过1个字符")
@Schema(description = "定时方式(0延时指定的分钟后执行/1指定一个时间点执行)")
private String delayType;
@Schema(description = "分钟")
private Integer minutes;
@Schema(description = "时间")
private LocalDateTime time;
@NotBlank(message = "流程节点ID不能为空")
@Length(max = 255, message = "流程节点ID不能超过255个字符")
@Schema(description = "流程节点ID")
private String nodeId;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
/**
* 流程节点配置表(规则配置)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_node_config")
@Schema(description = "流程节点配置表(规则配置)")
public class TNodeConfig extends Model<TNodeConfig> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "是否允许撤回(0是/1否)不能为空")
@Length(max = 1, message = "是否允许撤回(0是/1否)不能超过1个字符")
@Schema(description = "是否允许撤回(0是/1否)")
private String allowWithdraw;
@NotBlank(message = "是否允许流程回溯(0是/1否)不能为空")
@Length(max = 1, message = "是否允许流程回溯(0是/1否)不能超过1个字符")
@Schema(description = "是否允许流程回溯(0是/1否)")
private String allowBacktrack;
@NotBlank(message = "是否发起处理提醒(0是/1否;提醒会在站内和移动端提醒)不能为空")
@Length(max = 1, message = "是否发起处理提醒(0是/1否;提醒会在站内和移动端提醒)不能超过1个字符")
@Schema(description = "是否发起处理提醒(0是/1否;提醒会在站内和移动端提醒)")
private String allowDealRemind;
@NotBlank(message = "节点ID不能为空")
@Length(max = 255, message = "节点ID不能超过255个字符")
@Schema(description = "节点ID")
private String nodeId;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
/**
* 节点超时配置表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_node_timeout_config")
@Schema(description = "节点超时配置表")
public class TNodeTimeoutConfig extends Model<TNodeTimeoutConfig> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "流程是否超时(0不超时/1指定时长/2脚本)不能为空")
@Length(max = 1, message = "流程是否超时(0不超时/1指定时长/2脚本)不能超过1个字符")
@Schema(description = "流程是否超时(0不超时/1指定时长/2脚本)")
private String timeOut;
@Schema(description = "天数(TIME_OUT为2时启用)")
private Integer day;
@Schema(description = "小时(TIME_OUT为2时启用)")
private Integer hour;
@Length(max = 1, message = "是否仅计算工作时间(TIME_OUT为2时启用,0是/1否)不能超过1个字符")
@Schema(description = "是否仅计算工作时间(TIME_OUT为2时启用,0是/1否)")
private String workHourFlag;
@NotBlank(message = "节点ID不能为空")
@Length(max = 255, message = "节点ID不能超过255个字符")
@Schema(description = "节点ID")
private String nodeId;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
import java.time.LocalDateTime;
/**
* 主流程表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_process")
@Schema(description = "主流程表")
public class TProcess extends Model<TProcess> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "流程名称不能为空")
@Length(max = 255, message = "流程名称不能超过255个字符")
@Schema(description = "流程名称")
private String name;
@Length(max = 255, message = "流程标识(系统自动生成MD5串)不能超过255个字符")
@Schema(description = "流程标识(系统自动生成MD5串)")
private String logoTitle;
@NotBlank(message = "流程创建人不能为空")
@Length(max = 255, message = "流程创建人不能超过255个字符")
@Schema(description = "流程创建人")
private String createUser;
@Schema(description = "流程创建时间")
private LocalDateTime createDate;
@Length(max = 255, message = "流程更新人不能超过255个字符")
@Schema(description = "流程更新人")
private String updateUser;
@Schema(description = "流程更新时间")
private LocalDateTime updateDate;
@Length(max = 255, message = "流程描述不能超过255个字符")
@Schema(description = "流程描述")
private String description;
@Length(max = 1, message = "删除表示 0未删除 1删除不能超过1个字符")
@Schema(description = "删除表示 0未删除 1删除")
private String deleteFlag;
@Length(max = 1, message = "是否通用不能超过1个字符")
@Schema(description = "是否通用0是1否")
private String commonUse;
@Length(max = 1, message = "是否在用不能超过1个字符")
@Schema(description = "是否在用 0在用 1历史")
private String processIsUse;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
/**
* 审批配置表
*
* @author wangan
* @date 2020-12-07 14:08:38
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_process_approval_conf")
@Schema(description = "审批配置表")
public class TProcessApprovalConf extends Model<TProcessApprovalConf> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "字段名称不能为空")
@Length(max = 32, message = "字段名称不能超过32个字符")
@Schema(description = "字段名称")
private String fieldName;
@NotBlank(message = "字段值不能为空")
@Length(max = 32, message = "字段值不能超过32个字符")
@Schema(description = "字段值")
private String fieldValue;
@NotBlank(message = "类名不能为空")
@Length(max = 32, message = "类名不能超过32个字符")
@Schema(description = "类名")
private String className;
@Length(max = 32, message = "主流程id不能超过32个字符")
@Schema(description = "主流程id")
private String processId;
@NotBlank(message = "父配置id不能为空")
@Length(max = 32, message = "父配置id不能超过32个字符")
@Schema(description = "父配置id")
private String parentId;
@NotBlank(message = "类型不能为空")
@Length(max = 1, message = "类型不能超过1个字符")
@Schema(description = "类型 1不购买商险申请")
private String type;
@Length(max = 1, message = "删除表示 0未删除 1删除不能超过1个字符")
@Schema(description = "删除表示 0未删除 1删除")
private String deleteFlag;
@Length(max = 100, message = "备注不能超过100个字符")
@Schema(description = "备注")
private String remark;
}
package com.yifu.cloud.plus.v1.yifu.process.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.NotBlank;
/**
* 远程服务调用(在节点为服务调用节点时使用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("t_service_transfer_config")
@Schema(description = "远程服务调用(在节点为服务调用节点时使用)")
public class TServiceTransferConfig extends Model<TServiceTransferConfig> {
private static final long serialVersionUID = 1L;
@TableId(type = IdType.ASSIGN_ID)
@Schema(description = "主键")
private String id;
@NotBlank(message = "服务协议(0jaxws/1jaxrs)不能为空")
@Length(max = 1, message = "服务协议(0jaxws/1jaxrs)不能超过1个字符")
@Schema(description = "服务协议(0jaxws/1jaxrs)")
private String serviceAgreement;
@NotBlank(message = "调用方式(0同步/1异步)不能为空")
@Length(max = 1, message = "调用方式(0同步/1异步)不能超过1个字符")
@Schema(description = "调用方式(0同步/1异步)")
private String transferType;
@NotBlank(message = "WSDL地址不能为空")
@Length(max = 255, message = "WSDL地址不能超过255个字符")
@Schema(description = "WSDL地址")
private String wsdlAddress;
@Length(max = 255, message = "调用方法不能超过255个字符")
@Schema(description = "调用方法")
private String transferFunc;
@NotBlank(message = "节点ID不能为空")
@Length(max = 255, message = "节点ID不能超过255个字符")
@Schema(description = "节点ID")
private String nodeId;
}
package com.yifu.cloud.plus.v1.yifu.process.vo;
import lombok.Data;
import java.io.Serializable;
/**
* @program: yifu_cloud
* @description:
* @author: wangdayu
* @create: 2023-10-25 17:10
* @since:
*/
@Data
public class CheckNodeVo implements Serializable {
private String PrewNode;
private String NextNode;
private String ProcessId;
private String NodeRouteId;
private String Field;
private String LogoTitle;
}
package com.yifu.cloud.plus.v1.yifu.process.vo;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcess;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Set;
/**
* 主流程表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class TProcessViewVo extends TProcess {
private static final long serialVersionUID = 1L;
@Schema(description = "类型 1不购买商险申请")
private String type;
@Schema(description = "部门ids")
private Set<String> departIds;
@Schema(description = "用章类型")
private Set<String> chapterUnits;
@Schema(description = "删除部门ids")
private Set<String> delDepartIds;
@Schema(description = "删除用章类型")
private Set<String> delChapterUnits;
@Schema(description = "类型(条件查询用)")
private String processType;
@Schema(description = "部门(条件查询用)")
private String departId;
@Schema(description = "流程ids")
private Set<String> processIds;
@Schema(description = "指定权限类型")
private Integer nodePermissionType;
@Schema(description = "指定权限处理节点")
private String role;
}
FROM moxm/java:1.8-full
RUN mkdir -p /yifu-process-biz
WORKDIR yifu-process-biz
ARG JAR_FILE=target/yifu-process-biz.jar
COPY ${JAR_FILE} app.jar
EXPOSE 25087
ENV TZ=Asia/Shanghai JAVA_OPTS="-Xms128m -Xmx256m -Djava.security.egd=file:/dev/./urandom"
CMD sleep 60; java -jar app.jar $JAVA_OPTS
#!/usr/bin/env bash
mvn clean package -Pprd -Dmaven.test.skip=true docker:build -DpushImage
\ No newline at end of file
#!/usr/bin/env bash
mvn clean package -Ptest -Dmaven.test.skip=true docker:build -DpushImage
#!/usr/bin/env bash
mvn clean package -Dmaven.test.skip=true docker:build -DpushImage
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<artifactId>yifu</artifactId>
<groupId>com.yifu.cloud.plus.v1</groupId>
<version>1.0.0</version>
</parent>
<artifactId>yifu-process-biz</artifactId>
<description>审批流程服务 业务模块</description>
<packaging>jar</packaging>
<dependencies>
<!-- seata 依赖 -->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-seata</artifactId>
</dependency>
<!--必备:undertow容器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-undertow</artifactId>
</dependency>
<!--upms api、model 模块-->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-upms-api</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-process-api</artifactId>
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-process</artifactId>
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-core</artifactId>
</dependency>
<!--必备:日志处理-->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-log</artifactId>
</dependency>
<!--mybatis-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<!--数据库-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--必备:安全模块-->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-security</artifactId>
</dependency>
<!--必备:swagger-->
<dependency>
<groupId>com.yifu.cloud.plus.v1</groupId>
<artifactId>yifu-common-swagger</artifactId>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.2</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<version>5.8.0</version>
<artifactId>hutool-all</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<configuration>
<encoding>UTF-8</encoding>
<nonFilteredFileExtensions>
<nonFilteredFileExtension>xls</nonFilteredFileExtension>
<nonFilteredFileExtension>xlsx</nonFilteredFileExtension>
</nonFilteredFileExtensions>
</configuration>
</plugin>
<plugin>
<groupId>com.spotify</groupId>
<artifactId>docker-maven-plugin</artifactId>
<version>1.1.0</version>
<configuration>
<serverId>docker-hub</serverId>
<!--指定生成的镜像名-->
<imageName>${my.hub.host}/${map.group.name}/${project.artifactId}:${project.version}</imageName>
<dockerDirectory>${project.basedir}/</dockerDirectory>
<!--指定远程 docker api地址-->
<!--<dockerHost>http://172.16.66.232:2375</dockerHost>-->
<!-- 这里是复制 jar 包到 docker 容器指定目录配置-->
<resources>
<resource>
<targetPath>/</targetPath>
<!--jar 包所在的路径 此处配置的 即对应 target 目录-->
<directory>${project.build.directory}</directory>
<!-- 需要包含的 jar包 ,这里对应的是 Dockerfile中添加的文件名 -->
<include>${project.build.finalName}.jar</include>
</resource>
</resources>
<forceTags>true</forceTags>
</configuration>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
<excludes>
<exclude>**/*.xlsx</exclude>
<exclude>**/*.xls</exclude>
</excludes>
</resource>
<resource>
<directory>src/main/resources</directory>
<filtering>false</filtering>
<includes>
<include>**/*.xlsx</include>
<include>**/*.xls</include>
</includes>
</resource>
</resources>
</build>
</project>
package com.yifu.cloud.plus.v1.yifu.process;
import com.yifu.cloud.plus.v1.yifu.common.security.annotation.EnableYifuResourceServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
/**
* @author pig archetype
* <p>
* 项目启动类
*/
@EnableYifuResourceServer
@SpringBootApplication
public class YifuProcessApplication {
public static void main(String[] args) {
SpringApplication.run(YifuProcessApplication.class, args);
}
}
package com.yifu.cloud.plus.v1.yifu.process.config;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import com.yifu.cloud.plus.v1.yifu.common.mybatis.config.MybatisPlusMetaObjectHandler;
import com.yifu.cloud.plus.v1.yifu.common.mybatis.plugins.YifuPaginationInnerInterceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
import javax.sql.DataSource;
/**
* @author chenyuxi
* @date 2025-01-10
* @since 1.7.5
*/
@Configuration
@MapperScan(basePackages = "com.yifu.cloud.plus.v1.yifu.process.mapper", sqlSessionTemplateRef = "processSqlSessionTemplate", sqlSessionFactoryRef = "processSqlSessionFactory")
public class ProcessDataSourceConfig {
@Bean(name = "processDataSource")
@ConfigurationProperties(prefix = "spring.datasource.process")
@Primary
public DataSource processDataSource() {
return DataSourceBuilder.create().build();
}
@Bean
public SqlSessionFactory processSqlSessionFactory(@Qualifier("processDataSource") DataSource dataSource) throws Exception {
MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
bean.setDataSource(dataSource);
//多数据源 myMetaObjectHandler不起作用问题解决
GlobalConfig globalConfig = new GlobalConfig();
globalConfig.setMetaObjectHandler(new MybatisPlusMetaObjectHandler());
globalConfig.setDbConfig(new GlobalConfig.DbConfig());
globalConfig.setBanner(false);
bean.setGlobalConfig(globalConfig);
//添加XML目录
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
try {
bean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
//分页插件配置,不配置分页插件无效,否则会出现total为0的情况
bean.setPlugins(processPlusInterceptor());
SqlSessionFactory sqlSessionFactory = bean.getObject();
sqlSessionFactory.getConfiguration().setMapUnderscoreToCamelCase(true);
return sqlSessionFactory;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
@Bean(name = "processTransactionManager")
@Primary
public DataSourceTransactionManager processTransactionManager(@Qualifier("processDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
@Bean
public SqlSessionTemplate processSqlSessionTemplate(@Qualifier("processSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
return new SqlSessionTemplate(sqlSessionFactory);
}
@Bean
public TransactionTemplate processTransactionTemplate(@Qualifier("processTransactionManager") DataSourceTransactionManager dataSourceTransactionManager) {
return new TransactionTemplate(dataSourceTransactionManager);
}
@Bean
public MybatisPlusInterceptor processPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new YifuPaginationInnerInterceptor());
return interceptor;
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TDelayNodeConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TDelayNodeConfigService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
/**
* 定时流程节点配置
*
* @author hgw
* @date 2020-07-16 17:48:52
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tdelaynodeconfig")
@Tag(name = "定时流程节点配置")
public class TDelayNodeConfigController {
@Resource
private TDelayNodeConfigService tDelayNodeConfigService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tDelayNodeConfig 定时流程节点配置
* @return
*/
@Operation(summary = "简单分页查询", description = "简单分页查询")
@GetMapping("/page")
public R<IPage<TDelayNodeConfig>> getTDelayNodeConfigPage(Page<TDelayNodeConfig> page, TDelayNodeConfig tDelayNodeConfig) {
return R.ok(tDelayNodeConfigService.getTDelayNodeConfigPage(page, tDelayNodeConfig));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TDelayNodeConfig> getById(@PathVariable("id") String id) {
return R.ok(tDelayNodeConfigService.getById(id));
}
/**
* 新增记录
*
* @param tDelayNodeConfig
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TDelayNodeConfig tDelayNodeConfig) {
return R.ok(tDelayNodeConfigService.save(tDelayNodeConfig));
}
/**
* 修改记录
*
* @param tDelayNodeConfig
* @return R
*/
@Operation(summary = "新增")
@SysLog("修改定时流程节点配置")
@PutMapping
public R<Boolean> update(@RequestBody TDelayNodeConfig tDelayNodeConfig) {
return R.ok(tDelayNodeConfigService.updateById(tDelayNodeConfig));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除定时流程节点配置")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tDelayNodeConfigService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeConfigService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
/**
* 流程节点配置表(规则配置)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tnodeconfig")
@Tag(name = "流程节点配置表(规则配置)")
public class TNodeConfigController {
@Resource
private TNodeConfigService tNodeConfigService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tNodeConfig 流程节点配置表(规则配置)
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TNodeConfig>> getTNodeConfigPage(Page<TNodeConfig> page, TNodeConfig tNodeConfig) {
return new R<>(tNodeConfigService.getTNodeConfigPage(page, tNodeConfig));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TNodeConfig> getById(@PathVariable("id") String id) {
return new R<>(tNodeConfigService.getById(id));
}
/**
* 新增记录
*
* @param tNodeConfig
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TNodeConfig tNodeConfig) {
return new R<>(tNodeConfigService.save(tNodeConfig));
}
/**
* 修改记录
*
* @param tNodeConfig
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改流程节点配置表(规则配置)")
@PutMapping
public R<Boolean> update(@RequestBody TNodeConfig tNodeConfig) {
return new R<>(tNodeConfigService.updateById(tNodeConfig));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除流程节点配置表(规则配置)")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tNodeConfigService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodePrimission;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodePrimissionService;
import com.yifu.cloud.plus.v1.yifu.common.security.annotation.Inner;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.List;
import java.util.Set;
/**
* 流程处理权限表(允许多个,多个代表有主办和经办)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tnodeprimission")
@Tag(name = "流程处理权限表(允许多个,多个代表有主办和经办)")
public class TNodePrimissionController {
@Resource
private TNodePrimissionService tNodePrimissionService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tNodePrimission 流程处理权限表(允许多个,多个代表有主办和经办)
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TNodePrimission>> getTNodePrimissionPage(Page<TNodePrimission> page, TNodePrimission tNodePrimission) {
return new R<>(tNodePrimissionService.getTNodePrimissionPage(page, tNodePrimission));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TNodePrimission> getById(@PathVariable("id") String id) {
return new R<>(tNodePrimissionService.getById(id));
}
/**
* 新增记录
*
* @param tNodePrimission
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TNodePrimission tNodePrimission) {
return new R<>(tNodePrimissionService.save(tNodePrimission));
}
/**
* 修改记录
*
* @param tNodePrimission
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改流程处理权限表(允许多个,多个代表有主办和经办)")
@PutMapping
public R<Boolean> update(@RequestBody TNodePrimission tNodePrimission) {
return new R<>(tNodePrimissionService.updateById(tNodePrimission));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除流程处理权限表(允许多个,多个代表有主办和经办)")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tNodePrimissionService.removeById(id));
}
/**
* todo 功能描述: 通过流程ID查询对应的办理人和归档人
* @Param: [processId]
* @Return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<java.util.List<TNodePrimission>>
* @Author: zhouyang
* @Date: 2021/12/2 16:23
*/
@Inner
@GetMapping("/inner/getTNodePrimission/byProcessId")
public R<List<TNodePrimission>> getTNodePrimissionByProcessId(@RequestParam("processId") Set<String> processId){
List<TNodePrimission> list = tNodePrimissionService.list(Wrappers.<TNodePrimission>query().lambda().in(TNodePrimission::getProcessId, processId));
return new R<>(list);
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeReaderPromission;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeReaderPromissionService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
/**
* 流程审阅权限表(抄送/仅有查看权限)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tnodereaderpromission")
@Tag(name = "流程审阅权限表(抄送/仅有查看权限)")
public class TNodeReaderPromissionController {
@Resource
private TNodeReaderPromissionService tNodeReaderPromissionService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tNodeReaderPromission 流程审阅权限表(抄送/仅有查看权限)
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TNodeReaderPromission>> getTNodeReaderPromissionPage(Page<TNodeReaderPromission> page, TNodeReaderPromission tNodeReaderPromission) {
return new R<>(tNodeReaderPromissionService.getTNodeReaderPromissionPage(page, tNodeReaderPromission));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TNodeReaderPromission> getById(@PathVariable("id") String id) {
return new R<>(tNodeReaderPromissionService.getById(id));
}
/**
* 新增记录
*
* @param tNodeReaderPromission
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TNodeReaderPromission tNodeReaderPromission) {
return new R<>(tNodeReaderPromissionService.save(tNodeReaderPromission));
}
/**
* 修改记录
*
* @param tNodeReaderPromission
* @return R
*/
@Operation(summary = "修改(yifu-module:tnodereaderpromission_edit)")
@SysLog("修改流程审阅权限表(抄送/仅有查看权限)")
@PutMapping
public R<Boolean> update(@RequestBody TNodeReaderPromission tNodeReaderPromission) {
return new R<>(tNodeReaderPromissionService.updateById(tNodeReaderPromission));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除(yifu-module:tnodereaderpromission_del)")
@SysLog("删除流程审阅权限表(抄送/仅有查看权限)")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tNodeReaderPromissionService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRouteCondition;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeRouteConditionService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
/**
* 流程路由条件
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tnoderoutecondition")
@Tag(name = "流程路由条件")
public class TNodeRouteConditionController {
@Resource
private TNodeRouteConditionService tNodeRouteConditionService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tNodeRouteCondition 流程路由条件
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TNodeRouteCondition>> getTNodeRouteConditionPage(Page<TNodeRouteCondition> page, TNodeRouteCondition tNodeRouteCondition) {
return new R<>(tNodeRouteConditionService.getTNodeRouteConditionPage(page, tNodeRouteCondition));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TNodeRouteCondition> getById(@PathVariable("id") String id) {
return new R<>(tNodeRouteConditionService.getById(id));
}
/**
* 新增记录
*
* @param tNodeRouteCondition
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TNodeRouteCondition tNodeRouteCondition) {
return new R<>(tNodeRouteConditionService.save(tNodeRouteCondition));
}
/**
* 修改记录
*
* @param tNodeRouteCondition
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改流程路由条件")
@PutMapping
public R<Boolean> update(@RequestBody TNodeRouteCondition tNodeRouteCondition) {
return new R<>(tNodeRouteConditionService.updateById(tNodeRouteCondition));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除流程路由条件")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tNodeRouteConditionService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRoute;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeRouteService;
import com.yifu.cloud.plus.v1.yifu.common.security.annotation.Inner;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.List;
/**
* 流程路由表(节点与节点之间的路由关系)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tnoderoute")
@Tag(name = "流程路由表(节点与节点之间的路由关系)")
public class TNodeRouteController {
@Resource
private TNodeRouteService tNodeRouteService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tNodeRoute 流程路由表(节点与节点之间的路由关系)
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TNodeRoute>> getTNodeRoutePage(Page<TNodeRoute> page, TNodeRoute tNodeRoute) {
return new R<>(tNodeRouteService.getTNodeRoutePage(page, tNodeRoute));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TNodeRoute> getById(@PathVariable("id") String id) {
return new R<>(tNodeRouteService.getById(id));
}
/**
* 新增记录
*
* @param tNodeRoute
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TNodeRoute tNodeRoute) {
return new R<>(tNodeRouteService.save(tNodeRoute));
}
/**
* 修改记录
*
* @param tNodeRoute
* @return R
*/
@Operation(summary = "修改(yifu-module:tnoderoute_edit)")
@SysLog("修改流程路由表(节点与节点之间的路由关系)")
@PutMapping
public R<Boolean> update(@RequestBody TNodeRoute tNodeRoute) {
return new R<>(tNodeRouteService.updateById(tNodeRoute));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除流程路由表(节点与节点之间的路由关系)")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tNodeRouteService.removeById(id));
}
/**
* todo 功能描述: 根据流程id查询路由记录
* @Param: [processId]
* @Return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<java.util.List<TNodeRoute>>
* @Author: zhouyang
* @Date: 2021/9/3 11:46
*/
@Inner
@GetMapping("/inner/getNodeRoute/byProcessId")
public R<List<TNodeRoute>> getNodeRouteByProcessId(@RequestParam("processId") String processId) {
List<TNodeRoute> tNodeRoute = tNodeRouteService.list(Wrappers.<TNodeRoute>query().lambda().eq(TNodeRoute::getProcessId, processId));
return new R<>(tNodeRoute);
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTimeoutConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeTimeoutConfigService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
/**
* 节点超时配置表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tnodetimeoutconfig")
@Tag(name = "节点超时配置表")
public class TNodeTimeoutConfigController {
@Resource
private TNodeTimeoutConfigService tNodeTimeoutConfigService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tNodeTimeoutConfig 节点超时配置表
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TNodeTimeoutConfig>> getTNodeTimeoutConfigPage(Page<TNodeTimeoutConfig> page, TNodeTimeoutConfig tNodeTimeoutConfig) {
return new R<>(tNodeTimeoutConfigService.getTNodeTimeoutConfigPage(page, tNodeTimeoutConfig));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TNodeTimeoutConfig> getById(@PathVariable("id") String id) {
return new R<>(tNodeTimeoutConfigService.getById(id));
}
/**
* 新增记录
*
* @param tNodeTimeoutConfig
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TNodeTimeoutConfig tNodeTimeoutConfig) {
return new R<>(tNodeTimeoutConfigService.save(tNodeTimeoutConfig));
}
/**
* 修改记录
*
* @param tNodeTimeoutConfig
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改节点超时配置表")
@PutMapping
public R<Boolean> update(@RequestBody TNodeTimeoutConfig tNodeTimeoutConfig) {
return new R<>(tNodeTimeoutConfigService.updateById(tNodeTimeoutConfig));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除节点超时配置表")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tNodeTimeoutConfigService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTransferConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeTransferConfigService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
/**
* 流程调用配置(子流程调用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tnodetransferconfig")
@Tag(name = "流程调用配置(子流程调用)")
public class TNodeTransferConfigController {
@Resource
private TNodeTransferConfigService tNodeTransferConfigService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tNodeTransferConfig 流程调用配置(子流程调用)
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TNodeTransferConfig>> getTNodeTransferConfigPage(Page<TNodeTransferConfig> page, TNodeTransferConfig tNodeTransferConfig) {
return new R<>(tNodeTransferConfigService.getTNodeTransferConfigPage(page, tNodeTransferConfig));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TNodeTransferConfig> getById(@PathVariable("id") String id) {
return new R<>(tNodeTransferConfigService.getById(id));
}
/**
* 新增记录
*
* @param tNodeTransferConfig
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TNodeTransferConfig tNodeTransferConfig) {
return new R<>(tNodeTransferConfigService.save(tNodeTransferConfig));
}
/**
* 修改记录
*
* @param tNodeTransferConfig
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改流程调用配置(子流程调用)")
@PutMapping
public R<Boolean> update(@RequestBody TNodeTransferConfig tNodeTransferConfig) {
return new R<>(tNodeTransferConfigService.updateById(tNodeTransferConfig));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除流程调用配置(子流程调用)")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tNodeTransferConfigService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessApprovalConf;
import com.yifu.cloud.plus.v1.yifu.process.service.TProcessApprovalConfService;
import com.yifu.cloud.plus.v1.yifu.common.security.annotation.Inner;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.List;
/**
* 审批配置表
*
* @author wangan
* @date 2020-12-03 09:58:15
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tprocessapprovalconf")
@Tag(name = "审批配置表")
public class TProcessApprovalConfController {
@Resource
private TProcessApprovalConfService tProcessApprovalConfService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tProcessApprovalConf 审批配置表
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TProcessApprovalConf>> getTProcessApprovalConfPage(Page<TProcessApprovalConf> page, TProcessApprovalConf tProcessApprovalConf) {
return new R<>(tProcessApprovalConfService.getTProcessApprovalConfPage(page, tProcessApprovalConf));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TProcessApprovalConf> getById(@PathVariable("id") String id) {
return new R<>(tProcessApprovalConfService.getById(id));
}
/**
* 新增记录
*
* @param tProcessApprovalConf
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TProcessApprovalConf tProcessApprovalConf) {
return new R<>(tProcessApprovalConfService.save(tProcessApprovalConf));
}
/**
* 修改记录
*
* @param tProcessApprovalConf
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改审批配置表")
@PutMapping
public R<Boolean> update(@RequestBody TProcessApprovalConf tProcessApprovalConf) {
return new R<>(tProcessApprovalConfService.updateById(tProcessApprovalConf));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除审批配置表")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tProcessApprovalConfService.removeById(id));
}
/**
* todo
* @param type
* @param parentId
* @Author: wangan
* @Date: 2020/12/7
* @Description: 通过类型和父类名称去获取字段名称
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<TProcessApprovalConf>
* @see com.yifu.cloud.plus.v1.process.controller
**/
@Inner
@GetMapping("/inner/getRecord/byTypeAndParentId")
public R<TProcessApprovalConf> getRecordbyTypeAndParentId(@RequestParam("type") String type, @RequestParam("parentId") String parentId) {
List<TProcessApprovalConf> list = tProcessApprovalConfService.list(Wrappers.<TProcessApprovalConf>query().lambda()
.eq(TProcessApprovalConf::getType, type)
.eq(TProcessApprovalConf::getParentId, parentId)
.eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING));
if (list.isEmpty()) {
return new R<>(null);
}
return new R<>(list.get(CommonConstants.ZERO_INT));
}
/**
* todo
* @param type
* @param parentId
* @Author: wangan
* @Date: 2020/12/7
* @Description: 通过相关条件获取正确的一个主流程
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<TProcessApprovalConf>
* @see com.yifu.cloud.plus.v1.process.controller
**/
@Inner
@GetMapping("/inner/getRecord/byCondition")
public R<TProcessApprovalConf> getRecordByCondition(@RequestParam("type") String type,
@RequestParam("parentId") String parentId,
@RequestParam("fieldName") String fieldName,
@RequestParam("fieldValue") String fieldValue) {
return tProcessApprovalConfService.getRecordByCondition(type,parentId,fieldName,fieldValue);
}
/**
* todo
* @param processId
* @Author: wangan
* @Date: 2020/12/7
* @Description: 通过流程获取记录
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<TProcessApprovalConf>
* @see com.yifu.cloud.plus.v1.process.controller
**/
@Inner
@GetMapping("/inner/getRecord/byProcessId")
public R<List<TProcessApprovalConf>> getRecordByProcessId(@RequestParam("processId") String processId) {
List<TProcessApprovalConf> processApprovalConf = tProcessApprovalConfService.list(Wrappers.<TProcessApprovalConf>query().lambda().eq(TProcessApprovalConf::getProcessId, processId));
return new R<>(processApprovalConf);
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcess;
import com.yifu.cloud.plus.v1.yifu.process.vo.ProcessVo;
import com.yifu.cloud.plus.v1.yifu.process.vo.TProcessViewVo;
import com.yifu.cloud.plus.v1.yifu.process.service.TProcessService;
import com.yifu.cloud.plus.v1.yifu.common.security.annotation.Inner;
import com.yifu.cloud.plus.v1.yifu.common.security.util.SecurityUtils;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.time.LocalDateTime;
/**
* 主流程表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tprocess")
@Tag(name = "主流程表")
public class TProcessController {
@Resource
private TProcessService tProcessService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tProcess 主流程表
* @param type 0:在用流程 1非在用
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TProcessViewVo>> getTProcessPage(Page<TProcessViewVo> page, TProcessViewVo tProcess,String type) {
return new R<>(tProcessService.getTProcessPage(page, tProcess,type));
}
/**
* 通过id查询单条记录
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TProcess> getById(@PathVariable("id") String id) {
return new R<>(tProcessService.getById(id));
}
/**
* 通过ids查询多条记录
* @param ids
* @return R
*/
@Operation(summary = "ids查询")
@GetMapping("/get/byIds")
public R<TProcess> getByIds(@RequestParam("ids") String[] ids) {
return new R(tProcessService.list(Wrappers.<TProcess>query().lambda().in(TProcess::getId,ids)));
}
/**
* @param id
* @Description: 根据id查询ProcessVo
* @Author: hgw
* @Date: 2020/7/17 11:05
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<ProcessVo>
**/
@Operation(summary = "根据id查询ProcessVo")
@GetMapping("/getProcessVoById")
public R<ProcessVo> getProcessVoById(String id) {
return new R<>(tProcessService.getProcessVoById(id));
}
/**
* todo
* @param processId 流程名称
* @Description: 根据流程名称查询ProcessVo
* @Author: hgw
* @Date: 2020-7-22 18:17:29
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<ProcessVo>
**/
@Operation(summary = "根据流程名称查询ProcessVo")
@PostMapping("/inner/getProcessVoByName")
@Inner
public R<ProcessVo> getProcessVoByName(String processId) {
return tProcessService.getProcessVoByName(processId);
}
/**
* 新增记录
* @param processVo
* @return R
*/
@Operation(summary = "新增流程")
@PostMapping("/saveProcessVo")
public R saveProcessVo(@RequestBody ProcessVo processVo) {return tProcessService.saveProcessVo(processVo);}
/**
* 新增记录
*
* @param tProcess
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<String> save(@RequestBody TProcessViewVo tProcess) {
YifuUser user = SecurityUtils.getUser();
tProcess.setCreateDate(LocalDateTime.now());
tProcess.setCreateUser(String.valueOf(user.getId()));
return tProcessService.add(tProcess);
}
/**
* 修改记录
*
* @param vo
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改主流程表")
@PutMapping
public R<String> update(@RequestBody TProcessViewVo vo) {
YifuUser user = SecurityUtils.getUser();
vo.setUpdateDate(LocalDateTime.now());
vo.setUpdateUser(String.valueOf(user.getId()));
return tProcessService.modify(vo);
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除主流程表")
@DeleteMapping("/{id}")
public R removeById(@PathVariable String id) {
return tProcessService.delete(id);
}
/**
* 审批角色流程检测
*
* @param tProcess 审批角色
* @return R<List<ProcessVo>>
* @author chenyuxi
* @date 2023-10-23 09:48:57
* @since crm2.12.0
*/
@Operation(summary = "审批角色流程检测列表")
@GetMapping("/getProcessPageByRoleId")
public R<IPage<TProcessViewVo>> getProcessPageByRoleId(Page<TProcessViewVo> page, TProcessViewVo tProcess) {
if(Common.isEmpty(tProcess.getRole())) {
return R.failed("审批角色Id不能为空");
}
// 设置角色类型:5指定角色(crm)
tProcess.setNodePermissionType(CommonConstants.FIVE_INT);
return new R<>(tProcessService.getProcessPageByRoleId(page, tProcess));
}
/**
* 审批角色流程检测
*
* @param tProcess 审批角色
* @return R<List<ProcessVo>>
* @author chenyuxi
* @date 2023-10-23 09:48:57
* @since crm2.12.0
*/
@Operation(summary = "审批角色流程检测")
@GetMapping("/checkProcessByRoleId")
public R<String> checkProcessByRoleId(TProcessViewVo tProcess) {
if(Common.isEmpty(tProcess.getRole())) {
return R.failed("审批角色Id不能为空");
}
// 设置角色类型:5指定角色(crm)
tProcess.setNodePermissionType(CommonConstants.FIVE_INT);
return new R<>(tProcessService.checkProcessByRoleId(tProcess));
}
/**
* 流程弃用(弃用的流程会在历史流程列表里)
* @Author: wangdayu
* @Date: 2023年10月24日14:46
* @param id:流程id
* @return R
*/
@Operation(summary = "流程弃用(弃用的流程会在历史流程列表里")
@GetMapping("/noUse")
public R<String> noUse(@RequestParam(value = "id") String id) {
TProcess tProcess = new TProcess();
tProcess.setId(id);
return tProcessService.noUse(tProcess);
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessNode;
import com.yifu.cloud.plus.v1.yifu.process.service.TProcessNodeService;
import com.yifu.cloud.plus.v1.yifu.common.security.annotation.Inner;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.List;
/**
* 流程节点表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tprocessnode")
@Tag(name = "流程节点表")
public class TProcessNodeController {
@Resource
private TProcessNodeService tProcessNodeService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tProcessNode 流程节点表
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TProcessNode>> getTProcessNodePage(Page<TProcessNode> page, TProcessNode tProcessNode) {
return new R<>(tProcessNodeService.getTProcessNodePage(page, tProcessNode));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TProcessNode> getById(@PathVariable("id") String id) {
return new R<>(tProcessNodeService.getById(id));
}
/**
* 新增记录
*
* @param tProcessNode
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TProcessNode tProcessNode) {
return new R<>(tProcessNodeService.save(tProcessNode));
}
/**
* 修改记录
*
* @param tProcessNode
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改流程节点表")
@PutMapping
public R<Boolean> update(@RequestBody TProcessNode tProcessNode) {
return new R<>(tProcessNodeService.updateById(tProcessNode));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除流程节点表")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tProcessNodeService.removeById(id));
}
/**
* todo
* @param processId
* @param nodeId
* @Author: wangan
* @Date: 2020/9/4
* @Description:
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<ProcessVo>
**/
@Operation(summary = "根据流程名称查询ProcessVo")
@PostMapping("/inner/getNodeByVoId")
@Inner
public R<TProcessNode> getNodeByVoId(@RequestParam("processId") String processId, @RequestParam("nodeId") String nodeId) {
return new R(tProcessNodeService.getOne(Wrappers.<TProcessNode>query().lambda().eq(TProcessNode::getProcessId, processId).eq(TProcessNode::getId, nodeId)));
}
/**
* todo 功能描述: 查询流程id查询节点数据
* @Param: [processId]
* @Return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<java.util.List<TProcessNode>>
* @Author: zhouyang
* @Date: 2021/11/3 14:33
*/
@Operation(summary = "根据流程id查询ProcessNode")
@PostMapping("/inner/getNodeByVoProcessId")
@Inner
public R<List<TProcessNode>> getNodeByVoProcessId(@RequestParam("processId") String processId) {
return new R(tProcessNodeService.list((Wrappers.<TProcessNode>query().lambda().eq(TProcessNode::getProcessId, processId))));
}
}
package com.yifu.cloud.plus.v1.yifu.process.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.process.entity.TServiceTransferConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TServiceTransferConfigService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.validation.Valid;
/**
* 远程服务调用(在节点为服务调用节点时使用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@RestController
@RequiredArgsConstructor
@RequestMapping("/tservicetransferconfig")
@Tag(name = "远程服务调用(在节点为服务调用节点时使用)")
public class TServiceTransferConfigController {
@Resource
private TServiceTransferConfigService tServiceTransferConfigService;
/**
* 简单分页查询
*
* @param page 分页对象
* @param tServiceTransferConfig 远程服务调用(在节点为服务调用节点时使用)
* @return
*/
@Operation(summary = "简单分页查询")
@GetMapping("/page")
public R<IPage<TServiceTransferConfig>> getTServiceTransferConfigPage(Page<TServiceTransferConfig> page, TServiceTransferConfig tServiceTransferConfig) {
return new R<>(tServiceTransferConfigService.getTServiceTransferConfigPage(page, tServiceTransferConfig));
}
/**
* 通过id查询单条记录
*
* @param id
* @return R
*/
@Operation(summary = "id查询")
@GetMapping("/{id}")
public R<TServiceTransferConfig> getById(@PathVariable("id") String id) {
return new R<>(tServiceTransferConfigService.getById(id));
}
/**
* 新增记录
*
* @param tServiceTransferConfig
* @return R
*/
@Operation(summary = "新增")
@PostMapping
public R<Boolean> save(@Valid @RequestBody TServiceTransferConfig tServiceTransferConfig) {
return new R<>(tServiceTransferConfigService.save(tServiceTransferConfig));
}
/**
* 修改记录
*
* @param tServiceTransferConfig
* @return R
*/
@Operation(summary = "修改")
@SysLog("修改远程服务调用(在节点为服务调用节点时使用)")
@PutMapping
public R<Boolean> update(@RequestBody TServiceTransferConfig tServiceTransferConfig) {
return new R<>(tServiceTransferConfigService.updateById(tServiceTransferConfig));
}
/**
* 通过id删除一条记录
*
* @param id
* @return R
*/
@Operation(summary = "删除")
@SysLog("删除远程服务调用(在节点为服务调用节点时使用)")
@DeleteMapping("/{id}")
public R<Boolean> removeById(@PathVariable String id) {
return new R<>(tServiceTransferConfigService.removeById(id));
}
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TDelayNodeConfig;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Mapper;
/**
* 定时流程节点配置
*
* @author hgw
* @date 2020-07-16 17:48:52
*/
@Mapper
public interface TDelayNodeConfigMapper extends BaseMapper<TDelayNodeConfig> {
/**
* 定时流程节点配置简单分页查询
*
* @param tDelayNodeConfig 定时流程节点配置
* @return
*/
IPage<TDelayNodeConfig> getTDelayNodeConfigPage(Page<TDelayNodeConfig> page
, @Param("tDelayNodeConfig") TDelayNodeConfig tDelayNodeConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeConfig;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 流程节点配置表(规则配置)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TNodeConfigMapper extends BaseMapper<TNodeConfig> {
/**
* 流程节点配置表(规则配置)简单分页查询
*
* @param tNodeConfig 流程节点配置表(规则配置)
* @return
*/
IPage<TNodeConfig> getTNodeConfigPage(Page<TNodeConfig> page, @Param("tNodeConfig") TNodeConfig tNodeConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodePrimission;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 流程处理权限表(允许多个,多个代表有主办和经办)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TNodePrimissionMapper extends BaseMapper<TNodePrimission> {
/**
* 流程处理权限表(允许多个,多个代表有主办和经办)简单分页查询
*
* @param tNodePrimission 流程处理权限表(允许多个,多个代表有主办和经办)
* @return
*/
IPage<TNodePrimission> getTNodePrimissionPage(Page<TNodePrimission> page
, @Param("tNodePrimission") TNodePrimission tNodePrimission);
/**
* @param processId 流程id
* @Description: 删除
* @Author: hgw
* @Date: 2020/7/17 11:32
* @return: int
**/
int deleteByProcessId(@Param("processId") String processId);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeReaderPromission;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 流程审阅权限表(抄送/仅有查看权限)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TNodeReaderPromissionMapper extends BaseMapper<TNodeReaderPromission> {
/**
* 流程审阅权限表(抄送/仅有查看权限)简单分页查询
*
* @param tNodeReaderPromission 流程审阅权限表(抄送/仅有查看权限)
* @return
*/
IPage<TNodeReaderPromission> getTNodeReaderPromissionPage(Page<TNodeReaderPromission> page
, @Param("tNodeReaderPromission") TNodeReaderPromission tNodeReaderPromission);
/**
* @param processId 流程id
* @Description: 删除
* @Author: hgw
* @Date: 2020/7/17 11:32
* @return: int
**/
int deleteByProcessId(@Param("processId") String processId);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRouteCondition;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 流程路由条件
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TNodeRouteConditionMapper extends BaseMapper<TNodeRouteCondition> {
/**
* 流程路由条件简单分页查询
*
* @param tNodeRouteCondition 流程路由条件
* @return
*/
IPage<TNodeRouteCondition> getTNodeRouteConditionPage(Page<TNodeRouteCondition> page
, @Param("tNodeRouteCondition") TNodeRouteCondition tNodeRouteCondition);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRoute;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 流程路由表(节点与节点之间的路由关系)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TNodeRouteMapper extends BaseMapper<TNodeRoute> {
/**
* 流程路由表(节点与节点之间的路由关系)简单分页查询
*
* @param tNodeRoute 流程路由表(节点与节点之间的路由关系)
* @return
*/
IPage<TNodeRoute> getTNodeRoutePage(Page<TNodeRoute> page, @Param("tNodeRoute") TNodeRoute tNodeRoute);
/**
* @param processId 流程id
* @Description: 删除
* @Author: hgw
* @Date: 2020/7/17 11:32
* @return: int
**/
int deleteByProcessId(@Param("processId") String processId);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTimeoutConfig;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 节点超时配置表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TNodeTimeoutConfigMapper extends BaseMapper<TNodeTimeoutConfig> {
/**
* 节点超时配置表简单分页查询
*
* @param tNodeTimeoutConfig 节点超时配置表
* @return
*/
IPage<TNodeTimeoutConfig> getTNodeTimeoutConfigPage(Page<TNodeTimeoutConfig> page
, @Param("tNodeTimeoutConfig") TNodeTimeoutConfig tNodeTimeoutConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTransferConfig;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 流程调用配置(子流程调用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TNodeTransferConfigMapper extends BaseMapper<TNodeTransferConfig> {
/**
* 流程调用配置(子流程调用)简单分页查询
*
* @param tNodeTransferConfig 流程调用配置(子流程调用)
* @return
*/
IPage<TNodeTransferConfig> getTNodeTransferConfigPage(Page<TNodeTransferConfig> page
, @Param("tNodeTransferConfig") TNodeTransferConfig tNodeTransferConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessApprovalConf;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 审批配置表
*
* @author wangan
* @date 2020-12-03 09:58:15
*/
@Mapper
public interface TProcessApprovalConfMapper extends BaseMapper<TProcessApprovalConf> {
/**
* 审批配置表简单分页查询
* @param tProcessApprovalConf 审批配置表
* @return
*/
IPage<TProcessApprovalConf> getTProcessApprovalConfPage(Page<TProcessApprovalConf> page, @Param("tProcessApprovalConf") TProcessApprovalConf tProcessApprovalConf);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcess;
import com.yifu.cloud.plus.v1.yifu.process.vo.TProcessViewVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 主流程表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TProcessMapper extends BaseMapper<TProcess> {
/**
* 主流程表简单分页查询
*
* @param tProcess 主流程表
* @return
*/
IPage<TProcessViewVo> getTProcessPage(Page<TProcessViewVo> page, @Param("tProcess") TProcessViewVo tProcess, @Param("type")String type);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessNode;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 流程节点表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TProcessNodeMapper extends BaseMapper<TProcessNode> {
/**
* 流程节点表简单分页查询
*
* @param tProcessNode 流程节点表
* @return
*/
IPage<TProcessNode> getTProcessNodePage(Page<TProcessNode> page, @Param("tProcessNode") TProcessNode tProcessNode);
/**
* @param processId 流程id
* @Description: 删除
* @Author: hgw
* @Date: 2020/7/17 11:32
* @return: int
**/
int deleteByProcessId(@Param("processId") String processId);
}
package com.yifu.cloud.plus.v1.yifu.process.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yifu.cloud.plus.v1.yifu.process.entity.TServiceTransferConfig;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 远程服务调用(在节点为服务调用节点时使用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Mapper
public interface TServiceTransferConfigMapper extends BaseMapper<TServiceTransferConfig> {
/**
* 远程服务调用(在节点为服务调用节点时使用)简单分页查询
*
* @param tServiceTransferConfig 远程服务调用(在节点为服务调用节点时使用)
* @return
*/
IPage<TServiceTransferConfig> getTServiceTransferConfigPage(Page<TServiceTransferConfig> page
, @Param("tServiceTransferConfig") TServiceTransferConfig tServiceTransferConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TDelayNodeConfig;
/**
* 定时流程节点配置
*
* @author hgw
* @date 2020-07-16 17:48:52
*/
public interface TDelayNodeConfigService extends IService<TDelayNodeConfig> {
/**
* 定时流程节点配置简单分页查询
*
* @param tDelayNodeConfig 定时流程节点配置
* @return
*/
IPage<TDelayNodeConfig> getTDelayNodeConfigPage(Page<TDelayNodeConfig> page, TDelayNodeConfig tDelayNodeConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeConfig;
/**
* 流程节点配置表(规则配置)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TNodeConfigService extends IService<TNodeConfig> {
/**
* 流程节点配置表(规则配置)简单分页查询
*
* @param tNodeConfig 流程节点配置表(规则配置)
* @return
*/
IPage<TNodeConfig> getTNodeConfigPage(Page<TNodeConfig> page, TNodeConfig tNodeConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodePrimission;
/**
* 流程处理权限表(允许多个,多个代表有主办和经办)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TNodePrimissionService extends IService<TNodePrimission> {
/**
* 流程处理权限表(允许多个,多个代表有主办和经办)简单分页查询
*
* @param tNodePrimission 流程处理权限表(允许多个,多个代表有主办和经办)
* @return
*/
IPage<TNodePrimission> getTNodePrimissionPage(Page<TNodePrimission> page, TNodePrimission tNodePrimission);
/**
* @param processId 流程id
* @Description: 根据id删除节点
* @Author: hgw
* @Date: 2020-7-22 17:01:54
* @return: int
**/
int deleteByProcessId(String processId);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeReaderPromission;
/**
* 流程审阅权限表(抄送/仅有查看权限)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TNodeReaderPromissionService extends IService<TNodeReaderPromission> {
/**
* 流程审阅权限表(抄送/仅有查看权限)简单分页查询
*
* @param tNodeReaderPromission 流程审阅权限表(抄送/仅有查看权限)
* @return
*/
IPage<TNodeReaderPromission> getTNodeReaderPromissionPage(Page<TNodeReaderPromission> page, TNodeReaderPromission tNodeReaderPromission);
/**
* @param processId 流程id
* @Description: 根据id删除节点
* @Author: hgw
* @Date: 2020-7-22 17:01:54
* @return: int
**/
int deleteByProcessId(String processId);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRouteCondition;
/**
* 流程路由条件
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TNodeRouteConditionService extends IService<TNodeRouteCondition> {
/**
* 流程路由条件简单分页查询
*
* @param tNodeRouteCondition 流程路由条件
* @return
*/
IPage<TNodeRouteCondition> getTNodeRouteConditionPage(Page<TNodeRouteCondition> page, TNodeRouteCondition tNodeRouteCondition);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRoute;
/**
* 流程路由表(节点与节点之间的路由关系)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TNodeRouteService extends IService<TNodeRoute> {
/**
* 流程路由表(节点与节点之间的路由关系)简单分页查询
*
* @param tNodeRoute 流程路由表(节点与节点之间的路由关系)
* @return
*/
IPage<TNodeRoute> getTNodeRoutePage(Page<TNodeRoute> page, TNodeRoute tNodeRoute);
/**
* @param processId 流程id
* @Description: 根据id删除节点
* @Author: hgw
* @Date: 2020/7/17 11:19
* @return: int
**/
int deleteByProcessId(String processId);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTimeoutConfig;
/**
* 节点超时配置表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TNodeTimeoutConfigService extends IService<TNodeTimeoutConfig> {
/**
* 节点超时配置表简单分页查询
*
* @param tNodeTimeoutConfig 节点超时配置表
* @return
*/
IPage<TNodeTimeoutConfig> getTNodeTimeoutConfigPage(Page<TNodeTimeoutConfig> page, TNodeTimeoutConfig tNodeTimeoutConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTransferConfig;
/**
* 流程调用配置(子流程调用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TNodeTransferConfigService extends IService<TNodeTransferConfig> {
/**
* 流程调用配置(子流程调用)简单分页查询
*
* @param tNodeTransferConfig 流程调用配置(子流程调用)
* @return
*/
IPage<TNodeTransferConfig> getTNodeTransferConfigPage(Page<TNodeTransferConfig> page, TNodeTransferConfig tNodeTransferConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessApprovalConf;
/**
* 审批配置表
*
* @author wangan
* @date 2020-12-03 09:58:15
*/
public interface TProcessApprovalConfService extends IService<TProcessApprovalConf> {
/**
* 审批配置表简单分页查询
* @param tProcessApprovalConf 审批配置表
* @return
*/
IPage<TProcessApprovalConf> getTProcessApprovalConfPage(Page<TProcessApprovalConf> page, TProcessApprovalConf tProcessApprovalConf);
R<TProcessApprovalConf> getRecordByCondition(String type, String parentId, String fieldName, String fieldValue);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessNode;
/**
* 流程节点表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TProcessNodeService extends IService<TProcessNode> {
/**
* 流程节点表简单分页查询
*
* @param tProcessNode 流程节点表
* @return
*/
IPage<TProcessNode> getTProcessNodePage(Page<TProcessNode> page, TProcessNode tProcessNode);
/**
* @param processId 流程id
* @Description: 根据id删除节点
* @Author: hgw
* @Date: 2020/7/17 11:19
* @return: int
**/
int deleteByProcessId(String processId);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcess;
import com.yifu.cloud.plus.v1.yifu.process.vo.ProcessVo;
import com.yifu.cloud.plus.v1.yifu.process.vo.TProcessViewVo;
/**
* 主流程表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TProcessService extends IService<TProcess> {
/**
* 主流程表简单分页查询
*
* @param tProcess 主流程表
* @return
*/
IPage<TProcessViewVo> getTProcessPage(Page<TProcessViewVo> page, TProcessViewVo tProcess,String type);
/**
* @param id
* @Description: 返回ProcessVo
* @Author: hgw
* @Date: 2020/7/17 10:59
* @return: ProcessVo
**/
ProcessVo getProcessVoById(String id);
/**
* @param processId
* @Description: 返回ProcessVo
* @Author: hgw
* @Date: 2020-7-22 18:18:42
* @return: ProcessVo
**/
R<ProcessVo> getProcessVoByName(String processId);
/**
* @param processVo
* @Description: 保存流程
* @Author: hgw
* @Date: 2020/7/17 11:13
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R
**/
R saveProcessVo(ProcessVo processVo);
/**
* @param processId
* @Description: 删除流程
* @Author: hgw
* @Date: 2020/7/17 17:20
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R
**/
R deleteById(String processId);
R<String> add(TProcessViewVo tProcess);
R<String> modify(TProcessViewVo vo);
R<String> delete(String id);
R<String> noUse(TProcess tProcess);
/**
* 根据角色ID获取关联流程
*
* @param tProcess 审批角色
* @return IPage<TProcessViewVo>
* @author chenyuxi
* @date 2023-10-23 09:48:57
* @since crm2.12.0
*/
IPage<TProcessViewVo> getProcessPageByRoleId(Page<TProcessViewVo> page, TProcessViewVo tProcess);
String checkProcessByRoleId(TProcessViewVo tProcess);
}
package com.yifu.cloud.plus.v1.yifu.process.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.process.entity.TServiceTransferConfig;
/**
* 远程服务调用(在节点为服务调用节点时使用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
public interface TServiceTransferConfigService extends IService<TServiceTransferConfig> {
/**
* 远程服务调用(在节点为服务调用节点时使用)简单分页查询
*
* @param tServiceTransferConfig 远程服务调用(在节点为服务调用节点时使用)
* @return
*/
IPage<TServiceTransferConfig> getTServiceTransferConfigPage(Page<TServiceTransferConfig> page, TServiceTransferConfig tServiceTransferConfig);
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TDelayNodeConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TDelayNodeConfigService;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TDelayNodeConfigMapper;
import org.springframework.stereotype.Service;
/**
* 定时流程节点配置
*
* @author hgw
* @date 2020-07-16 17:48:52
*/
@Service
public class TDelayNodeConfigServiceImpl extends ServiceImpl<TDelayNodeConfigMapper, TDelayNodeConfig> implements TDelayNodeConfigService {
/**
* 定时流程节点配置简单分页查询
*
* @param tDelayNodeConfig 定时流程节点配置
* @return
*/
@Override
public IPage<TDelayNodeConfig> getTDelayNodeConfigPage(Page<TDelayNodeConfig> page, TDelayNodeConfig tDelayNodeConfig) {
return baseMapper.getTDelayNodeConfigPage(page, tDelayNodeConfig);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeConfigService;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TNodeConfigMapper;
import org.springframework.stereotype.Service;
/**
* 流程节点配置表(规则配置)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TNodeConfigServiceImpl extends ServiceImpl<TNodeConfigMapper, TNodeConfig> implements TNodeConfigService {
/**
* 流程节点配置表(规则配置)简单分页查询
*
* @param tNodeConfig 流程节点配置表(规则配置)
* @return
*/
@Override
public IPage<TNodeConfig> getTNodeConfigPage(Page<TNodeConfig> page, TNodeConfig tNodeConfig) {
return baseMapper.getTNodeConfigPage(page, tNodeConfig);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodePrimission;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TNodePrimissionMapper;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodePrimissionService;
import org.springframework.stereotype.Service;
/**
* 流程处理权限表(允许多个,多个代表有主办和经办)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TNodePrimissionServiceImpl extends ServiceImpl<TNodePrimissionMapper, TNodePrimission> implements TNodePrimissionService {
/**
* 流程处理权限表(允许多个,多个代表有主办和经办)简单分页查询
*
* @param tNodePrimission 流程处理权限表(允许多个,多个代表有主办和经办)
* @return
*/
@Override
public IPage<TNodePrimission> getTNodePrimissionPage(Page<TNodePrimission> page, TNodePrimission tNodePrimission) {
return baseMapper.getTNodePrimissionPage(page, tNodePrimission);
}
/**
* @param processId 流程id
* @Description: 删除
* @Author: hgw
* @Date: 2020-7-22 17:02:34
* @return: int
**/
@Override
public int deleteByProcessId(String processId) {
return baseMapper.deleteByProcessId(processId);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeReaderPromission;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TNodeReaderPromissionMapper;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeReaderPromissionService;
import org.springframework.stereotype.Service;
/**
* 流程审阅权限表(抄送/仅有查看权限)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TNodeReaderPromissionServiceImpl extends ServiceImpl<TNodeReaderPromissionMapper, TNodeReaderPromission> implements TNodeReaderPromissionService {
/**
* 流程审阅权限表(抄送/仅有查看权限)简单分页查询
*
* @param tNodeReaderPromission 流程审阅权限表(抄送/仅有查看权限)
* @return
*/
@Override
public IPage<TNodeReaderPromission> getTNodeReaderPromissionPage(Page<TNodeReaderPromission> page, TNodeReaderPromission tNodeReaderPromission) {
return baseMapper.getTNodeReaderPromissionPage(page, tNodeReaderPromission);
}
/**
* @param processId 流程id
* @Description: 删除
* @Author: hgw
* @Date: 2020-7-22 17:02:38
* @return: int
**/
@Override
public int deleteByProcessId(String processId) {
return baseMapper.deleteByProcessId(processId);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRouteCondition;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeRouteConditionService;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TNodeRouteConditionMapper;
import org.springframework.stereotype.Service;
/**
* 流程路由条件
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TNodeRouteConditionServiceImpl extends ServiceImpl<TNodeRouteConditionMapper, TNodeRouteCondition> implements TNodeRouteConditionService {
/**
* 流程路由条件简单分页查询
*
* @param tNodeRouteCondition 流程路由条件
* @return
*/
@Override
public IPage<TNodeRouteCondition> getTNodeRouteConditionPage(Page<TNodeRouteCondition> page, TNodeRouteCondition tNodeRouteCondition) {
return baseMapper.getTNodeRouteConditionPage(page, tNodeRouteCondition);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRoute;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeRouteService;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TNodeRouteMapper;
import org.springframework.stereotype.Service;
/**
* 流程路由表(节点与节点之间的路由关系)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TNodeRouteServiceImpl extends ServiceImpl<TNodeRouteMapper, TNodeRoute> implements TNodeRouteService {
/**
* 流程路由表(节点与节点之间的路由关系)简单分页查询
*
* @param tNodeRoute 流程路由表(节点与节点之间的路由关系)
* @return
*/
@Override
public IPage<TNodeRoute> getTNodeRoutePage(Page<TNodeRoute> page, TNodeRoute tNodeRoute) {
return baseMapper.getTNodeRoutePage(page, tNodeRoute);
}
/**
* @param processId 流程id
* @Description: 删除
* @Author: hgw
* @Date: 2020/7/17 11:25
* @return: int
**/
@Override
public int deleteByProcessId(String processId) {
return baseMapper.deleteByProcessId(processId);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTimeoutConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeTimeoutConfigService;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TNodeTimeoutConfigMapper;
import org.springframework.stereotype.Service;
/**
* 节点超时配置表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TNodeTimeoutConfigServiceImpl extends ServiceImpl<TNodeTimeoutConfigMapper, TNodeTimeoutConfig> implements TNodeTimeoutConfigService {
/**
* 节点超时配置表简单分页查询
*
* @param tNodeTimeoutConfig 节点超时配置表
* @return
*/
@Override
public IPage<TNodeTimeoutConfig> getTNodeTimeoutConfigPage(Page<TNodeTimeoutConfig> page, TNodeTimeoutConfig tNodeTimeoutConfig) {
return baseMapper.getTNodeTimeoutConfigPage(page, tNodeTimeoutConfig);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTransferConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TNodeTransferConfigService;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TNodeTransferConfigMapper;
import org.springframework.stereotype.Service;
/**
* 流程调用配置(子流程调用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TNodeTransferConfigServiceImpl extends ServiceImpl<TNodeTransferConfigMapper, TNodeTransferConfig> implements TNodeTransferConfigService {
/**
* 流程调用配置(子流程调用)简单分页查询
*
* @param tNodeTransferConfig 流程调用配置(子流程调用)
* @return
*/
@Override
public IPage<TNodeTransferConfig> getTNodeTransferConfigPage(Page<TNodeTransferConfig> page, TNodeTransferConfig tNodeTransferConfig) {
return baseMapper.getTNodeTransferConfigPage(page, tNodeTransferConfig);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcess;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessApprovalConf;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TProcessApprovalConfMapper;
import com.yifu.cloud.plus.v1.yifu.process.service.TProcessApprovalConfService;
import com.yifu.cloud.plus.v1.yifu.process.service.TProcessService;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import static com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants.SEARCH_SUCCESS;
/**
* 审批配置表
*
* @author wangan
* @date 2020-12-03 09:58:15
*/
@Service
public class TProcessApprovalConfServiceImpl extends ServiceImpl<TProcessApprovalConfMapper, TProcessApprovalConf> implements TProcessApprovalConfService {
@Resource
@Lazy
private TProcessService tProcessService;
/**
* 审批配置表简单分页查询
* @param tProcessApprovalConf 审批配置表
* @return
*/
@Override
public IPage<TProcessApprovalConf> getTProcessApprovalConfPage(Page<TProcessApprovalConf> page, TProcessApprovalConf tProcessApprovalConf){
return baseMapper.getTProcessApprovalConfPage(page,tProcessApprovalConf);
}
@Override
public R<TProcessApprovalConf> getRecordByCondition(String type, String parentId, String fieldName, String fieldValue) {
//存储流程配置信息
List<TProcessApprovalConf> list = new ArrayList<>();
//hro垫付不需查询在用的流程
if (!CommonConstants.FOUR_STRING.equals(type)){
/*
* 1.查找所有在用的流程
*/
List<TProcess> inUse = tProcessService.list(Wrappers.<TProcess>query().lambda()
.eq(TProcess::getDeleteFlag, CommonConstants.NOT_DELETE_FLAG)
.eq(TProcess::getProcessIsUse, CommonConstants.ZERO_STRING));
/*
* 2.将在用的流程过滤出id
*/
//在用流程id存放集合
List<String> inUseIdList = new ArrayList<>();
//开始根据是否通用分组
if (Common.isNotKong(inUse)){
inUseIdList = inUse.stream().map(TProcess::getId).collect(Collectors.toList());
}else {
return R.failed("当前部门未配置在用流程");
}
/*
* 3.获取当前部门流程配置
*/
list = this.list(Wrappers.<TProcessApprovalConf>query().lambda()
.eq(TProcessApprovalConf::getType, type)
.eq(TProcessApprovalConf::getFieldName, fieldName)
.eq(TProcessApprovalConf::getFieldValue, fieldValue)
.eq(TProcessApprovalConf::getParentId, parentId)
.eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING));
List<TProcessApprovalConf> one = new ArrayList<>();
/*
* 4.当前部门配置流程未找到 找不到找在用的通用的流程
*/
if (Common.isEmpty(list)) {
//找在用的通用流程
one = getCommonInUseProcess(type, inUseIdList);
//4.1在用的通用流程未找到,报错
if (Common.isEmpty(one)){
return R.failed("找不到流程");
}
//4.2当前类型的在用的通用流程找到不止一条
if (one.size() > CommonConstants.ONE_INT){
return R.failed("当前类型在用的通用流程不止一条");
}
return R.ok(one.get(CommonConstants.ZERO_INT),SEARCH_SUCCESS);
}
/*
* 5.当前部门配置流程找到了只有一条
*/
//判断是否在 在用列表里
if (list.size() == CommonConstants.ONE_INT){
if (Common.isNotKong(inUseIdList) && inUseIdList.contains(list.get(CommonConstants.ZERO_INT).getProcessId())){
return R.ok(list.get(CommonConstants.ZERO_INT),SEARCH_SUCCESS);
}else {
//找在用的通用流程
one = getCommonInUseProcess(type, inUseIdList);
//4.1在用的通用流程未找到,报错
if (Common.isEmpty(one)){
return R.failed("找不到流程");
}
//4.2当前类型的在用的通用流程找到不止一条
if (one.size() > CommonConstants.ONE_INT){
return R.failed("当前类型的在用的通用流程不止一条");
}
return R.ok(one.get(CommonConstants.ZERO_INT),SEARCH_SUCCESS);
}
}
/*
* 6.当前部门配置流程找到了多于一条
*/
//返回在用的那一条流程
one = new ArrayList<>();
for (TProcessApprovalConf tProcessApprovalConf : list) {
if (inUseIdList.contains(tProcessApprovalConf.getProcessId())){
one.add(tProcessApprovalConf);
}
}
//在用流程和配置的流程一条都没匹配上,返回在用的通用流程
if (one.isEmpty()) {
//找在用的通用流程
one = getCommonInUseProcess(type, inUseIdList);
//4.1在用的通用流程未找到,报错
if (Common.isEmpty(one)){
return R.failed("找不到流程");
}
//4.2当前类型的在用的通用流程找到不止一条
if (one.size() > CommonConstants.ONE_INT){
return R.failed("当前类型的在用的通用流程不止一条");
}
return R.ok(one.get(CommonConstants.ZERO_INT),SEARCH_SUCCESS);
}
//在用流程和配置的流程匹配上了不止一条
if (one.size() > CommonConstants.ONE_INT) {
return R.failed("满足当前条件的流程不止一条");
}
//在用流程和配置的流程匹配上了一条
return R.ok(one.get(CommonConstants.ZERO_INT),SEARCH_SUCCESS);
}else {
//垫付走原先流程
list = this.list(Wrappers.<TProcessApprovalConf>query().lambda()
.eq(TProcessApprovalConf::getType, type).eq(TProcessApprovalConf::getFieldName, fieldName)
.eq(TProcessApprovalConf::getFieldValue, fieldValue).eq(TProcessApprovalConf::getParentId, parentId)
.eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING));
if (list.isEmpty()) {
return new R<>(null);
}
if (list.size() > CommonConstants.ONE_INT) {
return R.failed("满足当前条件的流程不为一条");
}
return new R<>(list.get(CommonConstants.ZERO_INT));
}
}
private List<TProcessApprovalConf> getCommonInUseProcess(String type, List<String> inUseIdList) {
LambdaQueryWrapper<TProcessApprovalConf> query = new LambdaQueryWrapper<>();
//获取该类型下面的流程配置,并判断当前类型的流程是否是在用流程,若是,则提示重复,否则正常保存
query.eq(TProcessApprovalConf::getType, type)
.eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING)
.and(wq -> wq.isNull(TProcessApprovalConf::getFieldValue).or()
.eq(TProcessApprovalConf::getFieldValue, CommonConstants.EMPTY_STRING));
List<TProcessApprovalConf> commonProcess = this.list(query);
List<TProcessApprovalConf> one = new ArrayList<>();
if (Common.isNotKong(commonProcess)){
for (TProcessApprovalConf process : commonProcess) {
if (inUseIdList.contains(process.getProcessId())){
one.add(process);
}
}
}
return one;
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TProcessNode;
import com.yifu.cloud.plus.v1.yifu.process.service.TProcessNodeService;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TProcessNodeMapper;
import org.springframework.stereotype.Service;
/**
* 流程节点表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TProcessNodeServiceImpl extends ServiceImpl<TProcessNodeMapper, TProcessNode> implements TProcessNodeService {
/**
* 流程节点表简单分页查询
*
* @param tProcessNode 流程节点表
* @return
*/
@Override
public IPage<TProcessNode> getTProcessNodePage(Page<TProcessNode> page, TProcessNode tProcessNode) {
return baseMapper.getTProcessNodePage(page, tProcessNode);
}
/**
* @param processId 流程id
* @Description: 删除
* @Author: hgw
* @Date: 2020/7/17 11:25
* @return: int
**/
@Override
public int deleteByProcessId(String processId) {
return baseMapper.deleteByProcessId(processId);
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.yifu.cloud.plus.v1.yifu.process.entity.*;
import com.yifu.cloud.plus.v1.yifu.common.core.vo.YifuUser;
import com.yifu.cloud.plus.v1.yifu.common.security.util.SecurityUtils;
import com.yifu.cloud.plus.v1.yifu.process.entity.*;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.ResultConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.util.Common;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.common.core.util.bean.BeanCopyUtils;
import com.yifu.cloud.plus.v1.yifu.process.service.*;
import com.yifu.cloud.plus.v1.yifu.process.vo.CheckNodeVo;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TProcessMapper;
import com.yifu.cloud.plus.v1.yifu.process.vo.DeleteProcessIdsVo;
import com.yifu.cloud.plus.v1.yifu.process.vo.ProcessVo;
import com.yifu.cloud.plus.v1.yifu.process.vo.TProcessViewVo;
import com.yifu.cloud.plus.v1.yifu.process.service.*;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;
import static com.yifu.cloud.plus.v1.yifu.common.core.constant.ResultConstants.FAIL_INFO_NO_MODEL;
/**
* 主流程表
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TProcessServiceImpl extends ServiceImpl<TProcessMapper, TProcess> implements TProcessService {
@Resource
private TProcessNodeService processNodeService;
@Resource
private TNodeRouteService nodeRouteService;
@Resource
private TNodePrimissionService nodePrimissionService;
@Resource
private TNodeReaderPromissionService nodeReaderPromissionService;
static final List<String> departIdType = Arrays.asList("1", "4", "5", "6","7","8","9","10","11","12");
static final List<String> chapterUnitType = Arrays.asList("2", "3");
@Resource
private TNodeRouteConditionService nodeRouteConditionService;
@Resource
private TNodeTransferConfigService nodeTransferConfigService;
@Resource
private TProcessApprovalConfService processApprovalConfService;
/**
* 主流程表简单分页查询
*
* @param tProcess 主流程表
* @return
*/
@Override
public IPage<TProcessViewVo> getTProcessPage(Page<TProcessViewVo> page, TProcessViewVo tProcess,String type) {
//参数处理
if (Common.isEmpty(tProcess.getProcessIsUse())){
//默认查询在用
tProcess.setProcessIsUse(CommonConstants.ZERO_STRING);
}
// getProcessIds为空表示从流程管理页面进来查询的。不为空是用流程检测列表来的
List<TProcessApprovalConf> thisDepartIdConfig = new ArrayList<>();
if (Common.isEmpty(tProcess.getProcessIds())) {
//先获得符合条件的配置流程
thisDepartIdConfig = processApprovalConfService.list(Wrappers.<TProcessApprovalConf>query().lambda()
.eq(Common.isNotNull(tProcess.getProcessType()),TProcessApprovalConf::getType,tProcess.getProcessType())
.eq(Common.isNotNull(tProcess.getDepartId()),TProcessApprovalConf::getFieldValue,tProcess.getDepartId())
.eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING));
//用于流程信息查询方法 where查询的范围参数
Set<String> processIdSet = new HashSet<>();
if (Common.isNotKong(thisDepartIdConfig)){
//将符合条件的流程id封装起来
processIdSet = thisDepartIdConfig.stream().map(TProcessApprovalConf::getProcessId).collect(Collectors.toSet());
tProcess.setProcessIds(processIdSet);
}else {
//若条件查到为0条,则下面获得流程信息也应为0条
processIdSet.add(CommonConstants.ZERO_STRING);
tProcess.setProcessIds(processIdSet);
}
} else {
thisDepartIdConfig = processApprovalConfService.list(Wrappers.<TProcessApprovalConf>query().lambda()
.eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING));
}
IPage<TProcessViewVo> tProcessPage = baseMapper.getTProcessPage(page, tProcess, type);
List<TProcessViewVo> records = tProcessPage.getRecords();
if(Common.isEmpty(records)) {
return tProcessPage;
}
//合同和部门用章单位
//获取所有流程id的数据
//key: 流程, value:部门
Map<String, Set<String>> departIdTypeMap=Maps.newHashMap();
//key: 流程, value:流程类型
Map<String, String> processTypeMap=Maps.newHashMap();
//key: 流程, value:用章单位
Map<String, Set<String>> chapterUnitTypeMap=Maps.newHashMap();
if (Common.isNotKong(thisDepartIdConfig)) {
for (TProcessApprovalConf processApprovalConf : thisDepartIdConfig) {
processTypeMap.put(processApprovalConf.getProcessId(),processApprovalConf.getType());
//部门类型
if (departIdType.contains(processApprovalConf.getType())) {
Set<String> processDepartSet = departIdTypeMap.get(processApprovalConf.getProcessId());
if (processDepartSet == null) {
processDepartSet = Sets.newHashSet();
processDepartSet.add(processApprovalConf.getFieldValue());
departIdTypeMap.put(processApprovalConf.getProcessId(), processDepartSet);
} else {
processDepartSet.add(processApprovalConf.getFieldValue());
}
}
//用章单位类型
if (chapterUnitType.contains(processApprovalConf.getType())) {
Set<String> processChapterUnitSet = chapterUnitTypeMap.get(processApprovalConf.getProcessId());
if (processChapterUnitSet == null) {
processChapterUnitSet = Sets.newHashSet();
processChapterUnitSet.add(processApprovalConf.getFieldValue());
chapterUnitTypeMap.put(processApprovalConf.getProcessId(), processChapterUnitSet);
} else {
processChapterUnitSet.add(processApprovalConf.getFieldValue());
}
}
}
}
for (TProcessViewVo record :records) {
record.setType(processTypeMap.get(record.getId()));
Set<String> strings = departIdTypeMap.get(record.getId());
record.setDepartIds(departIdTypeMap.get(record.getId()));
record.setChapterUnits(chapterUnitTypeMap.get(record.getId()));
}
return tProcessPage;
}
/**
* @param id
* @Description: 获取包装类
* @Author: hgw
* @Date: 2020/7/17 11:05
* @return: ProcessVo
**/
@Override
public ProcessVo getProcessVoById(String id) {
// 主流程表
ProcessVo processVo = new ProcessVo();
if (Boolean.TRUE.equals(Common.isEmpty(id))) {
return processVo;
}
processVo.setProcessId(id);
// 节点
TProcessNode processNode = new TProcessNode();
processNode.setProcessId(id);
// 节点查询
QueryWrapper<TProcessNode> queryWrapperPn = new QueryWrapper<>();
queryWrapperPn.setEntity(processNode);
// 节点列表
List<TProcessNode> processNodeList = processNodeService.list(queryWrapperPn);
if (processNodeList != null && !processNodeList.isEmpty()) {
// 权限
TNodePrimission nodePrimission;
// 权限查询
QueryWrapper<TNodePrimission> queryWrapperNp;
// 权限列表
List<TNodePrimission> nodePrimissionList;
// 抄送
TNodeReaderPromission nodeReaderPromission;
// 抄送查询
QueryWrapper<TNodeReaderPromission> queryWrapperNrp;
// 抄送列表
List<TNodeReaderPromission> nodeReaderPromissionList;
for (TProcessNode proNode : processNodeList) {
nodePrimission = new TNodePrimission();
nodePrimission.setNodeId(proNode.getId());
queryWrapperNp = new QueryWrapper<>();
queryWrapperNp.setEntity(nodePrimission);
nodePrimissionList = nodePrimissionService.list(queryWrapperNp);
proNode.setNodePrimissionList(nodePrimissionList);
nodeReaderPromission = new TNodeReaderPromission();
nodeReaderPromission.setNodeId(proNode.getId());
queryWrapperNrp = new QueryWrapper<>();
queryWrapperNrp.setEntity(nodeReaderPromission);
nodeReaderPromissionList = nodeReaderPromissionService.list(queryWrapperNrp);
proNode.setNodeReaderPromissionList(nodeReaderPromissionList);
//子流程
proNode.setNodeTransferConfigs(nodeTransferConfigService.list(Wrappers.<TNodeTransferConfig>query().lambda().eq(TNodeTransferConfig::getNodeId, proNode.getId())));
}
}
processVo.setProcessNodeList(processNodeList);
// 路由
TNodeRoute nodeRoute = new TNodeRoute();
nodeRoute.setProcessId(id);
// 路由查询
QueryWrapper<TNodeRoute> queryWrapperNr = new QueryWrapper<>();
queryWrapperNr.setEntity(nodeRoute);
// 路由列表
List<TNodeRoute> nodeRouteList = nodeRouteService.list(queryWrapperNr);
//路由条件
for (TNodeRoute tNodeRoute : nodeRouteList) {
tNodeRoute.setNodeRouteConditionList(nodeRouteConditionService.list(Wrappers.<TNodeRouteCondition>query().lambda().eq(TNodeRouteCondition::getNodeRouteId,tNodeRoute.getId())));
}
processVo.setNodeRouteList(nodeRouteList);
return processVo;
}
/**
* @param processId
* @Description: 获取包装类
* @Author: hgw
* @Date: 2020/7/17 11:05
* @return: ProcessVo
**/
@Override
public R<ProcessVo> getProcessVoByName(String processId) {
// 主流程表
ProcessVo processVo = new ProcessVo();
TProcess process = this.getById(processId);
if (process == null) {
return R.failed("获取流程失败");
}
processVo.setProcessId(processId);
processVo.setName(process.getName());
// 节点
TProcessNode processNode = new TProcessNode();
processNode.setProcessId(processId);
// 节点查询
QueryWrapper<TProcessNode> queryWrapperPn = new QueryWrapper<>();
queryWrapperPn.setEntity(processNode);
// 节点列表
List<TProcessNode> processNodeList = processNodeService.list(queryWrapperPn);
if (processNodeList != null && !processNodeList.isEmpty()) {
// 权限
TNodePrimission nodePrimission;
// 权限查询
QueryWrapper<TNodePrimission> queryWrapperNp;
// 权限列表
List<TNodePrimission> nodePrimissionList;
// 抄送
TNodeReaderPromission nodeReaderPromission;
// 抄送查询
QueryWrapper<TNodeReaderPromission> queryWrapperNrp;
// 抄送列表
List<TNodeReaderPromission> nodeReaderPromissionList;
for (TProcessNode proNode : processNodeList) {
nodePrimission = new TNodePrimission();
nodePrimission.setNodeId(proNode.getId());
queryWrapperNp = new QueryWrapper<>();
queryWrapperNp.setEntity(nodePrimission);
nodePrimissionList = nodePrimissionService.list(queryWrapperNp);
proNode.setNodePrimissionList(nodePrimissionList);
nodeReaderPromission = new TNodeReaderPromission();
nodeReaderPromission.setNodeId(proNode.getId());
queryWrapperNrp = new QueryWrapper<>();
queryWrapperNrp.setEntity(nodeReaderPromission);
nodeReaderPromissionList = nodeReaderPromissionService.list(queryWrapperNrp);
proNode.setNodeReaderPromissionList(nodeReaderPromissionList);
//子流程
proNode.setNodeTransferConfigs(nodeTransferConfigService.list(Wrappers.<TNodeTransferConfig>query().lambda().eq(TNodeTransferConfig::getNodeId, proNode.getId())));
}
}
processVo.setProcessNodeList(processNodeList);
// 路由
TNodeRoute nodeRoute = new TNodeRoute();
nodeRoute.setProcessId(processId);
// 路由查询
QueryWrapper<TNodeRoute> queryWrapperNr = new QueryWrapper<>();
queryWrapperNr.setEntity(nodeRoute);
// 路由列表
List<TNodeRoute> nodeRouteList = nodeRouteService.list(queryWrapperNr);
for (TNodeRoute tNodeRoute : nodeRouteList) { tNodeRoute.setNodeRouteConditionList(nodeRouteConditionService.list(Wrappers.<TNodeRouteCondition>query().lambda().eq(TNodeRouteCondition::getNodeRouteId,tNodeRoute.getId())));
}
processVo.setNodeRouteList(nodeRouteList);
return new R<>(processVo);
}
/**
* @param processVo 流程VO
* @Description: 保存流程
* @Author: hgw
* @Date: 2020/7/17 11:14
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R
**/
@Override
@Transactional
public R saveProcessVo(ProcessVo processVo) {
// 主流程表
if (Boolean.TRUE.equals(Common.isEmpty(processVo.getProcessId()))) {
return R.failed("流程id不可为空!");
}
// 流程id
String processId = processVo.getProcessId();
// 删除之前保存的且被删掉的节点、线、权限、抄送
this.deleteIds(processVo.getDeleteIdsVo());
// 用户
YifuUser user = SecurityUtils.getUser();
// 用户id
String userId = String.valueOf(user.getId());
// 当前时间
LocalDateTime nowTime = LocalDateTime.now();
// 保存流程节点
if (processVo.getProcessNodeList() != null) {
// 循环节点
R err = saveOrUpdateNode(processVo, processId);
if (Common.isNotKong(err)){
return err;
}
}
// 保存节点路由
if (processVo.getNodeRouteList() != null && !processVo.getNodeRouteList().isEmpty()) {
//crm2.12.0 保存之前先进行校验 配置保存的时候验证同一个节点相同路由条件不能指向不同的节点
R r = saveBeforeCheck(processVo);
if (Common.isNotKong(r)){
return r;
}
saveOrUpdateRoute(processVo, processId, userId, nowTime);
}
return R.ok("保存成功");
}
/**
* @param processVo 流程vo
* @param processId 流程id
* @param userId 用户id
* @param nowTime 当前时间
* @Description: 保存线
* @Author: hgw
* @Date: 2020/7/27 14:12
* @return: void
**/
private void saveOrUpdateRoute(ProcessVo processVo, String processId, String userId, LocalDateTime nowTime) {
for (TNodeRoute nodeRoute : processVo.getNodeRouteList()) {
nodeRoute.setProcessId(processId);
if (Boolean.TRUE.equals(Common.isNotKong(nodeRoute.getId()))) {
nodeRoute.setUpdateDate(nowTime);
nodeRoute.setUpdateUser(userId);
nodeRouteService.updateById(nodeRoute);
} else {
nodeRoute.setCreateDate(nowTime);
nodeRoute.setCreateUser(userId);
nodeRouteService.save(nodeRoute);
}
saveOrUpdateRouteCondition(nodeRoute);
}
}
/**
* 功能描述: 校验同一个节点相同路由条件不能指向不同的节点
* @Param: []
* @Return: void
* @Author: wangdayu
* @Date: 2023/10/25 15:10
* @Since:
*/
private R saveBeforeCheck(ProcessVo processVo) {
List<CheckNodeVo> checkList = new ArrayList<>();
for (TNodeRoute tNodeRoute : processVo.getNodeRouteList()) {
//将需要的信息封装起来
CheckNodeVo one = new CheckNodeVo();
one.setProcessId(tNodeRoute.getProcessId());
one.setPrewNode(tNodeRoute.getPrewNode());
one.setNextNode(tNodeRoute.getNextNode());
one.setLogoTitle(tNodeRoute.getLogoTitle());
if (Common.isNotKong(tNodeRoute.getNodeRouteConditionList())) {
for (TNodeRouteCondition tNodeRouteCondition : tNodeRoute.getNodeRouteConditionList()) {
one.setNodeRouteId(tNodeRouteCondition.getNodeRouteId());
one.setField(tNodeRouteCondition.getField());
}
}
checkList.add(one);
}
if (Common.isNotKong(checkList)){
Map<String, List<CheckNodeVo>> groupMap = checkList.stream()
.collect(
Collectors.groupingBy(CheckNodeVo::getPrewNode));
if (Common.isNotKong(groupMap)) {
for (String key : groupMap.keySet()) {
List<CheckNodeVo> checkNodeVoList = groupMap.get(key);
for (CheckNodeVo checkNodeVo : checkNodeVoList) {
for (CheckNodeVo nodeVo : checkNodeVoList) {
//位置重合路由
if (Common.isNotKong(checkNodeVo.getPrewNode())
&& Common.isNotKong(nodeVo.getPrewNode())
&& !StringUtils.equals(checkNodeVo.getLogoTitle(),nodeVo.getLogoTitle())
&& StringUtils.equals(checkNodeVo.getPrewNode(),nodeVo.getPrewNode())
&& StringUtils.equals(checkNodeVo.getNextNode(),nodeVo.getNextNode())){
return R.failed("存在重合路由!");
}
//如果表达式相同且后置节点相同,跳过,否则抛出异常
if (Common.isNotKong(checkNodeVo.getField()) && Common.isNotKong(nodeVo.getField())) {
if (checkNodeVo.getField().equals(nodeVo.getField())) {
if (Common.isNotKong(checkNodeVo.getNextNode())
&& Common.isNotKong(nodeVo.getNextNode())
&& !checkNodeVo.getNextNode().equals(nodeVo.getNextNode())) {
return R.failed("存在相同表达式路由指向不同节点!");
}
}
}
}
}
}
}
}
return null;
}
/**
* 保存路由条件
* @param nodeRoute
*/
private void saveOrUpdateRouteCondition(TNodeRoute nodeRoute){
List<TNodeRouteCondition> nodeRouteConditionList = nodeRoute.getNodeRouteConditionList();
if(nodeRouteConditionList!=null) {
for (TNodeRouteCondition nodeRouteCondition : nodeRouteConditionList) {
nodeRouteCondition.setNodeRouteId(nodeRoute.getId());
nodeRouteConditionService.saveOrUpdate(nodeRouteCondition);
}
}
}
/**
* @param processVo 流程vo
* @param processId 流程id
* @Description: 保存节点
* @Author: hgw
* @Date: 2020/7/27 14:11
* @return: void
**/
private R saveOrUpdateNode(ProcessVo processVo, String processId) {
//保存之前先进行节点重合判断
String flag = saveBeforeCheckoverlap(processVo.getProcessNodeList());
if (Common.isNotKong(flag)){
return R.failed(flag);
}
for (TProcessNode processNode : processVo.getProcessNodeList()) {
processNode.setProcessId(processId);
if (Boolean.TRUE.equals(Common.isNotKong(processNode.getId()))) {
processNodeService.updateById(processNode);
} else {
processNodeService.save(processNode);
}
saveNodePromission(processId, processNode);
saveNodeReaderPromission(processId, processNode);
saveOrUpdateNodeTransferConfigs(processNode);
}
return null;
}
/**
* 功能描述: 保存节点前先进行做坐标重合判断
* @Param: [processNodeList]
* @Return: java.lang.Boolean
* @Author: wangdayu
* @Date: 2023/10/31 14:26
* @Since:
*/
private String saveBeforeCheckoverlap(List<TProcessNode> processNodeList) {
if (Common.isNotKong(processNodeList)){
for (TProcessNode first : processNodeList) {
for (TProcessNode second : processNodeList) {
if (Common.isNotKong(first.getLogoTitle())
&&Common.isNotKong(second.getLogoTitle())
&&!first.getLogoTitle().equals(second.getLogoTitle())){
//这里和前端保持一致逻辑,坐标差值在5以内,判定为重复节点
if (Math.abs(Double.valueOf(first.getCoordinatex()) - Double.valueOf(second.getCoordinatex())) <Double.valueOf(CommonConstants.FIVE_STRING)
&& Math.abs(Double.valueOf(first.getCoordinatey()) - Double.valueOf(second.getCoordinatey()))<Double.valueOf(CommonConstants.FIVE_STRING)){
return "存在节点位置重复";
}
}
}
}
Set<String> logoTitleSet = processNodeList.stream().map(TProcessNode::getLogoTitle).collect(Collectors.toSet());
if (processNodeList.size() != logoTitleSet.size()){
return "存在节点标志重复";
}
}
return CommonConstants.EMPTY_STRING;
}
/**
* 保存子流程
* @param processNode
*/
private void saveOrUpdateNodeTransferConfigs(TProcessNode processNode){
List<TNodeTransferConfig> nodeRouteConditionList = processNode.getNodeTransferConfigs();
if(nodeRouteConditionList!=null) {
for (TNodeTransferConfig nodeTransferConfig : nodeRouteConditionList) {
nodeTransferConfig.setNodeId(processNode.getId());
nodeTransferConfigService.saveOrUpdate(nodeTransferConfig);
}
}
}
/**
* @param deleteIdsVo 需要删除的ids
* @Description: 删除流程内的相关
* @Author: hgw
* @Date: 2020/7/27 11:10
* @return: void
**/
private void deleteIds(DeleteProcessIdsVo deleteIdsVo) {
if (deleteIdsVo != null) {
// 删除子流程节点
deleteNodeTransferConfig(deleteIdsVo);
// 删除线权限
deleteRoteCondition(deleteIdsVo);
// 删除权限
deletePrimission(deleteIdsVo);
// 删除抄送
deleteReadPrimission(deleteIdsVo);
// 删除节点路由
deleteRoute(deleteIdsVo);
// 删除流程节点
deleteNode(deleteIdsVo);
}
}
/**
* @param deleteIdsVo 删除id
* @Description: 删除流程节点
* @Author: hgw
* @Date: 2020/7/27 11:26
* @return: void
**/
private void deleteNode(DeleteProcessIdsVo deleteIdsVo) {
if (Boolean.TRUE.equals(Common.isNotKong(deleteIdsVo.getNodeIds()))
&& deleteIdsVo.getNodeIds().length > 0) {
for (String id : deleteIdsVo.getNodeIds()) {
processNodeService.removeById(id);
}
}
}
/**
* 删除子流程
* @param deleteIdsVo
*/
private void deleteNodeTransferConfig(DeleteProcessIdsVo deleteIdsVo) {
if (Boolean.TRUE.equals(Common.isNotKong(deleteIdsVo.getNodeTransferConfigIds()))
&& deleteIdsVo.getNodeTransferConfigIds().length > 0) {
for (String id : deleteIdsVo.getNodeTransferConfigIds()) {
nodeTransferConfigService.removeById(id);
}
}
}
/**
* @param deleteIdsVo 删除id
* @Description: 删除线
* @Author: hgw
* @Date: 2020/7/27 11:26
* @return: void
**/
private void deleteRoute(DeleteProcessIdsVo deleteIdsVo) {
if (Boolean.TRUE.equals(Common.isNotKong(deleteIdsVo.getRoteIds()))
&& deleteIdsVo.getRoteIds().length > 0) {
for (String id : deleteIdsVo.getRoteIds()) {
nodeRouteService.removeById(id);
}
}
}
/**
* @param deleteIdsVo 删除id
* @Description: 删除线权限id
* @Author: hgw
* @Date: 2020/7/27 11:26
* @return: void
**/
private void deleteRoteCondition(DeleteProcessIdsVo deleteIdsVo) {
if (Boolean.TRUE.equals(Common.isNotKong(deleteIdsVo.getRoteConditionIds()))
&& deleteIdsVo.getRoteConditionIds().length > 0) {
for (String id : deleteIdsVo.getRoteConditionIds()) {
nodeRouteConditionService.removeById(id);
}
}
}
/**
* @param deleteIdsVo 删除id
* @Description: 删除抄送
* @Author: hgw
* @Date: 2020/7/27 11:26
* @return: void
**/
private void deleteReadPrimission(DeleteProcessIdsVo deleteIdsVo) {
if (Boolean.TRUE.equals(Common.isNotKong(deleteIdsVo.getReadPrimissionIds()))
&& deleteIdsVo.getReadPrimissionIds().length > 0) {
for (String id : deleteIdsVo.getReadPrimissionIds()) {
nodeReaderPromissionService.removeById(id);
}
}
}
/**
* @param deleteIdsVo 删除id
* @Description: 删除权限
* @Author: hgw
* @Date: 2020/7/27 11:26
* @return: void
**/
private void deletePrimission(DeleteProcessIdsVo deleteIdsVo) {
if (Boolean.TRUE.equals(Common.isNotKong(deleteIdsVo.getPrimissionIds()))
&& deleteIdsVo.getPrimissionIds().length > 0) {
for (String id : deleteIdsVo.getPrimissionIds()) {
nodePrimissionService.removeById(id);
}
}
}
/**
* @param processId 流程id
* @param processNode 节点
* @Description: 保存抄送
* @Author: hgw
* @Date: 2020/7/24 20:18
* @return: void
**/
private void saveNodeReaderPromission(String processId, TProcessNode processNode) {
if (processNode.getNodeReaderPromissionList() != null) {
for (TNodeReaderPromission nodeReaderPrimission : processNode.getNodeReaderPromissionList()) {
nodeReaderPrimission.setProcessId(processId);
nodeReaderPrimission.setNodeId(processNode.getId());
if (Boolean.TRUE.equals(Common.isNotKong(nodeReaderPrimission.getId()))) {
nodeReaderPromissionService.updateById(nodeReaderPrimission);
} else {
nodeReaderPromissionService.save(nodeReaderPrimission);
}
}
}
}
/**
* @param processId 流程id
* @param processNode 节点
* @Description: 保存权限
* @Author: hgw
* @Date: 2020/7/24 20:19
* @return: void
**/
private void saveNodePromission(String processId, TProcessNode processNode) {
if (processNode.getNodePrimissionList() != null) {
for (TNodePrimission nodePrimission : processNode.getNodePrimissionList()) {
nodePrimission.setProcessId(processId);
nodePrimission.setNodeId(processNode.getId());
if (Boolean.TRUE.equals(Common.isNotKong(nodePrimission.getId()))) {
nodePrimissionService.updateById(nodePrimission);
} else {
nodePrimissionService.save(nodePrimission);
}
}
}
}
/**
* @param processId 流程id
* @Description: 删除流程以及节点、路由
* @Author: hgw
* @Date: 2020/7/17 17:22
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R
**/
@Override
public R deleteById(String processId) {
if (Boolean.TRUE.equals(Common.isEmpty(processId))) {
return R.failed("流程id不可为空!");
}
// 删除节点路由
nodeRouteService.deleteByProcessId(processId);
// 删除流程节点
processNodeService.deleteByProcessId(processId);
// 主流程表
this.removeById(processId);
return R.ok("删除成功");
}
/**
* @param vo
* @Author: wangan
* @Date: 2021/6/16
* @Description: 根据不同类型判断是
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R
* @see com.yifu.cloud.plus.v1.process.service.impl
* 类型 1客户合同审批 2客户合同办理 3客户合同归档 4垫付 5crm客户审批
* 如果类型非 合同办理和合同归档,则判断部门
* 如果类型为 合同办理和合同归档,为用章档案
* 如果数据为空。则直接过,为了兼容hr页面
**/
@Override
@Transactional
public R<String> add(TProcessViewVo vo) {
TProcess tProcess = new TProcess();
BeanCopyUtils.copyProperties(vo, tProcess);
if (Common.isEmpty(vo.getProcessIsUse())){
//设置默认在用
tProcess.setProcessIsUse(CommonConstants.ZERO_STRING);
}
if (Common.isNotKong(vo.getType())) {
// 若选则了通用
//if (CommonConstants.ZERO_STRING.equals(vo.getCommonUse())){
return commonUseSave(vo, tProcess);
// } else {
// // 1.7.5 只留通用流程
// if (departIdType.contains(vo.getType())) {
// return addDepartConfs(vo, tProcess);
// } else {
// return R.failCheckGeneric("未知的类型", CommonConstants.NULL);
// }
// }
} else {
this.save(tProcess);
return R.ok(CommonConstants.NULL,ResultConstants.SUCCESS_INFO);
}
}
/**
* @param vo
* @Author: wangan
* @Date: 2021/6/16
* @Description: 修改
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<java.lang.String>
* @see com.yifu.cloud.plus.v1.process.service.impl
* 新增逻辑不变。增加删除逻辑
**/
@Override
@Transactional
public R<String> modify(TProcessViewVo vo) {
TProcess tProcess = new TProcess();
BeanCopyUtils.copyProperties(vo, tProcess);
if (Common.isNotKong(vo.getType())) {
// todo 1.7.5 只留通用流程若选则了通用
//if (CommonConstants.ZERO_STRING.equals(vo.getCommonUse())){
return commonUseSave(vo, tProcess);
//}
// if (departIdType.contains(vo.getType())) {
// if (vo.getDepartIds()!=null && !vo.getDepartIds().isEmpty()) {
// R<String> addDepartConfsR = addDepartConfs(vo, tProcess);
// if(addDepartConfsR==null ||addDepartConfsR.getCode()!=CommonConstants.SUCCESS){
// throw new CheckedException(addDepartConfsR.getMsg());
// }
// }
// if(vo.getDelDepartIds()!=null && !vo.getDelDepartIds().isEmpty()){
// //删除部门配置
// processApprovalConfService.remove(Wrappers.<TProcessApprovalConf>query().lambda()
// .eq(TProcessApprovalConf::getType, vo.getType()).eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING)
// .in(TProcessApprovalConf::getFieldValue, vo.getDelDepartIds()));
// }
// this.updateById(tProcess);
// return R.successCheckGeneric(ResultConstants.SUCCESS_INFO,CommonConstants.NULL);
// } else {
// return R.failCheckGeneric("未知的类型", CommonConstants.NULL);
// }
} else {
this.updateById(tProcess);
return R.ok(CommonConstants.NULL,ResultConstants.SUCCESS_INFO);
}
}
/**
* @param id
* @Author: wangan
* @Date: 2021/6/18
* @Description: 数据都重置为假删除
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<java.lang.String>
* @see com.yifu.cloud.plus.v1.process.service.impl
**/
@Override
public R<String> delete(String id) {
TProcess process = this.getById(id);
if (process == null) {
return R.failed(CommonConstants.NULL,ResultConstants.FAIL_INFO_NO_MODEL);
}
//更新配置表为删除
TProcessApprovalConf processApprovalConf = new TProcessApprovalConf();
processApprovalConf.setDeleteFlag(CommonConstants.DELETE_FLAG);
processApprovalConfService.update(processApprovalConf,Wrappers.<TProcessApprovalConf>query().lambda()
.eq(TProcessApprovalConf::getProcessId,id));
//更新流程表为删除
process.setDeleteFlag(CommonConstants.DELETE_FLAG);
this.updateById(process);
return R.ok(CommonConstants.NULL,ResultConstants.SUCCESS_INFO);
}
/**
* @param vo
* @param tProcess
* @Author: wangdayu
* @Date: 2023年10月27日10:45
* @Description: 通用流程保存逻辑
* @return: com.yifu.cloud.plus.v1.yifu.common.core.util.R<java.lang.String>
* @see com.yifu.cloud.plus.v1.process.service.impl
**/
private R<String> commonUseSave(TProcessViewVo vo, TProcess tProcess) {
LambdaQueryWrapper<TProcessApprovalConf> query = new LambdaQueryWrapper<>();
//获取该类型下面的通用流程配置,并判断当前类型的流程是否是在用流程,若是,则提示重复,否则正常保存
query.eq(TProcessApprovalConf::getType, vo.getType())
.eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING)
.and(wq -> wq.isNull(TProcessApprovalConf::getFieldValue).or()
.eq(TProcessApprovalConf::getFieldValue, CommonConstants.EMPTY_STRING));
List<TProcessApprovalConf> commonProcess = processApprovalConfService.list(query);
//存在该类型的流程配置
if (Common.isNotKong(commonProcess)) {
Boolean inUse = judgeInuse(commonProcess);
if (inUse) {
if (Common.isEmpty(vo.getId())){
return R.failed("当前流程类型存在正在使用的流程");
}
}
}
//删除部门配置
processApprovalConfService.remove(Wrappers.<TProcessApprovalConf>query().lambda()
.eq(TProcessApprovalConf::getType, vo.getType())
.eq(TProcessApprovalConf::getProcessId,vo.getId())
.eq(TProcessApprovalConf::getDeleteFlag, CommonConstants.ZERO_STRING));
//校验通过后插入数据
if(Common.isEmpty(vo.getId())) {
//如果没有id则是新增
this.save(tProcess);
}
TProcessApprovalConf processApprovalConf = new TProcessApprovalConf();
processApprovalConf.setType(vo.getType());
if (departIdType.contains(vo.getType())) {
processApprovalConf.setClassName("OrganizationInfo");
processApprovalConf.setFieldName("id");
} else if (chapterUnitType.contains(vo.getType())) {
processApprovalConf.setClassName("TCustomerContract");
processApprovalConf.setFieldName("chapterUnit");
}
processApprovalConf.setDeleteFlag(CommonConstants.ZERO_STRING);
processApprovalConf.setFieldValue(CommonConstants.EMPTY_STRING);
processApprovalConf.setParentId(CommonConstants.ZERO_STRING);
processApprovalConf.setProcessId(tProcess.getId());
processApprovalConf.setRemark(tProcess.getName());
processApprovalConfService.save(processApprovalConf);
this.updateById(tProcess);
return R.ok(CommonConstants.NULL,ResultConstants.SUCCESS_INFO);
}
/**
* 功能描述: 校验当前类型流程是否存在在用
* @Param: [processId]
* @Return: java.lang.Boolean
* @Author: wangdayu
* @Date: 2023/10/27 10:32
* @Since:
*/
private Boolean judgeInuse(List<TProcessApprovalConf> tprocessApprovalConf) {
if (Common.isNotKong(tprocessApprovalConf)) {
Set<String> processId = tprocessApprovalConf.stream().map(TProcessApprovalConf::getProcessId)
.collect(Collectors.toSet());
//在流程表里面判断是否是在用流程
List<TProcess> tProcesses = this.listByIds(processId);
if (Common.isNotKong(tProcesses)) {
Boolean inUseFlag = tProcesses.stream().anyMatch(
t -> (CommonConstants.ZERO_STRING.equals(t.getProcessIsUse())
&& CommonConstants.NOT_DELETE_FLAG.equals(t.getDeleteFlag())));
//若当前类型的流程配置存在在用,则提示重复
return inUseFlag;
}
}
return Boolean.FALSE;
}
@Override
public R<String> noUse(TProcess tProcess) {
//1.参数校验
if (Common.isEmpty(tProcess.getId())){
return R.failed("id不能为空");
}
//2.实体是否存在校验
TProcess process = this.getById(tProcess.getId());
if (Common.isEmpty(process)){
return R.failed(FAIL_INFO_NO_MODEL);
}
//3.修改条件封装:实体存在则进行状态修改
UpdateWrapper<TProcess> updateWrapper = new UpdateWrapper();
updateWrapper.lambda()
.eq(TProcess::getId,tProcess.getId())
.eq(TProcess::getDeleteFlag, CommonConstants.NOT_DELETE_FLAG)
.set(TProcess::getProcessIsUse,CommonConstants.ONE_STRING);
//4.返回结果
if (this.update(updateWrapper)){
return R.ok(ResultConstants.MODIFY_SUCCESS);
}
return R.failed(ResultConstants.MODIFY_FAIL);
}
/**
* 根据角色ID获取关联流程
*
* @param tProcess 审批角色
* @return IPage<TProcessViewVo>
* @author chenyuxi
* @date 2023-10-23 09:48:57
* @since crm2.12.0
*/
@Override
public IPage<TProcessViewVo> getProcessPageByRoleId(Page<TProcessViewVo> page, TProcessViewVo tProcess) {
Set<String> processIds = new HashSet<>();
// 查关联角色的流程ID
LambdaQueryWrapper<TNodePrimission> nodePrimissionQuery = Wrappers.<TNodePrimission>lambdaQuery()
.eq(TNodePrimission::getApprovalRole, tProcess.getRole())
.eq(TNodePrimission::getType, tProcess.getNodePermissionType());
List<TNodePrimission> nodePrimissionList = nodePrimissionService.list(nodePrimissionQuery);
if(Common.isNotKong(nodePrimissionList)) {
processIds = nodePrimissionList.stream().map(TNodePrimission::getProcessId).collect(Collectors.toSet());
}
// 查关联角色的抄送流程ID t_node_reader_promission
LambdaQueryWrapper<TNodeReaderPromission> nodeReaderPrimissionQuery = Wrappers.<TNodeReaderPromission>lambdaQuery()
.eq(TNodeReaderPromission::getApprovalRole, tProcess.getRole())
.eq(TNodeReaderPromission::getType, tProcess.getNodePermissionType());
List<TNodeReaderPromission> nodeReaderPrimissionList = nodeReaderPromissionService.list(nodeReaderPrimissionQuery);
if(Common.isNotKong(nodeReaderPrimissionList)) {
for(TNodeReaderPromission nodeReaderPromission : nodeReaderPrimissionList) {
processIds.add(nodeReaderPromission.getProcessId());
}
}
if(Common.isEmpty(processIds)) {
return null;
}
// 传流程ID集合查流程列表
tProcess.setProcessIds(processIds);
return this.getTProcessPage(page, tProcess,CommonConstants.ZERO_STRING);
}
@Override
public String checkProcessByRoleId(TProcessViewVo tProcess) {
LambdaQueryWrapper<TNodePrimission> nodePrimissionQuery = Wrappers.<TNodePrimission>lambdaQuery()
.eq(TNodePrimission::getApprovalRole, tProcess.getRole())
.eq(TNodePrimission::getType, tProcess.getNodePermissionType());
List<TNodePrimission> nodePrimissionList = nodePrimissionService.list(nodePrimissionQuery);
LambdaQueryWrapper<TNodeReaderPromission> nodeReaderPrimissionQuery = Wrappers.<TNodeReaderPromission>lambdaQuery()
.eq(TNodeReaderPromission::getApprovalRole, tProcess.getRole())
.eq(TNodeReaderPromission::getType, tProcess.getNodePermissionType());
List<TNodeReaderPromission> nodeReaderPrimissionList = nodeReaderPromissionService.list(nodeReaderPrimissionQuery);
if(nodePrimissionList.size() == 0 && nodeReaderPrimissionList.size() == 0) {
return CommonConstants.ZERO_STRING;
} else {
Set<String> processIds = new HashSet<>();
if(Common.isNotKong(nodePrimissionList)) {
processIds = nodePrimissionList.stream().map(TNodePrimission::getProcessId).collect(Collectors.toSet());
}
if(Common.isNotKong(nodeReaderPrimissionList)) {
for(TNodeReaderPromission nodeReaderPromission : nodeReaderPrimissionList) {
processIds.add(nodeReaderPromission.getProcessId());
}
}
// 检测关联的流程是否被删除
LambdaQueryWrapper<TProcess> processQuery = Wrappers.<TProcess>lambdaQuery()
.in(TProcess::getId, processIds)
.eq(TProcess::getDeleteFlag, CommonConstants.ZERO_STRING);
long processCount = this.count(processQuery);
if(processCount == 0) {
return CommonConstants.ZERO_STRING;
}
}
return CommonConstants.ONE_STRING;
}
}
package com.yifu.cloud.plus.v1.yifu.process.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yifu.cloud.plus.v1.yifu.process.entity.TServiceTransferConfig;
import com.yifu.cloud.plus.v1.yifu.process.service.TServiceTransferConfigService;
import com.yifu.cloud.plus.v1.yifu.process.mapper.TServiceTransferConfigMapper;
import org.springframework.stereotype.Service;
/**
* 远程服务调用(在节点为服务调用节点时使用)
*
* @author hgw
* @date 2020-07-16 15:44:02
*/
@Service
public class TServiceTransferConfigServiceImpl extends ServiceImpl<TServiceTransferConfigMapper, TServiceTransferConfig> implements TServiceTransferConfigService {
/**
* 远程服务调用(在节点为服务调用节点时使用)简单分页查询
*
* @param tServiceTransferConfig 远程服务调用(在节点为服务调用节点时使用)
* @return
*/
@Override
public IPage<TServiceTransferConfig> getTServiceTransferConfigPage(Page<TServiceTransferConfig> page, TServiceTransferConfig tServiceTransferConfig) {
return baseMapper.getTServiceTransferConfigPage(page, tServiceTransferConfig);
}
}
# 数据源配置
spring:
mvc:
pathmatch:
matching-strategy: ant_path_matcher
config:
activate:
on-profile: dev
redis:
host: 127.0.0.1
port: 6379
password: '@yf_2017'
datasource:
process:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: yf_zsk
jdbc-url: jdbc:mysql://192.168.1.65:43306/mvp_process?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowMultiQueries=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
hikari:
driver-class-name: ${spring.datasource.driver-class-name}
jdbc-url: ${spring.datasource.url}
username: ${spring.datasource.username}
password: ${spring.datasource.password}
pool-name: AmytangHikariCP
minimum-idle: 20 # 最小空闲连接数量
idle-timeout: 60000 # 空闲连接存活最大时间,默认600000(10分钟)
maximum-pool-size: 100 # 连接池最大连接数,默认是10
auto-commit: true #此属性控制从池返回的连接的默认自动提交行为,默认值:true
max-lifetime: 0 #此属性控制池中连接的最长生命周期,值0表示无限生命周期,默认1800000即30分钟
spring:
mvc:
pathmatch:
matching-strategy: ant_path_matcher
config:
activate:
on-profile: prd
redis:
host: 192.168.0.222
port: 22379
password: '@yf_2022'
datasource:
process:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: yf_zsk
jdbc-url: jdbc:mysql://192.168.0.222:22306/mvp_process?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowMultiQueries=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
hikari:
driver-class-name: ${spring.datasource.driver-class-name}
jdbc-url: ${spring.datasource.url}
username: ${spring.datasource.username}
password: ${spring.datasource.password}
pool-name: AmytangHikariCP
minimum-idle: 20 # 最小空闲连接数量
idle-timeout: 60000 # 空闲连接存活最大时间,默认600000(10分钟)
maximum-pool-size: 100 # 连接池最大连接数,默认是10
auto-commit: true #此属性控制从池返回的连接的默认自动提交行为,默认值:true
max-lifetime: 0 #此属性控制池中连接的最长生命周期,值0表示无限生命周期,默认1800000即30分钟
spring:
mvc:
pathmatch:
matching-strategy: ant_path_matcher
config:
activate:
on-profile: test
redis:
host: 192.168.1.65
port: 22379
password: '@yf_2017'
datasource:
process:
type: com.zaxxer.hikari.HikariDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: yf_zsk
jdbc-url: jdbc:mysql://192.168.1.65:43306/mvp_process?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowMultiQueries=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
hikari:
driver-class-name: ${spring.datasource.driver-class-name}
jdbc-url: ${spring.datasource.url}
username: ${spring.datasource.username}
password: ${spring.datasource.password}
pool-name: AmytangHikariCP
minimum-idle: 10 # 最小空闲连接数量
idle-timeout: 60000 # 空闲连接存活最大时间,默认600000(10分钟)
maximum-pool-size: 12 # 连接池最大连接数,默认是10
auto-commit: true #此属性控制从池返回的连接的默认自动提交行为,默认值:true
max-lifetime: 0 #此属性控制池中连接的最长生命周期,值0表示无限生命周期,默认1800000即30分钟
servlet:
multipart:
location: /data/tmp/
server:
port: 25087
# 加解密根密码
jasypt:
encryptor:
password: yifu #根密码
# 暴露监控端点
management:
endpoints:
web:
exposure:
include: "*"
endpoint:
health:
show-details: ALWAYS
# mybaits-plus配置
mybatis-plus:
mapper-locations: classpath:/mapper/*Mapper.xml
global-config:
banner: false
db-config:
id-type: auto
table-underline: true
logic-delete-value: 1
logic-not-delete-value: 0
configuration:
map-underscore-to-camel-case: true
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# spring security 配置
security:
oauth2:
resource:
loadBalanced: true
token-info-uri: http://yifu-auth/oauth/check_token
ignore: # 通用放行URL,服务个性化,请在对应配置文件覆盖
urls:
- /v3/api-docs
- /actuator/**
- /swagger-ui/**
# Spring 相关
spring:
application:
name: @artifactId@
#mvc:
# pathmatch:
# matching-strategy: ANT_PATH_MATCHER
servlet:
multipart:
#所有上传文件最大大小
max-request-size: 100MB
#单个文件最大大小
max-file-size: 50MB
springdoc:
api-docs:
#是否开启文档功能
enabled: true
#swagger后端请求地址
path: /api-docs
swagger-ui:
#自定义swagger前端请求路径,输入http:127.0.0.1:8080/test会自动重定向到swagger页面
path: /api
#包扫描路径
packages-to-scan: com.yifu.cloud.plus.v1.yifu.process.controller
#这里定义了两个分组,可定义多个,也可以不定义
group-configs:
#分组名
#- group: admin
#按路径匹配
# pathsToMatch: /admin/**
#分组名
- group: insurances
#按包路径匹配
packagesToScan: com.yifu.cloud.plus.v1.yifu.process.controller
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false" scan="false">
<springProperty scop="context" name="springAppName" source="spring.application.name" defaultValue=""/>
<springProperty scop="context" name="springAppActive" source="spring.profiles.active" defaultValue=""/>
<property name="log.path" value="logs/${springAppName}"/>
<!-- 彩色日志格式 -->
<property name="CONSOLE_LOG_PATTERN"
value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
<!-- 彩色日志依赖的渲染类 -->
<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
<conversionRule conversionWord="wex"
converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
<conversionRule conversionWord="wEx"
converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
<!-- Console log output -->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${CONSOLE_LOG_PATTERN}</pattern>
</encoder>
</appender>
<!-- Log file debug output -->
<appender name="debug" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${log.path}/debug.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<fileNamePattern>${log.path}/%d{yyyy-MM, aux}/debug.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
<maxFileSize>50MB</maxFileSize>
<maxHistory>30</maxHistory>
</rollingPolicy>
<encoder>
<pattern>%date [%thread] %-5level [%logger{50}] %file:%line - %msg%n</pattern>
</encoder>
</appender>
<!-- Log file error output -->
<appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${log.path}/error.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<fileNamePattern>${log.path}/%d{yyyy-MM}/error.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
<maxFileSize>50MB</maxFileSize>
<maxHistory>30</maxHistory>
</rollingPolicy>
<encoder>
<pattern>%date [%thread] %-5level [%logger{50}] %file:%line - %msg%n</pattern>
</encoder>
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>ERROR</level>
</filter>
</appender>
<!--邮件提醒-->
<appender name="MAIL" class="ch.qos.logback.classic.net.SMTPAppender">
<smtpHost>smtp.exmail.qq.com</smtpHost>
<smtpPort>465</smtpPort>
<username>information@wanxin-holdings.com</username>
<password>QmdCaQSPmCAQEddd</password>
<SSL>true</SSL>
<asynchronousSending>true</asynchronousSending>
<to>wangpeng@wanxin-holdings.com,fangxinjiang@wanxin-holdings.com,hongguangwu@wanxin-holdings.com</to>
<from>information@wanxin-holdings.com</from>
<subject>hro-mvp ${springAppActive}环境 ${springAppName}服务: %-20msg 错误</subject>
<charsetEncoding>UTF-8</charsetEncoding>
<cyclicBufferTracker class="ch.qos.logback.core.spi.CyclicBufferTracker">
<!-- &lt;!&ndash; 每个电子邮件只发送一个日志条目 &ndash;&gt;-->
<bufferSize>1</bufferSize>
</cyclicBufferTracker>
<layout class="ch.qos.logback.classic.html.HTMLLayout"/>
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>ERROR</level>
</filter>
</appender>
<springProfile name="prd">
<root level="error">
<appender-ref ref="console"/>
<appender-ref ref="debug"/>
<appender-ref ref="error"/>
<appender-ref ref="MAIL"/>
</root>
</springProfile>
<springProfile name="dev">
<root level="error">
<appender-ref ref="console"/>
<appender-ref ref="debug"/>
<appender-ref ref="error"/>
</root>
</springProfile>
<springProfile name="test">
<!-- Level: FATAL 0 ERROR 3 WARN 4 INFO 6 DEBUG 7 -->
<root level="info">
<appender-ref ref="console"/>
<appender-ref ref="debug"/>
<appender-ref ref="error"/>
</root>
</springProfile>
</configuration>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TDelayNodeConfigMapper">
<resultMap id="tDelayNodeConfigMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TDelayNodeConfig">
<id property="id" column="ID"/>
<result property="delayType" column="DELAY_TYPE"/>
<result property="minutes" column="MINUTES"/>
<result property="time" column="TIME"/>
<result property="nodeId" column="NODE_ID"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.DELAY_TYPE,
a.MINUTES,
a.TIME,
a.NODE_ID
</sql>
<sql id="tDelayNodeConfig_where">
<if test="tDelayNodeConfig != null">
<if test="tDelayNodeConfig.id != null and tDelayNodeConfig.id.trim() != ''">
AND a.ID = #{tDelayNodeConfig.id}
</if>
<if test="tDelayNodeConfig.delayType != null and tDelayNodeConfig.delayType.trim() != ''">
AND a.DELAY_TYPE = #{tDelayNodeConfig.delayType}
</if>
<if test="tDelayNodeConfig.minutes != null">
AND a.MINUTES = #{tDelayNodeConfig.minutes}
</if>
<if test="tDelayNodeConfig.time != null">
AND a.TIME = #{tDelayNodeConfig.time}
</if>
<if test="tDelayNodeConfig.nodeId != null and tDelayNodeConfig.nodeId.trim() != ''">
AND a.NODE_ID = #{tDelayNodeConfig.nodeId}
</if>
</if>
</sql>
<!--tDelayNodeConfig简单分页查询-->
<select id="getTDelayNodeConfigPage" resultMap="tDelayNodeConfigMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_delay_node_config a
<where>
1=1
<include refid="tDelayNodeConfig_where"/>
</where>
</select>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TNodeConfigMapper">
<resultMap id="tNodeConfigMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TNodeConfig">
<id property="id" column="ID"/>
<result property="allowWithdraw" column="ALLOW_WITHDRAW"/>
<result property="allowBacktrack" column="ALLOW_BACKTRACK"/>
<result property="allowDealRemind" column="ALLOW_DEAL_REMIND"/>
<result property="nodeId" column="NODE_ID"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.ALLOW_WITHDRAW,
a.ALLOW_BACKTRACK,
a.ALLOW_DEAL_REMIND,
a.NODE_ID
</sql>
<sql id="tNodeConfig_where">
<if test="tNodeConfig != null">
<if test="tNodeConfig.id != null and tNodeConfig.id.trim() != ''">
AND a.ID = #{tNodeConfig.id}
</if>
<if test="tNodeConfig.allowWithdraw != null and tNodeConfig.allowWithdraw.trim() != ''">
AND a.ALLOW_WITHDRAW = #{tNodeConfig.allowWithdraw}
</if>
<if test="tNodeConfig.allowBacktrack != null and tNodeConfig.allowBacktrack.trim() != ''">
AND a.ALLOW_BACKTRACK = #{tNodeConfig.allowBacktrack}
</if>
<if test="tNodeConfig.allowDealRemind != null and tNodeConfig.allowDealRemind.trim() != ''">
AND a.ALLOW_DEAL_REMIND = #{tNodeConfig.allowDealRemind}
</if>
<if test="tNodeConfig.nodeId != null and tNodeConfig.nodeId.trim() != ''">
AND a.NODE_ID = #{tNodeConfig.nodeId}
</if>
</if>
</sql>
<!--tNodeConfig简单分页查询-->
<select id="getTNodeConfigPage" resultMap="tNodeConfigMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_node_config a
<where>
1=1
<include refid="tNodeConfig_where"/>
</where>
</select>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TNodePrimissionMapper">
<resultMap id="tNodePrimissionMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TNodePrimission">
<id property="id" column="ID"/>
<result property="user" column="USER"/>
<result property="role" column="ROLE"/>
<result property="post" column="POST"/>
<result property="organization" column="ORGANIZATION"/>
<result property="realationCreateUser" column="REALATION_CREATE_USER"/>
<result property="logoTitle" column="LOGO_TITLE"/>
<result property="nodeId" column="NODE_ID"/>
<result property="dealType" column="DEAL_TYPE"/>
<result property="processId" column="PROCESS_ID"/>
<result property="nodeLogoTitle" column="NODE_LOGO_TITLE"/>
<result property="type" column="TYPE"/>
<result property="approvalRole" column="approval_role"/>
<result property="divisionIdentification" column="division_identification"/>
<result property="isPass" column="is_pass"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.USER,
a.ROLE,
a.POST,
a.ORGANIZATION,
a.REALATION_CREATE_USER,
a.LOGO_TITLE,
a.NODE_ID,
a.DEAL_TYPE,
a.PROCESS_ID,
a.NODE_LOGO_TITLE,
a.TYPE,
a.approval_role,
a.division_identification,
a.is_pass
</sql>
<sql id="tNodePrimission_where">
<if test="tNodePrimission != null">
<if test="tNodePrimission.id != null and tNodePrimission.id.trim() != ''">
AND a.ID = #{tNodePrimission.id}
</if>
<if test="tNodePrimission.user != null and tNodePrimission.user.trim() != ''">
AND a.USER = #{tNodePrimission.user}
</if>
<if test="tNodePrimission.role != null and tNodePrimission.role.trim() != ''">
AND a.ROLE = #{tNodePrimission.role}
</if>
<if test="tNodePrimission.post != null and tNodePrimission.post.trim() != ''">
AND a.POST = #{tNodePrimission.post}
</if>
<if test="tNodePrimission.organization != null and tNodePrimission.organization.trim() != ''">
AND a.ORGANIZATION = #{tNodePrimission.organization}
</if>
<if test="tNodePrimission.realationCreateUser != null and tNodePrimission.realationCreateUser.trim() != ''">
AND a.REALATION_CREATE_USER = #{tNodePrimission.realationCreateUser}
</if>
<if test="tNodePrimission.logoTitle != null and tNodePrimission.logoTitle.trim() != ''">
AND a.LOGO_TITLE = #{tNodePrimission.logoTitle}
</if>
<if test="tNodePrimission.nodeId != null and tNodePrimission.nodeId.trim() != ''">
AND a.NODE_ID = #{tNodePrimission.nodeId}
</if>
<if test="tNodePrimission.dealType != null and tNodePrimission.dealType.trim() != ''">
AND a.DEAL_TYPE = #{tNodePrimission.dealType}
</if>
<if test="tNodePrimission.approvalRole != null and tNodePrimission.approvalRole.trim() != ''">
AND a.approval_role = #{tNodePrimission.approvalRole}
</if>
</if>
</sql>
<!--tNodePrimission简单分页查询-->
<select id="getTNodePrimissionPage" resultMap="tNodePrimissionMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_node_primission a
<where>
1=1
<include refid="tNodePrimission_where"/>
</where>
</select>
<!--删除-->
<delete id="deleteByProcessId">
delete from t_node_primission where PROCESS_ID = #{processId}
</delete>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TNodeReaderPromissionMapper">
<resultMap id="tNodeReaderPromissionMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TNodeReaderPromission">
<id property="id" column="ID"/>
<result property="user" column="USER"/>
<result property="role" column="ROLE"/>
<result property="post" column="POST"/>
<result property="organization" column="ORGANIZATION"/>
<result property="realationCreateUser" column="REALATION_CREATE_USER"/>
<result property="logoTitle" column="LOGO_TITLE"/>
<result property="nodeId" column="NODE_ID"/>
<result property="processId" column="PROCESS_ID"/>
<result property="nodeLogoTitle" column="NODE_LOGO_TITLE"/>
<result property="type" column="TYPE"/>
<result property="approvalRole" column="approval_role"/>
<result property="customizeField" column="customize_field"/>
<result property="isCustomize" column="is_customize"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.USER,
a.ROLE,
a.POST,
a.ORGANIZATION,
a.REALATION_CREATE_USER,
a.LOGO_TITLE,
a.NODE_ID,
a.PROCESS_ID,
a.NODE_LOGO_TITLE,
a.TYPE,
a.approval_role,
a.customize_field,
a.is_customize
</sql>
<sql id="tNodeReaderPromission_where">
<if test="tNodeReaderPromission != null">
<if test="tNodeReaderPromission.id != null and tNodeReaderPromission.id.trim() != ''">
AND a.ID = #{tNodeReaderPromission.id}
</if>
<if test="tNodeReaderPromission.user != null and tNodeReaderPromission.user.trim() != ''">
AND a.USER = #{tNodeReaderPromission.user}
</if>
<if test="tNodeReaderPromission.role != null and tNodeReaderPromission.role.trim() != ''">
AND a.ROLE = #{tNodeReaderPromission.role}
</if>
<if test="tNodeReaderPromission.post != null and tNodeReaderPromission.post.trim() != ''">
AND a.POST = #{tNodeReaderPromission.post}
</if>
<if test="tNodeReaderPromission.organization != null and tNodeReaderPromission.organization.trim() != ''">
AND a.ORGANIZATION = #{tNodeReaderPromission.organization}
</if>
<if test="tNodeReaderPromission.realationCreateUser != null and tNodeReaderPromission.realationCreateUser.trim() != ''">
AND a.REALATION_CREATE_USER = #{tNodeReaderPromission.realationCreateUser}
</if>
<if test="tNodeReaderPromission.logoTitle != null and tNodeReaderPromission.logoTitle.trim() != ''">
AND a.LOGO_TITLE = #{tNodeReaderPromission.logoTitle}
</if>
<if test="tNodeReaderPromission.nodeId != null and tNodeReaderPromission.nodeId.trim() != ''">
AND a.NODE_ID = #{tNodeReaderPromission.nodeId}
</if>
</if>
</sql>
<!--tNodeReaderPromission简单分页查询-->
<select id="getTNodeReaderPromissionPage" resultMap="tNodeReaderPromissionMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_node_reader_promission a
<where>
1=1
<include refid="tNodeReaderPromission_where"/>
</where>
</select>
<!--删除-->
<delete id="deleteByProcessId">
delete from t_node_reader_promission where PROCESS_ID = #{processId}
</delete>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TNodeRouteConditionMapper">
<resultMap id="tNodeRouteConditionMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRouteCondition">
<id property="id" column="ID"/>
<result property="field" column="FIELD"/>
<result property="conditions" column="CONDITIONS"/>
<result property="conditionValue" column="CONDITION_VALUE"/>
<result property="realation" column="REALATION"/>
<result property="nodeRouteId" column="NODE_ROUTE_ID"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.FIELD,
a.CONDITIONS,
a.CONDITION_VALUE,
a.REALATION,
a.NODE_ROUTE_ID
</sql>
<sql id="tNodeRouteCondition_where">
<if test="tNodeRouteCondition != null">
<if test="tNodeRouteCondition.id != null and tNodeRouteCondition.id.trim() != ''">
AND a.ID = #{tNodeRouteCondition.id}
</if>
<if test="tNodeRouteCondition.field != null and tNodeRouteCondition.field.trim() != ''">
AND a.FIELD = #{tNodeRouteCondition.field}
</if>
<if test="tNodeRouteCondition.conditions != null and tNodeRouteCondition.conditions.trim() != ''">
AND a.CONDITIONS = #{tNodeRouteCondition.conditions}
</if>
<if test="tNodeRouteCondition.conditionValue != null and tNodeRouteCondition.conditionValue.trim() != ''">
AND a.CONDITION_VALUE = #{tNodeRouteCondition.conditionValue}
</if>
<if test="tNodeRouteCondition.realation != null and tNodeRouteCondition.realation.trim() != ''">
AND a.REALATION = #{tNodeRouteCondition.realation}
</if>
<if test="tNodeRouteCondition.nodeRouteId != null and tNodeRouteCondition.nodeRouteId.trim() != ''">
AND a.NODE_ROUTE_ID = #{tNodeRouteCondition.nodeRouteId}
</if>
</if>
</sql>
<!--tNodeRouteCondition简单分页查询-->
<select id="getTNodeRouteConditionPage" resultMap="tNodeRouteConditionMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_node_route_condition a
<where>
1=1
<include refid="tNodeRouteCondition_where"/>
</where>
</select>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TNodeRouteMapper">
<resultMap id="tNodeRouteMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TNodeRoute">
<id property="id" column="ID"/>
<result property="processId" column="PROCESS_ID"/>
<result property="prewNode" column="PREW_NODE"/>
<result property="nextNode" column="NEXT_NODE"/>
<result property="logoTitle" column="LOGO_TITLE"/>
<result property="createUser" column="CREATE_USER"/>
<result property="createDate" column="CREATE_DATE"/>
<result property="updateUser" column="UPDATE_USER"/>
<result property="updateDate" column="UPDATE_DATE"/>
<result property="name" column="NAME"/>
<result property="description" column="DESCRIPTION"/>
<result property="sequenceNo" column="SEQUENCE_NO"/>
<result property="opinion" column="OPINION"/>
<result property="opinionMustFlag" column="OPINION_MUST_FLAG"/>
<result property="routeType" column="ROUTE_TYPE"/>
<result property="priorityFlag" column="PRIORITY_FLAG"/>
<result property="timeoutRoam" column="TIMEOUT_ROAM"/>
<result property="sameForPrew" column="SAME_FOR_PREW"/>
<result property="shape" column="SHAPE"/>
<result property="preNodeAnchor" column="PRE_NODE_ANCHOR"/>
<result property="nextNodeAnchor" column="NEXT_NODE_ANCHOR"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.PROCESS_ID,
a.PREW_NODE,
a.NEXT_NODE,
a.LOGO_TITLE,
a.CREATE_USER,
a.CREATE_DATE,
a.UPDATE_USER,
a.UPDATE_DATE,
a.NAME,
a.DESCRIPTION,
a.SEQUENCE_NO,
a.OPINION,
a.OPINION_MUST_FLAG,
a.ROUTE_TYPE,
a.PRIORITY_FLAG,
a.TIMEOUT_ROAM,
a.SAME_FOR_PREW,
a.SHAPE,
a.PRE_NODE_ANCHOR,
a.NEXT_NODE_ANCHOR
</sql>
<sql id="tNodeRoute_where">
<if test="tNodeRoute != null">
<if test="tNodeRoute.id != null and tNodeRoute.id.trim() != ''">
AND a.ID = #{tNodeRoute.id}
</if>
<if test="tNodeRoute.processId != null and tNodeRoute.processId.trim() != ''">
AND a.PROCESS_ID = #{tNodeRoute.processId}
</if>
<if test="tNodeRoute.prewNode != null and tNodeRoute.prewNode.trim() != ''">
AND a.PREW_NODE = #{tNodeRoute.prewNode}
</if>
<if test="tNodeRoute.nextNode != null and tNodeRoute.nextNode.trim() != ''">
AND a.NEXT_NODE = #{tNodeRoute.nextNode}
</if>
<if test="tNodeRoute.logoTitle != null and tNodeRoute.logoTitle.trim() != ''">
AND a.LOGO_TITLE = #{tNodeRoute.logoTitle}
</if>
<if test="tNodeRoute.createUser != null and tNodeRoute.createUser.trim() != ''">
AND a.CREATE_USER = #{tNodeRoute.createUser}
</if>
<if test="tNodeRoute.createDate != null">
AND a.CREATE_DATE = #{tNodeRoute.createDate}
</if>
<if test="tNodeRoute.updateUser != null and tNodeRoute.updateUser.trim() != ''">
AND a.UPDATE_USER = #{tNodeRoute.updateUser}
</if>
<if test="tNodeRoute.updateDate != null">
AND a.UPDATE_DATE = #{tNodeRoute.updateDate}
</if>
<if test="tNodeRoute.name != null and tNodeRoute.name.trim() != ''">
AND a.NAME = #{tNodeRoute.name}
</if>
<if test="tNodeRoute.description != null and tNodeRoute.description.trim() != ''">
AND a.DESCRIPTION = #{tNodeRoute.description}
</if>
<if test="tNodeRoute.sequenceNo != null">
AND a.SEQUENCE_NO = #{tNodeRoute.sequenceNo}
</if>
<if test="tNodeRoute.opinion != null and tNodeRoute.opinion.trim() != ''">
AND a.OPINION = #{tNodeRoute.opinion}
</if>
<if test="tNodeRoute.opinionMustFlag != null and tNodeRoute.opinionMustFlag.trim() != ''">
AND a.OPINION_MUST_FLAG = #{tNodeRoute.opinionMustFlag}
</if>
<if test="tNodeRoute.routeType != null and tNodeRoute.routeType.trim() != ''">
AND a.ROUTE_TYPE = #{tNodeRoute.routeType}
</if>
<if test="tNodeRoute.priorityFlag != null and tNodeRoute.priorityFlag.trim() != ''">
AND a.PRIORITY_FLAG = #{tNodeRoute.priorityFlag}
</if>
<if test="tNodeRoute.timeoutRoam != null and tNodeRoute.timeoutRoam.trim() != ''">
AND a.TIMEOUT_ROAM = #{tNodeRoute.timeoutRoam}
</if>
<if test="tNodeRoute.sameForPrew != null and tNodeRoute.sameForPrew.trim() != ''">
AND a.SAME_FOR_PREW = #{tNodeRoute.sameForPrew}
</if>
</if>
</sql>
<!--tNodeRoute简单分页查询-->
<select id="getTNodeRoutePage" resultMap="tNodeRouteMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_node_route a
<where>
1=1
<include refid="tNodeRoute_where"/>
</where>
</select>
<!--删除-->
<delete id="deleteByProcessId">
delete from t_node_route where PROCESS_ID = #{processId}
</delete>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TNodeTimeoutConfigMapper">
<resultMap id="tNodeTimeoutConfigMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTimeoutConfig">
<id property="id" column="ID"/>
<result property="timeOut" column="TIME_OUT"/>
<result property="day" column="DAY"/>
<result property="hour" column="HOUR"/>
<result property="workHourFlag" column="WORK_HOUR_FLAG"/>
<result property="nodeId" column="NODE_ID"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.TIME_OUT,
a.DAY,
a.HOUR,
a.WORK_HOUR_FLAG,
a.NODE_ID
</sql>
<sql id="tNodeTimeoutConfig_where">
<if test="tNodeTimeoutConfig != null">
<if test="tNodeTimeoutConfig.id != null and tNodeTimeoutConfig.id.trim() != ''">
AND a.ID = #{tNodeTimeoutConfig.id}
</if>
<if test="tNodeTimeoutConfig.timeOut != null and tNodeTimeoutConfig.timeOut.trim() != ''">
AND a.TIME_OUT = #{tNodeTimeoutConfig.timeOut}
</if>
<if test="tNodeTimeoutConfig.day != null">
AND a.DAY = #{tNodeTimeoutConfig.day}
</if>
<if test="tNodeTimeoutConfig.hour != null">
AND a.HOUR = #{tNodeTimeoutConfig.hour}
</if>
<if test="tNodeTimeoutConfig.workHourFlag != null and tNodeTimeoutConfig.workHourFlag.trim() != ''">
AND a.WORK_HOUR_FLAG = #{tNodeTimeoutConfig.workHourFlag}
</if>
<if test="tNodeTimeoutConfig.nodeId != null and tNodeTimeoutConfig.nodeId.trim() != ''">
AND a.NODE_ID = #{tNodeTimeoutConfig.nodeId}
</if>
</if>
</sql>
<!--tNodeTimeoutConfig简单分页查询-->
<select id="getTNodeTimeoutConfigPage" resultMap="tNodeTimeoutConfigMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_node_timeout_config a
<where>
1=1
<include refid="tNodeTimeoutConfig_where"/>
</where>
</select>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TNodeTransferConfigMapper">
<resultMap id="tNodeTransferConfigMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TNodeTransferConfig">
<id property="id" column="ID"/>
<result property="nodeId" column="NODE_ID"/>
<result property="processId" column="PROCESS_ID"/>
<result property="transferType" column="TRANSFER_TYPE"/>
<result property="copyData" column="COPY_DATA"/>
<result property="copyAtta" column="COPY_ATTA"/>
<result property="starterType" column="STARTER_TYPE"/>
<result property="starter" column="STARTER"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.NODE_ID,
a.PROCESS_ID,
a.TRANSFER_TYPE,
a.COPY_DATA,
a.COPY_ATTA,
a.STARTER_TYPE,
a.STARTER
</sql>
<sql id="tNodeTransferConfig_where">
<if test="tNodeTransferConfig != null">
<if test="tNodeTransferConfig.id != null and tNodeTransferConfig.id.trim() != ''">
AND a.ID = #{tNodeTransferConfig.id}
</if>
<if test="tNodeTransferConfig.nodeId != null and tNodeTransferConfig.nodeId.trim() != ''">
AND a.NODE_ID = #{tNodeTransferConfig.nodeId}
</if>
<if test="tNodeTransferConfig.processId != null and tNodeTransferConfig.processId.trim() != ''">
AND a.PROCESS_ID = #{tNodeTransferConfig.processId}
</if>
<if test="tNodeTransferConfig.transferType != null and tNodeTransferConfig.transferType.trim() != ''">
AND a.TRANSFER_TYPE = #{tNodeTransferConfig.transferType}
</if>
<if test="tNodeTransferConfig.copyData != null and tNodeTransferConfig.copyData.trim() != ''">
AND a.COPY_DATA = #{tNodeTransferConfig.copyData}
</if>
<if test="tNodeTransferConfig.copyAtta != null and tNodeTransferConfig.copyAtta.trim() != ''">
AND a.COPY_ATTA = #{tNodeTransferConfig.copyAtta}
</if>
<if test="tNodeTransferConfig.starterType != null and tNodeTransferConfig.starterType.trim() != ''">
AND a.STARTER_TYPE = #{tNodeTransferConfig.starterType}
</if>
<if test="tNodeTransferConfig.starter != null and tNodeTransferConfig.starter.trim() != ''">
AND a.STARTER = #{tNodeTransferConfig.starter}
</if>
</if>
</sql>
<!--tNodeTransferConfig简单分页查询-->
<select id="getTNodeTransferConfigPage" resultMap="tNodeTransferConfigMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_node_transfer_config a
<where>
1=1
<include refid="tNodeTransferConfig_where"/>
</where>
</select>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TProcessApprovalConfMapper">
<resultMap id="tProcessApprovalConfMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TProcessApprovalConf">
<id property="id" column="id"/>
<result property="fieldName" column="field_name"/>
<result property="processId" column="process_id"/>
<result property="parentId" column="parent_id"/>
<result property="type" column="type"/>
<result property="deleteFlag" column="delete_flag"/>
</resultMap>
<sql id="Base_Column_List">
a.id,
a.field_name,
a.process_id,
a.parent_id,
a.type,
a.delete_flag
</sql>
<sql id="tProcessApprovalConf_where">
<if test="tProcessApprovalConf != null">
<if test="tProcessApprovalConf.id != null and tProcessApprovalConf.id.trim() != ''">
AND a.id = #{tProcessApprovalConf.id}
</if>
<if test="tProcessApprovalConf.fieldName != null and tProcessApprovalConf.fieldName.trim() != ''">
AND a.field_name = #{tProcessApprovalConf.fieldName}
</if>
<if test="tProcessApprovalConf.processId != null and tProcessApprovalConf.processId.trim() != ''">
AND a.process_id = #{tProcessApprovalConf.processId}
</if>
<if test="tProcessApprovalConf.parentId != null and tProcessApprovalConf.parentId.trim() != ''">
AND a.parent_id = #{tProcessApprovalConf.parentId}
</if>
<if test="tProcessApprovalConf.type != null and tProcessApprovalConf.type.trim() != ''">
AND a.type = #{tProcessApprovalConf.type}
</if>
<if test="tProcessApprovalConf.deleteFlag != null and tProcessApprovalConf.deleteFlag.trim() != ''">
AND a.delete_flag = #{tProcessApprovalConf.deleteFlag}
</if>
</if>
</sql>
<!--tProcessApprovalConf简单分页查询-->
<select id="getTProcessApprovalConfPage" resultMap="tProcessApprovalConfMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_process_approval_conf a
<where>
1=1
<include refid="tProcessApprovalConf_where"/>
</where>
</select>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TProcessMapper">
<resultMap id="tProcessMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TProcess">
<id property="id" column="ID"/>
<result property="name" column="NAME"/>
<result property="logoTitle" column="LOGO_TITLE"/>
<result property="createUser" column="CREATE_USER"/>
<result property="createDate" column="CREATE_DATE"/>
<result property="updateUser" column="UPDATE_USER"/>
<result property="updateDate" column="UPDATE_DATE"/>
<result property="description" column="DESCRIPTION"/>
<result property="deleteFlag" column="DELETE_FLAG"/>
<result property="commonUse" column="common_use"/>
<result property="processIsUse" column="process_is_use"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.NAME,
a.LOGO_TITLE,
a.CREATE_USER,
a.CREATE_DATE,
a.UPDATE_USER,
a.UPDATE_DATE,
a.DESCRIPTION,
a.delete_flag,
a.common_use,
a.process_is_use
</sql>
<sql id="tProcess_where">
<if test="tProcess != null">
<if test="tProcess.id != null and tProcess.id.trim() != ''">
AND a.ID = #{tProcess.id}
</if>
<if test="tProcess.name != null and tProcess.name.trim() != ''">
AND a.NAME like CONCAT('%' , #{tProcess.name},'%')
</if>
<if test="tProcess.logoTitle != null and tProcess.logoTitle.trim() != ''">
AND a.LOGO_TITLE like CONCAT('%' , #{tProcess.logoTitle},'%')
</if>
<if test="tProcess.createUser != null and tProcess.createUser.trim() != ''">
AND a.CREATE_USER like CONCAT('%' , #{tProcess.createUser},'%')
</if>
<if test="tProcess.createDate != null">
AND a.CREATE_DATE = #{tProcess.createDate}
</if>
<if test="tProcess.updateUser != null and tProcess.updateUser.trim() != ''">
AND a.UPDATE_USER = #{tProcess.updateUser}
</if>
<if test="tProcess.updateDate != null">
AND a.UPDATE_DATE = #{tProcess.updateDate}
</if>
<if test="tProcess.description != null and tProcess.description.trim() != ''">
AND a.DESCRIPTION = #{tProcess.description}
</if>
<if test="tProcess.commonUse != null and tProcess.commonUse.trim() != ''">
AND a.common_use = #{tProcess.commonUse}
</if>
<if test="tProcess.processIsUse != null and tProcess.processIsUse.trim() != ''">
AND a.process_is_use = #{tProcess.processIsUse}
</if>
<if test="tProcess.processIds != null and tProcess.processIds.size()>0">
AND a.ID IN
<foreach collection="tProcess.processIds" item="id" index="index" open="(" close=")" separator=",">
#{id}
</foreach>
</if>
</if>
</sql>
<!--tProcess简单分页查询-->
<select id="getTProcessPage" resultType="com.yifu.cloud.plus.v1.yifu.process.vo.TProcessViewVo">
SELECT
<include refid="Base_Column_List"/>
FROM t_process a
<where>
delete_flag='0'
<include refid="tProcess_where"/>
<if test="type != null and type.trim() != ''">
<if test="type == 0">
and exists(select 1 from t_process_approval_conf where process_id=a.id and delete_flag='0' )
</if>
<if test="type == 1">
and exists(select 1 from t_process_approval_conf where process_id=a.id and delete_flag='1' )
</if>
</if>
<if test="tProcess.processIds != null and tProcess.processIds.size() > 0">
and a.ID IN
<foreach collection="tProcess.processIds" item="item" index="index" open="(" close=")" separator=",">
#{item}
</foreach>
</if>
order by a.CREATE_DATE desc
</where>
</select>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TProcessNodeMapper">
<resultMap id="tProcessNodeMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TProcessNode">
<id property="id" column="ID"/>
<result property="type" column="TYPE"/>
<result property="logoTitle" column="LOGO_TITLE"/>
<result property="name" column="NAME"/>
<result property="description" column="DESCRIPTION"/>
<result property="form" column="FORM"/>
<result property="allowDispatch" column="ALLOW_DISPATCH"/>
<result property="allowThis" column="ALLOW_THIS"/>
<result property="processId" column="PROCESS_ID"/>
<result property="handleAllowNext" column="HANDLE_ALLOW_NEXT"/>
<result property="countersign" column="COUNTERSIGN"/>
<result property="backType" column="BACK_TYPE"/>
<result property="shape" column="SHAPE"/>
<result property="size" column="SIZE"/>
<result property="coordinatex" column="COORDINATEX"/>
<result property="coordinatey" column="COORDINATEY"/>
<result property="color" column="COLOR"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.TYPE,
a.LOGO_TITLE,
a.NAME,
a.DESCRIPTION,
a.FORM,
a.ALLOW_DISPATCH,
a.ALLOW_THIS,
a.PROCESS_ID,
a.HANDLE_ALLOW_NEXT,
a.COUNTERSIGN,
a.BACK_TYPE,
a.SHAPE,
a.SIZE,
a.COORDINATEX,
a.COORDINATEY,
a.COLOR,
a.allow_add_sign
</sql>
<sql id="tProcessNode_where">
<if test="tProcessNode != null">
<if test="tProcessNode.id != null and tProcessNode.id.trim() != ''">
AND a.ID = #{tProcessNode.id}
</if>
<if test="tProcessNode.type != null and tProcessNode.type.trim() != ''">
AND a.TYPE = #{tProcessNode.type}
</if>
<if test="tProcessNode.logoTitle != null and tProcessNode.logoTitle.trim() != ''">
AND a.LOGO_TITLE = #{tProcessNode.logoTitle}
</if>
<if test="tProcessNode.name != null and tProcessNode.name.trim() != ''">
AND a.NAME = #{tProcessNode.name}
</if>
<if test="tProcessNode.description != null and tProcessNode.description.trim() != ''">
AND a.DESCRIPTION = #{tProcessNode.description}
</if>
<if test="tProcessNode.form != null and tProcessNode.form.trim() != ''">
AND a.FORM = #{tProcessNode.form}
</if>
<if test="tProcessNode.allowDispatch != null and tProcessNode.allowDispatch.trim() != ''">
AND a.ALLOW_DISPATCH = #{tProcessNode.allowDispatch}
</if>
<if test="tProcessNode.allowThis != null and tProcessNode.allowThis.trim() != ''">
AND a.ALLOW_THIS = #{tProcessNode.allowThis}
</if>
<if test="tProcessNode.processId != null and tProcessNode.processId.trim() != ''">
AND a.PROCESS_ID = #{tProcessNode.processId}
</if>
<if test="tProcessNode.handleAllowNext != null and tProcessNode.handleAllowNext.trim() != ''">
AND a.HANDLE_ALLOW_NEXT = #{tProcessNode.handleAllowNext}
</if>
<if test="tProcessNode.countersign != null and tProcessNode.countersign.trim() != ''">
AND a.COUNTERSIGN = #{tProcessNode.countersign}
</if>
<if test="tProcessNode.backType != null and tProcessNode.backType.trim() != ''">
AND a.BACK_TYPE = #{tProcessNode.backType}
</if>
</if>
</sql>
<!--tProcessNode简单分页查询-->
<select id="getTProcessNodePage" resultMap="tProcessNodeMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_process_node a
<where>
1=1
<include refid="tProcessNode_where"/>
</where>
</select>
<!--删除-->
<delete id="deleteByProcessId">
delete from t_process_node where PROCESS_ID = #{processId}
</delete>
</mapper>
<?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.yifu.cloud.plus.v1.yifu.process.mapper.TServiceTransferConfigMapper">
<resultMap id="tServiceTransferConfigMap" type="com.yifu.cloud.plus.v1.yifu.process.entity.TServiceTransferConfig">
<id property="id" column="ID"/>
<result property="serviceAgreement" column="SERVICE_AGREEMENT"/>
<result property="transferType" column="TRANSFER_TYPE"/>
<result property="wsdlAddress" column="WSDL_ADDRESS"/>
<result property="transferFunc" column="TRANSFER_FUNC"/>
<result property="nodeId" column="NODE_ID"/>
</resultMap>
<sql id="Base_Column_List">
a.ID,
a.SERVICE_AGREEMENT,
a.TRANSFER_TYPE,
a.WSDL_ADDRESS,
a.TRANSFER_FUNC,
a.NODE_ID
</sql>
<sql id="tServiceTransferConfig_where">
<if test="tServiceTransferConfig != null">
<if test="tServiceTransferConfig.id != null and tServiceTransferConfig.id.trim() != ''">
AND a.ID = #{tServiceTransferConfig.id}
</if>
<if test="tServiceTransferConfig.serviceAgreement != null and tServiceTransferConfig.serviceAgreement.trim() != ''">
AND a.SERVICE_AGREEMENT = #{tServiceTransferConfig.serviceAgreement}
</if>
<if test="tServiceTransferConfig.transferType != null and tServiceTransferConfig.transferType.trim() != ''">
AND a.TRANSFER_TYPE = #{tServiceTransferConfig.transferType}
</if>
<if test="tServiceTransferConfig.wsdlAddress != null and tServiceTransferConfig.wsdlAddress.trim() != ''">
AND a.WSDL_ADDRESS = #{tServiceTransferConfig.wsdlAddress}
</if>
<if test="tServiceTransferConfig.transferFunc != null and tServiceTransferConfig.transferFunc.trim() != ''">
AND a.TRANSFER_FUNC = #{tServiceTransferConfig.transferFunc}
</if>
<if test="tServiceTransferConfig.nodeId != null and tServiceTransferConfig.nodeId.trim() != ''">
AND a.NODE_ID = #{tServiceTransferConfig.nodeId}
</if>
</if>
</sql>
<!--tServiceTransferConfig简单分页查询-->
<select id="getTServiceTransferConfigPage" resultMap="tServiceTransferConfigMap">
SELECT
<include refid="Base_Column_List"/>
FROM t_service_transfer_config a
<where>
1=1
<include refid="tServiceTransferConfig_where"/>
</where>
</select>
</mapper>
......@@ -28,6 +28,7 @@ import com.yifu.cloud.plus.v1.yifu.common.dapr.util.MenuUtil;
import com.yifu.cloud.plus.v1.yifu.common.log.annotation.SysLog;
import com.yifu.cloud.plus.v1.yifu.common.security.annotation.Inner;
import com.yifu.cloud.plus.v1.yifu.common.security.util.SecurityUtils;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonCardVo;
import com.yifu.cloud.plus.v1.yifu.salary.vo.UpdateSocialFoundVo;
import com.yifu.cloud.plus.v1.yifu.social.entity.TSocialFundInfo;
import com.yifu.cloud.plus.v1.yifu.social.service.TSocialFundInfoService;
......@@ -181,4 +182,17 @@ public class TSocialFundInfoController {
return tSocialFundInfoService.selectSocialFoundByContract(sf);
}
/**
* @param cardVo
* @Description: 判断员工是否存在工伤社保数据
* @Author: huyc
* @Date: 2025/1/13
* @return:
**/
@Inner
@PostMapping("/inner/selectExitSocialInjury")
public Boolean selectExitSocialInjury(@RequestBody TInsuranceUnpurchasePersonCardVo cardVo) {
return tSocialFundInfoService.selectExitSocialInjury(cardVo);
}
}
......@@ -22,6 +22,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yifu.cloud.plus.v1.yifu.common.core.util.ErrorMessage;
import com.yifu.cloud.plus.v1.yifu.common.core.util.R;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonCardVo;
import com.yifu.cloud.plus.v1.yifu.salary.vo.UpdateSocialFoundVo;
import com.yifu.cloud.plus.v1.yifu.social.entity.TSocialFundInfo;
import com.yifu.cloud.plus.v1.yifu.social.vo.DispatchOneDetailVo;
......@@ -81,4 +82,6 @@ public interface TSocialFundInfoService extends IService<TSocialFundInfo> {
int selectSocialFoundByContract(TSocialFundInfo sf);
Boolean selectExitSocialInjury(TInsuranceUnpurchasePersonCardVo cardVo);
}
......@@ -38,6 +38,7 @@ import com.yifu.cloud.plus.v1.yifu.common.core.exception.ErrorCodes;
import com.yifu.cloud.plus.v1.yifu.common.core.util.*;
import com.yifu.cloud.plus.v1.yifu.common.dapr.util.ArchivesDaprUtil;
import com.yifu.cloud.plus.v1.yifu.common.mybatis.base.BaseEntity;
import com.yifu.cloud.plus.v1.yifu.insurances.vo.TInsuranceUnpurchasePersonCardVo;
import com.yifu.cloud.plus.v1.yifu.salary.vo.UpdateSocialFoundVo;
import com.yifu.cloud.plus.v1.yifu.social.constants.SocialConstants;
import com.yifu.cloud.plus.v1.yifu.social.entity.*;
......@@ -59,6 +60,8 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 社保公积金查询表
......@@ -904,4 +907,15 @@ public class TSocialFundInfoServiceImpl extends ServiceImpl<TSocialFundInfoMappe
}
return CommonConstants.ZERO_INT;
}
@Override
public Boolean selectExitSocialInjury(TInsuranceUnpurchasePersonCardVo cardVo) {
List<String> socialStatus = Stream.of("0","1","4","5").collect(Collectors.toList());
TSocialFundInfo socialFundInfo = baseMapper.selectOne(Wrappers.<TSocialFundInfo>query().lambda()
.eq(TSocialFundInfo::getEmpIdcard, cardVo.getEmpIdcardNo())
.eq(TSocialFundInfo::getEmpName, cardVo.getEmpName())
.in(TSocialFundInfo::getWorkInjuryHandle, socialStatus)
.last(CommonConstants.LAST_ONE_SQL));
return null != socialFundInfo;
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment