baoshi-was/app/Services/WorkOrderService.php

<?php

namespace App\Services;

use App\Order;
use App\OrderIssue;
use App\OrderIssueType;
use App\OrderPackage;
use App\Traits\ServiceAppAop;
use App\WorkOrder;
use App\WorkOrderType;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Auth;

class WorkOrderService
{
    use ServiceAppAop;

    protected $modelClass = WorkOrder::class;

    protected $work_type_relation = [
        '拦截' => '订单拦截',
        '信息更改' => '订单收件信息修改',
        '其他' => '订单其他异常',
        '快递异常' => '订单快递异常',
        '错漏发' => '快递错漏发',
        '破损' => '快递破损',
    ];

    /**
     * 获取可生成工单的问题件类型
     * @return Builder[]|\Illuminate\Database\Eloquent\Collection
     */
    public function getIssueType()
    {
        return OrderIssueType::query()->whereIn('name', ['拦截', '信息更改', '其他', '快递异常', '错漏发', '破损'])->get();
    }

    /**
     * 生成工单
     * @param $params
     * @return array|bool[]
     */
    public function build($params): array
    {
        $types = [];
        $work_order_types = [];
        $data = Carbon::now();
        $creator_id = Auth::user()['id'];
        $parent = WorkOrderType::query()->firstOrCreate(['name' => '订单', 'prent_id' => 0, 'level' => 1]);
        foreach ($params as $param) {
            $order = Order::query()->where('code', $param['order_no'])->first();
            $type_name = $param['order_issue_type'];
            if (!$param['order_issue_type']) {
                $order_issue_type_id = 0;
                $work_order_type_id = 0;
            } else {
                if (!array_key_exists($type_name, $types)) {
                    $types[$type_name] = OrderIssueType::query()->where('name', $type_name)->first();
                    $work_order_type_name = $this->work_type_relation[$type_name] ?? $type_name;
                    $work_order_types[$type_name] = WorkOrderType::query()->firstOrCreate(
                        ['name' => $work_order_type_name],
                        ['prent_id' => $parent['id'], 'table_name' => 'orders', 'level' => 2]
                    );
                }
                $order_issue_type_id = $types[$type_name]['id'] ?? 0;
                $work_order_type_id = $work_order_types[$type_name]['id'] ?? 0;
            }
            switch ($type_name) {
                case '拦截':
                    $remark = "拦截订单";
                    break;
                case '信息更改':
                case '其他':
                case '快递异常':
                case '错漏发':
                case '破损':
                    $remark = $param['remark'] ?? '';
                    break;
                default:
                    $work_order_type_id = 0;
                    $remark = $param['remark'] ?? '';
                    $order_issue_type_id = 0;
                    break;
            }
            $inner_params[] = [
                'order_id' => $order['id'],
                'creator_id' => $creator_id,
                'work_order_type_id' => $work_order_type_id ?? 0,
                'owner_id' => $order['owner_id'] ?? '',
                'grad' => $param['grad'] ?? 1,
                'remark' => $remark,
                'outer_table_name' => 'orders',
                'order_issue_type_id' => $order_issue_type_id ?? 0,
                'uniquely_tag' => $order['code'] ?? null,
                'status' => 1,
                'created_at' => $data,
                'updated_at' => $data,
            ];
        }
        if (isset($inner_params)) {
            WorkOrder::query()->insert($inner_params);
            return ['success' => true];
        }
        return ['success' => false, 'message' => '参数异常'];
    }

    /**
     * 工单审核
     * @param $wordOrder
     * @return array
     */
    public function review($wordOrder): array
    {
        $wordOrder->update(['reviewer_id' => Auth::user()['id'], 'review_at' => Carbon::now(), 'status' => '2',]);
        $workOrders = WorkOrder::query()->with(['type', 'creator', 'order' => function ($query) {
            /** @var $query Builder */
            $query->with('packages', 'issue', 'logistic');
        }, 'reviewer'])->whereIn('id', [$wordOrder['id']])->get();
        $this->tags($workOrders);
        return ['success' => true, 'data' => $workOrders->first()];
    }

    /**
     * 批量审核工单
     * @param $workOrders
     * @return array
     */
    public function batchReview($workOrders): array
    {
        $ids = $workOrders->map(function ($item) {
            return $item->id;
        })->toArray();
        WorkOrder::query()->whereIn('id', $ids)->update(['review_at' => Carbon::now(), 'reviewer_id' => Auth::user()['id'], 'status' => '2']);
        $wordOrders = WorkOrder::query()->with(['type', 'creator', 'order' => function ($query) {
            /** @var $query Builder */
            $query->with('packages', 'issue', 'logistic');
        }, 'reviewer'])->whereIn('id', $ids)->get();
        $this->tags($wordOrders);
        return ['success' => true, 'data' => $wordOrders];
    }


    /**
     * 生成问题件
     * @param $work_orders
     * @return array
     */
    public function buildOrderIssue($work_orders): array
    {
        foreach ($work_orders as $work_order) {
            $inner_params[] = [
                'order_id' => $work_order->order_id,
                'order_issue_type_id' => $work_order->order_issue_type_id,
                'result_explain' => $work_order->remark,
            ];
        }
        if (!isset($inner_params)) return ['success' => false, 'message' => '创建问题件失败'];
        return app('OrderIssueService')->buildOrderIssue($inner_params);
    }

    /**
     * 按 指定工单类型 和 唯一标识 确认工单是否存在
     * @param $work_order_type_id
     * @param $uniquely_tag
     * @return array|false[]
     */
    public function exists($work_order_type_id, $uniquely_tag): array
    {
        $query = WorkOrder::query()->where('work_order_type_id', $work_order_type_id);
        if (is_array($uniquely_tag)) $query->whereIn('uniquely_tag', $uniquely_tag);
        if (is_string($uniquely_tag)) $query->where('uniquely_tag', $uniquely_tag);
        $items = $query->get();
        if (count($items) > 0) {
            $exists_nos = $items->map(function ($item) {
                return $item->uniquely_tag;
            });
            return ['success' => true, 'data' => $exists_nos];
        }
        return ['success' => false];
    }

    /**
     * 标记已有 问题件的工单
     * @param $workOrders
     */
    public function tags(&$workOrders)
    {
        $order_ids = $workOrders->map(function ($item) {
            return $item->order_id;
        });
        $order_issues = OrderIssue::query()->whereIn('order_id', $order_ids)->get();

        foreach ($order_issues as $order_issue) {
            $codes[$order_issue->order_id] = true;
        }
        if (!isset($codes)) return;
        foreach ($workOrders as &$workOrder) {
            if (array_key_exists($workOrder->order_id, $codes)) $workOrder->is_issue_order = true;
            else  $workOrder->is_issue_order = false;
        }
    }

    /**
     * 判断是否拦截工单
     * @param $logistic_number
     * @return bool
     */
    public function isIntercept($logistic_number): bool
    {
        $package_query = OrderPackage::query()->select('order_id')->where('logistic_number', $logistic_number);
        $order_issue_query = OrderIssueType::query()->select('id')->where('name', '拦截');
        return WorkOrder::query()->whereIn('order_id', $package_query)->whereIn('order_issue_type_id', $order_issue_query)->exists();
    }
}