ball/app/adminapi/logic/works/ServiceWorkLogic.php

<?php
// +----------------------------------------------------------------------
// | likeadmin快速开发前后端分离管理后台（PHP版）
// +----------------------------------------------------------------------
// | 欢迎阅读学习系统程序代码，建议反馈是我们前进的动力
// | 开源版本可自由商用，可去除界面版权logo
// | gitee下载：https://gitee.com/likeshop_gitee/likeadmin
// | github下载：https://github.com/likeshop-github/likeadmin
// | 访问官网：https://www.likeadmin.cn
// | likeadmin团队 版权所有 拥有最终解释权
// +----------------------------------------------------------------------
// | author: likeadminTeam
// +----------------------------------------------------------------------

namespace app\adminapi\logic\works;


use app\api\logic\PerformanceLogic;
use app\common\enum\worker\WorkerAccountLogEnum;
use app\common\logic\WorkerAccountLogLogic;
use app\common\model\dict\DictData;
use app\common\model\master_worker\MasterWorker;
use app\common\model\master_worker\MasterWorkerAccountLog;
use app\common\model\master_worker\MasterWorkerRetentionMoneyLog;
use app\common\model\orders\OrderEffectiveLog;
use app\common\model\performance\PerformanceRules;
use app\common\model\recharge\OrderGoods;
use app\common\model\recharge\RechargeOrder;
use app\common\model\spare_part\SparePart;
use app\common\model\works\ServiceWork;
use app\common\logic\BaseLogic;
use app\common\model\works\ServiceWorkAllocateWorkerLog;
use app\common\model\works\ServiceWorkAppointmentLog;
use app\common\model\works\ServiceWorkLog;
use app\common\model\works\ServiceWorkSpare;
use app\workerapi\logic\ServiceWorkerAllocateWorkerLogic;
use app\workerapi\logic\ServiceWorkLogLogic;
use think\db\Query;
use think\Exception;
use think\facade\Db;
use think\facade\Log;


/**
 * ServiceWork逻辑
 * Class ServiceWorkLogic
 * @package app\adminapi\logic\works
 */
class ServiceWorkLogic extends BaseLogic
{
    /**
     * @notes 编辑
     * @param array $params
     * @return bool
     * @author likeadmin
     * @date 2024/07/10 18:17
     */
    public static function edit(array $params): bool
    {
        Db::startTrans();
        try {
            ServiceWork::where('id', $params['id'])->update([
                'address' => $params['address'],
                'appointment_time' => strtotime($params['appointment_time']),
                'lon' => $params['lon'],
                'lat' => $params['lat'],
            ]);
            Db::commit();
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }
    /**
     *
     * @return false|void
     */
    public static function pickWork($params)
    {
        Db::startTrans();
        try {
            $work = ServiceWork::where(['master_worker_id'=>$params['user_id'],'work_sn'=>$params['work_sn']])->findOrEmpty();
            if($work->isEmpty()){
                throw new Exception('工单不存在');
            }
            $receive_time = time();
            $work->work_status = 2;//待联系
            $work->service_status = 1;//服务中
            $work->receive_time = $receive_time;
            $work->save();

            //添加变更日志
            $work_log = [
                'work_id'=>$work->id,
                'master_worker_id'=>$work->master_worker_id,
                'opera_log'=>'编号['.$params['user_info']['worker_number'].']'.$params['user_info']['real_name'].'于'.date('y-m-d H:i:s',$receive_time).'领取了工单',
            ];
            ServiceWorkLogLogic::add($work_log);
            Db::commit();
        }
        catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    /**
     * 预约成功，等待上门
     * @return false|void
     */
    public static function appointWork($params)
    {
        Db::startTrans();
        try {
            $work = ServiceWork::where(['master_worker_id'=>$params['user_id'],'work_sn'=>$params['work_sn']])->findOrEmpty();
            if($work->isEmpty()){
                throw new Exception('工单不存在');
            }

            if($work->work_status != 2){
                throw new Exception('请勿重复点击');
            }

            //验证更改的预约时间必须是在领单时间内的半小内修改，否则不允许修改
            if(strtotime($work->appointment_time) != strtotime($params['appointment_time']) && (time()-strtotime($work->receive_time))>1800){
                throw new Exception('距离领单时间已超过半小时，无法修改预约时间，请联系客服');
            }

            $work->work_status = 3;//待上门
            $work->appointment_time = strtotime($params['appointment_time']);
            $work->save();

            //添加变更日志
            $work_log = [
                'work_id'=>$work->id,
                'master_worker_id'=>$work->master_worker_id,
                'opera_log'=>'编号['.$params['user_info']['worker_number'].']'.$params['user_info']['real_name'].'于'.date('y-m-d H:i:s',time()).'联系了客户,确认了于'.$params['appointment_time'].$params['address'].'预约上门',
            ];
            ServiceWorkLogLogic::add($work_log);
            Db::commit();
        }
        catch (\Exception $e) {
            self::setError($e->getMessage());
            return false;
        }
    }

    /**
     * 工程师确认上门
     * @param $params
     * @return false|void
     */
    public static function confirmDoor($params)
    {
        Db::startTrans();
        try {
            $work = ServiceWork::where(['master_worker_id'=>$params['user_id'],'work_sn'=>$params['work_sn']])->findOrEmpty();
            if($work->isEmpty()){
                throw new Exception('工单不存在');
            }

            if($work->work_status != 3){
                throw new Exception('请勿重复点击');
            }

            $work->finally_door_time = time();//最后上门时间
            $work->work_status = 4;//已上门
            $work->save();

            //添加变更日志
            $work_log = [
                'work_id'=>$work->id,
                'master_worker_id'=>$work->master_worker_id,
                'opera_log'=>'编号['.$params['user_info']['worker_number'].']'.$params['user_info']['real_name'].'于'.date('y-m-d H:i:s',time()).'于'.date('Y-m-d H:i:s',time()).'已上门',
            ];
            ServiceWorkLogLogic::add($work_log);
            Db::commit();
        }
        catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    /**
     * 工程师确认报价单
     * @param $params
     * @return false|void
     */
    public static function confirmPrice($params)
    {
        Db::startTrans();
        try {
            $work = ServiceWork::where(['master_worker_id'=>$params['user_id'],'work_sn'=>$params['work_sn']])->findOrEmpty();
            if($work->isEmpty()){
                throw new Exception('工单不存在');
            }
            //搜索待支付订单
            $paid_order = RechargeOrder::where(['work_id'=>$work['id'],'pay_status'=>1])->findOrEmpty()->toArray();
            if(empty($paid_order)){
                throw new Exception('订单错误');
            }

            if($work->work_status != 4){
                throw new Exception('请勿重复操作');
            }

            // 关联配件信息.计算配件总价  id  company_price original_price offering_price number
            $spare_total = 0;

            isset($params['spare_parts']) && $params['spare_parts'] && $params['spare_parts'] = json_decode($params['spare_parts'], true);
            if(isset($params['spare_parts']) && $params['spare_parts']){
                $spare_parts = $params['spare_parts'];
                foreach ($spare_parts as $spare){
                    $spare_total += $spare['company_price']*$spare['number'];
                }
                $work->spare_total = $spare_total;

                $service_work_spare = ServiceWorkSpare::where(['service_work_id'=>$work['id']])->findOrEmpty();
                if($service_work_spare->isEmpty()){
                    //新增
                    $service_work_spare = ServiceWorkSpare::create([
                        'service_work_id'=>$work['id'],
                        'spare_parts'=>$params['spare_parts'],
                        'remark'=>''
                    ]);
                }else{
                    //修改
                    $service_work_spare->spare_parts = $params['spare_parts'];
                    $service_work_spare->save();
                }
                $work->service_work_spare_id = $service_work_spare->id;
            }
            // order_amount 原 =  $params['amount'] 修改为 = 配件总价 + 服务尾款
            $order_amount = $params['amount'] + $spare_total;

            //定金存在尾款结算功能，全款直接提交
            if($paid_order['payment_type']==1){
                $un_order = RechargeOrder::where(['work_id'=>$work['id'],'pay_status'=>0])->findOrEmpty();
                if($un_order->isEmpty()){
                    //新增待支付尾款
                    $order_data = [
                        'order_type'=>$paid_order['order_type'],
                        'sn'=>generate_sn(\app\common\model\orders\RechargeOrder::class, 'sn'),
                        'work_id'=>$paid_order['work_id'],
                        'user_id'=>$paid_order['user_id'],
                        'payment_type'=>2,
                        'order_total'=>$order_amount,
                        //'order_amount'=>$params['amount'],
                        'order_amount'=>$order_amount,
                        'order_terminal'=>$paid_order['order_terminal']
                    ];
                    RechargeOrder::create($order_data);
                }else{
                    //修改尾款信息
                    $un_order->order_total = $order_amount;
                    //$un_order->order_amount = $params['amount'];
                    $un_order->order_amount = $order_amount;
                    $un_order->save();
                }

                //更新服务费用
                $work->service_fee = $paid_order['paid_amount']+$params['amount'];
            }
            //总工单费用
            $work->work_total = $order_amount + $paid_order['paid_amount'];
            $work->work_images = $params['work_images'];
            $work->user_confirm_status = 1;//待确认报价
            $work->price_approval = 0;
            $work->save();

            //添加变更日志
            $work_log = [
                'work_id'=>$work->id,
                'master_worker_id'=>$work->master_worker_id,
                'opera_log'=>'编号['.$params['user_info']['worker_number'].']'.$params['user_info']['real_name'].'于'.date('y-m-d H:i:s',time()).'于'.date('Y-m-d H:i:s',time()).'提交了报价单',
            ];
            ServiceWorkLogLogic::add($work_log);
            Db::commit();
        }
        catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    /**
     * 工程师确认服务完成
     * @param $params
     * @return false|void
     */
    public static function confirmServiceFinish($params)
    {
        Db::startTrans();
        try {
            $work = ServiceWork::where(['master_worker_id'=>$params['user_id'],'work_sn'=>$params['work_sn']])->findOrEmpty();
            if($work->isEmpty()){
                throw new Exception('工单不存在');
            }

            if($work->user_confirm_status !=2){
                throw new Exception('请勿重复操作');
            }

            $work->finished_images = $params['finished_images'];
            $work->user_confirm_status = 3;//待确认服务完成
            $work->save();

            //添加变更日志
            $work_log = [
                'work_id'=>$work->id,
                'master_worker_id'=>$work->master_worker_id,
                'opera_log'=>'编号['.$params['user_info']['worker_number'].']'.$params['user_info']['real_name'].'于'.date('y-m-d H:i:s',time()).'于'.date('Y-m-d H:i:s',time()).'提交了待用户确认服务完成',
            ];
            ServiceWorkLogLogic::add($work_log);
            Db::commit();
        } catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    public static function allocateWorker($params,$userInfo){
        Db::startTrans();
        try {
            $work = ServiceWork::findOrEmpty($params['id']);
            if($work->isEmpty()){
                throw new Exception('工单不存在');
            }
            if($work->work_status >=6 ){
                throw new \Exception('工单状态只能修改待结算之前的');
            }
            if($work->master_worker_id == $params['master_worker_id']){
                throw new \Exception('分配的工程师相同');
            }
            $worker = MasterWorker::where(['id'=>$params['master_worker_id'],'is_disable' =>0])->findOrEmpty();
            if($worker->isEmpty()){
                throw new \Exception('工程师不存在或被禁用');
            }
            if($worker->master_worker_id){
                MasterWorker::setWorktotal('dec',$worker->master_worker_id);
            }
            $work->master_worker_id = $params['master_worker_id'];
            $work->work_status = 1;
            $work->dispatch_time = time();
            MasterWorker::setWorktotal('inc',$params['master_worker_id']);
            $work->save();
            $work_log = [
                'work_id'=>$work->id,
                'master_worker_id'=>$work->master_worker_id,
                'opera_log'=>'后台用户['.$userInfo['admin_id'].']'.$userInfo['name'].'于'.date('Y-m-d H:i:s',time()).'分配了工程师'.'编号['.$worker->worker_number.']'.$worker->real_name
            ];
            ServiceWorkerAllocateWorkerLogic::add($work_log);
            Db::commit();
            return true;
        }catch(\Exception $e){
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    /**
     * 工单详情
     * @param $params
     * @return array|false
     */
    public static function detail($params){
        $work_where = !empty($params['work_sn'])?['work_sn'=>$params['work_sn']]:['id'=>$params['id']];
        $result = ServiceWork::with([
            'worker'=> function(Query $query) {
                $query->field('id,worker_number,real_name,mobile');
            },
            'allocateWorkerLog' =>function(Query $query){
                $query->field('id,work_id,opera_log,create_time');
            },
            'serviceWorkLog' =>function(Query $query){
                $query->field('id,work_id,opera_log,create_time');
            }
        ])->append(['id','work_status_text','service_status_text'])
            ->where($work_where)
            ->findOrEmpty()->toArray();
        if(isset($params['user_id']) && $params['user_id'] && ($params['user_id'] != $result['master_worker_id'])){
            throw new \Exception('您没有权限操作该工单');
        }
        //工程师工单按钮状态
        $work_service_status = 0;
        $work_service_status_text = '待派单';
        //工单状态
        if($result['work_status'] == 1){
            $work_service_status = 1;
            $work_service_status_text = '待领单';
        }
        if($result['work_status'] == 2){
            $work_service_status = 2;
            $work_service_status_text = '预约上门';
        }
        if($result['work_status'] == 3){
            $work_service_status = 3;
            $work_service_status_text = '等待上门';
            if(date('Y-m-d') === date('Y-m-d',strtotime($result['appointment_time']))){
                $work_service_status = 4;
                $work_service_status_text = '确认上门';
            }
        }
        if($result['work_status'] == 4 and $result['user_confirm_status']==0){
            $work_service_status = 5;
            $work_service_status_text = '确认报价';
        }
        if($result['work_status'] == 4 and $result['user_confirm_status']==1){
            $work_service_status = 6;
            $work_service_status_text = '用户确认报价中';
        }
        if($result['work_status'] == 5 and $result['user_confirm_status']==2){
            $work_service_status = 7;
            $work_service_status_text = '完成服务';
        }
        if($result['work_status'] == 5 and $result['user_confirm_status']==3){
            $work_service_status = 8;
            $work_service_status_text = '用户确认完成服务中';
        }
        if($result['work_status'] ==6){
            $work_service_status = 9;
            $work_service_status_text = '待结算';
        }
        if($result['work_status'] ==7){
            $work_service_status = 10;
            $work_service_status_text = '已完结';
        }
        if($result['work_status'] ==8){
            $work_service_status = 11;
            $work_service_status_text = '已评价';
        }
        if($result['work_status'] ==9){
            $work_service_status = 12;
            $work_service_status_text = '已退费';
        }

        $result['work_service_status'] = $work_service_status;
        $result['work_service_status_text'] = $work_service_status_text;


        //搜索当前工单下的所有订单记录
        $result['pay_orders'] = RechargeOrder::with(['orderGoods'=>function(Query $query){
            $query->field('id,sn,goods_id,goods_name,goods_image,goods_number,good_unit,goods_size,goods_payment_type,goods_type,goods_brand,base_service_fee,service_total,service_fee')->order(['id'=>'desc']);
        }])->where(['work_id'=>$result['id']])->field('id as order_id,sn,order_type,pay_status,payment_type,pay_way,pay_time,order_amount,order_total,coupon_price,create_time')->order('id asc')->select()->toArray();
        $pay_status_data = DictData::where('type_value','pay_status')->column('name','value');
        $payment_type_data = DictData::where('type_value','payment_type')->column('name','value');
        $pay_way_data = DictData::where('type_value','pay_way')->column('name','value');
        $order_type_data = DictData::where('type_value','order_type')->column('name','value');
        $coupon_price = 0;

        foreach ($result['pay_orders'] as $k=>&$v){
            $v['pay_status_name'] = $pay_status_data[$v['pay_status']];
            $v['payment_type_name'] = $payment_type_data[$v['payment_type']];
            $v['pay_way_name'] = $pay_way_data[$v['pay_way']];
            $v['order_type_name'] = $order_type_data[$v['order_type']];
            $v['pay_time'] = $v['pay_time'] && is_numeric($v['pay_time']) ? date('Y-m-d H:i:s',$v['pay_time']):'';
            if($v['payment_type']!=1 and !empty($result['spare_total'])){
                $v['order_total'] = $v['order_total'] - $result['spare_total'];
                $v['order_amount'] = $v['order_amount'] - $result['spare_total'];
            }
            $coupon_price += $v['coupon_price'];
            //服务支付类别
            if(!empty($v['orderGoods'][0]['goods_payment_type'])){
                $goods_payment_type = $v['orderGoods'][0]['goods_payment_type'];
            }
        }

        $result['goods_payment_type'] = !empty($goods_payment_type)?$goods_payment_type:1;

        //汇总优惠卷额度
        $result['coupon_price'] = $coupon_price;

        //工单总支付金额
        $result['worker_account'] = $result['work_amount'];

        // 配件信息
        $result['spare_parts'] = [];
        if($result['service_work_spare_id']){
            $work_spare_parts = json_decode(ServiceWorkSpare::where('id',$result['service_work_spare_id'])->value('spare_parts'),true);
            $spare_parts = SparePart::where('id','in',array_column($work_spare_parts,'id'))
                ->field(['id', 'goods_category_id', 'spare_name', 'spare_image', 'spare_number', 'spare_unit','spare_status'])
                ->select()
                ->toArray();
            $spare_parts = array_column($spare_parts,null,'id');
            foreach (array_column($work_spare_parts,null,'id') as $k=>&$v){
                $spare_parts[$k] = array_merge($spare_parts[$k],$v);
            }
            $result['spare_parts'] = array_values($spare_parts)??[];
        }
        // 保修卡信息
        $result['order_effectives'] = OrderEffectiveLog::with(['goods'=>function ($query) {
                                            $query->with(['goodsCategory'=>function ($query1) {
                                                $query1->field(['name','picture']);
                                            }]);
                                        }])->where('work_id',$result['id'])
                                        ->field(['id','goods_id','sn','effective_unit','effective_num','remark','end_effective_time'])
                                        ->append(['effective_unit_text'])
                                        ->order('create_time desc')
                                        ->select()
                                        ->toArray();

        //查收工程师提成金额
        $change_amount = MasterWorkerAccountLog::where(['work_sn'=>$result['work_sn'],'action'=>1])->value('change_amount');
        $result['change_amount'] = !empty($change_amount)?$change_amount:0;

        //质保金相关金额
        $result['retention'] = MasterWorkerRetentionMoneyLog::where('work_id',$result['id'])->visible(['action','amount'])->select()
            ->each(function ($item){
                $item['amount'] = $item['action'] == 1 ? '+'.$item['amount'] : '-'.$item['amount'];
            })->toArray();

        return  $result;
    }

    public static function getDetailWorkServiceStatus($params)
    {
        $result = ServiceWork::where('id',$params['id'])->field('work_status,user_confirm_status,appointment_time,price_approval,appoint_approval')->findOrEmpty()->toArray();
        //工程师工单按钮状态
        $work_service_status = 0;
        //工单状态
        if($result['work_status'] == 1){
            $work_service_status = 1;
        }
        if($result['work_status'] == 2){
            $work_service_status = 2;
        }
        if($result['work_status'] == 3){
            $work_service_status = 3;
            if(date('Y-m-d') === date('Y-m-d',strtotime($result['appointment_time']))){
                $work_service_status = 4;
            }
        }
        if($result['work_status'] == 4 and $result['user_confirm_status']==0){
            $work_service_status = 5;
        }
        if($result['work_status'] == 4 and $result['user_confirm_status']==1){
            $work_service_status = 6;
        }
        if($result['work_status'] == 5 and $result['user_confirm_status']==2){
            $work_service_status = 7;
        }
        if($result['work_status'] == 5 and $result['user_confirm_status']==3){
            $work_service_status = 8;
        }
        if($result['work_status'] ==6){
            $work_service_status = 9;
        }
        if($result['work_status'] ==7){
            $work_service_status = 10;
        }
        if($result['work_status'] ==8){
            $work_service_status = 11;
        }
        if($result['work_status'] ==9){
            $work_service_status = 12;
        }
        return ['work_service_status'=>$work_service_status,'price_approval'=>$result['price_approval'],'appoint_approval'=>$result['appoint_approval']];
    }

    /**
     * @notes 取消操作
     * @param array $params
     * @return bool
     * @author likeadmin
     * @date 2024/09/19 10:48
     */
    public static function cancel(array $params): bool
    {
        Db::startTrans();
        try {
            // 04-11-12 不做任何限制强制取消，已支付的费用给工程师余额
            $serviceWorkInfo = ServiceWork::find($params['id']);
            if((int)$serviceWorkInfo['user_confirm_status'] === 5 || (int)$serviceWorkInfo['service_status'] > 2){
                throw new \Exception('用户已完结该工单或已取消,已退款，不可执行取消');
            }
            ServiceWork::where('id', $params['id'])->update([
                //'work_status' => 9,
                'service_status' => 4,
                'remark' => $params['remark']??''
            ]);
            /*// 对应订单状态修改
            RechargeOrder::where('work_id', $params['id'])->update([
                'pay_status' => 2
            ]);*/
            ServiceWorkLog::create([
                'work_id' => $params['id'],
                'master_worker_id' => $serviceWorkInfo['master_worker_id'],
                'opera_log' => "工单:{$serviceWorkInfo['work_sn']}已取消"
            ]);

            $paid_amount = RechargeOrder::where('work_id', $params['id'])->where('payment_type', 1)->where('order_type', 0)->where('pay_status', 1)->value('paid_amount');
            if($paid_amount > 0){
                // 4=已上门,5=服务中,6=待结算, 即工程师已上门服务过
                if(in_array((int)$serviceWorkInfo['work_status'], [4,5,6])){
                    WorkerAccountLogLogic::addAccountLog($serviceWorkInfo,$paid_amount,WorkerAccountLogEnum::UM_INC_ADMIN,WorkerAccountLogEnum::INC,$params['remark']??'');
                }
            }

            Db::commit();
            Log::info('取消工单'.json_encode([$serviceWorkInfo]));
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            Log::info('取消工单-Error'.json_encode([$e->getMessage()]));
            return false;
        }
    }

    /**
     * @notes 工程师结算操作
     * @param array $params
     * @return bool
     * @author likeadmin
     * @date 2024/09/19 10:48
     */
    public static function settlement(array $params): bool
    {
        Db::startTrans();
        try {
            $serviceWorkInfo = ServiceWork::find($params['id']);
            if((int)$serviceWorkInfo['work_pay_status'] !== 3){
                throw new \Exception('该工单非待结算状态');
            }
            //获取工单对应的商品id
            $order_sns = \app\common\model\orders\RechargeOrder::where('work_id',$serviceWorkInfo->id)->column('sn');
            $goods_id = OrderGoods::whereIn('sn',$order_sns)->value('goods_id');
            $rule = PerformanceRules::whereFindInSet('goods_id',$goods_id)->findOrEmpty();
            if($rule->isEmpty()){
                throw new \Exception('请配置商品业绩规则');
            }
            PerformanceLogic::calculatePerformance($serviceWorkInfo);
            Db::commit();
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    /**
     * 获取所有改约通知
     * @param $userId
     * @return array|false
     */
    public static function getAppointmentNotice($userId)
    {
        return ServiceWork::where(['master_worker_id'=>$userId,'appoint_approval'=>1])
            ->where('work_status','>',1)
            ->where('work_status','<',7)
            ->field(['id', 'work_sn','real_name','mobile', 'address', 'title', 'appointment_time','work_status'])
            ->order(['appointment_time' => 'asc'])//上门时间排序
            ->select()->each(function (&$item){
                $item['last_appointment_time'] = date('Y-m-d H:i:s',ServiceWorkAppointmentLog::where('work_id',$item['id'])->order('id desc')->value('last_appointment_time'));
            })
            ->toArray();
    }

    /**
     * @param $params
     * @return bool
     */
    public static function submitAppointment($params)
    {
        Db::startTrans();
        try {
            $serviceWork = ServiceWork::where('work_sn',$params['work_sn'])->findOrEmpty();
            if($serviceWork->isEmpty()){
                throw new \Exception('工单不存在');
            }
            $serviceWork->appoint_approval = 2;
            $serviceWork->save();
            Db::commit();
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    /**
     * @param $params
     * @return bool
     */
    public static function submitChangePrice($params)
    {
        Db::startTrans();
        try {
            $serviceWork = ServiceWork::where('work_sn',$params['work_sn'])->findOrEmpty();
            if($serviceWork->isEmpty()){
                throw new \Exception('工单不存在');
            }
            $serviceWork->work_status = 4;
            $serviceWork->user_confirm_status = 0;
            $serviceWork->price_approval = 2;
            $serviceWork->save();
            Db::commit();
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }
    public static function notApproved($params)
    {
        Db::startTrans();
        try {
            $serviceWork = ServiceWork::where('id',$params['id'])->findOrEmpty();
            if($serviceWork->isEmpty()){
                throw new \Exception('工单不存在');
            }
            $serviceWork->refund_approval = 3;
            $serviceWork->save();
            Db::commit();
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    public static function againDoor($params)
    {
        Db::startTrans();
        try {
            $serviceWork = ServiceWork::where('work_sn',$params['work_sn'])->findOrEmpty();
            if($serviceWork->isEmpty()){
                throw new \Exception('工单不存在');
            }
            //更新预约日志
            //更新工单未确认上门的状态
            $serviceWork->work_status = 3;
            $serviceWork->user_confirm_status = 0;

            ServiceWorkAppointmentLog::create([
                'work_id'=>$serviceWork->id,
                'last_appointment_time'=>$serviceWork->appointment_time,
                'this_appointment_time'=>strtotime($params['appointment_time']),
            ]);

            $serviceWork->appointment_time = strtotime($params['appointment_time']);
            $serviceWork->save();
            Db::commit();
            return true;
        } catch (\Exception $e) {
            Db::rollback();
            self::setError($e->getMessage());
            return false;
        }
    }

    public static function cancelAllocation($params,$userInfo){
        Db::startTrans();
        try {

            $work = ServiceWork::findOrEmpty($params['id']);
            if($work->isEmpty()){
                throw new Exception('工单不存在');
            }
            if($work->work_status >=6 ){
                throw new \Exception('工单状态只能修改待结算之前的');
            }
            $worker = MasterWorker::where(['id'=>$work->master_worker_id])->findOrEmpty();
            if($worker->isEmpty()){
                throw new \Exception('工程师不存在');
            }
            MasterWorker::setWorktotal('dec',$work->master_worker_id);
            $work->master_worker_id = 0;
            $work->work_status = 0;
            $work->dispatch_time = 0;
            $work->save();

            $work_log = [
                'work_id'=>$work->id,
                'master_worker_id'=>$params['master_worker_id'],
                'opera_log'=>'后台用户['.$userInfo['admin_id'].']'.$userInfo['name'].'于'.date('Y-m-d H:i:s',time()).'取消了工程师'.'编号['.$worker->worker_number.']'.$worker->real_name
            ];
            ServiceWorkerAllocateWorkerLogic::add($work_log);
            Db::commit();
            return true;
        }catch(\Exception $e){
            Db::rollback();

            dd($e->getMessage());

            self::setError($e->getMessage());
            return false;
        }
    }

}