feat(aftersales): 新增售后模块数据权限管理和维修退货功能

云

4 天以前 8f7c42bb0bced4697755299f67483be11da3e44d

feat(aftersales): 新增售后模块数据权限管理和维修退货功能

- 添加AfterSaleNoRedisDAO实现售后单号生成功能
- 实现售后模块数据权限相关实体类、Mapper、Service及权限级别枚举
- 集成权限校验工具类AfterSalePermissionUtils支持多场景权限控制
- 开发售后维修记录的完整CRUD功能包括维修创建、更新、完成等操作
- 实现售后退货申请管理包括分页查询、审核、详情获取等功能
- 添加退货明细行数据对象及相应的映射处理
- 集成CRM客户信息展示退货申请中的客户名称
- 实现基于角色和权限的数据访问控制机制

 docs/aftersales_frontend_integration.md

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,636 @@
# å”®åŽå·¥å•æ¨¡å— - å‰ç«¯è”调方案

## æ¶‰åŠé¡µé¢ï¼ˆå…¨éƒ¨æ–°å»ºï¼‰

| é¡µé¢ | è·¯ç”±å»ºè®® | è¯´æ˜Ž |
|------|---------|------|
| å”®åŽå·¥å•åˆ—表 | `/aftersales/ticket` | å·¥å•åˆ—表、搜索、状态筛选 |
| å”®åŽå·¥å•è¯¦æƒ…/编辑 | `/aftersales/ticket/detail?id=:id` | æ–°å»º/编辑工单、查看详情 |
| é€€è´§ç”³è¯·åˆ—表 | `/aftersales/return` | é€€è´§ç”³è¯·åˆ—表、搜索 |
| é€€è´§ç”³è¯·è¯¦æƒ… | `/aftersales/return/detail?id=:id` | é€€è´§è¯¦æƒ…、审核操作 |

## ä¸šåŠ¡æµç¨‹ä¸Žæ•°æ®å¸¦å…¥

### æµç¨‹ä¸€ï¼šä¸€èˆ¬é—®é¢˜å·¥å•

```
创建工单 â†’ åˆ†é…å¤„理人 â†’ é—®é¢˜åˆ¤å®šï¼ˆä¸€èˆ¬é—®é¢˜ï¼‰â†’ å¤„理 â†’ å®Œç»“ â†’ å…³é—­
```

### æµç¨‹äºŒï¼šé€€è´§é—®é¢˜å·¥å•

```
创建工单 â†’ åˆ†é…å¤„理人 â†’ é—®é¢˜åˆ¤å®šï¼ˆé€€è´§é—®é¢˜ï¼‰
  â†’ åˆ›å»ºé€€è´§ç”³è¯· â†’ é”€å”®å®¡æ ¸ â†’ [MES退货流程自动执行] â†’ é€€æ¬¾/换货完成 â†’ å®Œç»“ â†’ å…³é—­
```

### æµç¨‹ä¸‰ï¼šç»´ä¿®é—®é¢˜å·¥å•

```
创建工单 â†’ åˆ†é…å¤„理人 â†’ é—®é¢˜åˆ¤å®šï¼ˆç»´ä¿®é—®é¢˜ï¼‰
  â†’ åˆ›å»ºç»´ä¿®è®°å½• â†’ ç»´ä¿®å®Œæˆ â†’ å®Œç»“ â†’ å…³é—­
```

### æ•°æ®å¸¦å…¥å…³ç³»

| æ­¥éª¤ | æ¥æº | å¸¦å…¥å­—段 |
|------|------|----------|
| åˆ›å»ºé€€è´§ç”³è¯· | å·¥å•è¯¦æƒ… | `ticketId`、`customerId`、`saleOrderId`、工单明细行（`ticketItemId`、`itemId`、`itemCode`、`itemName`） |
| é€€è´§ç”³è¯·å®¡æ‰¹ | é€€è´§ç”³è¯· | `id`（通过 URL å‚数或按钮传入） |

**重点说明：**
- åˆ›å»ºé€€è´§ç”³è¯·æ—¶ï¼Œä»Žå·¥å•è¯¦æƒ…页的明细行中筛选 `needReturn = true` çš„行作为退货明细
- é€€è´§æ˜Žç»†ä¸­çš„ `ticketItemId` å¿…须对应工单明细行的 `id`
- ç‰©æ–™ä¿¡æ¯ï¼ˆ`itemId`、`itemCode`、`itemName`）从工单明细行带入，不允许修改
- é”€å”®å•ä»·ï¼ˆ`unitPrice`）需要从销售订单行查询获取，前端可通过已有的 ERP é”€å”®è®¢å•æŽ¥å£æŸ¥è¯¢

---

## API è¯´æ˜Ž

### ä¸€ã€å”®åŽå·¥å•

| æ–¹æ³• | è·¯å¾„ | æƒé™ | è¯´æ˜Ž |
|------|------|------|------|
| POST | `/aftersales/ticket/create` | `aftersales:ticket:create` | åˆ›å»ºå·¥å• |
| PUT | `/aftersales/ticket/update` | `aftersales:ticket:update` | æ›´æ–°å·¥å•ï¼ˆä»…草稿状态可更新） |
| DELETE | `/aftersales/ticket/delete` | `aftersales:ticket:delete` | åˆ é™¤å·¥å•ï¼ˆä»…草稿/已取消状态可删除） |
| GET | `/aftersales/ticket/get` | `aftersales:ticket:query` | èŽ·å–工单详情 |
| GET | `/aftersales/ticket/page` | `aftersales:ticket:query` | åˆ†é¡µæŸ¥è¯¢å·¥å• |
| POST | `/aftersales/ticket/assign` | `aftersales:ticket:update` | åˆ†é…å¤„理人 |
| POST | `/aftersales/ticket/classify` | `aftersales:ticket:update` | é—®é¢˜åˆ¤å®š |
| PUT | `/aftersales/ticket/resolve` | `aftersales:ticket:update` | å®Œç»“工单 |
| PUT | `/aftersales/ticket/close` | `aftersales:ticket:update` | å…³é—­å·¥å• |
| PUT | `/aftersales/ticket/cancel` | `aftersales:ticket:update` | å–消工单 |

#### 1.1 åˆ›å»ºå·¥å• `POST /aftersales/ticket/create`

**请求参数：**

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| name | String | æ˜¯ | å·¥å•ä¸»é¢˜ |
| customerId | Long | æ˜¯ | å®¢æˆ·ç¼–号 |
| contactId | Long | å¦ | è”系人编号 |
| saleOrderId | Long | å¦ | é”€å”®è®¢å•ç¼–号 |
| saleOrderNo | String | å¦ | é”€å”®è®¢å•å·ï¼ˆå†—余，与 saleOrderId é…å¥—传入） |
| contractId | Long | å¦ | åˆåŒç¼–号 |
| issueDescription | String | å¦ | é—®é¢˜æè¿° |
| remark | String | å¦ | å¤‡æ³¨ |
| items | List\<Item\> | å¦ | æ˜Žç»†è¡Œåˆ—表 |

**Item ç»“构：**

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| saleOrderItemId | Long | å¦ | é”€å”®è®¢å•è¡Œç¼–号 |
| itemId | Long | æ˜¯ | MDM ç‰©æ–™ç¼–号 |
| itemCode | String | å¦ | ç‰©æ–™ç¼–码 |
| itemName | String | å¦ | ç‰©æ–™åç§° |
| batchId | Long | å¦ | ç”Ÿäº§æ‰¹æ¬¡ç¼–号 |
| batchCode | String | å¦ | ç”Ÿäº§æ‰¹æ¬¡å· |
| saleQuantity | BigDecimal | å¦ | é”€å”®æ•°é‡ |
| returnQuantity | BigDecimal | å¦ | é€€è´§æ•°é‡ |
| needRepair | Boolean | å¦ | æ˜¯å¦éœ€è¦ç»´ä¿® |
| needReturn | Boolean | å¦ | æ˜¯å¦éœ€è¦é€€è´§ |
| remark | String | å¦ | å¤‡æ³¨ |

**请求示例：**
```json
{
  "name": "产品外观缺陷投诉",
  "customerId": 1,
  "contactId": 2,
  "saleOrderId": 100,
  "saleOrderNo": "SO202401010001",
  "contractId": 50,
  "issueDescription": "收到货后发现产品表面有明显划痕",
  "remark": "客户要求尽快处理",
  "items": [
    {
      "saleOrderItemId": 10,
      "itemId": 200,
      "itemCode": "MAT-001",
      "itemName": "电子元器件",
      "batchId": 5,
      "batchCode": "BATCH-2024-001",
      "saleQuantity": 100.000,
      "returnQuantity": 10.000,
      "needRepair": false,
      "needReturn": true,
      "remark": "外观缺陷"
    }
  ]
}
```

**响应：** `{ "code": 0, "data": 1 }` â€” data ä¸ºæ–°å»ºå·¥å• ID

#### 1.2 æ›´æ–°å·¥å• `PUT /aftersales/ticket/update`

请求参数与创建相同，额外需要 `id` å­—段。仅草稿状态可更新。

#### 1.3 åˆ é™¤å·¥å• `DELETE /aftersales/ticket/delete`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | å·¥å•ç¼–号（Query å‚数） |

**响应：** `{ "code": 0, "data": true }`

#### 1.4 èŽ·å–工单详情 `GET /aftersales/ticket/get`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | å·¥å•ç¼–号（Query å‚数） |

**响应字段：**

| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | Long | å·¥å•ç¼–号 |
| no | String | å·¥å•å•å·ï¼ˆæ ¼å¼ï¼šAS + yyyyMMdd + 6位序号） |
| name | String | å·¥å•ä¸»é¢˜ |
| customerId | Long | å®¢æˆ·ç¼–号 |
| customerName | String | å®¢æˆ·åç§° |
| contactId | Long | è”系人编号 |
| contactName | String | è”系人名称 |
| saleOrderId | Long | é”€å”®è®¢å•ç¼–号 |
| saleOrderNo | String | é”€å”®è®¢å•å· |
| contractId | Long | åˆåŒç¼–号 |
| issueType | Integer | é—®é¢˜ç±»åž‹ï¼š1-一般问题 2-维修问题 3-退货问题 |
| issueCategory | String | é—®é¢˜åˆ†ç±» |
| issueDescription | String | é—®é¢˜æè¿° |
| severityLevel | Integer | ä¸¥é‡ç¨‹åº¦ï¼š0-轻微 1-一般 2-严重 3-致命 |
| status | Integer | çŠ¶æ€ï¼ˆè§çŠ¶æ€æžšä¸¾ï¼‰ |
| ownerUserId | Long | è´Ÿè´£äººç”¨æˆ·ç¼–号 |
| ownerUserName | String | è´Ÿè´£äººåç§° |
| handlerUserId | Long | å¤„理人用户编号 |
| handlerUserName | String | å¤„理人名称 |
| processInstanceId | String | BPM å·¥ä½œæµå®žä¾‹ç¼–号 |
| returnId | Long | å…³è”退货申请编号 |
| repairId | Long | å…³è”维修记录编号 |
| resolvedTime | DateTime | è§£å†³æ—¶é—´ |
| closedTime | DateTime | å…³é—­æ—¶é—´ |
| remark | String | å¤‡æ³¨ |
| creator | String | åˆ›å»ºè€… |
| createTime | DateTime | åˆ›å»ºæ—¶é—´ |
| updater | String | æ›´æ–°è€… |
| updateTime | DateTime | æ›´æ–°æ—¶é—´ |
| items | List\<Item\> | æ˜Žç»†è¡Œåˆ—表 |

**响应示例：**
```json
{
  "code": 0,
  "data": {
    "id": 1,
    "no": "AS20260730000001",
    "name": "产品外观缺陷投诉",
    "customerId": 1,
    "customerName": "XX科技有限公司",
    "contactId": 2,
    "contactName": "张三",
    "saleOrderId": 100,
    "saleOrderNo": "SO202401010001",
    "contractId": 50,
    "issueType": 3,
    "issueCategory": "外观缺陷",
    "issueDescription": "收到货后发现产品表面有明显划痕",
    "severityLevel": 1,
    "status": 30,
    "ownerUserId": 1,
    "ownerUserName": "管理员",
    "handlerUserId": 2,
    "handlerUserName": "售后专员",
    "returnId": 1,
    "items": [
      {
        "id": 1,
        "ticketId": 1,
        "saleOrderItemId": 10,
        "itemId": 200,
        "itemCode": "MAT-001",
        "itemName": "电子元器件",
        "batchId": 5,
        "batchCode": "BATCH-2024-001",
        "saleQuantity": 100.000,
        "returnQuantity": 10.000,
        "needRepair": false,
        "needReturn": true
      }
    ]
  }
}
```

#### 1.5 åˆ†é¡µæŸ¥è¯¢å·¥å• `GET /aftersales/ticket/page`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| pageNo | Integer | å¦ | é¡µç ï¼Œé»˜è®¤ 1 |
| pageSize | Integer | å¦ | æ¯é¡µå¤§å°ï¼Œé»˜è®¤ 10 |
| no | String | å¦ | å·¥å•å•å· |
| name | String | å¦ | å·¥å•ä¸»é¢˜ |
| customerId | Long | å¦ | å®¢æˆ·ç¼–号 |
| saleOrderId | Long | å¦ | é”€å”®è®¢å•ç¼–号 |
| status | Integer | å¦ | å·¥å•çŠ¶æ€ |
| issueType | Integer | å¦ | é—®é¢˜ç±»åž‹ |
| sceneType | Integer | å¦ | åœºæ™¯ç±»åž‹ï¼š1-我负责的 2-我参与的 3-下属负责的 4-全部 |

**响应：**
```json
{
  "code": 0,
  "data": {
    "list": [ /* AfterSaleTicketRespVO æ•°ç»„ */ ],
    "total": 100
  }
}
```

**注意：** åˆ†é¡µåˆ—表响应中的每条记录结构与详情接口一致（含 `items` å’Œå…³è”名称字段），但列表场景下 `items` å¯ä¸ºç©ºã€‚

#### 1.6 åˆ†é…å¤„理人 `POST /aftersales/ticket/assign`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | å·¥å•ç¼–号（Query å‚数） |
| handlerUserId | Long | æ˜¯ | å¤„理人用户编号（Query å‚数） |

**业务规则：** ä»…草稿、处理中状态可分配。分配后状态自动变为"处理中"。

#### 1.7 é—®é¢˜åˆ¤å®š `POST /aftersales/ticket/classify`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | å·¥å•ç¼–号（Query å‚数） |
| issueType | Integer | æ˜¯ | é—®é¢˜ç±»åž‹ï¼š1-一般问题 2-维修问题 3-退货问题 |
| issueCategory | String | å¦ | é—®é¢˜åˆ†ç±»ï¼ˆå¦‚"外观缺陷"、"功能故障"等） |
| severityLevel | Integer | å¦ | ä¸¥é‡ç¨‹åº¦ï¼š0-轻微 1-一般 2-严重 3-致命 |

**业务规则：** ä»…处理中状态可判定。判定为退货问题后，应引导用户创建退货申请。

#### 1.8 å®Œç»“工单 `PUT /aftersales/ticket/resolve`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | å·¥å•ç¼–号（Query å‚数） |

**业务规则：** ä»…处理中/待退货/待退款状态可完结。

#### 1.9 å…³é—­å·¥å• `PUT /aftersales/ticket/close`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | å·¥å•ç¼–号（Query å‚数） |

**业务规则：** ä»…已完结状态可关闭。

#### 1.10 å–消工单 `PUT /aftersales/ticket/cancel`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | å·¥å•ç¼–号（Query å‚数） |

**业务规则：** ä»…草稿、处理中状态可取消。

---

### äºŒã€å”®åŽé€€è´§ç”³è¯·

| æ–¹æ³• | è·¯å¾„ | æƒé™ | è¯´æ˜Ž |
|------|------|------|------|
| POST | `/aftersales/return/create` | `aftersales:return:create` | åˆ›å»ºé€€è´§ç”³è¯· |
| PUT | `/aftersales/return/approve` | `aftersales:return:approve` | å®¡æ ¸é€šè¿‡ï¼ˆè§¦å‘ MES é€€è´§å•ï¼‰ |
| GET | `/aftersales/return/get` | `aftersales:return:query` | èŽ·å–退货详情 |
| GET | `/aftersales/return/page` | `aftersales:return:query` | åˆ†é¡µæŸ¥è¯¢é€€è´§ç”³è¯· |

#### 2.1 åˆ›å»ºé€€è´§ç”³è¯· `POST /aftersales/return/create`

**请求参数：**

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| ticketId | Long | æ˜¯ | å…³è”工单编号 |
| customerId | Long | æ˜¯ | å®¢æˆ·ç¼–号（从工单带入） |
| saleOrderId | Long | å¦ | å…³è”销售订单编号（从工单带入） |
| returnType | Integer | æ˜¯ | é€€è´§ç±»åž‹ï¼š1-退款退货 2-换货 3-仅退款 |
| returnReason | String | æ˜¯ | é€€è´§åŽŸå›  |
| defectCategory | String | å¦ | ç¼ºé™·åˆ†ç±» |
| remark | String | å¦ | å¤‡æ³¨ |
| items | List\<Item\> | æ˜¯ | é€€è´§æ˜Žç»†è¡Œåˆ—表 |

**Item ç»“构：**

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| ticketItemId | Long | æ˜¯ | å·¥å•æ˜Žç»†è¡Œç¼–号（关联 after_sale_ticket_item.id） |
| itemId | Long | æ˜¯ | MDM ç‰©æ–™ç¼–号（从工单明细行带入） |
| itemCode | String | å¦ | ç‰©æ–™ç¼–码 |
| itemName | String | å¦ | ç‰©æ–™åç§° |
| batchId | Long | å¦ | æ‰¹æ¬¡ç¼–号 |
| batchCode | String | å¦ | æ‰¹æ¬¡å· |
| returnQuantity | BigDecimal | æ˜¯ | é€€è´§æ•°é‡ |
| unitPrice | BigDecimal | æ˜¯ | é”€å”®å•ä»·ï¼ˆéœ€ä»Žé”€å”®è®¢å•è¡ŒæŸ¥è¯¢èŽ·å–） |
| returnPrice | BigDecimal | å¦ | é€€è´§é‡‘额（= returnQuantity Ã— unitPrice） |
| remark | String | å¦ | å¤‡æ³¨ |

**请求示例：**
```json
{
  "ticketId": 1,
  "customerId": 1,
  "saleOrderId": 100,
  "returnType": 1,
  "returnReason": "产品外观缺陷",
  "defectCategory": "外观缺陷",
  "remark": "客户要求退货退款",
  "items": [
    {
      "ticketItemId": 1,
      "itemId": 200,
      "itemCode": "MAT-001",
      "itemName": "电子元器件",
      "batchId": 5,
      "batchCode": "BATCH-2024-001",
      "returnQuantity": 10.000,
      "unitPrice": 100.00,
      "returnPrice": 1000.00
    }
  ]
}
```

**响应：** `{ "code": 0, "data": 1 }` â€” data ä¸ºæ–°å»ºé€€è´§ç”³è¯· ID

**业务规则：**
- åˆ›å»ºé€€è´§ç”³è¯·åŽï¼Œå…³è”工单状态自动变为"待退货(30)"
- `returnPrice` åŽç«¯ä¼šè‡ªåŠ¨è®¡ç®—（`returnQuantity Ã— unitPrice` æ±‚和），前端可不传

#### 2.2 å®¡æ ¸é€šè¿‡ `PUT /aftersales/return/approve`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | é€€è´§ç”³è¯·ç¼–号（Query å‚数） |

**业务规则：**
- ä»…草稿状态(0)可审核
- å®¡æ ¸é€šè¿‡åŽï¼ŒåŽç«¯è‡ªåŠ¨è°ƒç”¨ MES åˆ›å»ºé”€å”®é€€è´§å•ï¼ŒçŠ¶æ€å˜ä¸º"审核通过-已同步MES(20)"
- åŽç»­ MES é€€è´§æµç¨‹ï¼ˆè´¨æ£€â†’入库→退款）由后端回调自动完成，前端无需操作

#### 2.3 èŽ·å–退货详情 `GET /aftersales/return/get`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | æ˜¯ | é€€è´§ç”³è¯·ç¼–号（Query å‚数） |

**响应字段（新增/重要字段）：**

| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | Long | é€€è´§ç”³è¯·ç¼–号 |
| no | String | é€€è´§å•å·ï¼ˆæ ¼å¼ï¼šRT + yyyyMMdd + 6位序号） |
| ticketId | Long | å…³è”工单编号 |
| customerId | Long | å®¢æˆ·ç¼–号 |
| customerName | String | å®¢æˆ·åç§° |
| saleOrderId | Long | é”€å”®è®¢å•ç¼–号 |
| returnType | Integer | é€€è´§ç±»åž‹ |
| returnReason | String | é€€è´§åŽŸå›  |
| defectCategory | String | ç¼ºé™·åˆ†ç±» |
| totalReturnPrice | BigDecimal | åº”退总金额 |
| actualRefundPrice | BigDecimal | å®žé€€é‡‘额 |
| status | Integer | çŠ¶æ€ï¼ˆè§é€€è´§çŠ¶æ€æžšä¸¾ï¼‰ |
| auditUserId | Long | å®¡æ ¸äºº |
| auditTime | DateTime | å®¡æ ¸æ—¶é—´ |
| mesReturnId | Long | MES退货单编号 |
| mesReturnCode | String | MES退货单号 |
| qualityResult | String | è´¨æ£€ç»“论 |
| qualityReportUrl | String | è´¨æ£€æŠ¥å‘Šé™„件URL |
| returnInboundTime | DateTime | é€€è´§å…¥åº“完成时间 |
| refundTime | DateTime | é€€æ¬¾å®Œæˆæ—¶é—´ |
| items | List\<Item\> | é€€è´§æ˜Žç»†è¡Œ |

#### 2.4 åˆ†é¡µæŸ¥è¯¢é€€è´§ç”³è¯· `GET /aftersales/return/page`

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| pageNo | Integer | å¦ | é¡µç  |
| pageSize | Integer | å¦ | æ¯é¡µå¤§å° |
| no | String | å¦ | é€€è´§å•å· |
| ticketId | Long | å¦ | å…³è”工单编号 |
| customerId | Long | å¦ | å®¢æˆ·ç¼–号 |
| status | Integer | å¦ | é€€è´§çŠ¶æ€ |
| sceneType | Integer | å¦ | åœºæ™¯ç±»åž‹ |

---

## æžšä¸¾å€¼é€ŸæŸ¥

### å·¥å•çŠ¶æ€ (AfterSaleTicketStatusEnum)

| å€¼ | åç§° | è¯´æ˜Ž |
|----|------|------|
| 0 | è‰ç¨¿ | å¯ç¼–辑、可删除、可取消 |
| 10 | å¤„理中 | å¯åˆ†é…ã€å¯åˆ¤å®šã€å¯å–消 |
| 30 | å¾…退货 | é€€è´§æµç¨‹è¿›è¡Œä¸­ |
| 40 | å¾…退款/换货 | ç­‰å¾…退款或换货完成 |
| 50 | å·²å®Œç»“ | å¯å…³é—­ |
| 60 | å·²å…³é—­ | ç»ˆæ€ |
| 99 | å·²å–消 | ç»ˆæ€ |

### é—®é¢˜ç±»åž‹ (AfterSaleIssueTypeEnum)

| å€¼ | åç§° | åŽç»­æ“ä½œ |
|----|------|----------|
| 0 | æœªåˆ¤å®š | åˆ›å»ºå·¥å•æ—¶çš„初始值 |
| 1 | ä¸€èˆ¬é—®é¢˜ | ç›´æŽ¥å¤„理→完结 |
| 2 | ç»´ä¿®é—®é¢˜ | åˆ›å»ºç»´ä¿®è®°å½•â†’维修完成→完结 |
| 3 | é€€è´§é—®é¢˜ | åˆ›å»ºé€€è´§ç”³è¯·â†’审核→MES退货→完结 |

### é€€è´§çŠ¶æ€ (AfterSaleReturnStatusEnum)

| å€¼ | åç§° | è¯´æ˜Ž |
|----|------|------|
| 0 | è‰ç¨¿ | å¯å®¡æ ¸ |
| 10 | é”€å”®å®¡æ ¸ä¸­ | â€” |
| 20 | å®¡æ ¸é€šè¿‡-已同步MES | ç­‰å¾…MES处理 |
| 30 | æ£€éªŒä¸­ | MES质检进行中 |
| 40 | æ£€éªŒå®Œæˆ | ç­‰å¾…入库 |
| 50 | å·²å…¥åº“ | ç­‰å¾…退款 |
| 60 | é€€æ¬¾/换货完成 | â€” |
| 70 | å·²å…³é—­ | ç»ˆæ€ |
| 99 | å·²å–消 | ç»ˆæ€ |

### é€€è´§ç±»åž‹

| å€¼ | åç§° |
|----|------|
| 1 | é€€æ¬¾é€€è´§ |
| 2 | æ¢è´§ |
| 3 | ä»…退款 |

### ä¸¥é‡ç¨‹åº¦

| å€¼ | åç§° | å»ºè®®é¢œè‰² |
|----|------|----------|
| 0 | è½»å¾® | ç»¿è‰² |
| 1 | ä¸€èˆ¬ | è“è‰² |
| 2 | ä¸¥é‡ | æ©™è‰² |
| 3 | è‡´å‘½ | çº¢è‰² |

### åœºæ™¯ç±»åž‹ (sceneType)

| å€¼ | åç§° | è¯´æ˜Ž |
|----|------|------|
| 1 | æˆ‘负责的 | å½“前用户为负责人 |
| 2 | æˆ‘参与的 | å½“前用户为处理人或被授权 |
| 3 | ä¸‹å±žè´Ÿè´£çš„ | ä¸‹å±žä¸ºè´Ÿè´£äºº |
| 4 | å…¨éƒ¨ | ç®¡ç†å‘˜æŸ¥çœ‹æ‰€æœ‰ |

---

## å­—段展示规则

### å·¥å•åˆ—表页

| å­—段 | å±•ç¤ºä½ç½® | è¯´æ˜Ž |
|------|----------|------|
| no | åˆ—表 | å•å·ï¼Œå¯ç‚¹å‡»è¿›å…¥è¯¦æƒ… |
| name | åˆ—表 | å·¥å•ä¸»é¢˜ |
| customerName | åˆ—表 | å®¢æˆ·åç§° |
| saleOrderNo | åˆ—表 | é”€å”®è®¢å•å· |
| issueType | åˆ—表 | é—®é¢˜ç±»åž‹ï¼Œç”¨æ ‡ç­¾åŒºåˆ†é¢œè‰² |
| severityLevel | åˆ—表 | ä¸¥é‡ç¨‹åº¦ï¼Œç”¨æ ‡ç­¾åŒºåˆ†é¢œè‰² |
| status | åˆ—表 | çŠ¶æ€ï¼Œç”¨æ ‡ç­¾åŒºåˆ†é¢œè‰² |
| ownerUserName | åˆ—表 | è´Ÿè´£äºº |
| handlerUserName | åˆ—表 | å¤„理人 |
| createTime | åˆ—表 | åˆ›å»ºæ—¶é—´ |
| â€” | æœç´¢åŒº | å•å·ã€ä¸»é¢˜ã€å®¢æˆ·ã€è®¢å•ã€çŠ¶æ€ã€é—®é¢˜ç±»åž‹ |
| â€” | æœç´¢åŒº | åœºæ™¯ç±»åž‹ Tab：我负责的/我参与的/下属负责的/全部 |

### å·¥å•è¯¦æƒ…页

| å­—段 | å±•ç¤ºåŒºåŸŸ | è¯´æ˜Ž |
|------|----------|------|
| no | å¤´éƒ¨ | å•å· |
| name | å¤´éƒ¨ | å·¥å•ä¸»é¢˜ |
| status | å¤´éƒ¨ | çŠ¶æ€æ ‡ç­¾ + çŠ¶æ€æµè½¬æŒ‰é’® |
| customerId / customerName | åŸºæœ¬ä¿¡æ¯ | å®¢æˆ·é€‰æ‹©å™¨ï¼ˆåˆ›å»ºæ—¶å¯é€‰ï¼Œåˆ›å»ºåŽåªè¯»ï¼‰ |
| contactId / contactName | åŸºæœ¬ä¿¡æ¯ | è”系人选择器 |
| saleOrderId / saleOrderNo | åŸºæœ¬ä¿¡æ¯ | é”€å”®è®¢å•é€‰æ‹©å™¨ |
| contractId | åŸºæœ¬ä¿¡æ¯ | åˆåŒé€‰æ‹©å™¨ |
| issueType | åŸºæœ¬ä¿¡æ¯ | é—®é¢˜ç±»åž‹ï¼ˆåˆ¤å®šåŽæ˜¾ç¤ºï¼‰ |
| issueCategory | åŸºæœ¬ä¿¡æ¯ | é—®é¢˜åˆ†ç±»ï¼ˆåˆ¤å®šåŽæ˜¾ç¤ºï¼‰ |
| issueDescription | åŸºæœ¬ä¿¡æ¯ | é—®é¢˜æè¿° |
| severityLevel | åŸºæœ¬ä¿¡æ¯ | ä¸¥é‡ç¨‹åº¦ï¼ˆåˆ¤å®šåŽæ˜¾ç¤ºï¼‰ |
| ownerUserId / ownerUserName | åŸºæœ¬ä¿¡æ¯ | è´Ÿè´£äººï¼ˆåˆ›å»ºæ—¶è‡ªåŠ¨è®¾ä¸ºå½“前用户） |
| handlerUserId / handlerUserName | åŸºæœ¬ä¿¡æ¯ | å¤„理人（分配后显示） |
| returnId | åŸºæœ¬ä¿¡æ¯ | å…³è”退货申请（可点击跳转） |
| repairId | åŸºæœ¬ä¿¡æ¯ | å…³è”维修记录（可点击跳转） |
| resolvedTime | åŸºæœ¬ä¿¡æ¯ | è§£å†³æ—¶é—´ï¼ˆå®Œç»“后显示） |
| closedTime | åŸºæœ¬ä¿¡æ¯ | å…³é—­æ—¶é—´ï¼ˆå…³é—­åŽæ˜¾ç¤ºï¼‰ |
| remark | åŸºæœ¬ä¿¡æ¯ | å¤‡æ³¨ |
| items | æ˜Žç»†è¡¨æ ¼ | ç‰©æ–™ã€æ‰¹æ¬¡ã€é”€å”®æ•°é‡ã€é€€è´§æ•°é‡ã€æ˜¯å¦ç»´ä¿®ã€æ˜¯å¦é€€è´§ |
| createTime / creator | åº•éƒ¨ä¿¡æ¯ | åˆ›å»ºä¿¡æ¯ |
| updateTime / updater | åº•éƒ¨ä¿¡æ¯ | æ›´æ–°ä¿¡æ¯ |

### é€€è´§ç”³è¯·åˆ—表页

| å­—段 | å±•ç¤ºä½ç½® | è¯´æ˜Ž |
|------|----------|------|
| no | åˆ—表 | é€€è´§å•å· |
| ticketId | åˆ—表 | å…³è”工单编号（可点击跳转） |
| customerName | åˆ—表 | å®¢æˆ·åç§° |
| returnType | åˆ—表 | é€€è´§ç±»åž‹æ ‡ç­¾ |
| totalReturnPrice | åˆ—表 | åº”退总金额 |
| actualRefundPrice | åˆ—表 | å®žé€€é‡‘额 |
| status | åˆ—表 | çŠ¶æ€æ ‡ç­¾ |
| mesReturnCode | åˆ—表 | MES退货单号 |
| qualityResult | åˆ—表 | è´¨æ£€ç»“论 |
| createTime | åˆ—表 | åˆ›å»ºæ—¶é—´ |

### é€€è´§ç”³è¯·è¯¦æƒ…页

| å­—段 | å±•ç¤ºåŒºåŸŸ | è¯´æ˜Ž |
|------|----------|------|
| no | å¤´éƒ¨ | é€€è´§å•å· |
| status | å¤´éƒ¨ | çŠ¶æ€æ ‡ç­¾ + å®¡æ ¸æŒ‰é’®ï¼ˆè‰ç¨¿çŠ¶æ€æ˜¾ç¤ºï¼‰ |
| ticketId | åŸºæœ¬ä¿¡æ¯ | å…³è”工单（可点击跳转） |
| customerName | åŸºæœ¬ä¿¡æ¯ | å®¢æˆ·åç§° |
| saleOrderId | åŸºæœ¬ä¿¡æ¯ | é”€å”®è®¢å• |
| returnType | åŸºæœ¬ä¿¡æ¯ | é€€è´§ç±»åž‹ |
| returnReason | åŸºæœ¬ä¿¡æ¯ | é€€è´§åŽŸå›  |
| defectCategory | åŸºæœ¬ä¿¡æ¯ | ç¼ºé™·åˆ†ç±» |
| totalReturnPrice | åŸºæœ¬ä¿¡æ¯ | åº”退总金额 |
| actualRefundPrice | åŸºæœ¬ä¿¡æ¯ | å®žé€€é‡‘额 |
| mesReturnId / mesReturnCode | MES信息 | MES退货单 |
| qualityResult | MES信息 | è´¨æ£€ç»“论 |
| qualityReportUrl | MES信息 | è´¨æ£€æŠ¥å‘Šé“¾æŽ¥ |
| returnInboundTime | MES信息 | å…¥åº“时间 |
| refundTime | é€€æ¬¾ä¿¡æ¯ | é€€æ¬¾æ—¶é—´ |
| items | æ˜Žç»†è¡¨æ ¼ | ç‰©æ–™ã€æ‰¹æ¬¡ã€é€€è´§æ•°é‡ã€å•ä»·ã€é€€è´§é‡‘额 |
| createTime / creator | åº•éƒ¨ä¿¡æ¯ | åˆ›å»ºä¿¡æ¯ |

---

## ä¸šåŠ¡è§„则说明

### å·¥å•æ“ä½œæŒ‰é’®æ˜¾éšè§„则

| æ“ä½œ | è‰ç¨¿(0) | å¤„理中(10) | å¾…退货(30) | å¾…退款(40) | å·²å®Œç»“(50) | å·²å…³é—­(60) | å·²å–消(99) |
|------|---------|------------|------------|------------|------------|------------|------------|
| ç¼–辑 | âœ… | âŒ | âŒ | âŒ | âŒ | âŒ | âŒ |
| åˆ é™¤ | âœ… | âŒ | âŒ | âŒ | âŒ | âŒ | âœ… |
| åˆ†é…å¤„理人 | âœ… | âœ… | âŒ | âŒ | âŒ | âŒ | âŒ |
| é—®é¢˜åˆ¤å®š | âŒ | âœ… | âŒ | âŒ | âŒ | âŒ | âŒ |
| åˆ›å»ºé€€è´§ç”³è¯· | âŒ | âœ…(判定为退货后) | âŒ | âŒ | âŒ | âŒ | âŒ |
| å®Œç»“ | âŒ | âœ… | âœ… | âœ… | âŒ | âŒ | âŒ |
| å…³é—­ | âŒ | âŒ | âŒ | âŒ | âœ… | âŒ | âŒ |
| å–消 | âœ… | âœ… | âŒ | âŒ | âŒ | âŒ | âŒ |

### é€€è´§ç”³è¯·æ“ä½œæŒ‰é’®æ˜¾éšè§„则

| æ“ä½œ | è‰ç¨¿(0) | å®¡æ ¸ä¸­(10) | å·²åŒæ­¥MES(20) | æ£€éªŒä¸­(30) | æ£€éªŒå®Œæˆ(40) | å·²å…¥åº“(50) | é€€æ¬¾å®Œæˆ(60) |
|------|---------|------------|---------------|------------|--------------|------------|--------------|
| å®¡æ ¸é€šè¿‡ | âœ… | âŒ | âŒ | âŒ | âŒ | âŒ | âŒ |
| æŸ¥çœ‹è¯¦æƒ… | âœ… | âœ… | âœ… | âœ… | âœ… | âœ… | âœ… |

### åˆ†é¡µæŸ¥è¯¢æ•°æ®æƒé™è¯´æ˜Ž

- **sceneType=1（我负责的）**：显示当前用户为 `ownerUserId` çš„工单 + æ•°æ®äº¤æŽ¥çš„工单
- **sceneType=2（我参与的）**：显示当前用户有读/写权限的工单
- **sceneType=3（下属负责的）**：显示当前用户的下属负责的工单
- **sceneType=4（全部）**：需要管理员权限（`aftersales:admin`）

---

## æ–‡ä»¶ä¸Šä¼ 

售后模块使用统一的文件上传机制，不自行实现上传接口。

**上传流程：**
1. è°ƒç”¨ `POST /system/storage-blob/upload` ä¸Šä¼ æ–‡ä»¶ â†’ èŽ·å¾— `blobId`
2. è°ƒç”¨ `POST /system/storage-attachment/bind` ç»‘定到业务记录

**recordType å–值：**

| ä¸šåŠ¡å¯¹è±¡ | recordType |
|----------|------------|
| å”®åŽå·¥å• | `aftersales_ticket` |
| å”®åŽé€€è´§ç”³è¯· | `aftersales_return` |

**查询附件：** `GET /system/storage-attachment/list?recordType=aftersales_ticket&recordId=1`

---

## æ³¨æ„äº‹é¡¹

1. **明细行更新策略**：更新工单时，明细行采用"先删后增"策略，前端必须传入完整的明细行列表（包括未修改的行），否则会导致明细行丢失。
2. **单号生成**：工单单号（AS前缀）和退货单号（RT前缀）由后端自动生成，前端不需要传入。
3. **状态流转**：所有状态变更操作（分配、判定、完结、关闭、取消、审核）后端都会校验当前状态是否允许，前端应根据按钮显隐规则控制操作入口。
4. **退货审核后自动同步 MES**：审核通过退货申请后，后端自动调用 MES åˆ›å»ºé”€å”®é€€è´§å•ï¼ŒåŽç»­ MES æµç¨‹ï¼ˆè´¨æ£€â†’入库→退款）由回调自动推进状态，前端只需轮询刷新查看最新状态。
5. **数据带入**：创建退货申请时，必须从工单详情页跳转并带入 `ticketId`、`customerId`、`saleOrderId` ä»¥åŠå·¥å•æ˜Žç»†è¡Œä¸­æ ‡è®°ä¸º"需要退货"的行。
6. **权限控制**：所有接口都有 `@PreAuthorize` æƒé™æ ¡éªŒï¼Œå‰ç«¯èœå•å’ŒæŒ‰é’®éœ€è¦å¯¹åº”配置权限标识。
7. **路由权限**：需在 `src/router/routes/modules/` ä¸‹æ–°å»º `aftersales.ts` è·¯ç”±æ¨¡å—文件，并在菜单中注册"售后服务"一级菜单。
8. **API æ¨¡å—**：需在 `src/api/` ä¸‹æ–°å»º `aftersales/` ç›®å½•ï¼Œåˆ›å»º `ticket.ts` å’Œ `return.ts` ä¸¤ä¸ª API æ–‡ä»¶ã€‚

 docs/sql/aftersales_init.sql

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,170 @@
-- ============================================================
-- å”®åŽå·¥å•æ¨¡å— DDL
-- ============================================================

-- 1. å”®åŽå·¥å•ä¸»è¡¨
DROP TABLE IF EXISTS `after_sale_ticket`;
CREATE TABLE `after_sale_ticket` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '工单编号',
  `no` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '工单单号',
  `name` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT '' COMMENT '工单主题/标题',
  `customer_id` bigint NOT NULL COMMENT '客户编号，关联 crm_customer.id',
  `contact_id` bigint DEFAULT NULL COMMENT '联系人编号，关联 crm_contact.id',
  `sale_order_id` bigint DEFAULT NULL COMMENT '销售订单编号，关联 erp_sale_order.id',
  `sale_order_no` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '销售订单号(冗余)',
  `contract_id` bigint DEFAULT NULL COMMENT '合同编号，关联 crm_contract.id',
  `issue_type` tinyint NOT NULL DEFAULT 0 COMMENT '问题类型: 0-未判定 1-一般问题 2-维修问题 3-退货问题',
  `issue_category` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '问题分类',
  `issue_description` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci COMMENT '问题描述',
  `severity_level` tinyint DEFAULT 0 COMMENT '严重程度: 0-轻微 1-一般 2-严重 3-致命',
  `status` tinyint NOT NULL DEFAULT 0 COMMENT '状态: 0-草稿 10-处理中 30-待退货 40-待退款/换货 50-已完结 60-已关闭 99-已取消',
  `owner_user_id` bigint NOT NULL COMMENT '负责人用户编号',
  `handler_user_id` bigint DEFAULT NULL COMMENT '处理人用户编号',
  `process_instance_id` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT 'BPM工作流实例编号',
  `return_id` bigint DEFAULT NULL COMMENT '关联退货申请编号',
  `repair_id` bigint DEFAULT NULL COMMENT '关联维修记录编号',
  `resolved_time` datetime DEFAULT NULL COMMENT '解决时间',
  `closed_time` datetime DEFAULT NULL COMMENT '关闭时间',
  `remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '备注',
  `creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '创建者',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '更新者',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `uk_no` (`no`),
  KEY `idx_customer_id` (`customer_id`),
  KEY `idx_sale_order_id` (`sale_order_id`),
  KEY `idx_owner_user_id` (`owner_user_id`),
  KEY `idx_status` (`status`),
  KEY `idx_create_time` (`create_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='售后工单主表';

-- 2. å”®åŽå·¥å•æ˜Žç»†è¡Œè¡¨
DROP TABLE IF EXISTS `after_sale_ticket_item`;
CREATE TABLE `after_sale_ticket_item` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '编号',
  `ticket_id` bigint NOT NULL COMMENT '工单编号，关联 after_sale_ticket.id',
  `sale_order_item_id` bigint DEFAULT NULL COMMENT '销售订单行编号',
  `item_id` bigint NOT NULL COMMENT 'MDM物料编号',
  `item_code` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '物料编码(冗余)',
  `item_name` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '物料名称(冗余)',
  `batch_id` bigint DEFAULT NULL COMMENT '生产批次编号',
  `batch_code` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '生产批次号',
  `sale_quantity` decimal(10,3) NOT NULL DEFAULT 0.000 COMMENT '销售数量',
  `return_quantity` decimal(10,3) DEFAULT 0.000 COMMENT '退货数量',
  `need_repair` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否需要维修',
  `need_return` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否需要退货',
  `remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '备注',
  `creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '创建者',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '更新者',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `idx_ticket_id` (`ticket_id`),
  KEY `idx_item_id` (`item_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='售后工单明细行表';

-- 3. é€€è´§ç”³è¯·è¡¨
DROP TABLE IF EXISTS `after_sale_return`;
CREATE TABLE `after_sale_return` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '退货申请编号',
  `no` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '退货单号',
  `ticket_id` bigint NOT NULL COMMENT '关联工单编号，关联 after_sale_ticket.id',
  `customer_id` bigint NOT NULL COMMENT '客户编号',
  `sale_order_id` bigint DEFAULT NULL COMMENT '关联销售订单编号',
  `return_type` tinyint NOT NULL COMMENT '退货类型: 1-退款退货 2-换货 3-仅退款',
  `return_reason` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '退货原因',
  `defect_category` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '缺陷分类',
  `total_return_price` decimal(12,2) NOT NULL DEFAULT 0.00 COMMENT '应退总金额',
  `actual_refund_price` decimal(12,2) DEFAULT 0.00 COMMENT '实退金额',
  `status` tinyint NOT NULL DEFAULT 0 COMMENT '状态: 0-草稿 10-销售审核中 20-审核通过已同步MES 30-检验中 40-检验完成 50-已入库 60-退款/换货完成 70-已关闭 99-已取消',
  `audit_user_id` bigint DEFAULT NULL COMMENT '审核人',
  `audit_time` datetime DEFAULT NULL COMMENT '审核时间',
  `mes_return_id` bigint DEFAULT NULL COMMENT 'MES退货单编号，关联 mes_wm_return_sales.id',
  `mes_return_code` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT 'MES退货单号(冗余)',
  `quality_result` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '质检结论: åˆæ ¼/特采/退货/报废',
  `quality_report_url` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '质检报告附件URL',
  `return_inbound_time` datetime DEFAULT NULL COMMENT '退货入库完成时间',
  `refund_time` datetime DEFAULT NULL COMMENT '退款/换货完成时间',
  `remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '备注',
  `creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '创建者',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '更新者',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `uk_no` (`no`),
  KEY `idx_ticket_id` (`ticket_id`),
  KEY `idx_mes_return_id` (`mes_return_id`),
  KEY `idx_status` (`status`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='售后退货申请表';

-- 4. é€€è´§æ˜Žç»†è¡Œè¡¨
DROP TABLE IF EXISTS `after_sale_return_item`;
CREATE TABLE `after_sale_return_item` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '编号',
  `return_id` bigint NOT NULL COMMENT '退货申请编号，关联 after_sale_return.id',
  `ticket_item_id` bigint NOT NULL COMMENT '工单明细行编号，关联 after_sale_ticket_item.id',
  `item_id` bigint NOT NULL COMMENT 'MDM物料编号',
  `item_code` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '物料编码(冗余)',
  `item_name` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '物料名称(冗余)',
  `batch_id` bigint DEFAULT NULL COMMENT '批次编号',
  `batch_code` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '批次号',
  `return_quantity` decimal(10,3) NOT NULL COMMENT '退货数量',
  `unit_price` decimal(12,2) NOT NULL COMMENT '销售单价',
  `return_price` decimal(12,2) NOT NULL COMMENT '退货金额',
  `mes_return_line_id` bigint DEFAULT NULL COMMENT 'MES退货单行编号',
  `remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '备注',
  `creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '创建者',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '更新者',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `idx_return_id` (`return_id`),
  KEY `idx_ticket_item_id` (`ticket_item_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='售后退货明细行表';

-- 5. ç»´ä¿®è®°å½•è¡¨
DROP TABLE IF EXISTS `after_sale_repair`;
CREATE TABLE `after_sale_repair` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '维修记录编号',
  `ticket_id` bigint NOT NULL COMMENT '关联工单编号，关联 after_sale_ticket.id',
  `repair_type` tinyint NOT NULL COMMENT '维修类型: 1-现场维修 2-返厂维修 3-远程指导',
  `fault_description` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci COMMENT '故障描述',
  `repair_action` text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci COMMENT '维修措施',
  `repair_result` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '维修结果: å·²ä¿®å¤/无法修复/部分修复',
  `repair_cost` decimal(10,2) DEFAULT 0.00 COMMENT '维修费用',
  `repair_user_id` bigint DEFAULT NULL COMMENT '维修人',
  `status` tinyint NOT NULL DEFAULT 0 COMMENT '状态: 0-待处理 10-维修中 20-已完成 30-已关闭',
  `start_time` datetime DEFAULT NULL COMMENT '开始维修时间',
  `finish_time` datetime DEFAULT NULL COMMENT '完成维修时间',
  `remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '备注',
  `creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '创建者',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '更新者',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `idx_ticket_id` (`ticket_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='售后维修记录表';

-- 6. å”®åŽæ•°æ®æƒé™è¡¨
DROP TABLE IF EXISTS `after_sale_permission`;
CREATE TABLE `after_sale_permission` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '编号',
  `biz_type` tinyint NOT NULL COMMENT '数据类型: 1-售后工单 2-退货申请 3-维修记录',
  `biz_id` bigint NOT NULL COMMENT '数据编号',
  `user_id` bigint NOT NULL COMMENT '用户编号',
  `level` tinyint NOT NULL COMMENT '权限级别: 1-负责人 2-只读 3-读写',
  `creator` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '创建者',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updater` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT '' COMMENT '更新者',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `idx_biz` (`biz_type`, `biz_id`),
  KEY `idx_user` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='售后数据权限表';

 pom.xml

@@ -38,6 +38,9 @@
        <!-- SRM ä¾›åº”商关系管理模块 -->
        <module>yudao-module-srm-api</module>
        <module>yudao-module-srm</module>
        <!-- å”®åŽå·¥å•æ¨¡å— -->
        <module>yudao-module-aftersales-api</module>
        <module>yudao-module-aftersales</module>
        <!-- è¯·å‚考 https://doc.iocoder.cn/ai/build/ æ–‡æ¡£ï¼Œå®Œæˆ AI æ¨¡å—的启动！！！ -->
<!--        <module>yudao-module-ai</module>-->
    </modules>

 yudao-module-aftersales-api/pom.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,33 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>cn.iocoder.boot</groupId>
        <artifactId>yudao</artifactId>
        <version>${revision}</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>yudao-module-aftersales-api</artifactId>
    <packaging>jar</packaging>

    <name>${project.artifactId}</name>
    <description>
        å”®åŽå·¥å•æ¨¡å—çš„ API æŽ¥å£å®šä¹‰ï¼Œä¾›å…¶ä»–模块引用
    </description>

    <dependencies>
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-common</artifactId>
        </dependency>

        <!-- Swagger æ³¨è§£ -->
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

 yudao-module-aftersales-api/src/main/java/cn/iocoder/yudao/module/aftersales/api/AfterSaleTicketApi.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,54 @@
package cn.iocoder.yudao.module.aftersales.api;

import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.module.aftersales.api.dto.AfterSaleReturnRespDTO;
import cn.iocoder.yudao.module.aftersales.api.dto.AfterSaleTicketRespDTO;

import java.math.BigDecimal;

/**
 * å”®åŽå·¥å• API æŽ¥å£ï¼ˆä¾› MES/ERP è·¨æ¨¡å—调用）
 */
public interface AfterSaleTicketApi {

    String PREFIX = "/rpc-api/aftersales/ticket";

    /**
     * MES é€€è´§è´¨æ£€å®ŒæˆåŽå›žè°ƒ
     *
     * @param returnId      é€€è´§ç”³è¯·ç¼–号
     * @param qualityResult è´¨æ£€ç»“论
     * @param reportUrl     è´¨æ£€æŠ¥å‘Š URL
     */
    CommonResult<Boolean> onReturnQualityFinished(Long returnId, String qualityResult, String reportUrl);

    /**
     * MES é€€è´§å…¥åº“完成后回调
     *
     * @param returnId é€€è´§ç”³è¯·ç¼–号
     */
    CommonResult<Boolean> onReturnInboundFinished(Long returnId);

    /**
     * ERP é€€æ¬¾å®ŒæˆåŽå›žè°ƒ
     *
     * @param returnId           é€€è´§ç”³è¯·ç¼–号
     * @param actualRefundPrice  å®žé€€é‡‘额
     */
    CommonResult<Boolean> onRefundCompleted(Long returnId, BigDecimal actualRefundPrice);

    /**
     * æŸ¥è¯¢å”®åŽå·¥å•ï¼ˆä¾› MES/ERP æŸ¥è¯¢å…³è”信息）
     *
     * @param id å·¥å•ç¼–号
     */
    CommonResult<AfterSaleTicketRespDTO> getTicket(Long id);

    /**
     * æŸ¥è¯¢é€€è´§ç”³è¯·ï¼ˆä¾› MES/ERP æŸ¥è¯¢å…³è”信息）
     *
     * @param id é€€è´§ç”³è¯·ç¼–号
     */
    CommonResult<AfterSaleReturnRespDTO> getReturn(Long id);

}

 yudao-module-aftersales-api/src/main/java/cn/iocoder/yudao/module/aftersales/api/dto/AfterSaleReturnRespDTO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@
package cn.iocoder.yudao.module.aftersales.api.dto;

import lombok.Data;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * å”®åŽé€€è´§ç”³è¯·å“åº” DTO（供 RPC è°ƒç”¨ä½¿ç”¨ï¼‰
 */
@Data
public class AfterSaleReturnRespDTO {

    private Long id;
    private String no;
    private Long ticketId;
    private Long customerId;
    private Long saleOrderId;
    private Integer returnType;
    private String returnReason;
    private BigDecimal totalReturnPrice;
    private BigDecimal actualRefundPrice;
    private Integer status;
    private Long mesReturnId;
    private String mesReturnCode;
    private String qualityResult;
    private String qualityReportUrl;
    private LocalDateTime returnInboundTime;
    private LocalDateTime refundTime;
    private LocalDateTime createTime;

}

 yudao-module-aftersales-api/src/main/java/cn/iocoder/yudao/module/aftersales/api/dto/AfterSaleTicketRespDTO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,31 @@
package cn.iocoder.yudao.module.aftersales.api.dto;

import lombok.Data;

import java.time.LocalDateTime;

/**
 * å”®åŽå·¥å•å“åº” DTO（供 RPC è°ƒç”¨ä½¿ç”¨ï¼‰
 */
@Data
public class AfterSaleTicketRespDTO {

    private Long id;
    private String no;
    private String name;
    private Long customerId;
    private Long saleOrderId;
    private String saleOrderNo;
    private Integer issueType;
    private String issueCategory;
    private String issueDescription;
    private Integer severityLevel;
    private Integer status;
    private Long ownerUserId;
    private Long handlerUserId;
    private Long returnId;
    private Long repairId;
    private LocalDateTime resolvedTime;
    private LocalDateTime createTime;

}

 yudao-module-aftersales/pom.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,118 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>cn.iocoder.boot</groupId>
        <artifactId>yudao</artifactId>
        <version>${revision}</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>yudao-module-aftersales</artifactId>
    <packaging>jar</packaging>

    <name>${project.artifactId}</name>
    <description>
        aftersales åŒ…下，售后服务管理（After-sales Service Management）。
        ä¾‹å¦‚说：售后工单、退货申请、维修记录等等
    </description>

    <dependencies>
        <!-- å”®åŽ API æ¨¡å— -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-aftersales-api</artifactId>
            <version>${revision}</version>
        </dependency>

        <!-- CRM API æ¨¡å— -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-crm-api</artifactId>
            <version>${revision}</version>
        </dependency>

        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-system</artifactId>
            <version>${revision}</version>
        </dependency>
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-infra</artifactId>
            <version>${revision}</version>
        </dependency>
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-bpm</artifactId>
            <version>${revision}</version>
        </dependency>

        <!-- MDM ä¸»æ•°æ®ç®¡ç† API -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-mdm-api</artifactId>
            <version>${revision}</version>
        </dependency>

        <!-- ERP é”€å”®è®¢å• API -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-erp-api</artifactId>
            <version>${revision}</version>
        </dependency>

        <!-- MES API -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-mes-api</artifactId>
            <version>${revision}</version>
        </dependency>

        <!-- HRM API（数据交接） -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-hrm-api</artifactId>
            <version>${revision}</version>
        </dependency>

        <!-- ä¸šåŠ¡ç»„件 -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-spring-boot-starter-biz-ip</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-spring-boot-starter-biz-tenant</artifactId>
        </dependency>

        <!-- Web ç›¸å…³ -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-spring-boot-starter-security</artifactId>
        </dependency>

        <!-- DB ç›¸å…³ -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-spring-boot-starter-mybatis</artifactId>
        </dependency>

        <!-- å·¥å…·ç±»ç›¸å…³ -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-spring-boot-starter-excel</artifactId>
        </dependency>

        <!-- Test æµ‹è¯•ç›¸å…³ -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/api/AfterSaleTicketApiImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,59 @@
package cn.iocoder.yudao.module.aftersales.api;

import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.aftersales.api.dto.AfterSaleReturnRespDTO;
import cn.iocoder.yudao.module.aftersales.api.dto.AfterSaleTicketRespDTO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO;
import cn.iocoder.yudao.module.aftersales.service.returnobj.AfterSaleReturnService;
import cn.iocoder.yudao.module.aftersales.service.ticket.AfterSaleTicketService;
import jakarta.annotation.Resource;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;

import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;

/**
 * å”®åŽå·¥å• API å®žçŽ°ç±»ï¼ˆä¾› MES/ERP è·¨æ¨¡å—调用）
 */
@RestController
public class AfterSaleTicketApiImpl implements AfterSaleTicketApi {

    @Resource
    private AfterSaleTicketService ticketService;
    @Resource
    private AfterSaleReturnService returnService;

    @Override
    public CommonResult<Boolean> onReturnQualityFinished(Long returnId, String qualityResult, String reportUrl) {
        returnService.onQualityFinished(returnId, qualityResult, reportUrl);
        return success(true);
    }

    @Override
    public CommonResult<Boolean> onReturnInboundFinished(Long returnId) {
        returnService.onInboundFinished(returnId);
        return success(true);
    }

    @Override
    public CommonResult<Boolean> onRefundCompleted(Long returnId, BigDecimal actualRefundPrice) {
        returnService.onRefundCompleted(returnId, actualRefundPrice);
        return success(true);
    }

    @Override
    public CommonResult<AfterSaleTicketRespDTO> getTicket(Long id) {
        AfterSaleTicketDO ticket = ticketService.getTicket(id);
        return success(BeanUtils.toBean(ticket, AfterSaleTicketRespDTO.class));
    }

    @Override
    public CommonResult<AfterSaleReturnRespDTO> getReturn(Long id) {
        AfterSaleReturnDO returnDO = returnService.getReturn(id);
        return success(BeanUtils.toBean(returnDO, AfterSaleReturnRespDTO.class));
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/returnobj/AfterSaleReturnController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,95 @@
package cn.iocoder.yudao.module.aftersales.controller.admin.returnobj;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnRespVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnItemDO;
import cn.iocoder.yudao.module.aftersales.service.returnobj.AfterSaleReturnService;
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.*;

import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;

@Tag(name = "管理后台 - å”®åŽé€€è´§ç”³è¯·")
@RestController
@RequestMapping("/aftersales/return")
@Validated
public class AfterSaleReturnController {

    @Resource
    private AfterSaleReturnService returnService;

    @Resource
    private CrmCustomerApi customerApi;

    @PostMapping("/create")
    @Operation(summary = "创建退货申请")
    @PreAuthorize("@ss.hasPermission('aftersales:return:create')")
    public CommonResult<Long> createReturn(@Valid @RequestBody AfterSaleReturnSaveReqVO createReqVO) {
        return success(returnService.createReturn(createReqVO, getLoginUserId()));
    }

    @PutMapping("/approve")
    @Operation(summary = "审核通过退货申请")
    @PreAuthorize("@ss.hasPermission('aftersales:return:approve')")
    public CommonResult<Boolean> approveReturn(@RequestParam("id") Long id) {
        returnService.approveReturn(id);
        return success(true);
    }

    @GetMapping("/get")
    @Operation(summary = "获得退货申请")
    @Parameter(name = "id", description = "退货申请编号", required = true, example = "1")
    @PreAuthorize("@ss.hasPermission('aftersales:return:query')")
    public CommonResult<AfterSaleReturnRespVO> getReturn(@RequestParam("id") Long id) {
        AfterSaleReturnDO returnDO = returnService.getReturn(id);
        List<AfterSaleReturnItemDO> items = returnService.getReturnItemListByReturnId(id);
        List<AfterSaleReturnRespVO> enrichedList = buildReturnDetailList(List.of(returnDO));
        AfterSaleReturnRespVO respVO = enrichedList.get(0);
        respVO.setItems(BeanUtils.toBean(items, AfterSaleReturnRespVO.Item.class));
        return success(respVO);
    }

    @GetMapping("/page")
    @Operation(summary = "获得退货申请分页")
    @PreAuthorize("@ss.hasPermission('aftersales:return:query')")
    public CommonResult<PageResult<AfterSaleReturnRespVO>> getReturnPage(@Valid AfterSaleReturnPageReqVO pageReqVO) {
        PageResult<AfterSaleReturnDO> pageResult = returnService.getReturnPage(pageReqVO, getLoginUserId());
        List<AfterSaleReturnRespVO> list = buildReturnDetailList(pageResult.getList());
        return success(new PageResult<>(list, pageResult.getTotal()));
    }

    // ========== å†…部方法：批量拼装关联名称 ==========

    private List<AfterSaleReturnRespVO> buildReturnDetailList(List<AfterSaleReturnDO> returnList) {
        if (CollUtil.isEmpty(returnList)) {
            return Collections.emptyList();
        }
        // æ‰¹é‡åŠ è½½å®¢æˆ·åç§°
        Set<Long> customerIds = convertSet(returnList, AfterSaleReturnDO::getCustomerId);
        Map<Long, CrmCustomerRespDTO> customerMap = customerApi.getCustomerMap(customerIds);
        // æ‹¼è£…名称字段
        return BeanUtils.toBean(returnList, AfterSaleReturnRespVO.class, vo -> {
            CrmCustomerRespDTO customer = customerMap.get(vo.getCustomerId());
            if (customer != null) vo.setCustomerName(customer.getName());
        });
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/returnobj/vo/AfterSaleReturnPageReqVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,33 @@
package cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo;

import cn.iocoder.yudao.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;

/**
 * å”®åŽé€€è´§ç”³è¯·åˆ†é¡µæŸ¥è¯¢ VO
 */
@Schema(description = "售后退货申请 - åˆ†é¡µæŸ¥è¯¢ Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class AfterSaleReturnPageReqVO extends PageParam {

    @Schema(description = "退货单号", example = "RT20240101000001")
    private String no;

    @Schema(description = "关联工单编号", example = "1")
    private Long ticketId;

    @Schema(description = "客户编号", example = "1")
    private Long customerId;

    @Schema(description = "退货状态", example = "10")
    private Integer status;

    @Schema(description = "场景类型", example = "1")
    private Integer sceneType;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/returnobj/vo/AfterSaleReturnRespVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,139 @@
package cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;

/**
 * å”®åŽé€€è´§ç”³è¯·å“åº” VO
 */
@Schema(description = "售后退货申请 - å“åº” VO")
@Data
public class AfterSaleReturnRespVO {

    @Schema(description = "退货申请编号", example = "1")
    private Long id;

    @Schema(description = "退货单号", example = "RT20240101000001")
    private String no;

    @Schema(description = "关联工单编号", example = "1")
    private Long ticketId;

    @Schema(description = "客户编号", example = "1")
    private Long customerId;

    @Schema(description = "客户名称")
    private String customerName;

    @Schema(description = "关联销售订单编号", example = "1")
    private Long saleOrderId;

    @Schema(description = "退货类型: 1-退款退货 2-换货 3-仅退款", example = "1")
    private Integer returnType;

    @Schema(description = "退货原因", example = "产品外观缺陷")
    private String returnReason;

    @Schema(description = "缺陷分类", example = "外观缺陷")
    private String defectCategory;

    @Schema(description = "应退总金额", example = "1000.00")
    private BigDecimal totalReturnPrice;

    @Schema(description = "实退金额", example = "950.00")
    private BigDecimal actualRefundPrice;

    @Schema(description = "状态", example = "10")
    private Integer status;

    @Schema(description = "审核人", example = "1")
    private Long auditUserId;

    @Schema(description = "审核时间")
    private LocalDateTime auditTime;

    @Schema(description = "MES退货单编号", example = "1")
    private Long mesReturnId;

    @Schema(description = "MES退货单号", example = "MES-RT-001")
    private String mesReturnCode;

    @Schema(description = "质检结论", example = "合格")
    private String qualityResult;

    @Schema(description = "质检报告附件URL")
    private String qualityReportUrl;

    @Schema(description = "退货入库完成时间")
    private LocalDateTime returnInboundTime;

    @Schema(description = "退款/换货完成时间")
    private LocalDateTime refundTime;

    @Schema(description = "备注")
    private String remark;

    @Schema(description = "创建者")
    private String creator;

    @Schema(description = "创建时间")
    private LocalDateTime createTime;

    @Schema(description = "更新者")
    private String updater;

    @Schema(description = "更新时间")
    private LocalDateTime updateTime;

    @Schema(description = "退货明细行列表")
    private List<Item> items;

    @Schema(description = "退货明细行")
    @Data
    public static class Item {

        @Schema(description = "编号", example = "1")
        private Long id;

        @Schema(description = "退货申请编号", example = "1")
        private Long returnId;

        @Schema(description = "工单明细行编号", example = "1")
        private Long ticketItemId;

        @Schema(description = "MDM物料编号", example = "1")
        private Long itemId;

        @Schema(description = "物料编码", example = "MAT-001")
        private String itemCode;

        @Schema(description = "物料名称", example = "电子元器件")
        private String itemName;

        @Schema(description = "批次编号", example = "1")
        private Long batchId;

        @Schema(description = "批次号", example = "BATCH-2024-001")
        private String batchCode;

        @Schema(description = "退货数量", example = "10.000")
        private BigDecimal returnQuantity;

        @Schema(description = "销售单价", example = "100.00")
        private BigDecimal unitPrice;

        @Schema(description = "退货金额", example = "1000.00")
        private BigDecimal returnPrice;

        @Schema(description = "MES退货单行编号", example = "1")
        private Long mesReturnLineId;

        @Schema(description = "备注")
        private String remark;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/returnobj/vo/AfterSaleReturnSaveReqVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,88 @@
package cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo;

import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;

import java.math.BigDecimal;
import java.util.List;

/**
 * å”®åŽé€€è´§ç”³è¯·ä¿å­˜ VO
 */
@Schema(description = "售后退货申请 - ä¿å­˜ Request VO")
@Data
public class AfterSaleReturnSaveReqVO {

    @Schema(description = "退货申请编号", example = "1")
    private Long id;

    @Schema(description = "关联工单编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
    @NotNull(message = "关联工单不能为空")
    private Long ticketId;

    @Schema(description = "客户编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
    @NotNull(message = "客户不能为空")
    private Long customerId;

    @Schema(description = "关联销售订单编号", example = "1")
    private Long saleOrderId;

    @Schema(description = "退货类型: 1-退款退货 2-换货 3-仅退款", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
    @NotNull(message = "退货类型不能为空")
    private Integer returnType;

    @Schema(description = "退货原因", requiredMode = Schema.RequiredMode.REQUIRED, example = "产品外观缺陷")
    @NotEmpty(message = "退货原因不能为空")
    private String returnReason;

    @Schema(description = "缺陷分类", example = "外观缺陷")
    private String defectCategory;

    @Schema(description = "备注")
    private String remark;

    @Schema(description = "退货明细行列表")
    private List<Item> items;

    @Schema(description = "退货明细行")
    @Data
    public static class Item {

        @Schema(description = "工单明细行编号", requiredMode = Schema.RequiredMode.REQUIRED)
        @NotNull(message = "工单明细行不能为空")
        private Long ticketItemId;

        @Schema(description = "MDM物料编号", requiredMode = Schema.RequiredMode.REQUIRED)
        @NotNull(message = "物料不能为空")
        private Long itemId;

        @Schema(description = "物料编码", example = "MAT-001")
        private String itemCode;

        @Schema(description = "物料名称", example = "电子元器件")
        private String itemName;

        @Schema(description = "批次编号", example = "1")
        private Long batchId;

        @Schema(description = "批次号", example = "BATCH-2024-001")
        private String batchCode;

        @Schema(description = "退货数量", requiredMode = Schema.RequiredMode.REQUIRED, example = "10.000")
        @NotNull(message = "退货数量不能为空")
        private BigDecimal returnQuantity;

        @Schema(description = "销售单价", requiredMode = Schema.RequiredMode.REQUIRED, example = "100.00")
        @NotNull(message = "销售单价不能为空")
        private BigDecimal unitPrice;

        @Schema(description = "退货金额", example = "1000.00")
        private BigDecimal returnPrice;

        @Schema(description = "备注")
        private String remark;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/ticket/AfterSaleTicketController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,165 @@
package cn.iocoder.yudao.module.aftersales.controller.admin.ticket;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket.AfterSaleTicketPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket.AfterSaleTicketRespVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket.AfterSaleTicketSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketItemDO;
import cn.iocoder.yudao.module.aftersales.service.ticket.AfterSaleTicketService;
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.*;

import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;

@Tag(name = "管理后台 - å”®åŽå·¥å•")
@RestController
@RequestMapping("/aftersales/ticket")
@Validated
public class AfterSaleTicketController {

    @Resource
    private AfterSaleTicketService ticketService;

    @Resource
    private CrmCustomerApi customerApi;
    @Resource
    private AdminUserApi adminUserApi;

    @PostMapping("/create")
    @Operation(summary = "创建售后工单")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:create')")
    public CommonResult<Long> createTicket(@Valid @RequestBody AfterSaleTicketSaveReqVO createReqVO) {
        return success(ticketService.createTicket(createReqVO, getLoginUserId()));
    }

    @PutMapping("/update")
    @Operation(summary = "更新售后工单")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:update')")
    public CommonResult<Boolean> updateTicket(@Valid @RequestBody AfterSaleTicketSaveReqVO updateReqVO) {
        ticketService.updateTicket(updateReqVO);
        return success(true);
    }

    @DeleteMapping("/delete")
    @Operation(summary = "删除售后工单")
    @Parameter(name = "id", description = "工单编号", required = true)
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:delete')")
    public CommonResult<Boolean> deleteTicket(@RequestParam("id") Long id) {
        ticketService.deleteTicket(id);
        return success(true);
    }

    @GetMapping("/get")
    @Operation(summary = "获得售后工单")
    @Parameter(name = "id", description = "工单编号", required = true, example = "1")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:query')")
    public CommonResult<AfterSaleTicketRespVO> getTicket(@RequestParam("id") Long id) {
        AfterSaleTicketDO ticket = ticketService.getTicket(id);
        List<AfterSaleTicketItemDO> items = ticketService.getTicketItemListByTicketId(id);
        // æ‰¹é‡åŠ è½½å…³è”名称
        List<AfterSaleTicketRespVO> enrichedList = buildTicketDetailList(List.of(ticket));
        AfterSaleTicketRespVO respVO = enrichedList.get(0);
        respVO.setItems(BeanUtils.toBean(items, AfterSaleTicketRespVO.Item.class));
        return success(respVO);
    }

    @GetMapping("/page")
    @Operation(summary = "获得售后工单分页")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:query')")
    public CommonResult<PageResult<AfterSaleTicketRespVO>> getTicketPage(@Valid AfterSaleTicketPageReqVO pageReqVO) {
        PageResult<AfterSaleTicketDO> pageResult = ticketService.getTicketPage(pageReqVO, getLoginUserId());
        List<AfterSaleTicketRespVO> list = buildTicketDetailList(pageResult.getList());
        return success(new PageResult<>(list, pageResult.getTotal()));
    }

    @PostMapping("/assign")
    @Operation(summary = "分配处理人")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:update')")
    public CommonResult<Boolean> assignTicket(@RequestParam("id") Long id,
                                              @RequestParam("handlerUserId") Long handlerUserId) {
        ticketService.assignTicket(id, handlerUserId);
        return success(true);
    }

    @PostMapping("/classify")
    @Operation(summary = "问题判定")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:update')")
    public CommonResult<Boolean> classifyTicket(@RequestParam("id") Long id,
                                                @RequestParam("issueType") Integer issueType,
                                                @RequestParam(value = "issueCategory", required = false) String issueCategory,
                                                @RequestParam(value = "severityLevel", required = false) Integer severityLevel) {
        ticketService.classifyTicket(id, issueType, issueCategory, severityLevel);
        return success(true);
    }

    @PutMapping("/resolve")
    @Operation(summary = "完结工单")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:update')")
    public CommonResult<Boolean> resolveTicket(@RequestParam("id") Long id) {
        ticketService.resolveTicket(id);
        return success(true);
    }

    @PutMapping("/close")
    @Operation(summary = "关闭工单")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:update')")
    public CommonResult<Boolean> closeTicket(@RequestParam("id") Long id) {
        ticketService.closeTicket(id);
        return success(true);
    }

    @PutMapping("/cancel")
    @Operation(summary = "取消工单")
    @PreAuthorize("@ss.hasPermission('aftersales:ticket:update')")
    public CommonResult<Boolean> cancelTicket(@RequestParam("id") Long id) {
        ticketService.cancelTicket(id);
        return success(true);
    }

    // ========== å†…部方法：批量拼装关联名称 ==========

    private List<AfterSaleTicketRespVO> buildTicketDetailList(List<AfterSaleTicketDO> ticketList) {
        if (CollUtil.isEmpty(ticketList)) {
            return Collections.emptyList();
        }
        // 1. æ‰¹é‡åŠ è½½å®¢æˆ·åç§°
        Set<Long> customerIds = convertSet(ticketList, AfterSaleTicketDO::getCustomerId);
        Map<Long, CrmCustomerRespDTO> customerMap = customerApi.getCustomerMap(customerIds);
        // 2. æ‰¹é‡åŠ è½½ç”¨æˆ·åç§°ï¼ˆè´Ÿè´£äºº + å¤„理人）
        Set<Long> userIds = new HashSet<>();
        ticketList.forEach(t -> {
            if (t.getOwnerUserId() != null) userIds.add(t.getOwnerUserId());
            if (t.getHandlerUserId() != null) userIds.add(t.getHandlerUserId());
        });
        Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(userIds);
        // 3. æ‹¼è£…名称字段
        return BeanUtils.toBean(ticketList, AfterSaleTicketRespVO.class, vo -> {
            CrmCustomerRespDTO customer = customerMap.get(vo.getCustomerId());
            if (customer != null) vo.setCustomerName(customer.getName());
            AdminUserRespDTO ownerUser = userMap.get(vo.getOwnerUserId());
            if (ownerUser != null) vo.setOwnerUserName(ownerUser.getNickname());
            AdminUserRespDTO handlerUser = userMap.get(vo.getHandlerUserId());
            if (handlerUser != null) vo.setHandlerUserName(handlerUser.getNickname());
        });
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/ticket/vo/ticket/AfterSaleTicketPageReqVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,39 @@
package cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket;

import cn.iocoder.yudao.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;

/**
 * å”®åŽå·¥å•åˆ†é¡µæŸ¥è¯¢ VO
 */
@Schema(description = "售后工单 - åˆ†é¡µæŸ¥è¯¢ Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class AfterSaleTicketPageReqVO extends PageParam {

    @Schema(description = "工单单号", example = "AS20240101000001")
    private String no;

    @Schema(description = "工单主题", example = "产品外观缺陷")
    private String name;

    @Schema(description = "客户编号", example = "1")
    private Long customerId;

    @Schema(description = "销售订单编号", example = "1")
    private Long saleOrderId;

    @Schema(description = "工单状态", example = "10")
    private Integer status;

    @Schema(description = "问题类型", example = "1")
    private Integer issueType;

    @Schema(description = "场景类型", example = "1")
    private Integer sceneType;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/ticket/vo/ticket/AfterSaleTicketRespVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,151 @@
package cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;

/**
 * å”®åŽå·¥å•å“åº” VO
 */
@Schema(description = "售后工单 - å“åº” VO")
@Data
public class AfterSaleTicketRespVO {

    @Schema(description = "工单编号", example = "1")
    private Long id;

    @Schema(description = "工单单号", example = "AS20240101000001")
    private String no;

    @Schema(description = "工单主题", example = "产品外观缺陷")
    private String name;

    @Schema(description = "客户编号", example = "1")
    private Long customerId;

    @Schema(description = "客户名称")
    private String customerName;

    @Schema(description = "联系人编号", example = "1")
    private Long contactId;

    @Schema(description = "联系人名称")
    private String contactName;

    @Schema(description = "销售订单编号", example = "1")
    private Long saleOrderId;

    @Schema(description = "销售订单号", example = "SO202401010001")
    private String saleOrderNo;

    @Schema(description = "合同编号", example = "1")
    private Long contractId;

    @Schema(description = "问题类型: 1-一般问题 2-维修问题 3-退货问题", example = "1")
    private Integer issueType;

    @Schema(description = "问题分类", example = "外观缺陷")
    private String issueCategory;

    @Schema(description = "问题描述", example = "收到货后发现产品表面有划痕")
    private String issueDescription;

    @Schema(description = "严重程度: 0-轻微 1-一般 2-严重 3-致命", example = "1")
    private Integer severityLevel;

    @Schema(description = "状态: 0-草稿 10-处理中 30-待退货 40-待退款/换货 50-已完结 60-已关闭 99-已取消", example = "0")
    private Integer status;

    @Schema(description = "负责人用户编号", example = "1")
    private Long ownerUserId;

    @Schema(description = "负责人名称")
    private String ownerUserName;

    @Schema(description = "处理人用户编号", example = "2")
    private Long handlerUserId;

    @Schema(description = "处理人名称")
    private String handlerUserName;

    @Schema(description = "BPM å·¥ä½œæµå®žä¾‹ç¼–号")
    private String processInstanceId;

    @Schema(description = "关联退货申请编号", example = "1")
    private Long returnId;

    @Schema(description = "关联维修记录编号", example = "1")
    private Long repairId;

    @Schema(description = "解决时间")
    private LocalDateTime resolvedTime;

    @Schema(description = "关闭时间")
    private LocalDateTime closedTime;

    @Schema(description = "备注")
    private String remark;

    @Schema(description = "创建者")
    private String creator;

    @Schema(description = "创建时间")
    private LocalDateTime createTime;

    @Schema(description = "更新者")
    private String updater;

    @Schema(description = "更新时间")
    private LocalDateTime updateTime;

    @Schema(description = "明细行列表")
    private List<Item> items;

    @Schema(description = "工单明细行")
    @Data
    public static class Item {

        @Schema(description = "编号", example = "1")
        private Long id;

        @Schema(description = "工单编号", example = "1")
        private Long ticketId;

        @Schema(description = "销售订单行编号", example = "1")
        private Long saleOrderItemId;

        @Schema(description = "MDM物料编号", example = "1")
        private Long itemId;

        @Schema(description = "物料编码", example = "MAT-001")
        private String itemCode;

        @Schema(description = "物料名称", example = "电子元器件")
        private String itemName;

        @Schema(description = "生产批次编号", example = "1")
        private Long batchId;

        @Schema(description = "生产批次号", example = "BATCH-2024-001")
        private String batchCode;

        @Schema(description = "销售数量", example = "100.000")
        private BigDecimal saleQuantity;

        @Schema(description = "退货数量", example = "10.000")
        private BigDecimal returnQuantity;

        @Schema(description = "是否需要维修", example = "false")
        private Boolean needRepair;

        @Schema(description = "是否需要退货", example = "true")
        private Boolean needReturn;

        @Schema(description = "备注")
        private String remark;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/controller/admin/ticket/vo/ticket/AfterSaleTicketSaveReqVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,89 @@
package cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket;

import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;

import java.math.BigDecimal;
import java.util.List;

/**
 * å”®åŽå·¥å•ä¿å­˜ VO
 */
@Schema(description = "售后工单 - ä¿å­˜ Request VO")
@Data
public class AfterSaleTicketSaveReqVO {

    @Schema(description = "工单编号", example = "1")
    private Long id;

    @Schema(description = "工单主题", requiredMode = Schema.RequiredMode.REQUIRED, example = "产品外观缺陷")
    @NotEmpty(message = "工单主题不能为空")
    private String name;

    @Schema(description = "客户编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
    @NotNull(message = "客户不能为空")
    private Long customerId;

    @Schema(description = "联系人编号", example = "1")
    private Long contactId;

    @Schema(description = "销售订单编号", example = "1")
    private Long saleOrderId;

    @Schema(description = "销售订单号", example = "SO202401010001")
    private String saleOrderNo;

    @Schema(description = "合同编号", example = "1")
    private Long contractId;

    @Schema(description = "问题描述", example = "收到货后发现产品表面有划痕")
    private String issueDescription;

    @Schema(description = "备注", example = "客户要求尽快处理")
    private String remark;

    @Schema(description = "明细行列表")
    private List<Item> items;

    @Schema(description = "工单明细行")
    @Data
    public static class Item {

        @Schema(description = "销售订单行编号", example = "1")
        private Long saleOrderItemId;

        @Schema(description = "MDM物料编号", requiredMode = Schema.RequiredMode.REQUIRED)
        @NotNull(message = "物料不能为空")
        private Long itemId;

        @Schema(description = "物料编码", example = "MAT-001")
        private String itemCode;

        @Schema(description = "物料名称", example = "电子元器件")
        private String itemName;

        @Schema(description = "生产批次编号", example = "1")
        private Long batchId;

        @Schema(description = "生产批次号", example = "BATCH-2024-001")
        private String batchCode;

        @Schema(description = "销售数量", example = "100.000")
        private BigDecimal saleQuantity;

        @Schema(description = "退货数量", example = "10.000")
        private BigDecimal returnQuantity;

        @Schema(description = "是否需要维修", example = "false")
        private Boolean needRepair;

        @Schema(description = "是否需要退货", example = "true")
        private Boolean needReturn;

        @Schema(description = "备注")
        private String remark;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/dataobject/permission/AfterSalePermissionDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,55 @@
package cn.iocoder.yudao.module.aftersales.dal.dataobject.permission;

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSalePermissionLevelEnum;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

/**
 * å”®åŽæ¨¡å—数据权限 DO
 */
@TableName("after_sale_permission")
@KeySequence("after_sale_permission_seq")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AfterSalePermissionDO extends BaseDO {

    /**
     * ç¼–号，主键自增
     */
    @TableId
    private Long id;

    /**
     * æ•°æ®ç±»åž‹
     *
     * æžšä¸¾ {@link AfterSaleBizTypeEnum}
     */
    private Integer bizType;
    /**
     * æ•°æ®ç¼–号
     *
     * å…³è” {@link AfterSaleBizTypeEnum} å¯¹åº”模块 DO çš„ id å­—段
     */
    private Long bizId;

    /**
     * ç”¨æˆ·ç¼–号
     */
    private Long userId;

    /**
     * æƒé™çº§åˆ«
     *
     * æžšä¸¾ {@link AfterSalePermissionLevelEnum}
     */
    private Integer level;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/dataobject/repair/AfterSaleRepairDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,78 @@
package cn.iocoder.yudao.module.aftersales.dal.dataobject.repair;

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleRepairStatusEnum;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * å”®åŽç»´ä¿®è®°å½• DO
 */
@TableName("after_sale_repair")
@KeySequence("after_sale_repair_seq")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AfterSaleRepairDO extends BaseDO {

    /**
     * ç»´ä¿®è®°å½•ç¼–号
     */
    @TableId
    private Long id;
    /**
     * å…³è”工单编号，关联 after_sale_ticket.id
     */
    private Long ticketId;
    /**
     * ç»´ä¿®ç±»åž‹: 1-现场维修 2-返厂维修 3-远程指导
     */
    private Integer repairType;
    /**
     * æ•…障描述
     */
    private String faultDescription;
    /**
     * ç»´ä¿®æŽªæ–½
     */
    private String repairAction;
    /**
     * ç»´ä¿®ç»“æžœ: å·²ä¿®å¤/无法修复/部分修复
     */
    private String repairResult;
    /**
     * ç»´ä¿®è´¹ç”¨
     */
    private BigDecimal repairCost;
    /**
     * ç»´ä¿®äºº
     */
    private Long repairUserId;
    /**
     * ç»´ä¿®çŠ¶æ€
     *
     * æžšä¸¾ {@link AfterSaleRepairStatusEnum}
     */
    private Integer status;
    /**
     * å¼€å§‹ç»´ä¿®æ—¶é—´
     */
    private LocalDateTime startTime;
    /**
     * å®Œæˆç»´ä¿®æ—¶é—´
     */
    private LocalDateTime finishTime;
    /**
     * å¤‡æ³¨
     */
    private String remark;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/dataobject/returnobj/AfterSaleReturnDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,112 @@
package cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj;

// æ³¨ï¼špackage åä½¿ç”¨ returnobj é¿å…ä¸Ž Java å…³é”®å­— return å†²çª

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleReturnStatusEnum;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * å”®åŽé€€è´§ç”³è¯· DO
 */
@TableName("after_sale_return")
@KeySequence("after_sale_return_seq")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AfterSaleReturnDO extends BaseDO {

    /**
     * é€€è´§ç”³è¯·ç¼–号
     */
    @TableId
    private Long id;
    /**
     * é€€è´§å•å·
     */
    private String no;
    /**
     * å…³è”工单编号，关联 after_sale_ticket.id
     */
    private Long ticketId;
    /**
     * å®¢æˆ·ç¼–号
     */
    private Long customerId;
    /**
     * å…³è”销售订单编号
     */
    private Long saleOrderId;
    /**
     * é€€è´§ç±»åž‹: 1-退款退货 2-换货 3-仅退款
     */
    private Integer returnType;
    /**
     * é€€è´§åŽŸå› 
     */
    private String returnReason;
    /**
     * ç¼ºé™·åˆ†ç±»
     */
    private String defectCategory;
    /**
     * åº”退总金额
     */
    private BigDecimal totalReturnPrice;
    /**
     * å®žé€€é‡‘额
     */
    private BigDecimal actualRefundPrice;
    /**
     * é€€è´§çŠ¶æ€
     *
     * æžšä¸¾ {@link AfterSaleReturnStatusEnum}
     */
    private Integer status;
    /**
     * å®¡æ ¸äºº
     */
    private Long auditUserId;
    /**
     * å®¡æ ¸æ—¶é—´
     */
    private LocalDateTime auditTime;
    /**
     * MES é€€è´§å•ç¼–号，关联 mes_wm_return_sales.id
     */
    private Long mesReturnId;
    /**
     * MES é€€è´§å•å·(冗余)
     */
    private String mesReturnCode;
    /**
     * è´¨æ£€ç»“论: åˆæ ¼/特采/退货/报废
     */
    private String qualityResult;
    /**
     * è´¨æ£€æŠ¥å‘Šé™„件URL
     */
    private String qualityReportUrl;
    /**
     * é€€è´§å…¥åº“完成时间
     */
    private LocalDateTime returnInboundTime;
    /**
     * é€€æ¬¾/换货完成时间
     */
    private LocalDateTime refundTime;
    /**
     * å¤‡æ³¨
     */
    private String remark;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/dataobject/returnobj/AfterSaleReturnItemDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,78 @@
package cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj;

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

import java.math.BigDecimal;

/**
 * å”®åŽé€€è´§æ˜Žç»†è¡Œ DO
 */
@TableName("after_sale_return_item")
@KeySequence("after_sale_return_item_seq")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AfterSaleReturnItemDO extends BaseDO {

    /**
     * ç¼–号
     */
    @TableId
    private Long id;
    /**
     * é€€è´§ç”³è¯·ç¼–号，关联 after_sale_return.id
     */
    private Long returnId;
    /**
     * å·¥å•æ˜Žç»†è¡Œç¼–号
     */
    private Long ticketItemId;
    /**
     * MDM ç‰©æ–™ç¼–号
     */
    private Long itemId;
    /**
     * ç‰©æ–™ç¼–码(冗余)
     */
    private String itemCode;
    /**
     * ç‰©æ–™åç§°(冗余)
     */
    private String itemName;
    /**
     * æ‰¹æ¬¡ç¼–号
     */
    private Long batchId;
    /**
     * æ‰¹æ¬¡å·
     */
    private String batchCode;
    /**
     * é€€è´§æ•°é‡
     */
    private BigDecimal returnQuantity;
    /**
     * é”€å”®å•ä»·
     */
    private BigDecimal unitPrice;
    /**
     * é€€è´§é‡‘额
     */
    private BigDecimal returnPrice;
    /**
     * MES é€€è´§å•è¡Œç¼–号
     */
    private Long mesReturnLineId;
    /**
     * å¤‡æ³¨
     */
    private String remark;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/dataobject/ticket/AfterSaleTicketDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,116 @@
package cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket;

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleIssueTypeEnum;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleTicketStatusEnum;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

import java.time.LocalDateTime;

/**
 * å”®åŽå·¥å• DO
 */
@TableName("after_sale_ticket")
@KeySequence("after_sale_ticket_seq")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AfterSaleTicketDO extends BaseDO {

    /**
     * å·¥å•ç¼–号
     */
    @TableId
    private Long id;
    /**
     * å·¥å•å•å·
     */
    private String no;
    /**
     * å·¥å•ä¸»é¢˜/标题
     */
    private String name;
    /**
     * å®¢æˆ·ç¼–号，关联 crm_customer.id
     */
    private Long customerId;
    /**
     * è”系人编号，关联 crm_contact.id
     */
    private Long contactId;
    /**
     * é”€å”®è®¢å•ç¼–号，关联 erp_sale_order.id
     */
    private Long saleOrderId;
    /**
     * é”€å”®è®¢å•å·(冗余)
     */
    private String saleOrderNo;
    /**
     * åˆåŒç¼–号，关联 crm_contract.id
     */
    private Long contractId;
    /**
     * é—®é¢˜ç±»åž‹
     *
     * æžšä¸¾ {@link AfterSaleIssueTypeEnum}
     */
    private Integer issueType;
    /**
     * é—®é¢˜åˆ†ç±»: å¤–观缺陷/功能故障/尺寸偏差/包装破损/其他
     */
    private String issueCategory;
    /**
     * é—®é¢˜æè¿°
     */
    private String issueDescription;
    /**
     * ä¸¥é‡ç¨‹åº¦: 0-轻微 1-一般 2-严重 3-致命
     */
    private Integer severityLevel;
    /**
     * å·¥å•çŠ¶æ€
     *
     * æžšä¸¾ {@link AfterSaleTicketStatusEnum}
     */
    private Integer status;
    /**
     * è´Ÿè´£äººç”¨æˆ·ç¼–号
     */
    private Long ownerUserId;
    /**
     * å¤„理人用户编号
     */
    private Long handlerUserId;
    /**
     * BPM å·¥ä½œæµå®žä¾‹ç¼–号
     */
    private String processInstanceId;
    /**
     * å…³è”退货申请编号，关联 after_sale_return.id
     */
    private Long returnId;
    /**
     * å…³è”维修记录编号，关联 after_sale_repair.id
     */
    private Long repairId;
    /**
     * è§£å†³æ—¶é—´
     */
    private LocalDateTime resolvedTime;
    /**
     * å…³é—­æ—¶é—´
     */
    private LocalDateTime closedTime;
    /**
     * å¤‡æ³¨
     */
    private String remark;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/dataobject/ticket/AfterSaleTicketItemDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,78 @@
package cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket;

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

import java.math.BigDecimal;

/**
 * å”®åŽå·¥å•æ˜Žç»†è¡Œ DO
 */
@TableName("after_sale_ticket_item")
@KeySequence("after_sale_ticket_item_seq")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class AfterSaleTicketItemDO extends BaseDO {

    /**
     * ç¼–号
     */
    @TableId
    private Long id;
    /**
     * å·¥å•ç¼–号，关联 after_sale_ticket.id
     */
    private Long ticketId;
    /**
     * é”€å”®è®¢å•è¡Œç¼–号
     */
    private Long saleOrderItemId;
    /**
     * MDM ç‰©æ–™ç¼–号
     */
    private Long itemId;
    /**
     * ç‰©æ–™ç¼–码(冗余)
     */
    private String itemCode;
    /**
     * ç‰©æ–™åç§°(冗余)
     */
    private String itemName;
    /**
     * ç”Ÿäº§æ‰¹æ¬¡ç¼–号
     */
    private Long batchId;
    /**
     * ç”Ÿäº§æ‰¹æ¬¡å·
     */
    private String batchCode;
    /**
     * é”€å”®æ•°é‡
     */
    private BigDecimal saleQuantity;
    /**
     * é€€è´§æ•°é‡
     */
    private BigDecimal returnQuantity;
    /**
     * æ˜¯å¦éœ€è¦ç»´ä¿®
     */
    private Boolean needRepair;
    /**
     * æ˜¯å¦éœ€è¦é€€è´§
     */
    private Boolean needReturn;
    /**
     * å¤‡æ³¨
     */
    private String remark;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/mysql/permission/AfterSalePermissionMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,48 @@
package cn.iocoder.yudao.module.aftersales.dal.mysql.permission;

import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.permission.AfterSalePermissionDO;
import org.apache.ibatis.annotations.Mapper;

import java.util.Collection;
import java.util.List;

/**
 * å”®åŽæ¨¡å—数据权限 Mapper
 */
@Mapper
public interface AfterSalePermissionMapper extends BaseMapperX<AfterSalePermissionDO> {

    default List<AfterSalePermissionDO> selectListByBiz(Integer bizType, Long bizId) {
        return selectList(new LambdaQueryWrapperX<AfterSalePermissionDO>()
                .eq(AfterSalePermissionDO::getBizType, bizType)
                .eq(AfterSalePermissionDO::getBizId, bizId));
    }

    default List<AfterSalePermissionDO> selectListByBiz(Integer bizType, Collection<Long> bizIds) {
        return selectList(new LambdaQueryWrapperX<AfterSalePermissionDO>()
                .eq(AfterSalePermissionDO::getBizType, bizType)
                .in(AfterSalePermissionDO::getBizId, bizIds));
    }

    default List<AfterSalePermissionDO> selectListByBizTypeAndUserId(Integer bizType, Long userId) {
        return selectList(new LambdaQueryWrapperX<AfterSalePermissionDO>()
                .eq(AfterSalePermissionDO::getBizType, bizType)
                .eq(AfterSalePermissionDO::getUserId, userId));
    }

    default AfterSalePermissionDO selectByBizAndUser(Integer bizType, Long bizId, Long userId) {
        return selectOne(new LambdaQueryWrapperX<AfterSalePermissionDO>()
                .eq(AfterSalePermissionDO::getBizType, bizType)
                .eq(AfterSalePermissionDO::getBizId, bizId)
                .eq(AfterSalePermissionDO::getUserId, userId));
    }

    default void deleteByBiz(Integer bizType, Long bizId) {
        delete(new LambdaQueryWrapperX<AfterSalePermissionDO>()
                .eq(AfterSalePermissionDO::getBizType, bizType)
                .eq(AfterSalePermissionDO::getBizId, bizId));
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/mysql/repair/AfterSaleRepairMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,34 @@
package cn.iocoder.yudao.module.aftersales.dal.mysql.repair;

import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.repair.AfterSaleRepairDO;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * å”®åŽç»´ä¿®è®°å½• Mapper
 */
@Mapper
public interface AfterSaleRepairMapper extends BaseMapperX<AfterSaleRepairDO> {

    default AfterSaleRepairDO selectByTicketId(Long ticketId) {
        return selectOne(AfterSaleRepairDO::getTicketId, ticketId);
    }

    default List<AfterSaleRepairDO> selectListByTicketId(Long ticketId) {
        return selectList(new LambdaQueryWrapperX<AfterSaleRepairDO>()
                .eq(AfterSaleRepairDO::getTicketId, ticketId));
    }

    default PageResult<AfterSaleRepairDO> selectPage(PageParam pageParam, Long ticketId, Integer status) {
        return selectPage(pageParam, new LambdaQueryWrapperX<AfterSaleRepairDO>()
                .eqIfPresent(AfterSaleRepairDO::getTicketId, ticketId)
                .eqIfPresent(AfterSaleRepairDO::getStatus, status)
                .orderByDesc(AfterSaleRepairDO::getId));
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/mysql/returnobj/AfterSaleReturnItemMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,26 @@
package cn.iocoder.yudao.module.aftersales.dal.mysql.returnobj;

import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnItemDO;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * å”®åŽé€€è´§æ˜Žç»†è¡Œ Mapper
 */
@Mapper
public interface AfterSaleReturnItemMapper extends BaseMapperX<AfterSaleReturnItemDO> {

    default List<AfterSaleReturnItemDO> selectListByReturnId(Long returnId) {
        return selectList(new LambdaQueryWrapperX<AfterSaleReturnItemDO>()
                .eq(AfterSaleReturnItemDO::getReturnId, returnId));
    }

    default void deleteByReturnId(Long returnId) {
        delete(new LambdaQueryWrapperX<AfterSaleReturnItemDO>()
                .eq(AfterSaleReturnItemDO::getReturnId, returnId));
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/mysql/returnobj/AfterSaleReturnMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,48 @@
package cn.iocoder.yudao.module.aftersales.dal.mysql.returnobj;

import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.MPJLambdaWrapperX;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnDO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.util.AfterSalePermissionUtils;
import org.apache.ibatis.annotations.Mapper;

/**
 * å”®åŽé€€è´§ç”³è¯· Mapper
 */
@Mapper
public interface AfterSaleReturnMapper extends BaseMapperX<AfterSaleReturnDO> {

    default AfterSaleReturnDO selectByNo(String no) {
        return selectOne(AfterSaleReturnDO::getNo, no);
    }

    default AfterSaleReturnDO selectByTicketId(Long ticketId) {
        return selectOne(AfterSaleReturnDO::getTicketId, ticketId);
    }

    default PageResult<AfterSaleReturnDO> selectPage(PageParam pageParam, Long userId, Integer sceneType,
                                                     String no, Long ticketId,
                                                     Long customerId, Integer status) {
        MPJLambdaWrapperX<AfterSaleReturnDO> query = new MPJLambdaWrapperX<>();
        // æ•°æ®æƒé™
        AfterSalePermissionUtils.appendPermissionCondition(query, AfterSaleBizTypeEnum.AFTER_SALE_RETURN.getType(),
                AfterSaleReturnDO::getId, userId, sceneType);
        // æŸ¥è¯¢æ¡ä»¶
        query.selectAll(AfterSaleReturnDO.class)
                .likeIfPresent(AfterSaleReturnDO::getNo, no)
                .eqIfPresent(AfterSaleReturnDO::getTicketId, ticketId)
                .eqIfPresent(AfterSaleReturnDO::getCustomerId, customerId)
                .eqIfPresent(AfterSaleReturnDO::getStatus, status)
                .orderByDesc(AfterSaleReturnDO::getId);
        return selectJoinPage(pageParam, AfterSaleReturnDO.class, query);
    }

    default AfterSaleReturnDO selectByMesReturnId(Long mesReturnId) {
        return selectOne(AfterSaleReturnDO::getMesReturnId, mesReturnId);
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/mysql/ticket/AfterSaleTicketItemMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,26 @@
package cn.iocoder.yudao.module.aftersales.dal.mysql.ticket;

import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketItemDO;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * å”®åŽå·¥å•æ˜Žç»†è¡Œ Mapper
 */
@Mapper
public interface AfterSaleTicketItemMapper extends BaseMapperX<AfterSaleTicketItemDO> {

    default List<AfterSaleTicketItemDO> selectListByTicketId(Long ticketId) {
        return selectList(new LambdaQueryWrapperX<AfterSaleTicketItemDO>()
                .eq(AfterSaleTicketItemDO::getTicketId, ticketId));
    }

    default void deleteByTicketId(Long ticketId) {
        delete(new LambdaQueryWrapperX<AfterSaleTicketItemDO>()
                .eq(AfterSaleTicketItemDO::getTicketId, ticketId));
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/mysql/ticket/AfterSaleTicketMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,58 @@
package cn.iocoder.yudao.module.aftersales.dal.mysql.ticket;

import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.MPJLambdaWrapperX;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.util.AfterSalePermissionUtils;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * å”®åŽå·¥å• Mapper
 */
@Mapper
public interface AfterSaleTicketMapper extends BaseMapperX<AfterSaleTicketDO> {

    default AfterSaleTicketDO selectByNo(String no) {
        return selectOne(AfterSaleTicketDO::getNo, no);
    }

    default PageResult<AfterSaleTicketDO> selectPage(PageParam pageParam, Long userId, Integer sceneType,
                                                     String no, String name,
                                                     Long customerId, Long saleOrderId,
                                                     Integer status, Integer issueType) {
        MPJLambdaWrapperX<AfterSaleTicketDO> query = new MPJLambdaWrapperX<>();
        // æ•°æ®æƒé™
        AfterSalePermissionUtils.appendPermissionCondition(query, AfterSaleBizTypeEnum.AFTER_SALE_TICKET.getType(),
                AfterSaleTicketDO::getId, userId, sceneType);
        // æŸ¥è¯¢æ¡ä»¶
        query.selectAll(AfterSaleTicketDO.class)
                .likeIfPresent(AfterSaleTicketDO::getNo, no)
                .likeIfPresent(AfterSaleTicketDO::getName, name)
                .eqIfPresent(AfterSaleTicketDO::getCustomerId, customerId)
                .eqIfPresent(AfterSaleTicketDO::getSaleOrderId, saleOrderId)
                .eqIfPresent(AfterSaleTicketDO::getStatus, status)
                .eqIfPresent(AfterSaleTicketDO::getIssueType, issueType)
                .orderByDesc(AfterSaleTicketDO::getId);
        return selectJoinPage(pageParam, AfterSaleTicketDO.class, query);
    }

    default List<AfterSaleTicketDO> selectListByCustomerId(Long customerId) {
        return selectList(new LambdaQueryWrapperX<AfterSaleTicketDO>()
                .eq(AfterSaleTicketDO::getCustomerId, customerId));
    }

    default AfterSaleTicketDO selectBySaleOrderId(Long saleOrderId) {
        return selectOne(AfterSaleTicketDO::getSaleOrderId, saleOrderId);
    }

    default Long selectCountByOwnerUserId(Long ownerUserId) {
        return selectCount(AfterSaleTicketDO::getOwnerUserId, ownerUserId);
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/redis/RedisKeyConstants.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package cn.iocoder.yudao.module.aftersales.dal.redis;

/**
 * å”®åŽæ¨¡å— Redis Key å¸¸é‡
 */
public interface RedisKeyConstants {

    /**
     * åºå·çš„缓存
     *
     * KEY æ ¼å¼ï¼šaftersales:seq_no:{prefix}
     * VALUE æ•°æ®æ ¼å¼ï¼šç¼–号自增
     */
    String NO = "aftersales:seq_no:";

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/dal/redis/no/AfterSaleNoRedisDAO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,46 @@
package cn.iocoder.yudao.module.aftersales.dal.redis.no;

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.iocoder.yudao.module.aftersales.dal.redis.RedisKeyConstants;
import jakarta.annotation.Resource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Repository;

import java.time.Duration;
import java.time.LocalDateTime;

/**
 * å”®åŽæ¨¡å—单号 Redis DAO
 */
@Repository
public class AfterSaleNoRedisDAO {

    /**
     * å”®åŽå·¥å• {@link cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO}
     */
    public static final String TICKET_NO_PREFIX = "AS";

    /**
     * é€€è´§ç”³è¯· {@link cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnDO}
     */
    public static final String RETURN_NO_PREFIX = "RT";

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * ç”Ÿæˆåºå·ï¼Œä½¿ç”¨å½“前日期，格式为 {PREFIX} + yyyyMMdd + 6 ä½è‡ªå¢ž
     *
     * @param prefix å‰ç¼€
     * @return åºå·
     */
    public String generate(String prefix) {
        String noPrefix = prefix + DateUtil.format(LocalDateTime.now(), DatePattern.PURE_DATE_PATTERN);
        String key = RedisKeyConstants.NO + noPrefix;
        Long no = stringRedisTemplate.opsForValue().increment(key);
        stringRedisTemplate.expire(key, Duration.ofDays(1L));
        return noPrefix + String.format("%06d", no);
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/AfterSaleBizTypeEnum.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,40 @@
package cn.iocoder.yudao.module.aftersales.enums;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.iocoder.yudao.framework.common.core.ArrayValuable;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

import java.util.Arrays;

/**
 * å”®åŽä¸šåŠ¡ç±»åž‹æžšä¸¾
 */
@RequiredArgsConstructor
@Getter
public enum AfterSaleBizTypeEnum implements ArrayValuable<Integer> {

    AFTER_SALE_TICKET(1, "售后工单"),
    AFTER_SALE_RETURN(2, "退货申请"),
    AFTER_SALE_REPAIR(3, "维修记录"),
    ;

    public static final Integer[] ARRAYS = Arrays.stream(values())
            .map(AfterSaleBizTypeEnum::getType).toArray(Integer[]::new);

    private final Integer type;
    private final String name;

    public static String getNameByType(Integer type) {
        AfterSaleBizTypeEnum typeEnum = CollUtil.findOne(CollUtil.newArrayList(AfterSaleBizTypeEnum.values()),
                item -> ObjUtil.equal(item.type, type));
        return typeEnum == null ? null : typeEnum.getName();
    }

    @Override
    public Integer[] array() {
        return ARRAYS;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/AfterSaleIssueTypeEnum.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@
package cn.iocoder.yudao.module.aftersales.enums;

import cn.iocoder.yudao.framework.common.core.ArrayValuable;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

import java.util.Arrays;

/**
 * å”®åŽé—®é¢˜ç±»åž‹æžšä¸¾
 */
@RequiredArgsConstructor
@Getter
public enum AfterSaleIssueTypeEnum implements ArrayValuable<Integer> {

    UNCLASSIFIED(0, "未判定"),
    GENERAL(1, "一般问题"),
    REPAIR(2, "维修问题"),
    RETURN(3, "退货问题");

    public static final Integer[] ARRAYS = Arrays.stream(values())
            .map(AfterSaleIssueTypeEnum::getType).toArray(Integer[]::new);

    private final Integer type;
    private final String name;

    @Override
    public Integer[] array() {
        return ARRAYS;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/AfterSaleRepairStatusEnum.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@
package cn.iocoder.yudao.module.aftersales.enums;

import cn.iocoder.yudao.framework.common.core.ArrayValuable;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

import java.util.Arrays;

/**
 * å”®åŽç»´ä¿®çŠ¶æ€æžšä¸¾
 */
@RequiredArgsConstructor
@Getter
public enum AfterSaleRepairStatusEnum implements ArrayValuable<Integer> {

    PENDING(0, "待处理"),
    IN_PROGRESS(10, "维修中"),
    COMPLETED(20, "已完成"),
    CLOSED(30, "已关闭");

    public static final Integer[] ARRAYS = Arrays.stream(values())
            .map(AfterSaleRepairStatusEnum::getStatus).toArray(Integer[]::new);

    private final Integer status;
    private final String name;

    @Override
    public Integer[] array() {
        return ARRAYS;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/AfterSaleReturnStatusEnum.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,37 @@
package cn.iocoder.yudao.module.aftersales.enums;

import cn.iocoder.yudao.framework.common.core.ArrayValuable;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

import java.util.Arrays;

/**
 * å”®åŽé€€è´§çŠ¶æ€æžšä¸¾
 */
@RequiredArgsConstructor
@Getter
public enum AfterSaleReturnStatusEnum implements ArrayValuable<Integer> {

    DRAFT(0, "草稿"),
    AUDITING(10, "销售审核中"),
    APPROVED(20, "审核通过-已同步MES"),
    INSPECTING(30, "检验中"),
    INSPECTED(40, "检验完成"),
    INBOUND(50, "已入库"),
    REFUNDED(60, "退款/换货完成"),
    CLOSED(70, "已关闭"),
    CANCELED(99, "已取消");

    public static final Integer[] ARRAYS = Arrays.stream(values())
            .map(AfterSaleReturnStatusEnum::getStatus).toArray(Integer[]::new);

    private final Integer status;
    private final String name;

    @Override
    public Integer[] array() {
        return ARRAYS;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/AfterSaleTicketStatusEnum.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
package cn.iocoder.yudao.module.aftersales.enums;

import cn.iocoder.yudao.framework.common.core.ArrayValuable;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

import java.util.Arrays;

/**
 * å”®åŽå·¥å•çŠ¶æ€æžšä¸¾
 */
@RequiredArgsConstructor
@Getter
public enum AfterSaleTicketStatusEnum implements ArrayValuable<Integer> {

    DRAFT(0, "草稿"),
    PROCESSING(10, "处理中"),
    WAITING_RETURN(30, "待退货"),
    WAITING_REFUND(40, "待退款/换货"),
    COMPLETED(50, "已完结"),
    CLOSED(60, "已关闭"),
    CANCELED(99, "已取消");

    public static final Integer[] ARRAYS = Arrays.stream(values())
            .map(AfterSaleTicketStatusEnum::getStatus).toArray(Integer[]::new);

    private final Integer status;
    private final String name;

    @Override
    public Integer[] array() {
        return ARRAYS;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/ErrorCodeConstants.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,38 @@
package cn.iocoder.yudao.module.aftersales.enums;

import cn.iocoder.yudao.framework.common.exception.ErrorCode;

/**
 * å”®åŽæ¨¡å—错误码枚举类
 * <p>
 * aftersales ç³»ç»Ÿï¼Œä½¿ç”¨ 1-022-000-000 æ®µ
 */
public interface ErrorCodeConstants {

    // ========== å”®åŽå·¥å• 1-022-000-000 ==========
    ErrorCode TICKET_NOT_EXISTS = new ErrorCode(1_022_000_000, "售后工单不存在");
    ErrorCode TICKET_NO_EXISTS = new ErrorCode(1_022_000_001, "生成工单号重复，请重试");
    ErrorCode TICKET_DELETE_FAIL_NOT_DRAFT = new ErrorCode(1_022_000_002, "工单不是草稿状态，无法删除");
    ErrorCode TICKET_UPDATE_FAIL_STATUS = new ErrorCode(1_022_000_003, "更新工单状态失败，原因：已经是该状态");
    ErrorCode TICKET_RESOLVE_FAIL = new ErrorCode(1_022_000_004, "完结工单失败，原因：工单不是处理中状态");
    ErrorCode TICKET_CLOSE_FAIL = new ErrorCode(1_022_000_005, "关闭工单失败，原因：工单未完结");
    ErrorCode TICKET_SUBMIT_FAIL_NOT_DRAFT = new ErrorCode(1_022_000_006, "提交工单审批失败，原因：工单不是草稿状态");
    ErrorCode TICKET_BPM_PROCESS_DEFINITION_NOT_EXISTS = new ErrorCode(1_022_000_007, "售后工单审批流程不存在或未激活，请检查 BPM é…ç½®");
    ErrorCode TICKET_STATUS_ERROR = new ErrorCode(1_022_000_008, "工单当前状态不允许此操作");

    // ========== å”®åŽå·¥å•æ˜Žç»†è¡Œ 1-022-001-000 ==========
    ErrorCode TICKET_ITEM_NOT_EXISTS = new ErrorCode(1_022_001_000, "工单明细行不存在");
    ErrorCode TICKET_ITEM_EMPTY = new ErrorCode(1_022_001_001, "工单明细行不能为空");

    // ========== é€€è´§ç”³è¯· 1-022-002-000 ==========
    ErrorCode RETURN_NOT_EXISTS = new ErrorCode(1_022_002_000, "退货申请不存在");
    ErrorCode RETURN_NO_EXISTS = new ErrorCode(1_022_002_001, "生成退货单号重复，请重试");
    ErrorCode RETURN_APPROVE_FAIL = new ErrorCode(1_022_002_002, "审核退货申请失败，原因：不是待审核状态");
    ErrorCode RETURN_ITEM_EMPTY = new ErrorCode(1_022_002_003, "退货明细行不能为空");
    ErrorCode RETURN_DELETE_FAIL_NOT_DRAFT = new ErrorCode(1_022_002_004, "退货申请不是草稿状态，无法删除");

    // ========== ç»´ä¿®è®°å½• 1-022-003-000 ==========
    ErrorCode REPAIR_NOT_EXISTS = new ErrorCode(1_022_003_000, "维修记录不存在");
    ErrorCode REPAIR_UPDATE_FAIL_STATUS = new ErrorCode(1_022_003_001, "更新维修状态失败，原因：已经是该状态");

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/LogRecordConstants.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,48 @@
package cn.iocoder.yudao.module.aftersales.enums;

/**
 * å”®åŽæ¨¡å—操作日志常量
 */
public interface LogRecordConstants {

    // ======================= å”®åŽå·¥å• =======================

    String AFTER_SALE_TICKET_TYPE = "售后工单";
    String AFTER_SALE_TICKET_CREATE_SUB_TYPE = "创建售后工单";
    String AFTER_SALE_TICKET_CREATE_SUCCESS = "创建了售后工单【{{#ticket.name}}】";
    String AFTER_SALE_TICKET_UPDATE_SUB_TYPE = "更新售后工单";
    String AFTER_SALE_TICKET_UPDATE_SUCCESS = "更新了售后工单【{{#ticketName}}】: {_DIFF{#updateReqVO}}";
    String AFTER_SALE_TICKET_DELETE_SUB_TYPE = "删除售后工单";
    String AFTER_SALE_TICKET_DELETE_SUCCESS = "删除了售后工单【{{#ticketName}}】";
    String AFTER_SALE_TICKET_ASSIGN_SUB_TYPE = "分配处理人";
    String AFTER_SALE_TICKET_ASSIGN_SUCCESS = "将售后工单【{{#ticketName}}】分配给【{getAdminUserById{#handlerUserId}}】";
    String AFTER_SALE_TICKET_CLASSIFY_SUB_TYPE = "问题判定";
    String AFTER_SALE_TICKET_CLASSIFY_SUCCESS = "对售后工单【{{#ticketName}}】进行了问题判定：【{{#issueTypeName}}】";
    String AFTER_SALE_TICKET_RESOLVE_SUB_TYPE = "完结工单";
    String AFTER_SALE_TICKET_RESOLVE_SUCCESS = "完结了售后工单【{{#ticketName}}】";
    String AFTER_SALE_TICKET_CLOSE_SUB_TYPE = "关闭工单";
    String AFTER_SALE_TICKET_CLOSE_SUCCESS = "关闭了售后工单【{{#ticketName}}】";
    String AFTER_SALE_TICKET_CANCEL_SUB_TYPE = "取消工单";
    String AFTER_SALE_TICKET_CANCEL_SUCCESS = "取消了售后工单【{{#ticketName}}】";
    String AFTER_SALE_TICKET_SUBMIT_SUB_TYPE = "提交工单审批";
    String AFTER_SALE_TICKET_SUBMIT_SUCCESS = "提交售后工单【{{#ticketName}}】审批成功";

    // ======================= é€€è´§ç”³è¯· =======================

    String AFTER_SALE_RETURN_TYPE = "售后退货";
    String AFTER_SALE_RETURN_CREATE_SUB_TYPE = "创建退货申请";
    String AFTER_SALE_RETURN_CREATE_SUCCESS = "创建了退货申请【{{#returnDO.no}}】";
    String AFTER_SALE_RETURN_APPROVE_SUB_TYPE = "审核退货申请";
    String AFTER_SALE_RETURN_APPROVE_SUCCESS = "审核通过了退货申请【{{#returnNo}}】，已同步到MES退货";
    String AFTER_SALE_RETURN_DELETE_SUB_TYPE = "删除退货申请";
    String AFTER_SALE_RETURN_DELETE_SUCCESS = "删除了退货申请【{{#returnNo}}】";

    // ======================= ç»´ä¿®è®°å½• =======================

    String AFTER_SALE_REPAIR_TYPE = "售后维修";
    String AFTER_SALE_REPAIR_CREATE_SUB_TYPE = "创建维修记录";
    String AFTER_SALE_REPAIR_CREATE_SUCCESS = "创建了维修记录【{{#repair.id}}】";
    String AFTER_SALE_REPAIR_COMPLETE_SUB_TYPE = "完成维修";
    String AFTER_SALE_REPAIR_COMPLETE_SUCCESS = "完成了维修记录【{{#repairId}}】，维修结果：【{{#repairResult}}】";

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/permission/AfterSalePermissionLevelEnum.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,58 @@
package cn.iocoder.yudao.module.aftersales.enums.permission;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.iocoder.yudao.framework.common.core.ArrayValuable;
import lombok.AllArgsConstructor;
import lombok.Getter;

import java.util.Arrays;

/**
 * å”®åŽæ¨¡å—数据权限级别枚举
 *
 * OWNER > WRITE > READ
 */
@Getter
@AllArgsConstructor
public enum AfterSalePermissionLevelEnum implements ArrayValuable<Integer> {

    OWNER(1, "负责人"),
    READ(2, "只读"),
    WRITE(3, "读写");

    public static final Integer[] ARRAYS = Arrays.stream(values()).map(AfterSalePermissionLevelEnum::getLevel).toArray(Integer[]::new);

    /**
     * çº§åˆ«
     */
    private final Integer level;
    /**
     * çº§åˆ«åç§°
     */
    private final String name;

    @Override
    public Integer[] array() {
        return ARRAYS;
    }

    public static boolean isOwner(Integer level) {
        return ObjUtil.equal(OWNER.level, level);
    }

    public static boolean isRead(Integer level) {
        return ObjUtil.equal(READ.level, level);
    }

    public static boolean isWrite(Integer level) {
        return ObjUtil.equal(WRITE.level, level);
    }

    public static String getNameByLevel(Integer level) {
        AfterSalePermissionLevelEnum typeEnum = CollUtil.findOne(CollUtil.newArrayList(AfterSalePermissionLevelEnum.values()),
                item -> ObjUtil.equal(item.level, level));
        return typeEnum == null ? null : typeEnum.getName();
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/enums/permission/AfterSaleSceneTypeEnum.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,54 @@
package cn.iocoder.yudao.module.aftersales.enums.permission;

import cn.hutool.core.util.ObjUtil;
import cn.iocoder.yudao.framework.common.core.ArrayValuable;
import lombok.AllArgsConstructor;
import lombok.Getter;

import java.util.Arrays;

/**
 * å”®åŽæ¨¡å—列表检索场景
 */
@Getter
@AllArgsConstructor
public enum AfterSaleSceneTypeEnum implements ArrayValuable<Integer> {

    OWNER(1, "我负责的"),
    INVOLVED(2, "我参与的"),
    SUBORDINATE(3, "下属负责的"),
    ALL(4, "全部");

    public static final Integer[] ARRAYS = Arrays.stream(values()).map(AfterSaleSceneTypeEnum::getType).toArray(Integer[]::new);

    /**
     * åœºæ™¯ç±»åž‹
     */
    private final Integer type;
    /**
     * åœºæ™¯åç§°
     */
    private final String name;

    public static boolean isOwner(Integer type) {
        return ObjUtil.equal(OWNER.getType(), type);
    }

    public static boolean isInvolved(Integer type) {
        return ObjUtil.equal(INVOLVED.getType(), type);
    }

    public static boolean isSubordinate(Integer type) {
        return ObjUtil.equal(SUBORDINATE.getType(), type);
    }

    public static boolean isAll(Integer type) {
        return ObjUtil.equal(ALL.getType(), type);
    }

    @Override
    public Integer[] array() {
        return ARRAYS;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/permission/AfterSalePermissionService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,61 @@
package cn.iocoder.yudao.module.aftersales.service.permission;

import cn.iocoder.yudao.module.aftersales.dal.dataobject.permission.AfterSalePermissionDO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSalePermissionLevelEnum;
import cn.iocoder.yudao.module.aftersales.service.permission.bo.AfterSalePermissionCreateReqBO;

import java.util.Collection;
import java.util.List;

/**
 * å”®åŽæ¨¡å—数据权限 Service æŽ¥å£
 */
public interface AfterSalePermissionService {

    /**
     * åˆ›å»ºæ•°æ®æƒé™ï¼ˆè´Ÿè´£äººæƒé™ï¼‰
     *
     * @param createReqBO åˆ›å»ºä¿¡æ¯
     * @return ç¼–号
     */
    Long createPermission(AfterSalePermissionCreateReqBO createReqBO);

    /**
     * åˆ é™¤æ•°æ®æƒé™
     *
     * @param bizType æ•°æ®ç±»åž‹ï¼Œå…³è” {@link AfterSaleBizTypeEnum}
     * @param bizId   æ•°æ®ç¼–号
     */
    void deletePermission(Integer bizType, Long bizId);

    /**
     * èŽ·å–数据权限列表
     *
     * @param bizType æ•°æ®ç±»åž‹
     * @param bizId   æ•°æ®ç¼–号
     * @return æƒé™åˆ—表
     */
    List<AfterSalePermissionDO> getPermissionListByBiz(Integer bizType, Long bizId);

    /**
     * èŽ·å–数据权限列表（批量）
     *
     * @param bizType æ•°æ®ç±»åž‹
     * @param bizIds  æ•°æ®ç¼–号列表
     * @return æƒé™åˆ—表
     */
    List<AfterSalePermissionDO> getPermissionListByBiz(Integer bizType, Collection<Long> bizIds);

    /**
     * æ ¡éªŒæ˜¯å¦æœ‰æŒ‡å®šæ•°æ®çš„操作权限
     *
     * @param bizType æ•°æ®ç±»åž‹
     * @param bizId   æ•°æ®ç¼–号
     * @param userId  ç”¨æˆ·ç¼–号
     * @param level   æƒé™çº§åˆ«
     * @return æ˜¯å¦æœ‰æƒé™
     */
    boolean hasPermission(Integer bizType, Long bizId, Long userId, AfterSalePermissionLevelEnum level);

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/permission/AfterSalePermissionServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,64 @@
package cn.iocoder.yudao.module.aftersales.service.permission;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.permission.AfterSalePermissionDO;
import cn.iocoder.yudao.module.aftersales.dal.mysql.permission.AfterSalePermissionMapper;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSalePermissionLevelEnum;
import cn.iocoder.yudao.module.aftersales.service.permission.bo.AfterSalePermissionCreateReqBO;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * å”®åŽæ¨¡å—数据权限 Service å®žçŽ°ç±»
 */
@Service
@Validated
public class AfterSalePermissionServiceImpl implements AfterSalePermissionService {

    @Resource
    private AfterSalePermissionMapper afterSalePermissionMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createPermission(AfterSalePermissionCreateReqBO createReqBO) {
        AfterSalePermissionDO permission = BeanUtils.toBean(createReqBO, AfterSalePermissionDO.class);
        afterSalePermissionMapper.insert(permission);
        return permission.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deletePermission(Integer bizType, Long bizId) {
        afterSalePermissionMapper.deleteByBiz(bizType, bizId);
    }

    @Override
    public List<AfterSalePermissionDO> getPermissionListByBiz(Integer bizType, Long bizId) {
        return afterSalePermissionMapper.selectListByBiz(bizType, bizId);
    }

    @Override
    public List<AfterSalePermissionDO> getPermissionListByBiz(Integer bizType, Collection<Long> bizIds) {
        if (CollUtil.isEmpty(bizIds)) {
            return Collections.emptyList();
        }
        return afterSalePermissionMapper.selectListByBiz(bizType, bizIds);
    }

    @Override
    public boolean hasPermission(Integer bizType, Long bizId, Long userId, AfterSalePermissionLevelEnum level) {
        List<AfterSalePermissionDO> permissionList = getPermissionListByBiz(bizType, bizId);
        return permissionList.stream()
                .anyMatch(p -> ObjUtil.equal(p.getUserId(), userId)
                        && ObjUtil.equal(p.getLevel(), level.getLevel()));
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/permission/bo/AfterSalePermissionCreateReqBO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,38 @@
package cn.iocoder.yudao.module.aftersales.service.permission.bo;

import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSalePermissionLevelEnum;
import jakarta.validation.constraints.NotNull;
import lombok.Data;

/**
 * å”®åŽæ¨¡å—数据权限创建 Request BO
 */
@Data
public class AfterSalePermissionCreateReqBO {

    /**
     * æ•°æ®ç±»åž‹ï¼Œå…³è” {@link AfterSaleBizTypeEnum}
     */
    @NotNull(message = "数据类型不能为空")
    private Integer bizType;

    /**
     * æ•°æ®ç¼–号
     */
    @NotNull(message = "数据编号不能为空")
    private Long bizId;

    /**
     * ç”¨æˆ·ç¼–号
     */
    @NotNull(message = "用户编号不能为空")
    private Long userId;

    /**
     * æƒé™çº§åˆ«ï¼Œå…³è” {@link AfterSalePermissionLevelEnum}
     */
    @NotNull(message = "权限级别不能为空")
    private Integer level;

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/repair/AfterSaleRepairService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,63 @@
package cn.iocoder.yudao.module.aftersales.service.repair;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.repair.AfterSaleRepairDO;
import jakarta.validation.Valid;

import java.util.Collection;
import java.util.List;

/**
 * å”®åŽç»´ä¿®è®°å½• Service æŽ¥å£
 */
public interface AfterSaleRepairService {

    /**
     * åˆ›å»ºç»´ä¿®è®°å½•
     *
     * @param repairDO ç»´ä¿®ä¿¡æ¯
     * @return ç¼–号
     */
    Long createRepair(@Valid AfterSaleRepairDO repairDO);

    /**
     * æ›´æ–°ç»´ä¿®è®°å½•
     *
     * @param repairDO æ›´æ–°ä¿¡æ¯
     */
    void updateRepair(@Valid AfterSaleRepairDO repairDO);

    /**
     * å®Œæˆç»´ä¿®
     *
     * @param id ç»´ä¿®è®°å½•ç¼–号
     */
    void completeRepair(Long id);

    /**
     * èŽ·å¾—维修记录
     *
     * @param id ç¼–号
     * @return ç»´ä¿®è®°å½•
     */
    AfterSaleRepairDO getRepair(Long id);

    /**
     * èŽ·å¾—维修记录列表
     *
     * @param ids ç¼–号列表
     * @return ç»´ä¿®è®°å½•åˆ—表
     */
    List<AfterSaleRepairDO> getRepairList(Collection<Long> ids);

    /**
     * èŽ·å¾—维修记录分页
     *
     * @param pageParam åˆ†é¡µå‚æ•°
     * @param ticketId  å…³è”工单编号
     * @param status    ç»´ä¿®çŠ¶æ€
     * @return ç»´ä¿®è®°å½•åˆ†é¡µ
     */
    PageResult<AfterSaleRepairDO> getRepairPage(Object pageParam, Long ticketId, Integer status);

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/repair/AfterSaleRepairServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,110 @@
package cn.iocoder.yudao.module.aftersales.service.repair;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.repair.AfterSaleRepairDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO;
import cn.iocoder.yudao.module.aftersales.dal.mysql.repair.AfterSaleRepairMapper;
import cn.iocoder.yudao.module.aftersales.dal.mysql.ticket.AfterSaleTicketMapper;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleRepairStatusEnum;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.aftersales.enums.ErrorCodeConstants.*;

/**
 * å”®åŽç»´ä¿®è®°å½• Service å®žçŽ°ç±»
 */
@Service
@Validated
@Slf4j
public class AfterSaleRepairServiceImpl implements AfterSaleRepairService {

    @Resource
    private AfterSaleRepairMapper repairMapper;
    @Resource
    private AfterSaleTicketMapper ticketMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createRepair(AfterSaleRepairDO repairDO) {
        // æ ¡éªŒå·¥å•å­˜åœ¨
        AfterSaleTicketDO ticket = ticketMapper.selectById(repairDO.getTicketId());
        if (ticket == null) {
            throw exception(TICKET_NOT_EXISTS);
        }

        repairDO.setStatus(AfterSaleRepairStatusEnum.PENDING.getStatus());
        repairMapper.insert(repairDO);

        // æ›´æ–°å·¥å•å…³è”维修记录
        ticketMapper.updateById(new AfterSaleTicketDO().setId(ticket.getId())
                .setRepairId(repairDO.getId()));

        return repairDO.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateRepair(AfterSaleRepairDO repairDO) {
        validateRepairExists(repairDO.getId());
        repairMapper.updateById(repairDO);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void completeRepair(Long id) {
        AfterSaleRepairDO repair = validateRepairExists(id);
        repairMapper.updateById(new AfterSaleRepairDO().setId(id)
                .setStatus(AfterSaleRepairStatusEnum.COMPLETED.getStatus())
                .setFinishTime(LocalDateTime.now()));
        // æ›´æ–°å·¥å•çŠ¶æ€
        AfterSaleTicketDO ticket = ticketMapper.selectById(repair.getTicketId());
        if (ticket != null) {
            ticketMapper.updateById(new AfterSaleTicketDO().setId(ticket.getId())
                    .setStatus(cn.iocoder.yudao.module.aftersales.enums.AfterSaleTicketStatusEnum.COMPLETED.getStatus())
                    .setResolvedTime(LocalDateTime.now()));
        }
    }

    @Override
    public AfterSaleRepairDO getRepair(Long id) {
        return validateRepairExists(id);
    }

    @Override
    public List<AfterSaleRepairDO> getRepairList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return List.of();
        }
        return repairMapper.selectBatchIds(ids);
    }

    @Override
    public PageResult<AfterSaleRepairDO> getRepairPage(Object pageParam, Long ticketId, Integer status) {
        if (pageParam instanceof PageParam) {
            return repairMapper.selectPage((PageParam) pageParam, ticketId, status);
        }
        return repairMapper.selectPage(new PageParam(), ticketId, status);
    }

    // ========== å†…部方法 ==========

    private AfterSaleRepairDO validateRepairExists(Long id) {
        AfterSaleRepairDO repair = repairMapper.selectById(id);
        if (repair == null) {
            throw exception(REPAIR_NOT_EXISTS);
        }
        return repair;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/returnobj/AfterSaleReturnService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,92 @@
package cn.iocoder.yudao.module.aftersales.service.returnobj;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnItemDO;
import jakarta.validation.Valid;

import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;

/**
 * å”®åŽé€€è´§ç”³è¯· Service æŽ¥å£
 */
public interface AfterSaleReturnService {

    /**
     * åˆ›å»ºé€€è´§ç”³è¯·
     *
     * @param createReqVO åˆ›å»ºä¿¡æ¯
     * @param userId      ç”¨æˆ·ç¼–号
     * @return ç¼–号
     */
    Long createReturn(@Valid AfterSaleReturnSaveReqVO createReqVO, Long userId);

    /**
     * å®¡æ ¸é€šè¿‡ï¼ˆè§¦å‘ MES é€€è´§æµç¨‹ï¼‰
     *
     * @param id é€€è´§ç”³è¯·ç¼–号
     */
    void approveReturn(Long id);

    /**
     * èŽ·å¾—退货申请
     *
     * @param id ç¼–号
     * @return é€€è´§ç”³è¯·
     */
    AfterSaleReturnDO getReturn(Long id);

    /**
     * èŽ·å¾—退货申请列表
     *
     * @param ids ç¼–号列表
     * @return é€€è´§ç”³è¯·åˆ—表
     */
    List<AfterSaleReturnDO> getReturnList(Collection<Long> ids);

    /**
     * èŽ·å¾—退货申请分页
     *
     * @param pageReqVO åˆ†é¡µæŸ¥è¯¢
     * @param userId    ç”¨æˆ·ç¼–号
     * @return é€€è´§ç”³è¯·åˆ†é¡µ
     */
    PageResult<AfterSaleReturnDO> getReturnPage(AfterSaleReturnPageReqVO pageReqVO, Long userId);

    /**
     * èŽ·å¾—退货明细行列表
     *
     * @param returnId é€€è´§ç”³è¯·ç¼–号
     * @return æ˜Žç»†è¡Œåˆ—表
     */
    List<AfterSaleReturnItemDO> getReturnItemListByReturnId(Long returnId);

    /**
     * MES è´¨æ£€å®Œæˆå›žè°ƒ
     *
     * @param returnId      é€€è´§ç”³è¯·ç¼–号
     * @param qualityResult è´¨æ£€ç»“论
     * @param reportUrl     è´¨æ£€æŠ¥å‘Š URL
     */
    void onQualityFinished(Long returnId, String qualityResult, String reportUrl);

    /**
     * MES é€€è´§å…¥åº“完成回调
     *
     * @param returnId é€€è´§ç”³è¯·ç¼–号
     */
    void onInboundFinished(Long returnId);

    /**
     * ERP é€€æ¬¾å®Œæˆå›žè°ƒ
     *
     * @param returnId           é€€è´§ç”³è¯·ç¼–号
     * @param actualRefundPrice  å®žé€€é‡‘额
     */
    void onRefundCompleted(Long returnId, BigDecimal actualRefundPrice);

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/returnobj/AfterSaleReturnServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,221 @@
package cn.iocoder.yudao.module.aftersales.service.returnobj;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnItemDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO;
import cn.iocoder.yudao.module.aftersales.dal.mysql.returnobj.AfterSaleReturnItemMapper;
import cn.iocoder.yudao.module.aftersales.dal.mysql.returnobj.AfterSaleReturnMapper;
import cn.iocoder.yudao.module.aftersales.dal.mysql.ticket.AfterSaleTicketMapper;
import cn.iocoder.yudao.module.aftersales.dal.redis.no.AfterSaleNoRedisDAO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleReturnStatusEnum;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleTicketStatusEnum;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSalePermissionLevelEnum;
import cn.iocoder.yudao.module.aftersales.service.permission.AfterSalePermissionService;
import cn.iocoder.yudao.module.aftersales.service.permission.bo.AfterSalePermissionCreateReqBO;
import cn.iocoder.yudao.module.mes.api.returnsales.MesWmReturnSalesApi;
import cn.iocoder.yudao.module.mes.api.returnsales.dto.MesWmReturnSalesCreateReqDTO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.aftersales.enums.ErrorCodeConstants.*;

/**
 * å”®åŽé€€è´§ç”³è¯· Service å®žçŽ°ç±»
 */
@Service
@Validated
@Slf4j
public class AfterSaleReturnServiceImpl implements AfterSaleReturnService {

    @Resource
    private AfterSaleReturnMapper returnMapper;
    @Resource
    private AfterSaleReturnItemMapper returnItemMapper;
    @Resource
    private AfterSaleTicketMapper ticketMapper;

    @Resource
    private AfterSaleNoRedisDAO noRedisDAO;

    @Resource
    private AfterSalePermissionService permissionService;

    @Resource
    private MesWmReturnSalesApi mesWmReturnSalesApi;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createReturn(AfterSaleReturnSaveReqVO createReqVO, Long userId) {
        // 1. æ ¡éªŒå·¥å•å­˜åœ¨
        AfterSaleTicketDO ticket = ticketMapper.selectById(createReqVO.getTicketId());
        if (ticket == null) {
            throw exception(TICKET_NOT_EXISTS);
        }

        // 2. ç”Ÿæˆå•å·
        String no = noRedisDAO.generate(AfterSaleNoRedisDAO.RETURN_NO_PREFIX);
        if (returnMapper.selectByNo(no) != null) {
            throw exception(RETURN_NO_EXISTS);
        }

        // 3. è®¡ç®—应退总金额
        BigDecimal totalReturnPrice = BigDecimal.ZERO;
        if (CollUtil.isNotEmpty(createReqVO.getItems())) {
            totalReturnPrice = createReqVO.getItems().stream()
                    .map(item -> item.getReturnPrice() != null ? item.getReturnPrice() : BigDecimal.ZERO)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);
        }

        // 4. æ’入退货申请
        AfterSaleReturnDO returnDO = BeanUtils.toBean(createReqVO, AfterSaleReturnDO.class)
                .setNo(no)
                .setTotalReturnPrice(totalReturnPrice)
                .setStatus(AfterSaleReturnStatusEnum.DRAFT.getStatus());
        returnMapper.insert(returnDO);

        // 5. æ’入退货明细行
        if (CollUtil.isNotEmpty(createReqVO.getItems())) {
            createReqVO.getItems().forEach(item -> {
                AfterSaleReturnItemDO itemDO = BeanUtils.toBean(item, AfterSaleReturnItemDO.class);
                itemDO.setReturnId(returnDO.getId());
                returnItemMapper.insert(itemDO);
            });
        }

        // 6. åˆ›å»ºæ•°æ®æƒé™
        AfterSalePermissionCreateReqBO permBO = new AfterSalePermissionCreateReqBO();
        permBO.setBizType(AfterSaleBizTypeEnum.AFTER_SALE_RETURN.getType());
        permBO.setBizId(returnDO.getId());
        permBO.setUserId(userId);
        permBO.setLevel(AfterSalePermissionLevelEnum.OWNER.getLevel());
        permissionService.createPermission(permBO);

        // 7. æ›´æ–°å·¥å•çŠ¶æ€ä¸ºå¾…退货
        ticketMapper.updateById(new AfterSaleTicketDO().setId(ticket.getId())
                .setReturnId(returnDO.getId())
                .setStatus(AfterSaleTicketStatusEnum.WAITING_RETURN.getStatus()));

        return returnDO.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void approveReturn(Long id) {
        // 1. æ ¡éªŒé€€è´§ç”³è¯·
        AfterSaleReturnDO returnDO = validateReturnExists(id);
        if (!AfterSaleReturnStatusEnum.DRAFT.getStatus().equals(returnDO.getStatus())) {
            throw exception(RETURN_APPROVE_FAIL);
        }

        // 2. èŽ·å–关联工单（用于获取销售订单号等冗余信息）
        AfterSaleTicketDO ticket = ticketMapper.selectById(returnDO.getTicketId());

        // 3. è°ƒç”¨ MES åˆ›å»ºé”€å”®é€€è´§å•
        MesWmReturnSalesCreateReqDTO mesReqDTO = new MesWmReturnSalesCreateReqDTO();
        mesReqDTO.setCode(returnDO.getNo());
        mesReqDTO.setName("售后退货-" + returnDO.getNo());
        mesReqDTO.setSaleOrderId(returnDO.getSaleOrderId());
        mesReqDTO.setSalesOrderCode(ticket != null ? ticket.getSaleOrderNo() : null);
        mesReqDTO.setClientId(returnDO.getCustomerId());
        mesReqDTO.setReturnDate(LocalDate.now());
        mesReqDTO.setReturnReason(returnDO.getReturnReason());
        mesReqDTO.setRemark("售后工单退货 - å·¥å•å·: " + (ticket != null ? ticket.getNo() : ""));
        mesReqDTO.setAfterSaleReturnId(returnDO.getId());
        Long mesReturnId = mesWmReturnSalesApi.createReturnSales(mesReqDTO);

        // 4. æ›´æ–°é€€è´§ç”³è¯·çŠ¶æ€
        returnMapper.updateById(new AfterSaleReturnDO().setId(id)
                .setStatus(AfterSaleReturnStatusEnum.APPROVED.getStatus())
                .setMesReturnId(mesReturnId)
                .setMesReturnCode(returnDO.getNo())
                .setAuditTime(LocalDateTime.now()));
    }

    @Override
    public AfterSaleReturnDO getReturn(Long id) {
        return validateReturnExists(id);
    }

    @Override
    public List<AfterSaleReturnDO> getReturnList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return List.of();
        }
        return returnMapper.selectBatchIds(ids);
    }

    @Override
    public PageResult<AfterSaleReturnDO> getReturnPage(AfterSaleReturnPageReqVO pageReqVO, Long userId) {
        return returnMapper.selectPage(pageReqVO, userId, pageReqVO.getSceneType(),
                pageReqVO.getNo(), pageReqVO.getTicketId(),
                pageReqVO.getCustomerId(), pageReqVO.getStatus());
    }

    @Override
    public List<AfterSaleReturnItemDO> getReturnItemListByReturnId(Long returnId) {
        return returnItemMapper.selectListByReturnId(returnId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onQualityFinished(Long returnId, String qualityResult, String reportUrl) {
        AfterSaleReturnDO returnDO = validateReturnExists(returnId);
        returnMapper.updateById(new AfterSaleReturnDO().setId(returnId)
                .setQualityResult(qualityResult)
                .setQualityReportUrl(reportUrl)
                .setStatus(AfterSaleReturnStatusEnum.INSPECTED.getStatus()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onInboundFinished(Long returnId) {
        AfterSaleReturnDO returnDO = validateReturnExists(returnId);
        returnMapper.updateById(new AfterSaleReturnDO().setId(returnId)
                .setStatus(AfterSaleReturnStatusEnum.INBOUND.getStatus())
                .setReturnInboundTime(LocalDateTime.now()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onRefundCompleted(Long returnId, BigDecimal actualRefundPrice) {
        AfterSaleReturnDO returnDO = validateReturnExists(returnId);
        returnMapper.updateById(new AfterSaleReturnDO().setId(returnId)
                .setActualRefundPrice(actualRefundPrice)
                .setStatus(AfterSaleReturnStatusEnum.REFUNDED.getStatus())
                .setRefundTime(LocalDateTime.now()));

        // æ›´æ–°å…³è”工单状态为待退款/换货完成
        AfterSaleTicketDO ticket = ticketMapper.selectById(returnDO.getTicketId());
        if (ticket != null) {
            ticketMapper.updateById(new AfterSaleTicketDO().setId(ticket.getId())
                    .setStatus(AfterSaleTicketStatusEnum.WAITING_REFUND.getStatus()));
        }
    }

    // ========== å†…部方法 ==========

    private AfterSaleReturnDO validateReturnExists(Long id) {
        AfterSaleReturnDO returnDO = returnMapper.selectById(id);
        if (returnDO == null) {
            throw exception(RETURN_NOT_EXISTS);
        }
        return returnDO;
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/ticket/AfterSaleTicketService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,113 @@
package cn.iocoder.yudao.module.aftersales.service.ticket;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket.AfterSaleTicketPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket.AfterSaleTicketSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketItemDO;
import jakarta.validation.Valid;

import java.util.Collection;
import java.util.List;

/**
 * å”®åŽå·¥å• Service æŽ¥å£
 */
public interface AfterSaleTicketService {

    /**
     * åˆ›å»ºå·¥å•
     *
     * @param createReqVO åˆ›å»ºä¿¡æ¯
     * @param userId      ç”¨æˆ·ç¼–号
     * @return ç¼–号
     */
    Long createTicket(@Valid AfterSaleTicketSaveReqVO createReqVO, Long userId);

    /**
     * æ›´æ–°å·¥å•
     *
     * @param updateReqVO æ›´æ–°ä¿¡æ¯
     */
    void updateTicket(@Valid AfterSaleTicketSaveReqVO updateReqVO);

    /**
     * åˆ é™¤å·¥å•
     *
     * @param id ç¼–号
     */
    void deleteTicket(Long id);

    /**
     * èŽ·å¾—工单
     *
     * @param id ç¼–号
     * @return å·¥å•
     */
    AfterSaleTicketDO getTicket(Long id);

    /**
     * èŽ·å¾—工单列表
     *
     * @param ids ç¼–号列表
     * @return å·¥å•åˆ—表
     */
    List<AfterSaleTicketDO> getTicketList(Collection<Long> ids);

    /**
     * èŽ·å¾—工单分页
     *
     * @param pageReqVO åˆ†é¡µæŸ¥è¯¢
     * @param userId    ç”¨æˆ·ç¼–号
     * @return å·¥å•åˆ†é¡µ
     */
    PageResult<AfterSaleTicketDO> getTicketPage(AfterSaleTicketPageReqVO pageReqVO, Long userId);

    /**
     * èŽ·å¾—工单明细行列表
     *
     * @param ticketId å·¥å•ç¼–号
     * @return æ˜Žç»†è¡Œåˆ—表
     */
    List<AfterSaleTicketItemDO> getTicketItemListByTicketId(Long ticketId);

    /**
     * åˆ†é…å¤„理人
     *
     * @param id              å·¥å•ç¼–号
     * @param handlerUserId   å¤„理人用户编号
     */
    void assignTicket(Long id, Long handlerUserId);

    /**
     * é—®é¢˜åˆ¤å®šï¼ˆç¡®å®šé—®é¢˜ç±»åž‹ã€åˆ†ç±»ã€ä¸¥é‡ç¨‹åº¦ï¼‰
     *
     * @param id            å·¥å•ç¼–号
     * @param issueType     é—®é¢˜ç±»åž‹
     * @param issueCategory é—®é¢˜åˆ†ç±»
     * @param severityLevel ä¸¥é‡ç¨‹åº¦
     */
    void classifyTicket(Long id, Integer issueType, String issueCategory, Integer severityLevel);

    /**
     * å®Œç»“工单
     *
     * @param id å·¥å•ç¼–号
     */
    void resolveTicket(Long id);

    /**
     * å…³é—­å·¥å•
     *
     * @param id å·¥å•ç¼–号
     */
    void closeTicket(Long id);

    /**
     * å–消工单
     *
     * @param id å·¥å•ç¼–号
     */
    void cancelTicket(Long id);

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/service/ticket/AfterSaleTicketServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,212 @@
package cn.iocoder.yudao.module.aftersales.service.ticket;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket.AfterSaleTicketPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.ticket.vo.ticket.AfterSaleTicketSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketItemDO;
import cn.iocoder.yudao.module.aftersales.dal.mysql.ticket.AfterSaleTicketItemMapper;
import cn.iocoder.yudao.module.aftersales.dal.mysql.ticket.AfterSaleTicketMapper;
import cn.iocoder.yudao.module.aftersales.dal.redis.no.AfterSaleNoRedisDAO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleTicketStatusEnum;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSalePermissionLevelEnum;
import cn.iocoder.yudao.module.aftersales.service.permission.AfterSalePermissionService;
import cn.iocoder.yudao.module.aftersales.service.permission.bo.AfterSalePermissionCreateReqBO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.aftersales.enums.ErrorCodeConstants.*;

/**
 * å”®åŽå·¥å• Service å®žçŽ°ç±»
 */
@Service
@Validated
@Slf4j
public class AfterSaleTicketServiceImpl implements AfterSaleTicketService {

    @Resource
    private AfterSaleTicketMapper ticketMapper;
    @Resource
    private AfterSaleTicketItemMapper ticketItemMapper;

    @Resource
    private AfterSaleNoRedisDAO noRedisDAO;

    @Resource
    private AfterSalePermissionService permissionService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createTicket(AfterSaleTicketSaveReqVO createReqVO, Long userId) {
        // 1. ç”Ÿæˆå•å·
        String no = noRedisDAO.generate(AfterSaleNoRedisDAO.TICKET_NO_PREFIX);
        if (ticketMapper.selectByNo(no) != null) {
            throw exception(TICKET_NO_EXISTS);
        }

        // 2. æ’入工单
        AfterSaleTicketDO ticket = BeanUtils.toBean(createReqVO, AfterSaleTicketDO.class)
                .setNo(no)
                .setStatus(AfterSaleTicketStatusEnum.DRAFT.getStatus())
                .setOwnerUserId(userId);
        ticketMapper.insert(ticket);

        // 3. æ’入明细行
        if (CollUtil.isNotEmpty(createReqVO.getItems())) {
            createReqVO.getItems().forEach(item -> {
                AfterSaleTicketItemDO itemDO = BeanUtils.toBean(item, AfterSaleTicketItemDO.class);
                itemDO.setTicketId(ticket.getId());
                ticketItemMapper.insert(itemDO);
            });
        }

        // 4. åˆ›å»ºæ•°æ®æƒé™ï¼ˆè´Ÿè´£äººï¼‰
        AfterSalePermissionCreateReqBO permBO = new AfterSalePermissionCreateReqBO();
        permBO.setBizType(AfterSaleBizTypeEnum.AFTER_SALE_TICKET.getType());
        permBO.setBizId(ticket.getId());
        permBO.setUserId(userId);
        permBO.setLevel(AfterSalePermissionLevelEnum.OWNER.getLevel());
        permissionService.createPermission(permBO);

        return ticket.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateTicket(AfterSaleTicketSaveReqVO updateReqVO) {
        // 1. æ ¡éªŒå­˜åœ¨
        AfterSaleTicketDO ticket = validateTicketExists(updateReqVO.getId());
        validateTicketStatus(ticket, AfterSaleTicketStatusEnum.DRAFT);

        // 2. æ›´æ–°å·¥å•
        AfterSaleTicketDO updateObj = BeanUtils.toBean(updateReqVO, AfterSaleTicketDO.class);
        ticketMapper.updateById(updateObj);

        // 3. æ›´æ–°æ˜Žç»†è¡Œï¼ˆå…ˆåˆ åŽå¢žï¼‰
        ticketItemMapper.deleteByTicketId(ticket.getId());
        if (CollUtil.isNotEmpty(updateReqVO.getItems())) {
            updateReqVO.getItems().forEach(item -> {
                AfterSaleTicketItemDO itemDO = BeanUtils.toBean(item, AfterSaleTicketItemDO.class);
                itemDO.setTicketId(ticket.getId());
                ticketItemMapper.insert(itemDO);
            });
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteTicket(Long id) {
        AfterSaleTicketDO ticket = validateTicketExists(id);
        validateTicketStatus(ticket, AfterSaleTicketStatusEnum.DRAFT, AfterSaleTicketStatusEnum.CANCELED);
        // è½¯åˆ é™¤
        ticketMapper.deleteById(id);
        ticketItemMapper.deleteByTicketId(id);
        permissionService.deletePermission(AfterSaleBizTypeEnum.AFTER_SALE_TICKET.getType(), id);
    }

    @Override
    public AfterSaleTicketDO getTicket(Long id) {
        return validateTicketExists(id);
    }

    @Override
    public List<AfterSaleTicketDO> getTicketList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return List.of();
        }
        return ticketMapper.selectBatchIds(ids);
    }

    @Override
    public PageResult<AfterSaleTicketDO> getTicketPage(AfterSaleTicketPageReqVO pageReqVO, Long userId) {
        return ticketMapper.selectPage(pageReqVO, userId, pageReqVO.getSceneType(),
                pageReqVO.getNo(), pageReqVO.getName(),
                pageReqVO.getCustomerId(), pageReqVO.getSaleOrderId(),
                pageReqVO.getStatus(), pageReqVO.getIssueType());
    }

    @Override
    public List<AfterSaleTicketItemDO> getTicketItemListByTicketId(Long ticketId) {
        return ticketItemMapper.selectListByTicketId(ticketId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void assignTicket(Long id, Long handlerUserId) {
        AfterSaleTicketDO ticket = validateTicketExists(id);
        validateTicketStatus(ticket, AfterSaleTicketStatusEnum.DRAFT, AfterSaleTicketStatusEnum.PROCESSING);
        ticketMapper.updateById(new AfterSaleTicketDO().setId(id).setHandlerUserId(handlerUserId)
                .setStatus(AfterSaleTicketStatusEnum.PROCESSING.getStatus()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void classifyTicket(Long id, Integer issueType, String issueCategory, Integer severityLevel) {
        AfterSaleTicketDO ticket = validateTicketExists(id);
        validateTicketStatus(ticket, AfterSaleTicketStatusEnum.PROCESSING);
        ticketMapper.updateById(new AfterSaleTicketDO().setId(id)
                .setIssueType(issueType).setIssueCategory(issueCategory).setSeverityLevel(severityLevel));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void resolveTicket(Long id) {
        AfterSaleTicketDO ticket = validateTicketExists(id);
        validateTicketStatus(ticket, AfterSaleTicketStatusEnum.PROCESSING,
                AfterSaleTicketStatusEnum.WAITING_RETURN, AfterSaleTicketStatusEnum.WAITING_REFUND);
        ticketMapper.updateById(new AfterSaleTicketDO().setId(id)
                .setStatus(AfterSaleTicketStatusEnum.COMPLETED.getStatus())
                .setResolvedTime(LocalDateTime.now()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void closeTicket(Long id) {
        AfterSaleTicketDO ticket = validateTicketExists(id);
        validateTicketStatus(ticket, AfterSaleTicketStatusEnum.COMPLETED);
        ticketMapper.updateById(new AfterSaleTicketDO().setId(id)
                .setStatus(AfterSaleTicketStatusEnum.CLOSED.getStatus())
                .setClosedTime(LocalDateTime.now()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void cancelTicket(Long id) {
        AfterSaleTicketDO ticket = validateTicketExists(id);
        validateTicketStatus(ticket, AfterSaleTicketStatusEnum.DRAFT, AfterSaleTicketStatusEnum.PROCESSING);
        ticketMapper.updateById(new AfterSaleTicketDO().setId(id)
                .setStatus(AfterSaleTicketStatusEnum.CANCELED.getStatus()));
    }

    // ========== å†…部方法 ==========

    private AfterSaleTicketDO validateTicketExists(Long id) {
        AfterSaleTicketDO ticket = ticketMapper.selectById(id);
        if (ticket == null) {
            throw exception(TICKET_NOT_EXISTS);
        }
        return ticket;
    }

    private void validateTicketStatus(AfterSaleTicketDO ticket, AfterSaleTicketStatusEnum... allowedStatuses) {
        for (AfterSaleTicketStatusEnum status : allowedStatuses) {
            if (status.getStatus().equals(ticket.getStatus())) {
                return;
            }
        }
        throw exception(TICKET_STATUS_ERROR);
    }

}

 yudao-module-aftersales/src/main/java/cn/iocoder/yudao/module/aftersales/util/AfterSalePermissionUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,94 @@
package cn.iocoder.yudao.module.aftersales.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.extra.spring.SpringUtil;
import cn.iocoder.yudao.framework.common.biz.system.permission.PermissionCommonApi;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.permission.AfterSalePermissionDO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSalePermissionLevelEnum;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSaleSceneTypeEnum;
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.yulichang.autoconfigure.MybatisPlusJoinProperties;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.springframework.util.Assert;

import java.util.List;

import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;

/**
 * å”®åŽæ¨¡å—数据权限工具类
 */
public class AfterSalePermissionUtils {

    /**
     * æ ¡éªŒç”¨æˆ·æ˜¯å¦æ˜¯å”®åŽç®¡ç†å‘˜
     *
     * @return æ˜¯/否
     */
    public static boolean isAftersaleAdmin() {
        PermissionCommonApi permissionApi = SpringUtil.getBean(PermissionCommonApi.class);
        return permissionApi.hasAnyRoles(getLoginUserId(), "aftersales_admin");
    }

    /**
     * æ ¡éªŒç”¨æˆ·æ˜¯å¦æœ‰æŸ¥çœ‹å…¨éƒ¨å”®åŽæ•°æ®çš„权限
     */
    private static boolean hasViewAllPermission() {
        PermissionCommonApi permissionApi = SpringUtil.getBean(PermissionCommonApi.class);
        return permissionApi.hasAnyPermissions(getLoginUserId(), "aftersales:view-all");
    }

    /**
     * æž„造售后模块数据【分页】查询条件
     *
     * @param query     è¿žè¡¨æŸ¥è¯¢å¯¹è±¡
     * @param bizType   æ•°æ®ç±»åž‹ {@link AfterSaleBizTypeEnum}
     * @param bizId     æ•°æ®ç¼–号
     * @param userId    ç”¨æˆ·ç¼–号
     * @param sceneType åœºæ™¯ç±»åž‹
     */
    public static <T extends MPJLambdaWrapper<?>, S> void appendPermissionCondition(T query, Integer bizType,
                                                                                     SFunction<S, ?> bizId,
                                                                                     Long userId, Integer sceneType) {
        MybatisPlusJoinProperties mybatisPlusJoinProperties = SpringUtil.getBean(MybatisPlusJoinProperties.class);
        final String ownerUserIdField = mybatisPlusJoinProperties.getTableAlias() + ".owner_user_id";
        // åœºæ™¯ä¸€ï¼šæˆ‘负责的数据
        if (AfterSaleSceneTypeEnum.isOwner(sceneType)) {
            query.eq(ownerUserIdField, userId);
        }
        // åœºæ™¯äºŒï¼šæˆ‘参与的数据（我有读或写权限，并且不是负责人）
        if (AfterSaleSceneTypeEnum.isInvolved(sceneType)) {
            if (isAftersaleAdmin()) {
                return;
            }
            query.innerJoin(AfterSalePermissionDO.class, on -> on.eq(AfterSalePermissionDO::getBizType, bizType)
                    .eq(AfterSalePermissionDO::getBizId, bizId)
                    .in(AfterSalePermissionDO::getLevel, AfterSalePermissionLevelEnum.READ.getLevel(),
                            AfterSalePermissionLevelEnum.WRITE.getLevel())
                    .eq(AfterSalePermissionDO::getUserId, userId));
            query.ne(ownerUserIdField, userId);
        }
        // åœºæ™¯ä¸‰ï¼šä¸‹å±žè´Ÿè´£çš„数据（下属是负责人）
        if (AfterSaleSceneTypeEnum.isSubordinate(sceneType)) {
            AdminUserApi adminUserApi = SpringUtil.getBean(AdminUserApi.class);
            List<AdminUserRespDTO> subordinateUsers = adminUserApi.getUserListBySubordinate(userId);
            if (CollUtil.isEmpty(subordinateUsers)) {
                query.eq(ownerUserIdField, -1);
            } else {
                query.in(ownerUserIdField, convertSet(subordinateUsers, AdminUserRespDTO::getId));
            }
        }
        // åœºæ™¯å››ï¼šå…¨éƒ¨æ•°æ®ï¼ˆéœ€è¦æœ‰ view-all æƒé™æˆ–售后管理员）
        if (AfterSaleSceneTypeEnum.isAll(sceneType)) {
            if (isAftersaleAdmin() || hasViewAllPermission()) {
                return;
            }
            query.eq(ownerUserIdField, userId);
        }
    }

}

 yudao-module-erp/src/main/java/cn/iocoder/yudao/module/erp/controller/admin/purchase/vo/request/ErpPurchaseRequestRespVO.java

@@ -5,6 +5,7 @@
import lombok.Data;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;

@@ -119,7 +120,7 @@
        private BigDecimal taxPrice;

        @Schema(description = "需求日期")
        private LocalDateTime demandTime;
        private LocalDate demandTime;

        @Schema(description = "备注", example = "备注")
        private String remark;

 yudao-module-erp/src/main/java/cn/iocoder/yudao/module/erp/controller/admin/purchase/vo/request/ErpPurchaseRequestSaveReqVO.java

@@ -7,6 +7,7 @@
import lombok.Data;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;

@@ -70,7 +71,7 @@
        private BigDecimal taxPercent;

        @Schema(description = "需求日期")
        private LocalDateTime demandTime;
        private LocalDate demandTime;

        @Schema(description = "备注", example = "备注")
        private String remark;

 yudao-module-erp/src/main/java/cn/iocoder/yudao/module/erp/controller/admin/sale/ErpSaleOrderController.java

@@ -19,6 +19,7 @@
import cn.iocoder.yudao.module.mdm.api.item.MdmItemApi;
import cn.iocoder.yudao.module.mdm.api.item.dto.MdmItemRespDTO;
import cn.iocoder.yudao.module.mes.api.mps.MesProMpsApi;
import cn.iocoder.yudao.module.mes.api.productsales.MesWmProductSalesLineApi;
import cn.iocoder.yudao.module.mes.api.salesnotice.MesWmSalesNoticeApi;
import cn.iocoder.yudao.module.system.api.storage.StorageAttachmentApi;
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
@@ -60,6 +61,8 @@
    private AdminUserApi adminUserApi;
    @Resource
    private MesWmSalesNoticeApi salesNoticeApi;
    @Resource
    private MesWmProductSalesLineApi productSalesLineApi;
    @Resource
    private MesProMpsApi mpsApi;
    @Resource
@@ -128,10 +131,13 @@
        List<ErpSaleOrderItemDO> saleOrderItemList = saleOrderService.getSaleOrderItemListByOrderId(id);
        Map<Long, MdmItemRespDTO> itemMap = mdmItemApi.getItemMap(
                convertSet(saleOrderItemList, ErpSaleOrderItemDO::getProductId));
        Map<Long, String> batchCodeMap = productSalesLineApi.getBatchCodesBySaleOrderItemIds(
                convertSet(saleOrderItemList, ErpSaleOrderItemDO::getId));
        return success(BeanUtils.toBean(saleOrder, ErpSaleOrderRespVO.class, saleOrderVO ->
                saleOrderVO.setItems(BeanUtils.toBean(saleOrderItemList, ErpSaleOrderRespVO.Item.class, item -> {
                    // åº“存信息暂不查询（仓储物流模块）
                    item.setStockCount(BigDecimal.ZERO);
                    item.setBatchCode(batchCodeMap.get(item.getId()));
                    MapUtils.findAndThen(itemMap, item.getProductId(), mdmItem -> item.setProductName(mdmItem.getName())
                            .setProductBarCode(mdmItem.getBarCode()));
                })).setAttachmentList(storageAttachmentApi.listAttachments("erp_sale_order", id))));
@@ -177,7 +183,10 @@
        // 1.5 å‘货通知单信息
        Map<Long, Boolean> salesNoticeMap = salesNoticeApi.checkSalesNoticeBySaleOrderIds(
                convertSet(pageResult.getList(), ErpSaleOrderDO::getId));
        // 1.6 æ£€æŸ¥æ˜¯å¦å¯ä»¥ç”Ÿæˆå‘货通知单（需要生产的明细对应的 MPS æ˜¯å¦å·²å®Œæˆï¼‰
        // 1.6 å‡ºåº“批号
        Map<Long, String> batchCodeMap = productSalesLineApi.getBatchCodesBySaleOrderItemIds(
                convertSet(saleOrderItemList, ErpSaleOrderItemDO::getId));
        // 1.7 æ£€æŸ¥æ˜¯å¦å¯ä»¥ç”Ÿæˆå‘货通知单（需要生产的明细对应的 MPS æ˜¯å¦å·²å®Œæˆï¼‰
        // ç­›é€‰å‡ºéœ€è¦ç”Ÿäº§çš„明细ID
        List<Long> needProductionItemIds = saleOrderItemList.stream()
                .filter(item -> item.getNeedProduction() != null && item.getNeedProduction() == 1)
@@ -214,8 +223,11 @@
        // 2. å¼€å§‹æ‹¼æŽ¥
        return BeanUtils.toBean(pageResult, ErpSaleOrderRespVO.class, saleOrder -> {
            saleOrder.setItems(BeanUtils.toBean(saleOrderItemMap.get(saleOrder.getId()), ErpSaleOrderRespVO.Item.class,
                    item -> MapUtils.findAndThen(itemMap, item.getProductId(), mdmItem -> item.setProductName(mdmItem.getName())
                            .setProductBarCode(mdmItem.getBarCode()))));
                    item -> {
                        item.setBatchCode(batchCodeMap.get(item.getId()));
                        MapUtils.findAndThen(itemMap, item.getProductId(), mdmItem -> item.setProductName(mdmItem.getName())
                                .setProductBarCode(mdmItem.getBarCode()));
                    }));
            saleOrder.setProductNames(CollUtil.join(saleOrder.getItems(), "，", ErpSaleOrderRespVO.Item::getProductName));
            MapUtils.findAndThen(customerMap, saleOrder.getCustomerId(), supplier -> saleOrder.setCustomerName(supplier.getName()));
            MapUtils.findAndThen(userMap, Long.parseLong(saleOrder.getCreator()), user -> saleOrder.setCreatorName(user.getNickname()));

 yudao-module-erp/src/main/java/cn/iocoder/yudao/module/erp/controller/admin/sale/vo/order/ErpSaleOrderPageReqVO.java

@@ -33,6 +33,15 @@
    @Schema(description = "销售状态", example = "2")
    private Integer status;

    @Schema(description = "出库状态", example = "3")
    private Integer outStatus;

    @Schema(description = "生产状态", example = "0")
    private Integer productionStatus;

    @Schema(description = "是否需要生产", example = "1")
    private Integer needProduction;

    @Schema(description = "创建者")
    private String creator;


 yudao-module-erp/src/main/java/cn/iocoder/yudao/module/erp/controller/admin/sale/vo/order/ErpSaleOrderRespVO.java

@@ -164,6 +164,11 @@
        @Schema(description = "关联的 MPS ç¼–号", example = "1024")
        private Long mpsId;

        // ========== å‡ºåº“批号 ==========

        @Schema(description = "出库批号", example = "B2026001、B2026002")
        private String batchCode;

        // ========== å…³è”字段 ==========

        @Schema(description = "产品名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "巧克力")

 yudao-module-erp/src/main/java/cn/iocoder/yudao/module/erp/dal/dataobject/purchase/ErpPurchaseRequestItemDO.java

@@ -7,7 +7,7 @@
import lombok.*;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.LocalDate;

/**
 * ERP é‡‡è´­ç”³è¯·æ˜Žç»† DO
@@ -71,7 +71,7 @@
    /**
     * éœ€æ±‚日期
     */
    private LocalDateTime demandTime;
    private LocalDate demandTime;

    /**
     * å¤‡æ³¨

 yudao-module-erp/src/main/java/cn/iocoder/yudao/module/erp/dal/mysql/sale/ErpSaleOrderMapper.java

@@ -27,12 +27,15 @@
                .eqIfPresent(ErpSaleOrderDO::getCustomerId, reqVO.getCustomerId())
                .betweenIfPresent(ErpSaleOrderDO::getOrderTime, reqVO.getOrderTime())
                .eqIfPresent(ErpSaleOrderDO::getStatus, reqVO.getStatus())
                .eqIfPresent(ErpSaleOrderDO::getOutStatus, reqVO.getOutStatus())
                .eqIfPresent(ErpSaleOrderDO::getProductionStatus, reqVO.getProductionStatus())
                .likeIfPresent(ErpSaleOrderDO::getRemark, reqVO.getRemark())
                .eqIfPresent(ErpSaleOrderDO::getCreator, reqVO.getCreator())
                .orderByDesc(ErpSaleOrderDO::getId);
        if (reqVO.getProductId() != null) {
        if (reqVO.getProductId() != null || reqVO.getNeedProduction() != null) {
            query.leftJoin(ErpSaleOrderItemDO.class, ErpSaleOrderItemDO::getOrderId, ErpSaleOrderDO::getId)
                    .eq(reqVO.getProductId() != null, ErpSaleOrderItemDO::getProductId, reqVO.getProductId())
                    .eq(reqVO.getNeedProduction() != null, ErpSaleOrderItemDO::getNeedProduction, reqVO.getNeedProduction())
                    .groupBy(ErpSaleOrderDO::getId); // é¿å… 1 å¯¹å¤šæŸ¥è¯¢ï¼Œäº§ç”Ÿç›¸åŒçš„ 1
        }
        return selectJoinPage(reqVO, ErpSaleOrderDO.class, query);
@@ -47,6 +50,8 @@
                .eqIfPresent(ErpSaleOrderDO::getCustomerId, reqVO.getCustomerId())
                .betweenIfPresent(ErpSaleOrderDO::getOrderTime, reqVO.getOrderTime())
                .eqIfPresent(ErpSaleOrderDO::getStatus, reqVO.getStatus())
                .eqIfPresent(ErpSaleOrderDO::getOutStatus, reqVO.getOutStatus())
                .eqIfPresent(ErpSaleOrderDO::getProductionStatus, reqVO.getProductionStatus())
                .likeIfPresent(ErpSaleOrderDO::getRemark, reqVO.getRemark())
                .eqIfPresent(ErpSaleOrderDO::getCreator, reqVO.getCreator())
                .orderByDesc(ErpSaleOrderDO::getId);
@@ -57,9 +62,10 @@
            }
            query.in(ErpSaleOrderDO::getCustomerId, permittedCustomerIds);
        }
        if (reqVO.getProductId() != null) {
        if (reqVO.getProductId() != null || reqVO.getNeedProduction() != null) {
            query.leftJoin(ErpSaleOrderItemDO.class, ErpSaleOrderItemDO::getOrderId, ErpSaleOrderDO::getId)
                    .eq(reqVO.getProductId() != null, ErpSaleOrderItemDO::getProductId, reqVO.getProductId())
                    .eq(reqVO.getNeedProduction() != null, ErpSaleOrderItemDO::getNeedProduction, reqVO.getNeedProduction())
                    .groupBy(ErpSaleOrderDO::getId); // é¿å… 1 å¯¹å¤šæŸ¥è¯¢ï¼Œäº§ç”Ÿç›¸åŒçš„ 1
        }
        return selectJoinPage(reqVO, ErpSaleOrderDO.class, query);

 yudao-module-mes-api/src/main/java/cn/iocoder/yudao/module/mes/api/productsales/MesWmProductSalesLineApi.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,21 @@
package cn.iocoder.yudao.module.mes.api.productsales;

import java.util.Collection;
import java.util.Map;

/**
 * MES é”€å”®å‡ºåº“单行 API æŽ¥å£
 *
 * @author èŠ‹é“源码
 */
public interface MesWmProductSalesLineApi {

    /**
     * æ ¹æ®é”€å”®è®¢å•æ˜Žç»† ID åˆ—表查询出库批号
     *
     * @param saleOrderItemIds é”€å”®è®¢å•æ˜Žç»† ID åˆ—表
     * @return Map<销售订单明细ID, æ‰¹å·ä¸²è”字符串>
     */
    Map<Long, String> getBatchCodesBySaleOrderItemIds(Collection<Long> saleOrderItemIds);

}

 yudao-module-mes-api/src/main/java/cn/iocoder/yudao/module/mes/api/returnsales/MesWmReturnSalesApi.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.mes.api.returnsales;

import cn.iocoder.yudao.module.mes.api.returnsales.dto.MesWmReturnSalesCreateReqDTO;

/**
 * MES é”€å”®é€€è´§å• API æŽ¥å£
 *
 * @author èŠ‹é“源码
 */
public interface MesWmReturnSalesApi {

    /**
     * åˆ›å»ºé”€å”®é€€è´§å•ï¼ˆç”±å”®åŽæ¨¡å—调用）
     *
     * @param reqDTO åˆ›å»ºè¯·æ±‚参数
     * @return åˆ›å»ºçš„销售退货单编号
     */
    Long createReturnSales(MesWmReturnSalesCreateReqDTO reqDTO);

}

 yudao-module-mes-api/src/main/java/cn/iocoder/yudao/module/mes/api/returnsales/dto/MesWmReturnSalesCreateReqDTO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
package cn.iocoder.yudao.module.mes.api.returnsales.dto;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.time.LocalDate;

/**
 * MES é”€å”®é€€è´§å•åˆ›å»º Request DTO
 *
 * @author èŠ‹é“源码
 */
@Schema(description = "RPC æœåŠ¡ - MES é”€å”®é€€è´§å•åˆ›å»º Request DTO")
@Data
public class MesWmReturnSalesCreateReqDTO {

    @Schema(description = "退货单编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "RS202603010001")
    private String code;

    @Schema(description = "退货单名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "售后退货")
    private String name;

    @Schema(description = "销售订单 ID", example = "1")
    private Long saleOrderId;

    @Schema(description = "销售订单编号", example = "SO202603010001")
    private String salesOrderCode;

    @Schema(description = "客户 ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
    private Long clientId;

    @Schema(description = "退货日期", requiredMode = Schema.RequiredMode.REQUIRED)
    private LocalDate returnDate;

    @Schema(description = "退货原因", requiredMode = Schema.RequiredMode.REQUIRED, example = "质量问题")
    private String returnReason;

    @Schema(description = "备注", example = "售后退货申请关联")
    private String remark;

    @Schema(description = "售后退货申请编号（关联 after_sale_return.id）", example = "1")
    private Long afterSaleReturnId;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/api/productsales/MesWmProductSalesLineApiImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,28 @@
package cn.iocoder.yudao.module.mes.api.productsales;

import cn.iocoder.yudao.module.mes.dal.mysql.wm.productsales.MesWmProductSalesLineMapper;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.util.Collection;
import java.util.Map;

/**
 * MES é”€å”®å‡ºåº“单行 API å®žçŽ°ç±»
 *
 * @author èŠ‹é“源码
 */
@Service
@Validated
public class MesWmProductSalesLineApiImpl implements MesWmProductSalesLineApi {

    @Resource
    private MesWmProductSalesLineMapper productSalesLineMapper;

    @Override
    public Map<Long, String> getBatchCodesBySaleOrderItemIds(Collection<Long> saleOrderItemIds) {
        return productSalesLineMapper.selectBatchCodesBySaleOrderItemIds(saleOrderItemIds);
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/api/returnsales/MesWmReturnSalesApiImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,27 @@
package cn.iocoder.yudao.module.mes.api.returnsales;

import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.api.returnsales.dto.MesWmReturnSalesCreateReqDTO;
import cn.iocoder.yudao.module.mes.controller.admin.wm.returnsales.vo.MesWmReturnSalesSaveReqVO;
import cn.iocoder.yudao.module.mes.service.wm.returnsales.MesWmReturnSalesService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

/**
 * MES é”€å”®é€€è´§å• API å®žçŽ°ç±»
 *
 * @author èŠ‹é“源码
 */
@Service
public class MesWmReturnSalesApiImpl implements MesWmReturnSalesApi {

    @Resource
    private MesWmReturnSalesService returnSalesService;

    @Override
    public Long createReturnSales(MesWmReturnSalesCreateReqDTO reqDTO) {
        MesWmReturnSalesSaveReqVO createReqVO = BeanUtils.toBean(reqDTO, MesWmReturnSalesSaveReqVO.class);
        return returnSalesService.createReturnSales(createReqVO);
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/wm/returnsales/vo/MesWmReturnSalesPageReqVO.java

@@ -6,9 +6,9 @@
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;

import java.time.LocalDateTime;
import java.time.LocalDate;

import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY;

/**
 * ç®¡ç†åŽå° - MES é”€å”®é€€è´§ç›¸å…³
@@ -26,6 +26,9 @@
    @Schema(description = "退货单名称", example = "销售退货")
    private String name;

    @Schema(description = "销售订单 ID", example = "1")
    private Long saleOrderId;

    @Schema(description = "销售订单编号", example = "SO202603010001")
    private String salesOrderCode;

@@ -36,7 +39,7 @@
    private Integer status;

    @Schema(description = "退货日期")
    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
    private LocalDateTime[] returnDate;
    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY)
    private LocalDate[] returnDate;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/wm/returnsales/vo/MesWmReturnSalesRespVO.java

@@ -3,6 +3,7 @@
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.time.LocalDate;
import java.time.LocalDateTime;

/**
@@ -23,6 +24,9 @@
    @Schema(description = "退货单名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "销售退货")
    private String name;

    @Schema(description = "销售订单 ID", example = "1")
    private Long saleOrderId;

    @Schema(description = "销售订单编号", example = "SO202603010001")
    private String salesOrderCode;

@@ -33,7 +37,7 @@
    private String clientName;

    @Schema(description = "退货日期")
    private LocalDateTime returnDate;
    private LocalDate returnDate;

    @Schema(description = "退货原因", example = "质量问题")
    private String returnReason;

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/wm/returnsales/vo/MesWmReturnSalesSaveReqVO.java

@@ -5,7 +5,7 @@
import jakarta.validation.constraints.NotNull;
import lombok.Data;

import java.time.LocalDateTime;
import java.time.LocalDate;

/**
 * ç®¡ç†åŽå° - MES é”€å”®é€€è´§å•æ–°å¢ž/修改 Request VO
@@ -27,6 +27,9 @@
    @NotBlank(message = "退货单名称不能为空")
    private String name;

    @Schema(description = "销售订单 ID", example = "1")
    private Long saleOrderId;

    @Schema(description = "销售订单编号", example = "SO202603010001")
    private String salesOrderCode;

@@ -36,7 +39,7 @@

    @Schema(description = "退货日期", requiredMode = Schema.RequiredMode.REQUIRED)
    @NotNull(message = "退货日期不能为空")
    private LocalDateTime returnDate;
    private LocalDate returnDate;

    @Schema(description = "退货原因", requiredMode = Schema.RequiredMode.REQUIRED, example = "质量问题")
    @NotBlank(message = "退货原因不能为空")

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/wm/returnvendor/vo/MesWmReturnVendorRespVO.java

@@ -3,6 +3,7 @@
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.time.LocalDate;
import java.time.LocalDateTime;

@Schema(description = "管理后台 - MES ä¾›åº”商退货单 Response VO")
@@ -34,7 +35,7 @@
    private String vendorNickname;

    @Schema(description = "退货日期")
    private LocalDateTime returnDate;
    private LocalDate returnDate;

    @Schema(description = "退货原因", example = "质量不合格")
    private String returnReason;

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/wm/returnvendor/vo/MesWmReturnVendorSaveReqVO.java

@@ -5,7 +5,7 @@
import jakarta.validation.constraints.NotNull;
import lombok.Data;

import java.time.LocalDateTime;
import java.time.LocalDate;

@Schema(description = "管理后台 - MES ä¾›åº”商退货单新增/修改 Request VO")
@Data
@@ -31,7 +31,7 @@

    @Schema(description = "退货日期", requiredMode = Schema.RequiredMode.REQUIRED)
    @NotNull(message = "退货日期不能为空")
    private LocalDateTime returnDate;
    private LocalDate returnDate;

    @Schema(description = "退货原因", example = "质量不合格")
    private String returnReason;

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/wm/returnsales/MesWmReturnSalesDO.java

@@ -7,7 +7,7 @@
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

import java.time.LocalDateTime;
import java.time.LocalDate;
import cn.iocoder.yudao.module.mes.enums.DictTypeConstants;

/**
@@ -39,6 +39,10 @@
     */
    private String name;
    /**
     * é”€å”®è®¢å• ID
     */
    private Long saleOrderId;
    /**
     * é”€å”®è®¢å•ç¼–号
     */
    private String salesOrderCode;
@@ -51,7 +55,7 @@
    /**
     * é€€è´§æ—¥æœŸ
     */
    private LocalDateTime returnDate;
    private LocalDate returnDate;
    /**
     * é€€è´§åŽŸå› 
     */

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/wm/returnvendor/MesWmReturnVendorDO.java

@@ -7,7 +7,7 @@
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

import java.time.LocalDateTime;
import java.time.LocalDate;
import cn.iocoder.yudao.module.mes.enums.DictTypeConstants;

/**
@@ -49,7 +49,7 @@
    /**
     * é€€è´§æ—¥æœŸ
     */
    private LocalDateTime returnDate;
    private LocalDate returnDate;
    /**
     * é€€è´§åŽŸå› 
     */

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/wm/productsales/MesWmProductSalesLineMapper.java

@@ -1,11 +1,13 @@
package cn.iocoder.yudao.module.mes.dal.mysql.wm.productsales;

import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.mes.dal.dataobject.wm.productsales.MesWmProductSalesLineDO;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;
import java.util.Map;

/**
 * MES é”€å”®å‡ºåº“单行 Mapper
@@ -31,6 +33,26 @@
                .orderByDesc(MesWmProductSalesLineDO::getId));
    }

    /**
     * æ ¹æ®é”€å”®è®¢å•æ˜Žç»† ID åˆ—表查询出库行，按 saleOrderItemId åˆ†ç»„返回批号
     */
    default Map<Long, String> selectBatchCodesBySaleOrderItemIds(java.util.Collection<Long> saleOrderItemIds) {
        if (saleOrderItemIds == null || saleOrderItemIds.isEmpty()) {
            return java.util.Collections.emptyMap();
        }
        List<MesWmProductSalesLineDO> lines = selectList(new LambdaQueryWrapperX<MesWmProductSalesLineDO>()
                .in(MesWmProductSalesLineDO::getSaleOrderItemId, saleOrderItemIds));
        return lines.stream()
                .filter(l -> l.getBatchCode() != null && !l.getBatchCode().isEmpty())
                .collect(java.util.stream.Collectors.groupingBy(
                        MesWmProductSalesLineDO::getSaleOrderItemId,
                        java.util.LinkedHashMap::new,
                        java.util.stream.Collectors.collectingAndThen(
                                java.util.stream.Collectors.mapping(MesWmProductSalesLineDO::getBatchCode,
                                        java.util.stream.Collectors.toSet()),
                                codes -> String.join("、", codes))));
    }

    default void updateQualityStatusByIds(List<Long> ids, Integer qualityStatus) {
        update(new MesWmProductSalesLineDO().setQualityStatus(qualityStatus),
                new LambdaUpdateWrapper<MesWmProductSalesLineDO>().in(MesWmProductSalesLineDO::getId, ids));

 yudao-module-system/src/main/java/cn/iocoder/yudao/module/system/enums/storage/StorageRecordTypeEnum.java

@@ -53,6 +53,10 @@
    HRM_RESIGNATION_APPLICATION("hrm_resignation_application", "HRM ç¦»èŒç”³è¯·"),
    HRM_ATTENDANCE_EXCEPTION("hrm_attendance_exception", "HRM è€ƒå‹¤å¼‚常"),

    // ===== å”®åŽ =====
    AFTER_SALE_TICKET("aftersales_ticket", "售后工单"),
    AFTER_SALE_RETURN("aftersales_return", "售后退货申请"),

    // ===== MES =====
    MES_PD_DOCUMENT("mes_pd_document", "MES è®¾è®¡èµ„æ–™");


 yudao-server/pom.xml

@@ -150,6 +150,13 @@
            <version>${revision}</version>
        </dependency>

        <!-- å”®åŽå·¥å•ç®¡ç†æ¨¡å— -->
        <dependency>
            <groupId>cn.iocoder.boot</groupId>
            <artifactId>yudao-module-aftersales</artifactId>
            <version>${revision}</version>
        </dependency>

        <!-- spring boot é…ç½®æ‰€éœ€ä¾èµ– -->
        <dependency>
            <groupId>org.springframework.boot</groupId>