bike-admin/app/Http/Controllers/App/WorkOrderController.php

<?php

namespace App\Http\Controllers\App;

use App\Filters\WorkOrderFilter;
use App\Http\Resources\App\WorkOrderResource;
use App\Http\Resources\WarningLogResource;
use App\Jobs\VerifyChargeWorkOrderJob;
use App\Jobs\VerifyWatchWorkOrderJob;
use App\Models\AdminUser;
use App\Models\Bike;
use App\Models\LocationsLog;
use App\Models\WarningLog;
use App\Models\WorkOrder;
use App\Utils\Admin;
use App\Utils\GaodeMaps;
use App\Utils\RedisKeys;
use Carbon\Carbon;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Redis;

class WorkOrderController extends AppBaseController
{
    /**
     * workOrderList 工单列表
     *
     * @param WorkOrderFilter $workOrderFilter
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function workOrderList(WorkOrderFilter $workOrderFilter)
    {
        $area_ids = self::$areaIds;
        $workOrderList = WorkOrder::query()
            ->whereIn('area_id', $area_ids)
            ->filter($workOrderFilter)
            ->orderBy('planned')
            ->orderByDesc('id')
            ->paginate();

        return $this->ok(WorkOrderResource::collection($workOrderList));
    }

    /**
     * myWorkOrder 我的工单列表
     *
     * @param WorkOrderFilter $workOrderFilter
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function myWorkOrder(WorkOrderFilter $workOrderFilter)
    {
        $admin_id = Admin::user()->id;
        $area_ids = self::$areaIds;
        $workOrderList = WorkOrder::query()
            ->whereIn('area_id', $area_ids)
            ->filter($workOrderFilter)
            ->where('worker_id', $admin_id)
            ->orderByDesc('id')
            ->paginate();

        return $this->ok(WorkOrderResource::collection($workOrderList));
    }

    /**
     * workOrderDetail 工单详情
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function workOrderDetail(Request $request)
    {

        $work_order_id = $request->get('work_order_id') ?? '';
        if (empty($work_order_id)) return $this->error('参数错误');
        $worker_order = WorkOrder::query()->find($work_order_id);
        if (empty($worker_order)) return $this->error('找不到该工单信息，请联系管理员');

        // 创建者
        $created_at = $worker_order->created_at;
        $created_man = WorkOrder::$sourceMaps[$worker_order->source];

        // 进度
        $planneds = WorkOrder::$plannedMaps[$worker_order->planned];
        $planned = $worker_order->planned;

        // 接单着
        $received_name = $worker_order->worker->name ?? '';
        $received_at = $worker_order->fix_start_time ?? '';


        $position = LocationsLog::getNewestLocationByBikeNo($worker_order->bike_no);


        $reason = $worker_order->reason ?? '';
        $type = $worker_order->type;
//        if($type === WorkOrder::TYPE_TROUBLE){
        $str = '';
        if (is_serialized($reason)) {
            $reasonArr = unserialize($reason);
            foreach ($reasonArr as $k => $v) {
                if ($v == 1) {
                    $str .= WorkOrder::$warningMaps[$k] . "、";
                }
            }
            $str = rtrim($str, '、');
            $reason = $str;
        }
        // }
        $data = [
            'reason' => empty($reason) ? $worker_order->type_name : $reason,
            'planned' => $planned,
            'planneds' => $planneds,
            'bike_no' => $worker_order->bike_no,
            'location' => GaodeMaps::getAddress([$position['lng'], $position['lat']]),
            'created_at' => Carbon::parse($created_at)->format('Y-m-d H:i:s'),
            'times' => $worker_order->times,
            'created_man' => $created_man
        ];
        switch ($planned) {
            case WorkOrder::PLANNED_STATUS_MEET:
                $data += [
                    'received_name' => '',
                    'received_at' => '',
                    'work_over_time' => '',
                    'work_over_name' => '',
                ];
                break;
            case WorkOrder::PLANNED_STATUS_WORK:
                $data += [
                    'received_name' => $received_name,
                    'received_at' => Carbon::parse($received_at)->format('Y-m-d H:i:s'),
                    'work_over_time' => '',
                    'work_over_name' => '',
                ];
                break;
            case WorkOrder::PLANNED_STATUS_WORKED:
                $data += [
                    'received_name' => $received_name,
                    'received_at' => Carbon::parse($received_at)->format('Y-m-d H:i:s'),
                    'work_over_time' => Carbon::parse($worker_order->fix_end_time)->format('Y-m-d H:i:s'),
                    'work_over_name' => $worker_order->workerOver->name ?? '系统',
                ];
                break;
            case WorkOrder::PLANNED_STATUS_OVER:
                $data += [
                    'received_name' => $received_name,
                    'received_at' => Carbon::parse($received_at)->format('Y-m-d H:i:s'),
                    'work_over_time' => Carbon::parse($worker_order->fix_end_time)->format('Y-m-d H:i:s'),
                    'work_over_name' => $worker_order->workerOver->name ?? '系统',
                ];
                break;
            default :
                $data += [
                    'received_name' => '',
                    'received_at' => '',
                    'work_over_time' => '',
                    'work_over_name' => '',
                ];

        }
        return $this->ok($data);

    }

    /**
     * workOrderStatistics 工单统计
     *
     * @param WorkOrderFilter $filter
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function workOrderStatistics(WorkOrderFilter $filter)
    {
        $area_ids = self::$areaIds;
        $type_num = WorkOrder::query()
            ->whereIn('area_id', $area_ids)
            ->where('status', WorkOrder::STATUS_NO)
            ->filter($filter)
            ->groupBy(['type'])
            ->select('type', DB::raw('COUNT(id) as type_num'))
            ->get()
            ->toArray();
        $data = [
            'charge_num' => 0,
            'watch_num' => 0,
            'power_failure_num' => 0,
            'alert_num' => 0,
            'steal_num' => 0,
            'headman_num' => 0,
            'trouble_num' => 0,
            'help_num' => 0,
            'other_num' => 0,
            'offline_num' => 0,
            'planned_meet_num' => 0, // 未认领
            'planned_work_num' => 0, // 处理中
            'planned_worked_num' => 0, // 已处理
            'planned_over_num' => 0,// 完结
        ];
        foreach ($type_num as $v) {
            switch ($v['type']) {
                case WorkOrder::TYPE_CHARGE:
                    $data['charge_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_WATCH:
                    $data['watch_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_POWER_FAILURE:
                    $data['power_failure_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_ALERT:
                    $data['alert_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_STEAL:
                    $data['steal_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_HEADMAN:
                    $data['headman_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_TROUBLE:
                    $data['trouble_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_HELP:
                    $data['help_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_OFFLINE:
                    $data['offline_num'] = $v['type_num'];
                    break;
                case WorkOrder::TYPE_OTHER:
                    $data['other_num'] = $v['type_num'];
                    break;
                default;
            }
        }


        $planned_num = WorkOrder::query()
            ->filter($filter)
            ->groupBy('planned')
            ->select('planned', DB::raw('COUNT(id) as planned_num'))
            ->get()
            ->toArray();
        foreach ($planned_num as $v) {
            switch ($v['planned']) {
                case WorkOrder::PLANNED_STATUS_MEET:
                    $data['planned_meet_num'] = $v['planned_num'];
                    break;
                case WorkOrder::PLANNED_STATUS_WORK:
                    $data['planned_work_num'] = $v['planned_num'];
                    break;
                case WorkOrder::PLANNED_STATUS_WORKED:
                    $data['planned_worked_num'] = $v['planned_num'];
                    break;
                case WorkOrder::PLANNED_STATUS_OVER:
                    $data['planned_over_num'] = $v['planned_num'];
                    break;
                default;
            }
        }

        return $this->ok($data);

    }

    /**
     * workOrderType 筛选项工单类型
     *
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function workOrderType()
    {
        $types = WorkOrder::$typeMaps;
        $data = [];
        foreach ($types as $k => $v) {

            $dataItem['key'] = $k;
            $dataItem['value'] = $v;
            $data[] = $dataItem;
        }
        return $this->ok($types);
    }

    /**
     * receiveWorkOrder 接单
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function receiveWorkOrder(Request $request)
    {

        $work_order_id = $request->get('work_order_id') ?? '';
        if (empty($work_order_id)) return $this->error('参数错误');
        $worker_order = WorkOrder::query()->find($work_order_id);
        if (empty($worker_order)) return $this->error('找不到该工单信息，请联系管理员');
        // 加锁防止重复
        $lock = $this->makeReceiveWorkLock($work_order_id);
        if (!$lock) return $this->error('该工单已被认领');


        if ($worker_order->planned > WorkOrder::PLANNED_STATUS_MEET) return $this->error('该工单已被认领');
        $worker_id = Admin::user()->id;
        $worker_order->planned = WorkOrder::PLANNED_STATUS_WORK;
        $worker_order->fix_start_time = Carbon::now();
        $worker_order->worker_id = $worker_id;

        $bool = $worker_order->save();
        if ($bool) {
            return $this->ok('接单成功');
        } else {
            return $this->error('出现错误，请联系管理员');
        }
    }

    /**
     * makeReceiveWorkLock 接单锁  防止重复接单
     *
     * @param $work_order_id
     * @return bool
     * @author Fx
     *
     */
    public function makeReceiveWorkLock($work_order_id)
    {
        $key = sprintf(RedisKeys::LOCK_RECEIVE_WORK, $work_order_id);
        $res = app()->redis->incr($key);
        app()->redis->Expire($key, RedisKeys::LOCK_EXPIRE_RECEIVE_WORK);
        return $res > 1 ? false : true;
    }

    /**
     * updateWorkOrderStatus 更新工单状态已处理
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function updateWorkOrderStatus(Request $request)
    {

        $work_order_id = $request->get('work_order_id') ?? '';
        if (empty($work_order_id)) return $this->error('参数错误');
        //验证工单存在
        $work_order = WorkOrder::query()->find($work_order_id);
        if (empty($work_order)) return $this->error('找不到该工单信息，请联系管理员');
        $work_order_type = $work_order->type;
        $worker_id = $work_order->worker_id;
        // 验证是否有权限操作此工单
        $worker_type = Admin::user()->type;
        $admin_id = Admin::user()->id;
        if ($worker_type != AdminUser::TYPE_ADMIN) {
            if ($admin_id != $worker_id) {
                return $this->error('无权限操作此工单');
            }
        }


        if ($work_order->planned == WorkOrder::PLANNED_STATUS_MEET) return $this->error('该工单暂未认领');
        if ($work_order->planned == WorkOrder::PLANNED_STATUS_WORKED) return $this->error('该工单为已处理状态不可重复提交');
        if ($work_order->planned == WorkOrder::PLANNED_STATUS_OVER) return $this->error('该工单为已完成状态不可重复提交');
        // 判断工单类型 进行验证是否真正完成
        switch ($work_order_type) {
            case WorkOrder::TYPE_WATCH: // 查看类型工单
                $res = $this->updateWorkOrder($work_order);
                if ($res) {
                    // 延时队列  验证是否完成工单
                    VerifyWatchWorkOrderJob::dispatch($work_order->work_no)->delay(Carbon::now()->addMinutes(config('queue.delay.verifyWatchWorkOrder')));
                    return $this->ok('操作成功');
                } else {
                    return $this->error('更新失败，请重新尝试');
                }
                break;
            case WorkOrder::TYPE_CHARGE: // 充电类型工单
                $res = $this->updateWorkOrder($work_order);
                if ($res) {
                    // 延时队列  验证是否完成工单
                    VerifyChargeWorkOrderJob::dispatch($work_order->work_no)->delay(Carbon::now()->addMinutes(config('queue.delay.verifyChargeWorkOrder')));
                    return $this->ok('操作成功');
                } else {
                    return $this->error('更新失败，请重新尝试');
                }
                break;
            case WorkOrder::TYPE_TROUBLE: // 故障工单
                // 需要修改车辆故障表   以及更新车辆状态
                $bike_id = $work_order->bike_id;
                $bike = Bike::find($bike_id);
                if(!empty($bike)){
                    $bike->is_trouble = Bike::TROUBLE_NO;
                    $bike->save();
                }else{
                    return $this->error('找不到车辆相关信息');
                }
                $res = $this->updateWorkOrderOver($work_order);
                if ($res) {
                    return $this->ok('操作成功');
                } else {
                    return $this->error('更新失败，请重新尝试');
                }

                break;
            default: // 其他工单了类型暂时不验证  直接赋值成功
                $res = $this->updateWorkOrderOver($work_order);

                if ($res) {
                    return $this->ok('操作成功');
                } else {
                    return $this->error('更新失败，请重新尝试');
                }

        }
    }

    /**
     * updateWorkOrder 更新工单状态为已处理
     *
     * @param $work_order
     * @return mixed
     * @author Fx
     *
     */
    private function updateWorkOrder($work_order)
    {
        $work_order->planned = WorkOrder::PLANNED_STATUS_WORKED;
        $work_order->work_over_id = Admin::user()->id;
        $bool = $work_order->save();
        return $bool;
    }

    /**
     * updateWorkOrderOver 更新工单状态为已完成
     *
     * @param $work_order
     * @return mixed
     * @author Fx
     *
     */
    private function updateWorkOrderOver($work_order)
    {
        $work_order->planned = WorkOrder::PLANNED_STATUS_OVER;
        $work_order->status = WorkOrder::STATUS_OK;
        $work_order->work_over_id = Admin::user()->id;
        $work_order->fix_end_time = Carbon::now();
        $bool = $work_order->save();

        $bike_id = $work_order->bike_id;
        $bike = Bike::find($bike_id);
        if(!empty($bike)){
            $bike->is_trouble = Bike::TROUBLE_NO;
            $bike->save();
        }
        return $bool;
    }

    /**
     * upgradeGroupWorkOrder 升级为组长工单
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function upgradeGroupWorkOrder(Request $request)
    {
        $work_order_id = $request->get('work_order_id') ?? '';
        $remark = $request->get('remark') ?? '';
        if (empty($work_order_id) || empty($remark)) return $this->error('参数错误');
        //验证工单存在
        $work_order = WorkOrder::query()->find($work_order_id);
        if (empty($work_order)) return $this->error('找不到该工单信息，请联系管理员');
        $admin_id = Admin::user()->id;
        $worker_id = $work_order->worker_id;

        if ($work_order->planned == WorkOrder::PLANNED_STATUS_MEET) return $this->error('该工单暂未认领不能升级');

        if ($admin_id != $worker_id) {
            return $this->error('无权限操作此工单');
        }

        try {
            $work_order->type = WorkOrder::TYPE_HEADMAN;
            $work_order->type_name = WorkOrder::$typeMaps[WorkOrder::TYPE_HEADMAN];
            $work_order->remark = $remark; // 备注信息
            $work_order->save();
            return $this->ok('更改成功');
        } catch (\Exception $exception) {
            Log::error($exception->getMessage());
            return $this->error('更改失败，请联系管理员');
        }


    }

    /**
     * getWarningByWorkOrderId 根据工单id获取警告日志
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     * @author Fx
     *
     */
    public function getWarningByWorkOrderId(Request $request)
    {
        $workOrderId = $request->get('id');
        $is_limit_type = $request->get('is_limit_type', 1);

        $workOrder = WorkOrder::find($workOrderId);
        if (empty($workOrder)) return $this->error('找不到工单');

        $warning = WarningLog::query()
            ->where('bike_no', $workOrder->bike_no);
        if ((bool)$is_limit_type) {
//            Log::info($is_limit_type);
            $warning = $warning
                ->where('type', $workOrder->warning_type);
        }
        $warning = $warning
            ->where('created_at', '>', Carbon::parse($workOrder->created_at)->subMinutes(5))
            ->orderByDesc('id')
            ->limit(300)
            ->get();
        return $this->ok(WarningLogResource::collection($warning));
    }
}