Merge branch 'master' into dev

0f6e18b7 · 杨树贤 · 221d7cf6 · 9e449996 · 0f6e18b7 · 0f6e18b7
Commit 0f6e18b7 authored May 15, 2026 by 杨树贤
Showing with 735 additions and 8 deletions
doc/price_generation_logic.md
model/ly_sku.go
service/service_ly.go
service/service_price.go
service/service_tags.go
service/service_zy.go
service/service_zy_common.go
--- a/doc/price_generation_logic.md
+++ b/doc/price_generation_logic.md
+# 商品价格生成逻辑说明（产品版）
+## 一、整体流程概述
+当用户查看商品详情时，系统会根据商品所属的组织类型，采用不同的价格计算方式。目前主要有两种组织：
+- **猎芯（OrgId = 1）**：标准价格体系
+- **爱智/华云（OrgId = 3）**：兼容多种历史数据格式
+---
+## 二、猎芯的价格生成流程
+### 第一步：售价计算（GetCoefficientAndPrice）
+#### A. 专营供应商（supplier_id = 17）
+**说明：** supplier_id = 17 是"专营供应商"的统一标识，实际上包含多个自营渠道：
+- **L0018319**：国内自营（WMS同步人民币未税成本价）
+- **L0018562**：香港自营（WMS同步美金未税成本价）
+- **L0003270**：其他自营渠道
+- 以及其他以 L 开头的专营渠道编码
+**核心概念：单一成本价 vs 自营商品成本价**
+这是两个不同的概念，需要区分清楚：
+| 类型 | 定义 | 适用场景 |
+|-----|------|---------|
+| **单一成本价** | 上传数据只有**1个阶梯**，且 `阶梯数量 = 0` | 专营供应商（supplier_id = 17） |
+| **自营商品成本价** | WMS同步的库存成本价（含税） | 专营供应商 supplier_id = 17（自营商品） |
+**单一成本价的判断逻辑：**
+```
+上传的数据：
+- 只有1个阶梯，且 阶梯数量 = 0 → 代表是【单一成本价】
+- 有多个阶梯，且 阶梯数量 > 0 → 代表是【已有阶梯价】
+```
+**单一成本价的特点：**
+- 供应商上传时只提供了一个成本价（没有设置阶梯价）
+- 系统需要根据这个成本价，自动生成完整的阶梯价格
+- 适用于专营供应商（supplier_id = 17）
+**自营商品成本价的特点：**
+- 从WMS系统同步过来的库存成本价
+- 国内自营（L0018319）：同步人民币含税成本价
+- 香港自营（L0018562）：同步美金未税成本价
+- 需要根据汇率和关税转换成含税成本价
+---
+**流程说明：**
+1. **汇率转换（仅香港自营 L0018562）**：
+   - WMS同步的是美金未税成本价
+   - 需要 × 汇率 × 关税(1.13) = 人民币含税成本价
+2. **判断是否有成本价**：
+   - 如果 `PriceCostUs` 和 `PriceCostCn` 都为0：调用 `GenerateLadderPrice()` 生成阶梯价
+   - 如果已有成本价：直接使用，应用折扣系数
+3. **获取折扣系数** (`GetDiscountRatio`)
+折扣系数用于对成本价进行折扣调整，**主要适用于代购渠道**（专营渠道基本为1，即无折扣）。
+**多条件匹配逻辑（按优先级从高到低）：**
+系统会尝试匹配最精确的折扣系数，匹配优先级：
+1. **商品名称**（精确匹配）
+2. **标准品牌ID**（匹配品牌）
+3. **默认配置**（无特殊条件）
+**匹配规则：**
+- 按排序号从大到小遍历配置
+- 任一条件匹配即命中，立即跳出
+- 如果设置了商品名称或品牌但未匹配，继续检查下一个排序号
+- 如果未设置任何特殊条件，直接采用该配置
+**示例：**
+```
+配置1（排序号=100）：
+- 商品名称：STM32F103C8T6
+- 折扣：0.95
+配置2（排序号=50）：
+- 品牌：STMicroelectronics
+- 折扣：0.92
+配置3（排序号=1）：
+- 无特殊条件
+- 折扣：0.90
+场景A：商品是 STM32F103C8T6
+→ 匹配配置1，折扣 = 0.95
+场景B：商品是 STM32F407VGT6（同品牌）
+→ 匹配配置2，折扣 = 0.92
+场景C：商品是其他品牌
+→ 匹配配置3，折扣 = 0.90
+```
+**计算应用：**
+```
+人民币成本 = 原始采购价 × 汇率 × 关税 × 折扣系数
+美金成本 = 原始采购价 × 折扣系数
+```
+**找不到配置时的兜底：**
+- 如果渠道无专属配置，使用全局默认配置
+- 全局默认配置中区分人民币系数（`ration`）和美金系数（`ration_usd`）
+4. **应用折扣**：最终售价 = 成本价 × 折扣系数
+---
+#### A.4 GenerateLadderPrice - 生成阶梯价格
+**适用范围：** 专营供应商（supplier_id = 17）
+当专营供应商载入产品时，有两种情况会进入这个方法：
+1. **单一成本价** (阶梯数量 = 0)：只提供了一个成本价，没有阶梯价，需要生成完整的阶梯价格
+2. **已有阶梯价** (阶梯数量 > 0)：载入了阶梯价，需要应用利润系数来计算售价
+**注意：** 自营商品不经过这个逻辑，因为自营商品的成本价是从WMS系统同步过来的，使用另一种计算价格的方法。
+---
+##### A.4.1 单一成本价生成阶梯价格 (阶梯数量 = 0)
+**情况1：MOQ <= 50 固定阶梯 (小MOQ产品)**
+当最小订购量小于等于50时，系统使用**固定阶梯和固定利润率**来生成价格，以避免亏损。
+**固定阶梯配置表：**
+| MOQ范围 | 阶梯1 | 阶梯2 | 阶梯3 | 阶梯4 | 阶梯5 |
+|---------|-------|-------|-------|-------|-------|
+| < 10 | MOQ | 30 | 100 | 300 | 1000 |
+| 10-29 | MOQ | 50 | 200 | 500 | 1000 |
+| 30-50 | MOQ | 200 | 500 | 1000 | 2000 |
+**固定利润率 (下限保证利润)：**
+- 阶梯1 (MOQ)：11% 利润
+- 阶梯2：10% 利润
+- 阶梯3：9% 利润
+- 阶梯4：8% 利润
+- 阶梯5：7% 利润
+**示例 (MOQ = 5)：**
+```
+成本价：¥100
+生成的阶梯价格：
+- 5个：¥100 × 1.11 = ¥111 (11% 利润)
+- 30个：¥100 × 1.10 = ¥110 (10% 利润)
+- 100个：¥100 × 1.09 = ¥109 (9% 利润)
+- 300个：¥100 × 1.08 = ¥108 (8% 利润)
+- 1000个：¥100 × 1.07 = ¥107 (7% 利润)
+```
+**情况2：MOQ > 50 动态阶梯 (大MOQ产品)**
+当最小订购量大于50时，系统根据**库存量**和**销售价格组配置的利润系数**动态计算阶梯和利润率。
+**计算逻辑：**
+1. 根据库存量确定可以显示的阶梯数量（库存量必须满足该阶梯的数量要求）
+2. 读取销售价格组配置的利润系数
+3. 成本价 × 利润系数 = 每个阶梯的售价
+**关键配置参数：**
+- `ladderPriceMiniProfitLevel`：阶梯最小利润点数量（例如设置为5，表示最多显示5个阶梯，从第5个利润点开始往前）
+- `costLadderCount`：根据库存量计算出的实际阶梯数量
+**示例计算阶梯利润：**
+```
+假设销售价格组配置了9个利润系数（从低到高）：
+[1.05, 1.06, 1.07, 1.08, 1.09, 1.10, 1.11, 1.12, 1.13]
+MOQ = 100，库存量 = 5000
+最小利润点 = 5
+库存量满足的阶梯数量 = 3（100×1=100，100×5=500，100×10=1000都在库存量范围内）
+因为 3 < 5，所以取向后阶梯利润：
+阶梯1 -> 取（5-3+0）=3个利润系数 = 1.07 -> 售价 ¥cost × 1.07
+阶梯2 -> 取（5-3+1）=3个利润系数 = 1.08 -> 售价 ¥cost × 1.08
+阶梯3 -> 取（5-3+2）=5个利润系数 = 1.09 -> 售价 ¥cost × 1.09
+```
+---
+##### A.4.2 已有阶梯价应用利润系数 (阶梯数量 > 0)
+当供应商载入了阶梯价（阶梯数量 > 0）时，系统根据销售价格组配置的`ladderType`字段，采用两种不同的处理方法：
+**销售价格组配置解释：**
+- `ladderType = 1`：旧逻辑，**基于载入的阶梯**，取向后利润系数
+- `ladderType = 2`：新逻辑，**基于销售价格组配置的阶梯**，生成固定阶梯
+- `ladderPriceMiniProfitLevel`：阶梯最小利润点数量（限制显示的最大阶梯数量）
+---
+**类型A：ladderType = 1 (旧逻辑：基于载入的阶梯)**
+**处理逻辑：**
+1. 基于载入的阶梯数量（例如供应商载入了3个阶梯：1个、10个、100个）
+2. 根据库存量判断可以满足的阶梯数量（库存量必须满足该阶梯的数量要求）
+3. 从销售价格组配置的利润系数中**取向后值**
+**示例：**
+```
+载入的阶梯：
+- 1个：$50 (成本价)
+- 10个：$45 (成本价)
+- 100个：$40 (成本价)
+销售价格组配置了9个利润系数：[1.05, 1.06, 1.07, 1.08, 1.09, 1.10, 1.11, 1.12, 1.13]
+最小利润点 = 5
+库存量满足的阶梯数量 = 3
+方法计算（取向后）：
+阶梯1 (1个) -> 取（5-3+0）=3个利润系数 = 1.07 -> 售价 $50 × 1.07 = $53.5
+阶梯2 (10个) -> 取（5-3+1）=3个利润系数 = 1.08 -> 售价 $45 × 1.08 = $48.6
+阶梯3 (100个) -> 取（5-3+2）=5个利润系数 = 1.09 -> 售价 $40 × 1.09 = $43.6
+```
+---
+**类型B：ladderType = 2 (新逻辑：基于销售价格组配置的阶梯)**
+**业务场景：** 操作希望统一某些产品的阶梯显示格式，不论供应商载入了什么阶梯，都按照销售价格组配置的阶梯显示。
+**处理逻辑：**
+1. **忽略载入的阶梯数量**，基于销售价格组配置的阶梯
+2. 基于**载入的第一个阶梯的价格**作为基准（作为成本价）
+3. 乘以销售价格组配置的每个阶梯的利润系数，生成固定阶梯价格
+**示例：**
+```
+载入的阶梯：
+- 5个：¥100 (成本价)
+- 50个：¥90 (成本价)
+- 200个：¥80 (成本价)
+销售价格组配置（固定阶梯）：
+- 1个：利润系数 1.15
+- 10个：利润系数 1.12
+- 100个：利润系数 1.10
+- 1000个：利润系数 1.08
+处理方法（基于第一个阶梯的价格）：
+成本价基准 = ¥100
+生成的阶梯价格：
+- 1个：¥100 × 1.15 = ¥115 (销售价格组配置的阶梯)
+- 10个：¥100 × 1.12 = ¥112 (销售价格组配置的阶梯)
+- 100个：¥100 × 1.10 = ¥110 (销售价格组配置的阶梯)
+- 1000个：¥100 × 1.08 = ¥108 (销售价格组配置的阶梯)
+注意：
+- 显示的阶梯数量和最终显示的数量完全由销售价格组配置决定
+- 其他载入的阶梯（50个、200个）被忽略
+```
+**两种类型的比较：**
+| 比较项 | ladderType = 1 (旧逻辑) | ladderType = 2 (新逻辑) |
+|-------|------------------------|------------------------|
+| 阶梯来源 | 基于载入的阶梯 | 基于销售价格组配置的阶梯 |
+| 阶梯数量 | 载入的阶梯数量 | 销售价格组配置的阶梯数量 |
+| 利润系数取值 | 取向后值 | 直接取值 |
+| 适用场景 | 遵循供应商载入的阶梯配置 | 统一产品阶梯显示格式 |
+---
+#### B. 代购供应商（supplier_id != 17）
+**流程说明：**
+1. **获取三个系数：**
+   **A. 折扣系数（`GetDiscountRatio`）：**
+   - **数据来源**：Redis `magic_cube_channel_discount_daigou`
+   - **适用对象**：代购供应商（supplier_id != 17）
+   - **作用**：对供应商提供的原始采购价进行折扣调整
+   - **匹配逻辑**：与专营供应商相同，按优先级（商品名称 > 品牌 > 默认）匹配
+   - **典型值**：0.90 ~ 0.98（根据供应商合作折扣而定）
+   **B. 售价组系数（`GenerateLadderPrice` 或售价组配置）：**
+   - **作用**：在成本价基础上加上利润率
+   - **来源**：售价组配置的 `priceRatioList`
+   - **典型值**：1.05 ~ 1.20（5% ~ 20%利润）
+   **C. 供应商系数：**
+   - **作用**：供应商级别的额外加成（如有）
+2. **计算成本价（应用折扣系数）：**
+   ```
+   美金成本 = 原始采购价 × 折扣系数
+   人民币成本 = 原始采购价 × 汇率 × 关税 × 折扣系数
+   ```
+3. **计算售价（应用售价组系数）：**
+   ```
+   美金售价 = 美金成本 × 售价组系数
+   人民币售价 = 人民币成本 × 售价组系数
+   ```
+   **完整公式串联：**
+   ```
+   人民币售价 = 原始采购价 × 汇率 × 关税 × 折扣系数 × 售价组系数
+   美金售价 = 原始采购价 × 折扣系数 × 售价组系数
+   ```
+**特殊供应商说明：**
+- **MRO（1688）**：只有人民币价格，直接作为成本价
+- **Digikey（7）**：可能同时有人民币和美金价格
+**价格计算示例：**
+```
+原始采购价：$100
+折扣系数：0.95
+售价组系数：1.15（15%利润）
+汇率：7.2
+关税：1.13
+计算过程：
+美金成本 = $100 × 0.95 = $95
+美金售价 = $95 × 1.15 = $109.25
+人民币成本 = $100 × 7.2 × 1.13 × 0.95 = ￥772.2
+人民币售价 = ￥772.2 × 1.15 = ￥888.03
+```
+### 第二步：生成自定义价格（getCustomPriceList）
+**业务场景：**
+除了标准售价外，还需要展示会员价、企业价等多种价格。
+**流程说明：**
+1. 根据组织ID从Redis获取自定义价格规则
+2. 每条规则包含：价格名称（如"会员价"）+ 利润比例（如10%）
+3. 在标准售价基础上，应用不同的利润率，生成多套阶梯价
+**举个栗子：**
+```
+标准售价阶梯：
+- 1个：￥100
+- 10个：￥95
+- 100个：￥90
+自定义价格配置：
+- 会员价：利润10%
+- 企业价：利润5%
+生成结果：
+会员价阶梯：
+- 1个：￥100 × 1.10 = ￥110
+- 10个：￥95 × 1.10 = ￥104.5
+- 100个：￥90 × 1.10 = ￥99
+企业价阶梯：
+- 1个：￥100 × 1.05 = ￥105
+- 10个：￥95 × 1.05 = ￥99.75
+- 100个：￥90 × 1.05 = ￥94.5
+```
+### 第三步：应用活动价格（GetActivityPrice）
+**业务场景：**
+商品参与促销活动时，需要计算活动价并展示给用户。
+**核心判断条件（同时满足才计算活动价）：**
+1. `GoodsType`：商品类型为联营(1)、专卖(2)或寄售(6)
+2. `AcType > 1`：活动类型大于1（表示有活动）
+3. `Ratio > 0`：活动折扣比例大于0
+**字段说明：**
+- `AcType`：活动类型（1=无活动，2=特价，3=限时折扣，4=直接覆盖原价）
+- `Ratio`：人民币活动折扣比例（如90表示9折）
+- `RatioUs`：美金活动折扣比例
+---
+#### 活动价计算方式
+**计算公式：**
+```
+人民币活动价 = 阶梯售价 × (Ratio / 100)
+美金活动价 = 阶梯售价 × (RatioUs / 100)
+```
+**不同组织的精度处理：**
+- **猎芯（OrgId = 1）**：保留4位小数
+- **爱智/华云（OrgId = 3）**：保留整数（人民币）、4位小数（美金）
+---
+#### 供应商类型差异处理
+**A. 专营供应商（supplier_id = 17）**
+针对爱智组织的特殊处理：
+- 当 `OrgId == 3` 时，所有阶梯的人民币活动价都基于**第一个阶梯的售价**计算
+- 美金活动价按各阶梯自身售价计算
+```
+示例：
+阶梯1：￥100，阶梯2：￥90，阶梯3：￥85
+Ratio = 90（9折）
+人民币活动价计算：
+- 阶梯1：￥100 × 0.9 = ￥90
+- 阶梯2：￥100 × 0.9 = ￥90  ← 注意：也是基于阶梯1的价格
+- 阶梯3：￥100 × 0.9 = ￥90  ← 注意：也是基于阶梯1的价格
+美金活动价计算（各阶梯独立）：
+- 阶梯1：$15 × 0.9 = $13.5
+- 阶梯2：$14 × 0.9 = $12.6
+- 阶梯3：$13 × 0.9 = $11.7
+```
+**B. 代购供应商（supplier_id ≠ 17）**
+所有阶梯的活动价都基于**各阶梯自身的售价**计算：
+```
+示例：
+阶梯1：￥100，阶梯2：￥90，阶梯3：￥85
+Ratio = 90（9折）
+人民币活动价：
+- 阶梯1：￥100 × 0.9 = ￥90
+- 阶梯2：￥90 × 0.9 = ￥81
+- 阶梯3：￥85 × 0.9 = ￥76.5
+```
+---
+#### 特殊活动类型处理（AcType = 4）
+当 `AcType == 4` 时，表示**直接覆盖原价**：
+1. 将第一个阶梯的活动价**直接设为新的原价**（`PriceCn = PriceAc`）
+2. 重置 `AcType = 0`，不再显示活动标签
+**业务场景：** 某些活动不需要显示"活动价"标签，而是直接替换原价展示。
+---
+#### 活动价与原价相等的处理
+**为什么前两个阶梯活动价等于原价时不展示？**
+当第1或第2个阶梯的**活动价等于原价**时，系统不会展示活动价样式。
+**原因：**
+- 活动价有特殊的视觉样式（如红色标签、划线价等）
+- 如果价格和原价一样，但样式是活动样式，客户会感到困惑
+- 为避免误导，价格相同时保持原样，不显示活动标签
+```
+示例：
+阶梯1：原价￥100，活动价￥100（Ratio=100，无折扣）
+→ 不展示活动价，避免客户误以为有优惠
+阶梯2：原价￥90，活动价￥90
+→ 同样不展示活动价
+阶梯3：原价￥85，活动价￥76.5（Ratio=90，9折）
+→ 正常展示活动价
+```
+---
+#### 活动失效判断
+如果计算出的活动价都**小于等于0**，则判定活动失效：
+```go
+if priceAc <= 0 && priceAcUs <= 0 {
+    sku.AcType = 0  // 取消活动标记
+}
+```
+---
+#### 完整示例
+```
+商品信息：
+- 供应商ID：17（专营）
+- 商品类型：2（专卖）
+- 组织ID：1（猎芯）
+- AcType：3（限时折扣）
+- Ratio：85（85折）
+- RatioUs：85（85折）
+阶梯价（已计算完售价）：
+- 1个：￥100 / $15
+- 10个：￥90 / $13.5
+- 100个：￥85 / $12.75
+计算活动价：
+- 1个：￥100×0.85=￥85 / $15×0.85=$12.75
+- 10个：￥90×0.85=￥76.5 / $13.5×0.85=$11.475
+- 100个：￥85×0.85=￥72.25 / $12.75×0.85=$10.8375
+最终展示：
+- 原价：￥100（划线价）
+- 活动价：￥85（红色高亮）
+```
+---
+## 三、爱智/华云的价格生成流程
+爱智的价格逻辑比较复杂，因为需要兼容**历史遗留数据**和**新的价格体系**。
+### 第一步：判断是否为寄售商品
+**判断条件：** `source == 12`
+**处理逻辑：**
+- **是寄售商品**：直接跳过价格体系，使用上传的价格
+- **非寄售商品**：继续后续判断
+### 第二步：判断数据类型（老数据 vs 新数据）
+根据阶梯价的数量和格式，判断是老数据还是新数据：
+#### 情况A：老数据格式（直接展示，不走价格体系）
+**老数据的三种情况：**
+| 阶梯数量 | 第一个阶梯 | 数据说明 | 处理方式 |
+|---------|-----------|---------|---------|
+| 2个 | 数量≠0 | 旧版格式（标准价+企业价）| GetIEdgePrice处理 |
+| 3个 | 数量=0 | 新版格式（成本价+会员价+企业价）| GetIEdgePrice处理，删除成本价 |
+| 4个 | 数量=0 | 新版格式（成本+会员+企业+限价）| GetIEdgePrice处理，取中间两个 |
+**GetIEdgePrice处理逻辑：**
+1. **给每个阶梯添加价格名称：**
+   - 数量0 → "成本价"
+   - 数量1 → "标准价"
+   - 数量2 → "企业价"
+   - 数量3 → "销售限价"
+2. **过滤不需要展示的价格：**
+   - 3个阶梯时：删除第一个（成本价），只展示标准价+企业价
+   - 4个阶梯时：取中间两个（标准价+企业价）
+**举个栗子（3个阶梯）：**
+```
+上传的数据：
+- 数量0：￥50（成本价）
+- 数量1：￥100（标准价）
+- 数量2：￥80（企业价）
+处理后展示：
+- 数量1：标准价 ￥100
+- 数量2：企业价 ￥80
+成本价内部保留，前端不展示
+```
+#### 情况B：新数据格式（走价格体系）
+**判断条件：**
+- 阶梯数量为2
+- 第一个阶梯数量为0（即成本价）
+**处理流程：**
+1. **预处理阶梯价：**
+   如果同时有成本价和销售限价，去掉销售限价（因为走价格体系的前提是有成本价）
+   ```
+   原始：[成本价, 销售限价]
+   处理后：[成本价]
+   ```
+2. **走标准价格体系：**
+   和猎芯的流程一样：
+   - GetCoefficientAndPrice（基础价格计算）
+   - getCustomPriceList（生成自定义价格）
+3. **华云格式转换（transformIEdgeLadderPrice）：**
+   为了让华云的老系统能正常显示，需要将自定义价格转换成特定的格式：
+   ```
+   转换前（自定义价格）：
+   - 会员价：数量100，价格￥90
+   - 企业价：数量100，价格￥85
+   转换后（华云格式）：
+   - 数量1：标准价 ￥90
+   - 数量2：企业价 ￥85
+   ```
+### 第三步：应用活动价格
+和猎芯的活动价处理逻辑基本一致，但有以下特殊点：
+**1. 精度差异：**
+- 人民币活动价：保留**整数**（猎芯保留4位小数）
+- 美金活动价：保留4位小数（与猎芯相同）
+**2. 专营供应商的特殊处理（OrgId = 3）：**
+```go
+// 所有阶梯的人民币活动价都基于第一个阶梯的售价计算
+tempAcPrice = c.MyRound(c.MulFloat(sku.LadderPrice[0].PriceCn, sku.Ratio/100), 0)
+```
+**示例对比：**
+| 阶梯 | 原价 | 猎芯活动价 | 爱智活动价 |
+|-----|------|-----------|-----------|
+| 1个 | ￥100.50 | ￥90.4500 | ￥90 |
+| 10个 | ￥95.80 | ￥86.2200 | ￥90（基于阶梯1）|
+| 100个 | ￥90.30 | ￥81.2700 | ￥90（基于阶梯1）|
+**注：** 美金活动价两个组织都保留4位小数，计算方式相同。
+---
+## 四、特殊供应商的币种转换
+有些供应商存入"美金"字段的实际上不是美金，需要进行币种转换：
+| 供应商 | 原始币种 | 转换逻辑 |
+|-------|---------|---------|
+| Element14（6）| 港币 | 港币 → 人民币 → 美金 |
+| RS（21）| 人民币 | 人民币 → 美金 |
+| Buerklin（1676）| 欧元 | 欧元 → 人民币 → 美金 |
+**转换示例（Element14）：**
+```
+原始价格：100港币
+港币汇率：0.92（1港币 = 0.92人民币）
+美金汇率：7.2（1美金 = 7.2人民币）
+计算：
+人民币 = 100 × 0.92 = 92元
+美金 = 92 ÷ 7.2 = $12.78
+```
+---
+## 五、后续处理
+### 1. 自营成本价处理（GetCostForZiying）
+针对自营供应商的特殊成本价处理。
+### 2. 最小起订量校验
+```
+规则：最小起订量 ≥ 阶梯价的最小数量
+示例：
+- 商品设置的最小起订量：5个
+- 阶梯价最小数量：10个
+- 最终结果：最小起订量改为10个
+```
+---
+## 六、总结对比表
+| 组织 | 价格体系 | 主要特点 |
+|-----|---------|---------|
+| 猎芯（1）| 标准体系 | 通过系数计算价格，支持多种自定义价格 |
+| 爱智（3）| 兼容体系 | 需要判断数据版本，老数据直接展示，新数据走价格体系 |
+| 寄售商品 | 跳过体系 | 直接使用上传的价格 |
+---
+## 七、关键术语解释
+| 术语 | 说明 |
+|-----|------|
+| 阶梯价 | 不同采购数量对应的不同价格，数量越多单价越低 |
+| 成本价 | 采购成本，内部使用 |
+| 标准价 | 普通用户看到的售价 |
+| 会员价 | 会员用户专享价格 |
+| 企业价 | 企业客户专享价格 |
+| 折扣系数 | 对成本价的折扣比例 |
+| 售价组系数 | 不同利润档位 |
+| 最小起订量（MOQ）| 单次采购的最低数量要求 |
+---
+*文档编写时间：2025年4月*
--- a/model/ly_sku.go
+++ b/model/ly_sku.go
@@ -102,8 +102,9 @@ type LySku struct {
 	OnwayStock           int           `json:"onway_stock"`
 	CompareRatio         float64       `json:"compare_ratio"`
 	//兼容自营下单的字段,取成本价的第一个阶梯的人民币
-	Cost   float64 `json:"cost"`
+	Cost     float64 `json:"cost"`
-	CostUs float64 `json:"cost_us"`
+	CostUs   float64 `json:"cost_us"`
+	IsZiying int     `json:"is_ziying"`
 }
 type DiscountRatio struct {
@@ -287,6 +288,12 @@ func InitSkuData(sku string) (data LySku) {
 		data.Encoded = "10142-L"
 	}
+	//判断是否自营
+	data.IsZiying = 0
+	if supplierId == 17 && (data.Canal == "L0018319" || data.Canal == "L0018562" || data.Canal == "L0003270") {
+		data.IsZiying = 1
+	}
 	cpTime := gjson.Get(sku, "cp_time").Int()
 	data.CpTime = cpTime

--- a/service/service_ly.go
+++ b/service/service_ly.go
@@ -266,8 +266,6 @@ func (ls *LyService) LyGoodsDetail(ctx context.Context, params RequestParams, go
 			sku = priceService.GetActivityPrice(sku)
 		}
-		// sku = priceService.GetComparePrice(sku)
 		sku = priceService.GetCostForZiying(sku)
 		//仅提供价格和库存
@@ -327,6 +325,7 @@ func (ls *LyService) LyGoodsDetail(ctx context.Context, params RequestParams, go
 		//获取关税以及价格转换
 		sku = ls.GetTariffAndPrice(sku)
+		sku = priceService.GetComparePrice(sku)
 		//获取新的限制库存信息
 		has, limitStock := ls.getLimitStock(sku.GoodsId)
 		if has {

--- a/service/service_price.go
+++ b/service/service_price.go
@@ -932,6 +932,7 @@ func (ps *PriceService) GetActivityPrice(sku model.LySku) model.LySku {
 // compare_price_ratio
 func (ps *PriceService) GetComparePrice(sku model.LySku) model.LySku {
 	redisCon := gredis.Conn("default_r")
+	defer redisCon.Close()
 	//判断是否存在
 	compareData, _ := redis.String(redisCon.Do("HGET", "compare_price_ratio", sku.GoodsId))
 	if compareData == "" {
@@ -943,7 +944,7 @@ func (ps *PriceService) GetComparePrice(sku model.LySku) model.LySku {
 	ladderPrice := sku.LadderPrice
 	for index, ladder := range ladderPrice {
-		if priceLimitOn == 2 && ladder.PriceAc != 0 {
+		if priceLimitOn == 1 && ladder.PriceAc != 0 {
 			ladder.PriceAc = c.MyRound(c.MulFloat(ladder.PriceAc, ratio), 4)
 		} else {
 			ladder.PriceCn = c.MyRound(c.MulFloat(ladder.PriceCn, ratio), 4)

--- a/service/service_tags.go
+++ b/service/service_tags.go
@@ -77,6 +77,18 @@ func (ts *TagsService) GetLyTags(sku model.LySku) (goodsTags model.GoodsTag) {
 		goodsTags.GoodsLabelName = goodsLabel
 		goodsTags.GoodsLabel = goodsLabelType
+		//系统打的标签
+		systemTagArr := gjson.Get(goodsTagsStr, "tags").Array()
+		if len(systemTagArr) > 0 {
+			for _, tagIdResult := range systemTagArr {
+				tagId := int(tagIdResult.Int())
+				tags = append(tags, tagId)
+				if tagName, ok := vars.GoodsTags[tagId]; ok {
+					tagNames = append(tagNames, tagName)
+				}
+			}
+		}
 		//自定义标签
 		customerTag := gjson.Get(goodsTagsStr, "customer_tag").String()
 		if customerTag != "" {

--- a/service/service_zy.go
+++ b/service/service_zy.go
@@ -185,8 +185,8 @@ func (qs *ZiyingService) ZyGoodsDetail(ctx context.Context, params RequestParams
 		A.Set("stock", 0)                         //默认库存为0
 		dbStock := gjson.Get(info, "stock").Int() //当前db库存
 		if dbStock > 0 {
-			lockStock := qs.skuLockNum(&redisConn, goodsId) //当前锁库库存
+			lockStock := SkuLockNum(goodsId) //当前锁库库存
-			stockG := dbStock - lockStock                   //当前可购买库存
+			stockG := dbStock - lockStock    //当前可购买库存
 			if stockG > 0 {
 				A.Set("actual_stock", dbStock) //锁定库存
 				A.Set("stock", stockG)
@@ -367,6 +367,8 @@ func (qs *ZiyingService) ZyGoodsDetail(ctx context.Context, params RequestParams
 			Stock:         gconv.Int64(nowstock),
 			AbilityLevel:  2,
 			StandardBrand: standardBrand,
+			Moq:           moq,
+			Mpq:           mpq,
 			GoodsName:     gjson.Get(info, "goods_name").String(),
 			SpuId:         gconv.String(spuId),
 			ClassID1:      gconv.Int(spuClassId1),

--- a/service/service_zy_common.go
+++ b/service/service_zy_common.go
@@ -4,6 +4,7 @@ import (
 	"go_sku_server/model"
 	"go_sku_server/pkg/common"
 	"go_sku_server/pkg/gredis"
+	"strconv"
 	"github.com/gomodule/redigo/redis"
 	"github.com/iancoleman/orderedmap"
@@ -12,8 +13,21 @@ import (
 )
 //自营公共函数类
+/*
+获取自营锁库数量
+*/
+func SkuLockNum(goodsId string) int64 {
+	//获取总锁库库存
+	redisCon := gredis.Conn("spu")
+	defer redisCon.Close()
+	stockStr, _ := redis.String(redisCon.Do("HGET", "sku_lock_stock", goodsId))
+	lockStock, _ := strconv.ParseInt(stockStr, 10, 64)
+	return lockStock
+}
 /*
- 计算单个sku总锁库数量
+计算单个sku总锁库数量-废弃
 */
 func (qs *ZiyingService) skuLockNum(c *redis.Conn, goodsId string) int64 {
 	reply, err := redis.Values((*c).Do("hvals", "Self_StockLock"+goodsId))