baoshi-was/app/Services/WorkOrderService.php

<?php

namespace App\Services;

use App\OrderIssue;
use App\OrderIssueProcessLog;
use App\OrderIssueRejectedBill;
use App\OrderIssueType;
use App\OrderPackage;
use App\Traits\ModelLogChanging;
use App\Traits\ServiceAppAop;
use App\WorkOrder;
use App\WorkOrderDetail;
use Illuminate\Support\Facades\Auth;

class WorkOrderService
{
    use ServiceAppAop;

    protected $modelClass = WorkOrder::class;

    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);
        $this->logService->createLog($detail, '完结', '完结工单');
        $workOrder->changeStatus('完成');
        $workOrder->update([
            'owner_tag' => 0,
            'logistic_tag' => 0,
            'bao_shi_tag' => 0,
        ]);
    }

    /**
     * 商家完结工单
     * @param WorkOrderDetail $detail
     */
    public function ownerEndWorkOrderDetail(WorkOrderDetail $detail)
    {
        $this->logService->createLog($detail, '完结', '货主完结');
        $detail->change('完成', '完成', '待货主完结');
        $detail->workOrder->change('完成', '完成', '待货主完结');
        $detail->workOrder->update([
            'owner_tag' => 0,
            'logistic_tag' => 0,
            'bao_shi_tag' => 0,
        ]);
        $this->detailService->endDetail($detail);                       // 标记为处理过
    }

    /**
     * 商家批量完结工单
     * @param $details
     */
    public function ownerBatchEndWorkOrderDetails($details)
    {
        foreach ($details as $detail) {
            $this->ownerEndWorkOrderDetail($detail);
        }
    }

    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, '处理', '处理中');
        $detail->change('承运商处理', '承运商处理中', $detail->last_status);
        $detail->workOrder->change('承运商处理', '承运商处理中', $detail->last_status);
        if ($detail->workOrder->work_order_status === '1') {
            $detail->workOrder()->update([
                'logistic_tag' => 1,
                'owner_tag' => 0,
                'bao_shi_tag' => 0,
                '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);
    }

    /**
     * 每日工单定时任务timingTask
     */
    public function timingTask()
    {
        $this->updateBaoShiHandlerTask();
        $this->updateLogisticHandlerTask();
    }

    private function updateLogisticHandlerTask()
    {
        // 将当日承运商处理过 且 状态为`无`的 标记为滞留状态 `滞`
        WorkOrder::query()->where('status', 3)
            ->where('logistic_tag', 1)
            ->update(['logistic_tag' => 2]);
    }

    private function updateBaoShiHandlerTask()
    {
        // 将当日宝时处理过 且 状态为`无`的 标记为滞留状态 `滞`
        WorkOrder::query()->whereIn('status', [1, 4])
            ->where('bao_shi_tag', 1)
            ->update(['bao_shi_tag' => 2]);
    }

    /**
     * 同步处理日志到问题件
     * @param WorkOrderDetail $detail
     */
    public function syncOrderIssueProcessLogs(WorkOrderDetail $detail)
    {
        /**
         * @var OrderIssue $order_issue
         * @var WorkOrder $work_order
         */
        $work_order = $detail->workOrder;
        $order_issue = OrderIssue::query()->where('order_id', $work_order->order_id)->first();
        if (!$order_issue) {
            $order_issue = OrderIssue::query()->create([
                'order_id' => $work_order->order_id,
                'result_explain' => $work_order->remark,
                'imported_status' => '正常',
                'order_issue_type_id' => $detail->order_issue_type_id,
            ]);
            OrderIssueProcessLog::query()
                ->create(['order_issue_id' => $order_issue->id, 'content' => '创建', 'user_id' => Auth::id(), 'type' => '创建','created_at' => $detail->workOrder->created_at]);
        }
        $process_logs = $detail->processLogs()->where('status', '未同步')->get();
        $order_issue->logs()->insert($process_logs->map((function ($process_log) use ($order_issue) {
            return [
                'order_issue_id' => $order_issue->id,
                'user_id' => $process_log->user_id,
                'content' => $process_log->content,
                'created_at' => $process_log->created_at,
                'updated_at' => $process_log->updated_at,
            ];
        }))->toArray());
        $detail->processLogs()->where('status', '未同步')->update(['status' => '同步']);
    }

}