baoshi-was/app/Services/WorkOrderService.php

<?php

namespace App\Services;

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

class WorkOrderService
{
    use ServiceAppAop;

    protected $modelClass = WorkOrder::class;

    public $logService;
    public $imageService;
    public $commoditiesService;
    public $detailService;
    public $issueTypeService;
    public $orderService;
    public $orderIssueService;
    public $orderIssueProcessLogService;

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

    public function createOrResetWorkOrder($order, $issueType, $remark, $process_progress = '商家创建')
    {
        $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' => Auth::id() ?? '',
                'status' => WorkOrder::$DEFAULT_STATUS,
                'process_progress' => $process_progress,
                'type' => $process_progress,
                'last_handler_id' => Auth::id() ?? '',
                'created_at' => now(),
            ]);
            SyncOrderIssueOrWorkOrderBySWMS::dispatch($workOrder,SyncOrderIssueOrWorkOrderBySWMS::$WORK_ORDER_TYPE);
            return $workOrder;
        }
        $workOrder  = WorkOrder::query()->create([
            'order_id' => $order->id,
            'logistic_id' => $order->logistic_id ?? '',
            'owner_id' => $order->owner_id ?? '',
            'creator_id' => Auth::id() ?? '',
            'remark' => $remark,
            'outer_table_name' => 'orders',
            'order_issue_type_id' => $issueType->id,
            'uniquely_tag' => $order->code,
            'status' => WorkOrder::$DEFAULT_STATUS,
            'process_progress' => $process_progress,
            'type' => $process_progress,
            'last_handler_id' => Auth::id() ?? '',
        ]);
        SyncOrderIssueOrWorkOrderBySWMS::dispatch($workOrder,SyncOrderIssueOrWorkOrderBySWMS::$WORK_ORDER_TYPE);
        return $workOrder;
    }

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


    /**
     * @param WorkOrder $workOrder
     * @param WorkOrderDetail $detail
     */
    public function end(WorkOrder $workOrder, WorkOrderDetail $detail)
    {
        $this->detailService->endDetail($detail);
        $workOrder->update([
            'status' => WorkOrder::$END_STATUS,
            'owner_tag' => WorkOrder::$DEFAULT_TAG,
            'logistic_tag' => WorkOrder::$DEFAULT_TAG,
            'bao_shi_tag' => WorkOrder::$DEFAULT_TAG,
            'work_order_status' => 0,
        ]);
        $this->logService->createLog($detail, '完结', '完结工单');
    }

    /**
     * 商家完结工单
     * @param WorkOrderDetail $detail
     */
    public function ownerEndWorkOrderDetail(WorkOrderDetail $detail)
    {
        $detail->update([
            'status' => WorkOrder::$END_STATUS,
            'process_progress' => '完成',
            'last_status' => WorkOrder::$TO_BO_OWNER_END_STATUS,
        ]);
        $detail->workOrder()->update([
            'status' => WorkOrder::$END_STATUS,
            'process_progress' => '完成',
            'last_status' => WorkOrder::$TO_BO_OWNER_END_STATUS,
            'owner_tag' => WorkOrder::$DEFAULT_TAG,
            'logistic_tag' => WorkOrder::$DEFAULT_TAG,
            'bao_shi_tag' => WorkOrder::$DEFAULT_TAG,
            'work_order_status' => 0,
        ]);
        $this->detailService->endDetail($detail);                       // 标记为处理过
        $this->logService->createLog($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();
        $codes = [];
        foreach ($order_issues as $order_issue) {
            $codes[$order_issue->order_id] = true;
        }
        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();
        $last_status = WorkOrder::$enums['status'][$detail->status];
        $detail->update([
            'status' => WorkOrder::$LOGISTIC_HANDLER_STATUS,
            'process_progress' => '承运商处理中',
            'last_status' => $last_status,
            'logistic_handle_tag' => 1,
        ]);
        $detail->workOrder()->update([
            'status' => WorkOrder::$LOGISTIC_HANDLER_STATUS,
            'process_progress' => '承运商处理中',
            'last_status' => $last_status,
            'logistic_tag' => WorkOrder::$NO_STATE_TAG,
            'owner_tag' => WorkOrder::$DEFAULT_TAG,
            'bao_shi_tag' => WorkOrder::$DEFAULT_TAG,
            'work_order_status' => WorkOrder::$DEFAULT_TAG,
        ]);
        $detail->processLogs()->create([
            'work_order_id' => $detail->work_order_id,
            'work_order_detail_id' => $detail->id,
            'user_id' => Auth::id(),
            'content' => '承运商标记在处理',
            'status' => '未同步',
            'type' => '处理',
        ]);
        app(WorkOrderLogService::class)->createLog($detail, '处理', '标记处理中');
    }

    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', WorkOrder::$NO_STATE_TAG)
            ->update(['logistic_tag' => WorkOrder::$STRAND_TAG]);
    }

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

    /**
     * 同步处理日志到问题件
     * @param WorkOrderDetail $detail
     */
    public function endOrderIssueAndSyncProcessLogs(WorkOrderDetail $detail)
    {
        /**
         * @var OrderIssue $order_issue
         * @var WorkOrder $work_order
         */
        $work_order = $detail->workOrder;
        $order_issue = OrderIssue::query()->withTrashed()->where('order_id', $work_order->order_id)->first();
        if($order_issue->deleted_at ?? false){
            $order_issue->restore();
        }
        $orderIssueType = app(OrderIssueTypeService::class)->firstOrCreate(['name' => '错漏发']);
        $expressAbnormal = app(OrderIssueTypeService::class)->firstOrCreate(['name' => '快递异常']);
        $loss = app(OrderIssueTypeService::class)->firstOrCreate(['name' => '快递丢件']);
        $orderIssueTypeId = $detail->order_issue_type_id;
        if($detail->order_issue_type_id == $expressAbnormal->id && $detail->process_progress == "丢件赔偿"){
            $orderIssueTypeId = $loss->id;
        }
        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' => $orderIssueTypeId,
            ]);
            $order_issue->update(['created_at' => $detail->created_at]);
        } else {
            $order_issue->update(['order_issue_type_id' => $orderIssueTypeId]);
        }

        $order_issue->update([
            'logistic_indemnity_money' => $work_order->logistic_indemnity_money,
            'logistic_express_remission' => $work_order->logistic_express_remission,
            'baoshi_indemnity_money' => $work_order->bao_shi_indemnity_money,
            'baoshi_express_remission' => $work_order->bao_shi_express_remission,
            'user_owner_group_id' => $work_order->user_owner_group_id,
        ]);

        $work_order_user_workgroup_ids = $work_order->userWorkGroups()->get()->map(function ($item) {
            return $item->id;
        })->toArray();

        $order_issue_work_groups = $order_issue->userWorkgroups()->get()->map(function ($item) {
            return $item->id;
        })->toArray();
        $order_issue->userWorkgroups()->attach(array_diff($work_order_user_workgroup_ids, $order_issue_work_groups));
        $process_logs = $detail->processLogs()->where('status', '未同步')->get();


        $processLogs = $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,
                'type' => $process_log->type,
                'tag' => $process_log->tag,
            ];
        }))->toArray();
        if ($detail->order_issue_type_id == $orderIssueType->id) {
            $commodityLog = $detail->commodities()->where('check_result', '!=', '核实未错漏发')->get()->map(function ($item) use ($order_issue) {
                $count = 0;
                $abnormalAmount = intval($item->abnormal_amount);
                $baoShiCheckAmount = intval($item->bao_shi_check_amount);
                if ($item->abnormal_type === '少发') {
                    $count = $baoShiCheckAmount  - $abnormalAmount;
                } else if ($item->abnormal_type === '多发') {
                    $count =  $abnormalAmount- $baoShiCheckAmount;
                }
                return [
                    'order_issue_id' => $order_issue->id,
                    'user_id' => Auth::id(),
                    'content' => $item->sku . ' ' . $item->commodity->name . ' ' . $item->abnormal_type . '(' . $count.')',
                    'created_at' => $item->updated_at,
                    'updated_at' => $item->updated_at,
                    'type' => '处理',
                    'tag' => 0
                ];
            })->toArray();
            $processLogs = array_merge($commodityLog, $processLogs);
        }
        $order_issue->logs()->insert($processLogs);
        $this->orderIssueService->endOrderIssues([$order_issue->id]);
        $detail->processLogs()->where('status', '未同步')->update(['status' => '同步']);
    }

    public function customRejectedStatus($ids, $customRejectedStatus): int
    {
        return WorkOrder::query()->whereIn('id', $ids)->update(['custom_rejected_status' => $customRejectedStatus]);
    }

    public function check($logisticNumbers,$orderIssueType)
    {
        $orderPackages = OrderPackage::query()->select(["id",'order_id',"logistic_number"])->whereIn("logistic_number",$logisticNumbers)->get();
        if(count($orderPackages) != count($logisticNumbers)){
            $array = array_diff($logisticNumbers,$orderPackages->map(function($item){return $item->logistic_number;})->toArray());
            return ['success' => false,'message'=> '未找到对应的订单快递单号:'.join(",",$array) ];
        }
        $orderIds = $orderPackages->map(function ($item){return $item->order_id;})->toArray();
        $workOrders = WorkOrder::query()->whereIn('order_id',$orderIds)->get();
        $issueType = $this->issueTypeService->firstOrCreate(['name' => $orderIssueType]);

        $workOrderDetails = WorkOrderDetail::query()->whereIn('work_order_id',$workOrders->map(function($item){
            return $item->id;
        }))->where('order_issue_type_id',$issueType->id)->get();
        if(count($workOrderDetails) > 0 ){
            $workOrderDetailIds = $workOrderDetails->map(function($item){
                return $item->work_order_id;
            })->toArray();
            $checkOrderIds = $workOrders->filter(function($item)use($workOrderDetailIds){
                return in_array($item->id,$workOrderDetailIds);
            })->map(function ($item){
                return $item->order_id;
            })->toArray();

            $items = $orderPackages->filter(function($item)use($checkOrderIds){
                return in_array($item->order_id,$checkOrderIds);
            })->map(function($item){
                return $item->logistic_number;
            })->toArray();
            return ['success' => false,"message" => "已有对应的".$orderIssueType."工单：".join(",",$items)];
        }
        return ['success' => true];
    }

}