package com.webmanage.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
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.webmanage.common.BusinessException;
|
import com.webmanage.common.PageResult;
|
import com.webmanage.dto.CreateOrderDTO;
|
import com.webmanage.dto.CreateOrderItemDTO;
|
import com.webmanage.dto.OrderQueryDTO;
|
import com.webmanage.entity.OrderAttachment;
|
import com.webmanage.entity.OrderDetail;
|
import com.webmanage.entity.OrderEvaluation;
|
import com.webmanage.entity.OrderInfo;
|
import com.webmanage.mapper.OrderAttachmentMapper;
|
import com.webmanage.mapper.OrderDetailMapper;
|
import com.webmanage.mapper.OrderEvaluationMapper;
|
import com.webmanage.mapper.OrderInfoMapper;
|
import com.webmanage.service.OrderInfoService;
|
import com.webmanage.service.OrderNoService;
|
import com.webmanage.vo.OrderAttachmentVO;
|
import com.webmanage.vo.OrderDetailItemVO;
|
import com.webmanage.vo.OrderDetailVO;
|
import com.webmanage.vo.OrderEvaluationVO;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.StringUtils;
|
|
import javax.annotation.Resource;
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
/**
|
* 订单信息Service实现类
|
*/
|
@Slf4j
|
@Service
|
public class OrderInfoServiceImpl extends ServiceImpl<OrderInfoMapper, OrderInfo> implements OrderInfoService {
|
|
@Resource
|
private OrderDetailMapper orderDetailMapper;
|
|
@Resource
|
private OrderAttachmentMapper orderAttachmentMapper;
|
|
@Resource
|
private OrderEvaluationMapper orderEvaluationMapper;
|
|
@Resource
|
private OrderNoService orderNoService;
|
|
@Override
|
public PageResult<OrderInfo> getBuyerOrderPage(OrderQueryDTO queryDTO) {
|
// 参数校验
|
if (queryDTO.getUserId() == null) {
|
throw new BusinessException("用户ID不能为空");
|
}
|
|
// 创建分页对象
|
Page<OrderInfo> page = new Page<>(queryDTO.getPageNum(), queryDTO.getPageSize());
|
|
// 执行分页查询
|
IPage<OrderInfo> result = baseMapper.selectBuyerOrderPage(
|
page, queryDTO.getUserId(), queryDTO.getUnitId(), queryDTO.getOrderStatus(),
|
queryDTO.getPaymentStatus(), queryDTO.getPaymentType(), queryDTO.getProductName(),
|
queryDTO.getProviderName(), queryDTO.getOrderId(),
|
queryDTO.getApplyTimeStart() != null ? queryDTO.getApplyTimeStart().toString() : null,
|
queryDTO.getApplyTimeEnd() != null ? queryDTO.getApplyTimeEnd().toString() : null,
|
queryDTO.getCreateTimeStart() != null ? queryDTO.getCreateTimeStart().toString() : null,
|
queryDTO.getCreateTimeEnd() != null ? queryDTO.getCreateTimeEnd().toString() : null,
|
queryDTO.getOrderBy(), queryDTO.getOrderDirection()
|
);
|
|
// 构建返回结果
|
return new PageResult<OrderInfo>(
|
result.getRecords(),
|
result.getTotal(),
|
queryDTO.getPageNum().longValue(),
|
queryDTO.getPageSize().longValue(),
|
result.getPages()
|
);
|
}
|
|
@Override
|
public PageResult<OrderInfo> getSellerOrderPage(OrderQueryDTO queryDTO) {
|
// 参数校验
|
if (queryDTO.getUserId() == null) {
|
throw new BusinessException("用户ID不能为空");
|
}
|
|
// 创建分页对象
|
Page<OrderInfo> page = new Page<>(queryDTO.getPageNum(), queryDTO.getPageSize());
|
|
// 执行分页查询
|
IPage<OrderInfo> result = baseMapper.selectSellerOrderPage(
|
page, queryDTO.getUserId(), queryDTO.getOrderStatus(), queryDTO.getPaymentStatus(),
|
queryDTO.getProductName(), queryDTO.getOrderId(),
|
queryDTO.getApplyTimeStart() != null ? queryDTO.getApplyTimeStart().toString() : null,
|
queryDTO.getApplyTimeEnd() != null ? queryDTO.getApplyTimeEnd().toString() : null,
|
queryDTO.getCreateTimeStart() != null ? queryDTO.getCreateTimeStart().toString() : null,
|
queryDTO.getCreateTimeEnd() != null ? queryDTO.getCreateTimeEnd().toString() : null,
|
queryDTO.getOrderBy(), queryDTO.getOrderDirection()
|
);
|
|
// 构建返回结果
|
return new PageResult<OrderInfo>(
|
result.getRecords(),
|
result.getTotal(),
|
queryDTO.getPageNum().longValue(),
|
queryDTO.getPageSize().longValue(),
|
result.getPages()
|
);
|
}
|
|
@Override
|
public PageResult<OrderInfo> getPendingApprovalOrderPage(OrderQueryDTO queryDTO) {
|
// 创建分页对象
|
Page<OrderInfo> page = new Page<>(queryDTO.getPageNum(), queryDTO.getPageSize());
|
|
// 执行分页查询
|
IPage<OrderInfo> result = baseMapper.selectPendingApprovalOrderPage(
|
page, queryDTO.getOrderStatus(), queryDTO.getProductName(), queryDTO.getProviderName(),
|
queryDTO.getOrderId(),
|
queryDTO.getApplyTimeStart() != null ? queryDTO.getApplyTimeStart().toString() : null,
|
queryDTO.getApplyTimeEnd() != null ? queryDTO.getApplyTimeEnd().toString() : null,
|
queryDTO.getOrderBy(), queryDTO.getOrderDirection()
|
);
|
|
// 构建返回结果
|
return new PageResult<OrderInfo>(
|
result.getRecords(),
|
result.getTotal(),
|
queryDTO.getPageNum().longValue(),
|
queryDTO.getPageSize().longValue(),
|
result.getPages()
|
);
|
}
|
|
@Override
|
public OrderDetailVO getOrderDetail(String orderId) {
|
// 参数校验
|
if (!StringUtils.hasText(orderId)) {
|
throw new BusinessException("订单ID不能为空");
|
}
|
|
// 查询订单基本信息
|
OrderInfo orderInfo = this.getById(orderId);
|
if (orderInfo == null) {
|
throw new BusinessException("订单不存在");
|
}
|
|
// 构建订单详情VO
|
OrderDetailVO orderDetailVO = new OrderDetailVO();
|
BeanUtils.copyProperties(orderInfo, orderDetailVO);
|
|
// 查询订单详情列表
|
List<OrderDetail> orderDetails = orderDetailMapper.selectByOrderId(orderId);
|
List<OrderDetailItemVO> orderDetailItemVOs = orderDetails.stream().map(detail -> {
|
OrderDetailItemVO itemVO = new OrderDetailItemVO();
|
BeanUtils.copyProperties(detail, itemVO);
|
return itemVO;
|
}).collect(Collectors.toList());
|
orderDetailVO.setOrderDetails(orderDetailItemVOs);
|
|
// 查询订单附件列表
|
List<OrderAttachment> attachments = orderAttachmentMapper.selectByOrderId(orderId);
|
List<OrderAttachmentVO> attachmentVOs = attachments.stream().map(attachment -> {
|
OrderAttachmentVO attachmentVO = new OrderAttachmentVO();
|
BeanUtils.copyProperties(attachment, attachmentVO);
|
return attachmentVO;
|
}).collect(Collectors.toList());
|
orderDetailVO.setAttachments(attachmentVOs);
|
|
// 查询订单评价
|
OrderEvaluation evaluation = orderEvaluationMapper.selectByOrderId(orderId);
|
if (evaluation != null) {
|
OrderEvaluationVO evaluationVO = new OrderEvaluationVO();
|
BeanUtils.copyProperties(evaluation, evaluationVO);
|
orderDetailVO.setEvaluation(evaluationVO);
|
}
|
|
return orderDetailVO;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public String createOrder(CreateOrderDTO createOrderDTO) {
|
if (createOrderDTO == null || CollectionUtils.isEmpty(createOrderDTO.getItems())) {
|
throw new BusinessException("订单信息不完整");
|
}
|
// 生成订单编号
|
String orderId = orderNoService.generateOrderNo();
|
|
// 计算总金额
|
BigDecimal totalAmount = BigDecimal.ZERO;
|
for (CreateOrderItemDTO item : createOrderDTO.getItems()) {
|
BigDecimal unitPrice = item.getUnitPrice();
|
Integer quantity = item.getQuantity();
|
if (unitPrice == null || quantity == null || quantity <= 0) {
|
throw new BusinessException("明细项单价或数量不合法");
|
}
|
BigDecimal lineAmount = unitPrice.multiply(BigDecimal.valueOf(quantity));
|
totalAmount = totalAmount.add(lineAmount);
|
}
|
|
// 保存订单头
|
OrderInfo orderInfo = new OrderInfo();
|
orderInfo.setOrderId(orderId);
|
orderInfo.setProductId(createOrderDTO.getItems().get(0).getProductId());
|
orderInfo.setProductName(createOrderDTO.getProductName());
|
orderInfo.setProviderId(createOrderDTO.getProviderId());
|
orderInfo.setProviderName(createOrderDTO.getProviderName());
|
orderInfo.setUserId(createOrderDTO.getUserId());
|
orderInfo.setUnitId(createOrderDTO.getUnitId());
|
orderInfo.setApplyTime(LocalDateTime.now());
|
orderInfo.setOrderStatus("待审批");
|
orderInfo.setTotalAmount(createOrderDTO.getTotalAmount() != null ? createOrderDTO.getTotalAmount() : totalAmount);
|
orderInfo.setPaymentType(createOrderDTO.getPaymentType());
|
orderInfo.setPaymentStatus("未支付");
|
orderInfo.setBuyerRemarks(createOrderDTO.getBuyerRemarks());
|
orderInfo.setCreatedAt(LocalDateTime.now());
|
orderInfo.setUpdatedAt(LocalDateTime.now());
|
|
int inserted = this.baseMapper.insert(orderInfo);
|
if (inserted <= 0) {
|
throw new BusinessException("保存订单失败");
|
}
|
|
// 保存订单明细
|
for (CreateOrderItemDTO item : createOrderDTO.getItems()) {
|
OrderDetail detail = new OrderDetail();
|
detail.setOrderId(orderId);
|
detail.setPricingId(item.getPricingId());
|
detail.setProductId(item.getProductId());
|
detail.setSuiteName(item.getSuiteName());
|
detail.setSalesForm(item.getSalesForm());
|
detail.setCustomerType(item.getCustomerType());
|
detail.setAccountLimit(item.getAccountLimit());
|
detail.setConcurrentNodes(item.getConcurrentNodes());
|
detail.setPriceType(item.getPriceType());
|
detail.setPriceUnit(item.getPriceUnit());
|
detail.setUnitPrice(item.getUnitPrice());
|
detail.setQuantity(item.getQuantity());
|
detail.setDuration(item.getDuration());
|
BigDecimal lineAmount = item.getUnitPrice().multiply(BigDecimal.valueOf(item.getQuantity()));
|
detail.setTotalPrice(item.getTotalPrice() != null ? item.getTotalPrice() : lineAmount);
|
detail.setProviderId(item.getProviderId());
|
detail.setProviderName(item.getProviderName());
|
detail.setRemarks(item.getRemarks());
|
detail.setCreatedAt(LocalDateTime.now());
|
detail.setUpdatedAt(LocalDateTime.now());
|
orderDetailMapper.insert(detail);
|
}
|
|
return orderId;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean uploadOrderAttachment(String orderId, String fileName, String originalName,
|
String fileType, Long fileSize, String fileUrl,
|
String bucketName, String objectName, Long uploadUserId,
|
String uploadUserName, String attachmentType, String description) {
|
// 参数校验
|
if (!StringUtils.hasText(orderId)) {
|
throw new BusinessException("订单ID不能为空");
|
}
|
if (!StringUtils.hasText(fileName)) {
|
throw new BusinessException("文件名不能为空");
|
}
|
|
// 检查订单是否存在
|
OrderInfo orderInfo = this.getById(orderId);
|
if (orderInfo == null) {
|
throw new BusinessException("订单不存在");
|
}
|
|
// 创建订单附件
|
OrderAttachment attachment = new OrderAttachment();
|
attachment.setOrderId(orderId);
|
attachment.setFileName(fileName);
|
attachment.setOriginalName(originalName);
|
attachment.setFileType(fileType);
|
attachment.setFileSize(fileSize);
|
attachment.setFileUrl(fileUrl);
|
attachment.setBucketName(bucketName);
|
attachment.setObjectName(objectName);
|
attachment.setUploadUserId(uploadUserId);
|
attachment.setUploadUserName(uploadUserName);
|
attachment.setAttachmentType(attachmentType);
|
attachment.setDescription(description);
|
|
// 保存附件
|
return orderAttachmentMapper.insert(attachment) > 0;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean addOrderEvaluation(String orderId, Long evaluatorId, String evaluatorName,
|
String evaluatorType, String content, Integer rating,
|
Integer serviceRating, Integer qualityRating, Integer deliveryRating,
|
Boolean isAnonymous) {
|
// 参数校验
|
if (!StringUtils.hasText(orderId)) {
|
throw new BusinessException("订单ID不能为空");
|
}
|
if (evaluatorId == null) {
|
throw new BusinessException("评价人ID不能为空");
|
}
|
if (!StringUtils.hasText(content)) {
|
throw new BusinessException("评价内容不能为空");
|
}
|
if (rating == null || rating < 1 || rating > 5) {
|
throw new BusinessException("评分必须在1-5之间");
|
}
|
|
// 检查订单是否存在
|
OrderInfo orderInfo = this.getById(orderId);
|
if (orderInfo == null) {
|
throw new BusinessException("订单不存在");
|
}
|
|
// 检查是否已经评价过
|
OrderEvaluation existingEvaluation = orderEvaluationMapper.selectByOrderId(orderId);
|
if (existingEvaluation != null) {
|
throw new BusinessException("该订单已经评价过了");
|
}
|
|
// 创建订单评价
|
OrderEvaluation evaluation = new OrderEvaluation();
|
evaluation.setOrderId(orderId);
|
evaluation.setEvaluatorId(evaluatorId);
|
evaluation.setEvaluatorName(evaluatorName);
|
evaluation.setEvaluatorType(evaluatorType);
|
evaluation.setContent(content);
|
evaluation.setRating(rating);
|
evaluation.setServiceRating(serviceRating);
|
evaluation.setQualityRating(qualityRating);
|
evaluation.setDeliveryRating(deliveryRating);
|
evaluation.setIsAnonymous(isAnonymous != null ? isAnonymous : false);
|
|
// 保存评价
|
return orderEvaluationMapper.insert(evaluation) > 0;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean confirmTransaction(String orderId, Long userId) {
|
// 参数校验
|
if (!StringUtils.hasText(orderId)) {
|
throw new BusinessException("订单ID不能为空");
|
}
|
if (userId == null) {
|
throw new BusinessException("用户ID不能为空");
|
}
|
|
// 查询订单信息
|
OrderInfo orderInfo = this.getById(orderId);
|
if (orderInfo == null) {
|
throw new BusinessException("订单不存在");
|
}
|
|
// 检查订单状态
|
if (!"待交易确认".equals(orderInfo.getOrderStatus())) {
|
throw new BusinessException("订单状态不正确，无法确认交易");
|
}
|
|
// 检查用户权限
|
if (!userId.equals(orderInfo.getUserId())) {
|
throw new BusinessException("无权限操作此订单");
|
}
|
|
// 更新订单状态
|
orderInfo.setOrderStatus("已完成");
|
orderInfo.setUpdatedAt(LocalDateTime.now());
|
|
// 如果是积分交易，需要扣除积分
|
if ("积分".equals(orderInfo.getPaymentType())) {
|
// TODO: 实现积分扣除逻辑
|
log.info("积分交易确认，订单ID: {}, 需要扣除积分", orderId);
|
}
|
|
// 保存订单
|
return this.updateById(orderInfo);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean replyEvaluation(Long evaluationId, String replyContent, Long replyUserId) {
|
// 参数校验
|
if (evaluationId == null) {
|
throw new BusinessException("评价ID不能为空");
|
}
|
if (!StringUtils.hasText(replyContent)) {
|
throw new BusinessException("回复内容不能为空");
|
}
|
if (replyUserId == null) {
|
throw new BusinessException("回复用户ID不能为空");
|
}
|
|
// 查询评价信息
|
OrderEvaluation evaluation = orderEvaluationMapper.selectById(evaluationId);
|
if (evaluation == null) {
|
throw new BusinessException("评价不存在");
|
}
|
|
// 更新回复信息
|
evaluation.setReplyContent(replyContent);
|
evaluation.setReplyUserId(replyUserId);
|
evaluation.setReplyTime(LocalDateTime.now());
|
evaluation.setUpdatedAt(LocalDateTime.now());
|
|
// 保存评价
|
return orderEvaluationMapper.updateById(evaluation) > 0;
|
}
|
}
|
