Skip to content

J
jiedao-api-boot-master
Commit 7774c515 authored by 332784038@qq.com's avatar 332784038@qq.com
Browse files
Options

Merge branch 'order_fee_update' into release

parents d44b86b0 3696380f
Show whitespace changes
Inline Side-by-side
Showing with 1009 additions and 15 deletions
sql/v2.2/20250228.sql 0 → 100644
View file @ 7774c515
CREATE TABLE `ecw_batch_order_fee_apply` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
`no` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '编号',
`details` json NOT NULL COMMENT '申请详情',
`reason` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '原因',
`state` tinyint DEFAULT 1 COMMENT '状态：0 已取消 1 申请中 2 已通过 3 已驳回',
`form_id` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '流程表单实例ID',
`creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '创建者',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '更新者',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
`audit` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '审核人',
`audit_time` datetime DEFAULT NULL COMMENT '审核时间',
`deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
PRIMARY KEY (`id`) USING BTREE,
UNIQUE KEY `no_key` (`no`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic COMMENT = '批量费用申请' ;
-- 新增费用申请记录流程类型
alter table ecw_order_fee_application
add COLUMN `bpm_type` tinyint DEFAULT 1 COMMENT '流程类型: 1 费用申请 2 批量订单费用申请' after `bpm_process_id`;
\ No newline at end of file
yudao-framework/yudao-common/src/main/java/cn/iocoder/yudao/framework/common/util/code/CodeUtils.java
View file @ 7774c515
......@@ -15,9 +15,13 @@ public class CodeUtils {
/**
* 收款单类别头
*/
private static final String RECEIPT_CODE = "SKD";
/**
* 收款单类别头
*/
private static final String BATCH_ORDER_FEE_APPLY_NO = "BFA";
/**
* 付款单类别头
*/
......@@ -279,6 +283,35 @@ public class CodeUtils {
}
/**
* 功能描述: 自动生成收款单单单号
*
* @param maxOddNumbers 数据库中的最新单号 BFA20250300001
* @return java.lang.String
*/
public static String getOddBatchOrderFeeApplyNumbers(String maxOddNumbers) {
// 格式： BPA+年份YYYY+月份MM+5位数
int numberLength = 14;
//获取当前日期并将其进行格式化
String formatYearMonth = getDateTime("yyyyMM");
int newEndIntNum;
//判断数据中的最大单号是否存在，是否包含当前日期
if (StringUtils.isNotEmpty(maxOddNumbers) && maxOddNumbers.length() == numberLength &&
maxOddNumbers.substring(3, 9).equals(formatYearMonth)) {
//截取后五位数
String endNum = maxOddNumbers.substring(maxOddNumbers.length() - 5);
//把截取的最后五位数解析为int
int endIntNum = Integer.parseInt(endNum);
//在将其加1(自增1)
newEndIntNum = endIntNum + 1;
} else {
// 如果为空(第一次生成)或者当前最大订单号的日期与当前日期不一致说明需要重新计数生成单号
newEndIntNum = 1;
}
//生成单号，将单号返回
return String.format("%s%s%05d", BATCH_ORDER_FEE_APPLY_NO, formatYearMonth, newEndIntNum);
}
/**
* 功能描述: 自动生成付款单单单号
......@@ -538,10 +571,12 @@ public class CodeUtils {
}
public static void main(String[] args) {
String destCountryCode = "ECW";
String channelCode = "SF";
String maxOddOrderNumbers = "";
System.out.println(getOddOrderNumbers("A2300006", "", "GA", "A", "", false, false));
System.out.println(getOddBatchOrderFeeApplyNumbers("BFA20250300001"));
// String destCountryCode = "ECW";
// String channelCode = "SF";
// String maxOddOrderNumbers = "";
// System.out.println(getOddOrderNumbers("A2300006", "", "GA", "A", "", false, false));
}
}
yudao-module-bpm/yudao-module-bpm-api/src/main/java/cn/iocoder/yudao/module/bpm/enums/WorkFlowEmus.java
View file @ 7774c515
......@@ -9,6 +9,7 @@ public enum WorkFlowEmus {
ORDER_FREE_APPLY("free_apply", "订单审批-费用审核"),
ORDER_BATCH_FREE_APPLY("batch_free_apply", "订单审批-批量费用审核"),
BATCH_ORDER_FREE_APPLY("batch_order_free_apply", "订单审批-批量订单费用审核"),
ORDER_SPECIAL_APPLY("special_apply", "订单审批-特价审核"),
ORDER_SPECIAL_APPLY_BATCH("special_apply_batch", "订单审批-批量特价审核"),
......
yudao-module-bpm/yudao-module-bpm-base/src/main/java/cn/iocoder/yudao/module/bpm/service/order/listener/BpmOrdeBatchOrderFreeApplyResultListener.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.bpm.service.order.listener;
import cn.iocoder.yudao.module.bpm.enums.WorkFlowEmus;
import cn.iocoder.yudao.module.bpm.framework.bpm.core.event.BpmProcessInstanceResultEvent;
import cn.iocoder.yudao.module.bpm.framework.bpm.core.event.BpmProcessInstanceResultEventListener;
import cn.iocoder.yudao.module.order.service.batchOrderFeeApply.BatchOrderFeeApplyService;
import cn.iocoder.yudao.module.order.service.order.OrderFeeApplicationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component
@Slf4j
public class BpmOrdeBatchOrderFreeApplyResultListener extends BpmProcessInstanceResultEventListener {
@Resource
BatchOrderFeeApplyService batchOrderFeeApplyService;
@Override
protected String getProcessDefinitionKey() {
return WorkFlowEmus.BATCH_ORDER_FREE_APPLY.getKey();
}
@Override
protected void onEvent(BpmProcessInstanceResultEvent event) {
log.info("------------------批量订单费用审核回调--------------------------{},{}", event.getBusinessKey(), event.getResult());
batchOrderFeeApplyService.batchOrderFeeApplyCallback(event.getBusinessKey(), event.getResult());
}
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/convert/batchOrderFeeApply/BatchOrderFeeApplyConvert.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.convert.batchOrderFeeApply;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import cn.iocoder.yudao.module.order.vo.batchOrderFeeApply.*;
import cn.iocoder.yudao.module.order.dal.dataobject.batchOrderFeeApply.BatchOrderFeeApplyDO;
/**
* 批量费用申请 Convert
* @author 系统管理员
*/
@Mapper
public interface BatchOrderFeeApplyConvert {
/*****转换MapStruct*****/
BatchOrderFeeApplyConvert INSTANCE = Mappers.getMapper(BatchOrderFeeApplyConvert.class);
/***
* 创建VO转实体
* @param bean
* @return
*/
BatchOrderFeeApplyDO convert(BatchOrderFeeApplyCreateReqVO bean);
/***
* 修改VO转实体
* @param bean
* @return
*/
BatchOrderFeeApplyDO convert(BatchOrderFeeApplyUpdateReqVO bean);
/***
* 实体转返回VO
* @param bean
* @return
*/
BatchOrderFeeApplyBackVO convert(BatchOrderFeeApplyDO bean);
/***
* 实体列表转返回VO列表
* @param list
* @return
*/
List<BatchOrderFeeApplyBackVO> convertList(List<BatchOrderFeeApplyDO> list);
/***
* 实体分页转返回分页
* @param page
* @return
*/
PageResult<BatchOrderFeeApplyBackVO> convertPage(PageResult<BatchOrderFeeApplyDO> page);
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/dal/dataobject/batchOrderFeeApply/BatchOrderFeeApplyDO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.dal.dataobject.batchOrderFeeApply;
import lombok.*;
import java.util.*;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* 批量费用申请 DO
*
* @author 系统管理员
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@TableName("ecw_batch_order_fee_apply")
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BatchOrderFeeApplyDO extends BaseDO {
/**
* 主键
*/
@TableId
private Long id;
/**
* 编号
*/
private String no;
/**
* 申请详情
*/
private String details;
/**
* 原因
*/
private String reason;
/**
* 状态：1 申请中 2 已通过 3 已驳回 4 已取消
*/
private Integer state;
/**
* 流程表单实例ID
*/
private String formId;
/**
* 审核人
*/
private String audit;
/**
* 审核时间
*/
private Date auditTime;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/dal/dataobject/orderFeeApplication/OrderFeeApplicationDO.java
View file @ 7774c515
......@@ -100,6 +100,10 @@ public class OrderFeeApplicationDO extends BaseDO {
* 流程ID
*/
private String bpmProcessId;
/**
* 流程类型：1 费用申请 2 批量订单费用申请
*/
private String bpmType;
/**
* 应收ID
*/
......
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/dal/mysql/batchOrderFeeApply/BatchOrderFeeApplyMapper.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.dal.mysql.batchOrderFeeApply;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQuery;
import cn.iocoder.yudao.framework.mybatis.core.mapper.AbstractMapper;
import cn.iocoder.yudao.module.order.dal.dataobject.batchOrderFeeApply.BatchOrderFeeApplyDO;
import cn.iocoder.yudao.framework.mybatis.core.vo.PageVO;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.order.vo.batchOrderFeeApply.*;
/**
* 批量费用申请 Mapper
* @author 系统管理员
*/
@Mapper
public interface BatchOrderFeeApplyMapper extends AbstractMapper<BatchOrderFeeApplyDO> {
@Override
default PageResult<BatchOrderFeeApplyDO> selectPage(PageVO page, Object object) {
if (object instanceof BatchOrderFeeApplyQueryVO) {
BatchOrderFeeApplyQueryVO vo = (BatchOrderFeeApplyQueryVO)object;
return selectPage(page, new LambdaQuery<BatchOrderFeeApplyDO>()
.eqIfPresent(BatchOrderFeeApplyDO::getNo, vo.getNo())
.eqIfPresent(BatchOrderFeeApplyDO::getDetails, vo.getDetails())
.eqIfPresent(BatchOrderFeeApplyDO::getReason, vo.getReason())
.eqIfPresent(BatchOrderFeeApplyDO::getState, vo.getState())
.betweenIfPresent(BatchOrderFeeApplyDO::getCreateTime, vo.getBeginCreateTime(), vo.getEndCreateTime())
.orderByDesc(BatchOrderFeeApplyDO::getId));
}
return null;
}
@Override
default List<BatchOrderFeeApplyDO> selectList(Object object) {
if (object instanceof BatchOrderFeeApplyQueryVO) {
BatchOrderFeeApplyQueryVO vo = (BatchOrderFeeApplyQueryVO)object;
return selectList(new LambdaQuery<BatchOrderFeeApplyDO>()
.eqIfPresent(BatchOrderFeeApplyDO::getNo, vo.getNo())
.eqIfPresent(BatchOrderFeeApplyDO::getDetails, vo.getDetails())
.eqIfPresent(BatchOrderFeeApplyDO::getReason, vo.getReason())
.eqIfPresent(BatchOrderFeeApplyDO::getState, vo.getState())
.betweenIfPresent(BatchOrderFeeApplyDO::getCreateTime, vo.getBeginCreateTime(), vo.getEndCreateTime())
.orderByDesc(BatchOrderFeeApplyDO::getId));
}
return null;
}
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/enums/ErrorCodeConstants.java
View file @ 7774c515
......@@ -435,7 +435,8 @@ public interface ErrorCodeConstants {
ErrorCode GUAN_LIAN_ORDER_IS_APPROVAL_IN_PROCESS = new ErrorCode(1004001173, "guan.lian.order.is.approval.in.process");
ErrorCode ORDER_UPDATE_BOX_EXCEPTION = new ErrorCode(1004001174, "warehouse.in.box.exception");
ErrorCode BATCH_ORDER_FEE_APPLY_NOT_EXISTS = new ErrorCode(1004001175, "批量费用申请不存在");
ErrorCode BATCH_ORDER_FEE_APPLY_INFO_NOT_EXISTS = new ErrorCode(1004001176, "批量费用申请详情数据不存在");
//订单不是已装柜/已出货，不可操作
......
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/enums/OrderApprovalTypeResultEnum.java
View file @ 7774c515
......@@ -159,6 +159,12 @@ public enum OrderApprovalTypeResultEnum implements IntArrayValuable {
expense_apply_batch_reject(41,3, "fee.application.reject"),
expense_apply_batch_cancel(41,4, "fee.application.cancel"),
//批量订单费用申请
expense_apply_batch_order_processing(42,1, "fee.application.processing"),
expense_apply_batch_order_pass(42,2, "fee.application.pass"),
expense_apply_batch_order_reject(42,3, "fee.application.reject"),
expense_apply_batch_order_cancel(42,4, "fee.application.cancel"),
//分拣
sorting_processing(50,1, "shipment.sorting.processing"),
sorting_pass(50,2, "shipment.sorting.pass"),
......
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/enums/OrderNumberEnum.java
View file @ 7774c515
......@@ -16,6 +16,7 @@ public enum OrderNumberEnum {
PAYMENT_NO(3, "付款单号"),
COMMISSION_PAYMENT_NO(5, "佣金付款单号"),
FOLLOWUP_NO(6, "跟进单号"),
BFA_NO(7, "批量订单申请编号"),
;
/**
* 类型
......
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/service/batchOrderFeeApply/BatchOrderFeeApplyService.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.service.batchOrderFeeApply;
import java.util.*;
import javax.validation.*;
import cn.iocoder.yudao.framework.mybatis.core.vo.PageVO;
import cn.iocoder.yudao.framework.mybatis.core.service.IService;
import cn.iocoder.yudao.module.order.vo.batchOrderFeeApply.*;
import cn.iocoder.yudao.module.order.dal.dataobject.batchOrderFeeApply.BatchOrderFeeApplyDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.order.vo.order.OrderBackVO;
/**
* 批量费用申请 Service 接口
*
* @author 系统管理员
*/
public interface BatchOrderFeeApplyService extends IService<BatchOrderFeeApplyDO> {
/**
* 创建批量费用申请
* @param createReqVO 创建信息
* @return 编号
*/
Long createBatchOrderFeeApply(@Valid BatchOrderFeeApplyCreateReqVO createReqVO);
/**
* 获得批量费用申请
* @param id 编号
* @return 批量费用申请
*/
BatchOrderFeeApplyBackVO getBatchOrderFeeApply(Long id);
/**
* 获得批量费用申请列表
* @param ids 编号
* @return 批量费用申请列表
*/
List<BatchOrderFeeApplyDO> getBatchOrderFeeApplyList(Collection<Long> ids);
/**
* 获得批量费用申请分页
* @param page 分页查询
* @param query 查询
* @return 批量费用申请分页
*/
PageResult<BatchOrderFeeApplyDO> getBatchOrderFeeApplyPage(BatchOrderFeeApplyQueryVO query, PageVO page);
/**
* 获得批量费用申请列表, 用于 Excel 导出
* @param query 查询
* @return 批量费用申请列表
*/
List<BatchOrderFeeApplyDO> getBatchOrderFeeApplyList(BatchOrderFeeApplyQueryVO query);
BatchOrderFeeApplyBackVO getInfoByFormId(Long formId);
List<OrderBackVO> getOrderListByIds(List<Long> orderIds);
/**
* 批量订单费用申请回调
*
* @param id 表单业务ID
* @param result 1 处理中 2 通过 3 不通过 4 已取消
*/
void batchOrderFeeApplyCallback(String id, Integer result);
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/service/batchOrderFeeApply/BatchOrderFeeApplyServiceImpl.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.service.batchOrderFeeApply;
import java.util.*;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.generator.SnowflakeGenerator;
import cn.iocoder.yudao.framework.apollo.core.event.Order.OrderApprovalTypeCheckEvent;
import cn.iocoder.yudao.framework.apollo.core.event.Order.OrderNumberLogEvent;
import cn.iocoder.yudao.framework.common.util.code.CodeUtils;
import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
import cn.iocoder.yudao.framework.dict.core.dto.DictDataRespDTO;
import cn.iocoder.yudao.framework.dict.core.util.DictFrameworkUtils;
import cn.iocoder.yudao.framework.http.util.StrUtils;
import cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils;
import cn.iocoder.yudao.module.bpm.api.BpmCreateServiceFactory;
import cn.iocoder.yudao.module.bpm.enums.WorkFlowEmus;
import cn.iocoder.yudao.module.ecw.dal.dataobject.currency.CurrencyDO;
import cn.iocoder.yudao.module.ecw.service.currency.CurrencyService;
import cn.iocoder.yudao.module.order.dal.dataobject.orderFeeApplication.OrderFeeApplicationDO;
import cn.iocoder.yudao.module.order.enums.OrderApprovalTypeResultEnum;
import cn.iocoder.yudao.module.order.service.order.OrderBusinessService;
import cn.iocoder.yudao.module.order.service.order.OrderFeeApplicationService;
import cn.iocoder.yudao.module.order.service.order.OrderQueryService;
import cn.iocoder.yudao.module.order.service.order.OrderService;
import cn.iocoder.yudao.module.order.vo.order.ApplyInfoVO;
import cn.iocoder.yudao.module.order.vo.order.OrderBackVO;
import cn.iocoder.yudao.module.order.vo.orderFeeApplication.OrderFeeApplicationCreateReqVO;
import cn.iocoder.yudao.module.system.enums.DictTypeConstants;
import cn.iocoder.yudao.module.wealth.dal.dataobject.receipt.ReceiptDO;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import cn.iocoder.yudao.framework.mybatis.core.vo.PageVO;
import cn.iocoder.yudao.framework.mybatis.core.service.AbstractService;
import cn.iocoder.yudao.module.order.vo.batchOrderFeeApply.*;
import cn.iocoder.yudao.module.order.dal.dataobject.batchOrderFeeApply.BatchOrderFeeApplyDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.order.convert.batchOrderFeeApply.BatchOrderFeeApplyConvert;
import cn.iocoder.yudao.module.order.dal.mysql.batchOrderFeeApply.BatchOrderFeeApplyMapper;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.order.enums.ErrorCodeConstants.*;
import static cn.iocoder.yudao.module.order.enums.OrderApprovalTypeEnum.expense_apply;
import static cn.iocoder.yudao.module.order.enums.OrderNumberEnum.BFA_NO;
/**
* 批量费用申请 Service 实现类
*
* @author 系统管理员
*/
@Service
@Validated
public class BatchOrderFeeApplyServiceImpl extends AbstractService<BatchOrderFeeApplyMapper, BatchOrderFeeApplyDO> implements BatchOrderFeeApplyService {
@Resource
private BatchOrderFeeApplyMapper batchOrderFeeApplyMapper;
@Resource
private OrderQueryService orderQueryService;
@Resource
private SnowflakeGenerator snowflakeGenerator;
@Resource
private OrderFeeApplicationService orderFeeApplicationService;
@Resource
private ApplicationContext applicationContext;
@Resource
private BpmCreateServiceFactory bpmCreateServiceFactory;
@Resource
private CurrencyService currencyService;
@Resource
@Lazy
private OrderBusinessService orderBusinessService;
@Resource
private OrderService orderService;
@Override
public Long createBatchOrderFeeApply(BatchOrderFeeApplyCreateReqVO createReqVO) {
if (Objects.isNull(createReqVO.getBatchApplyDetailsInfoVO()) || CollectionUtil.isEmpty(createReqVO.getBatchApplyDetailsInfoVO().getOrderFeeDetailsVOList())) {
throw exception(BATCH_ORDER_FEE_APPLY_INFO_NOT_EXISTS);
}
for (BatchOrderFeeDetailsVO batchOrderFeeDetailsVO : createReqVO.getBatchApplyDetailsInfoVO().getOrderFeeDetailsVOList()) {
OrderApprovalTypeCheckEvent approvalTypeCheckEvent = new OrderApprovalTypeCheckEvent(batchOrderFeeDetailsVO.getOrderId(), null, expense_apply.getValue(), null, false);
applicationContext.publishEvent(approvalTypeCheckEvent);
if (approvalTypeCheckEvent.getResult()) {
throw exception(ORDER_IS_APPROVAL_IN_PROCESS);
}
}
// 插入
BatchOrderFeeApplyDO batchOrderFeeApply = BatchOrderFeeApplyConvert.INSTANCE.convert(createReqVO);
batchOrderFeeApply.setDetails(JsonUtils.toJsonString(createReqVO.getBatchApplyDetailsInfoVO()));
// 批量费用申请编号BFA+年份+月份+五位数；BFA240100001
String no = this.generateNo();
batchOrderFeeApply.setNo(no);
batchOrderFeeApplyMapper.insert(batchOrderFeeApply);
// 发起流程
String formId = bpmCreateServiceFactory.createBmp(SecurityFrameworkUtils.getLoginUserId(),
batchOrderFeeApply.getId(), WorkFlowEmus.BATCH_ORDER_FREE_APPLY.getKey(), batchOrderFeeApply.getNo(), createReqVO.getCopyUserId());
batchOrderFeeApply.setFormId(formId);
batchOrderFeeApplyMapper.updateById(batchOrderFeeApply);
for (BatchOrderFeeDetailsVO batchOrderFeeDetailsVO : createReqVO.getBatchApplyDetailsInfoVO().getOrderFeeDetailsVOList()) {
List<ApplyInfoVO> list = new ArrayList<>();
for (OrderFeeApplicationCreateReqVO orderFeeApplicationCreateReqVO : batchOrderFeeDetailsVO.getOrderFeeApplicationBaseVOList()) {
DictDataRespDTO feeDictDataFromCache = DictFrameworkUtils.getDictDataFromCache(DictTypeConstants.RECEIVABLE_FEE_TYPE, String.valueOf(orderFeeApplicationCreateReqVO.getFeeType()));
DictDataRespDTO payDictDataFromCache = DictFrameworkUtils.getDictDataFromCache(DictTypeConstants.PAYMENT_TYPE, String.valueOf(orderFeeApplicationCreateReqVO.getPayType()));
CurrencyDO currency = currencyService.getCurrency(orderFeeApplicationCreateReqVO.getApplicationFeeCurrency());
String value = "%s: 金额[%s%s], 付款类型[%s], 付款人[%s]";
ApplyInfoVO applyInfoVO = new ApplyInfoVO();
applyInfoVO.setName(String.format("编号[%s]的批量订单费用申请", no));
applyInfoVO.setNewValue(String.format(value, feeDictDataFromCache.getLabel().concat("/").concat(feeDictDataFromCache.getLabelEn()), orderFeeApplicationCreateReqVO.getApplicationFee().toString(),
currency.getTitleZh().concat("/").concat(currency.getTitleEn()),
payDictDataFromCache.getLabel().concat("/").concat(payDictDataFromCache.getLabelEn()),
orderFeeApplicationCreateReqVO.getPayer() == 1 ? "发货人" : "收货人"));
list.add(applyInfoVO);
}
orderBusinessService.addOrderOperateLog(batchOrderFeeDetailsVO.getOrderId(), "", "批量提交费用申请", list);
orderService.updateStatus(batchOrderFeeDetailsVO.getOrderId(), null, null, null, null, null, OrderApprovalTypeResultEnum.expense_apply_batch_order_processing.getType(), OrderApprovalTypeResultEnum.expense_apply_batch_order_processing.getDesc());
}
// TODO 这里是多订单进行的批量审批，没有将审批加入到订单审批业务中，后续看业务是否需要将订单细分审批任务
// 返回
return batchOrderFeeApply.getId();
}
private static final String RECEIPT_NEW_NUMBER = "batch:order:fee:apply";
/**
* 批量费用申请编号BFA+年份+月份+五位数；BFA240100001
*/
private String generateNo() {
OrderNumberLogEvent event = new OrderNumberLogEvent();
event.setType(BFA_NO.getType());
event.setNumberKey(RECEIPT_NEW_NUMBER);
applicationContext.publishEvent(event);
String no = CodeUtils.getOddReceiptNumbers(event.getNumber());
// 更新批量订单费用申请编号最新缓存
// 待将最新编号持久化
event.setNewNumber(no);
applicationContext.publishEvent(event);
return no;
}
@Override
public BatchOrderFeeApplyBackVO getBatchOrderFeeApply(Long id) {
BatchOrderFeeApplyDO batchOrderFeeApply = batchOrderFeeApplyMapper.selectById(id);
if (Objects.isNull(batchOrderFeeApply)) {
throw exception(BATCH_ORDER_FEE_APPLY_NOT_EXISTS);
}
BatchOrderFeeApplyBackVO backVO = BatchOrderFeeApplyConvert.INSTANCE.convert(batchOrderFeeApply);
if (StrUtils.isNotBlank(backVO.getDetails())) {
BatchApplyDetailsInfoVO batchApplyDetailsInfoVO = JsonUtils.parseObject(batchOrderFeeApply.getDetails(), BatchApplyDetailsInfoVO.class);
if (batchApplyDetailsInfoVO != null && CollectionUtil.isNotEmpty(batchApplyDetailsInfoVO.getOrderFeeDetailsVOList())) {
for (BatchOrderFeeDetailsVO batchOrderFeeDetailsVO : batchApplyDetailsInfoVO.getOrderFeeDetailsVOList()) {
OrderBackVO orderBackVO = orderQueryService.getOrder(batchOrderFeeDetailsVO.getOrderId());
batchOrderFeeDetailsVO.setOrderBackVO(orderBackVO);
}
}
backVO.setBatchApplyDetailsInfoVO(batchApplyDetailsInfoVO);
}
return backVO;
}
@Override
public List<BatchOrderFeeApplyDO> getBatchOrderFeeApplyList(Collection<Long> ids) {
return batchOrderFeeApplyMapper.selectBatchIds(ids);
}
@Override
public PageResult<BatchOrderFeeApplyDO> getBatchOrderFeeApplyPage(BatchOrderFeeApplyQueryVO query, PageVO page) {
return batchOrderFeeApplyMapper.selectPage(page, query);
}
@Override
public List<BatchOrderFeeApplyDO> getBatchOrderFeeApplyList(BatchOrderFeeApplyQueryVO query) {
return batchOrderFeeApplyMapper.selectList(query);
}
@Override
public BatchOrderFeeApplyBackVO getInfoByFormId(Long formId) {
BatchOrderFeeApplyDO batchOrderFeeApply = batchOrderFeeApplyMapper.selectOne(new LambdaQueryWrapper<BatchOrderFeeApplyDO>()
.eq(BatchOrderFeeApplyDO::getFormId, formId).orderByDesc(BatchOrderFeeApplyDO::getId).last("limit 1"));
if (Objects.isNull(batchOrderFeeApply)) {
throw exception(BATCH_ORDER_FEE_APPLY_NOT_EXISTS);
}
BatchOrderFeeApplyBackVO backVO = BatchOrderFeeApplyConvert.INSTANCE.convert(batchOrderFeeApply);
if (StrUtils.isNotBlank(backVO.getDetails())) {
BatchApplyDetailsInfoVO batchApplyDetailsInfoVO = JsonUtils.parseObject(batchOrderFeeApply.getDetails(), BatchApplyDetailsInfoVO.class);
if (batchApplyDetailsInfoVO != null && CollectionUtil.isNotEmpty(batchApplyDetailsInfoVO.getOrderFeeDetailsVOList())) {
for (BatchOrderFeeDetailsVO batchOrderFeeDetailsVO : batchApplyDetailsInfoVO.getOrderFeeDetailsVOList()) {
OrderBackVO orderBackVO = orderQueryService.getOrder(batchOrderFeeDetailsVO.getOrderId());
batchOrderFeeDetailsVO.setOrderBackVO(orderBackVO);
}
}
backVO.setBatchApplyDetailsInfoVO(batchApplyDetailsInfoVO);
}
return backVO;
}
@Override
public List<OrderBackVO> getOrderListByIds(List<Long> orderIds) {
return orderIds.stream().map(orderId -> orderQueryService.getOrder(orderId)).collect(Collectors.toList());
}
@Override
public void batchOrderFeeApplyCallback(String id, Integer result) {
if (result == 1) {
return;
}
BatchOrderFeeApplyDO batchOrderFeeApply = batchOrderFeeApplyMapper.selectById(id);
if (Objects.isNull(batchOrderFeeApply)) {
throw exception(BATCH_ORDER_FEE_APPLY_NOT_EXISTS);
}
String audit = String.valueOf(SecurityFrameworkUtils.getLoginUserId());
Date now = new Date();
batchOrderFeeApply.setAudit(audit);
batchOrderFeeApply.setAuditTime(now);
batchOrderFeeApply.setUpdater(audit);
batchOrderFeeApply.setUpdateTime(now);
if (result == 3 || result == 4) {
batchOrderFeeApply.setState(result);
batchOrderFeeApplyMapper.updateById(batchOrderFeeApply);
BatchApplyDetailsInfoVO batchApplyDetailsInfoVO = JsonUtils.parseObject(batchOrderFeeApply.getDetails(), BatchApplyDetailsInfoVO.class);
if (batchApplyDetailsInfoVO != null && CollectionUtil.isNotEmpty(batchApplyDetailsInfoVO.getOrderFeeDetailsVOList())) {
for (BatchOrderFeeDetailsVO batchOrderFeeDetailsVO : batchApplyDetailsInfoVO.getOrderFeeDetailsVOList()) {
List<ApplyInfoVO> list = new ArrayList<>();
for (OrderFeeApplicationCreateReqVO orderFeeApplicationCreateReqVO : batchOrderFeeDetailsVO.getOrderFeeApplicationBaseVOList()) {
DictDataRespDTO feeDictDataFromCache = DictFrameworkUtils.getDictDataFromCache(DictTypeConstants.RECEIVABLE_FEE_TYPE, String.valueOf(orderFeeApplicationCreateReqVO.getFeeType()));
DictDataRespDTO payDictDataFromCache = DictFrameworkUtils.getDictDataFromCache(DictTypeConstants.PAYMENT_TYPE, String.valueOf(orderFeeApplicationCreateReqVO.getPayType()));
CurrencyDO currency = currencyService.getCurrency(orderFeeApplicationCreateReqVO.getApplicationFeeCurrency());
String value = "%s: 金额[%s%s], 付款类型[%s], 付款人[%s]";
ApplyInfoVO applyInfoVO = new ApplyInfoVO();
String name = String.format(result == 3?"编号[%s]的批量订单费用申请拒绝":"编号[%s]的批量订单费用申请取消", batchOrderFeeApply.getNo());
applyInfoVO.setName(name);
applyInfoVO.setNewValue(String.format(value, feeDictDataFromCache.getLabel().concat("/").concat(feeDictDataFromCache.getLabelEn()), orderFeeApplicationCreateReqVO.getApplicationFee().toString(),
currency.getTitleZh().concat("/").concat(currency.getTitleEn()),
payDictDataFromCache.getLabel().concat("/").concat(payDictDataFromCache.getLabelEn()),
orderFeeApplicationCreateReqVO.getPayer() == 1 ? "发货人" : "收货人"));
list.add(applyInfoVO);
}
orderBusinessService.addOrderOperateLog(batchOrderFeeDetailsVO.getOrderId(), "", "批量提交费用申请", list);
orderService.updateStatus(batchOrderFeeDetailsVO.getOrderId(), null, null, null, null, null, OrderApprovalTypeResultEnum.expense_apply_batch_order_processing.getType(), OrderApprovalTypeResultEnum.expense_apply_batch_order_processing.getDesc());
}
}
return;
}
if (StrUtils.isNotBlank(batchOrderFeeApply.getDetails())) {
BatchApplyDetailsInfoVO batchApplyDetailsInfoVO = JsonUtils.parseObject(batchOrderFeeApply.getDetails(), BatchApplyDetailsInfoVO.class);
if (Objects.isNull(batchApplyDetailsInfoVO) || CollectionUtil.isEmpty(batchApplyDetailsInfoVO.getOrderFeeDetailsVOList())) {
throw exception(BATCH_ORDER_FEE_APPLY_INFO_NOT_EXISTS);
}
for (BatchOrderFeeDetailsVO batchOrderFeeDetailsVO : batchApplyDetailsInfoVO.getOrderFeeDetailsVOList()) {
// TODO 保存订单费用申请信息
orderFeeApplicationService.saveFeeBatchApplication(batchOrderFeeDetailsVO.getOrderId(),
batchOrderFeeDetailsVO.getOrderFeeApplicationBaseVOList(),
batchOrderFeeApply.getCreator(),
audit,
now,
batchOrderFeeApply.getFormId()
);
List<ApplyInfoVO> list = new ArrayList<>();
for (OrderFeeApplicationCreateReqVO orderFeeApplicationCreateReqVO : batchOrderFeeDetailsVO.getOrderFeeApplicationBaseVOList()) {
DictDataRespDTO feeDictDataFromCache = DictFrameworkUtils.getDictDataFromCache(DictTypeConstants.RECEIVABLE_FEE_TYPE, String.valueOf(orderFeeApplicationCreateReqVO.getFeeType()));
DictDataRespDTO payDictDataFromCache = DictFrameworkUtils.getDictDataFromCache(DictTypeConstants.PAYMENT_TYPE, String.valueOf(orderFeeApplicationCreateReqVO.getPayType()));
CurrencyDO currency = currencyService.getCurrency(orderFeeApplicationCreateReqVO.getApplicationFeeCurrency());
String value = "%s: 金额[%s%s], 付款类型[%s], 付款人[%s]";
ApplyInfoVO applyInfoVO = new ApplyInfoVO();
applyInfoVO.setName(String.format("编号[%s]的批量订单费用申请通过", batchOrderFeeApply.getNo()));
applyInfoVO.setNewValue(String.format(value, feeDictDataFromCache.getLabel().concat("/").concat(feeDictDataFromCache.getLabelEn()), orderFeeApplicationCreateReqVO.getApplicationFee().toString(),
currency.getTitleZh().concat("/").concat(currency.getTitleEn()),
payDictDataFromCache.getLabel().concat("/").concat(payDictDataFromCache.getLabelEn()),
orderFeeApplicationCreateReqVO.getPayer() == 1 ? "发货人" : "收货人"));
list.add(applyInfoVO);
}
orderBusinessService.addOrderOperateLog(batchOrderFeeDetailsVO.getOrderId(), "", "批量提交费用申请", list);
orderService.updateStatus(batchOrderFeeDetailsVO.getOrderId(), null, null, null, null, null, OrderApprovalTypeResultEnum.expense_apply_batch_order_processing.getType(), OrderApprovalTypeResultEnum.expense_apply_batch_order_processing.getDesc());
}
}
}
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/service/order/OrderFeeApplicationService.java
View file @ 7774c515
......@@ -8,6 +8,7 @@ import cn.iocoder.yudao.module.order.vo.orderFeeApplication.*;
import javax.validation.Valid;
import java.util.Collection;
import java.util.Date;
import java.util.List;
/**
......@@ -100,4 +101,15 @@ public interface OrderFeeApplicationService extends IService<OrderFeeApplication
void cancelFeeApplication(OrderFeeApplicationUpdateReqVO orderFeeApplicationUpdateReqVO);
OrderFeeApplicationBackVO getApprovalFeeApplication(Long id);
/**
* @param orderId 订单ID
* @param orderFeeApplicationBaseVOList 订单费用申请详情列表
* @param audit 审批人
* @param now 审批时间
* @param formId 流程实例id
*/
void saveFeeBatchApplication(Long orderId, List<OrderFeeApplicationCreateReqVO> orderFeeApplicationBaseVOList,
String creator, String audit, Date now, String formId);
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/service/order/impl/OrderFeeApplicationServiceImpl.java
View file @ 7774c515
......@@ -51,10 +51,7 @@ import org.springframework.validation.annotation.Validated;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.*;
import java.util.stream.Collectors;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
......@@ -94,7 +91,6 @@ public class OrderFeeApplicationServiceImpl extends AbstractService<OrderFeeAppl
@Resource
private AdminUserService adminUserService;
@Resource
private CurrencyService currencyService;
@Resource
......@@ -716,4 +712,53 @@ public class OrderFeeApplicationServiceImpl extends AbstractService<OrderFeeAppl
}
return convert;
}
@Override
public void saveFeeBatchApplication(Long orderId, List<OrderFeeApplicationCreateReqVO> orderFeeApplicationBaseVOList,
String creator, String audit, Date now, String formId) {
OrderApprovalTypeCheckEvent approvalTypeCheckEvent = new OrderApprovalTypeCheckEvent(orderId, null, expense_apply.getValue(), null, false);
applicationContext.publishEvent(approvalTypeCheckEvent);
if (approvalTypeCheckEvent.getResult()) {
throw exception(ORDER_IS_APPROVAL_IN_PROCESS);
}
//查询订单信息
OrderDO orderDO = orderService.getById(orderId);
List<FeeDto> feeDtos = new ArrayList<>();
for (OrderFeeApplicationCreateReqVO orderFeeApplicationBaseVO : orderFeeApplicationBaseVOList) {
OrderFeeApplicationDO feeApplicationDO = OrderFeeApplicationConvert.INSTANCE.convert(orderFeeApplicationBaseVO);
feeApplicationDO.setCreateTime(now);
feeApplicationDO.setCreator(creator);
feeApplicationDO.setUpdater(audit);
feeApplicationDO.setUpdateTime(now);
feeApplicationDO.setBpmProcessId(formId);
//生成应收
DictDataRespDTO dictDto = DictFrameworkUtils.getDictDataFromCache("receivable_fee_type", String.valueOf(feeApplicationDO.getFeeType()));
ReceivableCreateReqVO receivableCreateReqVO = new ReceivableCreateReqVO();
receivableCreateReqVO.setTitleZh(dictDto.getLabel());
receivableCreateReqVO.setTitleEn(dictDto.getLabelEn());
receivableCreateReqVO.setOrderId(feeApplicationDO.getOrderId());
receivableCreateReqVO.setOrderNo(orderDO.getOrderNo());
receivableCreateReqVO.setTotalAmount(feeApplicationDO.getApplicationFee());
receivableCreateReqVO.setUnitPrice(feeApplicationDO.getApplicationFee());
receivableCreateReqVO.setCollectionType(feeApplicationDO.getPayType());
receivableCreateReqVO.setCurrencyId(Long.valueOf(feeApplicationDO.getApplicationFeeCurrency()));
receivableCreateReqVO.setFeeType(feeApplicationDO.getFeeType());
receivableCreateReqVO.setIsPayAdvance(feeApplicationDO.getPayType() == 4 ? 0 : 1);
receivableCreateReqVO.setState(feeApplicationDO.getReceiveFlag());
receivableCreateReqVO.setPaymentUser(String.valueOf(Objects.nonNull(feeApplicationDO.getPayer()) ? feeApplicationDO.getPayer(): (getPayer(orderDO, feeApplicationDO))));//6待修改
receivableCreateReqVO.setFeeSource(2);
receivableCreateReqVO.setAuthor(feeApplicationDO.getApplicationAuthor());
receivableCreateReqVO.setRemark(feeApplicationDO.getRemarks());
Long receivableId = receivableService.createReceivable(receivableCreateReqVO);
feeApplicationDO.setReceivableId(receivableId.intValue());
feeApplicationDO.setStatus(2);
feeApplicationMapper.insert(feeApplicationDO);
FeeDto feeDto = new FeeDto();
feeDto.setFeeType(feeApplicationDO.getFeeType());
feeDto.setAmount(feeApplicationDO.getApplicationFee());
feeDto.setCurrencyId(feeApplicationDO.getApplicationFeeCurrency());
feeDtos.add(feeDto);
}
orderService.addOrderOtherFee(orderId, feeDtos);
}
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/batchOrderFeeApply/BatchApplyDetailsInfoVO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.batchOrderFeeApply;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
@Data
@ApiModel("批量申请详情")
public class BatchApplyDetailsInfoVO {
@ApiModelProperty("费用申请明细")
private List<BatchFeeDetailsVO> feeDetailsVOList;
@ApiModelProperty("订单费用申请明细")
private List<BatchOrderFeeDetailsVO> orderFeeDetailsVOList;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/batchOrderFeeApply/BatchFeeDetailsVO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.batchOrderFeeApply;
import cn.iocoder.yudao.framework.excel.annotations.DictFormat;
import cn.iocoder.yudao.framework.excel.convert.DictConvert;
import com.alibaba.excel.annotation.ExcelProperty;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.math.BigDecimal;
@Data
@ApiModel("费用明细")
public class BatchFeeDetailsVO {
@ExcelProperty(value = "费用类型", converter = DictConvert.class)
@DictFormat("fee_type") // TODO 代码优化：建议设置到对应的 XXXDictTypeConstants 枚举类中
@ApiModelProperty(value = "费用类型", required = true)
private Integer feeType;
@ExcelProperty("费用申请金额")
@ApiModelProperty(value = "费用申请金额", required = true)
private BigDecimal applicationFee;
@ExcelProperty(value = "费用申请货币类型", converter = DictConvert.class)
@ApiModelProperty(value = "费用申请货币类型", required = true)
private Integer applicationFeeCurrency;
@ExcelProperty(value = "付款类型", converter = DictConvert.class)
@DictFormat("pay_type") // TODO 代码优化：建议设置到对应的 XXXDictTypeConstants 枚举类中
@ApiModelProperty(value = "付款类型", required = true)
private Integer payType;
@ApiModelProperty(value = "付款人：0 按订单 1 发货人 2 收货人", required = true)
private Integer payer;
@ApiModelProperty(value = "计量单位：计量单位\n" +
"票，指的是每个订单都添加加同样金额的费用\n" +
"收费体积：按订单的收费体积计算，金额是单价，例如订单收费体积是34m³，则订单添加的清关费金额=170,000\n" +
"入仓体积：按订单的入仓体积计算，金额是单价，例如订单收费体积是34m³，则订单添加的清关费金额=170,000\n" +
"收费重量：按订单的入仓体积计算，金额是单价，例如订单收费体积是34KG，则订单添加的清关费金额=170,000\n" +
"入仓重量：按订单的入仓体积计算，金额是单价，例如订单收费体积是34KG，则订单添加的清关费金额=170,000", required = true)
private Integer unitMeasurement;
@ExcelProperty("备注")
@ApiModelProperty(value = "备注")
private String remarks;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/batchOrderFeeApply/BatchOrderFeeApplyBackVO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.batchOrderFeeApply;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import com.alibaba.excel.annotation.ExcelProperty;
import org.springframework.format.annotation.DateTimeFormat;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
/**
* 批量费用申请 Response VO
* @author 系统管理员
*/
@Data
@ApiModel("管理后台 - 批量费用申请 Response VO")
public class BatchOrderFeeApplyBackVO {
@ExcelProperty("主键")
@ApiModelProperty(value = "主键", required = true)
private Long id;
@ExcelProperty("编号")
@ApiModelProperty(value = "编号", required = true)
private String no;
@ExcelProperty("申请详情")
@ApiModelProperty(value = "申请详情", required = true)
private String details;
@ExcelProperty("原因")
@ApiModelProperty(value = "原因")
private String reason;
@ExcelProperty("状态：0 已取消 1 申请中 2 已通过 3 已驳回")
@ApiModelProperty(value = "状态：0 已取消 1 申请中 2 已通过 3 已驳回")
private Integer state;
@ExcelProperty("流程表单实例ID")
@ApiModelProperty(value = "流程表单实例ID")
private String formId;
@ExcelProperty("创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
@ApiModelProperty(value = "创建时间", required = true)
private Date createTime;
@ApiModelProperty("批量申请详情信息")
private BatchApplyDetailsInfoVO batchApplyDetailsInfoVO;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/batchOrderFeeApply/BatchOrderFeeApplyBaseVO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.batchOrderFeeApply;
import lombok.*;
import io.swagger.annotations.*;
import javax.validation.constraints.*;
/**
* 批量费用申请 Base VO，提供给添加、修改、详细的子 VO 使用
* 如果子 VO 存在差异的字段，请不要添加到这里，影响 Swagger 文档生成
*/
@Data
public class BatchOrderFeeApplyBaseVO {
@ApiModelProperty(value = "编号", required = true)
@NotNull(message = "编号不能为空")
private String no;
@ApiModelProperty(value = "申请详情", required = true)
@NotNull(message = "申请详情不能为空")
private String details;
@ApiModelProperty(value = "原因")
private String reason;
@ApiModelProperty(value = "状态：0 已取消 1 申请中 2 已通过 3 已驳回")
private Integer state;
@ApiModelProperty("批量申请详情信息")
private BatchApplyDetailsInfoVO batchApplyDetailsInfoVO;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/batchOrderFeeApply/BatchOrderFeeApplyCreateReqVO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.batchOrderFeeApply;
import lombok.*;
import io.swagger.annotations.*;
@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@ApiModel("管理后台 - 批量费用申请创建 Request VO")
public class BatchOrderFeeApplyCreateReqVO extends BatchOrderFeeApplyBaseVO {
@ApiModelProperty(value = "抄送人userId")
String[] copyUserId;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/batchOrderFeeApply/BatchOrderFeeApplyQueryVO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.batchOrderFeeApply;
import lombok.*;
import java.util.*;
import io.swagger.annotations.*;
import org.springframework.format.annotation.DateTimeFormat;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Data
@ApiModel("管理后台 - 批量费用申请查询 VO")
public class BatchOrderFeeApplyQueryVO {
@ApiModelProperty(value = "编号")
private String no;
@ApiModelProperty(value = "申请详情")
private String details;
@ApiModelProperty(value = "原因")
private String reason;
@ApiModelProperty(value = "状态：0 已取消 1 申请中 2 已通过 3 已驳回")
private Integer state;
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
@ApiModelProperty(value = "开始创建时间")
private Date beginCreateTime;
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
@ApiModelProperty(value = "结束创建时间")
private Date endCreateTime;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/batchOrderFeeApply/BatchOrderFeeApplyUpdateReqVO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.batchOrderFeeApply;
import lombok.*;
import io.swagger.annotations.*;
import javax.validation.constraints.*;
@ApiModel("管理后台 - 批量费用申请更新 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class BatchOrderFeeApplyUpdateReqVO extends BatchOrderFeeApplyBaseVO {
@ApiModelProperty(value = "主键", required = true)
@NotNull(message = "主键不能为空")
private Long id;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/batchOrderFeeApply/BatchOrderFeeDetailsVO.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.batchOrderFeeApply;
import cn.iocoder.yudao.module.order.vo.order.OrderBackVO;
import cn.iocoder.yudao.module.order.vo.orderFeeApplication.OrderFeeApplicationCreateReqVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
@Data
@ApiModel("订单费用明细")
public class BatchOrderFeeDetailsVO {
@ApiModelProperty("订单ID")
private Long orderId;
@ApiModelProperty("订单详情")
private OrderBackVO orderBackVO;
@ApiModelProperty("订单费用申请详情(数据格式同步参考订单费用申请功能页面)")
private List<OrderFeeApplicationCreateReqVO> orderFeeApplicationBaseVOList;
}
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/orderFeeApplication/OrderFeeApplicationBackVO.java
View file @ 7774c515
......@@ -96,6 +96,10 @@ public class OrderFeeApplicationBackVO {
@ApiModelProperty(value = "审批流程编号")
private String bpmProcessId;
@ExcelProperty("流程类型：1 费用申请 2 批量订单费用申请")
@ApiModelProperty(value = "流程类型：1 费用申请 2 批量订单费用申请")
private String bpmType;
@ExcelProperty("批量费用审核时业务主键ID")
@ApiModelProperty(value = "批量费用审核时业务主键ID")
private String batchBpmBusinessId;
......
yudao-module-order/yudao-module-order-core/src/main/java/cn/iocoder/yudao/module/order/vo/orderFeeApplication/OrderFeeApplicationBaseVO.java
View file @ 7774c515
package cn.iocoder.yudao.module.order.vo.orderFeeApplication;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.*;
import java.math.BigDecimal;
......@@ -73,4 +74,7 @@ public class OrderFeeApplicationBaseVO {
*/
@ApiModelProperty(value = "流程ID")
private String bpmProcessId;
@ApiModelProperty(value = "流程类型：1 费用申请 2 批量订单费用申请")
private String bpmType;
}
yudao-module-order/yudao-module-order-rest/src/main/java/cn/iocoder/yudao/module/order/controller/admin/batchOrderFeeApply/BatchOrderFeeApplyController.java 0 → 100644
View file @ 7774c515
package cn.iocoder.yudao.module.order.controller.admin.batchOrderFeeApply;
import cn.iocoder.yudao.framework.mybatis.core.vo.PageVO;
import cn.iocoder.yudao.module.order.vo.order.OrderBackVO;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.annotations.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import cn.iocoder.yudao.framework.excel.util.ExcelUtils;
import cn.iocoder.yudao.framework.operatelog.core.annotations.OperateLog;
import static cn.iocoder.yudao.framework.operatelog.core.enums.OperateTypeEnum.*;
import cn.iocoder.yudao.module.order.vo.batchOrderFeeApply.*;
import cn.iocoder.yudao.module.order.dal.dataobject.batchOrderFeeApply.BatchOrderFeeApplyDO;
import cn.iocoder.yudao.module.order.convert.batchOrderFeeApply.BatchOrderFeeApplyConvert;
import cn.iocoder.yudao.module.order.service.batchOrderFeeApply.BatchOrderFeeApplyService;
@Validated
@RestController
@Api(tags = "管理后台 - 批量费用申请")
@RequestMapping("/ecw/batch-order-fee-apply")
public class BatchOrderFeeApplyController {
@Resource
private BatchOrderFeeApplyService batchOrderFeeApplyService;
@PostMapping("/create")
@ApiOperation("创建批量费用申请")
@PreAuthorize("@ss.hasPermission('ecw:batch-order-fee-apply:create')")
public CommonResult<Long> createBatchOrderFeeApply(@Valid @RequestBody BatchOrderFeeApplyCreateReqVO createReqVO) {
return success(batchOrderFeeApplyService.createBatchOrderFeeApply(createReqVO));
}
@PostMapping("/getOrderListByIds")
@ApiOperation("批量获取需要申请费用的订单详情")
@ApiImplicitParam(name = "orderIds", value = "订单ids", required = true, example = "1024,2048,3072,4096", dataTypeClass = List.class)
@PreAuthorize("@ss.hasPermission('ecw:batch-order-fee-apply:query')")
public CommonResult<List<OrderBackVO>> getOrderListByIds(List<Long> orderIds) {
return success(batchOrderFeeApplyService.getOrderListByIds(orderIds));
}
@GetMapping("/info")
@ApiOperation("获得批量费用申请详情")
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('ecw:batch-order-fee-apply:query')")
public CommonResult<BatchOrderFeeApplyBackVO> info(@RequestParam("id") Long id) {
return success(batchOrderFeeApplyService.getBatchOrderFeeApply(id));
}
@GetMapping("/getInfoByFormId")
@ApiOperation("根据流程实例id获得批量费用申请详情")
@ApiImplicitParam(name = "id", value = "编号", required = true, example = "1024", dataTypeClass = Long.class)
@PreAuthorize("@ss.hasPermission('ecw:batch-order-fee-apply:query')")
public CommonResult<BatchOrderFeeApplyBackVO> getInfoByFormId(@RequestParam("formId") Long formId) {
return success(batchOrderFeeApplyService.getInfoByFormId(formId));
}
@GetMapping("/page")
@ApiOperation("获得批量费用申请分页")
@PreAuthorize("@ss.hasPermission('ecw:batch-order-fee-apply:query')")
public CommonResult<PageResult<BatchOrderFeeApplyBackVO>> getBatchOrderFeeApplyPage(@Valid BatchOrderFeeApplyQueryVO query, PageVO page) {
PageResult<BatchOrderFeeApplyDO> pageResult = batchOrderFeeApplyService.getBatchOrderFeeApplyPage(query, page);
return success(BatchOrderFeeApplyConvert.INSTANCE.convertPage(pageResult));
}
}
yudao-module-shipment/yudao-module-shipment-core/src/main/java/cn/iocoder/yudao/module/shipment/dal/dataobject/BoxDO.java
View file @ 7774c515
......@@ -79,7 +79,7 @@ public class BoxDO extends BaseDO {
*/
private Date qgDate;
/**
* 提货时间
* 提货时间 -> 实际已改为卸柜时间
*/
private Date thDate;
......
yudao-module-shipment/yudao-module-shipment-core/src/main/java/cn/iocoder/yudao/module/shipment/vo/box/BoxBaseBackVO.java
View file @ 7774c515
......@@ -116,12 +116,19 @@ public class BoxBaseBackVO {
@ApiModelProperty(value = "到仓时间")
private Date dcDate;
@ExcelProperty("提货时间")
@ExcelProperty("提货时间-> 实际已改为卸柜时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
@JsonFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
@ApiModelProperty(value = "提货时间")
@ApiModelProperty(value = "提货时间-> 实际已改为卸柜时间")
private Date thDate;
@ExcelProperty("出仓时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
@JsonFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
@ApiModelProperty(value = "出仓时间")
private Date ckDate;
@ExcelProperty(value = "订舱状态")
@ApiModelProperty(value = "订舱状态")
private Integer bkStatus;
......
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