<?php

namespace app\api\controllers;

use Yii;
use yii\base\Exception;
use yii\log\Logger;
use yii\helpers\HtmlPurifier;
use yii\db\Query;

use common\business\MarketingCoupon;
use common\business\RepairOrderPriceRule;
use common\business\WarrantyLevelRule;
use common\helpers\AppErrorLog;
use common\helpers\Log                      as AppLog;
use common\helpers\ImageManager;
use common\helpers\Utils;

use common\models\Address                   as AddressModel;
use common\models\BindDeviceApply           as BindDeviceApplyModel;
use common\models\ClientUser                as ClientUserModel;
use common\models\CouponActivity            as CouponActivityModel;
use common\models\DeviceFault               as DeviceFaultModel;
use common\models\GuestDevice               as GuestDeviceModel;
use common\models\Owner                     as OwnerModel;
use common\models\Qrcode                    as QrcodeModel;
use common\models\RegionFeeSetting          as RegionFeeSettingModel;
use common\models\RepairOrder               as RepairOrderModel;
use common\models\RepairOrderRepairPlans    as RepairOrderRepairPlansModel;
use common\models\SysSetting                as SysSettingModel;
use common\models\UserDevice                as UserDeviceModel;
use common\models\UserDeviceFav             as UserDeviceFavModel;
use common\models\UserDeviceLog             as UserDeviceLogModel;
use common\models\RedpackActivity           as RedpackActivityModel;
use common\models\UserRedpacks              as UserRedpacksModel;
use common\models\User                      as UserModel;
use common\models\RedpackAmount             as RedpackAmountModel;
use common\models\RepairPlan                as RepairPlanModel;
use common\helpers\MinaHelper;

use common\exts\wxpay\Log as WxpayLog;
use domain\device\DeviceCatRepository;
use domain\device\DeviceCat;
use domain\device\models\ModelsDeviceFaults as ModelsDeviceFaultsModel;
use domain\trade\RepairOrderUserOp;
use domain\trade\RepairOrderStatus;
use domain\trade\RepairOrderChannel;
use domain\trade\RepairOrderClaimRepository;
use domain\marketing\userads\UserAdsRepository;

use stdClass;
use function sizeof;
use function date;
use function count;
use function time;

/**
 * 设备-控制器
 * Class DeviceController
 * @package app\api\controllers
 */
class DeviceController extends ScopeUserController
{
    const PAGE_SIZE = 20; // 列表数据默认分页大小

    /**
     * 极速报修首页
     * @return string
     */
    public function actionRepairHome()
    {
        $e = new stdClass();
        $e->success = true;

        // 获取顶级分类信息
        $cats = DeviceCatRepository::getRootCatsWithImg();

        // 首页广告
        $ads = [];
        $adsArray = UserAdsRepository::search(['is_enable' => 1], ['orderBy' => ['sort_order' => SORT_ASC]])->fetchAll();
        foreach ($adsArray as $adItem) {
            $ad = new stdClass();
            $ad->id = $adItem['id'];
            $ad->title = $adItem['title'];
            $ad->cover_img_path = !empty($adItem['cover_img_path']) ? ImageManager::getUrl($adItem['cover_img_path']) : '';
            $ad->link_mode = $adItem['link_mode'];
            $ad->link_mode_label = $adItem['link_mode_label'];
            $ad->url = $adItem['url'];
            $ad->appid = $adItem['appid'];
            $ad->path = $adItem['path'];
            $ads[] = $ad;
        }

        // 后台读取配置
        $e->service_phone = SysSettingModel::getServicePhone();
        $e->enable_more = (SysSettingModel::getIsMoreDeviceEnable() == 1) ? true : false; // 是否启用更多分类: 未启用提示"敬请期待..."
        //$e->is_notice_enable = (SysSetting::getIsNoticeEnable() == 1) ? true : false; // 是否启用通知栏
        //$e->can_close_notice = (SysSetting::getCanCloseNotice() == 1) ? true : false; // 是否允许关闭通知栏
        $e->ads = $ads;
        $e->cats = $cats;

        return $e;
    }

    /**
     * 极速报修首页获取用户相关信息
     * @return string
     */
    public function actionRepairHomeUser()
    {
        $e = new stdClass();
        $e->device_fav_num = 0;
        $e->hasBindPhone = false;
        $e->hasCouponActivity = false;

        $clientUserId = $this->getClientUserId();
        $clientUser = ClientUserModel::findOne($clientUserId);
        if (false == $clientUser) {
            return $e;
        }

        $userModel = $this->getUserModel();
        if (false == $userModel) {
            return $e;
        }

        // 检测是否有符合的优惠券活动
        $coupon_activity = MarketingCoupon::checkCouponActivity($userModel->id, $clientUserId, CouponActivityModel::CHANNEL_USER_MINA, CouponActivityModel::ACTION_HOME_PAGE);
        if ($coupon_activity) {
            $e->hasCouponActivity = true;
            $e->couponActivity = $coupon_activity;
        }

        // 设备收藏夹数量
        $e->device_fav_num  = UserDeviceFavModel::getFavNum($userModel->id);

        // 是否手机号绑定认证
        if (!empty($userModel->phone)) {
            $e->hasBindPhone = true;
            // 手机认证用户才需要显示
            $e->agreement_version = MinaHelper::getAgreementVersion(); // 极办公用户协议版本号
            $e->agreement_udpate_desc = MinaHelper::getAgreementUpdateDesc(); // 极办公用户协议更新描述
        }

        return $e;
    }


    /**
     * 读取维修设备的二级分类数据
     * @return stdClass
     */
    public function actionDeviceCats()
    {
        $e = new stdClass();
        $e->success = false;

        if (false == $this->request->isPost) {
            $e->success = false;
            return $e;
        }

        $deviceCatId = $this->request->post('id');
        if (empty($deviceCatId)) {
            $e->success = false;
            return $e;
        }

        $cats = DeviceCatRepository::getCatByParentIdWithImg($deviceCatId);

        $e->success = true;
        $e->cats = $cats;

        return $e;
    }

    /**
     * 获取指定设备分类ID下的所有品牌
     * @return stdClass
     */
    public function actionGetBrands()
    {
        $e = new stdClass();
        $e->success = false;

        if (false == $this->request->isPost) {
            $e->success = false;
            return $e;
        }

        // 从设备型号表找出属于$deviceCatId的所有不同品牌
        $deviceCatId = $this->request->post('device_cat_id');
        if (empty($deviceCatId)) {
            $e->success = false;
            return $e;
        }

        $deviceCatModel = DeviceCatRepository::selectOne($deviceCatId);
        if (!$deviceCatModel) {
            $e->success = false;
            return $e;
        }

        $query = new Query();
        $query->select(['brand.id AS brand_id', 'brand.chinese_name AS chinese_name', 'brand.english_name AS english_name', 'brand.img_url AS img_url']);
        $query->from('model');
        $query->leftJoin('brand', 'brand.id = model.brand_id');
        $query->groupBy('brand.id');
        $query->where([
            'brand.is_available'  => 1,
            'model.device_cat_id' => $deviceCatId
        ]);
        $brandArray = $query->all();

        // 格式化返回匹配的品牌数组
        $brands = [];

        foreach ($brandArray as $item) {
            if (empty($item['brand_id'])) {
                continue ;
            }
            if ($item['english_name'] == 'JIWORK') {
                continue ; // 过滤[极办公]品牌
            }
            $brand = new stdClass();
            $brand->id = $item['brand_id'];
            $brand->name = $item['chinese_name'];
            $brand->english_name = $item['english_name'];
	        $brand->full_name = $item['chinese_name'] . '( ' . $item['english_name'] . ' )';
            $brand->icon = $item['img_url'] ? ImageManager::getUrl($item['img_url'], ImageManager::$STYLE_180) : '';

            // 电脑通用品牌图标区分: 台式机/笔记本/一体机
            if ($item['english_name'] == 'COMPUTER') {
                if ($deviceCatModel->name == "一体机") {
                    $brand->icon = '/i/ic_computer_yiti.png';
                } elseif ($deviceCatModel->name == "笔记本") {
                    $brand->icon = '/i/ic_computer_notebook.png';
                }
            }

            $brands[] = $brand;
        }

        $rootCatModel = DeviceCatRepository::selectOne($deviceCatId);
        if (isset($rootCatModel->parent_id) && $rootCatModel->parent_id != DeviceCat::COMPUTER_CAT_ID) {
            $brand = new stdClass();
            $brand->id = 0;
            $brand->name = "其它品牌";
            $brand->english_name = "OTHER";
            $brand->full_name = "其它品牌";
            $brand->icon = '/i/ic_brand_other.png';
            $brands[] = $brand;
        }
        $e->success = true;
        $e->brands = $brands;

        return $e;
    }

    /**
     * 读取系统对应二级分类的所有常见故障列表
     * @return stdClass
     */
    public function actionGetFaultsByCatId()
    {
        $e = new stdClass();
        $e->success = false;

        if (false == $this->request->isPost) {
            $e->success = false;
            return $e;
        }

        $deviceCatId = $this->request->post('device_cat_id');
        if (empty($deviceCatId)) {
            $e->success = false;
            return $e;
        }

        $faults = [];
        //$faultArray = DeviceFault::findAll(['device_cat_id' => $deviceCatId, 'is_common' => 1]);
        //$faultArray = DeviceFault::find()->where(['device_cat_id' => $deviceCatId, 'is_common' => 1])->orderBy('sort_order ASC')->all();
        $faultArray = DeviceFaultModel::find()->where(['device_cat_id' => $deviceCatId, 'version' => Yii::$app->params['DATA_VERSION']])->orderBy('sort_order ASC')->all();
        foreach ($faultArray as $faultItem) {
            $fault = new stdClass();
            $fault->id = $faultItem->id;
            $fault->name = $faultItem->name;
            $faults[] = $fault;
        }

        $e->success = true;
        $e->faults = $faults;

        return $e;
    }


    /**
     * 根据二维码编号获取设备信息
     * @return stdClass
     */
    public function actionGetDeviceByNumber()
    {
        $e = new stdClass();
        $e->success = false;

        if (false == $this->request->isPost) {
            $e->success = false;
            return $e;
        }

        $qrcode_number = $this->request->post('qrcode_number');
        AppLog::DEBUG('根据二维码编号获取设备信息: qrcode_number=' . $qrcode_number);
        if (empty($qrcode_number)) {
            $e->error = '无效设备二维码';
            $e->success = false;
            return $e;
        }

        $deviceQuery = QrcodeModel::find();
        $deviceQuery->select(['qrcode.*',
            'user_device.id AS device_id',
            'user_device.uuid AS device_uuid',
            'brand.id AS brand_id',
            'device_cat.id AS device_cat_id',
            'device.device_name AS device_name']);
        $deviceQuery->leftJoin('user_device', "qrcode.id = user_device.device_qrcode_id");
        $deviceQuery->leftJoin('device', "user_device.device_id = device.id");
        $deviceQuery->leftJoin('device_cat', "device.device_cat_id = device_cat.id");
        $deviceQuery->leftJoin('model', "device.model_id = model.id");
        $deviceQuery->leftJoin('brand', "model.brand_id = brand.id");
        $deviceQuery->where(['qrcode.number'=> $qrcode_number]);
        $deviceQuery->asArray();
        $deviceArray = $deviceQuery->one();
        if (empty($deviceArray)) {
            $e->error = '无效设备二维码';
            return $e;
        }

        if ($deviceArray['device_id'] == 0) {
            $e->error = '该二维码未绑定设备';
            return $e;
        }

        $device = new stdClass();
        $device->device_id = $deviceArray['device_uuid'];
        $device->brand_id = (int)$deviceArray['brand_id'];
        $device->device_cat_id = (int)$deviceArray['device_cat_id'];
        $device->device_name = $deviceArray['device_name'];

        $e->success = true;
        $e->device = $device;

        return $e;
    }


    /**
     * 获取设备信息
     * @return stdClass
     */
    public function actionGetDeviceDetail()
    {
        $e = new stdClass();
        $e->success = false;
        $e->needClaim = false;
        $e->orderId = '';

        if (false == $this->request->isPost) {
            $e->success = false;
            return $e;
        }

        $channel = $this->request->post('channel');
        $qrcodeNumber = $this->request->post('qrcodeNumber');
        $deviceUUId = $this->request->post('deviceId');
        $deviceType = $this->request->post('deviceType');

        AppLog::DEBUG('获取设备信息[参数]: ' . 'channel=' . $channel . ' | qrcodeNumber=' . $qrcodeNumber . ' | deviceUUId=' . $deviceUUId . ' | deviceType=' . $deviceType);

        // 根据设备二维码读取
        if ($channel == RepairOrderChannel::REPAIR_CHANNEL_SCAN || $channel == RepairOrderChannel::REPAIR_CHANNEL_HOME_SCAN) {
            $deviceResult = QrcodeModel::getDeviceInfoByScan($qrcodeNumber);
            if (false == $deviceResult->success) {
                return $deviceResult;
            }
            $deviceArray = $deviceResult->device;
            $device = new stdClass();
            $device->device_id = $deviceArray['device_uuid'];
            $device->model_id = $deviceArray['model_uuid'];
            $device->device_name = !empty($deviceArray['device_name']) ? $deviceArray['device_name'] : '';
            $device->model_name = !empty($deviceArray['model_name']) ? $deviceArray['model_name'] : '';
            $device->serial_no = !empty($deviceArray['serial_no']) ? $deviceArray['serial_no'] : '';
            $device->device_img = DeviceCatRepository::getParentCatImg($deviceArray['cat_parent_id'], $deviceArray['device_img']); ;

            // 设备位置
            if ($deviceArray['address_id']) {
                $addressModel = AddressModel::findOne($deviceArray['address_id']);
                if ($addressModel) {
                    $addressTitle = empty($addressModel->title)?$addressModel->address:$addressModel->title;
                    $addressDetailNote =  empty($addressModel->detail)?'':$addressModel->detail;
                    $device->address = $addressTitle.$addressDetailNote;
                } else {
                    $device->address = false;
                }
            }

            // 设备拥有者
            if ($deviceArray['owner_id']) {
                $ownerModel = OwnerModel::findOne($deviceArray['owner_id']);
                if ($ownerModel) {
                    $device->owner = $ownerModel->name;
                } else {
                    $device->owner = false;
                }
            }
            $user_id = $this->getUserId();
            $clientUserId = $this->getClientUserId();
            $claimResult = new stdClass();
            if (!empty($device->model_id) && !empty($user_id)) {
                $claimResult = RepairOrderClaimRepository::canClaimDeviceOrder($deviceArray['user_device_id'], UserDeviceFavModel::DeviceTypeUser, $user_id);
            } else {
                $claimResult->success = false;
            }

            if (true == $claimResult->success) {
                $orders = [];
                $device->busy_order = false;
                $device->can_submit_order = false;
                $e->needClaim = true;
                $e->orderId = $claimResult->orderId;
            } else {
                // 维修订单记录
                $orders = $this->getDeviceOrders(0, self::PAGE_SIZE, $deviceArray['user_device_id'], UserDeviceFavModel::DeviceTypeUser);

                // 查找该设备是否有亟需处理订单
                $device->busy_order = $this->getBusyOrder($deviceArray['user_device_id'], UserDeviceFavModel::DeviceTypeUser);
                $device->can_submit_order = UserDeviceModel::canSubmitOrder($deviceArray['user_device_id']);
            }

            MarketingCoupon::checkCouponActivity($user_id, $clientUserId,  CouponActivityModel::CHANNEL_USER_MINA,  CouponActivityModel::ACTION_SCAN_ORDER_DETAIL);
        } elseif ($channel == RepairOrderChannel::REPAIR_CHANNEL_FAV) { // 根据设备ID读取详情
            $dResult = UserDeviceModel::getFavDeviceInfoById($deviceUUId);
            if (false == $dResult->success) {
                return $dResult;
            }
            $deviceArray = $dResult->device;

            $device = new stdClass();
            $device->device_id = $deviceArray['device_uuid'];
            $device->model_id = $deviceArray['model_uuid'];

            $brandName = isset($deviceArray['brand_name'])?$deviceArray['brand_name']:'';
            $deviceName = isset($deviceArray['device_name'])?$deviceArray['device_name']:'';
            $deviceCatName = isset($deviceArray['device_cat_name'])?$deviceArray['device_cat_name']:'';

            // 设备名称
            $device->device_name = !empty($deviceName) ? $deviceName : $brandName.'-'.$deviceCatName;

            // 未审核用户设备空值处理
            if (empty($device->device_name)) {
                $device->device_name = '';
            }
            // 设备型号名称
            $device->model_name = !empty($deviceArray['model_name']) ? $deviceArray['model_name'] : $deviceArray['input_model'];
            if (empty($device->model_name)) {
                $device->model_name = '';
            }

            // 设备序列号
            if ($deviceType == UserDeviceFavModel::DeviceTypeUser) {
                $device->serial_no = $deviceArray['serial_no'];
            } else {
                $device->serial_no = '';
            }

            // 未审核用户设备空值处理
            if (empty($device->serial_no)) {
                $device->serial_no = '';
            }

            $device->device_img = DeviceCatRepository::getParentCatImg($deviceArray['cat_parent_id'], $deviceArray['device_img']) ;//$deviceArray['device_img'] ? ImageManager::getUrl($deviceArray['device_img']) : '/i/ic_device.jpg';

            // 设备位置
            if ($deviceType == UserDeviceFavModel::DeviceTypeUser && $deviceArray['address_id']) {
                $addressModel = AddressModel::findOne($deviceArray['address_id']);
                if ($addressModel) {
                    $device->address = $addressModel->address;
                } else {
                    $device->address = false;
                }
            } else {
                $device->address = false;
            }

            // 设备拥有者
            if ($deviceType == UserDeviceFavModel::DeviceTypeUser && $deviceArray['owner_id']) {
                $ownerModel = OwnerModel::findOne($deviceArray['owner_id']);
                if ($ownerModel) {
                    $device->owner = $ownerModel->name;
                } else {
                    $device->owner = false;
                }
            } else {
                $device->owner = false;
            }
            $user_id = $this->getUserId();
            $claimResult = new stdClass();
            if (!empty($deviceArray['model_uuid']) && !empty($user_id)) {
                $claimResult = RepairOrderClaimRepository::canClaimDeviceOrder($deviceArray['device_id'], UserDeviceFavModel::DeviceTypeUser, $user_id);
            } else {
                $claimResult->success = false;
            }
            if (true == $claimResult->success) {
                $orders = [];
                $device->busy_order = false;
                $device->can_submit_order = false;
                $e->needClaim = true;
                $e->orderId = $claimResult->orderId;
            } else {
                // 历史维修订单记录
                $orders = $this->getDeviceOrders(0, self::PAGE_SIZE, $deviceArray['device_id'], $deviceType);

                // 查找该设备是否有亟需处理订单
                $device->busy_order = $this->getBusyOrder($deviceArray['device_id'], UserDeviceFavModel::DeviceTypeUser);
                $device->can_submit_order = UserDeviceModel::canSubmitOrder($deviceArray['device_id']);
            }

        } else {
            $e->error = '非法访问设备详情页';
            return $e;
        }

        $bindStatus = $deviceArray['bindStatus'];
        if (BindDeviceApplyModel::STATUS_APPLY_PASS == $bindStatus) {
            $device->showSerial = true; 
        } else {
            $device->showSerial = false;
        }

        $e->success = true;
        $e->device = $device;
        $e->orders = $orders;

        // 是否手机号绑定认证
        $userModel = $this->getUserModel();
        if ($userModel && !empty($userModel->phone)) {
            $e->hasBindPhone = true;
        } else {
            $e->hasBindPhone = false;
        }

        return $e;
    }

    /** 获取订设备维修订单
     * @param $offset
     * @param $limit
     * @param $deviceId
     * @param $deviceType
     * @return array
     */
    private function getDeviceOrders($offset, $limit, $deviceId, $deviceType)
    {
        $userId = $this->getUserId();
        $orders = [];

//        $orderQuery = RepairOrder::find();
        $orderQuery = new Query();
        $orderQuery->select(['repair_order.*', 'repair_order_detail.contact_name', 'engineer_profile.firstname AS firstname', 'engineer_profile.lastname AS lastname']);
        $orderQuery->from('repair_order');
        $orderQuery->leftJoin('engineer_profile', "`repair_order`.`engineer_id` = `engineer_profile`.`engineer_id`");
        $orderQuery->leftJoin('repair_order_detail', "`repair_order_detail`.`repair_order_id` = `repair_order`.`id`");
        $orderQuery->where(['repair_order.repair_device_id' => $deviceId]);
        $orderQuery->andWhere(['repair_order.repair_device_type' => $deviceType]);

        // 只读取已完成订单-[修改为: 全部展示]
        //$statusValues = [RepairOrderStatus::STATUS_WAIT_RATE, RepairOrderStatus::STATUS_FINISH];
        //$orderQuery->andFilterWhere(['repair_order.status' => $statusValues]);
        // 过滤系统删除订单
        $orderQuery->andWhere(['repair_order.is_system_delete' => 0]);
        $orderQuery->orderBy('repair_order.id DESC');
        $orderQuery->offset($offset);
        $orderQuery->limit($limit);
        $rows = $orderQuery->all();

        // 获取最终结果
        foreach ($rows as $row) {
            $order = [];
            $orderId =  $row['id'];
            $order['order_id'] = $row['uuid'];
            $order['repair_price'] = RepairOrderPriceRule::orderTotalPrice($row, true); // 订单总金额， 这个reprice_price 不是订单里面的repair_price
            $order['status'] = (int)$row['status'];
            $order['processing'] = RepairOrderStatus::isProcessing($row['status']);
            $order['status_label'] = RepairOrderStatus::statusLabel($row['status']);
            $order['created_time'] = $row['created_at'] ? date('Y-m-d', $row['created_at']) : '';

            // 维修工程师名字
            if ($row['engineer_id'] != 0) {
                $order['engineer_name'] = $row['firstname'] . '工'; // $row['firstname'] . $row['lastname'];
            }else {
                $order['engineer_name'] = false;
            }

            /**
             * 报修用户信息
             */
            //if ($row['user_id']) {
            $order['repair_user_name'] = empty($row['contact_name']) ? UserModel::getUserNickName($row['user_id'], $row['client_id']) : $row['contact_name'];
            $avatar = UserModel::getUseAvatar($row['user_id'], $row['client_id']);

            $order['repair_user_avatar'] = Utils::getUserAvatar($avatar);
            //}

            // 权限检查: 订单本人和授权用户才有权限
            $order['has_permission'] = RepairOrderUserOp::hasPermission($userId, $orderId);

            /**
             * 维修方案
             */
            $repairPlansQuery = RepairOrderRepairPlansModel::find()
                ->select(['repair_plan_id', 'plan_name AS name', 'price'])
                ->where(['repair_order_id' => $orderId])
                ->asArray();
            // 拼接维修方案描述
            $repair_plans_desc = '';
            if ($repairPlansArray = $repairPlansQuery->all()) {
                foreach ($repairPlansArray as $k => $item) {
                    if ( 0 == $k ) {
                        $repair_plans_desc = $repair_plans_desc . $item['name'];
                    } else {
                        $repair_plans_desc = $repair_plans_desc . ' | '. $item['name'];
                    }
                }
            }
            $order['repair_plans_desc'] = $repair_plans_desc;

            // 填充数组
            $orders[] = $order;
        }

        return $orders;
    }

    /**
     * 获取指定设备的历史维修订单
     * @return string
     */
    public function actionGetDeviceOrders()
    {
        $e = new stdClass();
        $e->success = false;
        $e->orders = [];

        $deviceUUId = $this->request->post('deviceId');
        $deviceType = (int)$this->request->post('deviceType');
        $offset = (int)$this->request->post('offset');
        $limit = (int)$this->request->post('limit');

        $deviceId = '';
        if (RepairOrderModel::REPAIR_DEVICE_USER_TYPE == $deviceType) {
            $deviceInfo = UserDeviceModel::findOne(['uuid' => $deviceUUId]);
        } else {
            $deviceInfo = GuestDeviceModel::findOne(['uuid' => $deviceUUId]);
        }
        if ($deviceInfo) {
            $deviceId = $deviceInfo->id;
        }

        $orders = $this->getDeviceOrders($offset, $limit, $deviceId, $deviceType);
        if (sizeof($orders)) {
            $e->hasMore = true;
            $e->orders = $orders;
        } else {
            $e->hasMore = false;
        }

        $e->success = true;
        return $e;
    }

    /**
     * 查找指定设备是否存在亟需处理的订单
     * @param $deviceId
     * @param $deviceType
     * @return int
     */
    private function getBusyOrder($deviceId, $deviceType)
    {
        $orderQuery = new Query();
        $orderQuery->select(['repair_order.*']);
        $orderQuery->from('repair_order');
        $orderQuery->where(['repair_order.repair_device_id' => $deviceId]);
        $orderQuery->andWhere(['repair_order.repair_device_type' => $deviceType]);

        // 3-确认报价；4-等待验收；5-等待支付；
        $statusValues = [
            RepairOrderStatus::STATUS_CONFIRM_PRICE,
            RepairOrderStatus::STATUS_WAIT_ACCEPT,
            RepairOrderStatus::STATUS_WAIT_PAY
        ];
        $orderQuery->andWhere(['repair_order.status' => $statusValues]);

        $orderArray = $orderQuery->one();
        if (empty($orderArray)) {
            return false;
        }

        // 权限检查: 订单本人和授权用户才有权限
        $userId = $this->getUserId();
        $hasPermission = RepairOrderUserOp::hasPermission($userId, $orderArray['id']);
        if (false == $hasPermission) {
            return false;
        }

        $busyOrder = new stdClass();
        $busyOrder->id = $orderArray['uuid'];
        $busyOrder->status = (int)$orderArray['status'];

        //AppLog::DEBUG('getBusyOrder: 该设备有待处理订单=>' . json_encode($busyOrder));

        return $busyOrder;
    }

    /**
     * 扫码领红包结果回调
     * @return stdClass
     */
    public function actionScanRedpackResult()
    {
        $e = new stdClass();
        $e->success = false;
        $e->errMsg = false;

        $clientUserId = $this->getClientUserId();
        $clientUser = ClientUserModel::findOne($clientUserId);
        if (false == $clientUser) {
            $e->errMsg = '用户不存在';
            return $e;
        }

        // 读取传参
        $success = $this->request->post('success');
        $user_redpacks_id = $this->request->post('user_redpacks_id');
        $func = $this->request->post('func');
        $jsRes = $this->request->post('jsRes');
        WxpayLog::init();
        WxpayLog::DEBUG('扫码领红包js返回结果(' . $func .  '):=>' . json_encode($jsRes) . ' | success=' . $success);

        $userRedpacksModel = UserRedpacksModel::findOne(['client_user_id' => $clientUserId, 'id' => $user_redpacks_id]);
        // 更新红包领取记录的状态
        if (false == $userRedpacksModel) {
            $e->errMsg = '红包领取记录不存在';
            return $e;
        }

        $userRedpacksModel->status = $success ? UserRedpacksModel::STATUS_OPEN_SUCCESS : UserRedpacksModel::STATUS_OPEN_FAIL;
        $userRedpacksModel->received_at = time();
        if (!$userRedpacksModel->save()) {
            $e->errMsg = '红包领取记录保存失败';
            return $e;
        }

        $e->success = true;
        return $e;
    }

    /**
     * 扫码领红包接口
     * @return stdClass
     */
    public function actionScanRedpack()
    {
        $e = new stdClass();
        $e->success = false;
        $e->errMsg = false;
        $e->subcribeHint = RedpackActivityModel::SUBCRIBE_HINT;
        $e->has_no_act = false;

        $qrcodeNumber = $this->request->post('qrcodeNumber');
        if (empty($qrcodeNumber)) {
            // 邮件通知告警
            //AppErrorLog::error("[设备二维码扫码红包] 无效二维码编号");
            $e->errMsg = '无效二维码编号';
            return $e;
        }

        // 检测是否demo二维码
        if ($qrcodeNumber == RedpackActivityModel::DEMO_QRCODE_NUMBER) {
            // 邮件通知告警
            //AppErrorLog::error("[设备二维码扫码红包] 检测demo二维码");
            return $this->scanDemoRedpack();
        }

        // 扫码收藏用户设备
        $deviceResult = QrcodeModel::getDeviceInfoByScan($qrcodeNumber);
        if ($deviceResult->success) {
            $deviceArray = $deviceResult->device;
            $user_id = $this->getUserId();
            if ($deviceArray['device_id'] > 0) { // 仅收藏已审核通过的设备
                UserDeviceFavModel::scanFavDevice($user_id, $deviceArray['user_device_id']);
            }
        }

        $user_device_id = $this->getUserDeviceIdByQrcodeNumber($qrcodeNumber);
        if (false == $user_device_id) {
            // 邮件通知告警
            //AppErrorLog::error("[设备二维码扫码红包] 设备不存在=>[qrcodeNumber=" . $qrcodeNumber . ']');
            $e->errMsg = '设备不存在';
            return $e;
        }

        $clientUserId = $this->getClientUserId();
        $clientUser = ClientUserModel::findOne($clientUserId);
        if (false == $clientUser || false == $clientUser->profileMina) {
            // 邮件通知告警
            //AppErrorLog::error("[设备二维码扫码红包] 用户不存在");
            $e->errMsg = '用户不存在';
            return $e;
        }

        $clientId = $clientUser->client_id;
        $openId = $clientUser->profileMina->openid;

        // 该手机号在工程师端注册的角色是否允许领红包
//        $engineerModel = Engineer::findOne(['phone' => $clientUser->user->phone]);
//        if ($engineerModel && !Engineer::canRedpack($engineerModel->role)) {
//            $e->errMsg = '不允许领红包';
//            $e->has_no_act = true;
//            return $e;
//        }

        /**
         * 读取红包活动表，判断当前设备、当前用户是否符合【场景红包】领取条件，如符合则调用JS接口（回调函数中必须调用API更新红包领取记录表）；如不符合则弹窗提示“该设备红包已被领取，更多红包正在来袭~”
         * 约定: 用户U1     设备D1     活动A1
         * 1. 查找一个可参加的活动: 启用/未过期(多个活动循环判断一个有红包的)
         * 2. D1的A1红包未被领取完 < redpack_num_per_device
         * 3. U1领取A1红包数量 < redpack_num_per_user
         */
        $findActivity = new stdClass();
        $resultCode = RedpackActivityModel::RESULT_NO_ACT;

        $currentTime = time();
        $weekDay = date('w'); // 0-周日; 1~6-周一~周六
        $actQuery = RedpackActivityModel::find()
            ->select(['redpack_activity.*'])
            ->where(['redpack_activity.is_enable' => 1])
            ->andWhere(['redpack_activity.scene' => RedpackActivityModel::SCENE_SCAN])
            ->andFilterWhere(['<=', 'redpack_activity.start_at', $currentTime])
            ->andFilterWhere(['>=', 'redpack_activity.end_at', $currentTime])
            ->andWhere("find_in_set('{$weekDay}', redpack_activity.weekdays)") // 固定星期几有效
            ->asArray();
        $actArray = $actQuery->all();
        if ($actQuery && $actArray) {
            foreach ($actArray as $act) {
                // 判断该红包活动已发放金额是否超过预算 或 超过发放总数
                $sendAmountQuery = UserRedpacksModel::find()
                    ->select(['SUM(user_redpacks.amount) as sent_amount', 'COUNT(*) as sent_num'])
                    ->where(['user_redpacks.redpack_activity_id' => $act['id']])
                    ->asArray();
                $sendAmount = $sendAmountQuery->one();
                $sent_amount = $sendAmount['sent_amount'] ? $sendAmount['sent_amount'] : 0;
                $sent_num = $sendAmount['sent_num'] ? $sendAmount['sent_num'] : 0;
                if ($sent_amount >= $act['total_amount']) {
                    // 邮件通知告警
                    //AppErrorLog::error("[设备二维码扫码红包]活动ID:{$act['id']}、端用户编号(client_user_id):{$clientUserId}、扫描二维码编号:{$qrcodeNumber}; 该活动已经超预算了");
                    continue ; // 该活动已超预算, 直接跳过
                }
                if ($sent_num >= $act['total_num']) {
                    // 邮件通知告警
                    //AppErrorLog::error("[设备二维码扫码红包]活动ID:{$act['id']}、端用户编号(client_user_id):{$clientUserId}、扫描二维码编号:{$qrcodeNumber}; 该活动红包已发完");
                    continue ; // 该活动红包已发完, 直接跳过
                }

                // 遍历查找一个该设备的红包尚未领取完的活动
                $deviceRedpackQuery = UserRedpacksModel::find()
                    ->select('COUNT(*)')
                    ->where(['user_redpacks.redpack_activity_id' => $act['id']])
                    ->andWhere(['user_redpacks.user_device_id' => $user_device_id])
                    ->asArray();

                // 该设备还有该活动红包可以领取
                $sendCount = $deviceRedpackQuery->count();
                if ($sendCount < $act['redpack_num_per_device']) {
                    // 用户领取该活动红包数量是否超过限制
                    $userRedpackQuery = UserRedpacksModel::find()
                        ->select('COUNT(*)')
                        ->where(['user_redpacks.redpack_activity_id' => $act['id']])
                        ->andWhere(['user_redpacks.client_user_id' => $clientUserId])
                        ->asArray();

                    $userRecvCount = $userRedpackQuery->count();
                    if ($userRecvCount < $act['redpack_num_per_user']) {
                        // 用户领取该活动单个设备的红包数量是否超过限制
                        $userDeviceRedpackQuery = UserRedpacksModel::find()
                            ->select('COUNT(*)')
                            ->where(['user_redpacks.redpack_activity_id' => $act['id']])
                            ->andWhere(['user_redpacks.user_device_id' => $user_device_id])
                            ->andWhere(['user_redpacks.client_user_id' => $clientUserId])
                            ->asArray();

                        $userDeviceRecvCount = $userDeviceRedpackQuery->count();
                        if ($userDeviceRecvCount < $act['user_redpack_num_per_device']) {
                            $findActivity->id = $act['id'];
                            $findActivity->name = $act['name'];
                            $findActivity->send_name = $act['send_name'];
                            $findActivity->remark = $act['remark'];

                            // 找到一个可领取的红包, 直接跳出, 走红包领取流程
                            $resultCode = RedpackActivityModel::RESULT_OK;
                            break;
                        } else {
                            // 邮件通知告警
                            //AppErrorLog::error("[设备二维码扫码红包]活动ID:{$act['id']}、端用户编号(client_user_id):{$clientUserId}、扫描二维码编号:{$qrcodeNumber}; 用户领取该活动单个设备的红包数量超过限制（用户领取数：{$userDeviceRecvCount}，设置数：{$act['user_redpack_num_per_device']}）");
                            $resultCode = RedpackActivityModel::RESULT_OVER_DEVICE_LIMIT;
                        }
                    } else {
                        // 邮件通知告警
                        //AppErrorLog::error("[设备二维码扫码红包]活动ID:{$act['id']}、端用户编号(client_user_id):{$clientUserId}、扫描二维码编号:{$qrcodeNumber}; 该活动红包每个用户可领取红包个数超限（用户领取数：{$userRecvCount}，设置数：{$act['redpack_num_per_user']}）");
                        $resultCode = RedpackActivityModel::RESULT_OVER_ACT_LIMIT;
                    }
                } else {
                    // 邮件通知告警
                    //AppErrorLog::error("[设备二维码扫码红包]活动ID:{$act['id']}、端用户编号(client_user_id):{$clientUserId}、扫描二维码编号:{$qrcodeNumber}; 该活动红包每台设备可领取红包个数超限（当前领取数：{$sendCount}，设置数：{$act['redpack_num_per_device']}）");
                    $resultCode = RedpackActivityModel::RESULT_DEVICE_NO_REDPACK;
                }
            }
        } else {
            // 邮件通知告警
            // AppErrorLog::error("[设备二维码扫码红包]端用户编号(client_user_id):{$clientUserId}、扫描二维码编号:{$qrcodeNumber}; 暂无可参加的红包活动");
        }

        // 领取红包失败
        if (RedpackActivityModel::RESULT_OK != $resultCode ) {
            $e->errMsg = RedpackActivityModel::resultLabels($resultCode);
            $e->has_no_act = true; // 不提示用户, 太烦了
            return $e;
        }

        // 红包领取流程
        try {
            AppLog::DEBUG(json_encode($findActivity));
            $redpackAmount = RedpackAmountModel::getRandomAmountRecord($findActivity->id);
            $amount = $redpackAmount ? $redpackAmount->amount : RedpackAmountModel::DEFAULT_AMOUNT;
            $wishing = $redpackAmount ? $redpackAmount->wishing : RedpackAmountModel::DEFAULT_WISHING;
            $result = MinaHelper::sendMinaRedPack($openId, $amount, $wishing, $findActivity->name, $findActivity->remark, $findActivity->send_name);

            // 添加红包领取记录
            $userRedpacksModel = new UserRedpacksModel([
                'client_id'             => $clientId,
                'client_user_id'        => $clientUserId,
                'redpack_activity_id'   => $findActivity->id,
                'user_device_id'        => $user_device_id,
                'amount'                => $amount,
                'status'                => UserRedpacksModel::STATUS_WAIT,
                'jsApiParameters'       => $result['jsApiParameters'], // 保存小程序红包发放接口返回结果,用于红包领取失败后重新领取
                'send_result'           => $result['result'], // 保存小程序红包发放接口返回结果
            ]);
            $userRedpacksModel->save();
            $userRedpackId = $userRedpacksModel->id;
        } catch (Exception $exception) {
            Yii::getLogger()->log($exception->getTraceAsString(), Logger::LEVEL_ERROR);
            //$e->errMsg = '接口异常: ' . $exception->getMessage();
            $e->errMsg = RedpackActivityModel::resultLabels(RedpackActivityModel::RESULT_API_ERROR);
            return $e;
        }

        $e->success = true;
        $e->jsApiParameters = json_decode($result['jsApiParameters']);
        $e->user_redpacks_id = $userRedpackId;
        return $e;
    }

    /**
     * 根据二维码编号判断对一个的用户设备是否存在
     * @param $qrcodeNumber
     * @return bool
     */
    private function getUserDeviceIdByQrcodeNumber($qrcodeNumber)
    {
        $deviceQuery = QrcodeModel::find();
        $deviceQuery->select(['qrcode.*',
            'user_device.id AS user_device_id',
        ]);
        $deviceQuery->leftJoin('user_device', "qrcode.id = user_device.device_qrcode_id");
        $deviceQuery->leftJoin('device', "user_device.device_id = device.id");
        $deviceQuery->where(['qrcode.number' => $qrcodeNumber]);
        $deviceQuery->asArray();
        $deviceArray = $deviceQuery->one();
        if (empty($deviceArray) || $deviceArray['user_device_id'] == 0) {
            return false;
        }

        return $deviceArray['user_device_id'];
    }

    /**
     * 扫描demo二维码, 100%发红包(仅供演示)
     * @return stdClass
     */
    public function scanDemoRedpack()
    {
        $e = new stdClass();
        $e->success = false;
        $e->errMsg = false;
        $e->subcribeHint = RedpackActivityModel::SUBCRIBE_HINT;
        $e->has_no_act = false;

        $qrcodeNumber = RedpackActivityModel::DEMO_QRCODE_NUMBER;
        $user_device_id = $this->getUserDeviceIdByQrcodeNumber($qrcodeNumber);
        if (false == $user_device_id) {
            $e->errMsg = '用户设备不存在';
            return $e;
        }

        $clientUserId = $this->getClientUserId();
        $clientUser = ClientUserModel::findOne($clientUserId);
        if (false == $clientUser || false == $clientUser->profileMina) {
            $e->errMsg = '用户不存在';
            return $e;
        }

        $clientId = $clientUser->client_id;
        $openId = $clientUser->profileMina->openid;

        $findActivity = RedpackActivityModel::findOne(['scene' => RedpackActivityModel::SCENE_DEMO]);
        if (false == $findActivity) {
            $e->errMsg = '未设置demo红包活动';
            return $e;
        }

        // 判断该红包活动已发放金额是否超过预算 或 超过发放总数
        $sendAmountQuery = UserRedpacksModel::find()
            ->select(['SUM(user_redpacks.amount) as sent_amount', 'COUNT(*) as sent_num'])
            ->where(['user_redpacks.redpack_activity_id' => $findActivity->id])
            ->asArray();
        $sendAmount = $sendAmountQuery->one();
        $sent_amount = $sendAmount['sent_amount'] ? $sendAmount['sent_amount'] : 0;
        $sent_num = $sendAmount['sent_num'] ? $sendAmount['sent_num'] : 0;
        if ($sent_amount >= $findActivity->total_amount) {
            // 该活动已超预算, 直接跳过
            $e->has_no_act = true;
            return $e;
        }
        if ($sent_num >= $findActivity->total_num) {
            // 该活动红包已发完, 直接跳过
            $e->has_no_act = true;
            return $e;
        }

        // 遍历查找一个该设备的红包尚未领取完的活动
        $deviceRedpackQuery = UserRedpacksModel::find()
            ->select('COUNT(*)')
            ->where(['user_redpacks.redpack_activity_id' => $findActivity->id])
            ->andWhere(['user_redpacks.user_device_id' => $user_device_id])
            ->asArray();

        // 该设备还有该活动红包可以领取
        $sendCount = $deviceRedpackQuery->count();
        if ($sendCount < $findActivity->redpack_num_per_device) {
            // 用户领取该活动红包数量是否超过限制
            $userRedpackQuery = UserRedpacksModel::find()
                ->select('COUNT(*)')
                ->where(['user_redpacks.redpack_activity_id' => $findActivity->id])
                ->andWhere(['user_redpacks.client_user_id' => $clientUserId])
                ->asArray();

            $userRecvCount = $userRedpackQuery->count();
            if ($userRecvCount < $findActivity->redpack_num_per_user) {
                // 用户领取该活动单个设备的红包数量是否超过限制
                $userDeviceRedpackQuery = UserRedpacksModel::find()
                    ->select('COUNT(*)')
                    ->where(['user_redpacks.redpack_activity_id' => $findActivity->id])
                    ->andWhere(['user_redpacks.user_device_id' => $user_device_id])
                    ->andWhere(['user_redpacks.client_user_id' => $clientUserId])
                    ->asArray();

                $userDeviceRecvCount = $userDeviceRedpackQuery->count();
                if ($userDeviceRecvCount < $findActivity->user_redpack_num_per_device) {
                    // 找到一个可领取的红包, 直接跳出, 走红包领取流程
                    $resultCode = RedpackActivityModel::RESULT_OK;
                } else {
                    $resultCode = RedpackActivityModel::RESULT_OVER_DEVICE_LIMIT;
                }
            } else {
                $resultCode = RedpackActivityModel::RESULT_OVER_ACT_LIMIT;
            }
        } else {
            $resultCode = RedpackActivityModel::RESULT_DEVICE_NO_REDPACK;
        }

        // 领取红包失败
        if (RedpackActivityModel::RESULT_OK != $resultCode ) {
            $e->errMsg = RedpackActivityModel::resultLabels($resultCode);
            return $e;
        }

        // 红包领取流程
        try {
            //AppLog::DEBUG(json_encode($findActivity));
            $redpackAmount = RedpackAmountModel::getRandomAmountRecord($findActivity->id);
            $amount = $redpackAmount ? $redpackAmount->amount : RedpackAmountModel::DEFAULT_AMOUNT;
            $wishing = $redpackAmount ? $redpackAmount->wishing : RedpackAmountModel::DEFAULT_WISHING;
            $result = MinaHelper::sendMinaRedPack($openId, $amount, $wishing, $findActivity->name, $findActivity->remark, $findActivity->send_name);

            // 添加红包领取记录
            $userRedpacksModel = new UserRedpacksModel([
                'client_id'           => $clientId,
                'client_user_id'      => $clientUserId,
                'redpack_activity_id' => $findActivity->id,
                'user_device_id'      => $user_device_id,
                'amount'              => $amount,
                'status'              => UserRedpacksModel::STATUS_WAIT,
                'jsApiParameters'     => $result['jsApiParameters'], // 保存小程序红包发放接口返回结果,用于红包领取失败后重新领取
                'send_result'         => $result['result'], // 保存小程序红包发放接口返回结果
            ]);
            if (!$userRedpacksModel->save()) {
                $e->errMsg = '添加红包领取记录失败';
                return $e;
            }

            $userRedpackId = $userRedpacksModel->id;
        } catch (Exception $exception) {
            Yii::getLogger()->log($exception->getTraceAsString(), Logger::LEVEL_ERROR);
            //$e->errMsg = '接口异常: ' . $exception->getMessage();
            $e->errMsg = RedpackActivityModel::resultLabels(RedpackActivityModel::RESULT_API_ERROR);
            return $e;
        }

        $e->success = true;
        $e->jsApiParameters = json_decode($result['jsApiParameters']);
        $e->user_redpacks_id = $userRedpackId;

        return $e;
    }

    /**
     * 获取指定型号的所有故障
     * @return stdClass
     */
    public function actionGetFaultsByModelId()
    {
        $e = new stdClass();
        $e->success = false;

        if (false == $this->request->isPost) {
            $e->success = false;
            return $e;
        }
        $deviceFaultName = $this->request->post("device_fault_name");

        $modelUUId = $this->request->post('model_id');
        $faultQuery = ModelsDeviceFaultsModel::find()
            ->select(['models_device_faults.device_fault_id', 'models_device_faults.version', 'device_fault.name AS device_fault_name', 'device_fault.sort_order AS sort_order'])
            ->leftJoin('device_fault', "`models_device_faults`.`device_fault_id` = `device_fault`.`id`")
            ->innerJoin('model', "model.id = models_device_faults.model_id")
            ->where(['model.uuid' => $modelUUId])
            ->andWhere(['models_device_faults.version' => Yii::$app->params['DATA_VERSION']])
            ->orderBy('sort_order ASC')
            ->asArray();
        if ($deviceFaultName) {
            $faultQuery->andWhere(['like', 'device_fault.name', $deviceFaultName]);
        }
        // 格式化获取该报修设备的故障列表
        $index = 0;
        $faults = array();
        if ( $faultArray = $faultQuery->all()) {
            foreach ($faultArray as $item) {
                $fault = new stdClass();
                $fault->index = ++$index;
                $fault->id = $item['device_fault_id'];
                $fault->name = $item['device_fault_name'];
                $faults[] = $fault;
            }
        }

        $e->success = true;
        $e->faults = $faults;
        $e->hasData = count($faults) > 0 ? true : false;

        return $e;
    }

    /**
     * 搜索所有维修方案
     * @return stdClass
     */
    public function actionSearchRepairPlans()
    {
        $e = new stdClass();
        $e->success = false;

        if (false == $this->request->isPost) {
            return $e;
        }
        $repairPlanName = $this->request->post("repair_plan_name");

        //$faultId = $this->request->post('fault_id');
        $modelUUId = $this->request->post('model_id');
        $deviceUUId = $this->request->post('device_id');
        if (empty($modelUUId) || empty($deviceUUId)) {
            return $e;
        }

        $city = '';
        $repairOrderUUId = $this->request->post('order_id');
        $repairOrderModel = RepairOrderModel::findOne(['uuid' => $repairOrderUUId ]);
        if ($repairOrderModel) { // 按订单所在城市查询上门费
            if (isset($repairOrderModel->addressProfile->city)) {
                $city = $repairOrderModel->addressProfile->city;
            }
        } else { // 按设备所在城市查询上门费
            $userDeviceModel = UserDeviceModel::find();
            $userDeviceModel->leftJoin("address_profile", "user_device.address_id = address_profile.address_id");
            $userDeviceModel->select(['address_profile.city']);
            $userDeviceModel->where(['user_device.uuid' => $deviceUUId]);
            $userDeviceModel->asArray();
            $deviceInfo = $userDeviceModel->one();
            if ($deviceInfo) {
                $city = $deviceInfo['city'];
            }
        }
        $regionSetting = RegionFeeSettingModel::getSettingByCity($city);
        $version = Yii::$app->params['DATA_VERSION'];
        $repairPlansQuery = RepairPlanModel::find()
            ->select(['repair_plan.id AS repair_plan_id', 'repair_plan.name AS name', 'repair_plan.reason AS reason',
                'models_repair_plan_prices.parts_price AS parts_price', 'models_repair_plan_prices.repair_hours AS repair_hours',
                'models_repair_plan_prices.difficulty_degree AS difficulty_degree', 'models_repair_plan_prices.price AS price',
                'models_repair_plan_prices.warranty_level AS warranty_level', 'model.device_cat_id'])
            ->innerJoin('models_repair_plan_prices', "`models_repair_plan_prices`.`repair_plan_id` = `repair_plan`.`id`")
            ->leftJoin('model', "model.id = models_repair_plan_prices.model_id")
            ->where(['model.uuid' => $modelUUId])
            ->andWhere(['repair_plan.version' => $version])
            ->andWhere(['models_repair_plan_prices.version' => $version])
            ->andWhere(['>','models_repair_plan_prices.price', 0])
            //->andWhere(['repair_plan.device_fault_id' => $faultId])
            ->orderBy('price ASC')
            ->asArray();

        if ($repairPlanName) {
            $repairPlansQuery->andWhere(['like', 'repair_plan.name', $repairPlanName]);
        }
        $repairPlansArray = $repairPlansQuery->all();
        $index = 0;
        $repair_plans = array();
        if ($repairPlansArray) {
            foreach ($repairPlansArray as $item) {
                $warrantyDays = SysSettingModel::getGuranteeTime() . '天';
                if (isset($item['device_cat_id']) && !empty($item['device_cat_id'])) {
                    $modelDeviceCat = DeviceCatRepository::selectOne($item['device_cat_id']);
                    $warrantyDaysPlan = WarrantyLevelRule::getWarrantyLevelsByDeviceCatId($modelDeviceCat->parent_id, $modelDeviceCat->id, $item['warranty_level']);
                    if ($warrantyDaysPlan) {
                        $warrantyDays = $warrantyDaysPlan['desc'];
                    }
                }
                $plan = new stdClass();
                $plan->id = ++$index;
                $plan->name = $item['name'];
                $plan->reason = $item['reason'];
                $price = $item['parts_price'] + ($regionSetting['man_hour_fee'] * $item['repair_hours'] * $item['difficulty_degree']);
                $plan->price = round($price, 2);
                $plan->warranty_days = $warrantyDays;
                $repair_plans[] = $plan;
            }
        }

        $e->success = true;
        $e->repair_plans = $repair_plans;
        $e->door_fee = $regionSetting['door_fee'];
        $e->hasData = count($repair_plans) > 0 ? true : false;

        return $e;
    }

    /**
     * 获取指定故障的所有维修方案
     * @return stdClass
     */
    public function actionGetRepairPlansByFaultId()
    {
        $e = new stdClass();
        $e->success = false;

        if (false == $this->request->isPost) {
            return $e;
        }
        $repairPlanName = $this->request->post("repair_plan_name");

        $faultId = $this->request->post('fault_id');
        $modelUUId = $this->request->post('model_id');
        $deviceUUId = $this->request->post('device_id');
        if (empty($faultId) || empty($modelUUId) || empty($deviceUUId)) {
            return $e;
        }

        $city = '';
        $repairOrderUUId = $this->request->post('order_id');
        $repairOrderModel = RepairOrderModel::findOne(['uuid' => $repairOrderUUId ]);
        if ($repairOrderModel) { // 按订单所在城市查询上门费
            if (isset($repairOrderModel->addressProfile->city)) {
                $city = $repairOrderModel->addressProfile->city;
            }
        } else { // 按设备所在城市查询上门费
            $userDeviceModel = UserDeviceModel::find();
            $userDeviceModel->leftJoin("address_profile", "user_device.address_id = address_profile.address_id");
            $userDeviceModel->select(['address_profile.city']);
            $userDeviceModel->where(['user_device.uuid' => $deviceUUId]);
            $userDeviceModel->asArray();
            $deviceInfo = $userDeviceModel->one();
            if ($deviceInfo) {
                $city = $deviceInfo['city'];
            }
        }
        $regionSetting = RegionFeeSettingModel::getSettingByCity($city);

        $version = Yii::$app->params['DATA_VERSION'];
        $repairPlansQuery = RepairPlanModel::find()
            ->select(['repair_plan.id AS repair_plan_id', 'repair_plan.name AS name', 'repair_plan.reason AS reason', 'repair_plan.version AS version',
                'models_repair_plan_prices.parts_price AS parts_price', 'models_repair_plan_prices.repair_hours AS repair_hours',
                'models_repair_plan_prices.difficulty_degree AS difficulty_degree', 'models_repair_plan_prices.price AS price', 'models_repair_plan_prices.warranty_level AS warranty_level', 'model.device_cat_id'])
            ->innerJoin('models_repair_plan_prices', "`models_repair_plan_prices`.`repair_plan_id` = `repair_plan`.`id`")
            ->leftJoin('model', "model.id = models_repair_plan_prices.model_id")
            ->where(['model.uuid' => $modelUUId])
            ->andWhere(['repair_plan.device_fault_id' => $faultId])
            ->andWhere(['repair_plan.version' => $version])
            ->andWhere(['models_repair_plan_prices.version' => $version])
            ->andWhere(['>', 'models_repair_plan_prices.price', 0])
            ->orderBy('price ASC')
            ->asArray();

        if ($repairPlanName) {
            $repairPlansQuery->andWhere(['like', 'repair_plan.name', $repairPlanName]);
        }
        $repairPlansArray = $repairPlansQuery->all();
        $index = 0;
        $repair_plans = array();
        if ($repairPlansArray) {
            foreach ($repairPlansArray as $item) {
                $warrantyDays =  SysSettingModel::getGuranteeTime().'天';
                if (isset($item['device_cat_id']) && !empty($item['device_cat_id'])) {
                    $modelDeviceCat = DeviceCatRepository::selectOne($item['device_cat_id']);
                    $warrantyDaysPlan = WarrantyLevelRule::getWarrantyLevelsByDeviceCatId($modelDeviceCat->parent_id, $modelDeviceCat->id, $item['warranty_level']);
                    if ($warrantyDaysPlan) {
                        $warrantyDays = $warrantyDaysPlan['desc'];
                    }
                }
                $plan = new stdClass();
                $plan->id = ++$index;
                $plan->name = $item['name'];
                $plan->reason = $item['reason'];
                $price = $item['parts_price'] + ($regionSetting['man_hour_fee'] * $item['repair_hours'] * $item['difficulty_degree']);
                $plan->price = round($price, 2);
                $plan->warranty_days = $warrantyDays;
                $repair_plans[] = $plan;
            }
        }

        $e->success = true;
        $e->repair_plans = $repair_plans;
        $e->door_fee = $regionSetting['door_fee'];
        $e->hasData = count($repair_plans) > 0 ? true : false;

        return $e;
    }

    /**
     * 获取用户设备信息
     */
    public  function actionGetUserDeviceInfoById()
    {
        $e = new stdClass();
        $e->success = false;

        if (false == $this->request->isPost) {
            return $e;
        }

        $deviceUUId = $this->request->post('deviceId');
        if (empty($deviceUUId)) {
            return $e;
        }

        $deviceQuery = UserDeviceModel::find();
        $deviceQuery->select([
            'user_device.uuid AS device_uuid',
            'user_device.address_id AS address_id',
            'user_device.owner_id AS owner_id',
            'address.longitude as longitude',
            'address.latitude as latitude',
            'address.address as address',
            'owner.type AS owner_type',
            'owner.name AS owner',
        ]);
        $deviceQuery->leftJoin('owner', "user_device.owner_id = owner.id");
        $deviceQuery->leftJoin('address', "user_device.address_id = address.id");
        $deviceQuery->where(['user_device.uuid' => $deviceUUId]);
        $deviceQuery->asArray();
        $deviceArray = $deviceQuery->one();
        if (empty($deviceArray)) {
            $e->error = '用户设备不存在';
            return $e;
        }

        $e->success = true;
        $e->device = $deviceArray;

        return $e;
    }

    /**
     * 编辑用户设备
     * @return \Exception|stdClass|Exception
     * @throws \yii\base\ErrorException
     * @throws \yii\db\Exception
     */
     public function actionEditUserDeviceInfoById()
     {
        $e = new stdClass();
        $e->success = false;
        $transaction = Yii::$app->db->beginTransaction();
        try {
            if (false == $this->request->isPost) {
                $e->success = false;
                return $e;
            }
            $deviceUUId = $this->request->post('deviceId');
            $address = $this->request->post('address');
            $address = HtmlPurifier::process($address,['HTML.Allowed'=> '']);

            $longitude = $this->request->post('longitude');
            $latitude = $this->request->post('latitude');
            $companyName = $this->request->post('companyname');
            $companyName = HtmlPurifier::process($companyName,['HTML.Allowed'=> '']);


            $ownerType = $this->request->post('ownertype');
            if (empty($address) || empty($longitude) || empty($latitude) || empty($companyName) || !isset($ownerType)) {
                $e->error='缺少必要参数（deviceUUId|address|longitude|latitude|companyname|ownerType）';
                return $e;
            }

            if (empty($deviceUUId)) {
                $e->error='该用户设备不存在';
                return $e;
            }

            $deviceQuery = UserDeviceModel::find();
            $deviceQuery->select([
                'user_device.id AS user_device_id',
                'user_device.address_id AS address_id',
                'user_device.owner_id AS owner_id',
            ]);
            $deviceQuery->leftJoin('device', "user_device.device_id = device.id");
            $deviceQuery->leftJoin('device_img', "`user_device`.`device_id` = `device_img`.`device_id` and  `device_img`.`is_cover` = 1");
            $deviceQuery->leftJoin('model', "device.model_id = model.id");
            $deviceQuery->leftJoin('owner', "user_device.owner_id = owner.id");
            $deviceQuery->where(['user_device.uuid' => $deviceUUId]);
            $deviceQuery->asArray();
            $deviceArray = $deviceQuery->one();
            if (empty($deviceArray)) {
                $e->error = '用户设备不存在';
                return $e;
            }

            if (empty($deviceArray["address_id"])) {
                $e->error='用户设备地址不存在';
                return $e;
            }

            if (empty($deviceArray["owner_id"])) {
                $e->error='用户设备地址无设备拥有者';
                return $e;
            }

            $addressModel = AddressModel::findOne($deviceArray["address_id"]);
            if (empty($addressModel)) {
                $e->error='用户设备地址编号无效';
                return $e;
            }

            $deviceId = $deviceArray['user_device_id'];
            $clientUserId = $this->getClientUserId();
            $clientUser = ClientUserModel::findOne($clientUserId);
            if (false == $clientUser || false == $clientUser->profileMina) {
                $e->errMsg = '用户不存在';
                return $e;
            }

            UserDeviceLogModel::addLog([
                'user_device_id'     => $deviceId,
                'operator_id'        => $clientUser->user_id,
                'operator_type'      => UserDeviceLogModel::OPERATOR_TYPE_USER,
                'old_user_device_id' => 0,
                'content'            => "编辑设备地址 ：address_id: {$deviceArray["address_id"]} ==> address(old:{$addressModel->address}, new:{$address}), longitude(old:{$addressModel->longitude}, new:{$longitude}), latitude(old:{$addressModel->latitude}, new:{$latitude})",
                'type'               => UserDeviceLogModel::TYPE_EDIT_ADDRESS
            ]);
            //AppLog::DEBUG("actionEditUserDeviceInfoById（编辑设备信息）：address_id:{$deviceArray["address_id"]} ==> address(old:{$addressModel->address},new:{$address}), longitude(old:{$addressModel->longitude},new:{$longitude}), latitude(old:{$addressModel->latitude},new:{$latitude})");
            $addressModel->address = $address;
            $addressModel->longitude = $longitude;
            $addressModel->latitude = $latitude;
            $addressModel->updated_at = time();
            $resEditAddress = $addressModel->save();
            $ownerModel = OwnerModel::findOne($deviceArray["owner_id"]);
            if (empty($ownerModel)) {
                $e->error='用户设备拥有者编号不存在';
                return $e;
            }

            UserDeviceLogModel::addLog([
                'user_device_id'     => $deviceId,
                'operator_id'        => $clientUser->user_id,
                'operator_type'      => UserDeviceLogModel::OPERATOR_TYPE_USER,
                'old_user_device_id' => 0,
                'content'            => "编辑设备拥有者：owner_id: {$deviceArray["owner_id"]} ==> name(old:{$ownerModel->name}, new:{$companyName}), type(old:{$ownerModel->type}, new:{$ownerType})",
                'type'               => UserDeviceLogModel::TYPE_EDIT_OWNER
            ]);
            //AppLog::DEBUG("actionEditUserDeviceInfoById（编辑设备信息）：owner_id:{$deviceArray["owner_id"]} ==> name(old:{$ownerModel->name},new:{$companyName}), type(old:{$ownerModel->type},new:{$ownerType})");
            $ownerModel->name = $companyName;
            $ownerModel->type = $ownerType;
            $ownerModel->updated_at = time();
            $resEditOwner = $ownerModel->save();
            if ($resEditAddress && $resEditOwner) {
                $transaction->commit();
                $e->success = true;
                $e->error='用户设备更新成功';
                return $e;
            } else {
                $transaction->rollBack();
                $e->error='用户设备更新失败';
                return $e;
            }
        } catch (Exception $e) {
            $transaction->rollBack();
            Yii::getLogger()->log($e->getTraceAsString(), Logger::LEVEL_ERROR);
            //$e->errMsg = '接口异常: ' . $exception->getMessage();
            $e->error = RedpackActivityModel::resultLabels(RedpackActivityModel::RESULT_API_ERROR);
            return $e;
        }
    }
}