baoshi-was/app/Services/WorkOrderService.php

<?php

namespace App\Services;

use App\OracleDOCOrderHeader;
use App\Order;
use App\OrderIssue;
use App\OrderIssueRejectedBill;
use App\OrderIssueType;
use App\OrderPackage;
use App\RejectedBill;
use App\Traits\ServiceAppAop;
use App\WorkOrder;
use App\WorkOrderDetail;
use Illuminate\Support\Facades\Auth;

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()
    {
        $this->logService = app(WorkOrderLogService::class);
        $this->imageService = app(WorkOrderImageService::class);
        $this->commoditiesService = app(WorkOrderCommoditiesService::class);
        $this->detailService = app(WorkOrderDetailService::class);
        $this->issueTypeService = app(OrderIssueTypeService::class);
        $this->orderService = app(OrderService::class);
    }

    public function createOrResetWorkOrder($order, $issueType, $remark, $process_progress = '商家创建')
    {
        $user = Auth::user();
        $workOrder = WorkOrder::query()->where('order_id', $order->id)->orderByDesc('created_at')->first();
        if ($workOrder) {
            $this->detailService->undoneTagsByWorkOrder($workOrder);
            $workOrder->update([
                'remark' => $remark,
                'order_issue_type_id' => $issueType->id,
                'creator_id' => $user['id'] ?? '',
                'status' => 0,
                'work_order_status' => 1,
                'process_progress' => $process_progress,
                'type' => $process_progress,
                'last_handler_id' => $user['id'] ?? '',
                'created_at' => now(),
            ]);
            return $workOrder;
        }
        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,
            'work_order_status' => 1,
            'process_progress' => $process_progress,
            'type' => $process_progress,
            'last_handler_id' => $user['id'] ?? '',
        ]);
    }

    public function createAndNotification($order, $orderIssueType, $remark, $process_progress = '商家创建'): WorkOrder
    {
        /** @var WorkOrder $workOrder */
        $workOrder = $this->createOrResetWorkOrder($order, $orderIssueType, $remark, $process_progress);

        $workOrder->notification();

        return $workOrder;
    }


    /**
     * @param WorkOrder $workOrder
     * @param WorkOrderDetail $detail
     */
    public function end(WorkOrder $workOrder, WorkOrderDetail $detail)
    {
        $this->detailService->endDetail($detail);
        $workOrder->clearWorkOrderStatus();
        $this->logService->createLog($detail, '完结', '完结工单');
        $workOrder->changeStatus('完成');
    }

    /**
     * 商家完结工单
     * @param WorkOrderDetail $detail
     */
    public function ownerEndWorkOrderDetail(WorkOrderDetail $detail)
    {
        $this->logService->createLog($detail, '完结', '货主完结');
        $detail->change('完成', '完成', '待货主完结');
        $detail->workOrder->change('完成', '完成', '待货主完结');
        $detail->workOrder->clearWorkOrderStatus();                     // 清除创建标记
        $this->detailService->endDetail($detail);                       // 标记为处理过
    }

    /**
     * @param WorkOrder $workOrder
     * @param WorkOrderDetail $detail
     */
    public function logisticEnd(WorkOrder $workOrder, WorkOrderDetail $detail)
    {
        $this->logService->createLog($detail, '完结', '承运商完结工单');
        $this->detailService->endDetail($detail);
        $workOrder->clearWorkOrderStatus();
        $workOrder->changeStatus('完成');
    }

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

    public function getDefaultWith($id)
    {
        return WorkOrder::query()->defaultWith()->find($id);
    }


    /**
     * 生成问题件
     * @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();
    }

    /**
     * 标记工单
     * @param $orders
     */
    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;
        }
    }

    /**
     * 校验工单是否存在
     * @param $nos
     * @return mixed
     */
    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();
    }

    /**
     * 同步订单
     * @param $order_no
     * @return mixed
     */
    public function syncOrder($order_no)
    {
        return $this->orderService->first(['code' => $order_no]);
    }

    /**
     * 承运商标记在处理
     * @param WorkOrderDetail $detail
     */
    public function logisticHandlerTag(WorkOrderDetail $detail)
    {
        $detail->logisticTagHandle();
        app(WorkOrderLogService::class)->createLog($detail,'处理','处理中');
        $last_status = $detail->last_status;
        $detail->change('承运商处理','承运商处理中',$last_status);
        $detail->workOrder->change('承运商处理','承运商处理中',$last_status);
        if ($detail->workOrder->work_order_status === '1')
            $detail->workOrder->update(['work_order_status' => 0]);

    }

    public function syncWorkOrder($rejectedBill)
    {
        /** @var OrderIssue $order_issue */
        $orderIssueRejectedBill = OrderIssueRejectedBill::query()->where('logistic_number_return',$rejectedBill['logistic_number_return'])->first();
        $order_issue = OrderIssue::query()->find($orderIssueRejectedBill->order_issue_id);
        if (!$order_issue || $order_issue->rejecting_status !== '全部退回') return ;
        /** @var WorkOrderInterceptService $workOrderInterceptService */
        $workOrderInterceptService = app(WorkOrderInterceptService::class);
        /** @var WorkOrder $workOrder */
        $workOrder = WorkOrder::query()->where('order_id',$order_issue->order_id)->orderByDesc('created_at')->first();
        if (!$workOrder)return ;
        $workOrderInterceptService->autoReviewIntercept($workOrder);
    }
}