b2894lxlx/tms-erp-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat:添加wps相关代码

Browse Source
This commit is contained in:
aguanleishen
2026-07-28 17:29:45 +08:00
parent b5246d4e58
commit 27b1c5543d
55 changed files with 2499 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
blade-service-api/blade-open-api/pom.xml Normal file
View File

@@ -0,0 +1,15 @@
<?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>
<groupId>org.springblade</groupId>
<artifactId>blade-service-api</artifactId>
<version>${revision}</version>
</parent>
<artifactId>blade-open-api</artifactId>
<name>${project.artifactId}</name>
<packaging>jar</packaging>
</project>

40
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/common/vo/PageVO.java Normal file
View File

@@ -0,0 +1,40 @@
package org.springblade.openapi.common.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serial;
import java.io.Serializable;
import java.util.Collections;
import java.util.List;
/**
* 分页参数
* @author bfhuange
* @since 2025/4/23
*/
@AllArgsConstructor
@NoArgsConstructor
@Data
@Schema(description = "分页结果")
public class PageVO<T> implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 查询数据列表
*/
@Schema(description = "查询数据列表")
protected List<T> records = Collections.emptyList();
/**
* 总数
*/
@Schema(description = "总数")
protected long total = 0;
/**
* 总页数
*/
@Schema(description = "总页数")
protected long pages = 0;
}

61
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/mk/api/IApi4MK.java Normal file
View File

@@ -0,0 +1,61 @@
package org.springblade.openapi.mk.api;
import org.springblade.core.tool.api.FR;
import org.springblade.openapi.mk.pojo.dto.Api4MKProcessApprovalDTO;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 给mk回调的api
* @author bfhuange
* @date 2024/9/5
*/
public interface IApi4MK {
String API_PREFIX = "/openApi/mk";
String PROCESS_API_PREFIX = API_PREFIX + "/process";
String PROCESS_FINISH_CALLBACK = PROCESS_API_PREFIX + "/finishCallback";
String PROCESS_APPROVAL_CALLBACK = PROCESS_API_PREFIX + "/approvalCallback";
String PROCESS_REJECT_CALLBACK = PROCESS_API_PREFIX + "/rejectCallback";
String PROCESS_REVOKE_CALLBACK = PROCESS_API_PREFIX + "/revokeCallback";
String PROCESS_COMMON_CALLBACK = PROCESS_API_PREFIX + "/commonCallback";
/**
* 流程通用回调接口
* @param param
* @return
*/
@PostMapping(PROCESS_COMMON_CALLBACK)
FR<Boolean> processCommonCallback(@RequestBody Api4MKProcessApprovalDTO param);
/**
* 流程结束回调接口
* @param param
* @return
*/
@PostMapping(PROCESS_FINISH_CALLBACK)
FR<Boolean> processFinishCallback(@RequestBody Api4MKProcessApprovalDTO param);
/**
* 流程审批同意回调接口
* @param param
* @return
*/
@PostMapping(PROCESS_APPROVAL_CALLBACK)
FR<Boolean> processApprovalCallback(@RequestBody Api4MKProcessApprovalDTO param);
/**
* 流程审批拒绝回调接口
* @param param
* @return
*/
@PostMapping(PROCESS_REJECT_CALLBACK)
FR<Boolean> processRejectCallback(@RequestBody Api4MKProcessApprovalDTO param);
/**
* 流程撤销回调接口
* @param param
* @return
*/
@PostMapping(PROCESS_REVOKE_CALLBACK)
FR<Boolean> processRevokeCallback(@RequestBody Api4MKProcessApprovalDTO param);
}

8
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/mk/constant/MKConstant.java Normal file
View File

@@ -0,0 +1,8 @@
package org.springblade.openapi.mk.constant;
/**
* @author bfhuange
* @date 2024/9/12
*/
public class MKConstant {
}

81
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/mk/pojo/dto/Api4MKProcessApprovalDTO.java Normal file
View File

@@ -0,0 +1,81 @@
package org.springblade.openapi.mk.pojo.dto;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* mk审批回调参数
* @author bfhuange
* @date 2024/9/5
*/
@Data
public class Api4MKProcessApprovalDTO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 流程实例id
*/
private String processInstanceId;
/**
* 表单实例id
*/
private String formInstanceId;
/**
* 模板id
*/
private String templateId;
/**
* 模板编码，template_拼接 ProcessTypeEnum 的值
*/
private String templateCode;
/**
* 流程状态
*/
private String processStatus;
/**
* 申请人登录名
*/
private String applicantLoginName;
//===========================下面5个参数流程结束没有=========================
/**
* 驳回节点id N2 是起草节点
*/
private String rejectNodeId;
/**
* 当前节点id
*/
private String currentNodeId;
/**
* 当前节点编号
*/
private String currentNodeNumber;
/**
* 执行的操作
*/
private String operation;
/**
* 操作名称
*/
private String operationName;
/**
* 审批意见
*/
private String approvalOpinion;
/**
* 操作人登录名
*/
private String operatorLoginName;
//====================非mk回调参数，回调接口设置参数===================
/**
* 是否流程已完成，非mk回调参数，回调接口设置参数
*/
private boolean complete;
/**
* 审批状态，非mk回调参数，回调接口设置参数
*/
private String approveStatus;
}

34
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/mk/pojo/dto/ApiMKProcessFinishDTO.java Normal file
View File

@@ -0,0 +1,34 @@
package org.springblade.openapi.mk.pojo.dto;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* mk审批结束回调参数
* @author bfhuange
* @date 2024/9/5
*/
@Data
public class ApiMKProcessFinishDTO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 流程实例id
*/
private String processInstanceId;
/**
* 表单实例id
*/
private String formInstanceId;
/**
* 模板编码，template_拼接 ProcessTypeEnum 的值
*/
private String templateCode;
/**
* 流程状态
*/
private String processStatus;
}

40
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/mk/pojo/dto/ProcessApprovalDTO.java Normal file
View File

@@ -0,0 +1,40 @@
package org.springblade.openapi.mk.pojo.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Builder
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ProcessApprovalDTO implements Serializable {
/**
* 流程实例id
*/
@Schema(description = "流程实例id")
protected String flowInstId;
/**
* 表单实例id
*/
protected String formInstanceId;
/**
* 审批状态
*/
protected String approveStatus;
/**
* 下级审批人
*/
protected String nextApproveUser;
}

101
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/mk/pojo/enums/ProcessCallbackType.java Normal file
View File

@@ -0,0 +1,101 @@
package org.springblade.openapi.mk.pojo.enums;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 流程回调类型
* @author bfhuange
* @since 2024/11/23
*/
@AllArgsConstructor
@Getter
public enum ProcessCallbackType {
/**
* 提交
*/
SUBMIT(ProcessOperationType.DRAFTER_SUBMIT),
/**
* 起草人撤回
*/
RETRACT(ProcessOperationType.DRAFTER_RETRACT),
/**
* 审批通过
*/
PASS(ProcessOperationType.HANDLER_PASS),
/**
* 审批驳回
*/
REJECT(ProcessOperationType.HANDLER_REJECT),
/**
* 废弃（起草人废弃、审批人废弃、超管废弃）
*/
ABANDON(ProcessOperationType.DRAFTER_ABANDON, ProcessOperationType.HANDLER_ABANDON, ProcessOperationType.ADMIN_ABANDON),
/**
* 修改当前处理人（超管修改当前处理人、审批人转办、审批人撤回、特权人前后跳转）
*/
CHANGE_CUR_HANDLER(ProcessOperationType.ADMIN_CHANGE_CUR_HANDLER, ProcessOperationType.HANDLER_TRANSFER, ProcessOperationType.HISTORY_HANDLER_RETRACT, ProcessOperationType.ADMIN_JUMP),
/**
* 流程结束
*/
FINISH(ProcessOperationType.PROCESS_FINISH),
;
/**
* 编码
*/
private final List<String> operationTypes;
ProcessCallbackType(ProcessOperationType... operationTypes) {
if (operationTypes.length == 0) {
throw new RuntimeException("流程操作类型不能为空");
}
this.operationTypes = Stream.of(operationTypes)
.map(ProcessOperationType::getCode)
.toList();
}
ProcessCallbackType(String... operationTypes) {
if (operationTypes.length == 0) {
throw new RuntimeException("流程操作类型不能为空");
}
this.operationTypes = Lists.newArrayList(operationTypes);
}
/**
* 流程操作类型对应的事件
*/
private static final Map<String, ProcessCallbackType> CALLBACK_MAP = initCallbackMap();
/**
* 初始化流程操作类型对应的事件
* @return
*/
private static Map<String, ProcessCallbackType> initCallbackMap() {
return Stream.of(values())
.flatMap(callbackType -> callbackType.getOperationTypes().stream()
.collect(Collectors.toMap(Function.identity(), type -> callbackType))
.entrySet()
.stream()
)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> {
throw new RuntimeException("流程操作类型不能重复");
}));
}
/**
* 根据流程操作类型，获取对应的回调
* @param operationType
* @return
*/
public static ProcessCallbackType getCallbackType(String operationType) {
return CALLBACK_MAP.get(operationType);
}
}

175
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/mk/pojo/enums/ProcessOperationType.java Normal file
View File

@@ -0,0 +1,175 @@
package org.springblade.openapi.mk.pojo.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.stream.Stream;
/**
* 流程操作类型枚举
* @author bfhuange
* @since 2024/11/23
*/
@AllArgsConstructor
@Getter
public enum ProcessOperationType {
/**
* 起草人协同
*/
DRAFTER_COOPERATE("drafter_cooperate", "起草人协同"),
/**
* 起草人取消协同
*/
DRAFTER_CANCEL_DRAFT_COOPERATE("drafter_cancelDraftCooperate", "起草人取消协同"),
/**
* 协同接收人-回复协同
*/
HANDLER_REPLY_DRAFT_COOPERATE("handler_replyDraftCooperate", "协同接收人-回复协同"),
/**
* 起草人-提交
*/
DRAFTER_SUBMIT("drafter_submit", "起草人-提交"),
/**
* 起草人-废弃
*/
DRAFTER_ABANDON("drafter_abandon", "起草人-废弃"),
/**
* 起草人-撤回
*/
DRAFTER_RETRACT("drafter_retract", "起草人-撤回"),
/**
* 审批人-通过
*/
HANDLER_PASS("handler_pass", "审批人-通过"),
/**
* 审批人-驳回
*/
HANDLER_REJECT("handler_reject", "审批人-驳回"),
/**
* 审批人-废弃
*/
HANDLER_ABANDON("handler_abandon", "审批人-废弃"),
/**
* 审批人-撤回
*/
HISTORY_HANDLER_RETRACT("historyHandler_retract", "审批人-撤回"),
/**
* 审批人-签字
*/
HANDLER_SIGN("handler_sign", "审批人-签字"),
/**
* 审批人-转办
*/
HANDLER_TRANSFER("handler_transfer", "审批人-转办"),
/**
* 审批人-分发
*/
HANDLER_ASSIGN("handler_assign", "审批人-分发"),
/**
* 审批人-催办
*/
HISTORY_HANDLER_URGE("historyHandler_urge", "审批人-催办"),
/**
* 审批人-沟通
*/
HANDLER_COMMUNICATE("handler_communicate", "审批人-沟通"),
/**
* 审批人-回复沟通
*/
HANDLER_REPLY_COMMUNICATE("handler_replyCommunicate", "审批人-回复沟通"),
/**
* 审批人-取消沟通
*/
HANDLER_CANCEL_COMMUNICATE("handler_cancelCommunicate", "审批人-取消沟通"),
/**
* 审批人-补签
*/
HANDLER_APPEND_SIGN("handler_appendSign", "审批人-补签"),
/**
* 审批人-加签
*/
HANDLER_PREPEND_SIGN("handler_prependSign", "审批人-加签"),
/**
* 审批人(加签人)-取消加签
*/
HANDLER_PREPEND_SIGN_CANCEL("handler_prependSignCancel", "审批人(加签人)-取消加签"),
/**
* 审批人(被加签人)-退回加签
*/
HANDLER_PREPEND_SIGN_REFUSE("handler_prependSignRefuse", "审批人(被加签人)-退回加签"),
/**
* 审批人(被加签人)-通过加签
*/
HANDLER_PREPEND_SIGN_PASS("handler_prependSignPass", "审批人(被加签人)-通过加签"),
/**
* 审批人(被加签人)-审批人-传阅
*/
HANDLER_CIRCULATION("handler_circulation", "审批人(被加签人)-审批人-传阅"),
/**
* 特权人-前后跳转
*/
ADMIN_JUMP("admin_jump", "特权人-前后跳转"),
/**
* 特权人-流程暂停
*/
ADMIN_PROCESS_SUSPEND("admin_processSuspend", "特权人-流程暂停"),
/**
* 特权人-节点暂停
*/
ADMIN_NODE_SUSPEND("admin_nodeSuspend", "特权人-节点暂停"),
/**
* 审批人-节点唤醒
*/
HANDLER_NODE_RESUME("handler_nodeResume", "审批人-节点唤醒"),
/**
* 特权人-节点唤醒
*/
ADMIN_NODE_RESUME("admin_nodeResume", "特权人-节点唤醒"),
/**
* 特权人-流程唤醒
*/
ADMIN_PROCESS_RESUME("admin_processResume", "特权人-流程唤醒"),
/**
* 特权人-修改流程
*/
ADMIN_MODIFY_PROCESS("admin_modifyProcess", "特权人-修改流程"),
/**
* 特权人-修改当前处理人
*/
ADMIN_CHANGE_CUR_HANDLER("admin_changeCurHandler", "特权人-修改当前处理人"),
/**
* 特权人-终审通过
*/
ADMIN_END("admin_end", "特权人-终审通过"),
/**
* 特权人-直接废弃
*/
ADMIN_ABANDON("admin_abandon", "特权人-直接废弃"),
;
/**
* 编码
*/
private final String code;
/**
* 名称
*/
private final String name;
/**
* 流程结束，mk没有这个操作，但是有这个事件，自定义一个操作类型，统一管理
*/
public static final String PROCESS_FINISH = "erp_process_finish";
/**
* 根据操作编码获取名称
* @param code
* @return
*/
public static String getOperationName(String code) {
return Stream.of(values())
.filter(type -> type.getCode().equals(code))
.findFirst()
.map(ProcessOperationType::getName)
.orElse(null);
}
}

36
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/api/IApi4OCR.java Normal file
View File

@@ -0,0 +1,36 @@
package org.springblade.openapi.ocr.api;
import org.springblade.core.tool.api.FR;
import org.springblade.openapi.common.vo.PageVO;
import org.springblade.openapi.ocr.pojo.dto.Api4OCRProjectDTO;
import org.springblade.openapi.ocr.pojo.dto.Api4OCRResultDTO;
import org.springblade.openapi.ocr.pojo.vo.Api4OCRProjectVO;
import org.springblade.openapi.ocr.pojo.vo.Api4OCRResultVO;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author bfhuange
* @since 2025/04/22
*/
public interface IApi4OCR {
String API_PREFIX = "/openApi/ocr";
String PROJECT_LIST = API_PREFIX + "/queryProjectList";
String OCR_RESULT_LIST = API_PREFIX + "/queryOCRResultList";
/**
* 查询项目列表
* @param param
* @return
*/
@PostMapping(PROJECT_LIST)
FR<PageVO<Api4OCRProjectVO>> queryProjectList(@RequestBody(required = false) Api4OCRProjectDTO param);
/**
* 查询凭证ocr识别结果列表
* @param param
* @return
*/
@PostMapping(OCR_RESULT_LIST)
FR<PageVO<Api4OCRResultVO>> queryOCRResultList(@RequestBody(required = false) Api4OCRResultDTO param);
}

24
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/dto/Api4OCRProjectDTO.java Normal file
View File

@@ -0,0 +1,24 @@
package org.springblade.openapi.ocr.pojo.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serial;
/**
* @author bfhuange
* @since 2025/4/22
*/
@EqualsAndHashCode(callSuper = true)
@Data
@Schema(description = "提供给ocr的项目信息")
public class Api4OCRProjectDTO extends PageQuery {
@Serial
private static final long serialVersionUID = 1L;
/**
* 关键字，项目名称或简称模糊查询
*/
@Schema(description = "关键字，项目名称或简称模糊查询")
private String keyword;
}

62
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/dto/Api4OCRResultDTO.java Normal file
View File

@@ -0,0 +1,62 @@
package org.springblade.openapi.ocr.pojo.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springblade.core.tool.utils.DateUtil;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serial;
import java.util.Date;
/**
* @author bfhuange
* @since 2025/4/22
*/
@EqualsAndHashCode(callSuper = true)
@Data
@Schema(description = "凭证ocr结果查询参数")
public class Api4OCRResultDTO extends PageQuery {
@Serial
private static final long serialVersionUID = 1L;
/**
* 项目id
*/
@Schema(description = "项目id，项目id、凭证批次号、凭证号至少一个不为空")
private Long projectId;
/**
* 凭证批次号
*/
@Schema(description = "凭证批次号，项目id、凭证批次号、凭证号至少一个不为空")
private String batchCode;
/**
* 凭证号
*/
@Schema(description = "凭证号，项目id、凭证批次号、凭证号至少一个不为空")
private String detailCode;
/**
* 是否类型错误（1 否 2 是）
*/
@Schema(description = "是否类型错误（1 否 2 是）")
private Integer isTypeError;
/**
* 是否数据错误（1 否 2 是）
*/
@Schema(description = "是否数据错误（1 否 2 是）")
private Integer isDataError;
/**
* 创建时间始
*/
@DateTimeFormat(pattern = DateUtil.PATTERN_DATETIME)
@JsonFormat(pattern = DateUtil.PATTERN_DATETIME, timezone = "GMT+8")
@Schema(description = "创建时间始，格式yyyy-MM-dd HH:mm:ss")
private Date createTimeStart;
/**
* 创建时间至
*/
@DateTimeFormat(pattern = DateUtil.PATTERN_DATETIME)
@JsonFormat(pattern = DateUtil.PATTERN_DATETIME, timezone = "GMT+8")
@Schema(description = "创建时间至，格式yyyy-MM-dd HH:mm:ss")
private Date createTimeEnd;
}

41
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/dto/PageQuery.java Normal file
View File

@@ -0,0 +1,41 @@
package org.springblade.openapi.ocr.pojo.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* 分页查询参数
* @author bfhuange
* @since 2025/4/22
*/
@Data
@Schema(description = "分页查询参数")
public class PageQuery implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 每页最大数量 200
*/
public static final int MAX_SIZE = 200;
/**
* 当前页
*/
@Schema(description = "当前页，默认1")
protected Integer current = 1;
/**
* 每页的数量
*/
@Schema(description = "每页的数量，默认10，超过200会修改为200")
protected Integer size = 10;
public void setSize(Integer size) {
if (size != null && size > MAX_SIZE) {
size = MAX_SIZE;
}
this.size = size;
}
}

56
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/vo/Api4OCRProjectVO.java Normal file
View File

@@ -0,0 +1,56 @@
package org.springblade.openapi.ocr.pojo.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.springblade.core.tool.utils.DateUtil;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* @author bfhuange
* @since 2025/4/22
*/
@Data
@Schema(description = "提供给ocr的项目信息")
public class Api4OCRProjectVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 项目id
*/
@JsonSerialize(using = ToStringSerializer.class)
@Schema(description = "项目id")
private Long id;
/**
* 项目名称
*/
@Schema(description = "项目名称")
private String name;
/**
* 项目简称
*/
@Schema(description = "项目简称")
private String abbreviation;
/**
* 创建时间
*/
@DateTimeFormat(pattern = DateUtil.PATTERN_DATETIME)
@JsonFormat(pattern = DateUtil.PATTERN_DATETIME)
@Schema(description = "创建时间")
private Date createTime;
/**
* 更新时间
*/
@DateTimeFormat(pattern = DateUtil.PATTERN_DATETIME)
@JsonFormat(pattern = DateUtil.PATTERN_DATETIME)
@Schema(description = "更新时间")
private Date updateTime;
}

103
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/vo/Api4OCRResultVO.java Normal file
View File

@@ -0,0 +1,103 @@
package org.springblade.openapi.ocr.pojo.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.NullSerializer;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.springblade.core.tool.utils.DateUtil;
import org.springblade.openapi.ocr.pojo.vo.result.AttachmentType;
import org.springblade.openapi.ocr.pojo.vo.result.ErrorAttachmentType;
import org.springblade.openapi.ocr.pojo.vo.result.ErrorField;
import org.springblade.openapi.ocr.pojo.vo.result.TransportCertificateBatchDetailData;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* @author bfhuange
* @since 2025/4/22
*/
@Data
@Schema(description = "凭证ocr结果")
public class Api4OCRResultVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@JsonSerialize(using = ToStringSerializer.class, nullsUsing = NullSerializer.class)
@Schema(description = "主键")
private Long id;
/**
* 凭证号
*/
@Schema(description = "凭证号")
private String code;
/**
* 识别类型（batch 批量识别，mixed 单张识别合并）
*/
@Schema(description = "识别类型（batch 批量识别，mixed 单张识别合并）")
private String identifyType;
/**
* 是否类型错误（1 否 2 是）
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
@Schema(description = "是否类型错误（1 否 2 是）")
private Integer isTypeError;
/**
* 是否数据错误（1 否 2 是）
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
@Schema(description = "是否数据错误（1 否 2 是）")
private Integer isDataError;
/**
* 附件类型列表
*/
@Schema(description = "附件类型列表")
private List<AttachmentType> attachmentTypeList;
/**
* 数据
*/
@Schema(description = "数据")
private TransportCertificateBatchDetailData data;
/**
* 错误类型列表
*/
@Schema(description = "错误类型列表")
private List<ErrorAttachmentType> errorTypeList;
/**
* 错误字段列表
*/
@Schema(description = "错误字段列表")
private List<ErrorField> errorFieldList;
/**
* 错误字段列表
*/
@DateTimeFormat(pattern = DateUtil.PATTERN_DATETIME)
@JsonFormat(pattern = DateUtil.PATTERN_DATETIME)
@Schema(description = "创建时间")
private Date createTime;
/**
* 更新时间
*/
@DateTimeFormat(pattern = DateUtil.PATTERN_DATETIME)
@JsonFormat(pattern = DateUtil.PATTERN_DATETIME)
@Schema(description = "更新时间")
private Date updateTime;
}

40
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/vo/result/AttachmentType.java Normal file
View File

@@ -0,0 +1,40 @@
package org.springblade.openapi.ocr.pojo.vo.result;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* 附件类型
* @author bfhuange
* @since 2025/4/18
*/
@Data
@Schema(description = "附件类型")
public class AttachmentType implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 附件id
*/
@JsonSerialize(using = ToStringSerializer.class)
@Schema(description = "附件id")
private Long attachmentId;
/**
* ocr附件类型
*/
@Schema(description = "ocr附件类型")
private String ocrType;
/**
* 附件url
*/
@JsonInclude(JsonInclude.Include.NON_EMPTY)
@Schema(description = "附件url")
private String url;
}

25
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/vo/result/ErrorAttachmentType.java Normal file
View File

@@ -0,0 +1,25 @@
package org.springblade.openapi.ocr.pojo.vo.result;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serial;
/**
* 错误附件类型
* @author bfhuange
* @since 2025/4/21
*/
@EqualsAndHashCode(callSuper = true)
@Data
@Schema(description = "错误附件类型")
public class ErrorAttachmentType extends AttachmentType {
@Serial
private static final long serialVersionUID = 1L;
/**
* erp附件类型
*/
@Schema(description = "erp附件类型")
private String erpType;
}

45
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/vo/result/ErrorField.java Normal file
View File

@@ -0,0 +1,45 @@
package org.springblade.openapi.ocr.pojo.vo.result;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.List;
/**
* 错误字段
* @author bfhuange
* @since 2025/4/21
*/
@Data
@Schema(description = "错误字段")
public class ErrorField implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 字段名
*/
@Schema(description = "字段名")
private String filed;
/**
* ocr类型
*/
@Schema(description = "ocr类型")
private String ocrType;
/**
* ocr字段值
*/
@Schema(description = "ocr字段值")
private String ocrValue;
/**
* erp字段值
*/
@Schema(description = "erp字段值")
private String erpValue;
/**
* 附件列表
*/
@Schema(description = "附件列表")
private List<AttachmentType> attachmentList;
}

94
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/ocr/pojo/vo/result/TransportCertificateBatchDetailData.java Normal file
View File

@@ -0,0 +1,94 @@
package org.springblade.openapi.ocr.pojo.vo.result;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.NullSerializer;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.springblade.core.tool.utils.DateUtil;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* 车辆运输凭证批次明细表 实体类
*
* @author BladeX
* @since 2024-10-23
*/
@Data
@Schema(description = "凭证数据对象")
public class TransportCertificateBatchDetailData implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 磅单车牌号
*/
@Schema(description = "磅单车牌号")
private String poundPlateNo;
/**
* 行驶证上的车牌号
*/
@Schema(description = "行驶证上的车牌号")
private String drivingPlateNo;
/**
* 车头车牌号
*/
@Schema(description = "车头车牌号")
private String carFrontPlateNo;
/**
* 到货日期
*/
@JsonFormat(pattern = DateUtil.PATTERN_DATE, timezone = "GMT+8")
@Schema(description = "到货日期")
private Date supplyMaterialDate;
/**
* 货物名称
*/
@Schema(description = "货物名称")
private String productName;
/**
* 规格料型
*/
@Schema(description = "规格料型")
private String specificationMaterial;
/**
* 毛重（吨）
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
@Schema(description = "毛重（吨）")
private BigDecimal grossWeight;
/**
* 皮重（吨）
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
@Schema(description = "皮重（吨）")
private BigDecimal skinWeight;
/**
* 净重（吨）
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
@Schema(description = "净重（吨）")
private BigDecimal netWeight;
/**
* 扣杂（吨）
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
@Schema(description = "扣杂（吨）")
private BigDecimal miscellaneousWeight;
/**
* 实收（吨）
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
@Schema(description = "实收（吨）")
private BigDecimal realityWeight;
/**
* 驾驶证是否有效（1 否 2 是）
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
@Schema(description = "驾驶证是否有效（1 否 2 是）")
private Integer isDriverLicenseValid;
}

40
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/track/api/IApi4Track.java Normal file
View File

@@ -0,0 +1,40 @@
package org.springblade.openapi.track.api;
import org.springblade.openapi.track.pojo.dto.Api4TrackWaybillDTO;
import org.springblade.openapi.track.pojo.vo.Api4TrackResultVO;
import org.springblade.openapi.track.pojo.vo.Api4TrackWaybillVO;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
/**
* @author bfhuange
* @since 2024/12/16
*/
public interface IApi4Track {
String API_PREFIX = "/openApi/gj";
String WAYBILL_LIST = API_PREFIX + "/mycode/zhcx/getZhcx";
String WAYBILL_TRACK_UPDATE = API_PREFIX + "/mycode/zhcx/callback";
/**
* 轨迹查询运单信息
*
* @param param@return
*/
@PostMapping(WAYBILL_LIST)
Api4TrackResultVO<List<Api4TrackWaybillVO>> queryWaybillList(@RequestBody Api4TrackWaybillDTO param);
/**
* 轨迹更新运单轨迹url和状态
* @param waybillId
* @param trajectoryId
* @param trajectoryStatus
* @return
*/
@PostMapping(WAYBILL_TRACK_UPDATE)
Api4TrackResultVO<Void> updateWaybillTrack(@RequestParam(name = "zhcxId", required = false) String waybillId,
@RequestParam(name = "diTuUrl", required = false) String trajectoryId,
@RequestParam(name = "guiJiZhuangTai", required = false) String trajectoryStatus);
}

17
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/track/constant/TrackConstant.java Normal file
View File

@@ -0,0 +1,17 @@
package org.springblade.openapi.track.constant;
/**
* 轨迹常量
* @author bfhuange
* @since 2024/12/16
*/
public class TrackConstant {
/**
* 响应成功状态码
*/
public static final Integer SUCCESS_CODE = 200;
/**
* 响应失败状态码
*/
public static final Integer FAIL_CODE = 500;
}

22
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/track/pojo/dto/Api4TrackWaybillDTO.java Normal file
View File

@@ -0,0 +1,22 @@
package org.springblade.openapi.track.pojo.dto;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.List;
/**
* @author bfhuange
* @since 2024/12/16
*/
@Data
public class Api4TrackWaybillDTO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 运单id列表
*/
private List<String> ids;
}

33
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/track/pojo/dto/Api4TrackWaybillUpdateDTO.java Normal file
View File

@@ -0,0 +1,33 @@
package org.springblade.openapi.track.pojo.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* @author bfhuange
* @since 2024/12/16
*/
@Data
public class Api4TrackWaybillUpdateDTO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 运单id
*/
@JsonProperty("zhcxId")
private String waybillId;
/**
* 轨迹id
*/
@JsonProperty("diTuUrl")
private String trajectoryId;
/**
* 轨迹状态
*/
@JsonProperty("guiJiZhuangTai")
private String trajectoryStatus;
}

50
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/track/pojo/vo/Api4TrackResultVO.java Normal file
View File

@@ -0,0 +1,50 @@
package org.springblade.openapi.track.pojo.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springblade.openapi.track.constant.TrackConstant;
import java.io.Serial;
import java.io.Serializable;
/**
* @author bfhuange
* @since 2024/12/16
*/
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Api4TrackResultVO<T> implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 响应代码。200为正确
*/
private Integer state;
/**
* 对应的提示信息
*/
private String message;
/**
* 数据
*/
private T data;
public Api4TrackResultVO(Integer state, T data) {
this.state = state;
this.data = data;
}
public static <T> Api4TrackResultVO<T> success() {
return Api4TrackResultVO.success(null);
}
public static <T> Api4TrackResultVO<T> fail(String message) {
return new Api4TrackResultVO<>(TrackConstant.FAIL_CODE, message, null);
}
public static <T> Api4TrackResultVO<T> success(T data) {
return new Api4TrackResultVO<>(TrackConstant.SUCCESS_CODE, data);
}
}

86
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/track/pojo/vo/Api4TrackWaybillVO.java Normal file
View File

@@ -0,0 +1,86 @@
package org.springblade.openapi.track.pojo.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import org.springblade.core.tool.utils.DateUtil;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serial;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @author bfhuange
* @since 2024/12/16
*/
@Data
public class Api4TrackWaybillVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 运单id
*/
private String id;
/**
* 收货日期
*/
@DateTimeFormat(pattern = DateUtil.PATTERN_DATE)
@JsonFormat(pattern = DateUtil.PATTERN_DATE)
@JsonProperty("shouHuoRiQi")
private Date enterDate;
/**
* 车牌号
*/
@JsonProperty("chePaiHao")
private String plateNo;
/**
* 钢厂简称
*/
@JsonProperty("gangChangJianCheng")
private String customerAbbreviation;
/**
* 钢厂合同编号
*/
@JsonIgnore
private String contractGcCode;
//===========================设置默认值的参数==========================
/**
* 托运人
*/
@JsonProperty("tuoYunRen")
private String shipper = "托运人";
/**
* 收货人
*/
@JsonProperty("shouHuoRen")
private String consignee = "收货人";
/**
* 收货地址
*/
@JsonProperty("shouHuoDiZhi")
private String address = "收货地址";
/**
* 投送人
*/
@JsonProperty("touSongRen")
private String delivery = "投送人";
/**
* 货物名称
*/
@JsonProperty("huoWuMingCheng")
private String goodsName = "货物名称";
/**
* 重量
*/
@JsonProperty("zhongLiang")
private BigDecimal weight = BigDecimal.ZERO;
/**
* 事业部
*/
@JsonProperty("shiYeBu")
private String division = "事业部";
}

50
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/api/IApi4Wps.java Normal file
View File

@@ -0,0 +1,50 @@
package org.springblade.openapi.wps.api;
import org.springblade.openapi.wps.pojo.dto.Api4WpsFileInfoDTO;
import org.springblade.openapi.wps.pojo.vo.Api4WpsFileInfoVO;
import org.springframework.cloud.openfeign.SpringQueryMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.multipart.MultipartFile;
/**
* 给wps回调的api
* @author bfhuange
* @date 2024/10/30
*/
public interface IApi4Wps {
String API_PREFIX = "/openApi/wps";
String VERSION = "/v1";
String FILE_INFO = API_PREFIX + VERSION + "/3rd/file/info";
String FILE_SAVE = API_PREFIX + VERSION + "/3rd/file/save";
/**
* wps回调查询文件信息
*
* @param fileId 文件id，必填
* @param token 非必填
* @param param 在获取预览链接时按需求传入的所有自定义参数
* @return
*/
@GetMapping(FILE_INFO)
Api4WpsFileInfoVO getFileInfo(@RequestHeader("X-Weboffice-File-Id") String fileId,
@RequestHeader(value = "X-Wps-Weboffice-Token", required = false) String token,
@SpringQueryMap Api4WpsFileInfoDTO param);
/**
* wps回调-上传文件新版本
*
* @param fileId 文件id，必填
* @param token 非必填
* @param param 在获取预览链接时按需求传入的所有自定义参数
* @return
*/
@PostMapping(FILE_SAVE)
Api4WpsFileInfoVO getFileSave(@RequestHeader("X-Weboffice-File-Id") String fileId,
@RequestHeader(value = "X-Weboffice-Save-Type") String saveType,
@RequestHeader(value = "X-Wps-Weboffice-Token", required = false) String token,
@RequestPart("file") MultipartFile file,
@SpringQueryMap Api4WpsFileInfoDTO param);
}

21
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/constant/WpsConstant.java Normal file
View File

@@ -0,0 +1,21 @@
package org.springblade.openapi.wps.constant;
/**
* wps常量类
* @author bfhuange
* @date 2024/10/30
*/
public class WpsConstant {
/**
* 是
*/
public static final Integer YES = 1;
/**
* 否
*/
public static final Integer NO = 0;
/**
* 文件信息查询默认缓存时间 120 秒
*/
public static final String FILE_INFO_DEFAULT_CACHE_TIME = "120";
}

17
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/dto/Api4WpsFileInfoDTO.java Normal file
View File

@@ -0,0 +1,17 @@
package org.springblade.openapi.wps.pojo.dto;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* wps文件信息查询参数
* @author bfhuange
* @date 2024/10/30
*/
@Data
public class Api4WpsFileInfoDTO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
}

60
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/enums/Api4WpsError.java Normal file
View File

@@ -0,0 +1,60 @@
package org.springblade.openapi.wps.pojo.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* wps 回调接口错误枚举
* @author bfhuange
* @since 2024/11/26
*/
@AllArgsConstructor
@Getter
public enum Api4WpsError {
/**
* 服务处理正常
*/
OK(0, "OK"),
/**
* token过期
*/
SESSION_EXPIRED(40002, "SessionExpired"),
/**
* 用户无权限访问
*/
PERMISSION_DENIED(40003, "PermissionDenied"),
/**
* 资源不存在
*/
NOT_EXISTS(40004, "NotExists"),
/**
* 参数错误
*/
INVALID_ARGUMENT(40005, "InvalidArgument"),
/**
* 保存空间已满
*/
SPACE_FULL(40006, "SpaceFull"),
/**
* 自定义错误提示，前端页面将显示此错误内容，在回调错误响应中的hint字段中自定义错误提示，该错误提示不支持多语言
*/
CUSTOM_MSG(40007, "CustomMsg"),
/**
* 文件重命名冲突
*/
FNAME_CONFLICT(40008, "FnameConflict"),
/**
* 对接系统错误
*/
SERVER_ERROR(50001, "ServerError"),
;
/**
* 错误码
*/
private final Integer code;
/**
* 信息
*/
private final String message;
}

27
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/vo/Api4WpsAttrsVO.java Normal file
View File

@@ -0,0 +1,27 @@
package org.springblade.openapi.wps.pojo.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serial;
import java.io.Serializable;
/**
* wps附加参数
* @author bfhuange
* @date 2024/10/30
*/
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Api4WpsAttrsVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 单位秒，取值范围为1-300，超过300秒不会缓存回调信息，此字段需服务端全局配置开启缓存，且需要使用token访问预览链接，非必填
*/
@JsonProperty("cachetime")
private String cacheTime;
}

41
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/vo/Api4WpsErrorVO.java Normal file
View File

@@ -0,0 +1,41 @@
package org.springblade.openapi.wps.pojo.vo;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serial;
import java.io.Serializable;
/**
* wps回调接口错误
* @author bfhuange
* @since 2024/11/26
*/
@NoArgsConstructor
@Data
public class Api4WpsErrorVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 错误码
*/
private Integer code;
/**
* 错误提示
*/
private String message;
/**
* 错误提示详细信息
*/
private String details;
/**
* 自定义错误信息，当code为40007错误码时必填
*/
private String hint;
public Api4WpsErrorVO(Integer code, String message, String hint) {
this.code = code;
this.message = message;
this.hint = hint;
}
}

34
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/vo/Api4WpsFileInfoVO.java Normal file
View File

@@ -0,0 +1,34 @@
package org.springblade.openapi.wps.pojo.vo;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.NullSerializer;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* wps文件信息查询结果
* @author bfhuange
* @date 2024/10/30
*/
@Data
public class Api4WpsFileInfoVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 文件信息，必填
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
private Api4WpsFileVO file;
/**
* 用户信息，必填
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
private Api4WpsUserVO user;
/**
* 附加参数，v6.0.2209.20220920新增
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
private Api4WpsAttrsVO attrs;
}

83
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/vo/Api4WpsFileVO.java Normal file
View File

@@ -0,0 +1,83 @@
package org.springblade.openapi.wps.pojo.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.NullSerializer;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* wps文件结果
* @author bfhuange
* @date 2024/10/30
*/
@Data
public class Api4WpsFileVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 文件id,字符串长度不超过64位，必填
*/
private String id;
/**
* 文件名必须带后缀，必填
*/
private String name;
/**
* 文档版本号，从1开始累加，位数小于11，必填
*/
private Integer version = 1;
/**
* 文档大小，单位为字节；此处需传文件真实大小，否则会出现异常，必填
*/
private Integer size;
/**
* readonly默认为false
* true开启表格筛选，支持对EXCEL表格文档筛选，但不支持对EXCEL表格文档开启多人同步筛选，该预览特性见常见问题
* false关闭表格筛选（20220707新增），非必填
*/
private Boolean readonly = true;
/**
* 创建者id，字符串长度不超过32位。与user里的id一致，必填
*/
private String creator;
/**
* 创建时间，时间戳，单位为秒，必填
*/
@JsonProperty("create_time")
private Integer createTime;
/**
* 修改者id，字符串长度不超过32位，必填
*/
private String modifier;
/**
* 最近修改时间，时间戳，单位为秒，必填
*/
@JsonProperty("modify_time")
private Integer modifyTime;
/**
* 文档下载地址，必填
*/
@JsonProperty("download_url")
private String downloadUrl;
/**
* 普通预览模式下可限制预览页数（不超过5000）
* previewPages 默认值为 0，不限制预览页数；
* previewPages >= 1 时，限制生效，限制的页数为 previewpages 字段的值，必填
*/
@JsonProperty("preview_pages")
private Integer previewPages = 0;
/**
* 用户权限，非必填
*/
@JsonProperty("user_acl")
@JsonSerialize(nullsUsing = NullSerializer.class)
private Api4WpsUserAclVO userAcl;
/**
* 水印参数，非必填
*/
@JsonSerialize(nullsUsing = NullSerializer.class)
private Api4WpsWatermarkVO watermark;
}

37
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/vo/Api4WpsUserAclVO.java Normal file
View File

@@ -0,0 +1,37 @@
package org.springblade.openapi.wps.pojo.vo;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* wps用户权限
* @author bfhuange
* @date 2024/10/30
*/
@Data
public class Api4WpsUserAclVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 重命名权限，1为打开该权限，0为关闭该权限，默认为0，非必填
*/
private Integer rename;
/**
* 历史文件打开权限，1为打开该权限，0为关闭该权限，默认为1，非必填
*/
private Integer history;
/**
* 复制权限，1为打开该权限，0为关闭该权限，默认为1，非必填
*/
private Integer copy;
/**
* 导出权限，1为打开该权限，0为关闭该权限，默认为1，非必填
*/
private Integer export;
/**
* 打印权限，1为打开该权限，0为关闭该权限，默认为1，非必填
*/
private Integer print;
}

36
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/vo/Api4WpsUserVO.java Normal file
View File

@@ -0,0 +1,36 @@
package org.springblade.openapi.wps.pojo.vo;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serial;
import java.io.Serializable;
/**
* wps用户信息
* @author bfhuange
* @date 2024/10/30
*/
@NoArgsConstructor
@Data
public class Api4WpsUserVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 用户id，长度不超过32位，与creator、modifier一致，必填
*/
private String id;
/**
* 用户名称，必填
*/
private String name;
/**
* 用户操作权限，预览固定为read，必填
*/
private String permission = "write";
public Api4WpsUserVO(String id, String name) {
this.id = id;
this.name = name;
}
}

48
blade-service-api/blade-open-api/src/main/java/org/springblade/openapi/wps/pojo/vo/Api4WpsWatermarkVO.java Normal file
View File

@@ -0,0 +1,48 @@
package org.springblade.openapi.wps.pojo.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
/**
* wps水印参数
* @author bfhuange
* @date 2024/10/30
*/
@Data
public class Api4WpsWatermarkVO implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 水印类型， 0为无水印； 1为文字水印，非必填
*/
private Integer type;
/**
* 文字水印的文字，支持通过\r\n换行，支持emoji表情
* 当type为1时此字段必选
*/
private String value;
/**
* 水印的颜色（含透明度），非必选，有默认值。格式为：rgba( 192, 192, 192, 0.6 )
*/
@JsonProperty("fillstyle")
private String fillStyle;
/**
* 水印的字体，非必选，有默认值，格式为bold 20px Serif，非必填
*/
private String font;
/**
* 水印的旋转度(弧度)，非必选，有默认值，默认为-0.7853982，非必填
*/
private Float rotate;
/**
* 水印水平间距，非必选，有默认值，默认为50，非必填
*/
private Integer horizontal;
/**
* 水印垂直间距，非必选，有默认值，默认为100，非必填
*/
private Integer vertical;
}