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\User;
use App\WorkOrder;
use App\WorkOrderType;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Auth;

class WorkOrderService
{
    use ServiceAppAop;

    protected $modelClass = WorkOrder::class;

    /**
     * 获取可生成工单的问题件类型
     * @return Builder[]|Collection
     */
    public function getIssueType()
    {
        $user = Auth::user();
        $logistic_ids = App('UserService')->getPermittingLogisticIds($user);
        if ($user->isSuperAdmin() || count($logistic_ids) == 0 ){
            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 createAndNotification($order, $orderIssueType, $remake): WorkOrder
    {
        $user = Auth::user();
        /** @var WorkOrder $workOrder */
        $workOrder = WorkOrder::query()->create([
            'order_id' => $order->id,
            'creator_id' => $user["id"],
            'owner_id' => $order->owner_id,
            'remark' => $remake,
            'outer_table_name' => 'orders',
            'order_issue_type_id' => $orderIssueType->id,
            'uniquely_tag' => $order->code,
            'status' => 1,
        ]);
        $workOrder->notification();
        return $workOrder;
    }

    /**
     * 拦截
     */
    public function createInterceptWorkOrder($param): WorkOrder
    {
        $orderIssueType = OrderIssueType::query()->firstOrCreate(['name' => '拦截']);
        $order = Order::query()->where('code', $param['order_no'])->first();
        $remake = '拦截订单';
        return $this->createAndNotification($order, $orderIssueType, $remake);
    }

    /**
     * 错漏发
     */
    public function createMistakeWorkOrder($param): WorkOrder
    {
        $orderIssueType = OrderIssueType::query()->firstOrCreate(['name' => '错漏发']);
        $order = Order::query()->where('code', $param['order_no'])->first();
        $remake = $param['remark'] ?? '';
        return $this->createAndNotification($order, $orderIssueType, $remake);
    }

    /**
     * 破损
     */
    public function createDamagedWorkOrder($param): WorkOrder
    {
        $orderIssueType = OrderIssueType::query()->firstOrCreate(['name' => '破损']);
        $order = Order::query()->where('code', $param['order_no'])->first();
        $remake = $param['remark'] ?? '';

        $workOrderImageService = app('WorkOrderImageService');

        $workOrder = $this->createAndNotification($order, $orderIssueType, $remake);

        $workOrderImageService->createWorkOrderPackageImages($workOrder,$param['packageImages']);

        $workOrderImageService->createWorkOrderCommodityImages($workOrder,$param['commodityImages']);

        $workOrderImageService->createWorkOrderDealImages($workOrder,$param['dealImages']);

        app('WorkOrderDetailService')->createWorkOrderDetail($workOrder,$param);

        app('WorkOrderCommoditiesService')->createWorkOrderCommoditiesByJsonArray($workOrder,$param['commodities']); // 登记商品信息
        return $workOrder;
    }

    /***
     * 快递异常
     */
    public function createExpressAbnormalWorkOrder($param): WorkOrder
    {
        $orderIssueType = OrderIssueType::query()->firstOrCreate(['name'=>  '快递异常']);
        $order = Order::query()->where('code', $param['order_no'])->first();
        $remake = $param['remark'] ?? '';
        return $this->createAndNotification($order, $orderIssueType, $remake);
    }

    /***
     * 信息更改
     */
    public function createInformationChangeWorkOrder($param): WorkOrder
    {
        $orderIssueType = OrderIssueType::query()->firstOrCreate(['name' => '信息更改']);
        $order = Order::query()->where('code', $param['order_no'])->first();
        $remake = $param['remark'] ?? '';
        return $this->createAndNotification($order, $orderIssueType, $remake);
    }

    /**
     * 其他
     */
    public function createDefaultWorkOrder($param): WorkOrder
    {
        $orderIssueType = OrderIssueType::query()->firstOrCreate(['name' => '其他']);
        $order = Order::query()->where('code', $param['order_no'])->first();
        $remake = $param['remark'] ?? '';
        return $this->createAndNotification($order, $orderIssueType, $remake);
    }

    /**
     * 快递丢件
    */
    public function createLossWorkOrder($param):WorkOrder
    {
        $orderIssueType = OrderIssueType::query()->firstOrCreate(['name' => '快递丢件']);
        $order = Order::query()->where('code', $param['order_no'])->first();
        $remake = $param['remark'] ?? '';
        return $this->createAndNotification($order, $orderIssueType, $remake);
    }

    /**
     *  填充丢件信息
    */
    public function fillLossWorkOrder(WorkOrder $workOrder, $param): WorkOrder
    {
        $workOrder->saveWorkOrderDetail($param);        // 收方信息 丢件价值 补发单号
        $workOrder->addDealImage($param['dealImages']); // 交易截图
        $workOrder->addRefundImage($param['refundImages']); // 退款截图
        return $workOrder;
    }

    /**
     * 工单审核
     * @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 Builder $query */
            $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 Builder $query */
            $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();
    }


}