feat(订单): 增加根据企业微信用户ID和AB98用户ID查询订单功能

新增通过企业微信用户ID直接查询订单的接口
扩展原有openid查询接口支持关联AB98用户和企业微信用户
添加用户信息关联查询逻辑，完善订单查询场景覆盖

agileboot-admin/src/main/java/com/agileboot/admin/controller/common/LoginController.java

@@ -159,6 +159,14 @@ public class LoginController {
         return ResponseDTO.ok(routerTree);
     }
 
+    @Operation(summary = "获取用户对应的全部权限", description = "用于显示按钮")
+    @GetMapping("/getPermissions")
+    public ResponseDTO<List<String>> getPermissions() {
+        SystemLoginUser loginUser = AuthenticationUtils.getSystemLoginUser();
+        List<String> permissions = menuApplicationService.getPermissions(loginUser);
+        return ResponseDTO.ok(permissions);
+    }
+
 
     @Operation(summary = "注册接口", description = "暂未实现")
     @PostMapping("/register")

agileboot-admin/src/main/java/com/agileboot/admin/controller/shop/ApprovalGoodsCellController.java

@@ -0,0 +1,67 @@
+package com.agileboot.admin.controller.shop;
+
+import com.agileboot.admin.customize.aop.accessLog.AccessLog;
+import com.agileboot.common.core.base.BaseController;
+import com.agileboot.common.core.dto.ResponseDTO;
+import com.agileboot.common.core.page.PageDTO;
+import com.agileboot.common.enums.common.BusinessTypeEnum;
+import com.agileboot.domain.common.command.BulkOperationCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.ApprovalGoodsCellApplicationService;
+import com.agileboot.domain.shop.approvalGoodsCell.command.AddApprovalGoodsCellCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.command.UpdateApprovalGoodsCellCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import com.agileboot.domain.shop.approvalGoodsCell.query.SearchApprovalGoodsCellQuery;
+import io.swagger.v3.oas.annotations.Operation;
+import java.util.List;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/shop/approval-goods-cells")
+@RequiredArgsConstructor
+@Validated
+public class ApprovalGoodsCellController extends BaseController {
+
+    private final ApprovalGoodsCellApplicationService approvalGoodsCellApplicationService;
+
+    @Operation(summary = "商品格口审批列表")
+    @GetMapping
+    public ResponseDTO<PageDTO<ApprovalGoodsCellEntity>> list(SearchApprovalGoodsCellQuery<ApprovalGoodsCellEntity> query) {
+        PageDTO<ApprovalGoodsCellEntity> page = approvalGoodsCellApplicationService.getApprovalGoodsCellList(query);
+        return ResponseDTO.ok(page);
+    }
+
+    @Operation(summary = "新增商品格口审批")
+    @AccessLog(title = "商品格口审批管理", businessType = BusinessTypeEnum.ADD)
+    @PostMapping
+    public ResponseDTO<Void> add(@Validated @RequestBody AddApprovalGoodsCellCommand command) {
+        approvalGoodsCellApplicationService.addApprovalGoodsCell(command);
+        return ResponseDTO.ok();
+    }
+
+    @Operation(summary = "修改商品格口审批")
+    @AccessLog(title = "商品格口审批管理", businessType = BusinessTypeEnum.MODIFY)
+    @PutMapping("/{approvalGoodsCellId}")
+    public ResponseDTO<Void> edit(@PathVariable Long approvalGoodsCellId, @Validated @RequestBody UpdateApprovalGoodsCellCommand command) {
+        command.setApprovalGoodsCellId(approvalGoodsCellId);
+        approvalGoodsCellApplicationService.updateApprovalGoodsCell(command);
+        return ResponseDTO.ok();
+    }
+
+    @Operation(summary = "删除商品格口审批")
+    @AccessLog(title = "商品格口审批管理", businessType = BusinessTypeEnum.DELETE)
+    @DeleteMapping("/{ids}")
+    public ResponseDTO<Void> remove(@PathVariable @NotNull List<Long> ids) {
+        approvalGoodsCellApplicationService.deleteApprovalGoodsCell(new BulkOperationCommand<>(ids));
+        return ResponseDTO.ok();
+    }
+}

agileboot-admin/src/main/java/com/agileboot/admin/customize/service/QywxScheduleJob.java

@@ -498,8 +498,12 @@ public class QywxScheduleJob {
                     localUser.setGender(String.valueOf(wxUser.getGender()));
                     localUser.setEmail(wxUser.getEmail());
                     localUser.setBizMail(wxUser.getBiz_mail());
-                    localUser.setDirectLeader(StringUtils.join(wxUser.getDirect_leader(), ","));
-                    localUser.setIsLeaderInDept(StringUtils.join(wxUser.getIs_leader_in_dept(), ","));
+                    if (wxUser.getDirect_leader()!= null && !wxUser.getDirect_leader().isEmpty()) {
+                        localUser.setDirectLeader(wxUser.getDirect_leader().get(0));
+                    }
+                    if (wxUser.getIs_leader_in_dept()!= null &&!wxUser.getIs_leader_in_dept().isEmpty()) {
+                        localUser.setIsLeaderInDept(String.valueOf(wxUser.getIs_leader_in_dept().get(0)));
+                    }
                     localUser.setTelephone(wxUser.getTelephone());
                     localUser.setAlias(wxUser.getAlias());
                     localUser.setAddress(wxUser.getAddress());
@@ -533,8 +537,12 @@ public class QywxScheduleJob {
                     newUser.setGender(String.valueOf(wxUser.getGender()));
                     newUser.setEmail(wxUser.getEmail());
                     newUser.setBizMail(wxUser.getBiz_mail());
-                    newUser.setDirectLeader(StringUtils.join(wxUser.getDirect_leader(), ","));
-                    newUser.setIsLeaderInDept(StringUtils.join(wxUser.getIs_leader_in_dept(), ","));
+                    if (wxUser.getDirect_leader()!= null && !wxUser.getDirect_leader().isEmpty()) {
+                        newUser.setDirectLeader(wxUser.getDirect_leader().get(0));
+                    }
+                    if (wxUser.getIs_leader_in_dept()!= null &&!wxUser.getIs_leader_in_dept().isEmpty()) {
+                        newUser.setIsLeaderInDept(String.valueOf(wxUser.getIs_leader_in_dept().get(0)));
+                    }
                     newUser.setTelephone(wxUser.getTelephone());
                     newUser.setAlias(wxUser.getAlias());
                     newUser.setAddress(wxUser.getAddress());

agileboot-api/src/main/java/com/agileboot/api/controller/ApprovalApiController.java

@@ -1,23 +1,33 @@
 package com.agileboot.api.controller;
 
+import cn.hutool.json.JSONUtil;
+import com.agileboot.common.constant.WeixinConstants;
 import com.agileboot.common.core.dto.ResponseDTO;
 import com.agileboot.common.core.page.PageDTO;
 import com.agileboot.common.exception.ApiException;
 import com.agileboot.common.exception.error.ErrorCode;
+import com.agileboot.domain.cabinet.operation.command.AddCabinetCellOperationCommand;
 import com.agileboot.domain.shop.approval.ReturnApprovalApplicationService;
 import com.agileboot.domain.shop.approval.command.AddReturnApprovalCommand;
 import com.agileboot.domain.shop.approval.command.UpdateReturnApprovalCommand;
 import com.agileboot.domain.shop.approval.db.ReturnApprovalEntity;
+import com.agileboot.domain.shop.approval.dto.ReturnApprovalAssetDTO;
+import com.agileboot.domain.shop.approval.dto.ReturnApprovalDetailDTO;
 import com.agileboot.domain.shop.approval.model.ReturnApprovalModel;
 import com.agileboot.domain.shop.approval.query.SearchApiReturnApprovalQuery;
+import com.agileboot.domain.shop.approval.query.SearchReturnApprovalAssetQuery;
 import com.agileboot.domain.shop.approval.query.SearchReturnApprovalQuery;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
 import com.agileboot.domain.shop.order.OrderApplicationService;
 import com.agileboot.domain.shop.order.db.ShopOrderGoodsEntity;
 
+import com.agileboot.domain.shop.paymentOperationLog.PaymentOperationLogApplicationService;
+import com.agileboot.domain.shop.paymentOperationLog.command.AddPaymentOperationLogCommand;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.springframework.web.bind.annotation.*;
 import org.apache.commons.lang3.StringUtils;
 
@@ -45,6 +55,7 @@ public class ApprovalApiController {
 
     /** 订单应用服务，用于处理订单相关查询操作 */
     private final OrderApplicationService orderApplicationService;
+    private final PaymentOperationLogApplicationService paymentOperationLogApplicationService;
 
     /**
      * 处理审批操作
@@ -93,19 +104,50 @@ public class ApprovalApiController {
 
         try {
             if (command.getStatus() == 2) {
-                approvalApplicationService.approveAssetApproval(command);
+                approvalApplicationService.updateApprovalStatusAndComplete(command);
             } else if (command.getStatus() == 3) {
-                approvalApplicationService.rejectApproval(command);
+                approvalApplicationService.rejectAssetApproval(command);
             } else {
                 return ResponseDTO.fail(new ApiException(ErrorCode.Internal.INTERNAL_ERROR, "无效的操作状态"));
             }
             return ResponseDTO.ok("操作成功");
         } catch (Exception e) {
             log.error("审批操作失败", e);
+            // 记录支付操作日志
+            AddPaymentOperationLogCommand paymentOperationLogCommand = new AddPaymentOperationLogCommand();
+            paymentOperationLogCommand.setOperationType("handleAssetApproval");
+            paymentOperationLogCommand.setStatus(2);
+            paymentOperationLogCommand.setRemark(ExceptionUtils.getStackTrace(e));
+            paymentOperationLogCommand.setParams(JSONUtil.toJsonStr(command));
+            paymentOperationLogCommand.initBaseEntity();
+            paymentOperationLogApplicationService.addPaymentOperationLog(paymentOperationLogCommand);
             return ResponseDTO.fail(new ApiException(ErrorCode.Internal.INTERNAL_ERROR, e.getMessage()));
         }
     }
 
+    @PostMapping("/handle/allocateApprovalGoods")
+    @ApiOperation(value = "处理审批操作")
+    public ResponseDTO<String> allocateApprovalGoods(@Valid @RequestBody UpdateReturnApprovalCommand command) {
+        if (command.getApprovalId() == null) {
+            return ResponseDTO.fail(new ApiException(ErrorCode.Internal.INTERNAL_ERROR, "审批ID不能为空"));
+        }
+
+        try {
+            approvalApplicationService.allocateApprovalGoodsCells(command);
+            return ResponseDTO.ok("操作成功");
+        } catch (Exception e) {
+            log.error("审批操作失败", e);
+            // 记录支付操作日志
+            AddPaymentOperationLogCommand paymentOperationLogCommand = new AddPaymentOperationLogCommand();
+            paymentOperationLogCommand.setOperationType("handleAssetApproval");
+            paymentOperationLogCommand.setStatus(2);
+            paymentOperationLogCommand.setRemark(ExceptionUtils.getStackTrace(e));
+            paymentOperationLogCommand.setParams(JSONUtil.toJsonStr(command));
+            paymentOperationLogCommand.initBaseEntity();
+            paymentOperationLogApplicationService.addPaymentOperationLog(paymentOperationLogCommand);
+            return ResponseDTO.fail(new ApiException(ErrorCode.Internal.INTERNAL_ERROR, e.getMessage()));
+        }
+    }
 
     /**
      * 提交退货审批申请
@@ -151,4 +193,51 @@ public class ApprovalApiController {
         List<ShopOrderGoodsEntity> list = approvalApplicationService.getApprovalOrderGoods(approvalId);
         return ResponseDTO.ok(list);
     }
+
+    @GetMapping("/getApprovalGoodsCell")
+    public ResponseDTO<List<ApprovalGoodsCellEntity>> getApprovalGoodsCell(Long approvalId) {
+        List<ApprovalGoodsCellEntity> list = approvalApplicationService.getApprovalGoodsCell(approvalId);
+        return ResponseDTO.ok(list);
+    }
+
+    @GetMapping("/detail/asset")
+    @ApiOperation(value = "审批列表")
+    public ResponseDTO<ReturnApprovalDetailDTO> detailAsset(Long approval_id) {
+        return ResponseDTO.ok(approvalApplicationService.getApprovalDetail(approval_id));
+    }
+
+
+    @GetMapping("/list/asset")
+    @ApiOperation(value = "审批列表")
+    public ResponseDTO<PageDTO<ReturnApprovalAssetDTO>> listAsset(SearchReturnApprovalAssetQuery<ReturnApprovalEntity> query) {
+        PageDTO<ReturnApprovalAssetDTO> page = approvalApplicationService.getApprovalAssetPage(query);
+        return ResponseDTO.ok(page);
+    }
+
+    @PostMapping("/checkCode")
+    @ApiOperation(value = "校验审批码")
+    public ResponseDTO<String> checkCode(@RequestParam String corpid, @RequestParam Integer approvalType, @RequestParam String code) {
+        try {
+            if (StringUtils.isBlank(corpid)) {
+                corpid = WeixinConstants.corpid;
+            }
+            approvalApplicationService.checkCode(corpid, approvalType, code);
+        } catch (Exception e) {
+            return ResponseDTO.fail(new ApiException(ErrorCode.Internal.INTERNAL_ERROR, e.getMessage()));
+        }
+
+        return ResponseDTO.ok("校验成功");
+    }
+
+    /**
+     * 打开审批商品柜门接口
+     * @param approvalGoodsCellId 通过审批单商品详情ID
+     * @return 空响应
+     */
+    @PostMapping("/openCabinet/{approvalGoodsCellId}")
+    public ResponseDTO<?> openCabinet(@PathVariable Long approvalGoodsCellId,
+                                      @RequestBody AddCabinetCellOperationCommand operationCommand) {
+        approvalApplicationService.openCabinet(approvalGoodsCellId, operationCommand);
+        return ResponseDTO.ok();
+    }
 }

agileboot-api/src/main/java/com/agileboot/api/controller/OrderController.java

@@ -84,8 +84,18 @@ public class OrderController extends BaseController {
      * @return 包含订单列表的响应
      */
     @GetMapping("/user/{openid}")
-    public ResponseDTO<GetOrdersByOpenIdDTO> getOrdersByOpenId(@PathVariable String openid) {
-        GetOrdersByOpenIdDTO result = orderApplicationService.getOrdersByOpenId(openid);
+    public ResponseDTO<GetOrdersByOpenIdDTO> getOrdersByOpenId(@PathVariable String openid, @RequestParam(required = false) String corpid) {
+        GetOrdersByOpenIdDTO result = orderApplicationService.getOrdersByOpenId(openid, corpid);
+        return ResponseDTO.ok(result);
+    }
+
+    /**
+     * 根据用户openid获取订单列表
+     * @return 包含订单列表的响应
+     */
+    @GetMapping("/user/qy/{qyUserId}")
+    public ResponseDTO<GetOrdersByOpenIdDTO> getOrdersByOpenId(@PathVariable Long qyUserId) {
+        GetOrdersByOpenIdDTO result = orderApplicationService.getOrdersByQyUserId(qyUserId);
         return ResponseDTO.ok(result);
     }
 

agileboot-api/src/main/java/com/agileboot/api/controller/PaymentController.java

@@ -255,6 +255,16 @@ public class PaymentController {
             return ResponseDTO.fail(new ApiException(ErrorCode.Client.COMMON_REQUEST_PARAMETERS_INVALID, "无效的openid参数"));
         }
 
+        try {
+            if (qyUser.getAb98UserId()!= null) {
+                Ab98UserEntity ab98User = ab98UserApplicationService.getByAb98UserId(qyUser.getAb98UserId());
+                ab98User.setOpenid(openid);
+                ab98User.updateById();
+            }
+        } catch (Exception e) {
+            log.error("更新汇邦云绑定的微信openid失败", e);
+        }
+
         // 创建响应对象（假设GetBalanceResponse包含balance字段）
         GetBalanceResponse response = new GetBalanceResponse(
                 qyUser.getUserid(),

agileboot-api/src/main/java/com/agileboot/api/controller/ShopController.java

@@ -187,6 +187,45 @@ public class ShopController {
         return new RedirectView(builder.build().encode().toUriString());
     }
 
+    /**
+     * 企业微信推送消息点击商品图片后跳转的地址
+     * @param request
+     * @return
+     */
+    @GetMapping("/qy/wechatAuth/asset")
+    public RedirectView qyWechatAuthAssetRedirect(HttpServletRequest request) {
+        String authUrl = "https://open.weixin.qq.com/connect/oauth2/authorize"
+                + "?appid=" + WeixinConstants.corpid
+                + "&redirect_uri=http%3A%2F%2Fwxshop.ab98.cn%2Fshop-api%2Fapi%2Fshop%2FapprovalAssetRedirect"
+                + "&response_type=code"
+                + "&scope=snsapi_base"
+                + "&state=STATE"
+                + "&agentid=" + WeixinConstants.agentid
+                + "#wechat_redirect";
+        return new RedirectView(authUrl);
+    }
+
+    /**
+     * 企业微信推送消息点击商品图片后跳转的地址
+     * @param request
+     * @return
+     */
+    @GetMapping("/approvalAssetRedirect")
+    public RedirectView approvalAssetRedirect(HttpServletRequest request) {
+        UriComponentsBuilder builder = UriComponentsBuilder
+                .fromHttpUrl("http://wxshop.ab98.cn/shop#/approvalAsset/list")
+                .queryParam("corpid", WeixinConstants.corpid)
+                .queryParam("device", "APP");
+
+        request.getParameterMap().forEach((key, values) -> {
+            if (!"corpid".equals(key) && !"device".equals(key)) {
+                builder.queryParam(key, (Object[]) values);
+            }
+        });
+
+        return new RedirectView(builder.build().encode().toUriString());
+    }
+
     /**
      * 企业微信聊天界面点击进入主页后跳转的地址
      * @param request

agileboot-api/src/test/java/com/agileboot/api/controller/AssetApiControllerTest.java

@@ -150,7 +150,7 @@ public class AssetApiControllerTest {
 
         // 2.发送POST请求
         log.info("请求参数: {}", JSONUtil.toJsonStr(request));
-        String res = HttpUtil.post("http://192.168.8.33:8090/api/receive/cabinet/consume/output", JSONUtil.toJsonStr(request));
+        String res = HttpUtil.post("https://kvkk.cn/api/receive/cabinet/consume/output", JSONUtil.toJsonStr(request));
 
         log.info("接口响应: {}", res);
 

agileboot-api/src/test/java/com/agileboot/api/controller/CabinetControllerTest.java

@@ -4,6 +4,8 @@ import cn.hutool.http.HttpUtil;
 import cn.hutool.json.JSONUtil;
 import com.agileboot.common.constant.OpenApiConstants;
 import com.agileboot.common.core.dto.ResponseDTO;
+import com.agileboot.domain.ab98.api.Ab98ApiUtil;
+import com.agileboot.domain.ab98.api.Ab98UserDto;
 import com.agileboot.domain.shop.payment.SignUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.Test;
@@ -44,4 +46,11 @@ public class CabinetControllerTest {
         // 5. 验证响应
         System.out.println("Response: " + res);
     }
+
+    @Test
+    public void testPullUserInfoByIdnum() {
+        String IdNum = "452526196206215829";
+        Ab98UserDto ab98UserDto = Ab98ApiUtil.pullUserInfoByIdnum("wxshop", "34164e41f0c6694be6bbbba0dc50c14a", IdNum);
+        log.info("ab98UserDto:{}", JSONUtil.toJsonStr(ab98UserDto));
+    }
 }

agileboot-domain/src/main/java/com/agileboot/domain/asset/AssetApplicationService.java

@@ -20,6 +20,7 @@ import com.agileboot.domain.shop.approval.command.AddReturnApprovalCommand;
 import com.agileboot.domain.shop.approval.model.ReturnApprovalModel;
 import com.agileboot.domain.shop.approval.model.ReturnApprovalModelFactory;
 import com.agileboot.domain.shop.approvalGoods.command.AddApprovalGoodsCommand;
+import com.agileboot.domain.shop.approvalGoods.db.ApprovalGoodsEntity;
 import com.agileboot.domain.shop.approvalGoods.model.ApprovalGoodsModel;
 import com.agileboot.domain.shop.approvalGoods.model.ApprovalGoodsModelFactory;
 import com.agileboot.domain.shop.goods.db.ShopGoodsEntity;
@@ -129,6 +130,8 @@ public class AssetApplicationService {
         if (returnApprovalCommand.getApprovalType() == null) {
             returnApprovalCommand.setApprovalType(1);
         }
+        returnApprovalCommand.setApplyUserid(postAssetApprovalCommand.getUserid());
+        returnApprovalCommand.setApplyUserName(postAssetApprovalCommand.getName());
 
         ReturnApprovalModel returnApprovalModel = returnApprovalModelFactory.create();
         returnApprovalModel.initBaseEntity();
@@ -196,7 +199,7 @@ public class AssetApplicationService {
                 article.setDescription(postAssetApprovalCommand.getName() + " 申请领用" + firstGoods.getGoodsName());
             }
             article.setPicurl(firstGoods.getCoverImg());
-            article.setUrl("http://wxshop.ab98.cn/shop-api/api/shop/qy/wechatAuth");
+            article.setUrl("http://wxshop.ab98.cn/shop-api/api/shop/qy/wechatAuth/asset");
             articles.add(article);
 
             QywxApiUtil.sendNewsMessage(accessToken.getAccessToken(), Integer.valueOf(authCorpInfo.getAgentid()),
@@ -206,32 +209,50 @@ public class AssetApplicationService {
         }
     }
 
-    public void consumeOutput(String corpid, String outUserid, String approveUserid,
-                              ReturnApprovalModel returnApprovalModel,
-                              List<ShopOrderGoodsEntity> shopOrderGoodsList,
-                              List<GoodsModel> goodsModelList) {
+    public void rejectConsumeOutput(String corpid, String approveUserid,
+                                    ReturnApprovalModel returnApprovalModel) {
         ConsumeOutputRequest request = new ConsumeOutputRequest();
         request.setCorpid(corpid);
-        request.setOutUserid(outUserid);
-        request.setOutDate(new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
+        request.setConsumeOutId(returnApprovalModel.getExternalApprovalId());
         request.setApproveUserid(approveUserid);
         request.setRemark(returnApprovalModel.getAuditRemark());
+        request.setState("3");
+        request.setIsVerify("3");
+
+
+        // 2.发送POST请求
+        log.info("consumeOutput 请求参数: {}", JSONUtil.toJsonStr(request));
+        String res = HttpUtil.post("https://kvkk.cn/api/receive/cabinet/consume/output", JSONUtil.toJsonStr(request));
+        log.info("consumeOutput 接口响应: {}", res);
+
+        ConsumeOutputResponse response = JSONUtil.toBean(res, ConsumeOutputResponse.class);
+        if (response != null && response.getCode() == 0) {
+            log.info("拒绝出库单成功，出库单: {}", JSONUtil.toJsonStr(response.getData()));
+        } else {
+            log.error("拒绝出库单失败，错误信息: {}", response.getMessage());
+            throw new RuntimeException("出库单创建失败：" + res);
+        }
+    }
+
+    public void consumeOutput(String corpid, String outUserid, String approveUserid,
+                              ReturnApprovalModel returnApprovalModel,
+                              List<ApprovalGoodsEntity> approvalGoodsList,
+                              List<ShopGoodsEntity> goodsList) {
+        ConsumeOutputRequest request = new ConsumeOutputRequest();
+        request.setCorpid(corpid);
+        request.setConsumeOutId(returnApprovalModel.getExternalApprovalId());
+        request.setApproveUserid(StringUtils.isBlank(approveUserid) ? "woZ1ZrEgAAV9AEdRt1MGQxSg-KDJrDlA" : approveUserid);
+        request.setRemark(returnApprovalModel.getAuditRemark());
         request.setState("2");
+        request.setIsVerify("-1");
 
         List<ConsumeOutputRequest.ConsumeOutDetailParam> details = new ArrayList<>();
-        for (ShopOrderGoodsEntity shopOrderGoods : shopOrderGoodsList) {
-            GoodsModel goodsModel = goodsModelList.stream()
-                    .filter(g -> g.getGoodsId().equals(shopOrderGoods.getGoodsId()))
-                    .findFirst().orElse(null);
-            if (goodsModel == null) {
-                throw new IllegalArgumentException("GoodsModel not found");
-            }
-
+        for (ApprovalGoodsEntity approvalGoods : approvalGoodsList) {
             ConsumeOutputRequest.ConsumeOutDetailParam detail = new ConsumeOutputRequest.ConsumeOutDetailParam();
-            detail.setConsumeId(goodsModel.getExternalGoodsId());
-            detail.setOutNum(shopOrderGoods.getQuantity());
-            detail.setOutPrice(shopOrderGoods.getPrice());
-            detail.setOutAmount(shopOrderGoods.getTotalAmount());
+            detail.setConsumeId(approvalGoods.getExternalGoodsId());
+            detail.setOutNum(approvalGoods.getApprovalQuantity());
+            detail.setOutPrice(approvalGoods.getPrice());
+            detail.setOutAmount(approvalGoods.getPrice().multiply(BigDecimal.valueOf(approvalGoods.getApprovalQuantity())));
             details.add(detail);
         }
 
@@ -252,19 +273,11 @@ public class AssetApplicationService {
             List<Map<String, Integer>> consumeOutDetail = response.getData();
             Map<String, Integer> consumeOutDetailMap = new HashMap<>();
             consumeOutDetail.forEach(consumeOutDetailMap::putAll);
-            for (ShopOrderGoodsEntity shopOrderGoods : shopOrderGoodsList) {
-                GoodsModel goodsModel = goodsModelList.stream()
-                        .filter(g -> g.getGoodsId().equals(shopOrderGoods.getGoodsId()))
-                        .findFirst().orElse(null);
-                if (goodsModel == null) {
-                    throw new IllegalArgumentException("GoodsModel not found");
-                }
-                if (!consumeOutDetailMap.containsKey(String.valueOf(goodsModel.getExternalGoodsId()))) {
+            for (ShopGoodsEntity goods : goodsList) {
+                if (!consumeOutDetailMap.containsKey(String.valueOf(goods.getExternalGoodsId()))) {
                     throw new IllegalArgumentException("ConsumeOutDetail not found");
                 }
-                if (!consumeOutDetailMap.get(String.valueOf(goodsModel.getExternalGoodsId())).equals(shopOrderGoods.getQuantity())) {
-                    throw new IllegalArgumentException("Insufficient stock");
-                }
+                goods.setStock(consumeOutDetailMap.get(String.valueOf(goods.getExternalGoodsId())));
             }
         } else {
             log.error("出库单创建失败，错误信息: {}", response.getMessage());

agileboot-domain/src/main/java/com/agileboot/domain/asset/api/request/ConsumeOutputRequest.java

@@ -11,6 +11,7 @@ import java.util.List;
 public class ConsumeOutputRequest {
     /** 企业corpid，必填 */
     private String corpid;
+    private Long consumeOutId;
     /** 申领用户企业微信id，必填 */
     private String outUserid;
     /** 申领出库单日期，不传默认当天 */
@@ -25,6 +26,7 @@ public class ConsumeOutputRequest {
     private String remark;
     /** 审批状态（"2"通过，"3"拒绝），必填 */
     private String state;
+    private String isVerify;
     /** 耗材明细，必填 */
     private List<ConsumeOutDetailParam> consumeOutDetailParams;
 

agileboot-domain/src/main/java/com/agileboot/domain/qywx/user/db/QyUserService.java

@@ -30,4 +30,6 @@ public interface QyUserService extends IService<QyUserEntity> {
     List<String> selectAdminUserIds(String corpid);
 
     QyUserStatsDTO selectTotalBalance(String corpid);
+
+    QyUserEntity getUserByAb98UserId(Long ab98UserId, String corpid);
 }

agileboot-domain/src/main/java/com/agileboot/domain/qywx/user/db/QyUserServiceImpl.java

@@ -68,4 +68,14 @@ public class QyUserServiceImpl extends ServiceImpl<QyUserMapper, QyUserEntity> i
             return baseMapper.selectTotalBalanceByCorpid(corpid);
         }
     }
+
+    @Override
+    public QyUserEntity getUserByAb98UserId(Long ab98UserId, String corpid) {
+        LambdaQueryWrapper<QyUserEntity> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(QyUserEntity::getAb98UserId, ab98UserId)
+               .eq(QyUserEntity::getCorpid, corpid)
+               .eq(QyUserEntity::getDeleted, false)
+                .last("LIMIT 1");
+        return this.getOne(wrapper);
+    }
 }

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/ReturnApprovalApplicationService.java

@@ -5,10 +5,22 @@ import cn.hutool.json.JSONUtil;
 import com.agileboot.common.constant.PayApiConstants;
 import com.agileboot.common.constant.WeixinConstants;
 import com.agileboot.common.core.page.PageDTO;
+import com.agileboot.common.exception.ApiException;
+import com.agileboot.common.exception.error.ErrorCode;
 import com.agileboot.domain.asset.AssetApplicationService;
+import com.agileboot.domain.cabinet.cell.db.CabinetCellEntity;
+import com.agileboot.domain.cabinet.cell.db.CabinetCellService;
 import com.agileboot.domain.cabinet.cell.model.CabinetCellModel;
 import com.agileboot.domain.cabinet.cell.model.CabinetCellModelFactory;
+import com.agileboot.domain.cabinet.mainboard.db.CabinetMainboardEntity;
+import com.agileboot.domain.cabinet.mainboard.db.CabinetMainboardService;
+import com.agileboot.domain.cabinet.operation.command.AddCabinetCellOperationCommand;
+import com.agileboot.domain.cabinet.operation.model.CabinetCellOperationModel;
+import com.agileboot.domain.cabinet.operation.model.CabinetCellOperationModelFactory;
+import com.agileboot.domain.cabinet.smartCabinet.db.SmartCabinetEntity;
+import com.agileboot.domain.cabinet.smartCabinet.db.SmartCabinetService;
 import com.agileboot.domain.common.command.BulkOperationCommand;
+import com.agileboot.domain.mqtt.MqttService;
 import com.agileboot.domain.qywx.accessToken.AccessTokenApplicationService;
 import com.agileboot.domain.qywx.accessToken.db.QyAccessTokenEntity;
 import com.agileboot.domain.qywx.api.QywxApiUtil;
@@ -21,10 +33,21 @@ import com.agileboot.domain.shop.approval.command.AddReturnApprovalCommand;
 import com.agileboot.domain.shop.approval.command.UpdateReturnApprovalCommand;
 import com.agileboot.domain.shop.approval.db.ReturnApprovalEntity;
 import com.agileboot.domain.shop.approval.db.ReturnApprovalService;
+import com.agileboot.domain.shop.approval.dto.ReturnApprovalAssetDTO;
+import com.agileboot.domain.shop.approval.dto.ReturnApprovalDetailDTO;
 import com.agileboot.domain.shop.approval.model.ReturnApprovalModel;
 import com.agileboot.domain.shop.approval.model.ReturnApprovalModelFactory;
 import com.agileboot.domain.shop.approval.query.SearchApiReturnApprovalQuery;
+import com.agileboot.domain.shop.approval.query.SearchReturnApprovalAssetQuery;
 import com.agileboot.domain.shop.approval.query.SearchReturnApprovalQuery;
+import com.agileboot.domain.shop.approvalGoods.command.UpdateApprovalGoodsCommand;
+import com.agileboot.domain.shop.approvalGoods.db.ApprovalGoodsEntity;
+import com.agileboot.domain.shop.approvalGoods.db.ApprovalGoodsService;
+import com.agileboot.domain.shop.approvalGoodsCell.command.AddApprovalGoodsCellCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellService;
+import com.agileboot.domain.shop.goods.db.ShopGoodsEntity;
+import com.agileboot.domain.shop.goods.db.ShopGoodsService;
 import com.agileboot.domain.shop.goods.model.GoodsModel;
 import com.agileboot.domain.shop.goods.model.GoodsModelFactory;
 import com.agileboot.domain.shop.order.db.ShopOrderGoodsEntity;
@@ -37,11 +60,15 @@ import com.agileboot.domain.shop.payment.PaymentApplicationService;
 import com.agileboot.domain.shop.payment.dto.RefundVO;
 import com.agileboot.domain.shop.paymentOperationLog.PaymentOperationLogApplicationService;
 import com.agileboot.domain.shop.paymentOperationLog.command.AddPaymentOperationLogCommand;
+import com.agileboot.domain.shop.shop.db.ShopEntity;
+import com.agileboot.domain.shop.shop.db.ShopService;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -64,14 +91,23 @@ public class ReturnApprovalApplicationService {
     private final OrderGoodsModelFactory orderGoodsModelFactory;
     private final OrderModelFactory orderModelFactory;
     private final PaymentApplicationService paymentApplicationService;
+    private final ShopGoodsService shopGoodsService;
     private final GoodsModelFactory goodsModelFactory;
     private final AuthCorpInfoApplicationService authCorpInfoApplicationService;
     private final AccessTokenApplicationService accessTokenApplicationService;
     private final QyUserService qyUserService;
+    private final ShopService shopService;
+    private final SmartCabinetService smartCabinetService;
     private final CabinetCellModelFactory cabinetCellModelFactory;
+    private final CabinetCellService cabinetCellService;
     private final QyUserService userService;
     private final PaymentOperationLogApplicationService paymentOperationLogApplicationService;
     private final AssetApplicationService assetApplicationService;
+    private final ApprovalGoodsService approvalGoodsService;
+    private final ApprovalGoodsCellService approvalGoodsCellService;
+    private final CabinetMainboardService cabinetMainboardService;
+    private final CabinetCellOperationModelFactory cabinetCellOperationModelFactory;
+    private final MqttService mqttService;
 
     /**
      * 获取退货审批列表
@@ -267,21 +303,16 @@ public class ReturnApprovalApplicationService {
 
 
     /**
-     * 审批通过资产退货申请
-     * @param command 更新退货审批命令，包含审批ID、审批人信息等
-     * @throws RuntimeException 如果商品库存不足
+     * 处理库存分配并创建addApprovalGoodsCellList
      */
-    public void approveAssetApproval(UpdateReturnApprovalCommand command) {
+    public void allocateApprovalGoodsCells(UpdateReturnApprovalCommand command) {
+        List<UpdateApprovalGoodsCommand> approvalGoodsCommands = command.getApprovalGoodsList();
+        if (approvalGoodsCommands == null || approvalGoodsCommands.isEmpty()) {
+            throw new RuntimeException("审批通过的耗材列表不能为空");
+        }
         // 加载退货审批模型
         ReturnApprovalModel model = modelFactory.loadById(command.getApprovalId());
 
-        // 获取关联的订单商品列表
-        List<ShopOrderGoodsEntity> shopOrderGoodsList = shopOrderGoodsService.selectOrderGoodsByApprovalId(model.getApprovalId());
-
-        if (shopOrderGoodsList == null || shopOrderGoodsList.isEmpty()) {
-            throw new RuntimeException("未找到关联的订单商品");
-        }
-
         // 设置审批人信息
         if (StringUtils.isNotBlank(command.getAuditName())) {
             model.setAuditName(command.getAuditName());
@@ -291,40 +322,183 @@ public class ReturnApprovalApplicationService {
                 model.setAuditName(qyUserEntity.getName());
             }
         }
+        // 获取关联的订单商品列表
+        List<ApprovalGoodsEntity> approvalGoodsList = approvalGoodsService.selectByApprovalId(model.getApprovalId());
+        if (approvalGoodsList == null || approvalGoodsList.isEmpty()) {
+            throw new RuntimeException("未找到关联的订单商品");
+        }
+        approvalGoodsList.forEach(approvalGoods -> {
+            approvalGoods.setApprovalQuantity(0);
+        });
+
+        // 获取关联的商品列表
+        QueryWrapper<ShopGoodsEntity> goodsWrapper = new QueryWrapper<>();
+        goodsWrapper.in("goods_id", approvalGoodsCommands.stream().map(ApprovalGoodsEntity::getGoodsId).distinct().collect(Collectors.toList()))
+                .eq("deleted", false);
+        List<ShopGoodsEntity> goodsList = shopGoodsService.list(goodsWrapper);
+        if (goodsList == null || goodsList.isEmpty()) {
+            throw new RuntimeException("未找到关联的商品");
+        }
 
         // 初始化商品和格口模型列表
-        List<GoodsModel> goodsModelList = new ArrayList<>();
-        List<CabinetCellModel> cabinetCellModelList = new ArrayList<>();
-        
-        // 遍历订单商品，检查并更新库存
-        for (ShopOrderGoodsEntity shopOrderGoods : shopOrderGoodsList) {
-            // 获取或创建商品模型
-            GoodsModel goodsModel = goodsModelList.stream()
-                    .filter(g -> g.getGoodsId().equals(shopOrderGoods.getGoodsId()))
-                    .findFirst().orElse(null);
-            if (goodsModel == null) {
-                goodsModel = goodsModelFactory.loadById(shopOrderGoods.getGoodsId());
-                goodsModelList.add(goodsModel);
-            }
-            
-            // 获取或创建格口模型
-            CabinetCellModel cabinetCellModel = cabinetCellModelList.stream()
-                    .filter(c -> c.getCellId().equals(shopOrderGoods.getCellId()))
-                    .findFirst().orElse(null);
-            if (cabinetCellModel == null) {
-                cabinetCellModel = cabinetCellModelFactory.loadById(shopOrderGoods.getCellId());
-                cabinetCellModelList.add(cabinetCellModel);
-            }
+        List<ApprovalGoodsCellEntity> addApprovalGoodsCellList = new ArrayList<>();
 
-            // 检查商品和格口库存是否充足
-            if (goodsModel.getStock().compareTo(shopOrderGoods.getQuantity()) < 0 || 
-                cabinetCellModel.getStock().compareTo(shopOrderGoods.getQuantity()) < 0) {
+        for (ApprovalGoodsEntity approvalGoodsCommand : approvalGoodsCommands) {
+            if (approvalGoodsCommand.getApprovalQuantity() == null || approvalGoodsCommand.getApprovalQuantity().compareTo(0) <= 0) {
+                continue;
+            }
+            ApprovalGoodsEntity approvalGoods = approvalGoodsList.stream()
+                    .filter(g -> g.getApprovalGoodsId().equals(approvalGoodsCommand.getApprovalGoodsId())).findFirst().orElse(null);
+            if (approvalGoods == null) {
+                throw new RuntimeException("未找到关联的订单商品");
+            }
+            if (approvalGoods.getApplyQuantity().compareTo(approvalGoodsCommand.getApprovalQuantity()) < 0) {
+                throw new RuntimeException("审批数量不能大于申请数量");
+            }
+            approvalGoods.setApprovalQuantity(approvalGoodsCommand.getApprovalQuantity());
+
+            ShopGoodsEntity goods = goodsList.stream()
+                    .filter(g -> g.getGoodsId().equals(approvalGoodsCommand.getGoodsId())).findFirst().orElse(null);
+            if (goods == null) {
+                throw new RuntimeException("未找到关联的商品");
+            }
+            if (goods.getStock().compareTo(approvalGoodsCommand.getApprovalQuantity()) < 0) {
                 throw new RuntimeException("商品库存不足");
             }
 
-            // 更新商品和格口库存
-            goodsModel.setStock(goodsModel.getStock() - shopOrderGoods.getQuantity());
-            cabinetCellModel.setStock(cabinetCellModel.getStock() - shopOrderGoods.getQuantity());
+            List<CabinetCellEntity> cells = cabinetCellService.selectByGoodsId(approvalGoodsCommand.getGoodsId());
+            // 如果没有找到对应的格口，抛出异常
+            if (cells == null || cells.isEmpty()) {
+                throw new RuntimeException("未找到关联的格口");
+            }
+            // 按库存数量从大到小排序
+            cells.sort(Comparator.comparingInt(CabinetCellEntity::getStock).reversed());
+            // 遍历格口列表，从库存最多的格口开始分配，直到满足需求
+            int remainingQuantity = approvalGoodsCommand.getApprovalQuantity();
+            for (CabinetCellEntity cell : cells) {
+                SmartCabinetEntity smartCabinetEntity = smartCabinetService.getByCabinetId(cell.getCabinetId());
+                if (smartCabinetEntity == null) {
+                    throw new RuntimeException("未找到关联的柜子");
+                }
+                ShopEntity shop = shopService.getById(smartCabinetEntity.getShopId());
+
+                ApprovalGoodsCellEntity addApprovalGoodsCellCommand = new ApprovalGoodsCellEntity();
+                addApprovalGoodsCellCommand.initBaseEntity();
+                addApprovalGoodsCellCommand.setApprovalId(command.getApprovalId());
+                addApprovalGoodsCellCommand.setApprovalGoodsId(approvalGoodsCommand.getApprovalGoodsId());
+                addApprovalGoodsCellCommand.setCabinetId(smartCabinetEntity.getCabinetId());
+                addApprovalGoodsCellCommand.setCabinetName(smartCabinetEntity.getCabinetName());
+                addApprovalGoodsCellCommand.setCellId(cell.getCellId());
+                addApprovalGoodsCellCommand.setCellNo(cell.getCellNo());
+                if (shop != null) {
+                    addApprovalGoodsCellCommand.setShopId(shop.getShopId());
+                    addApprovalGoodsCellCommand.setShopName(shop.getShopName());
+                }
+                addApprovalGoodsCellList.add(addApprovalGoodsCellCommand);
+
+                if (cell.getStock() >= remainingQuantity) {
+                    addApprovalGoodsCellCommand.setAllocateQuantity(remainingQuantity);
+                    cell.setStock(cell.getStock() - remainingQuantity);
+                    remainingQuantity = 0;
+                    break;
+                } else {
+                    addApprovalGoodsCellCommand.setAllocateQuantity(cell.getStock());
+                    remainingQuantity -= cell.getStock();
+                    cell.setStock(0);
+                }
+            }
+            // 如果还有剩余数量，说明库存不足
+            if (remainingQuantity > 0) {
+                throw new RuntimeException("商品" + goods.getGoodsName() + "在柜子中的库存不足");
+            }
+            goods.setStock(goods.getStock() - approvalGoodsCommand.getApprovalQuantity());
+
+        }
+
+        // 更新审批状态为通过
+        model.validateApprovalStatus();
+        model.setAuditImages(command.getAuditImages());
+        model.setAuditRemark(command.getAuditRemark());
+        model.setAuditUserid(command.getAuditUserid());
+
+        // 开始执行数据库操作
+        model.setStatus(4); // 2表示审核通过状态
+        model.updateById();
+
+        // 批量更新审批商品表
+        approvalGoodsList.forEach(ApprovalGoodsEntity::updateById);
+
+        // 批量插入审批商品格口关联表
+        approvalGoodsCellService.saveBatch(addApprovalGoodsCellList);
+    }
+
+    /**
+     * 执行更新审批状态为通过以及之后的操作
+     */
+    public void updateApprovalStatusAndComplete(UpdateReturnApprovalCommand command) {
+        // 加载退货审批模型
+        ReturnApprovalModel model = modelFactory.loadById(command.getApprovalId());
+
+        // 设置审批人信息
+        if (StringUtils.isNotBlank(command.getAuditName())) {
+            model.setAuditName(command.getAuditName());
+        } else if (StringUtils.isNotBlank(command.getUserid())) {
+            QyUserEntity qyUserEntity = qyUserService.getUserByUserIdAndCorpid(command.getUserid(), model.getCorpid());
+            if (null != qyUserEntity) {
+                model.setAuditName(qyUserEntity.getName());
+            }
+        }
+        // 获取关联的订单商品列表
+        List<ApprovalGoodsEntity> approvalGoodsList = approvalGoodsService.selectByApprovalId(model.getApprovalId());
+        if (approvalGoodsList == null || approvalGoodsList.isEmpty()) {
+            throw new RuntimeException("未找到关联的订单商品");
+        }
+
+        List<ApprovalGoodsCellEntity> approvalGoodsCellEntities = approvalGoodsCellService.selectByApprovalId(model.getApprovalId());
+
+        // 获取关联的商品列表
+        QueryWrapper<ShopGoodsEntity> goodsWrapper = new QueryWrapper<>();
+        goodsWrapper.in("goods_id", approvalGoodsList.stream().map(ApprovalGoodsEntity::getGoodsId).distinct().collect(Collectors.toList()))
+                .eq("deleted", false);
+        List<ShopGoodsEntity> goodsList = shopGoodsService.list(goodsWrapper);
+        if (goodsList == null || goodsList.isEmpty()) {
+            throw new RuntimeException("未找到关联的商品");
+        }
+
+        // 初始化商品和格口模型列表
+        QueryWrapper<CabinetCellEntity> cellEntityQueryWrapper = new QueryWrapper<>();
+        cellEntityQueryWrapper.in("cell_id", approvalGoodsCellEntities.stream().map(ApprovalGoodsCellEntity::getCellId).collect(Collectors.toList()))
+                .eq("deleted", false);
+        List<CabinetCellEntity> cabinetCellList = cabinetCellService.list(cellEntityQueryWrapper);
+
+        for (ApprovalGoodsCellEntity approvalGoodsCell : approvalGoodsCellEntities) {
+            if (approvalGoodsCell.getAllocateQuantity() == null || approvalGoodsCell.getAllocateQuantity().compareTo(0) <= 0) {
+                continue;
+            }
+            ApprovalGoodsEntity approvalGoods = approvalGoodsList.stream()
+                    .filter(g -> g.getApprovalGoodsId().equals(approvalGoodsCell.getApprovalGoodsId())).findFirst().orElse(null);
+            if (approvalGoods == null) {
+                throw new RuntimeException("未找到关联的订单商品");
+            }
+
+            ShopGoodsEntity goods = goodsList.stream()
+                    .filter(g -> g.getGoodsId().equals(approvalGoods.getGoodsId())).findFirst().orElse(null);
+            if (goods == null) {
+                throw new RuntimeException("未找到关联的商品");
+            }
+            if (goods.getStock().compareTo(approvalGoodsCell.getAllocateQuantity()) < 0) {
+                throw new RuntimeException("商品库存不足");
+            }
+
+            CabinetCellEntity cell = cabinetCellList.stream()
+                    .filter(c -> c.getCellId().equals(approvalGoodsCell.getCellId()))
+                    .findFirst().orElse(null);
+            // 如果没有找到对应的格口，抛出异常
+            if (cell == null) {
+                throw new RuntimeException("未找到关联的格口");
+            }
+            goods.setStock(goods.getStock() - approvalGoodsCell.getAllocateQuantity());
+            cell.setStock(cell.getStock() - approvalGoodsCell.getAllocateQuantity());
         }
 
         // 更新审批状态为通过
@@ -336,30 +510,197 @@ public class ReturnApprovalApplicationService {
 
         // 调用固资通服务的出库方法
         assetApplicationService.consumeOutput(model.getCorpid(), model.getApplyUserid(), model.getAuditUserid(),
-                model, shopOrderGoodsList, goodsModelList);
+                model, approvalGoodsList, goodsList);
 
         // 开始执行数据库操作
         model.setStatus(2); // 2表示审核通过状态
         model.updateById();
 
-        // 更新关联订单商品状态为已完成退货
-        shopOrderGoodsList.forEach(shopOrderGoods -> {
-            shopOrderGoods.setStatus(4); // 4表示已完成退货
-            shopOrderGoods.updateById();
-        });
-
         // 批量更新商品库存
-        goodsModelList.forEach(GoodsModel::updateById);
+        goodsList.forEach(ShopGoodsEntity::updateById);
 
         // 批量更新格口库存
-        cabinetCellModelList.forEach(CabinetCellModel::updateById);
+        cabinetCellList.forEach(CabinetCellEntity::updateById);
+    }
 
-        OrderModel orderModel = orderModelFactory.loadById(shopOrderGoodsList.get(0).getOrderId());
-        orderModel.setStatus(2);
-        orderModel.setPayStatus(2);
-        orderModel.setPayTime(new Date());
-        orderModel.setIsDeductStock(1);
-        orderModel.updateById();
+
+    /**
+     * 审批通过资产退货申请
+     * @param command 更新退货审批命令，包含审批ID、审批人信息等
+     * @throws RuntimeException 如果商品库存不足
+     */
+    public void approveAssetApproval(UpdateReturnApprovalCommand command) {
+        List<UpdateApprovalGoodsCommand> approvalGoodsCommands = command.getApprovalGoodsList();
+        if (approvalGoodsCommands == null || approvalGoodsCommands.isEmpty()) {
+            throw new RuntimeException("审批通过的耗材列表不能为空");
+        }
+        // 加载退货审批模型
+        ReturnApprovalModel model = modelFactory.loadById(command.getApprovalId());
+
+        // 设置审批人信息
+        if (StringUtils.isNotBlank(command.getAuditName())) {
+            model.setAuditName(command.getAuditName());
+        } else if (StringUtils.isNotBlank(command.getUserid())) {
+            QyUserEntity qyUserEntity = qyUserService.getUserByUserIdAndCorpid(command.getUserid(), model.getCorpid());
+            if (null != qyUserEntity) {
+                model.setAuditName(qyUserEntity.getName());
+            }
+        }
+        // 获取关联的订单商品列表
+        List<ApprovalGoodsEntity> approvalGoodsList = approvalGoodsService.selectByApprovalId(model.getApprovalId());
+        if (approvalGoodsList == null || approvalGoodsList.isEmpty()) {
+            throw new RuntimeException("未找到关联的订单商品");
+        }
+        approvalGoodsList.forEach(approvalGoods -> {
+            approvalGoods.setApprovalQuantity(0);
+        });
+
+        // 获取关联的商品列表
+        QueryWrapper<ShopGoodsEntity> goodsWrapper = new QueryWrapper<>();
+        goodsWrapper.in("goods_id", approvalGoodsCommands.stream().map(ApprovalGoodsEntity::getGoodsId).distinct().collect(Collectors.toList()))
+                .eq("deleted", false);
+        List<ShopGoodsEntity> goodsList = shopGoodsService.list(goodsWrapper);
+        if (goodsList == null || goodsList.isEmpty()) {
+            throw new RuntimeException("未找到关联的商品");
+        }
+
+        // 初始化商品和格口模型列表
+        List<CabinetCellEntity> cabinetCellList = new ArrayList<>();
+        List<ApprovalGoodsCellEntity> addApprovalGoodsCellList = new ArrayList<>();
+
+        for (ApprovalGoodsEntity approvalGoodsCommand : approvalGoodsCommands) {
+            if (approvalGoodsCommand.getApprovalQuantity() == null || approvalGoodsCommand.getApprovalQuantity().compareTo(0) <= 0) {
+                continue;
+            }
+            ApprovalGoodsEntity approvalGoods = approvalGoodsList.stream()
+                    .filter(g -> g.getApprovalGoodsId().equals(approvalGoodsCommand.getApprovalGoodsId())).findFirst().orElse(null);
+            if (approvalGoods == null) {
+                throw new RuntimeException("未找到关联的订单商品");
+            }
+            if (approvalGoods.getApplyQuantity().compareTo(approvalGoodsCommand.getApprovalQuantity()) < 0) {
+                throw new RuntimeException("审批数量不能大于申请数量");
+            }
+            approvalGoods.setApprovalQuantity(approvalGoodsCommand.getApprovalQuantity());
+
+            ShopGoodsEntity goods = goodsList.stream()
+                   .filter(g -> g.getGoodsId().equals(approvalGoodsCommand.getGoodsId())).findFirst().orElse(null);
+            if (goods == null) {
+                throw new RuntimeException("未找到关联的商品");
+            }
+            if (goods.getStock().compareTo(approvalGoodsCommand.getApprovalQuantity()) < 0) {
+                throw new RuntimeException("商品库存不足");
+            }
+
+            List<CabinetCellEntity> cells = cabinetCellService.selectByGoodsId(approvalGoodsCommand.getGoodsId());
+            // 如果没有找到对应的格口，抛出异常
+            if (cells == null || cells.isEmpty()) {
+                throw new RuntimeException("未找到关联的格口");
+            }
+            // 按库存数量从大到小排序
+            cells.sort(Comparator.comparingInt(CabinetCellEntity::getStock).reversed());
+            // 遍历格口列表，从库存最多的格口开始分配，直到满足需求
+            int remainingQuantity = approvalGoodsCommand.getApprovalQuantity();
+            for (CabinetCellEntity cell : cells) {
+                SmartCabinetEntity smartCabinetEntity = smartCabinetService.getByCabinetId(cell.getCabinetId());
+                if (smartCabinetEntity == null) {
+                    throw new RuntimeException("未找到关联的柜子");
+                }
+                ShopEntity shop = shopService.getById(smartCabinetEntity.getShopId());
+
+                ApprovalGoodsCellEntity addApprovalGoodsCellCommand = new ApprovalGoodsCellEntity();
+                addApprovalGoodsCellCommand.initBaseEntity();
+                addApprovalGoodsCellCommand.setApprovalId(command.getApprovalId());
+                addApprovalGoodsCellCommand.setApprovalGoodsId(approvalGoodsCommand.getApprovalGoodsId());
+                addApprovalGoodsCellCommand.setCabinetId(smartCabinetEntity.getCabinetId());
+                addApprovalGoodsCellCommand.setCabinetName(smartCabinetEntity.getCabinetName());
+                addApprovalGoodsCellCommand.setCellId(cell.getCellId());
+                addApprovalGoodsCellCommand.setCellNo(cell.getCellNo());
+                if (shop != null) {
+                    addApprovalGoodsCellCommand.setShopId(shop.getShopId());
+                    addApprovalGoodsCellCommand.setShopName(shop.getShopName());
+                }
+                addApprovalGoodsCellList.add(addApprovalGoodsCellCommand);
+
+                if (cell.getStock() >= remainingQuantity) {
+                    addApprovalGoodsCellCommand.setAllocateQuantity(remainingQuantity);
+                    cell.setStock(cell.getStock() - remainingQuantity);
+                    remainingQuantity = 0;
+                    cabinetCellList.add(cell);
+                    break;
+                } else {
+                    addApprovalGoodsCellCommand.setAllocateQuantity(cell.getStock());
+                    remainingQuantity -= cell.getStock();
+                    cell.setStock(0);
+                    cabinetCellList.add(cell);
+                }
+            }
+            // 如果还有剩余数量，说明库存不足
+            if (remainingQuantity > 0) {
+                throw new RuntimeException("商品" + goods.getGoodsName() + "在柜子中的库存不足");
+            }
+            goods.setStock(goods.getStock() - approvalGoodsCommand.getApprovalQuantity());
+
+        }
+
+        // 更新审批状态为通过
+        model.validateApprovalStatus();
+        model.setAuditImages(command.getAuditImages());
+        model.setAuditRemark(command.getAuditRemark());
+        model.setAuditUserid(command.getAuditUserid());
+        model.setApprovalTime(new Date());
+
+        // 调用固资通服务的出库方法
+        assetApplicationService.consumeOutput(model.getCorpid(), model.getApplyUserid(), model.getAuditUserid(),
+                model, approvalGoodsList, goodsList);
+
+        // 开始执行数据库操作
+        model.setStatus(2); // 2表示审核通过状态
+        model.updateById();
+
+        // 批量更新商品库存
+        goodsList.forEach(ShopGoodsEntity::updateById);
+
+        // 批量更新格口库存
+        cabinetCellList.forEach(CabinetCellEntity::updateById);
+
+        // 批量更新审批商品表
+        approvalGoodsList.forEach(ApprovalGoodsEntity::updateById);
+
+        // 批量插入审批商品格口关联表
+        approvalGoodsCellService.saveBatch(addApprovalGoodsCellList);
+
+    }
+
+    public void rejectAssetApproval(UpdateReturnApprovalCommand command) {
+        ReturnApprovalModel model = modelFactory.loadById(command.getApprovalId());
+        model.validateApprovalStatus();
+
+        // 审批人信息
+        if (StringUtils.isNotBlank(command.getUserid())) {
+            QyUserEntity qyUserEntity = qyUserService.getUserByUserIdAndCorpid(command.getUserid(), command.getCorpid());
+            if (null != qyUserEntity) {
+                model.setAuditUserid(qyUserEntity.getUserid());
+                model.setAuditName(qyUserEntity.getName());
+            }
+        }
+
+        if (model.getAuditUserid() == null) {
+            model.setAuditUserid("woZ1ZrEgAAV9AEdRt1MGQxSg-KDJrDlA");
+        }
+        if (StringUtils.isBlank(command.getAuditName())) {
+            model.setAuditName("用户信息为空");
+        }
+
+        // 更新审批状态为驳回
+        model.setStatus(3);
+        model.setAuditImages(command.getAuditImages());
+        model.setAuditRemark(command.getAuditRemark());
+        model.setApprovalTime(new Date());
+
+
+        assetApplicationService.rejectConsumeOutput(model.getCorpid(), model.getAuditUserid(), model);
+
+        model.updateById();
     }
 
     /**
@@ -439,6 +780,48 @@ public class ReturnApprovalApplicationService {
         return shopOrderGoodsService.selectOrderGoodsByApprovalId(approvalId);
     }
 
+    public List<ApprovalGoodsCellEntity> getApprovalGoodsCell(Long approvalId) {
+        return approvalGoodsCellService.selectByApprovalId(approvalId);
+    }
+
+    public ReturnApprovalDetailDTO getApprovalDetail(Long approvalId) {
+        ReturnApprovalEntity approval = approvalService.getById(approvalId);
+        if (approval == null) {
+            throw new RuntimeException("未找到对应的审批记录");
+        }
+        ReturnApprovalDetailDTO detailDTO = new ReturnApprovalDetailDTO(approval);
+        detailDTO.setGoodsList(approvalGoodsService.selectByApprovalId(approvalId));
+        detailDTO.setApprovalGoodsCellList(approvalGoodsCellService.selectByApprovalId(approvalId));
+        return detailDTO;
+    }
+
+    public PageDTO<ReturnApprovalAssetDTO> getApprovalAssetPage(SearchReturnApprovalAssetQuery<ReturnApprovalEntity> query) {
+        Page<ReturnApprovalEntity> page = approvalService.getApprovalAssetPage(query);
+        List<ReturnApprovalAssetDTO> dtoList = page.getRecords().stream()
+           .map(ReturnApprovalAssetDTO::new)
+           .collect(java.util.stream.Collectors.toList());
+
+        if (!dtoList.isEmpty()) {
+            QueryWrapper<ApprovalGoodsEntity> queryWrapper = new QueryWrapper<>();
+            queryWrapper.in("approval_id",
+                            page.getRecords().stream()
+                                    .map(ReturnApprovalEntity::getApprovalId)
+                                    .collect(java.util.stream.Collectors.toList()))
+                    .eq("deleted", false);
+
+            List<ApprovalGoodsEntity> approvalGoodsEntities = approvalGoodsService.list(queryWrapper);
+
+            for (ReturnApprovalAssetDTO dto : dtoList) {
+                List<ApprovalGoodsEntity> goodsList = approvalGoodsEntities.stream()
+                        .filter(g -> g.getApprovalId().equals(dto.getApprovalId()))
+                        .collect(java.util.stream.Collectors.toList());
+                dto.setGoodsList(goodsList);
+            }
+        }
+
+        return new PageDTO<>(dtoList, page.getTotal());
+    }
+
     /**
      * 审批驳回退货申请
      * @param command 更新退货审批命令（包含驳回原因）
@@ -461,4 +844,74 @@ public class ReturnApprovalApplicationService {
         model.setApprovalTime(new Date());
         model.updateById();
     }
+
+
+    /**
+     * 验证审批码有效性并更新核销状态
+     * @param corpid 企业微信ID
+     * @param approvalType 审批类型（0为借还柜 1为固资通）
+     * @param code 审批码
+     * @throws RuntimeException 当审批码无效或已核销时抛出
+     */
+    public void checkCode(String corpid, Integer approvalType, String code) {
+        QueryWrapper<ReturnApprovalEntity> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("corpid", corpid)
+                .eq("approval_type", approvalType)
+                .eq("code", code)
+                .eq("code_check", 0)
+                .eq("deleted", false);
+        ReturnApprovalEntity approval = approvalService.getOne(queryWrapper);
+        if (approval == null) {
+            throw new RuntimeException("无效的审批码");
+        }
+        approval.setCodeCheck(1);
+        approval.updateById();
+    }
+
+    public void openCabinet(Long approvalGoodsCellId, AddCabinetCellOperationCommand operationCommand) {
+        ApprovalGoodsCellEntity approvalGoodsCell = approvalGoodsCellService.getById(approvalGoodsCellId);
+        if (approvalGoodsCell == null) {
+            throw new RuntimeException("无效的审批商品格口关联");
+        }
+
+        ApprovalGoodsEntity approvalGoods = approvalGoodsService.getById(approvalGoodsCell.getApprovalGoodsId());
+
+        // 获取柜子单元和智能柜信息
+        CabinetCellEntity cabinetCellEntity = cabinetCellService.getById(approvalGoodsCell.getCellId());
+        SmartCabinetEntity smartCabinet = smartCabinetService.getById(cabinetCellEntity.getCabinetId());
+        if (null == smartCabinet) {
+            throw new ApiException(ErrorCode.Client.COMMON_FORBIDDEN_TO_CALL, "柜子不存在");
+        }
+
+        CabinetMainboardEntity cabinetMainboard = cabinetMainboardService.getById(cabinetCellEntity.getMainboardId());
+
+        operationCommand.setCellId(approvalGoodsCell.getCellId());
+        operationCommand.setGoodsId(approvalGoods.getGoodsId());
+        operationCommand.setGoodsName(approvalGoods.getGoodsName());
+        operationCommand.setStatus(1);
+        CabinetCellOperationModel cellOperationModel = cabinetCellOperationModelFactory.create();
+
+        // 构造MQTT开柜指令：
+        // 指令格式：8A + 锁控编号(2位HEX) + 引脚号(2位HEX) + 操作码11
+        String mqttDate = "8A";
+        mqttDate += String.format("%02X", cabinetMainboard.getLockControlNo());
+        mqttDate += String.format("%02X", cabinetCellEntity.getPinNo());
+        mqttDate += "11";
+        try {
+            mqttService.publish(mqttDate, smartCabinet.getMqttServerId());
+        } catch (Exception e) {
+            log.error("mqtt publish error", e);
+            operationCommand.setStatus(2);
+            throw new ApiException(ErrorCode.Internal.INTERNAL_ERROR, "发送指令失败");
+        } finally {
+            // 记录操作日志
+            operationCommand.setCreatorId(0L);
+            operationCommand.setCreateTime(new Date());
+            operationCommand.setUpdaterId(0L);
+            operationCommand.setUpdateTime(new Date());
+            operationCommand.setDeleted(false);
+            cellOperationModel.loadAddCommand(operationCommand);
+            cellOperationModel.insert();
+        }
+    }
 }

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/command/UpdateReturnApprovalCommand.java

@@ -2,9 +2,13 @@ package com.agileboot.domain.shop.approval.command;
 
 import javax.validation.constraints.NotNull;
 import javax.validation.constraints.PositiveOrZero;
+
+import com.agileboot.domain.shop.approvalGoods.command.UpdateApprovalGoodsCommand;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
+import java.util.List;
+
 @EqualsAndHashCode(callSuper = true)
 @Data
 public class UpdateReturnApprovalCommand extends AddReturnApprovalCommand {
@@ -14,4 +18,6 @@ public class UpdateReturnApprovalCommand extends AddReturnApprovalCommand {
     private Long approvalId;
 
     private String userid;
+
+    private List<UpdateApprovalGoodsCommand> approvalGoodsList;
 }

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/db/ReturnApprovalEntity.java

@@ -58,6 +58,10 @@ public class ReturnApprovalEntity extends BaseEntity<ReturnApprovalEntity> {
     @TableField("code")
     private String code;
 
+    @ApiModelProperty("审批码校验状态(0未核销 1已核销)")
+    @TableField("code_check")
+    private Integer codeCheck;
+
     @ApiModelProperty("企业微信id")
     @TableField("corpid")
     private String corpid;
@@ -66,6 +70,10 @@ public class ReturnApprovalEntity extends BaseEntity<ReturnApprovalEntity> {
     @TableField("apply_userid")
     private String applyUserid;
 
+    @ApiModelProperty("申请人")
+    @TableField("apply_user_name")
+    private String applyUserName;
+
     @ApiModelProperty("审批人企业UserID")
     @TableField("audit_userid")
     private String auditUserid;
@@ -114,7 +122,7 @@ public class ReturnApprovalEntity extends BaseEntity<ReturnApprovalEntity> {
     @TableField("audit_name")
     private String auditName;
 
-    @ApiModelProperty("审批状态(1待审核 2已通过 3已驳回)")
+    @ApiModelProperty("审批状态(1待审核 2已通过 3已驳回 4开柜中)")
     @TableField("status")
     private Integer status;
 

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/db/ReturnApprovalMapper.java

@@ -26,6 +26,14 @@ public interface ReturnApprovalMapper extends BaseMapper<ReturnApprovalEntity> {
         "${ew.customSqlSegment}")
     Page<ReturnApprovalEntity> selectApprovalWithGoodsInfo(Page<ReturnApprovalEntity> page, 
     @Param(Constants.WRAPPER) Wrapper<ReturnApprovalEntity> queryWrapper);
+
+
+    @Select("SELECT ra.* " +
+            "FROM return_approval ra " +
+            "LEFT JOIN approval_goods ag ON ag.approval_id = ra.approval_id AND ag.deleted = 0 " +
+            "${ew.customSqlSegment}")
+    Page<ReturnApprovalEntity> selectApprovalAssetPage(Page<ReturnApprovalEntity> page,
+                                                           @Param(Constants.WRAPPER) Wrapper<ReturnApprovalEntity> queryWrapper);
     
     @Select("SELECT ra.*, sog.goods_name AS goodsName, sog.cover_img AS coverImg, " +
         "so.mobile, so.userid, so.name, so.payment_method AS paymentMethod " +

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/db/ReturnApprovalService.java

@@ -25,4 +25,6 @@ public interface ReturnApprovalService extends IService<ReturnApprovalEntity> {
     ReturnApprovalEntity getByOrderId(Long orderId);
 
     Page<ReturnApprovalEntity> selectApprovalWithGoodsInfo(AbstractPageQuery<ReturnApprovalEntity> query);
+
+    Page<ReturnApprovalEntity> getApprovalAssetPage(AbstractPageQuery<ReturnApprovalEntity> query);
 }

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/db/ReturnApprovalServiceImpl.java

@@ -48,4 +48,9 @@ public class ReturnApprovalServiceImpl extends ServiceImpl<ReturnApprovalMapper,
     public Page<ReturnApprovalEntity> selectApprovalWithGoodsInfo(AbstractPageQuery<ReturnApprovalEntity> query) {
         return this.baseMapper.selectApprovalWithGoodsInfo(query.toPage(), query.toQueryWrapper());
     }
+
+    @Override
+    public Page<ReturnApprovalEntity> getApprovalAssetPage(AbstractPageQuery<ReturnApprovalEntity> query) {
+        return this.baseMapper.selectApprovalAssetPage(query.toPage(), query.toQueryWrapper());
+    }
 }

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/dto/ReturnApprovalAssetDTO.java

@@ -0,0 +1,21 @@
+package com.agileboot.domain.shop.approval.dto;
+
+import com.agileboot.domain.shop.approval.db.ReturnApprovalEntity;
+import com.agileboot.domain.shop.approvalGoods.db.ApprovalGoodsEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.beans.BeanUtils;
+
+import java.util.List;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class ReturnApprovalAssetDTO extends ReturnApprovalEntity {
+    public ReturnApprovalAssetDTO(ReturnApprovalEntity entity) {
+        if (entity != null) {
+            BeanUtils.copyProperties(entity, this);
+        }
+    }
+
+    private List<ApprovalGoodsEntity> goodsList;
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/dto/ReturnApprovalDTO.java

@@ -28,6 +28,7 @@ public class ReturnApprovalDTO {
             case 1: return "待审核";
             case 2: return "已通过";
             case 3: return "已驳回";
+            case 4: return "开柜中";
             default: return "未知状态";
         }
     }
@@ -53,12 +54,17 @@ public class ReturnApprovalDTO {
     @ExcelColumn(name = "审批码")
     private String code;
 
+    private Integer codeCheck;
+
     @ExcelColumn(name = "企业微信id")
     private String corpid;
 
     @ExcelColumn(name = "申请人企业UserID")
     private String applyUserid;
 
+    @ExcelColumn(name = "申请人")
+    private String applyUserName;
+
     @ExcelColumn(name = "审批人企业UserID")
     private String auditUserid;
 
@@ -95,7 +101,7 @@ public class ReturnApprovalDTO {
     @ExcelColumn(name = "审批人")
     private String auditName;
 
-    @ExcelColumn(name = "审批状态(1待审核 2已通过 3已驳回)")
+    @ExcelColumn(name = "审批状态(1待审核 2已通过 3已驳回 4开柜中)")
     private Integer status;
 
     @ExcelColumn(name = "审批状态")

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/dto/ReturnApprovalDetailDTO.java

@@ -0,0 +1,119 @@
+package com.agileboot.domain.shop.approval.dto;
+
+import cn.hutool.core.bean.BeanUtil;
+import com.agileboot.common.annotation.ExcelColumn;
+import com.agileboot.common.annotation.ExcelSheet;
+import com.agileboot.domain.shop.approval.db.ReturnApprovalEntity;
+import com.agileboot.domain.shop.approvalGoods.db.ApprovalGoodsEntity;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+@Data
+@ExcelSheet(name = "审批详情")
+public class ReturnApprovalDetailDTO {
+
+    public ReturnApprovalDetailDTO(ReturnApprovalEntity entity) {
+        if (entity != null) {
+            BeanUtil.copyProperties(entity, this);
+
+            this.statusStr = convertStatus(entity.getStatus());
+        }
+    }
+
+    private String convertStatus(Integer status) {
+        if (status == null) return "-";
+        switch (status) {
+            case 1: return "待审核";
+            case 2: return "已通过";
+            case 3: return "已驳回";
+            case 4: return "开柜中";
+            default: return "未知状态";
+        }
+    }
+    @ExcelColumn(name = "审批编号")
+    private Long approvalId;
+
+    @ExcelColumn(name = "关联订单ID")
+    private Long orderId;
+
+    @ExcelColumn(name = "关联商品ID")
+    private Long goodsId;
+
+    @ExcelColumn(name = "关联订单商品ID")
+    private Long orderGoodsId;
+
+    @ExcelColumn(name = "外部归属类型的商品ID")
+    private Long externalGoodsId;
+
+    @ExcelColumn(name = "外部归属类型的审批ID")
+    private Long externalApprovalId;
+
+    @ExcelColumn(name = "审批码")
+    private String code;
+
+    private Integer codeCheck;
+
+    @ExcelColumn(name = "企业微信id")
+    private String corpid;
+
+    @ExcelColumn(name = "申请人企业UserID")
+    private String applyUserid;
+
+    @ExcelColumn(name = "申请人")
+    private String applyUserName;
+
+    @ExcelColumn(name = "审批人企业UserID")
+    private String auditUserid;
+
+    @ExcelColumn(name = "申请数量")
+    private Integer applyQuantity;
+
+    @ExcelColumn(name = "审批类型")
+    private Integer approvalType;
+
+    @ExcelColumn(name = "申请说明")
+    private String applyRemark;
+
+    @ExcelColumn(name = "归还数量")
+    private Integer returnQuantity;
+
+    @ExcelColumn(name = "商品单价")
+    private BigDecimal goodsPrice;
+
+    @ExcelColumn(name = "退还金额")
+    private BigDecimal returnAmount;
+
+    @ExcelColumn(name = "归还图片")
+    private String returnImages;
+
+    @ExcelColumn(name = "审核图片")
+    private String auditImages;
+
+    @ExcelColumn(name = "归还说明")
+    private String returnRemark;
+
+    @ExcelColumn(name = "审核说明")
+    private String auditRemark;
+
+    @ExcelColumn(name = "审批人")
+    private String auditName;
+
+    @ExcelColumn(name = "审批状态(1待审核 2已通过 3已驳回 4开柜中)")
+    private Integer status;
+
+    @ExcelColumn(name = "审批状态")
+    private String statusStr;
+
+    /**
+     * 关联的商品信息
+     */
+    private List<ApprovalGoodsEntity> goodsList;
+
+    /**
+     * 关联的商品格口分配信息
+     */
+    private List<ApprovalGoodsCellEntity> approvalGoodsCellList;
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/query/SearchApiReturnApprovalQuery.java

@@ -19,8 +19,10 @@ public class SearchApiReturnApprovalQuery<T> extends AbstractPageQuery<T> {
     private Long externalGoodsId;
     private Long externalApprovalId;
     private String code;
+    private Integer codeCheck;
     private String corpid;
     private String applyUserid;
+    private String applyUserName;
     private String auditUserid;
     private Integer applyQuantity;
     private Integer approvalType;
@@ -42,9 +44,11 @@ public class SearchApiReturnApprovalQuery<T> extends AbstractPageQuery<T> {
             .eq(externalGoodsId != null, "ra.external_goods_id", externalGoodsId)
             .eq(externalApprovalId != null, "ra.external_approval_id", externalApprovalId)
             .eq(StrUtil.isNotEmpty(code), "ra.code", code)
+            .eq(codeCheck != null, "ra.code_check", codeCheck)
             .eq(approvalType != null, "ra.approval_type", approvalType)
             .eq(StrUtil.isNotEmpty(corpid), "ra.corpid", corpid)
             .eq(StrUtil.isNotEmpty(applyUserid), "ra.apply_userid", applyUserid)
+            .eq(StrUtil.isNotEmpty(applyUserName), "ra.apply_user_name", applyUserName)
             .eq(StrUtil.isNotEmpty(auditUserid), "ra.audit_userid", auditUserid)
             .like(StrUtil.isNotEmpty(goodsName), "sog.goods_name", goodsName)
             .between(startTime != null && endTime != null, "ra.create_time", startTime, endTime)

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/query/SearchReturnApprovalAssetQuery.java

@@ -0,0 +1,95 @@
+package com.agileboot.domain.shop.approval.query;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.StrUtil;
+import com.agileboot.common.core.page.AbstractPageQuery;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.Date;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class SearchReturnApprovalAssetQuery<T> extends AbstractPageQuery<T> {
+    private Long approvalId;
+    private Long orderId;
+    private Long goodsId;
+    private Integer status;
+    // 0:未处理 1:已处理
+    private Integer handleStatus;
+    private Long externalGoodsId;
+    private Long externalApprovalId;
+    private String code;
+    private Integer codeCheck;
+    private String corpid;
+    private String applyUserid;
+    private String applyUserName;
+    private String auditUserid;
+    private Integer applyQuantity;
+    private Integer approvalType;
+    private String applyRemark;
+    private String returnRemark;
+    private String auditRemark;
+    private Date startTime;
+    private Date endTime;
+    private String paymentMethod;
+    private Date approvalTime;
+    private String searchStr;
+
+    @Override
+    public QueryWrapper<T> addQueryCondition() {
+        QueryWrapper<T> queryWrapper = new QueryWrapper<>();
+
+        if (status == null && handleStatus!= null) {
+            if (handleStatus == 0) {
+                queryWrapper.and(wrapper ->
+                    wrapper.eq("ra.status", 1)
+                            .or()
+                            .eq("ra.status", 4));
+            } else if (handleStatus == 1) {
+                queryWrapper.and(wrapper ->
+                    wrapper.eq("ra.status", 2)
+                            .or()
+                            .eq("ra.status", 3));
+            }
+        }
+
+        if (StrUtil.isNotEmpty(searchStr)) {
+            if (searchStr.matches("\\d{6}")) {
+                queryWrapper.eq("ra.code", searchStr);
+            } else {
+                queryWrapper.and(wrapper ->
+                    wrapper.like("ra.apply_user_name", searchStr)
+                            .or()
+                            .like("ag.goods_name", searchStr));
+            }
+        }
+
+        queryWrapper
+                .eq(approvalId != null, "ra.approval_id", approvalId)
+                .eq(orderId != null, "ra.order_id", orderId)
+                .eq(goodsId != null, "ra.goods_id", goodsId)
+                .eq(status != null, "ra.status", status)
+                .eq(externalGoodsId != null, "ra.external_goods_id", externalGoodsId)
+                .eq(externalApprovalId != null, "ra.external_approval_id", externalApprovalId)
+                .eq(StrUtil.isNotEmpty(code), "ra.code", code)
+                .eq(codeCheck!= null, "ra.code_check", codeCheck)
+                .eq(approvalType != null, "ra.approval_type", approvalType)
+                .eq(StrUtil.isNotEmpty(corpid), "ra.corpid", corpid)
+                .eq(StrUtil.isNotEmpty(applyUserid), "ra.apply_userid", applyUserid)
+                .eq(StrUtil.isNotEmpty(applyUserName), "ra.apply_user_name", applyUserName)
+                .eq(StrUtil.isNotEmpty(auditUserid), "ra.audit_userid", auditUserid)
+                .like(StrUtil.isNotEmpty(returnRemark), "ra.return_remark", returnRemark)
+                .like(StrUtil.isNotEmpty(auditRemark), "ra.audit_remark", auditRemark)
+                .between(approvalTime != null, "ra.approval_time",
+                        approvalTime == null ? null : DateUtil.beginOfDay(approvalTime).toJdkDate(),
+                        approvalTime == null ? null : DateUtil.endOfDay(approvalTime).toJdkDate())
+                .groupBy("ra.approval_id")
+                .orderByDesc("ra.create_time");
+
+        this.timeRangeColumn = "create_time";
+
+        return queryWrapper;
+    }
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approval/query/SearchReturnApprovalQuery.java

@@ -21,6 +21,7 @@ public class SearchReturnApprovalQuery<T> extends AbstractPageQuery<T> {
     private String code;
     private String corpid;
     private String applyUserid;
+    private String applyUserName;
     private String auditUserid;
     private Integer applyQuantity;
     private Integer approvalType;
@@ -47,6 +48,7 @@ public class SearchReturnApprovalQuery<T> extends AbstractPageQuery<T> {
             .eq(approvalType != null, "ra.approval_type", approvalType)
             .eq(StrUtil.isNotEmpty(corpid), "ra.corpid", corpid)
             .eq(StrUtil.isNotEmpty(applyUserid), "ra.apply_userid", applyUserid)
+            .eq(StrUtil.isNotEmpty(applyUserName), "ra.apply_user_name", applyUserName)
             .eq(StrUtil.isNotEmpty(auditUserid), "ra.audit_userid", auditUserid)
             .like(StrUtil.isNotEmpty(returnRemark), "ra.return_remark", returnRemark)
             .like(StrUtil.isNotEmpty(auditRemark), "ra.audit_remark", auditRemark)

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoods/ApprovalGoodsApplicationService.java

@@ -64,7 +64,7 @@ public class ApprovalGoodsApplicationService {
         return approvalGoodsService.selectLatest();
     }
 
-    public ApprovalGoodsEntity getByApprovalId(Long approvalId) {
+    public List<ApprovalGoodsEntity> getByApprovalId(Long approvalId) {
         return approvalGoodsService.selectByApprovalId(approvalId);
     }
 

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoods/db/ApprovalGoodsEntity.java

@@ -64,6 +64,10 @@ public class ApprovalGoodsEntity extends BaseEntity<ApprovalGoodsEntity> {
     @TableField("apply_quantity")
     private Integer applyQuantity;
 
+    @ApiModelProperty("审批数量")
+    @TableField("approval_quantity")
+    private Integer approvalQuantity;
+
     @ApiModelProperty("封面图URL")
     @TableField("cover_img")
     private String coverImg;

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoods/db/ApprovalGoodsMapper.java

@@ -36,8 +36,8 @@ public interface ApprovalGoodsMapper extends BaseMapper<ApprovalGoodsEntity> {
         "ORDER BY approval_goods_id DESC")
     List<ApprovalGoodsEntity> selectAll();
 
-    @Select("SELECT * FROM approval_goods WHERE approval_id = #{approvalId} LIMIT 1")
-    ApprovalGoodsEntity selectByApprovalId(Long approvalId);
+    @Select("SELECT * FROM approval_goods WHERE approval_id = #{approvalId}")
+    List<ApprovalGoodsEntity> selectByApprovalId(Long approvalId);
 
     @Select("SELECT * FROM approval_goods WHERE goods_id = #{goodsId} LIMIT 1")
     ApprovalGoodsEntity selectByGoodsId(Long goodsId);

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoods/db/ApprovalGoodsService.java

@@ -20,8 +20,8 @@ public interface ApprovalGoodsService extends IService<ApprovalGoodsEntity> {
     List<ApprovalGoodsEntity> selectAll();
     
     ApprovalGoodsEntity selectLatest();
-    
-    ApprovalGoodsEntity selectByApprovalId(Long approvalId);
+
+    List<ApprovalGoodsEntity> selectByApprovalId(Long approvalId);
     
     ApprovalGoodsEntity selectByGoodsId(Long goodsId);
 }

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoods/db/ApprovalGoodsServiceImpl.java

@@ -34,7 +34,7 @@ public class ApprovalGoodsServiceImpl extends ServiceImpl<ApprovalGoodsMapper, A
     }
 
     @Override
-    public ApprovalGoodsEntity selectByApprovalId(Long approvalId) {
+    public List<ApprovalGoodsEntity> selectByApprovalId(Long approvalId) {
         return baseMapper.selectByApprovalId(approvalId);
     }
 

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoods/dto/ApprovalGoodsDTO.java

@@ -46,6 +46,9 @@ public class ApprovalGoodsDTO {
     @ExcelColumn(name = "申请数量")
     private Integer applyQuantity;
 
+    @ExcelColumn(name = "审批数量")
+    private Integer approvalQuantity;
+
     @ExcelColumn(name = "封面图URL")
     private String coverImg;
 }

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/ApprovalGoodsCellApplicationService.java

@@ -0,0 +1,65 @@
+package com.agileboot.domain.shop.approvalGoodsCell;
+
+import com.agileboot.common.core.page.PageDTO;
+import com.agileboot.common.core.page.AbstractPageQuery;
+import com.agileboot.domain.common.command.BulkOperationCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.command.AddApprovalGoodsCellCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.command.UpdateApprovalGoodsCellCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellService;
+import com.agileboot.domain.shop.approvalGoodsCell.model.ApprovalGoodsCellModel;
+import com.agileboot.domain.shop.approvalGoodsCell.model.ApprovalGoodsCellModelFactory;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class ApprovalGoodsCellApplicationService {
+    private final ApprovalGoodsCellService approvalGoodsCellService;
+    private final ApprovalGoodsCellModelFactory approvalGoodsCellModelFactory;
+
+    public PageDTO<ApprovalGoodsCellEntity> getApprovalGoodsCellList(AbstractPageQuery<ApprovalGoodsCellEntity> query) {
+        Page<ApprovalGoodsCellEntity> page = approvalGoodsCellService.getApprovalGoodsCellList(query);
+        return new PageDTO<>(page.getRecords(), page.getTotal());
+    }
+
+    public void addApprovalGoodsCell(AddApprovalGoodsCellCommand command) {
+        ApprovalGoodsCellModel model = approvalGoodsCellModelFactory.create();
+        model.loadAddCommand(command);
+        model.insert();
+    }
+
+    public void updateApprovalGoodsCell(UpdateApprovalGoodsCellCommand command) {
+        ApprovalGoodsCellModel model = approvalGoodsCellModelFactory.loadById(command.getApprovalGoodsCellId());
+        model.loadUpdateCommand(command);
+        model.updateById();
+    }
+
+    public void deleteApprovalGoodsCell(BulkOperationCommand<Long> command) {
+        for (Long id : command.getIds()) {
+            ApprovalGoodsCellModel model = approvalGoodsCellModelFactory.loadById(id);
+            model.deleteById();
+        }
+    }
+
+    public List<ApprovalGoodsCellEntity> getAllApprovalGoodsCells() {
+        return approvalGoodsCellService.selectAll();
+    }
+
+    public List<ApprovalGoodsCellEntity> getByApprovalId(Long approvalId) {
+        return approvalGoodsCellService.selectByApprovalId(approvalId);
+    }
+
+    public ApprovalGoodsCellEntity getByCellId(Long cellId) {
+        return approvalGoodsCellService.selectByCellId(cellId);
+    }
+
+    public List<ApprovalGoodsCellEntity> getByShopId(Long shopId) {
+        return approvalGoodsCellService.selectByShopId(shopId);
+    }
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/command/AddApprovalGoodsCellCommand.java

@@ -0,0 +1,11 @@
+package com.agileboot.domain.shop.approvalGoodsCell.command;
+
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class AddApprovalGoodsCellCommand extends ApprovalGoodsCellEntity {
+
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/command/UpdateApprovalGoodsCellCommand.java

@@ -0,0 +1,16 @@
+package com.agileboot.domain.shop.approvalGoodsCell.command;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.PositiveOrZero;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class UpdateApprovalGoodsCellCommand extends AddApprovalGoodsCellCommand {
+
+    @NotNull
+    @PositiveOrZero
+    private Long approvalGoodsCellId;
+
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/db/ApprovalGoodsCellEntity.java

@@ -0,0 +1,76 @@
+package com.agileboot.domain.shop.approvalGoodsCell.db;
+
+import com.agileboot.common.core.base.BaseEntity;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.io.Serializable;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * <p>
+ * 申请领用商品格口分配表
+ * </p>
+ *
+ * @author valarchie
+ * @since 2025-06-14
+ */
+@Getter
+@Setter
+@TableName("approval_goods_cell")
+@ApiModel(value = "ApprovalGoodsCellEntity对象", description = "申请领用商品格口分配表")
+public class ApprovalGoodsCellEntity extends BaseEntity<ApprovalGoodsCellEntity> {
+
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty("主键ID")
+    @TableId(value = "approval_goods_cell_id", type = IdType.AUTO)
+    private Long approvalGoodsCellId;
+
+    @ApiModelProperty("审批ID")
+    @TableField("approval_id")
+    private Long approvalId;
+
+    @ApiModelProperty("申请领用商品ID")
+    @TableField("approval_goods_id")
+    private Long approvalGoodsId;
+
+    @ApiModelProperty("商店ID")
+    @TableField("shop_id")
+    private Long shopId;
+
+    @ApiModelProperty("柜机ID")
+    @TableField("cabinet_id")
+    private Long cabinetId;
+
+    @ApiModelProperty("格口ID")
+    @TableField("cell_id")
+    private Long cellId;
+
+    @ApiModelProperty("分配数量")
+    @TableField("allocate_quantity")
+    private Integer allocateQuantity;
+
+    @ApiModelProperty("商店名称")
+    @TableField("shop_name")
+    private String shopName;
+
+    @ApiModelProperty("柜机名称")
+    @TableField("cabinet_name")
+    private String cabinetName;
+
+    @ApiModelProperty("格口号")
+    @TableField("cell_no")
+    private Integer cellNo;
+
+
+    @Override
+    public Serializable pkVal() {
+        return this.approvalGoodsCellId;
+    }
+
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/db/ApprovalGoodsCellMapper.java

@@ -0,0 +1,39 @@
+package com.agileboot.domain.shop.approvalGoodsCell.db;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.toolkit.Constants;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import java.util.List;
+
+/**
+ * <p>
+ * 申请领用商品格口分配表 Mapper 接口
+ * </p>
+ *
+ * @author valarchie
+ * @since 2025-06-14
+ */
+public interface ApprovalGoodsCellMapper extends BaseMapper<ApprovalGoodsCellEntity> {
+
+    @Select("SELECT * FROM approval_goods_cell ${ew.customSqlSegment}")
+    Page<ApprovalGoodsCellEntity> getApprovalGoodsCellList(
+        Page<ApprovalGoodsCellEntity> page,
+        @Param(Constants.WRAPPER) Wrapper<ApprovalGoodsCellEntity> queryWrapper
+    );
+
+    @Select("SELECT * FROM approval_goods_cell ORDER BY create_time DESC")
+    List<ApprovalGoodsCellEntity> selectAll();
+
+    @Select("SELECT * FROM approval_goods_cell WHERE approval_id = #{approvalId}")
+    List<ApprovalGoodsCellEntity> selectByApprovalId(Long approvalId);
+
+    @Select("SELECT * FROM approval_goods_cell WHERE cell_id = #{cellId} LIMIT 1")
+    ApprovalGoodsCellEntity selectByCellId(Long cellId);
+
+    @Select("SELECT * FROM approval_goods_cell WHERE shop_id = #{shopId} ORDER BY create_time DESC")
+    List<ApprovalGoodsCellEntity> selectByShopId(Long shopId);
+
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/db/ApprovalGoodsCellService.java

@@ -0,0 +1,27 @@
+package com.agileboot.domain.shop.approvalGoodsCell.db;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ * 申请领用商品格口分配表 服务类
+ * </p>
+ *
+ * @author valarchie
+ * @since 2025-06-14
+ */
+import com.agileboot.common.core.page.AbstractPageQuery;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import java.util.List;
+
+public interface ApprovalGoodsCellService extends IService<ApprovalGoodsCellEntity> {
+    Page<ApprovalGoodsCellEntity> getApprovalGoodsCellList(AbstractPageQuery<ApprovalGoodsCellEntity> query);
+    
+    List<ApprovalGoodsCellEntity> selectAll();
+
+    List<ApprovalGoodsCellEntity> selectByApprovalId(Long approvalId);
+    
+    ApprovalGoodsCellEntity selectByCellId(Long cellId);
+    
+    List<ApprovalGoodsCellEntity> selectByShopId(Long shopId);
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/db/ApprovalGoodsCellServiceImpl.java

@@ -0,0 +1,44 @@
+package com.agileboot.domain.shop.approvalGoodsCell.db;
+
+import com.agileboot.common.core.page.AbstractPageQuery;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+import java.util.List;
+
+/**
+ * <p>
+ * 申请领用商品格口分配表 服务实现类
+ * </p>
+ *
+ * @author valarchie
+ * @since 2025-06-14
+ */
+@Service
+public class ApprovalGoodsCellServiceImpl extends ServiceImpl<ApprovalGoodsCellMapper, ApprovalGoodsCellEntity> implements ApprovalGoodsCellService {
+
+    @Override
+    public Page<ApprovalGoodsCellEntity> getApprovalGoodsCellList(AbstractPageQuery<ApprovalGoodsCellEntity> query) {
+        return baseMapper.getApprovalGoodsCellList(query.toPage(), query.toQueryWrapper());
+    }
+
+    @Override
+    public List<ApprovalGoodsCellEntity> selectAll() {
+        return baseMapper.selectAll();
+    }
+
+    @Override
+    public List<ApprovalGoodsCellEntity> selectByApprovalId(Long approvalId) {
+        return baseMapper.selectByApprovalId(approvalId);
+    }
+
+    @Override
+    public ApprovalGoodsCellEntity selectByCellId(Long cellId) {
+        return baseMapper.selectByCellId(cellId);
+    }
+
+    @Override
+    public List<ApprovalGoodsCellEntity> selectByShopId(Long shopId) {
+        return baseMapper.selectByShopId(shopId);
+    }
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/dto/ApprovalGoodsCellDTO.java

@@ -0,0 +1,48 @@
+package com.agileboot.domain.shop.approvalGoodsCell.dto;
+
+import cn.hutool.core.bean.BeanUtil;
+import com.agileboot.common.annotation.ExcelColumn;
+import com.agileboot.common.annotation.ExcelSheet;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import lombok.Data;
+
+@ExcelSheet(name = "申请领用商品格口分配表")
+@Data
+public class ApprovalGoodsCellDTO {
+
+    public ApprovalGoodsCellDTO(ApprovalGoodsCellEntity entity) {
+        if (entity != null) {
+            BeanUtil.copyProperties(entity, this);
+        }
+    }
+
+    @ExcelColumn(name = "主键ID")
+    private Long approvalGoodsCellId;
+
+    @ExcelColumn(name = "审批ID")
+    private Long approvalId;
+
+    @ExcelColumn(name = "申请领用商品ID")
+    private Long approvalGoodsId;
+
+    @ExcelColumn(name = "商店ID")
+    private Long shopId;
+
+    @ExcelColumn(name = "柜机ID")
+    private Long cabinetId;
+
+    @ExcelColumn(name = "格口ID")
+    private Long cellId;
+
+    @ExcelColumn(name = "分配数量")
+    private Integer allocateQuantity;
+
+    @ExcelColumn(name = "商店名称")
+    private String shopName;
+
+    @ExcelColumn(name = "柜机名称")
+    private String cabinetName;
+
+    @ExcelColumn(name = "格口号")
+    private Integer cellNo;
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/model/ApprovalGoodsCellModel.java

@@ -0,0 +1,39 @@
+package com.agileboot.domain.shop.approvalGoodsCell.model;
+
+import cn.hutool.core.bean.BeanUtil;
+import com.agileboot.domain.shop.approvalGoodsCell.command.AddApprovalGoodsCellCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.command.UpdateApprovalGoodsCellCommand;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellService;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class ApprovalGoodsCellModel extends ApprovalGoodsCellEntity {
+
+    private ApprovalGoodsCellService approvalGoodsCellService;
+
+    public ApprovalGoodsCellModel(ApprovalGoodsCellEntity entity, ApprovalGoodsCellService approvalGoodsCellService) {
+        this(approvalGoodsCellService);
+        if (entity != null) {
+            BeanUtil.copyProperties(entity, this);
+        }
+    }
+
+    public ApprovalGoodsCellModel(ApprovalGoodsCellService approvalGoodsCellService) {
+        this.approvalGoodsCellService = approvalGoodsCellService;
+    }
+
+    public void loadAddCommand(AddApprovalGoodsCellCommand command) {
+        if (command != null) {
+            BeanUtil.copyProperties(command, this, "id");
+        }
+    }
+
+    public void loadUpdateCommand(UpdateApprovalGoodsCellCommand command) {
+        if (command != null) {
+            loadAddCommand(command);
+        }
+    }
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/model/ApprovalGoodsCellModelFactory.java

@@ -0,0 +1,27 @@
+package com.agileboot.domain.shop.approvalGoodsCell.model;
+
+import com.agileboot.common.exception.ApiException;
+import com.agileboot.common.exception.error.ErrorCode;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class ApprovalGoodsCellModelFactory {
+
+    private final ApprovalGoodsCellService approvalGoodsCellService;
+
+    public ApprovalGoodsCellModel loadById(Long approvalGoodsCellId) {
+        ApprovalGoodsCellEntity entity = approvalGoodsCellService.getById(approvalGoodsCellId);
+        if (entity == null) {
+            throw new ApiException(ErrorCode.Business.COMMON_OBJECT_NOT_FOUND, approvalGoodsCellId, "申请领用商品格口分配");
+        }
+        return new ApprovalGoodsCellModel(entity, approvalGoodsCellService);
+    }
+
+    public ApprovalGoodsCellModel create() {
+        return new ApprovalGoodsCellModel(approvalGoodsCellService);
+    }
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/approvalGoodsCell/query/SearchApprovalGoodsCellQuery.java

@@ -0,0 +1,39 @@
+package com.agileboot.domain.shop.approvalGoodsCell.query;
+
+import cn.hutool.core.util.StrUtil;
+import com.agileboot.common.core.page.AbstractPageQuery;
+import com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellEntity;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class SearchApprovalGoodsCellQuery<T> extends AbstractPageQuery<T> {
+
+    private Long approvalId;
+    private Long approvalGoodsId;
+    private Long shopId;
+    private Long cabinetId;
+    private Long cellId;
+    private String shopName;
+    private String cabinetName;
+    private Integer cellNo;
+
+    @Override
+    public QueryWrapper<T> addQueryCondition() {
+        QueryWrapper<T> queryWrapper = new QueryWrapper<>();
+
+        queryWrapper
+            .eq(approvalId != null, "approval_id", approvalId)
+            .eq(approvalGoodsId != null, "approval_goods_id", approvalGoodsId)
+            .eq(shopId != null, "shop_id", shopId)
+            .eq(cabinetId != null, "cabinet_id", cabinetId)
+            .eq(cellId != null, "cell_id", cellId)
+            .like(StrUtil.isNotEmpty(shopName), "shop_name", shopName)
+            .like(StrUtil.isNotEmpty(cabinetName), "cabinet_name", cabinetName)
+            .eq(cellNo != null, "cell_no", cellNo);
+
+        return queryWrapper;
+    }
+}

agileboot-domain/src/main/java/com/agileboot/domain/shop/order/OrderApplicationService.java

@@ -6,6 +6,8 @@ import com.agileboot.common.constant.PayApiConstants;
 import com.agileboot.common.core.page.PageDTO;
 import com.agileboot.common.exception.ApiException;
 import com.agileboot.common.exception.error.ErrorCode;
+import com.agileboot.domain.ab98.user.db.Ab98UserEntity;
+import com.agileboot.domain.ab98.user.db.Ab98UserService;
 import com.agileboot.domain.cabinet.cell.db.CabinetCellEntity;
 import com.agileboot.domain.cabinet.cell.db.CabinetCellService;
 import com.agileboot.domain.cabinet.mainboard.db.CabinetMainboardEntity;
@@ -62,6 +64,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -88,6 +91,7 @@ public class OrderApplicationService {
     private final AuthCorpInfoApplicationService authCorpInfoApplicationService;
     private final AccessTokenApplicationService accessTokenApplicationService;
     private final QyUserService qyUserService;
+    private final Ab98UserService ab98UserService;
 
     public PageDTO<OrderWithGoodsDTO> getOrderList(SearchShopOrderQuery<OrderWithGoodsDTO> query) {
         Page<OrderWithGoodsDTO> page = orderService.getOrderList(query);
@@ -395,11 +399,106 @@ public class OrderApplicationService {
         }
     }
 
-    public GetOrdersByOpenIdDTO getOrdersByOpenId(String openid) {
+    /**
+     * 根据 openid 和 corpid 获取订单相关信息
+     *
+     * @param openid 开放用户 ID
+     * @param corpid 企业微信 ID
+     * @return 包含订单列表、订单商品列表和商品列表的 DTO 对象
+     */
+    public GetOrdersByOpenIdDTO getOrdersByOpenId(String openid, String corpid) {
+        // 根据 openid 获取 Ab98 用户信息
+        Ab98UserEntity ab98User = ab98UserService.getByOpenid(openid);
+
+        // 构建订单查询条件
         QueryWrapper<ShopOrderEntity> orderQueryWrapper = new QueryWrapper<>();
+        // 添加 openid 作为查询条件
         orderQueryWrapper.eq("openid", openid);
+        // 如果 Ab98 用户信息存在
+        if (ab98User != null) {
+            // 添加 or 条件，根据 Ab98 用户的 userid 查询订单
+            orderQueryWrapper.or()
+               .eq("userid", ab98User.getUserid());
+
+            // 如果 corpid 不为空
+            if (StringUtils.isNotBlank(corpid)) {
+                // 根据 Ab98 用户的 ab98UserId 和 corpid 获取企业微信用户信息
+                QyUserEntity qyUser = qyUserService.getUserByAb98UserId(ab98User.getAb98UserId(), corpid);
+                // 如果企业微信用户信息存在
+                if (qyUser!= null) {
+                    // 添加 or 条件，根据企业微信用户的 userid 查询订单
+                    orderQueryWrapper.or()
+                            .eq("userid", qyUser.getUserid());
+                }
+            }
+        }
+        // 根据查询条件获取订单列表
         List<ShopOrderEntity> orderList = orderService.list(orderQueryWrapper);
 
+        // 构建订单商品查询条件
+        QueryWrapper<ShopOrderGoodsEntity> orderGoodsQueryWrapper = new QueryWrapper<>();
+        // 添加订单 ID 作为查询条件，查询属于这些订单的商品
+        orderGoodsQueryWrapper.in("order_id", orderList.stream().map(ShopOrderEntity::getOrderId).collect(Collectors.toList()));
+        // 根据查询条件获取订单商品列表
+        List<ShopOrderGoodsEntity> orderGoods = orderGoodsService.list(orderGoodsQueryWrapper);
+
+        // 构建商品查询条件
+        QueryWrapper<ShopGoodsEntity> goodsQueryWrapper = new QueryWrapper<>();
+        // 添加商品 ID 作为查询条件，查询这些商品信息
+        goodsQueryWrapper.in("goods_id", orderGoods.stream().map(ShopOrderGoodsEntity::getGoodsId).collect(Collectors.toList()));
+        // 根据查询条件获取商品列表
+        List<ShopGoodsEntity> goods = goodsService.list(goodsQueryWrapper);
+
+        // 返回包含订单列表、订单商品列表和商品列表的 DTO 对象
+        return new GetOrdersByOpenIdDTO(orderList, orderGoods, goods);
+    }
+
+    /**
+     * 根据企业微信用户 ID 获取订单相关信息
+     *
+     * @param qyUserId 企业微信用户 ID
+     * @return 包含订单列表、订单商品列表和商品列表的 DTO 对象
+     */
+    public GetOrdersByOpenIdDTO getOrdersByQyUserId(Long qyUserId) {
+        // 校验 qyUserId 是否为空，为空则抛出异常
+        if (qyUserId == null) {
+            throw new ApiException(ErrorCode.Client.COMMON_REQUEST_PARAMETERS_INVALID, "qyUserId不能为空");
+        }
+        // 根据企业微信用户 ID 获取企业微信用户信息
+        QyUserEntity qyUser = qyUserService.getById(qyUserId);
+
+        // 构建订单查询条件
+        QueryWrapper<ShopOrderEntity> orderQueryWrapper = new QueryWrapper<>();
+        // 添加企业微信用户的 userid 作为查询条件
+        orderQueryWrapper.eq("userid", qyUser.getUserid());
+        // 如果企业微信用户的 ab98UserId 不为空
+        if (qyUser.getAb98UserId() != null) {
+            // 根据 ab98UserId 获取 Ab98 用户信息
+            Ab98UserEntity ab98User = ab98UserService.getById(qyUser.getAb98UserId());
+            // 如果 Ab98 用户信息存在
+            if (ab98User!= null) {
+                // 添加 or 条件，根据 Ab98 用户的 userid 查询订单
+                orderQueryWrapper.or()
+                        .eq("userid", ab98User.getUserid());
+
+                // 如果 Ab98 用户的 openid 不为空
+                if (StringUtils.isNotBlank(ab98User.getOpenid())) {
+                    // 添加 or 条件，根据 Ab98 用户的 openid 查询订单
+                    orderQueryWrapper.or()
+                            .eq("openid", ab98User.getOpenid());
+                }
+            }
+        }
+        // 根据查询条件获取订单列表
+        List<ShopOrderEntity> orderList = orderService.list(orderQueryWrapper);
+
+        // 构建订单商品查询条件
+        // 返回包含订单列表、订单商品列表和商品列表的 DTO 对象
+        // 根据查询条件获取商品列表
+        // 添加商品 ID 作为查询条件，查询这些商品信息
+        // 构建商品查询条件
+        // 根据查询条件获取订单商品列表
+        // 添加订单 ID 作为查询条件，查询属于这些订单的商品
         QueryWrapper<ShopOrderGoodsEntity> orderGoodsQueryWrapper = new QueryWrapper<>();
         orderGoodsQueryWrapper.in("order_id", orderList.stream().map(ShopOrderEntity::getOrderId).collect(Collectors.toList()));
         List<ShopOrderGoodsEntity> orderGoods = orderGoodsService.list(orderGoodsQueryWrapper);

agileboot-domain/src/main/java/com/agileboot/domain/shop/shop/ShopApplicationService.java

@@ -25,7 +25,7 @@ public class ShopApplicationService {
     private final ShopModelFactory shopModelFactory;
 
     public PageDTO<ShopDTO> getShopList(SearchShopQuery<ShopEntity> query) {
-        Page<ShopEntity> page = shopService.page(query.toPage(), query.toQueryWrapper());
+        Page<ShopEntity> page = shopService.getShopList(query.toPage(), query.toQueryWrapper());
         List<ShopDTO> dtoList = page.getRecords().stream()
             .map(ShopDTO::new)
             .collect(Collectors.toList());

agileboot-domain/src/main/java/com/agileboot/domain/shop/shop/db/ShopEntity.java

@@ -55,6 +55,10 @@ public class ShopEntity extends BaseEntity<ShopEntity> {
     @TableField("cover_img")
     private String coverImg;
 
+    @ApiModelProperty("关联的智能柜数量")
+    @TableField(exist = false)
+    private Integer cabinetCount;
+
     @Override
     public Serializable pkVal() {
         return this.shopId;

agileboot-domain/src/main/java/com/agileboot/domain/shop/shop/db/ShopMapper.java

@@ -18,8 +18,9 @@ import java.util.List;
  * @since 2025-05-09
  */
 public interface ShopMapper extends BaseMapper<ShopEntity> {
-    @Select("SELECT * " +
-        "FROM shop " +
+    @Select("SELECT s.*, COUNT(sc.cabinet_id) AS cabinetCount " +
+        "FROM shop s " +
+        "LEFT JOIN smart_cabinet sc ON sc.shop_id = s.shop_id AND sc.deleted = 0 " +
         "${ew.customSqlSegment}")
     Page<ShopEntity> getShopList(
         Page<ShopEntity> page,

agileboot-domain/src/main/java/com/agileboot/domain/shop/shop/dto/ShopDTO.java

@@ -40,4 +40,7 @@ public class ShopDTO {
 
     @ExcelColumn(name = "封面图URL")
     private String coverImg;
+
+    @ExcelColumn(name = "智能柜数量")
+    private Integer cabinetCount;
 }

agileboot-domain/src/main/java/com/agileboot/domain/shop/shop/query/SearchShopQuery.java

@@ -25,13 +25,14 @@ public class SearchShopQuery<T> extends AbstractPageQuery<T> {
         QueryWrapper<T> queryWrapper = new QueryWrapper<>();
 
         queryWrapper
-            .like(StrUtil.isNotEmpty(shopName), "shop_name", shopName)
-            .eq(StrUtil.isNotEmpty(enable), "enable", enable)
-            .eq(StrUtil.isNotEmpty(corpid), "corpid", corpid)
-            .eq(belongType != null, "belong_type", belongType)
-            .eq(mode != null, "mode", mode)
-            .eq(balanceEnable != null, "balance_enable", balanceEnable)
-            .between(startTime != null && endTime != null, "create_time", startTime, endTime);
+            .like(StrUtil.isNotEmpty(shopName), "s.shop_name", shopName)
+            .eq(StrUtil.isNotEmpty(enable), "s.enable", enable)
+            .eq(StrUtil.isNotEmpty(corpid), "s.corpid", corpid)
+            .eq(belongType != null, "s.belong_type", belongType)
+            .eq(mode != null, "s.mode", mode)
+            .eq(balanceEnable != null, "s.balance_enable", balanceEnable)
+            .between(startTime != null && endTime != null, "s.create_time", startTime, endTime)
+            .groupBy("s.shop_id");
 
         this.timeRangeColumn = "create_time";
 

agileboot-domain/src/main/java/com/agileboot/domain/system/menu/MenuApplicationService.java

@@ -24,6 +24,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 
 /**
@@ -176,4 +177,18 @@ public class MenuApplicationService {
         return buildRouterTree(trees);
     }
 
+    public List<String> getPermissions(SystemLoginUser loginUser) {
+        List<SysMenuEntity> allMenus;
+        if (loginUser.isAdmin()) {
+            allMenus = menuService.list();
+        } else {
+            allMenus = menuService.getMenuListByUserId(loginUser.getUserId());
+        }
+
+        return allMenus.stream()
+           .filter(menu-> StatusEnum.ENABLE.getValue().equals(menu.getStatus()))
+           .map(SysMenuEntity::getPermission)
+            .filter(StringUtils::isNotBlank)
+           .collect(Collectors.toList());
+    }
 }

agileboot-domain/src/main/resources/mapper/shop/ApprovalGoodsCellMapper.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.agileboot.domain.shop.approvalGoodsCell.db.ApprovalGoodsCellMapper">
+
+</mapper>

agileboot-infrastructure/src/main/java/com/agileboot/infrastructure/mybatisplus/CodeGenerator.java

@@ -61,7 +61,7 @@ public class CodeGenerator {
             //生成的类 放在orm子模块下的/target/generated-code目录底下
             .module("/agileboot-orm/target/generated-code")
             .parentPackage("com.agileboot")
-            .tableName("approval_goods")
+            .tableName("approval_goods_cell")
             // 决定是否继承基类
             .isExtendsFromBaseEntity(true)
             .build();

sql/20250611.sql

@@ -25,3 +25,41 @@ AFTER `balance_enable`;
 ALTER TABLE `return_approval` 
 ADD COLUMN `code` varchar(32) DEFAULT NULL COMMENT '审批码' 
 AFTER `external_approval_id`;
+
+ALTER TABLE `return_approval` 
+ADD COLUMN `code_check` TINYINT NOT NULL DEFAULT 0 COMMENT '审批码校验 0未核销 1已核销' 
+AFTER `code`;
+
+ALTER TABLE `return_approval` 
+ADD COLUMN `apply_user_name` varchar(30) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '申请人' 
+AFTER `apply_userid`;
+
+ALTER TABLE `approval_goods` 
+ADD COLUMN `approval_quantity` int DEFAULT NULL COMMENT '审批数量' 
+AFTER `apply_quantity`;
+
+
+CREATE TABLE `approval_goods_cell` (
+  `approval_goods_cell_id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `approval_id` bigint NOT NULL COMMENT '审批ID',
+  `approval_goods_id` bigint NOT NULL COMMENT '申请领用商品ID',
+  `shop_id` bigint NULL COMMENT '商店ID',
+  `cabinet_id` bigint NOT NULL COMMENT '柜机ID',
+  `cell_id` bigint NOT NULL COMMENT '格口ID',
+  `allocate_quantity` int NOT NULL COMMENT '分配数量',
+  `shop_name` varchar(100) NULL COMMENT '商店名称',
+  `cabinet_name` varchar(100) NULL COMMENT '柜机名称',
+  `cell_no` int NULL COMMENT '格口号',
+  `creator_id` bigint NULL DEFAULT '0' COMMENT '创建者ID',
+  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `updater_id` bigint NULL DEFAULT '0' COMMENT '更新者ID',
+  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  `deleted` tinyint(1) NOT NULL DEFAULT '0' COMMENT '删除标志（0存在 1删除）',
+  PRIMARY KEY (`approval_goods_cell_id`),
+  UNIQUE KEY `uk_approval_goods_cell` (`approval_goods_id`, `cell_id`),
+  KEY `idx_approval_id` (`approval_id`),
+  KEY `idx_approval_goods_id` (`approval_goods_id`),
+  KEY `idx_shop_id` (`shop_id`),
+  KEY `idx_cabinet_id` (`cabinet_id`),
+  KEY `idx_cell_id` (`cell_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='申请领用商品格口分配表';