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\WorkOrderProcessLog;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Gate;

class WorkOrderService
{
    use ServiceAppAop;

    protected $modelClass = WorkOrder::class;

    /**
     * @var WorkOrderLogService $logService
     * @var WorkOrderImageService $imageService
     * @var WorkOrderCommoditiesService $commoditiesService
     * @var WorkOrderDetailService $detailService
     * @var OrderIssueTypeService $issueTypeService
     * @var OrderService $orderService
     */
    private $logService;
    private $imageService;
    private $commoditiesService;
    private $detailService;
    private $issueTypeService;
    private $orderService;

    public function __construct(WorkOrderLogService $logService,
                                WorkOrderImageService $imageService,
                                WorkOrderCommoditiesService $commoditiesService,
                                WorkOrderDetailService $detailService,
                                OrderIssueTypeService $issueTypeService,
                                OrderService $orderService)
    {
        $this->logService = $logService;
        $this->imageService = $imageService;
        $this->commoditiesService = $commoditiesService;
        $this->detailService = $detailService;
        $this->issueTypeService = $issueTypeService;
        $this->orderService = $orderService;
    }

    /**
     * 获取可生成工单的问题件类型
     * @return Builder[]|Collection
     */
    public function getIssueType()
    {
        if (Gate::allows('订单管理-工单处理-客服编辑') || Gate::allows('订单管理-工单处理-货主编辑')) {
            return OrderIssueType::query()->whereIn('name', ['拦截', '信息更改', '其他', '快递异常', '错漏发', '破损', '快递丢件'])->get();
        } else if (Gate::allows('订单管理-工单处理-承运商编辑')) {
            return OrderIssueType::query()->whereIn('name', ['拦截', '信息更改', '破损', '快递丢件', '快递异常'])->get();
        }
        return OrderIssueType::query()->whereIn('name', ['拦截', '信息更改', '其他', '快递异常', '错漏发', '破损', '快递丢件'])->get();
    }

    /**
     * 生成工单
     * @param $params
     * @return array|bool[]
     */
    public function build($params): array
    {
        foreach ($params as $param) {
            $type_name = $param['order_issue_type'];
            if ('拦截' == $type_name) {
                $this->createInterceptWorkOrder($param);
            } else if ('信息更改' == $type_name) {
                $this->createInformationChangeWorkOrder($param);
            } else if ('快递异常' == $type_name) {
                $this->createExpressAbnormalWorkOrder($param);
            } else if ('错漏发' == $type_name) {
                $this->createMistakeWorkOrder($param);
            } else if ('破损' == $type_name) {
                $this->createDamagedWorkOrder($param);
            } else if ('快递丢件' == $type_name) {
                $this->createLossWorkOrder($param);
            } else {
                $this->createDefaultWorkOrder($param);
            }
        }
        return ['success' => true];
    }

    public function createWorkOrder($order, $issueType, $remark)
    {
        $user = Auth::user();

        return WorkOrder::query()->create([
            'order_id' => $order->id,
            'logistic_id' => $order->logistic_id ?? '',
            'owner_id' => $order->owner_id ?? '',
            'creator_id' => $user['id'] ?? '',
            'remark' => $remark,
            'outer_table_name' => 'orders',
            'order_issue_type_id' => $issueType->id,
            'uniquely_tag' => $order->code,
            'status' => 0,
        ]);
    }

    public function createAndNotification($order, $orderIssueType, $remark): WorkOrder
    {
        /** @var WorkOrder $workOrder */
        $workOrder = $this->createWorkOrder($order, $orderIssueType, $remark);

        $workOrder->notification();

        return $workOrder;
    }

    /**
     * 拦截
     */
    public function createInterceptWorkOrder($param): WorkOrder
    {
        $issueType = $this->issueTypeService->firstOrCreate(['name' => '拦截']);

        $order = $this->orderService->first(['code' => $param['order_no']]);

        $remark = $param['remark'] ?? '拦截工单';

        $workOrder = $this->createAndNotification($order, $issueType, $remark);

        $workOrder->changeStatus('承运商处理');

        $this->logService->createLog($workOrder, '创建', '创建');

        return $workOrder;
    }

    /**
     * 错漏发
     */
    public function createMistakeWorkOrder($param): WorkOrder
    {
        $issueType = $this->issueTypeService->firstOrCreate(['name' => '错漏发']);

        $order = $this->orderService->first(['code' => $param['order_no']]);

        $workOrder = $this->createAndNotification($order, $issueType, $param['remark'] ?? '');

        $this->commoditiesService->createWorkOrderCommoditiesByJsonArray($workOrder, $param['commodities']);

        $workOrder->changeStatus('宝时处理');

        return $workOrder;
    }

    /**
     * 破损
     */
    public function createDamagedWorkOrder($param): WorkOrder
    {
        $issueType = $this->issueTypeService->firstOrCreate(['name' => '破损']);

        $order = $this->orderService->first(['code' => $param['order_no']]);

        $workOrder = $this->createAndNotification($order, $issueType, $param['remark'] ?? '');

        $this->imageService->createWorkOrderImages($workOrder, $param);

        $this->detailService->createWorkOrderDetail($workOrder, $param);

        $this->commoditiesService->createWorkOrderCommoditiesByJsonArray($workOrder, $param['commodities']); // 登记商品信息

        $workOrder->changeStatus('承运商处理');

        $this->logService->createLog($workOrder, '创建', '创建工单');

        return $workOrder;
    }

    /***
     * 快递异常
     */
    public function createExpressAbnormalWorkOrder($param): WorkOrder
    {
        $order = $this->orderService->first(['code' => $param['order_no']]);

        $issueType = $this->issueTypeService->firstOrCreate(['name' => '快递异常']);

        $workOrder = $this->createAndNotification($order, $issueType, $param['remark'] ?? '');

        $this->imageService->createWorkOrderImages($workOrder, $param);

        $this->commoditiesService->createWorkOrderCommoditiesByJsonArray($workOrder, $param['commodities']);

        $workOrder->changeStatus('承运商处理');

        $this->logService->createLog($workOrder, '创建', '创建工单');

        return $workOrder;
    }

    /***
     * 信息更改
     */
    public function createInformationChangeWorkOrder($param): WorkOrder
    {
        $issueType = $this->issueTypeService->firstOrCreate(['name' => '信息更改']);

        $order = $this->orderService->first(['code' => $param['order_no']]);

        $workOrder = $this->createAndNotification($order, $issueType, $param['remark'] ?? '');

        $workOrder->changeStatus('承运商处理');

        $this->logService->createLog($workOrder, '创建', '创建工单');

        return $workOrder;
    }

    /**
     * 其他
     */
    public function createDefaultWorkOrder($param): WorkOrder
    {
        $orderIssueType = $this->issueTypeService->firstOrCreate(['name' => '其他']);

        $order = $this->orderService->first(['code' => $param['order_no']]);

        return $this->createAndNotification($order, $orderIssueType, $param['remark'] ?? '');
    }

    /**
     * 快递丢件
     */
    public function createLossWorkOrder($param): WorkOrder
    {
        $orderIssueType = $this->issueTypeService->firstOrCreate(['name' => '快递丢件']);

        $order = $this->orderService->first(['code' => $param['order_no']]);

        $workOrder = $this->createAndNotification($order, $orderIssueType, $param['remark'] ?? '');

        $workOrder->changeStatus('货主处理');

        $this->logService->createLog($workOrder, '创建', '创建工单');

        return $workOrder;
    }

    /**
     *  填充丢件信息
     */
    public function fillLossWorkOrder(WorkOrder $workOrder, $param): WorkOrder
    {
        $workOrder->saveWorkOrderDetail($param);        // 收方信息 丢件价值 补发单号

        $this->imageService->createWorkOrderImages($workOrder, $param);

        $workOrder->changeStatus('承运商处理');

        $this->logService->createLog($workOrder, '处理', '填充丢件信息');

        $this->commoditiesService->createWorkOrderCommoditiesByJsonArray($workOrder, $param['commodities'] ?? '');

        return $workOrder;
    }

    public function end(WorkOrder $workOrder)
    {
        $workOrder->end();

        $this->logService->createLog($workOrder, '完结', '完结工单');
    }

    public function logisticEnd(WorkOrder $workOrder)
    {
        $workOrder->changeStatus('完成');
        $this->logService->createLog($workOrder, '完结', '承运商完结工单');
    }

    public function find($id): WorkOrder
    {
        /** @var WorkOrder $item */
        $item = WorkOrder::query()->where('id', $id)->first();
        return $item;
    }


    /**
     * 工单审核
     * @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()->defaultWith()->whereIn('id', [$wordOrder['id']])->get();

        $this->tags($workOrders);

        return ['success' => true, 'data' => $workOrders->first()];
    }

    public function baoShiReview(WorkOrder $workOrder,$params)
    {
        $user = Auth::user();

        $workOrder->update(['reviewer_id' => $user['id'], 'review_at' => Carbon::now(), 'status' => '5']);

        $this->logService->createLog($workOrder,'终审','终审完成');

        $this->commoditiesService->updateWorkOrderCommoditiesByJsonArray($workOrder,$params);
    }

    /**
     * 批量审核工单
     * @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()->defaultWith()->whereIn('id', $ids)->get();
        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' => '创建问题件失败'];
        try {
            return app('OrderIssueService')->buildOrderIssue($inner_params);
        } catch (\Exception $e) {
            return ['success' => false, 'message' => '刷新页面后重试'];
        }
    }

    /**
     * 按 指定工单类型 和 唯一标识 确认工单是否存在
     * @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();
    }

    public function tagWorkOrder(&$orders)
    {
        $orderNos = data_get($orders, '*.orderno');
        $workOrders = WorkOrder::query()->with('order')->whereIn('order_id', function ($query) use ($orderNos) {
            $query->from('orders')->select('id')->whereIn('code', $orderNos);
        })->get();
        $tags = [];
        $workOrders->each(function ($workOrder) use (&$tags) {
            $order_code = $workOrder->order->code ?? null;
            if ($order_code) $tags[$order_code] = true;
        });

        foreach ($orders as &$order) {
            if (array_key_exists($order->orderno, $tags)) $order->is_work_order = true;
            else $order->is_work_order = false;
        }
    }

    public function checkWorkOrder($nos)
    {
        return  WorkOrder::query()->defaultWith()->whereIn('order_id', function ($query) use ($nos) {
            $query->from('orders')->selectRaw('id');
            if (is_array($nos))
                $query->whereIn('code', $nos);
            else {
                $query->where('code', $nos);
            }
        })->get();
    }
}