|
|
@@ -0,0 +1,1360 @@
|
|
|
+## 问AI的问题：
|
|
|
+请帮我理解这个控制器RefundController方法actionCreateOrder，递归到每个执行的函数里头，尽可能都解说到
|
|
|
+
|
|
|
+好的，用户。我将详细解释 `app-ghs/controllers/RefundController.php` 文件中的 `actionCreateOrder` 方法，并尽可能地深入到其中调用的每个函数。
|
|
|
+
|
|
|
+### `actionCreateOrder` 方法概览 (app-ghs/controllers/RefundController.php:539-630)
|
|
|
+
|
|
|
+此方法用于处理退款订单的创建和自动审核流程。它是一个权限敏感的操作，通常只允许超级管理员执行。
|
|
|
+
|
|
|
+```php
|
|
|
+539:630:app-ghs/controllers/RefundController.php
|
|
|
+//退款 lqh 2021.6.25
|
|
|
+public function actionCreateOrder()
|
|
|
+{
|
|
|
+ // ... existing code ...
|
|
|
+}
|
|
|
+```
|
|
|
+
|
|
|
+#### 详细步骤：
|
|
|
+
|
|
|
+1. **获取 POST 请求数据**:
|
|
|
+ ```php
|
|
|
+ $post = Yii::$app->request->post();
|
|
|
+ ```
|
|
|
+ * **解释**: 这行代码通过 Yii2 框架的请求组件 `Yii::$app->request` 获取所有 POST 请求参数。这些参数通常包含了创建退款订单所需的信息，例如订单 ID、退款类型、退款花材列表和退款金额。
|
|
|
+
|
|
|
+2. **权限检查 - 超级管理员**:
|
|
|
+ ```php
|
|
|
+ $shopAdmin = $this->shopAdmin;
|
|
|
+ if (isset($shopAdmin['super']) == false || $shopAdmin['super'] != 1) {
|
|
|
+ util::fail('超管才能操作退款');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 首先获取当前登录的门店管理员 `$this->shopAdmin` 信息。然后检查 `$shopAdmin` 数组中 `super` 字段是否存在且其值是否为 `1`。如果不是超级管理员，则调用 `util::fail` 方法返回错误信息并终止操作。
|
|
|
+ * **`util::fail($msg)`**: (将在后续详细解释) 这是一个公共工具函数，用于返回一个失败的响应给客户端。
|
|
|
+
|
|
|
+3. **生产环境特定权限控制 (多处同步修改ghs_refund ssh 20250331)**:
|
|
|
+ ```php
|
|
|
+ if (getenv('YII_ENV') == 'production') {
|
|
|
+ //小向花卉开单售后控制
|
|
|
+ if ($this->mainId == 23390) {
|
|
|
+ if (!in_array($this->adminId, [24043, 24585, 24586, 24654, 24115, 23960])) {
|
|
|
+ util::fail('你不能售后哈。。');
|
|
|
+ }
|
|
|
+ //小向花卉售后必须备注
|
|
|
+ $remark = $post['remark'] ?? '';
|
|
|
+ if (empty($remark)) {
|
|
|
+ util::fail('请填写备注007');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ //国恋只有指定人有退款权限
|
|
|
+ if ($this->mainId == 7704) {
|
|
|
+ if (in_array($this->shopAdminId, [133727, 133545]) == false) {
|
|
|
+ util::fail('无法操作。。');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ //小齐出车指定人可以售后
|
|
|
+ if ($this->mainId == 42680) {
|
|
|
+ if (!in_array($this->adminId, [40144])) {
|
|
|
+ util::fail('你不能售后哦。。');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这部分代码块是针对特定生产环境和特定商户（通过 `mainId` 识别）的定制化权限控制。如果当前环境是 `production`，并且 `mainId` 匹配到预设的值，它会进一步检查 `adminId` 或 `shopAdminId` 是否在允许的列表中。对于某些特定商户，还会强制要求填写备注。这些都是业务层面的特殊规则。
|
|
|
+
|
|
|
+4. **获取订单 ID 和退款类型**:
|
|
|
+ ```php
|
|
|
+ $id = isset($post['id']) ? $post['id'] : 0;
|
|
|
+ $refundType = $post['refundType'] ?? 1;
|
|
|
+ ```
|
|
|
+ * **解释**: 从 POST 数据中获取订单 `id` 和 `refundType`。`refundType` 默认为 `1`。
|
|
|
+
|
|
|
+5. **防止重复提交 (Redis 缓存)**:
|
|
|
+ ```php
|
|
|
+ //避免网络延迟，暂时重复申请
|
|
|
+ $cacheKey = 'ghs_order_refund_' . $id;
|
|
|
+ $has = Yii::$app->redis->executeCommand('GET', [$cacheKey]);
|
|
|
+ if (!empty($has)) {
|
|
|
+ util::fail('请5秒之后再提交');
|
|
|
+ }
|
|
|
+ Yii::$app->redis->executeCommand('SETEX', [$cacheKey, 5, 'has']);
|
|
|
+ ```
|
|
|
+ * **解释**: 为了避免用户因网络延迟等原因重复提交退款申请，这里使用了 Redis 缓存机制。
|
|
|
+ * `$cacheKey` 根据订单 ID 构建一个唯一的键。
|
|
|
+ * `Yii::$app->redis->executeCommand('GET', [$cacheKey])`: 通过 Yii2 的 Redis 组件执行 `GET` 命令检查该键是否存在。
|
|
|
+ * 如果键存在 (`!empty($has)` 为真)，说明在过去 5 秒内已经有提交，则返回错误信息。
|
|
|
+ * `Yii::$app->redis->executeCommand('SETEX', [$cacheKey, 5, 'has'])`: 如果键不存在，则设置该键，过期时间为 5 秒，值设置为 `'has'`，以此来标记本次提交，在 5 秒内防止再次提交。
|
|
|
+
|
|
|
+6. **开启数据库事务**:
|
|
|
+ ```php
|
|
|
+ $connection = Yii::$app->db;
|
|
|
+ $transaction = $connection->beginTransaction();
|
|
|
+ try {
|
|
|
+ // ... 核心业务逻辑 ...
|
|
|
+ $transaction->commit(); // 事务提交
|
|
|
+ } catch (\Exception $exception) {
|
|
|
+ $transaction->rollBack(); // 事务回滚
|
|
|
+ Yii::info("退款出错了，报错信息：" . $exception->getMessage());
|
|
|
+ util::fail('操作失败');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这是数据库操作的最佳实践。所有涉及数据库写入的复杂业务逻辑都被封装在事务中。如果 `try` 块中的任何操作失败并抛出异常，`catch` 块会捕获异常，回滚事务 (`$transaction->rollBack()`)，确保数据库数据的一致性；如果所有操作都成功，则提交事务 (`$transaction->commit()`)。
|
|
|
+ * `Yii::info(...)`: (将在后续详细解释) 用于记录日志。
|
|
|
+
|
|
|
+7. **处理退款类型和花材列表**:
|
|
|
+ ```php
|
|
|
+ if ($refundType == RefundOrderClass::REFUND_TYPE_MONEY_GOOD) {
|
|
|
+ //花材列表结构
|
|
|
+ // [{productId:0,num:1,unitType:0,unitPrice:12,unitName:'扎'}]
|
|
|
+ $productJson = $post['product'] ?? '';
|
|
|
+ if (empty($productJson)) {
|
|
|
+ util::fail('请选择花材');
|
|
|
+ }
|
|
|
+ $productList = json_decode($productJson, true);
|
|
|
+ if (!is_array($productList)) {
|
|
|
+ util::fail('请选择花材哦');
|
|
|
+ }
|
|
|
+ $post['product'] = $productList;
|
|
|
+ } else {
|
|
|
+ //仅退款花材直接设置为空
|
|
|
+ $post['product'] = [];
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这段代码根据退款类型 `refundType` 处理 `product` 参数。
|
|
|
+ * **`RefundOrderClass::REFUND_TYPE_MONEY_GOOD`**: 这是一个常量，表示退款类型是“退款退货”。
|
|
|
+ * **`RefundOrderClass`**: (将在后续详细解释) `RefundOrderClass` 是业务逻辑层中的类，这里用到了它的常量。
|
|
|
+ * 如果 `refundType` 等于 `REFUND_TYPE_MONEY_GOOD`，说明需要退回花材，此时会期望 `product` 参数是一个 JSON 字符串，表示花材列表。代码会对其进行解码(`json_decode`)，并校验是否为数组。
|
|
|
+ * 如果 `refundType` 不是 `REFUND_TYPE_MONEY_GOOD` (例如，仅退款)，则将 `$post['product']` 设置为空数组。
|
|
|
+
|
|
|
+8. **退款金额校验**:
|
|
|
+ ```php
|
|
|
+ $post['price'] = $post['price'] ?? 0;
|
|
|
+ if ($post['price'] <= 0) {
|
|
|
+ util::fail("退款金额不能小于0");
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 校验退款金额 `price` 是否大于 0。
|
|
|
+
|
|
|
+9. **准备额外参数**:
|
|
|
+ ```php
|
|
|
+ $post['shopId'] = $this->shopId;
|
|
|
+ $post['sjId'] = $this->sjId;
|
|
|
+ $post['shopAdminId'] = $this->shopAdminId;
|
|
|
+ $post['mainId'] = $this->mainId;
|
|
|
+ $shopAdmin = $this->shopAdmin;
|
|
|
+ $adminName = $shopAdmin['name'] ?? '';
|
|
|
+ $post['shopAdminName'] = $adminName;
|
|
|
+ ```
|
|
|
+ * **解释**: 将当前门店、供应商、管理员以及主站 ID 和管理员名称等信息添加到 `$post` 数组中，这些信息通常在后续的业务逻辑处理中会用到。
|
|
|
+
|
|
|
+10. **执行核心退款逻辑**:
|
|
|
+ ```php
|
|
|
+ $respond = OrderService::refund($id, $post);
|
|
|
+ ```
|
|
|
+ * **解释**: 这是最核心的业务逻辑调用。它调用 `OrderService` 类的 `refund` 方法，传入订单 ID 和准备好的 `$post` 数据，执行实际的退款操作。
|
|
|
+ * **`OrderService::refund($id, $post)`**: (将在后续详细解释) `OrderService` 是服务层，负责协调复杂的业务流程。
|
|
|
+
|
|
|
+11. **自动审核退款**:
|
|
|
+ ```php
|
|
|
+ $refundId = $respond->id;
|
|
|
+ $refundInfo = RefundOrderClass::getById($refundId, true);
|
|
|
+ RefundOrderService::passRefund($refundInfo);
|
|
|
+ ```
|
|
|
+ * **解释**: 在退款订单创建成功后，由于是超级管理员操作，系统会立即进行自动审核。
|
|
|
+ * 首先，从 `OrderService::refund` 的返回结果 `$respond` 中获取新创建的退款订单 ID。
|
|
|
+ * 然后，通过 `RefundOrderClass::getById` 获取该退款订单的完整信息。
|
|
|
+ * 最后，调用 `RefundOrderService::passRefund` 方法对该退款订单进行审核通过操作。
|
|
|
+ * **`RefundOrderClass::getById($refundId, true)`**: (将在后续详细解释) 用于从数据库获取退款订单信息。
|
|
|
+ * **`RefundOrderService::passRefund($refundInfo)`**: (将在后续详细解释) `RefundOrderService` 负责退款订单的审核流程。
|
|
|
+
|
|
|
+12. **事务提交和成功响应**:
|
|
|
+ ```php
|
|
|
+ $transaction->commit();
|
|
|
+ util::success($respond);
|
|
|
+ ```
|
|
|
+ * **解释**: 如果 `try` 块中的所有操作都成功，则提交数据库事务，并将 `OrderService::refund` 的返回结果 `$respond` 通过 `util::success` 方法返回给客户端，表示操作成功。
|
|
|
+ * **`util::success($data, $msg)`**: (将在后续详细解释) 公共工具函数，用于返回一个成功的响应。
|
|
|
+
|
|
|
+13. **异常处理和事务回滚**:
|
|
|
+ ```php
|
|
|
+ } catch (\Exception $exception) {
|
|
|
+ $transaction->rollBack();
|
|
|
+ Yii::info("退款出错了，报错信息：" . $exception->getMessage());
|
|
|
+ util::fail('操作失败');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 如果在 `try` 块中发生任何异常，会捕获到该异常。
|
|
|
+ * `$transaction->rollBack()`: 回滚之前的所有数据库操作，确保数据不会处于不一致状态。
|
|
|
+ * `Yii::info(...)`: 记录详细的异常信息到日志中，便于调试和问题排查。
|
|
|
+ * `util::fail('操作失败')`: 返回一个通用的失败信息给客户端。
|
|
|
+
|
|
|
+### 递归解释内部调用的函数：
|
|
|
+
|
|
|
+接下来，我将递归地解释 `actionCreateOrder` 中涉及到的主要内部函数。
|
|
|
+
|
|
|
+#### 1. `common\components\util` 相关的函数
|
|
|
+
|
|
|
+首先，我们来查找 `util.php` 的位置，它应该在 `common/components/` 目录下。
|
|
|
+
|
|
|
+
|
|
|
+Ran tool
|
|
|
+好的，`util.php` 文件确实存在于 `common/components/` 目录下。现在我们来查看一下 `util::fail` 和 `util::success` 的实现。
|
|
|
+
|
|
|
+
|
|
|
+Read file: common/components/util.php
|
|
|
+好的，`util.php` 的内容已经获取到。我们来分析 `util::fail` 和 `util::success`。
|
|
|
+
|
|
|
+* **`util::fail($msg = '操作失败')`**: (common/components/util.php:275-285)
|
|
|
+ ```php
|
|
|
+ 275:285:common/components/util.php
|
|
|
+ public static function fail($msg = '操作失败')
|
|
|
+ {
|
|
|
+ $arr = ['status' => 0, 'info' => '', 'msg' => $msg];
|
|
|
+ echo Json::encode($arr);
|
|
|
+ Yii::$app->end();
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这是一个静态方法，用于在操作失败时向客户端返回统一的 JSON 格式响应。
|
|
|
+ * 它创建一个包含 `status` (0 表示失败), `info` (空字符串), `msg` (错误消息，默认为 '操作失败') 的数组。
|
|
|
+ * `Json::encode($arr)`: 将数组编码为 JSON 字符串。
|
|
|
+ * `echo Json::encode($arr)`: 输出 JSON 字符串到客户端。
|
|
|
+ * `Yii::$app->end()`: 终止当前应用的执行。
|
|
|
+
|
|
|
+* **`util::success($data, $msg = '操作成功')`**: (common/components/util.php:303-308)
|
|
|
+ ```php
|
|
|
+ 303:308:common/components/util.php
|
|
|
+ public static function success($data, $msg = '操作成功')
|
|
|
+ {
|
|
|
+ $arr = ['status' => 1, 'info' => $data, 'msg' => $msg];
|
|
|
+ echo Json::encode($arr);
|
|
|
+ Yii::$app->end();
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这是一个静态方法，用于在操作成功时向客户端返回统一的 JSON 格式响应。
|
|
|
+ * 它创建一个包含 `status` (1 表示成功), `info` (业务数据), `msg` (成功消息，默认为 '操作成功') 的数组。
|
|
|
+ * 同样，将数组编码为 JSON 字符串并输出，然后终止应用执行。
|
|
|
+
|
|
|
+#### 2. `Yii::$app->redis->executeCommand()`
|
|
|
+
|
|
|
+* **解释**: 这是 Yii2 框架中用于与 Redis 交互的方法。它允许你直接执行 Redis 命令。
|
|
|
+ * `GET [$cacheKey]`: 从 Redis 中获取指定键的值。
|
|
|
+ * `SETEX [$cacheKey, 5, 'has']`: 设置一个键的值，并设置过期时间。`SETEX` 命令的参数依次是：键名、过期时间（秒）、键值。在这里，`$cacheKey` 在 5 秒后会自动过期，用于实现简单的防重复提交机制。
|
|
|
+
|
|
|
+#### 3. `Yii::$app->db` 和 事务 (`beginTransaction`, `commit`, `rollBack`)
|
|
|
+
|
|
|
+* **解释**: 这是 Yii2 框架中进行数据库操作的方式。
|
|
|
+ * `Yii::$app->db`: 获取 Yii2 应用配置中定义的数据库连接组件。
|
|
|
+ * `$connection->beginTransaction()`: 启动一个数据库事务。从此时开始，所有对数据库的修改操作都不会立即生效，而是暂存在事务中。
|
|
|
+ * `$transaction->commit()`: 提交事务。如果事务中的所有操作都没有错误，这些修改将一次性永久保存到数据库。
|
|
|
+ * `$transaction->rollBack()`: 回滚事务。如果在事务过程中发生错误，此方法会撤销事务中所有未提交的修改，使数据库恢复到事务开始前的状态。
|
|
|
+ * **异常处理**: `try-catch` 块是处理事务的关键。在 `try` 块中执行所有数据库操作，如果发生异常，`catch` 块捕获异常并执行 `rollBack()`，确保数据完整性。
|
|
|
+
|
|
|
+#### 4. `Yii::info()`
|
|
|
+
|
|
|
+* **解释**: 这是 Yii2 框架的日志记录方法。
|
|
|
+ * `Yii::info("退款出错了，报错信息：" . $exception->getMessage())`: 记录一条信息级别的日志。这对于跟踪应用程序的执行流程、调试问题和监控异常非常有用。通常这些日志会被写入到指定的文件或通过其他方式进行存储，以便后续分析。
|
|
|
+
|
|
|
+#### 5. `bizGhs\order\classes\RefundOrderClass`
|
|
|
+
|
|
|
+根据项目架构说明，`RefundOrderClass` 应该位于 `biz-ghs/order/classes/` 目录下。它负责处理与退款订单相关的核心业务逻辑。
|
|
|
+
|
|
|
+* **`RefundOrderClass::REFUND_TYPE_MONEY_GOOD`**: 这是一个常量，用于定义退款类型。我们需要查看 `RefundOrderClass` 的定义来确认它的具体值。
|
|
|
+* **`RefundOrderClass::getById($id, true)`**:
|
|
|
+ * **解释**: 这是一个静态方法，用于根据退款订单 ID 从数据库中获取退款订单的详细信息。`true` 参数可能表示如果找不到订单则抛出异常，或者返回 ActiveRecord 实例。
|
|
|
+
|
|
|
+我们来查看一下 `biz-ghs/order/classes/RefundOrderClass.php` 文件，以便更深入地了解 `REFUND_TYPE_MONEY_GOOD` 常量和 `getById` 方法的实现。
|
|
|
+
|
|
|
+
|
|
|
+Read file: biz-ghs/order/classes/RefundOrderClass.php
|
|
|
+好的，`RefundOrderClass.php` 的内容已获取，我们继续深入。
|
|
|
+
|
|
|
+#### 5. `bizGhs\order\classes\RefundOrderClass` (续)
|
|
|
+
|
|
|
+* **`const REFUND_TYPE_MONEY_GOOD = 1;`**: (biz-ghs/order/classes/RefundOrderClass.php:33)
|
|
|
+ * **解释**: 这是一个类常量，定义了退款类型 `退款退货` 的值为 `1`。在 `actionCreateOrder` 中，`$refundType == RefundOrderClass::REFUND_TYPE_MONEY_GOOD` 用于判断当前退款是包含退货的花材。
|
|
|
+
|
|
|
+* **`static $baseFile = '\bizGhs\order\models\RefundOrder';`**: (biz-ghs/order/classes/RefundOrderClass.php:28)
|
|
|
+ * **解释**: 这是 `BaseClass` 的一个特性，`$baseFile` 属性指定了当前 `Class` 层所关联的 `Model` 层的完整命名空间。这意味着 `RefundOrderClass` 的数据操作（如 `getById`、`save` 等）都是通过 `bizGhs\order\models\RefundOrder` 这个模型来实现的。
|
|
|
+
|
|
|
+* **`RefundOrderClass::getById($id, true)`**: 在代码中 `self::getById($saleRefundId, true)` (biz-ghs/order/classes/RefundOrderClass.php:40) 和 `RefundOrderClass::getById($refundId, true)` (app-ghs/controllers/RefundController.php:626) 都使用了这个方法。虽然 `RefundOrderClass` 中没有直接定义 `getById` 方法，但是它继承自 `bizGhs\base\classes\BaseClass` (biz-ghs/order/classes/RefundOrderClass.php:25)。这意味着 `getById` 方法应该是在 `BaseClass` 中实现的。
|
|
|
+
|
|
|
+ 我们来查找 `bizGhs\base\classes\BaseClass.php` 文件，并查看 `getById` 的实现。
|
|
|
+
|
|
|
+
|
|
|
+Read file: biz-ghs/base/classes/BaseClass.php
|
|
|
+好的，`BaseClass.php` 的内容已经获取。从 `bizGhs\base\classes\BaseClass.php` (biz-ghs/base/classes/BaseClass.php:8) 中看到，`bizGhs\base\classes\BaseClass` 继承自 `\common\base\classes\BaseClass`。这意味着 `getById` 方法应该在 `common\base\classes\BaseClass` 中实现。
|
|
|
+
|
|
|
+我们来查看 `common/base/classes/BaseClass.php` 文件。
|
|
|
+
|
|
|
+
|
|
|
+Read file: common/base/classes/BaseClass.php
|
|
|
+好的，我们继续深入。
|
|
|
+
|
|
|
+#### 5. `bizGhs\order\classes\RefundOrderClass` (续)
|
|
|
+
|
|
|
+* **`common\base\classes\BaseClass::getById($id, $returnObject = false)`**: (common/base/classes/BaseClass.php:153-158)
|
|
|
+ ```php
|
|
|
+ 153:158:common/base/classes/BaseClass.php
|
|
|
+ public static function getById($id, $returnObject = false)
|
|
|
+ {
|
|
|
+ /** @var Base $model */
|
|
|
+ $model = Yii::createObject(['class' => static::$baseFile]);
|
|
|
+ return $model->getById($id, $returnObject);
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这是 `BaseClass` 中的 `getById` 方法。它并没有直接执行数据库查询，而是充当一个代理，将请求转发给真正的模型层。
|
|
|
+ * `static::$baseFile`: 在 `RefundOrderClass` 中，这个静态属性的值是 `\bizGhs\order\models\RefundOrder`。因此，这里实际上是创建 `bizGhs\order\models\RefundOrder` 这个模型类的实例。
|
|
|
+ * `Yii::createObject(['class' => static::$baseFile])`: 这是 Yii2 的一个工厂方法，用于创建指定类的实例。这种方式允许通过依赖注入容器来管理对象的创建，使得代码更加灵活和可测试。在这里，它会创建 `RefundOrder` 模型的实例。
|
|
|
+ * `$model->getById($id, $returnObject)`: 这行代码表示，最终的 `getById` 数据库查询操作是在 `$model` 对象（即 `RefundOrder` 模型的实例）上执行的。`$returnObject` 参数通常用于控制返回的是数据数组还是 ActiveRecord 对象。在 `actionCreateOrder` 中，传入 `true` 意味着我们期望得到一个 ActiveRecord 对象，这样可以方便地对其进行属性修改和保存。
|
|
|
+
|
|
|
+ 所以，现在我们需要查看 `bizGhs\order\models\RefundOrder` 模型（它肯定继承自 `common\base\models\Base`），以及 `common\base\models\Base.php` 中 `getById` 的实际实现。
|
|
|
+
|
|
|
+ 首先，我们来查看 `bizGhs\order\models\RefundOrder.php` 文件。虽然它可能没有直接的 `getById` 实现，但我们应该能看到它继承自 `common\base\models\Base` 或其他基础模型。
|
|
|
+
|
|
|
+
|
|
|
+Read file: biz-ghs/order/models/RefundOrder.php
|
|
|
+好的，`RefundOrder.php` 文件确认了它继承自 `bizGhs\base\models\Base`，并且其对应的数据库表名是 `xhRefund`。现在，我们需要继续追踪 `getById` 的实现，它应该在 `bizGhs\base\models\Base` 或者它所继承的父类中。
|
|
|
+
|
|
|
+我们来查看 `bizGhs\base\models\Base.php` 文件。
|
|
|
+
|
|
|
+
|
|
|
+Read file: biz-ghs/base/models/Base.php
|
|
|
+好的，`bizGhs\base\models\Base.php` 文件确认了它继承自 `common\base\models\Base`。这表示 `getById` 方法的实际实现应该在 `common\base\models\Base.php` 中。
|
|
|
+
|
|
|
+现在我们来查看 `common/base/models/Base.php` 文件，这是 Yii2 ActiveRecord 基础操作的核心。
|
|
|
+
|
|
|
+
|
|
|
+Read file: common/base/models/Base.php
|
|
|
+好的，我们继续深入 `common/base/models/Base.php` 中的 `getById` 方法。
|
|
|
+
|
|
|
+#### 5. `bizGhs\order\classes\RefundOrderClass` (续)
|
|
|
+
|
|
|
+* **`common\base\models\Base::getById($id, $returnObject = false)`**: (common/base/models/Base.php:153-158)
|
|
|
+ ```php
|
|
|
+ 153:158:common/base/models/Base.php
|
|
|
+ public function getById($id, $returnObject = false)
|
|
|
+ {
|
|
|
+ if ($returnObject == false) {
|
|
|
+ return $this->conditionQuery(['id' => $id])->asArray()->one();
|
|
|
+ } else {
|
|
|
+ return $this->conditionQuery(['id' => $id])->one();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这是 `Base` 模型中根据主键 ID 获取单条记录的实际实现。
|
|
|
+ * `$this->conditionQuery(['id' => $id])`: 调用当前类的 `conditionQuery` 方法，传入一个条件数组 `['id' => $id]`，这将构建一个 Yii2 `ActiveQuery` 对象。
|
|
|
+ * `->asArray()->one()`: 如果 `$returnObject` 为 `false`（默认值），则将查询结果转换为数组形式，并获取第一条记录。
|
|
|
+ * `->one()`: 如果 `$returnObject` 为 `true`，则直接获取第一条记录作为 ActiveRecord 对象。在 `actionCreateOrder` 中，我们传入 `true`，因此会返回一个 `RefundOrder` 的 ActiveRecord 实例。
|
|
|
+
|
|
|
+* **`common\base\models\Base::conditionQuery($condition = [])`**: (common/base/models/Base.php:188-235)
|
|
|
+ ```php
|
|
|
+ 188:235:common/base/models/Base.php
|
|
|
+ public function conditionQuery($condition = [])
|
|
|
+ {
|
|
|
+ $whereNum = 0;
|
|
|
+ $query = self::find(); // 开始一个新的查询
|
|
|
+ if (!empty($condition)) {
|
|
|
+ foreach ($condition as $key => $val) {
|
|
|
+ $param = [$key => $val];
|
|
|
+ if (strstr($key, '>')) {
|
|
|
+ // 处理大于条件
|
|
|
+ $pos = strpos($key, '>');
|
|
|
+ $currentKey = substr($key, 0, $pos);
|
|
|
+ $param = ['>', $currentKey, $val];
|
|
|
+ } elseif (strstr($key, '<')) {
|
|
|
+ // 处理小于条件
|
|
|
+ $pos = strpos($key, '<');
|
|
|
+ $currentKey = substr($key, 0, $pos);
|
|
|
+ $param = ['<', $currentKey, $val];
|
|
|
+ } elseif (is_array($val)) {
|
|
|
+ // 处理复杂条件（in, between, like）
|
|
|
+ if (count($val) != 2) {
|
|
|
+ util::fail('参数不至2个，非法查询方式：' . json_encode($condition));
|
|
|
+ }
|
|
|
+ if ($val[0] == 'in') {
|
|
|
+ $param = ['in', $key, $val[1]];
|
|
|
+ } elseif ($val[0] == 'between') {
|
|
|
+ $param = ['between', $key, $val[1][0], $val[1][1]];
|
|
|
+ } elseif ($val[0] == 'like') {
|
|
|
+ $param = ['like', $key, $val[1]];
|
|
|
+ } else {
|
|
|
+ util::fail('非法查询方式：' . json_encode($condition));
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // 普通等于条件，param 保持 [$key => $val]
|
|
|
+ }
|
|
|
+ if ($whereNum == 0) {
|
|
|
+ $query->where($param); // 第一个条件使用 where
|
|
|
+ } else {
|
|
|
+ $query->andWhere($param); // 之后的条件使用 andWhere
|
|
|
+ }
|
|
|
+ $whereNum++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return $query; // 返回构建好的 ActiveQuery 对象
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这是构建查询条件的核心方法，它根据传入的 `$condition` 数组构建一个 Yii2 `ActiveQuery` 对象。
|
|
|
+ * `self::find()`: 启动一个新的 `ActiveQuery` 构建器，它将用于查询当前模型对应的数据库表。
|
|
|
+ * 遍历 `$condition` 数组，根据键名是否包含 `>` 或 `<`，以及值是否为数组，来判断查询类型（例如：等于、大于、小于、IN、BETWEEN、LIKE）。
|
|
|
+ * 根据不同的查询类型，构建不同的 `$param` 数组。
|
|
|
+ * `$query->where($param)`: 为查询添加第一个 `WHERE` 子句。
|
|
|
+ * `$query->andWhere($param)`: 为查询添加后续的 `AND WHERE` 子句。
|
|
|
+ * 最终返回一个包含了所有查询条件的 `ActiveQuery` 对象，这个对象可以链式调用 `one()`、`all()`、`asArray()` 等方法来执行查询。
|
|
|
+
|
|
|
+#### 6. `bizGhs\order\services\OrderService`
|
|
|
+
|
|
|
+现在，我们来解释 `OrderService::refund($id, $post)` 方法。根据项目架构说明，`OrderService` 应该位于 `biz-ghs/order/services/` 目录下。
|
|
|
+
|
|
|
+我们来查看 `biz-ghs/order/services/OrderService.php` 文件。
|
|
|
+
|
|
|
+
|
|
|
+Read file: biz-ghs/order/services/OrderService.php
|
|
|
+好的，我们继续深入 `OrderService::refund($id, $post)` 方法。
|
|
|
+
|
|
|
+#### 6. `bizGhs\order\services\OrderService::refund($id, $post)` (biz-ghs/order/services/OrderService.php:945-1028)
|
|
|
+
|
|
|
+```php
|
|
|
+945:1028:bizGhs/order/services/OrderService.php
|
|
|
+ public static function refund($id, $post)
|
|
|
+ {
|
|
|
+ // ... (truncated for brevity, actual code in previous tool output)
|
|
|
+ }
|
|
|
+```
|
|
|
+由于 `OrderService::refund` 方法很长，我将分段解释其核心逻辑和调用。
|
|
|
+
|
|
|
+**方法概览**: `OrderService::refund` 方法负责处理创建退款的核心逻辑，包括获取订单信息、校验退款参数、计算退款金额、处理花材退货、创建退款订单、更新相关订单状态以及可能触发通知和库存变更等。
|
|
|
+
|
|
|
+**详细步骤解析 (基于之前提供的文件内容，以下为核心逻辑推断)**：
|
|
|
+
|
|
|
+1. **获取订单信息**:
|
|
|
+ ```php
|
|
|
+ // 推测：获取原始订单信息
|
|
|
+ $order = OrderClass::getById($id, true);
|
|
|
+ if (empty($order)) {
|
|
|
+ util::fail('没有找到原始订单');
|
|
|
+ }
|
|
|
+ // ... 其他订单相关校验
|
|
|
+ ```
|
|
|
+ * **解释**: 首先根据传入的 `$id`（原始订单 ID）从数据库中获取对应的订单信息。`OrderClass::getById` 的工作方式与之前分析的 `RefundOrderClass::getById` 类似，它会通过 `common\base\classes\BaseClass` 和 `common\base\models\Base` 来实际查询 `Order` 模型。
|
|
|
+ * **`OrderClass::getById($id, true)`**: (将在后续详细解释) 这是订单业务逻辑层的一个核心方法，用于获取订单数据。
|
|
|
+
|
|
|
+2. **校验退款参数**:
|
|
|
+ * 方法内部会进行一系列的校验，确保 `$post` 中包含的退款金额 `price`、退款花材 `product` (如果 `refundType` 是退款退货)等是有效的。这些校验通常包括：
|
|
|
+ * 退款金额是否合理（例如，不能超过订单实际支付金额）。
|
|
|
+ * 退货花材的数量是否合理（例如，不能超过原始订单中该花材的数量）。
|
|
|
+ * 退款类型是否有效。
|
|
|
+ * 其他业务规则校验。
|
|
|
+
|
|
|
+3. **计算退款金额和花材处理**:
|
|
|
+ * 根据退款类型和传入的花材列表，计算最终的退款金额。
|
|
|
+ * 如果涉及到花材退货，还会处理每个退货花材的数量、单价等信息。
|
|
|
+
|
|
|
+4. **创建退款订单**:
|
|
|
+ ```php
|
|
|
+ // 推测：创建 RefundOrder 实例并保存
|
|
|
+ $refundOrder = new RefundOrderClass(); // 实际可能是通过 add 方法创建
|
|
|
+ // 填充退款订单的各个字段，例如 orderSn, relateOrderSn, refundPrice, refundType, cause 等
|
|
|
+ $refundOrderData = [
|
|
|
+ 'relateOrderSn' => $order->orderSn,
|
|
|
+ 'refundPrice' => $post['price'],
|
|
|
+ 'refundType' => $post['refundType'],
|
|
|
+ // ... 其他字段
|
|
|
+ ];
|
|
|
+ $respond = RefundOrderClass::add($refundOrderData, true); // 返回对象
|
|
|
+ ```
|
|
|
+ * **解释**: 这是创建 `RefundOrder` 记录的关键步骤。它会收集所有必要的退款信息，并将其保存到 `xhRefund` 数据库表中。
|
|
|
+ * **`RefundOrderClass::add($data, true)`**: (将在后续详细解释) 这是 `RefundOrderClass` 的一个静态方法，用于创建新的退款订单记录。
|
|
|
+
|
|
|
+5. **创建退款订单花材明细 (如果退款退货)**:
|
|
|
+ ```php
|
|
|
+ // 推测：如果 refundType 是退款退货，创建 RefundOrderItem 实例并保存
|
|
|
+ if ($post['refundType'] == RefundOrderClass::REFUND_TYPE_MONEY_GOOD) {
|
|
|
+ foreach ($post['product'] as $item) {
|
|
|
+ // 为每个退货花材创建 RefundOrderItem 记录
|
|
|
+ RefundOrderItemClass::add([
|
|
|
+ 'orderSn' => $respond->orderSn, // 新创建的退款订单号
|
|
|
+ 'productId' => $item['productId'],
|
|
|
+ 'xhNum' => $item['num'],
|
|
|
+ // ... 其他花材明细字段
|
|
|
+ ]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 如果退款类型包含退货，则会为每个退货花材创建一条 `RefundOrderItem` 记录，记录退货花材的详细信息，并与主退款订单关联。
|
|
|
+ * **`RefundOrderItemClass::add(...)`**: (将在后续详细解释) 用于创建退款订单明细项。
|
|
|
+
|
|
|
+6. **更新原始订单状态**:
|
|
|
+ ```php
|
|
|
+ // 推测：更新原始订单的退款状态，例如将 order.refund 字段设置为 REFUND_ING 或 REFUND_YES
|
|
|
+ // OrderClass::updateById($id, ['refund' => OrderClass::REFUND_ING]);
|
|
|
+ ```
|
|
|
+ * **解释**: 退款成功后，通常需要更新原始订单的状态，以便追踪其退款进度。
|
|
|
+
|
|
|
+7. **处理库存 (如果退款退货)**:
|
|
|
+ * 如果涉及到花材退货，可能还会更新对应花材的库存。退货通常意味着库存增加。
|
|
|
+ * **`ProductClass::addStock(...)`**: (将在后续解释) 如果涉及退货，可能会调用此方法增加库存。
|
|
|
+
|
|
|
+8. **记录资金变动**:
|
|
|
+ * 退款操作会引起资金变动，通常会记录到门店的资金流水中。
|
|
|
+ * **`ShopMoneyChangeClass::addRecord(...)`**: (将在后续解释) 可能调用此方法记录门店资金变动。
|
|
|
+
|
|
|
+9. **通知相关方**:
|
|
|
+ * 退款成功后，可能会向客户、门店管理员发送通知。
|
|
|
+ * **`NoticeClass::afterSaleNotice(...)` 或其他通知类**: (将在后续解释) 用于发送通知。
|
|
|
+
|
|
|
+10. **返回退款订单信息**:
|
|
|
+ ```php
|
|
|
+ return $respond; // 返回新创建的 RefundOrder 对象
|
|
|
+ ```
|
|
|
+ * **解释**: 返回新创建的 `RefundOrder` 对象，其中包含 `id` 等关键信息，供 `actionCreateOrder` 后续使用。
|
|
|
+
|
|
|
+---
|
|
|
+
|
|
|
+现在，我们来详细解释 `OrderService::refund` 中可能调用的关键函数和类：
|
|
|
+
|
|
|
+#### 6.1. `bizGhs\order\classes\OrderClass::getById($id, true)`
|
|
|
+
|
|
|
+* **解释**: 这与 `RefundOrderClass::getById` 类似。`OrderClass` 应该位于 `biz-ghs/order/classes/` 目录下，并且也继承自 `common\base\classes\BaseClass`。因此，其 `getById` 方法的实际实现仍然会追溯到 `common\base\models\Base::getById`。
|
|
|
+ * 它将查询 `Order` 模型（对应数据库表可能是 `xhOrder` 或类似命名）。
|
|
|
+
|
|
|
+#### 6.2. `bizGhs\order\classes\RefundOrderClass::add($data, true)`
|
|
|
+
|
|
|
+* **解释**: 这同样继承自 `common\base\classes\BaseClass::add($data, $returnObject = false)` (common/base/models/Base.php:19-45)。
|
|
|
+ * 它接收一个 `$data` 数组，用于填充 `RefundOrder` 模型的属性，然后调用模型的 `save()` 方法将数据插入到 `xhRefund` 表中。
|
|
|
+ * `true` 参数表示会返回新创建的 `RefundOrder` ActiveRecord 实例。
|
|
|
+
|
|
|
+#### 6.3. `bizGhs\order\classes\RefundOrderItemClass::add(...)`
|
|
|
+
|
|
|
+* **解释**: 类似于 `RefundOrderClass::add`。`RefundOrderItemClass` 应该位于 `biz-ghs/order/classes/` 目录下，它也继承自 `common\base\classes\BaseClass`，并关联 `RefundOrderItem` 模型（对应数据库表可能是 `xhRefundItem` 或类似命名）。
|
|
|
+ * `add` 方法用于创建退款订单明细记录，将花材的退货数量、单价等信息保存到数据库。
|
|
|
+
|
|
|
+#### 7. `bizGhs\order\services\RefundOrderService`
|
|
|
+
|
|
|
+现在，我们来解释 `RefundOrderService::passRefund($refundInfo)` 方法。根据项目架构说明，`RefundOrderService` 应该位于 `biz-ghs/order/services/` 目录下。
|
|
|
+
|
|
|
+我们来查看 `biz-ghs/order/services/RefundOrderService.php` 文件。
|
|
|
+
|
|
|
+
|
|
|
+Read file: biz-ghs/order/services/RefundOrderService.php
|
|
|
+好的，我们继续深入 `RefundOrderService::passRefund($refund)` 方法。
|
|
|
+
|
|
|
+#### 7. `bizGhs\order\services\RefundOrderService::passRefund($refund)` (biz-ghs/order/services/RefundOrderService.php:36-150)
|
|
|
+
|
|
|
+```php
|
|
|
+36:150:bizGhs/order/services/RefundOrderService.php
|
|
|
+ //审核通过 ssh 20230811
|
|
|
+ public static function passRefund($refund)
|
|
|
+ {
|
|
|
+ $relateOrderSn = $refund->relateOrderSn ?? '';
|
|
|
+ $order = OrderClass::getByCondition(['orderSn' => $relateOrderSn], true);
|
|
|
+ if (empty($order)) {
|
|
|
+ util::fail('没有找到订单信息');
|
|
|
+ }
|
|
|
+ if ($order->status == OrderClass::ORDER_STATUS_UN_PAY) {
|
|
|
+ util::fail("待付款订单，不能申请售后");
|
|
|
+ }
|
|
|
+ if ($order->status == OrderClass::ORDER_STATUS_UN_SEND) {
|
|
|
+ util::fail("待配送订单，不能申请售后");
|
|
|
+ }
|
|
|
+ if ($order->status == OrderClass::ORDER_STATUS_SENDING) {
|
|
|
+ util::fail("配送中订单，不能申请售后");
|
|
|
+ }
|
|
|
+ if ($order->status == OrderClass::ORDER_STATUS_CANCEL) {
|
|
|
+ util::fail("已取消订单，不能申请售后");
|
|
|
+ }
|
|
|
+ if (isset($order->clearId) && !empty($order->clearId)) {
|
|
|
+ util::fail('订单已结账，请驳回，并在线下完成售后');
|
|
|
+ }
|
|
|
+ $currentOrderId = $order->id;
|
|
|
+ $addTime = $order->addTime ?? '';
|
|
|
+ $current = time();
|
|
|
+ if ($order->debt != 1 && (strtotime($addTime) + 3 * 30 * 24 * 60 * 60) < $current) {
|
|
|
+ util::fail('历史订单，不能再发起退款');
|
|
|
+ }
|
|
|
+ if (strtotime($addTime) <= strtotime('2022-03-30 00:00:00')) {
|
|
|
+ util::fail('历史订单，不能发起退款哦');
|
|
|
+ }
|
|
|
+ if (bccomp($refund->refundPrice, $order->realPrice, 2) == 1) {
|
|
|
+ util::fail("退款金额超过订单金额");
|
|
|
+ }
|
|
|
+ $refund->passTime = date("Y-m-d H:i:s");
|
|
|
+ $refund->save();
|
|
|
+
|
|
|
+ $customId = $order->customId ?? 0;
|
|
|
+ $clearList = PurchaseClearClass::getAllByCondition(['customId' => $customId, 'status' => 1], null, '*', null, true);
|
|
|
+ $orderIds = [];
|
|
|
+ $currentClearId = 0;
|
|
|
+ if (!empty($clearList)) {
|
|
|
+ foreach ($clearList as $clear) {
|
|
|
+ $saleStr = $clear->saleIds ?? '';
|
|
|
+ $deadline = $clear->deadline ?? '';
|
|
|
+ if ($deadline < date("Y-m-d H:i:s")) {
|
|
|
+ $n = date("Y-m-d H:i:s");
|
|
|
+ $clear->status = 3;
|
|
|
+ $clear->remark = "账单过期，已自动取消！！参数：{$deadline} {$n}";
|
|
|
+ $clear->save();
|
|
|
+ } else {
|
|
|
+ if (!empty($saleStr)) {
|
|
|
+ $current = explode(',', $saleStr);
|
|
|
+ $orderIds = array_merge($orderIds, $current);
|
|
|
+ $currentClearId = $clear->id;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!empty($orderIds) && in_array($currentOrderId, $orderIds)) {
|
|
|
+ //有结账单要取消才能售后
|
|
|
+ util::success(['clearId' => $currentClearId, 'error' => 'hasUnClearOrder']);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ $relateOrderSn = $refund->relateOrderSn ?? '';
|
|
|
+ if (empty($relateOrderSn)) {
|
|
|
+ util::fail('没有订单信息');
|
|
|
+ }
|
|
|
+ $order = OrderClass::getByCondition(['orderSn' => $relateOrderSn], true);
|
|
|
+ if (empty($order)) {
|
|
|
+ util::fail('没有订单信息哦');
|
|
|
+ }
|
|
|
+ RefundOrderClass::passRefund($refund, $order);
|
|
|
+ $cgRefundId = $refund->cgRefundId ?? 0;
|
|
|
+ $cgRefund = CgRefundClass::getById($cgRefundId, true);
|
|
|
+ if (empty($cgRefund)) {
|
|
|
+ util::fail('信息缺失哦');
|
|
|
+ }
|
|
|
+ $cgId = $cgRefund->cgId ?? 0;
|
|
|
+ $cg = PurchaseClass::getById($cgId, true);
|
|
|
+ if (empty($cg)) {
|
|
|
+ util::fail('采购信息缺失');
|
|
|
+ }
|
|
|
+ CgRefundClass::passRefund($cgRefund, $cg);
|
|
|
+ }
|
|
|
+```
|
|
|
+
|
|
|
+**方法概览**: `passRefund` 方法是退款订单审核通过的核心逻辑，它执行多项校验以确保退款的合法性，然后更新退款订单状态、原始订单状态，并同步更新关联的采购退款单状态。
|
|
|
+
|
|
|
+**详细步骤解析**:
|
|
|
+
|
|
|
+1. **获取关联原始订单信息**:
|
|
|
+ ```php
|
|
|
+ $relateOrderSn = $refund->relateOrderSn ?? '';
|
|
|
+ $order = OrderClass::getByCondition(['orderSn' => $relateOrderSn], true);
|
|
|
+ if (empty($order)) {
|
|
|
+ util::fail('没有找到订单信息');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 通过退款订单 `$refund` 中的 `relateOrderSn`（关联的原始订单号），获取原始订单的详细信息。`OrderClass::getByCondition` 会查询 `Order` 模型（通常是 `xhOrder` 表）并返回一个订单对象。
|
|
|
+ * **`OrderClass::getByCondition($condition, true)`**: (将在后续详细解释) 这是 `OrderClass` 的一个静态方法，用于根据条件获取一条订单记录。
|
|
|
+
|
|
|
+2. **原始订单状态校验**:
|
|
|
+ ```php
|
|
|
+ if ($order->status == OrderClass::ORDER_STATUS_UN_PAY) {
|
|
|
+ util::fail("待付款订单，不能申请售后");
|
|
|
+ }
|
|
|
+ // ... 其他状态校验 (待配送、配送中、已取消)
|
|
|
+ ```
|
|
|
+ * **解释**: 检查原始订单的状态，如果订单处于“待付款”、“待配送”、“配送中”或“已取消”状态，则不允许进行售后（退款）。这些都是业务规则，防止对不适合进行售后的订单进行操作。`OrderClass::ORDER_STATUS_UN_PAY` 等是 `OrderClass` 中定义的常量。
|
|
|
+
|
|
|
+3. **订单结账状态校验**:
|
|
|
+ ```php
|
|
|
+ if (isset($order->clearId) && !empty($order->clearId)) {
|
|
|
+ util::fail('订单已结账，请驳回，并在线下完成售后');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 检查原始订单是否已经结账。如果订单已关联 `clearId` (结账单 ID)，则说明订单已纳入结算，此时不允许在线上退款，需要线下处理。
|
|
|
+
|
|
|
+4. **历史订单退款时间限制**:
|
|
|
+ ```php
|
|
|
+ $addTime = $order->addTime ?? '';
|
|
|
+ $current = time();
|
|
|
+ if ($order->debt != 1 && (strtotime($addTime) + 3 * 30 * 24 * 60 * 60) < $current) {
|
|
|
+ util::fail('历史订单，不能再发起退款');
|
|
|
+ }
|
|
|
+ if (strtotime($addTime) <= strtotime('2022-03-30 00:00:00')) {
|
|
|
+ util::fail('历史订单，不能发起退款哦');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这段代码对历史订单的退款进行了限制。
|
|
|
+ * 第一部分：如果不是欠款订单 (`$order->debt != 1`)，并且订单添加时间超过 3 个月（`3 * 30 * 24 * 60 * 60` 秒），则不允许退款。
|
|
|
+ * 第二部分：硬编码了对 2022 年 3 月 30 日之前的订单不允许退款的限制，这通常是由于业务数据迁移或旧数据处理策略导致的。
|
|
|
+
|
|
|
+5. **退款金额与订单金额校验**:
|
|
|
+ ```php
|
|
|
+ if (bccomp($refund->refundPrice, $order->realPrice, 2) == 1) {
|
|
|
+ util::fail("退款金额超过订单金额");
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 使用 `bccomp` 函数（用于高精度浮点数比较）比较退款金额 `refundPrice` 是否超过了原始订单的实际支付金额 `realPrice`。如果退款金额大于实际支付金额，则不允许通过。
|
|
|
+
|
|
|
+6. **更新退款订单通过时间**:
|
|
|
+ ```php
|
|
|
+ $refund->passTime = date("Y-m-d H:i:s");
|
|
|
+ $refund->save();
|
|
|
+ ```
|
|
|
+ * **解释**: 设置退款订单的 `passTime` 字段为当前时间，表示退款订单已通过审核。然后调用 `$refund->save()` 方法将更改保存到数据库。
|
|
|
+
|
|
|
+7. **处理客户结账单**:
|
|
|
+ ```php
|
|
|
+ $customId = $order->customId ?? 0;
|
|
|
+ $clearList = PurchaseClearClass::getAllByCondition(['customId' => $customId, 'status' => 1], null, '*', null, true);
|
|
|
+ // ... 遍历 $clearList，处理过期结账单，检查当前订单是否在未取消的结账单中
|
|
|
+ if (!empty($orderIds) && in_array($currentOrderId, $orderIds)) {
|
|
|
+ util::success(['clearId' => $currentClearId, 'error' => 'hasUnClearOrder']);
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这部分逻辑与客户的结账单相关。
|
|
|
+ * 它会查询与该客户关联的、状态为“已生效”的结账单。
|
|
|
+ * 遍历这些结账单，检查是否有已过期的结账单，并将其状态更新为“已取消”。
|
|
|
+ * **如果当前原始订单包含在任何未取消的结账单中，则返回一个特定的成功响应 (`util::success(['clearId' => $currentClearId, 'error' => 'hasUnClearOrder'])`)，这意味着虽然技术上通过了某些校验，但由于结账单的存在，需要前端进行进一步处理或提示。** 这是一种特殊的业务流程控制。
|
|
|
+ * **`PurchaseClearClass::getAllByCondition(...)`**: (将在后续详细解释) 用于获取客户的结账单信息。
|
|
|
+
|
|
|
+8. **再次获取原始订单信息 (冗余但安全)**:
|
|
|
+ ```php
|
|
|
+ $relateOrderSn = $refund->relateOrderSn ?? '';
|
|
|
+ if (empty($relateOrderSn)) {
|
|
|
+ util::fail('没有订单信息');
|
|
|
+ }
|
|
|
+ $order = OrderClass::getByCondition(['orderSn' => $relateOrderSn], true);
|
|
|
+ if (empty($order)) {
|
|
|
+ util::fail('没有订单信息哦');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 再次根据 `relateOrderSn` 获取原始订单信息。这看起来有点冗余，但可能是为了确保在执行后续操作时，`$order` 对象是最新的，或者在前面的某个逻辑分支中 `$order` 被修改后，在这里获取最新的状态。
|
|
|
+
|
|
|
+9. **调用 `RefundOrderClass` 审核通过方法**:
|
|
|
+ ```php
|
|
|
+ RefundOrderClass::passRefund($refund, $order);
|
|
|
+ ```
|
|
|
+ * **解释**: 这是将退款订单状态实际标记为“通过”的核心调用。它会将退款订单 `$refund` 和关联的原始订单 `$order` 传递给 `RefundOrderClass` 的 `passRefund` 方法。
|
|
|
+ * **`RefundOrderClass::passRefund($refund, $order)`**: (将在后续详细解释) 这是 `RefundOrderClass` 的静态方法，负责更新退款订单的状态以及原始订单的退款标记。
|
|
|
+
|
|
|
+10. **同步更新关联的采购退款单**:
|
|
|
+ ```php
|
|
|
+ $cgRefundId = $refund->cgRefundId ?? 0;
|
|
|
+ $cgRefund = CgRefundClass::getById($cgRefundId, true);
|
|
|
+ if (empty($cgRefund)) {
|
|
|
+ util::fail('信息缺失哦');
|
|
|
+ }
|
|
|
+ $cgId = $cgRefund->cgId ?? 0;
|
|
|
+ $cg = PurchaseClass::getById($cgId, true);
|
|
|
+ if (empty($cg)) {
|
|
|
+ util::fail('采购信息缺失');
|
|
|
+ }
|
|
|
+ CgRefundClass::passRefund($cgRefund, $cg);
|
|
|
+ ```
|
|
|
+ * **解释**: 如果退款订单关联了采购退款单（通过 `cgRefundId`），则需要同步更新采购退款单的状态。这反映了系统中的订单和采购单之间的关联关系。
|
|
|
+ * **`CgRefundClass::getById($cgRefundId, true)`**: (将在后续详细解释) 用于获取采购退款单信息。
|
|
|
+ * **`PurchaseClass::getById($cgId, true)`**: (将在后续详细解释) 用于获取采购单信息。
|
|
|
+ * **`CgRefundClass::passRefund($cgRefund, $cg)`**: (将在后续详细解释) 用于更新采购退款单的状态。
|
|
|
+
|
|
|
+---
|
|
|
+
|
|
|
+现在，我们来详细解释 `RefundOrderService::passRefund` 中可能调用的关键函数和类：
|
|
|
+
|
|
|
+#### 7.1. `bizGhs\order\classes\OrderClass::getByCondition($condition, $returnObject = false, $order = false)`
|
|
|
+
|
|
|
+* **解释**: 这与 `RefundOrderClass::getByCondition` 类似，它最终会通过 `common\base\models\Base::getByCondition` 来执行数据库查询。
|
|
|
+ * 它将查询 `Order` 模型（对应数据库表可能是 `xhOrder` 或类似命名），并返回符合条件的第一条订单记录。
|
|
|
+
|
|
|
+#### 7.2. `bizHd\purchase\classes\PurchaseClearClass::getAllByCondition($condition, $order = null, $field, $indexBy = null, $returnObject = false)`
|
|
|
+
|
|
|
+* **解释**: `PurchaseClearClass` 应该位于 `biz-hd/purchase/classes/` 目录下，它也继承自 `common\base\classes\BaseClass`。因此，其 `getAllByCondition` 方法的实际实现仍然会追溯到 `common\base\models\Base::getAllByCondition`。
|
|
|
+ * 它将查询 `PurchaseClear` 模型（对应数据库表可能是 `hdPurchaseClear` 或类似命名），用于获取客户的结账单信息。
|
|
|
+
|
|
|
+#### 7.3. `bizGhs\order\classes\RefundOrderClass::passRefund($refund, $order)`
|
|
|
+
|
|
|
+我们之前已经查看过 `RefundOrderClass.php` 文件，现在我们来详细解释其 `passRefund` 方法。
|
|
|
+
|
|
|
+* **`bizGhs\order\classes\RefundOrderClass::passRefund($refund, $order)`**: (biz-ghs/order/classes/RefundOrderClass.php:120-360)
|
|
|
+ ```php
|
|
|
+ 120:360:bizGhs/order/classes/RefundOrderClass.php
|
|
|
+ public static function passRefund($refund, $order)
|
|
|
+ {
|
|
|
+ if ($refund->status == 1) {
|
|
|
+ util::fail('已通过');
|
|
|
+ }
|
|
|
+ if ($refund->status == 2) {
|
|
|
+ util::fail('已驳回');
|
|
|
+ }
|
|
|
+ if ($refund->status == 3) {
|
|
|
+ util::fail('已取消');
|
|
|
+ }
|
|
|
+ $refund->status = 1; // 设置退款订单状态为“已通过”
|
|
|
+ $refund->save(); // 保存退款订单状态更改
|
|
|
+
|
|
|
+ $order->refund = OrderClass::REFUND_YES; // 设置原始订单的退款标记
|
|
|
+ $order->save(); // 保存原始订单状态更改
|
|
|
+
|
|
|
+ // ... 剩余代码处理退款花材库存、资金变动、通知等复杂逻辑 ...
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这是退款订单审核通过后，实际更新数据和执行业务逻辑的地方。
|
|
|
+ * **状态校验**: 首先检查退款订单的当前状态，如果已经是“已通过”、“已驳回”或“已取消”，则直接失败，避免重复操作。
|
|
|
+ * **更新退款订单状态**: 将传入的 `$refund` 对象的 `status` 属性设置为 `1` (表示“已通过”)，并调用 `$refund->save()` 将其保存到数据库。
|
|
|
+ * **更新原始订单退款标记**: 将关联的原始订单 `$order` 的 `refund` 属性设置为 `OrderClass::REFUND_YES` (表示“已退款”)，并调用 `$order->save()` 将其保存到数据库。
|
|
|
+ * **处理退款花材库存**: 如果退款类型是“退款退货” (`RefundOrderClass::REFUND_TYPE_MONEY_GOOD`)，则会遍历退款花材明细，更新原始订单花材的已退数量 `refundNum`，并根据退货数量增加对应花材的库存。
|
|
|
+ * **`ProductClass::addStock($productId, $bigNum, $smallNum)`**: (将在后续详细解释) 这是产品类中的方法，用于增加库存。
|
|
|
+ * **`StockRecordClass::ghsRefundAddRecord($recordData)`**: (将在后续详细解释) 这是库存记录类中的方法，用于记录库存变动。
|
|
|
+ * **处理资金变动**: 更新主站和门店的总支出和总退款金额。
|
|
|
+ * **在线支付退款流程**: 如果是线上支付，会根据支付方式（微信支付或支付宝）处理实际的退款流程，并可能减少门店余额。
|
|
|
+ * **`ShopClass::saleRefundReduceBalance($main, $shop, $refund, $refundPrice)`**: (将在后续详细解释) 这是门店类中的方法，用于减少门店余额。
|
|
|
+
|
|
|
+#### 7.4. `bizHd\cg\classes\CgRefundClass::getById($cgRefundId, true)`
|
|
|
+
|
|
|
+* **解释**: `CgRefundClass` 应该位于 `biz-hd/cg/classes/` 目录下，它也继承自 `common\base\classes\BaseClass`。因此，其 `getById` 方法的实际实现仍然会追溯到 `common\base\models\Base::getById`。
|
|
|
+ * 它将查询 `CgRefund` 模型（对应数据库表可能是 `hdCgRefund` 或类似命名），用于获取采购退款单信息。
|
|
|
+
|
|
|
+#### 7.5. `bizHd\purchase\classes\PurchaseClass::getById($cgId, true)`
|
|
|
+
|
|
|
+* **解释**: `PurchaseClass` 应该位于 `biz-hd/purchase/classes/` 目录下，它也继承自 `common\base\classes\BaseClass`。因此，其 `getById` 方法的实际实现仍然会追溯到 `common\base\models\Base::getById`。
|
|
|
+ * 它将查询 `Purchase` 模型（对应数据库表可能是 `hdPurchase` 或类似命名），用于获取采购单信息。
|
|
|
+
|
|
|
+#### 7.6. `bizHd\cg\classes\CgRefundClass::passRefund($cgRefund, $cg)`
|
|
|
+
|
|
|
+* **解释**: 这是采购退款单审核通过的核心方法。`CgRefundClass` 中的 `passRefund` 应该会更新采购退款单的状态，并可能回溯更新原始采购单的相关状态，处理供应商的资金、库存等。
|
|
|
+ * **`CgRefundClass::passRefund($cgRefund, $cg)`**: 我们来查看 `biz-hd/cg/classes/CgRefundClass.php` 文件，深入了解它的 `passRefund` 方法。
|
|
|
+
|
|
|
+
|
|
|
+Read file: biz-hd/cg/classes/CgRefundClass.php
|
|
|
+好的，我们继续深入 `CgRefundClass::passRefund($cgRefund, $cg)` 方法。
|
|
|
+
|
|
|
+#### 7.6. `bizHd\cg\classes\CgRefundClass::passRefund($cgRefund, $cg)` (biz-hd/cg/classes/CgRefundClass.php:120-368)
|
|
|
+
|
|
|
+```php
|
|
|
+120:368:biz-hd/cg/classes/CgRefundClass.php
|
|
|
+ //审核通过 ssh 20230811
|
|
|
+ public static function passRefund($cgRefund, $cg)
|
|
|
+ {
|
|
|
+ if ($cgRefund->status == 1) {
|
|
|
+ util::fail('已通过');
|
|
|
+ }
|
|
|
+ if ($cgRefund->status == 2) {
|
|
|
+ util::fail('已驳回');
|
|
|
+ }
|
|
|
+ if ($cgRefund->status == 3) {
|
|
|
+ util::fail('已取消');
|
|
|
+ }
|
|
|
+ $refundType = $cgRefund->refundType ?? 1;
|
|
|
+ $refundSn = $cgRefund->orderSn ?? '';
|
|
|
+ $cgRefund->status = 1; // 设置采购退款单状态为“已通过”
|
|
|
+ $cgRefund->save(); // 保存采购退款单状态更改
|
|
|
+
|
|
|
+ $cgId = $cg->id ?? 0;
|
|
|
+ $orderSn = $cg->orderSn ?? '';
|
|
|
+ $mainId = $cg->mainId ?? 0;
|
|
|
+ $shopId = $cg->shopId ?? 0;
|
|
|
+ $sjId = $cg->sjId ?? 0;
|
|
|
+ $ghsName = $cg->ghsName ?? '';
|
|
|
+ $payWay = $cg->payWay;
|
|
|
+ $onlinePay = $cg->onlinePay ?? 1;
|
|
|
+ $cg->refund = PurchaseClass::REFUND_YES; // 设置原始采购单的退款标记
|
|
|
+ $cg->save(); // 保存原始采购单状态更改
|
|
|
+
|
|
|
+ $transaction_id = $cg->thirdNo ?? '';
|
|
|
+ $refundOrderSn = orderSn::getCgRefundSn(); // 生成新的采购退款单号
|
|
|
+ $refundPrice = $cgRefund->refundPrice ?? 0;
|
|
|
+ if (is_numeric($refundPrice) == false || $refundPrice < 0) {
|
|
|
+ util::fail('退款金额有问题');
|
|
|
+ }
|
|
|
+ $shop = ShopClass::getLockById($shopId); // 获取门店信息，并加锁
|
|
|
+ if (empty($shop)) {
|
|
|
+ util::fail('没有找到门店14');
|
|
|
+ }
|
|
|
+ $main = MainClass::getLockById($mainId); // 获取主站信息，并加锁
|
|
|
+ if (empty($main)) {
|
|
|
+ util::fail('没有main信息7');
|
|
|
+ }
|
|
|
+ if ($refundType == CgRefundClass::REFUND_TYPE_MONEY_GOOD) {
|
|
|
+ // 处理退款退货的花材
|
|
|
+ $refundItemList = CgRefundItemClass::getAllByCondition(['orderSn' => $refundSn], null, '*', null, true);
|
|
|
+ if (empty($refundItemList)) {
|
|
|
+ util::fail('没有找到售后订单的花材哦');
|
|
|
+ }
|
|
|
+ $refundData = [];
|
|
|
+ foreach ($refundItemList as $key => $val) {
|
|
|
+ $val->status = 1; // 设置退款花材明细状态为“已通过”
|
|
|
+ $val->save(); // 保存退款花材明细状态更改
|
|
|
+ $cgItemId = $val->cgItemId ?? 0;
|
|
|
+ if (empty($cgItemId)) {
|
|
|
+ util::fail('旧订单无法售后，请联系管理员哦');
|
|
|
+ }
|
|
|
+ $refundData[$cgItemId] = $val;
|
|
|
+ }
|
|
|
+ $cgItemList = PurchaseItemClass::getAllByCondition(['orderSn' => $orderSn], null, '*', null, true);
|
|
|
+ if (empty($cgItemList)) {
|
|
|
+ util::fail('采购单花材错误');
|
|
|
+ }
|
|
|
+ foreach ($cgItemList as $oneKey => $oneItem) {
|
|
|
+ $oneItemId = $oneItem->id;
|
|
|
+ $productId = $oneItem->productId ?? 0;
|
|
|
+ $ptItemId = $oneItem->itemId ?? 0;
|
|
|
+ $itemName = $oneItem->name ?? '';
|
|
|
+
|
|
|
+ $cgItemNum = $oneItem->xhNum ?? 0;
|
|
|
+ $refundNum = $oneItem->refundNum ?? 0;
|
|
|
+ $remainNum = bcsub($cgItemNum, $refundNum); // 计算可退数量
|
|
|
+
|
|
|
+ if (isset($refundData[$oneItemId])) {
|
|
|
+ $refundSingle = $refundData[$oneItemId];
|
|
|
+ $num = $refundSingle->xhNum ?? 0;
|
|
|
+
|
|
|
+ if ($num > $remainNum) {
|
|
|
+ util::fail("{$itemName} 超过可退数量");
|
|
|
+ }
|
|
|
+ $oneItem->refundNum = bcadd($refundNum, $num); // 更新原始采购花材的已退数量
|
|
|
+ $oneItem->save(); // 保存原始采购花材状态更改
|
|
|
+
|
|
|
+ if ($refundSingle->xhUnitType == 1) {
|
|
|
+ $smallNum = $num;
|
|
|
+ $bigNum = 0;
|
|
|
+ } else {
|
|
|
+ $smallNum = 0;
|
|
|
+ $bigNum = $num;
|
|
|
+ }
|
|
|
+ $itemNum = $refundSingle->itemNum;
|
|
|
+
|
|
|
+ if ($bigNum > 0 || $smallNum > 0) {
|
|
|
+ // 减少库存
|
|
|
+ $stockInfo = ProductClass::decreaseStock($productId, $bigNum, $smallNum);
|
|
|
+ $oldStock = $stockInfo['oldStock'] ?? 0;
|
|
|
+ $newStock = $stockInfo['newStock'] ?? 0;
|
|
|
+
|
|
|
+ // 记录库存变动
|
|
|
+ $recordData = [];
|
|
|
+ $recordData['itemNum'] = $itemNum;
|
|
|
+ $recordData['sjId'] = $sjId;
|
|
|
+ $recordData['shopId'] = $shopId;
|
|
|
+ $recordData['mainId'] = $mainId;
|
|
|
+ $recordData['orderSn'] = $orderSn;
|
|
|
+ $recordData['itemId'] = $ptItemId;
|
|
|
+ $recordData['oldStock'] = $oldStock; //当时库存
|
|
|
+ $recordData['productId'] = $productId;
|
|
|
+ $recordData['newStock'] = $newStock;// 最新库存
|
|
|
+ $recordData['relateName'] = $ghsName;
|
|
|
+ $recordData['io'] = 0; // io = 0 表示出库/减少库存
|
|
|
+ StockRecordClass::hdCgApplyRefundAddRecord($recordData); // 记录采购退款导致的库存变动
|
|
|
+
|
|
|
+ $refundSingle->itemStock = $oldStock;
|
|
|
+ $refundSingle->newStock = $newStock;
|
|
|
+ $refundSingle->save();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // 记录总的退款金额到原始采购单
|
|
|
+ $currentTkPrice = bcadd($cg->tkPrice, $refundPrice, 2);
|
|
|
+ $cg->tkPrice = $currentTkPrice;
|
|
|
+ $cg->refund = PurchaseClass::REFUND_YES;
|
|
|
+ $cg->save();
|
|
|
+
|
|
|
+ $ghsId = $cg->ghsId;
|
|
|
+ $ghs = GhsClass::getLockById($ghsId); // 获取供货商信息，并加锁
|
|
|
+ if (empty($ghs)) {
|
|
|
+ util::fail('没有找到供货商');
|
|
|
+ }
|
|
|
+
|
|
|
+ if ($onlinePay == dict::getDict('onlinePay', 'yes')) {
|
|
|
+ // 在线支付退款流程 (微信支付或支付宝)
|
|
|
+ if ($payWay == dict::getDict('payWay', 'wxPay') || $payWay == dict::getDict('payWay', 'alipay')) {
|
|
|
+
|
|
|
+ $ghsShopId = $ghs->shopId ?? 0;
|
|
|
+ $ghsShop = ShopClass::getById($ghsShopId, true); // 获取供货商门店信息
|
|
|
+ if (empty($ghsShop)) {
|
|
|
+ util::fail('没有找到供货商的门店');
|
|
|
+ }
|
|
|
+ $refundFee = bcmul($refundPrice, 100); // 将退款金额转换为分
|
|
|
+ // 拉卡拉支付接口配置
|
|
|
+ $merchantPrivateKeyPath = Yii::getAlias("@vendor/lakala") . '/production/api_private_key.pem';
|
|
|
+ $lklCertificatePath = Yii::getAlias("@vendor/lakala") . '/production/lkl-apigw-v1.cer';
|
|
|
+ $params = [
|
|
|
+ 'appid' => 'OP00002119',
|
|
|
+ 'serial_no' => '018b08cfddbd',
|
|
|
+ 'merchant_no' => $ghsShop->lklSjNo,
|
|
|
+ 'term_no' => $ghsShop->lklScanTermNo,
|
|
|
+ 'merchantPrivateKeyPath' => $merchantPrivateKeyPath,
|
|
|
+ 'lklCertificatePath' => $lklCertificatePath,
|
|
|
+ ];
|
|
|
+ $laResource = new Lakala($params); // 创建拉卡拉支付接口实例
|
|
|
+ $refundReason = '';
|
|
|
+ $aliParams = [ // 退款请求参数
|
|
|
+ 'refundSn' => $refundOrderSn,
|
|
|
+ 'orderSn' => $orderSn,
|
|
|
+ 'refundAmount' => $refundFee,
|
|
|
+ 'refundReason' => $refundReason,
|
|
|
+ 'thirdNo' => $transaction_id,
|
|
|
+ ];
|
|
|
+ $response = $laResource->refund($aliParams); // 执行退款操作
|
|
|
+ if (isset($response['code']) == false || $response['code'] != 'BBS00000') {
|
|
|
+ $errMsg = $response['msg'] ?? '';
|
|
|
+ util::fail('退款失败：' . $errMsg);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ // ... 其他支付方式不支持退款的逻辑
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+```
|
|
|
+
|
|
|
+**方法概览**: `CgRefundClass::passRefund` 方法负责处理采购退款单的审核通过逻辑。它更新退款单和采购单的状态，处理退货花材的库存减少，并与第三方支付（如拉卡拉）进行退款操作。
|
|
|
+
|
|
|
+**详细步骤解析**:
|
|
|
+
|
|
|
+1. **状态校验**:
|
|
|
+ ```php
|
|
|
+ if ($cgRefund->status == 1) { /* ... */ } // 已通过
|
|
|
+ if ($cgRefund->status == 2) { /* ... */ } // 已驳回
|
|
|
+ if ($cgRefund->status == 3) { /* ... */ } // 已取消
|
|
|
+ ```
|
|
|
+ * **解释**: 首先检查采购退款单 `$cgRefund` 的当前状态，如果已经是“已通过”、“已驳回”或“已取消”，则直接返回错误信息，防止重复操作。
|
|
|
+
|
|
|
+2. **更新采购退款单状态**:
|
|
|
+ ```php
|
|
|
+ $cgRefund->status = 1; // 设置状态为“已通过”
|
|
|
+ $cgRefund->save(); // 保存更改
|
|
|
+ ```
|
|
|
+ * **解释**: 将传入的 `$cgRefund` 对象的 `status` 属性设置为 `1` (表示“已通过”)，并调用 `$cgRefund->save()` 将其保存到数据库。
|
|
|
+
|
|
|
+3. **更新原始采购单状态**:
|
|
|
+ ```php
|
|
|
+ $cg->refund = PurchaseClass::REFUND_YES; // 设置原始采购单的退款标记
|
|
|
+ $cg->save(); // 保存更改
|
|
|
+ ```
|
|
|
+ * **解释**: 将关联的原始采购单 `$cg` 的 `refund` 属性设置为 `PurchaseClass::REFUND_YES` (表示“已退款”)，并调用 `$cg->save()` 将其保存到数据库。
|
|
|
+
|
|
|
+4. **生成新的采购退款单号**:
|
|
|
+ ```php
|
|
|
+ $refundOrderSn = orderSn::getCgRefundSn();
|
|
|
+ ```
|
|
|
+ * **解释**: 调用 `orderSn::getCgRefundSn()` 方法生成一个新的唯一的采购退款单号。
|
|
|
+ * **`orderSn::getCgRefundSn()`**: 这应该是一个工具方法，用于根据一定的规则生成订单号。它应该在 `common/components/orderSn.php` 文件中定义。
|
|
|
+
|
|
|
+5. **校验退款金额**:
|
|
|
+ ```php
|
|
|
+ $refundPrice = $cgRefund->refundPrice ?? 0;
|
|
|
+ if (is_numeric($refundPrice) == false || $refundPrice < 0) {
|
|
|
+ util::fail('退款金额有问题');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 校验退款金额 `$refundPrice` 是否为有效的数字且不小于 0。
|
|
|
+
|
|
|
+6. **获取门店和主站信息并加锁**:
|
|
|
+ ```php
|
|
|
+ $shop = ShopClass::getLockById($shopId);
|
|
|
+ if (empty($shop)) { util::fail('没有找到门店14'); }
|
|
|
+ $main = MainClass::getLockById($mainId);
|
|
|
+ if (empty($main)) { util::fail('没有main信息7'); }
|
|
|
+ ```
|
|
|
+ * **解释**: 通过 `ShopClass::getLockById` 和 `MainClass::getLockById` 获取门店和主站信息。`getLockById` 方法通常表示会获取行级锁，以防止在事务处理过程中其他并发操作修改这些数据，确保数据一致性。
|
|
|
+ * **`ShopClass::getLockById($shopId)`**: (将在后续解释) 获取门店信息并加锁。
|
|
|
+ * **`MainClass::getLockById($mainId)`**: (将在后续解释) 获取主站信息并加锁。
|
|
|
+
|
|
|
+7. **处理退款退货的花材 (减少库存)**:
|
|
|
+ ```php
|
|
|
+ if ($refundType == CgRefundClass::REFUND_TYPE_MONEY_GOOD) {
|
|
|
+ // ...
|
|
|
+ foreach ($refundItemList as $key => $val) {
|
|
|
+ $val->status = 1; // 设置退款花材明细状态为“已通过”
|
|
|
+ $val->save(); // 保存
|
|
|
+ // ...
|
|
|
+ }
|
|
|
+ foreach ($cgItemList as $oneKey => $oneItem) {
|
|
|
+ // ...
|
|
|
+ $oneItem->refundNum = bcadd($refundNum, $num); // 更新原始采购花材的已退数量
|
|
|
+ $oneItem->save(); // 保存
|
|
|
+ // ... 减少库存和记录库存变动
|
|
|
+ $stockInfo = ProductClass::decreaseStock($productId, $bigNum, $smallNum); // 减少花材库存
|
|
|
+ StockRecordClass::hdCgApplyRefundAddRecord($recordData); // 记录库存变动
|
|
|
+ // ...
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 如果退款类型是 `REFUND_TYPE_MONEY_GOOD` (退款退货)，则会执行以下操作：
|
|
|
+ * **获取退款花材明细**: 通过 `CgRefundItemClass::getAllByCondition` 获取当前采购退款单的所有花材明细。
|
|
|
+ * **`CgRefundItemClass::getAllByCondition(...)`**: (将在后续解释) 获取采购退款单花材明细。
|
|
|
+ * **更新退款花材明细状态**: 将每条退款花材明细的 `status` 设置为 `1` (已通过) 并保存。
|
|
|
+ * **更新原始采购花材数量**: 通过 `PurchaseItemClass::getAllByCondition` 获取原始采购单的花材明细。然后遍历原始花材和退款花材，更新原始采购花材的 `refundNum` (已退数量)。
|
|
|
+ * **`PurchaseItemClass::getAllByCondition(...)`**: (将在后续解释) 获取采购单花材明细。
|
|
|
+ * **减少库存**: 调用 `ProductClass::decreaseStock` 方法减少对应花材的库存。因为是退货给供应商，所以对于采购方来说是库存减少。
|
|
|
+ * **`ProductClass::decreaseStock($productId, $bigNum, $smallNum)`**: (将在后续解释) 减少产品库存。
|
|
|
+ * **记录库存变动**: 调用 `StockRecordClass::hdCgApplyRefundAddRecord` 记录本次库存变动，包括旧库存、新库存等信息，方便追溯。
|
|
|
+ * **`StockRecordClass::hdCgApplyRefundAddRecord($recordData)`**: (将在后续解释) 记录库存变动。
|
|
|
+
|
|
|
+8. **记录总的退款金额到原始采购单**:
|
|
|
+ ```php
|
|
|
+ $currentTkPrice = bcadd($cg->tkPrice, $refundPrice, 2);
|
|
|
+ $cg->tkPrice = $currentTkPrice;
|
|
|
+ $cg->refund = PurchaseClass::REFUND_YES;
|
|
|
+ $cg->save();
|
|
|
+ ```
|
|
|
+ * **解释**: 将本次退款金额累加到原始采购单 `$cg` 的 `tkPrice` (总退款金额) 字段，并再次设置 `refund` 状态为 `REFUND_YES`，然后保存。
|
|
|
+
|
|
|
+9. **获取供货商信息并加锁**:
|
|
|
+ ```php
|
|
|
+ $ghsId = $cg->ghsId;
|
|
|
+ $ghs = GhsClass::getLockById($ghsId);
|
|
|
+ if (empty($ghs)) { util::fail('没有找到供货商'); }
|
|
|
+ ```
|
|
|
+ * **解释**: 通过 `GhsClass::getLockById` 获取供货商信息并加锁，这可能用于后续的资金变动或通知。
|
|
|
+ * **`GhsClass::getLockById($ghsId)`**: (将在后续解释) 获取供货商信息并加锁。
|
|
|
+
|
|
|
+10. **在线支付退款流程 (拉卡拉)**:
|
|
|
+ ```php
|
|
|
+ if ($onlinePay == dict::getDict('onlinePay', 'yes')) {
|
|
|
+ if ($payWay == dict::getDict('payWay', 'wxPay') || $payWay == dict::getDict('payWay', 'alipay')) {
|
|
|
+ // ... 获取供货商门店信息
|
|
|
+ $ghsShop = ShopClass::getById($ghsShopId, true);
|
|
|
+ // ... 设置拉卡拉支付接口参数
|
|
|
+ $laResource = new Lakala($params); // 创建拉卡拉支付接口实例
|
|
|
+ $response = $laResource->refund($aliParams); // 执行退款操作
|
|
|
+ if (isset($response['code']) == false || $response['code'] != 'BBS00000') {
|
|
|
+ util::fail('退款失败：' . $errMsg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 如果原始采购单是在线支付且支付方式是微信支付或支付宝，则会调用拉卡拉支付接口进行实际的退款操作。
|
|
|
+ * **`dict::getDict('onlinePay', 'yes')`**: (将在后续解释) 获取字典中在线支付为“是”的值。
|
|
|
+ * **`dict::getDict('payWay', 'wxPay')` / `dict::getDict('payWay', 'alipay')`**: (将在后续解释) 获取字典中微信支付或支付宝支付的值。
|
|
|
+ * **`ShopClass::getById($ghsShopId, true)`**: (将在后续解释) 获取供货商门店信息。
|
|
|
+ * **`Lakala($params)`**: 创建 `Lakala` 支付接口的实例。这是一个第三方支付 SDK 的使用，用于与拉卡拉支付平台进行交互。
|
|
|
+ * **`$laResource->refund($aliParams)`**: 调用拉卡拉 SDK 的 `refund` 方法执行退款操作，传入退款金额、订单号等参数。
|
|
|
+ * **响应校验**: 检查拉卡拉接口的返回码 (`code`) 是否为成功码 (`BBS00000`)，如果不是，则返回退款失败信息。
|
|
|
+
|
|
|
+---
|
|
|
+
|
|
|
+现在，我们来详细解释 `CgRefundClass::passRefund` 中可能调用的其他关键函数和类：
|
|
|
+
|
|
|
+#### 8. `common\components\orderSn::getCgRefundSn()`
|
|
|
+
|
|
|
+* **解释**: 用于生成采购退款单号。它应该位于 `common/components/orderSn.php` 文件中。
|
|
|
+
|
|
|
+#### 9. `bizHd\shop\classes\ShopClass::getLockById($shopId)`
|
|
|
+
|
|
|
+* **解释**: 这是一个从 `bizHd\shop\classes\ShopClass` 中获取门店信息并加锁的方法。它最终会追溯到 `common\base\models\Base::getLockById`。
|
|
|
+ * 它将查询 `Shop` 模型（对应数据库表可能是 `hdShop` 或类似命名）。
|
|
|
+
|
|
|
+#### 10. `bizHd\shop\classes\MainClass::getLockById($mainId)`
|
|
|
+
|
|
|
+* **解释**: 这是一个从 `bizHd\shop\classes\MainClass` 中获取主站信息并加锁的方法。它最终会追溯到 `common\base\models\Base::getLockById`。
|
|
|
+ * 它将查询 `Main` 模型（对应数据库表可能是 `hdMain` 或类似命名）。
|
|
|
+
|
|
|
+#### 11. `bizHd\cg\classes\CgRefundItemClass::getAllByCondition(...)`
|
|
|
+
|
|
|
+* **解释**: 类似于 `RefundOrderItemClass::getAllByCondition`。`CgRefundItemClass` 应该位于 `biz-hd/cg/classes/` 目录下，它也继承自 `common\base\classes\BaseClass`，并关联 `CgRefundItem` 模型（对应数据库表可能是 `hdCgRefundItem` 或类似命名）。
|
|
|
+ * `getAllByCondition` 方法用于获取采购退款单的所有花材明细记录。
|
|
|
+
|
|
|
+#### 12. `bizHd\purchase\classes\PurchaseItemClass::getAllByCondition(...)`
|
|
|
+
|
|
|
+* **解释**: 类似于 `OrderItemClass::getAllByCondition`。`PurchaseItemClass` 应该位于 `biz-hd/purchase/classes/` 目录下，它也继承自 `common\base\classes\BaseClass`，并关联 `PurchaseItem` 模型（对应数据库表可能是 `hdPurchaseItem` 或类似命名）。
|
|
|
+ * `getAllByCondition` 方法用于获取原始采购单的所有花材明细记录。
|
|
|
+
|
|
|
+#### 13. `bizGhs\product\classes\ProductClass::decreaseStock($productId, $bigNum, $smallNum)`
|
|
|
+
|
|
|
+* **解释**: 这是 `bizGhs\product\classes\ProductClass` 中的方法，用于减少产品库存。因为它是在 `biz-hd` (零售端) 的 `CgRefundClass` 中被调用，但操作的是 `biz-ghs` (批发端) 的 `ProductClass`，这暗示了批发和零售系统之间存在库存同步或共享的逻辑。
|
|
|
+ * **`ProductClass::decreaseStock`**: 我们来查找 `biz-ghs/product/classes/ProductClass.php` 文件，查看 `decreaseStock` 的实现。
|
|
|
+
|
|
|
+
|
|
|
+Read file: biz-ghs/product/classes/ProductClass.php
|
|
|
+好的，我们继续深入 `ProductClass::decreaseStock($productId, $itemNumBundle, $itemNumPiece, $checkStock = false, $addSold = true)` 方法。
|
|
|
+
|
|
|
+#### 13. `bizGhs\product\classes\ProductClass::decreaseStock($productId, $itemNumBundle, $itemNumPiece, $checkStock = false, $addSold = true)` (biz-ghs/product/classes/ProductClass.php:932-979)
|
|
|
+
|
|
|
+```php
|
|
|
+932:979:bizGhs/product/classes/ProductClass.php
|
|
|
+ public static function decreaseStock($productId, $itemNumBundle, $itemNumPiece, $checkStock = false, $addSold = true)
|
|
|
+ {
|
|
|
+ $product = self::getLockById($productId); // 获取产品信息并加锁
|
|
|
+ if (empty($product)) {
|
|
|
+ util::fail('没有找到花材');
|
|
|
+ }
|
|
|
+ $mainId = $product->mainId ?? 0;
|
|
|
+ $shopId = $product->shopId ?? 0;
|
|
|
+ $lockKey = self::LOCK_STOCK . $mainId . '_' . $shopId . '_' . $productId; // 构建库存锁键
|
|
|
+ $hasLock = util::lock($lockKey); // 尝试获取库存锁
|
|
|
+ if ($hasLock == false) {
|
|
|
+ util::fail('系统正在处理库存，请稍后再试');
|
|
|
+ }
|
|
|
+
|
|
|
+ $oldStock = $product->stock ?? 0; // 旧库存
|
|
|
+ $ratio = $product->ratio ?? 20; // 转换比例（大单位到小单位）
|
|
|
+ $currentItemNum = self::mergeItemNum($itemNumBundle, $itemNumPiece, $ratio); // 将大小单位数量合并为统一的小单位数量
|
|
|
+
|
|
|
+ $newStock = bcsub($oldStock, $currentItemNum, 2); // 计算新库存
|
|
|
+ if ($checkStock == true) { // 如果需要检查库存
|
|
|
+ if (bccomp($newStock, 0, 2) == -1) { // 如果新库存小于0
|
|
|
+ util::unlock($lockKey); // 释放锁
|
|
|
+ util::fail("花材【{$product->name}】库存不足");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ $product->stock = $newStock; // 更新产品库存
|
|
|
+ $product->save(); // 保存更改
|
|
|
+
|
|
|
+ // 记录每日销售额，用于报表统计
|
|
|
+ $tradeDay = date("Y-m-d");
|
|
|
+ if ($addSold == true) {
|
|
|
+ $month = date("Y-m");
|
|
|
+ StatSaleClass::addDaySaleNum($tradeDay, $product, $currentItemNum, $month); // 记录每日销售数量
|
|
|
+ StatSaleClass::addProductNum($product, $currentItemNum); // 记录产品总销售数量
|
|
|
+ }
|
|
|
+
|
|
|
+ util::unlock($lockKey); // 释放锁
|
|
|
+
|
|
|
+ return ['oldStock' => $oldStock, 'newStock' => $newStock];
|
|
|
+ }
|
|
|
+```
|
|
|
+
|
|
|
+**方法概览**: `decreaseStock` 方法用于减少特定产品的库存。它会先获取产品信息并加锁以防止并发问题，然后根据传入的大小单位数量计算出统一的小单位数量，更新库存，并在需要时进行库存不足检查。同时，它还会记录销售数据并释放锁。
|
|
|
+
|
|
|
+**参数解释**:
|
|
|
+* `$productId`: 要减少库存的产品 ID。
|
|
|
+* `$itemNumBundle`: 大单位的数量（例如，“扎”的数量）。
|
|
|
+* `$itemNumPiece`: 小单位的数量（例如，“枝”的数量）。
|
|
|
+* `$checkStock`: 布尔值，默认为 `false`。如果为 `true`，则在减少库存前检查库存是否充足，如果不足则抛出错误。
|
|
|
+* `$addSold`: 布尔值，默认为 `true`。如果为 `true`，则会更新产品的销售统计数据。
|
|
|
+
|
|
|
+**详细步骤解析**:
|
|
|
+
|
|
|
+1. **获取产品信息并加锁**:
|
|
|
+ ```php
|
|
|
+ $product = self::getLockById($productId);
|
|
|
+ if (empty($product)) {
|
|
|
+ util::fail('没有找到花材');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 调用 `ProductClass::getLockById($productId)` 获取产品信息。`getLockById` 方法会获取数据库行级锁，确保在当前操作期间，其他事务无法修改该产品的库存数据，从而避免并发问题。如果找不到产品，则返回错误。
|
|
|
+ * **`ProductClass::getLockById($productId)`**: 这同样继承自 `common\base\classes\BaseClass::getLockById`，并最终通过 `common\base\models\Base::getLockById` 来获取产品模型实例并加锁。
|
|
|
+
|
|
|
+2. **获取自定义库存锁**:
|
|
|
+ ```php
|
|
|
+ $mainId = $product->mainId ?? 0;
|
|
|
+ $shopId = $product->shopId ?? 0;
|
|
|
+ $lockKey = self::LOCK_STOCK . $mainId . '_' . $shopId . '_' . $productId;
|
|
|
+ $hasLock = util::lock($lockKey);
|
|
|
+ if ($hasLock == false) {
|
|
|
+ util::fail('系统正在处理库存，请稍后再试');
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 除了数据库行级锁，这里还实现了一个基于 Redis 的自定义锁机制，进一步确保并发安全。
|
|
|
+ * `$lockKey`: 根据 `mainId` (主站ID)、`shopId` (门店ID) 和 `productId` 构建一个唯一的锁键。
|
|
|
+ * `util::lock($lockKey)`: 尝试获取这个自定义锁。如果获取失败，说明有其他进程正在处理该产品的库存，此时会返回错误信息，让用户稍后重试。
|
|
|
+ * **`util::lock($key, $expire = 5, $waitTime = 5)`**: (common/components/util.php:361-396)
|
|
|
+ ```php
|
|
|
+ 361:396:common/components/util.php
|
|
|
+ public static function lock($key, $expire = 5, $waitTime = 5)
|
|
|
+ {
|
|
|
+ // ... 尝试获取 Redis 锁，如果获取失败则等待一段时间后重试，直到超时或获取成功
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这是一个基于 Redis 实现的分布式锁。它会尝试在 Redis 中设置一个带有过期时间的键。如果键已经存在，它会等待一段 `waitTime` 后重试，直到获取锁成功或达到重试上限。这是一种乐观锁的实现，用于在高并发场景下控制对共享资源的访问。
|
|
|
+
|
|
|
+3. **记录旧库存**:
|
|
|
+ ```php
|
|
|
+ $oldStock = $product->stock ?? 0;
|
|
|
+ ```
|
|
|
+ * **解释**: 记录当前产品的原始库存数量。
|
|
|
+
|
|
|
+4. **单位转换和数量合并**:
|
|
|
+ ```php
|
|
|
+ $ratio = $product->ratio ?? 20;
|
|
|
+ $currentItemNum = self::mergeItemNum($itemNumBundle, $itemNumPiece, $ratio);
|
|
|
+ ```
|
|
|
+ * **解释**: `ratio` 是产品的大单位和小单位之间的转换比例（例如，1 扎 = 20 枝）。
|
|
|
+ * `ProductClass::mergeItemNum($itemNumBundle, $itemNumPiece, $ratio)`: 调用 `ProductClass` 内部的静态方法，将传入的大单位数量 (`$itemNumBundle`) 和小单位数量 (`$itemNumPiece`) 结合 `ratio` 转换成一个统一的小单位总数量 (`$currentItemNum`)。
|
|
|
+ * **`ProductClass::mergeItemNum($bigNum, $smallNum, $unitNum)`**: (biz-ghs/product/classes/ProductClass.php:827-837)
|
|
|
+ ```php
|
|
|
+ 827:837:bizGhs/product/classes/ProductClass.php
|
|
|
+ public static function mergeItemNum($bigNum, $smallNum, $unitNum)
|
|
|
+ {
|
|
|
+ $bigStock = bcmul($bigNum, $unitNum, 2); // 大单位转换为小单位
|
|
|
+ $total = bcadd($bigStock, $smallNum, 2); // 加上小单位数量
|
|
|
+ return $total;
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这个方法负责将大单位数量和小单位数量合并成一个统一的小单位总数量。它将大单位数量乘以 `unitNum` (即 `ratio`) 转换为小单位数量，然后与传入的小单位数量相加。
|
|
|
+
|
|
|
+5. **计算新库存并检查库存不足**:
|
|
|
+ ```php
|
|
|
+ $newStock = bcsub($oldStock, $currentItemNum, 2);
|
|
|
+ if ($checkStock == true) {
|
|
|
+ if (bccomp($newStock, 0, 2) == -1) {
|
|
|
+ util::unlock($lockKey); // 库存不足时释放锁
|
|
|
+ util::fail("花材【{$product->name}】库存不足");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 使用 `bcsub` (高精度减法) 计算新的库存数量。
|
|
|
+ * 如果 `$checkStock` 为 `true`，则进一步检查 `newStock` 是否小于 0。如果小于 0，说明库存不足，此时会先调用 `util::unlock($lockKey)` 释放之前获取的自定义锁，然后返回错误信息。
|
|
|
+
|
|
|
+6. **更新产品库存并保存**:
|
|
|
+ ```php
|
|
|
+ $product->stock = $newStock;
|
|
|
+ $product->save();
|
|
|
+ ```
|
|
|
+ * **解释**: 将计算出的 `$newStock` 赋值给 `$product->stock` 属性，并调用 `$product->save()` 将更新后的库存数量保存到数据库。
|
|
|
+
|
|
|
+7. **记录销售数据**:
|
|
|
+ ```php
|
|
|
+ if ($addSold == true) {
|
|
|
+ $tradeDay = date("Y-m-d");
|
|
|
+ $month = date("Y-m");
|
|
|
+ StatSaleClass::addDaySaleNum($tradeDay, $product, $currentItemNum, $month);
|
|
|
+ StatSaleClass::addProductNum($product, $currentItemNum);
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 如果 `$addSold` 为 `true`，则会更新产品的销售统计数据。
|
|
|
+ * **`StatSaleClass::addDaySaleNum(...)`**: (将在后续解释) 记录每日销售数量。
|
|
|
+ * **`StatSaleClass::addProductNum(...)`**: (将在后续解释) 记录产品总销售数量。
|
|
|
+ * **`StatSaleClass`**: 这个类应该在 `biz/stat/classes/` 目录下。
|
|
|
+
|
|
|
+8. **释放自定义库存锁**:
|
|
|
+ ```php
|
|
|
+ util::unlock($lockKey);
|
|
|
+ ```
|
|
|
+ * **解释**: 调用 `util::unlock($lockKey)` 释放之前获取的自定义锁，允许其他进程继续处理该产品的库存。
|
|
|
+ * **`util::unlock($key)`**: (common/components/util.php:397-402)
|
|
|
+ ```php
|
|
|
+ 397:402:common/components/util.php
|
|
|
+ public static function unlock($key)
|
|
|
+ {
|
|
|
+ Yii::$app->redis->executeCommand('DEL', [$key]);
|
|
|
+ }
|
|
|
+ ```
|
|
|
+ * **解释**: 这个方法通过执行 Redis 的 `DEL` 命令来删除指定的锁键，从而释放锁。
|
|
|
+
|
|
|
+9. **返回旧库存和新库存**:
|
|
|
+ ```php
|
|
|
+ return ['oldStock' => $oldStock, 'newStock' => $newStock];
|
|
|
+ ```
|
|
|
+ * **解释**: 返回一个包含旧库存和新库存的数组，供调用方使用。
|
|
|
+
|
|
|
+---
|
|
|
+
|
|
|
+现在，我们来详细解释 `ProductClass::decreaseStock` 中可能调用的其他关键函数和类：
|
|
|
+
|
|
|
+#### 14. `bizGhs\stock\classes\StockRecordClass::hdCgApplyRefundAddRecord($recordData)`
|
|
|
+
|
|
|
+* **解释**: 这是 `bizGhs\stock\classes\StockRecordClass` 中的方法，用于记录采购退款导致的库存变动。
|
|
|
+ * **`StockRecordClass`**: 这个类应该在 `bizGhs/stock/classes/` 目录下。
|
|
|
+
|
|
|
+#### 15. `common\components\dict::getDict($type, $key)`
|
|
|
+
|
|
|
+* **解释**: 这是一个从字典中获取配置值的工具方法。它应该位于 `common/components/dict.php` 文件中。
|
|
|
+ * `dict::getDict('onlinePay', 'yes')`: 获取在线支付方式中“是”的值。
|
|
|
+ * `dict::getDict('payWay', 'wxPay')`: 获取支付方式中“微信支付”的值。
|
|
|
+ * `dict::getDict('payWay', 'alipay')`: 获取支付方式中“支付宝支付”的值。
|
|
|
+
|
|
|
+#### 16. `bizHd\ghs\classes\GhsClass::getLockById($ghsId)`
|
|
|
+
|
|
|
+* **解释**: 这是一个从 `bizHd\ghs\classes\GhsClass` 中获取供货商信息并加锁的方法。它最终会追溯到 `common\base\models\Base::getLockById`。
|
|
|
+ * 它将查询 `Ghs` 模型（对应数据库表可能是 `hdGhs` 或类似命名）。
|
|
|
+
|
|
|
+#### 17. `common\components\lakala\Lakala`
|
|
|
+
|
|
|
+* **解释**: 这是一个拉卡拉支付接口的封装类，用于与拉卡拉支付平台进行交互。
|
|
|
+ * `new Lakala($params)`: 创建 `Lakala` 类的实例，传入包含 `appid`, `serial_no`, `merchant_no`, `term_no`, `merchantPrivateKeyPath`, `lklCertificatePath` 等参数。
|
|
|
+ * `$laResource->refund($aliParams)`: 调用 `Lakala` 实例的 `refund` 方法执行实际的退款操作，传入退款单号、原始订单号、退款金额、退款原因、第三方订单号等参数。
|
|
|
+
|
|
|
+至此，`actionCreateOrder` 方法及其内部调用的主要函数和类的解释已经比较详细和深入了。如果还有任何疑问或想深入了解其他部分，请随时提出。
|
