# -*- coding: utf-8 -*-
# !/usr/bin/env python

import datetime
import logging
import re

import simplejson as json
from bson.objectid import ObjectId
from django.conf import settings
from django.contrib import auth
from django.views.decorators.http import require_POST, require_GET
from mongoengine.errors import DoesNotExist, NotUniqueError
from typing import TYPE_CHECKING
from voluptuous import MultipleInvalid

from apilib import utils_datetime
from apilib.monetary import RMB, Ratio, VirtualCoin
from apilib.utils import is_number
from apilib.utils_datetime import to_datetime
from apilib.utils_json import JsonResponse
from apilib.utils_string import make_title_from_dict
from apilib.utils_sys import memcache_lock
from apps import serviceCache
from apps.web.agent import api
from apps.web.agent.models import Agent, MoniApp, MoniAppPoint
from apps.web.common.models import AddressType, FAQ, WithdrawBankCard, WithdrawBranchBanks
from apps.web.common.models import Feature
from apps.web.constant import Const, SimStatus
from apps.web.core import ROLE
from apps.web.core.bridge.wechat import WechatClientProxy
from apps.web.core.exceptions import InvalidFileSize, InvalidFileName, \
    ManagerServiceTimeOutException, ManagerServiceSerialException, ServiceException, RentDeviceError
from apps.web.core.file import AliOssFileUploader
from apps.web.core.models import AliApp, WechatPayApp
from apps.web.core.models import OfflineTask
from apps.web.core.models import WechatAuthApp
from apps.web.core.networking import MessageSender
from apps.web.core.utils import DefaultJsonErrorResponse, JsonErrorResponse, JsonOkResponse
from apps.web.dealer.models import Dealer, ExchangeOrder, DealerRechargeRecord, ApiAppInfo
from apps.web.dealer.transaction_deprecated import refund_cash_to_dealer
from apps.web.dealer.utils import create_dealer_sim_charge_order
from apps.web.device.models import Device, DeviceType, MajorDeviceType, DeviceCommandParam, DeviceCommand, SIMCard, \
    Part, Group
from apps.web.device.timescale import SignalManager
from apps.web.exceptions import UserServerException
from apps.web.helpers import get_manual_pay_gateway
from apps.web.management.models import Manager, DeviceReplacement
from apps.web.promotion.models import InsuranceOrder
from apps.web.superadmin import OfflineTaskType
from apps.web.superadmin.models import SuperManager, WebLog
from apps.web.user.models import RechargeRecord, ConsumeRecord
from apps.web.user.transaction_deprecated import refund_cash
from apps.web.utils import permission_required, error_tolerate, super_manager_login, trace_call
from apps.web.validation import SavePublicWithdrawBankCardExtraSchema, \
    SaveWithdrawBankCardSchemaForSuper
from library.qiben import SimManager
from taskmanager.mediator import task_caller

if TYPE_CHECKING:
    from apps.web.device.models import DeviceDict
    from django.core.handlers.wsgi import WSGIRequest
    from apps.web.core.db import CustomQuerySet
    from typing import Dict, List, Callable, Iterable, Union, Any
    from apps.web.common.models import UserSearchable
    from apps.web.dealer.models import DealerDict
    from apps.web.user.models import MyUser
    from apps.web.device.models import GroupDict

logger = logging.getLogger(__name__)


def login(request):
    # type: (WSGIRequest)->JsonResponse

    try:
        payload = json.loads(request.body)
        username, password = payload['username'], payload['password']
        if SuperManager.objects(username = username).first():
            return super_manager_login(request, logger, username, password)
        else:
            return JsonResponse({'result': 0, 'description': u'用户名或者密码错误', 'payload': {}})
    except Exception as e:
        logger.exception('super manager login error = %s' % e)
        return JsonResponse({'result': 0, 'description': u'登录异常', 'payload': {}})


@permission_required(ROLE.supermanager)
def logout(request):
    # type: (WSGIRequest)->JsonResponse

    auth.logout(request)
    return JsonResponse({'result': 1})


@permission_required(ROLE.supermanager)
def getCurrentUserInfo(request):
    # type: (WSGIRequest)->JsonResponse

    return JsonResponse(
        {
            "result": 1,
            "description": "",
            "payload":
                {
                    'username': request.user.username,
                    "nickname": request.user.nickname,
                    "brandName": "厂商管理后台",
                    "logo": ""
                }
        })


@permission_required(ROLE.supermanager)
def getManagerList(request):
    # type: (WSGIRequest)->JsonResponse

    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 40))
    searchKey = request.GET.get('searchKey', None)
    searchType = request.GET.get('searchType', None)

    if searchType is None:
        managers = Manager.search(searchKey).filter(domain = settings.MY_DOMAIN).order_by('-dateTimeAdded')
    elif searchType == ROLE.dealer:
        dealers = Dealer.objects().search(searchKey)
        agents = Agent.objects(id__in = [str(_.agentId) for _ in dealers])
        managers = Manager.objects(domain = settings.MY_DOMAIN, id__in = [str(_.managerId) for _ in agents])
    elif searchType == ROLE.agent:
        agents = Agent.objects().search(searchKey)
        managers = Manager.objects(domain = settings.MY_DOMAIN, id__in = [str(_.managerId) for _ in agents])
    else:
        return JsonErrorResponse(description = u'目前只支持按照代理商查询或经销商查询或厂商通用查询')

    total = managers.count()

    dataList = []

    for manager in managers.paginate(pageIndex = pageIndex, pageSize = pageSize):  # type: Manager
        dictValue = manager.to_dict(shadow = (not request.user.universal_password_login))
        dictValue.update({'agentTotal': Agent.objects(managerId = str(manager.id)).count()})
        dataList.append(dictValue)

    return JsonOkResponse(payload = {'total': total, 'dataList': dataList})


@permission_required(ROLE.supermanager)
def addManager(request):
    # type: (WSGIRequest)->JsonResponse

    payload = json.loads(request.body)

    username = payload.pop('username')
    password = payload.pop('password')
    nickname = payload.get('nickname')

    logo_path = payload.pop('img', '')

    primaryAgentUsername = payload.pop('primaryAgentUsername')
    primaryAgentPassword = payload.pop('primaryAgentPassword')
    primaryAgentNickName = payload.pop('primaryAgentNickName')

    payload.update({'logo': logo_path})
    payload.update({'brandName': nickname})

    try:
        trafficCardCost = RMB(payload.get('trafficCardCost', Const.PLATFORM_DEFAULT_TRAFFIC_COST))
        if trafficCardCost < RMB(0):
            return JsonErrorResponse(description = u'流量卡年费输入错误')

        if 'withdrawFeeRatioCost' in payload:
            withdrawFeeRatioCost = Ratio(payload.get('withdrawFeeRatioCost'))
        else:
            withdrawFeeRatioCost = Const.PLATFORM_DEFAULT_WITHDRAW_FEE_RATIO

        if withdrawFeeRatioCost < Const.MIN_DEALER_WITHDRAW_FEE_RATIO or withdrawFeeRatioCost > Const.MAX_DEALER_WITHDRAW_FEE_RATIO:
            return JsonErrorResponse(description = u'提现费率输入错误')

        try:
            manager = Manager.create_user(username, password, **payload)
        except NotUniqueError as e:
            logger.exception('not unique super admin data, error=%s' % (e,))
            return JsonErrorResponse(description = u'重复的超级管理员电话号码')

        agent = Agent.create_user(username = primaryAgentUsername, password = primaryAgentPassword, **{
            'managerId': str(manager.id),
            'nickname': primaryAgentNickName,
            'productName': nickname,
            'productLogo': logo_path,
            'annualTrafficCost': trafficCardCost,
            'trafficCardCost': trafficCardCost,
            'withdrawFeeRatio': withdrawFeeRatioCost,
            'withdrawFeeRatioCost': withdrawFeeRatioCost})
    except NotUniqueError as e:
        logger.exception('not unique primary agent data, error=%s' % (e,))
        return JsonErrorResponse(description = u'重复的代理商电话号码')

    updated = manager.update(primeAgentId = str(agent.id))
    assert updated, u'更新主代理商ID错误'

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
def editManager(request):
    # type: (WSGIRequest)->JsonResponse

    payload = json.loads(request.body)

    id_ = str(payload.pop('id'))
    updated = Manager.objects(id = id_).update(**payload)

    if updated:
        return JsonOkResponse()
    else:
        return JsonErrorResponse(description = u'编辑厂商失败')


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def editManagerPassword(request):
    # type: (WSGIRequest)->JsonResponse

    try:
        payload = json.loads(request.body)
        managerId = payload.get('id')
        password = payload.get('password')

        agent = Manager.objects.get(id = managerId)
        agent.set_password(password)

        return JsonResponse({'result': 1, 'description': u'修改成功', 'payload': {}})
    except DoesNotExist:
        return JsonResponse({'result': 0, 'description': u'厂商不存在，请刷新后再试', 'payload': {}})
    except Exception as e:
        logger.exception('cannot [editManagerPassword], error=%s' % (e,))
        return JsonResponse({'result': 0, 'description': u'修改失败', 'payload': {}})


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def editAgentPassword(request):
    # type: (WSGIRequest)->JsonResponse

    try:
        payload = json.loads(request.body)
        agentId = payload.get('id')
        password = payload.get('password')

        agent = Agent.objects.get(id = agentId)
        agent.set_password(password)

        return JsonResponse({'result': 1, 'description': u'修改成功', 'payload': {}})
    except DoesNotExist:
        return JsonResponse({'result': 0, 'description': u'代理商不存在，请刷新后再试', 'payload': {}})
    except Exception as e:
        logger.exception('cannot [editManagerPassword], error=%s' % (e,))
        return JsonResponse({'result': 0, 'description': u'修改失败', 'payload': {}})


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def editDealerPassword(request):
    # type: (WSGIRequest)->JsonResponse

    try:
        payload = json.loads(request.body)
        dealerId = payload.get('id')
        password = payload.get('password')

        dealer = Dealer.objects.get(id = dealerId)
        dealer.set_password(password)

        return JsonResponse({'result': 1, 'description': u'修改成功', 'payload': {}})
    except DoesNotExist:
        return JsonResponse({'result': 0, 'description': u'经销商不存在，请刷新后再试', 'payload': {}})
    except Exception as e:
        logger.exception('cannot [editManagerPassword], error=%s' % (e,))
        return JsonResponse({'result': 0, 'description': u'修改失败', 'payload': {}})


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def getDeviceDetailList(request):
    # type: (WSGIRequest)->JsonResponse

    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 40))
    searchKey = request.GET.get('searchKey', None)
    managerId = request.GET.get('managerId', None)
    dealerId = request.GET.get('dealerId', None)
    agentId = request.GET.get('agentId', None)

    online = request.GET.get('online', None)
    registered = request.GET.get('registered')

    logicalCode = request.GET.get("logicalCode", None)
    if logicalCode:
        data = Device.accurate_filter(logicalCode = logicalCode, shadow = (not request.user.universal_password_login))
        if not data:
            return JsonErrorResponse(description = u'无效的logicalCode')
        return JsonOkResponse(payload = {'total': 1, 'dataList': [data]})

    logicalCodeList = list(set(request.GET.getlist('logicalCodeList', None)))
    if logicalCodeList is not None:
        if len(logicalCodeList) > 0:
            dataList = []
            ds = Device.objects(logicalCode__in = logicalCodeList)
            for _ in ds.paginate(pageIndex = pageIndex, pageSize = pageSize):
                data = Device.accurate_filter(logicalCode = _.logicalCode,
                                              shadow = (not request.user.universal_password_login))
                if data is None:
                    continue
                else:
                    dataList.append(data)

            return JsonOkResponse(payload = {'total': ds.count(), 'dataList': dataList})

    try:
        if online is not None:
            online = json.loads(online)

        if registered is not None:
            registered = json.loads(registered)

    except ValueError:
        return JsonErrorResponse(description = u'参数不合法')

    total, device_list = Device.tree_filter(dealerId,
                                            agentId,
                                            managerId,
                                            searchKey,
                                            pageIndex,
                                            pageSize,
                                            online = online,
                                            registered = registered,
                                            shadow = (not request.user.universal_password_login))
    return JsonOkResponse(payload = {'total': total, 'dataList': device_list})


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def getOrderDetailList(request):
    # type: (WSGIRequest)->JsonResponse

    def get_consume_dataList(consumeRcd, index, size):
        return [{
            'wxOrderNo': '',
            'orderNo': '',
            'orderResult': '',
            'rechargeUser': '',
            'rechargeType': '',
            'money': '',
            'coins': '',
            'orderDetail': {},
            'orderCreateTime': '',
            'logicalCode': _.logicalCode,
            'devNo': _.devNo,
            'devTypeCode': Device.objects(devNo = _.devNo).first().devType.get('code', '') if Device.objects(
                devNo = _.devNo).first() is not None else '',
            'consumeOrderNo': _.orderNo,
            'consumeUser': _.nickname + '  ' + _.openId,
            'consumeCoins': _.coin,
            'consumeResult': u'消费成功' if _.isNormal else u'消费失败',
            'failedReason': _.errorDesc,
            'consumeOrderCreateTime': _.dateTimeAdded.strftime('%Y-%m-%d %H:%M:%S'),
            'consumeDetail': _.attachParas,
            'consumeDict': _.servicedInfo
        } for _ in consumeRcd.paginate(pageIndex = index, pageSize = size)]

    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 40))
    searchKey = request.GET['searchKey']
    searchType = request.GET['searchType']
    searchResult = True

    if searchType == 'logicalCodeRecharge':
        device = Device.objects(logicalCode = searchKey).first()
        if device is not None:
            devNo = device.devNo
            rs = RechargeRecord.objects(devNo = devNo, via__in = ['recharge', 'chargeCard']).order_by('-dateTimeAdded')
            dataList = [_.to_dict_for_super_admin() for _ in rs.paginate(pageIndex = pageIndex, pageSize = pageSize)]
        else:
            return JsonErrorResponse(description = u'设备编号不存在')

    elif searchType == 'logicalCodeConsume':
        device = Device.objects(logicalCode=searchKey).first()
        if device is not None:
            devNo = device.devNo
            cs = ConsumeRecord.objects(devNo=devNo).order_by('-dateTimeAdded')
            dataList = get_consume_dataList(cs, pageIndex, pageSize)
        else:
            return JsonErrorResponse(description=u'设备编号不存在')

    elif searchType == 'wxOrderNo':
        rs = RechargeRecord.objects(wxOrderNo = searchKey)
        if rs.count() == 0:
            searchResult = False
        dataList = [_.to_dict_for_super_admin() for _ in rs]

    elif searchType == 'orderNo':
        rs = RechargeRecord.objects(orderNo = searchKey)
        if rs.count() == 0:
            searchResult = False
        dataList = [_.to_dict_for_super_admin() for _ in rs]

    elif searchType == 'consumeOrderNo':
        cs = ConsumeRecord.objects(orderNo = searchKey)
        if cs.count() == 0:
            searchResult = False

        c = cs.first()
        if c.rechargeRcdId is None or c.rechargeRcdId == '':
            dataList = get_consume_dataList(cs, pageIndex, pageSize)
        else:
            rs = RechargeRecord.objects(id = str(c.rechargeRcdId))
            dataList = [_.to_dict_for_super_admin() for _ in rs.paginate(pageIndex = pageIndex, pageSize = pageSize)]

    else:
        return JsonErrorResponse(description = u'查询方式错误')

    if searchResult is False:
        return JsonErrorResponse(description = u'没有查询到结果')
    else:
        return JsonOkResponse(payload = {'total': 0, 'dataList': dataList})


@error_tolerate(nil=JsonErrorResponse(u'退款失败'), logger=logger)
@permission_required(ROLE.supermanager)
def refundCashFromRecharge(request):
    # type: (WSGIRequest)->JsonResponse

    data = json.loads(request.body)
    orderNo = data['orderNo']
    money = data['money']

    rcd = RechargeRecord.objects(orderNo=orderNo).first()  # type: RechargeRecord
    if rcd is None:
        return JsonErrorResponse(description=u"充值订单不存在，退款失败")

    if RMB(money) <= RMB(0):
        return JsonErrorResponse(description=u"退费金额错误")

    if float(money) > float(str(rcd.money)):
        return JsonErrorResponse(description=u"退款金额大于订单金额，退款失败")

    if not rcd.is_success:
        return JsonErrorResponse(description = u"退款失败，订单状态非成功，请联系平台客服")

    if not rcd.is_ledgered:
        return JsonErrorResponse(description=u"订单还没有分账，无法退款")

    try:
        deductCoins = VirtualCoin(rcd.coins) * Ratio(float(RMB(money)) / float(RMB(rcd.money)))

        refund_cash(recharge_record = rcd, refundFee = RMB(money), **{
            'deductCoins': deductCoins,
            'frozenCoins': deductCoins,
            'operatorId': request.user.identity_id,
            'checkWallet': True
        })
        return JsonOkResponse()
    except ServiceException as e:
        logger.error(e.result)
        return JsonErrorResponse(description=e.result.get("description"))
    except UserServerException as e:
        logger.error(e.message)
        return JsonResponse(e.message)


@error_tolerate(nil = JsonErrorResponse(u'管理员强制删除失败'), logger = logger)
@permission_required(ROLE.supermanager)
def unbindDevByAdmin(request):
    # type: (WSGIRequest)->JsonResponse
    logicalCode = json.loads(request.body)['logicalCode']

    dev = Device.get_dev_by_logicalCode(logicalCode)  # type: DeviceDict
    if dev is None:
        return JsonErrorResponse(description = u"该设备不存在，请刷新后再试")

    Device.un_register(dev, force = True, operator = request.user.human_id)

    return JsonOkResponse()


###############
##: 特性列表 :##
###############


@error_tolerate(nil = JsonErrorResponse(u'获取特性列表失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getFeatureList(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 40))
    role = request.GET.get('role')
    searchKey = request.GET.get('searchKey')

    if role is not None:
        query = {'role': role}
    else:
        query = {}

    queryset = Feature.objects(**query).search(searchKey)
    total = queryset.count()

    return JsonOkResponse(
        payload = {
            'dataList': [_.to_dict() for _ in queryset.paginate(pageIndex = pageIndex, pageSize = pageSize)],
            'total': total
        }
    )


@error_tolerate(nil = JsonErrorResponse(u'增加特性失败'), logger = logger)
@permission_required(ROLE.supermanager)
def addFeature(request):
    # type: (WSGIRequest)->JsonResponse
    try:
        Feature(**json.loads(request.body)).save()
    except NotUniqueError:
        return JsonErrorResponse(description = u'已有相同的角色+特性名，重复数据')
    return JsonOkResponse(description = u'添加成功')


@error_tolerate(nil = JsonErrorResponse(u'编辑特性失败'), logger = logger)
@permission_required(ROLE.supermanager)
def editFeature(request):
    # type: (WSGIRequest)->JsonResponse
    payload = json.loads(request.body)
    id_ = payload.pop('id')
    feature = Feature.objects(id = str(id_)).get()
    result = feature.update(**payload)
    if not result:
        logger.error(u'{0!r} 编辑特性失败 id={1}'.format(request.user, id_))
    return JsonOkResponse(description = u'编辑成功')


@error_tolerate(nil = JsonErrorResponse(u'删除特性失败'), logger = logger)
@permission_required(ROLE.supermanager)
def removeFeatures(request):
    # type: (WSGIRequest)->JsonResponse
    ids = json.loads(request.body)['ids']
    queryset = Feature.objects(id__in = ids)  # type: CustomQuerySet
    deleted = queryset.delete()
    if not deleted:
        logger.error(u'{0!r} 删除特性失败 ids={1}'.format(request.user, ids))
        return JsonErrorResponse(description = u'删除特性失败')
    return JsonOkResponse(description = u'删除成功')


def edit_feature(request, model):
    # type: (WSGIRequest, Any)->JsonResponse
    payload = json.loads(request.body)
    id_ = payload['id']
    featureList = payload.get('featureList', [])
    specialFeature = payload.get('specialFeature')
    user = model.objects(id = id_).first()  # type: Union[Dealer, Agent, Manager]
    if not user:
        return JsonErrorResponse(description = u'未找到该用户')
    result = user.edit_feature_list(featureList, specialFeature)
    if result:
        return JsonOkResponse(description = u'编辑成功')
    else:
        return JsonErrorResponse(description = u'编辑不成功')


@error_tolerate(nil = JsonErrorResponse(u'编辑特性失败'), logger = logger)
@permission_required(ROLE.supermanager)
def editAgentFeature(request):
    # type: (WSGIRequest)->JsonResponse

    """

    :param request:
    :return:
    """
    return edit_feature(request, Agent)


@error_tolerate(nil = JsonErrorResponse(u'编辑特性失败'), logger = logger)
@permission_required(ROLE.supermanager)
def editDealerFeature(request):
    # type: (WSGIRequest)->JsonResponse

    """

    :param request:
    :return:
    """
    return edit_feature(request, Dealer)


@error_tolerate(nil = JsonErrorResponse(u'编辑特性失败'), logger = logger)
@permission_required(ROLE.supermanager)
def editManagerFeature(request):
    # type: (WSGIRequest)->JsonResponse

    """

    :param request:
    :return:
    """
    return edit_feature(request, Manager)


#########
# Utils #
#########

@error_tolerate(nil = JsonErrorResponse(u'设备更换失败'), logger = logger)
@permission_required(ROLE.supermanager)
def replaceDevice(request):
    # type: (WSGIRequest)->JsonResponse
    """
    调换设备
    动机：
      部分设备因各种原因退役，但是二维码已经贴在机器上，更换其设备，保持老的逻辑设备即可
    :param request:
    :return:
    """
    payload = json.loads(request.body)

    oldLogicalCode = payload['old']
    newLogicalCode = payload['new']

    key = 'device-replacement-{old}-{new}'.format(old = payload['old'], new = payload['new'])

    with memcache_lock(key, '1', expire = 60) as acquired:
        if acquired:
            logger.debug(
                '%r started a new device replacement, old=%s, new=%s' % (request.user, oldLogicalCode, newLogicalCode))

            try:
                Device.replace(oldLogicalCode, newLogicalCode, request.user)
                return JsonOkResponse(description = u'替换成功')
            except UserServerException as e:
                return JsonErrorResponse(description = e.message)
        else:
            return JsonErrorResponse(description = u'已经同一个替换在进行')


@error_tolerate(nil = JsonErrorResponse(u'设备互换失败'), logger = logger)
@permission_required(ROLE.supermanager)
def swapDevice(request):
    # type: (WSGIRequest)->JsonResponse
    """
    调换设备
    动机：
      部分设备因各种原因退役，但是二维码已经贴在机器上，更换其设备，保持老的逻辑设备即可
    :param request:
    :return:
    """
    payload = json.loads(request.body)

    left_lc = payload['left']
    right_lc = payload['right']

    key = 'device-swap-{left}-{right}'.format(left = left_lc, right = right_lc)

    with memcache_lock(key, '1', expire = 60) as acquired:
        if acquired:
            logger.debug('%r started a new device swap, old=%s, new=%s' % (request.user, left_lc, right_lc))

            try:
                Device.swap(left_lc, right_lc, request.user)

                return JsonOkResponse(description = u'互换成功')

            except UserServerException as e:
                return JsonErrorResponse(description = e.message)
        else:
            return JsonErrorResponse(description = u'已经同一个互换在进行')


@error_tolerate(nil = JsonErrorResponse(u'撤销设备更换失败'), logger = logger)
@permission_required(ROLE.supermanager)
def rollbackDeviceReplacement(request):
    # type: (WSGIRequest)->JsonResponse
    """
    回退调换设备操作
    :param request:
    :return:
    """
    payload = json.loads(request.body) if request.body else {}

    if 'id' not in payload:
        return JsonErrorResponse(description = u'ID未传入')

    replacement_id = payload['id']
    key = 'device-replacement-revoke-{id}'.format(id = replacement_id)
    with memcache_lock(key, '1', expire = 60) as acquired:
        if acquired:
            try:
                Device.rollback_replacement(replacement_id)

                return JsonResponse({'result': 1, 'payload': {}, 'description': u'回滚成功'})
            except UserServerException as e:
                return JsonErrorResponse(description = e.message)
        else:
            return JsonErrorResponse(description = u'已有同一个回滚操作正在运行')


@error_tolerate(nil = JsonErrorResponse(u'获取设备更换记录失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getDeviceReplacements(request):
    # type: (WSGIRequest)->JsonResponse
    """
    获取设备更换记录
    :param request:
    :return:
    """
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

    replace_type = request.GET.get('replaceType', 'replace')

    replacements = DeviceReplacement.objects(replaceType = replace_type).paginate(pageIndex,
                                                                                  pageSize)  # type: Iterable[DeviceReplacement]

    return JsonResponse(
        {
            'result': 1,
            'description': '',
            'payload': {
                'total': DeviceReplacement.objects().count(),
                'dataList': [_.to_dict() for _ in replacements]
            }
        }
    )


##: 日志系统
@error_tolerate(nil = JsonErrorResponse(u'获取网志失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getWebLogs(request):
    # type: (WSGIRequest)->JsonResponse
    """
    获取日志系统
    :param request:
    :return:
    """
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 40))
    searchKey = request.GET.get('searchKey')
    logs = WebLog.objects().search(searchKey) \
        .order_by('-createdTime') \
        .paginate(pageIndex = pageIndex, pageSize = pageSize)  # type: Iterable[WebLog]
    total = WebLog.objects().search(searchKey).count()  # type: int

    return JsonResponse(
        {
            'result': 1,
            'description': '',
            'payload':
                {
                    'dataList': [_.to_dict() for _ in logs],
                    'total': total
                }
        }
    )


@error_tolerate(nil = JsonErrorResponse(u'添加日志失败'), logger = logger)
@permission_required(ROLE.supermanager)
def addWebLog(request):
    # type: (WSGIRequest)->JsonResponse

    """
    添加超级管理员日志
    :param request:
    :return:
    """
    currentSuperManagerId = ObjectId(request.user.id)
    payload = json.loads(request.body)
    payload['superManagerId'] = currentSuperManagerId
    WebLog(**payload).save()
    return JsonResponse({'result': 1, 'description': u'添加成功'})


@error_tolerate(nil = JsonErrorResponse(u'编辑日志失败'), logger = logger)
@permission_required(ROLE.supermanager)
def editWebLog(request):
    # type: (WSGIRequest)->JsonResponse

    """
    编辑超级管理员日志
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    log = WebLog.objects(id = payload['id']).get()
    updated = log.update(**payload)
    if not updated:
        return JsonErrorResponse(description = u'编辑失败')
    else:
        return JsonResponse({'result': 1, 'description': u'编辑成功', 'payload': {}})


@error_tolerate(nil = JsonErrorResponse(u'查询主设备类型失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getMajorDeviceType(request):
    # type: (WSGIRequest)->JsonResponse

    """
    查询主设备类型
    :param request:
    :return:
    """
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    searchKey = request.GET.get('searchKey')
    types = MajorDeviceType.objects().search(searchKey).order_by('-createdTime').paginate(pageIndex, pageSize)
    return JsonResponse(
        {
            'result': 1,
            'payload':
                {
                    'total': MajorDeviceType.objects().count(),
                    'dataList': [{'name': _.name, 'createdTime': _.createdTime} for _ in types]
                }
        }
    )


@error_tolerate(nil = JsonErrorResponse(u'添加主设备类型失败'), logger = logger)
@permission_required(ROLE.supermanager)
def addMajorDeviceType(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    payload = json.loads(request.body)
    try:
        MajorDeviceType(name = payload['name']).save()
    except NotUniqueError:
        return JsonErrorResponse(description = u'该主设备类型名称已经存在')
    return JsonResponse({'result': 1, 'description': '', 'payload': ''})


@require_GET
@error_tolerate(nil = JsonErrorResponse(u'获取地址类型失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getAddressType(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

    addressTypes = AddressType.objects.all().order_by('-showWeight')
    dataList = [
        {
            'value': addressType.value,
            'name': addressType.label,
            'count': addressType.showWeight,
            'createdTime': addressType.createdAt
        } for addressType in addressTypes
    ]

    return JsonResponse(
        {
            'result': 1,
            'description': '',
            'payload':
                {
                    'dataList': dataList[(pageIndex - 1) * pageSize: pageIndex * pageSize],
                    'total': len(dataList)
                }
        }
    )


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'添加地址类型失败'), logger = logger)
@permission_required(ROLE.supermanager)
def addAddressType(request):
    payload = json.loads(request.body)
    try:
        obj = AddressType(value = payload['value'], label = payload['name'],
                          showWeight = payload.get('showWeight', 0)).save()
        obj.save()
    except NotUniqueError:
        return JsonErrorResponse(description = u'添加地址类型失败')

    return JsonResponse({'result': 1, 'description': u'添加成功', 'payload': {}})


@require_GET
@error_tolerate(nil = JsonErrorResponse(u'获取代理商列表失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getAgentsDetailList(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    page_index = int(request.GET.get('pageIndex', 1))
    page_size = int(request.GET.get('pageSize', 10))
    search_key = request.GET.get('searchKey')

    manager_id = request.GET.get('managerId')
    moniAppId = request.GET.get('moniAppId', None)

    total, items = Agent.filter(manager_id = manager_id, search_key = search_key, page_index = page_index,
                                page_size = page_size, moniAppId = moniAppId,
                                shadow = (not request.user.universal_password_login))
    return JsonOkResponse(
        payload =
        {
            'total': total,
            'dataList': items
        }
    )


@require_GET
@error_tolerate(nil = JsonErrorResponse(u'获取经销商列表失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getDealerDetailList(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    searchKey = request.GET.get('searchKey')

    managerId = request.GET.get('managerId')
    agentId = request.GET.get('agentId')

    forceFollowGzh = request.GET.get('forceFollowGzh', None)
    devCountMin = request.GET.get('devCountMin', None)
    devCountMax = request.GET.get('devCountMax', None)

    query = {}

    #     if all([managerId is None, agentId is None]) or not ((managerId is None) ^ (agentId is None)):
    #         return JsonErrorResponse(description=u'代理商ID和厂商ID只能传递一个')

    if managerId is not None:
        agentIds = [str(_.id) for _ in Agent.objects(managerId = managerId)]
        query['agentId__in'] = agentIds

    if agentId is not None:
        query['agentId'] = agentId

    if forceFollowGzh:
        query['forceFollowGzh'] = forceFollowGzh

    if devCountMin:
        query['devCount__gte'] = devCountMin

    if devCountMax:
        query['devCount__lte'] = devCountMax

    dealers = Dealer.objects(**query).search(searchKey)
    total = dealers.count()  # type: int

    pageAgentIds = []
    dealerList = []
    for dealer in dealers.order_by('-createdTime').paginate(pageIndex = pageIndex, pageSize = pageSize):
        dealerList.append(dealer)
        pageAgentIds.append(dealer.agentId)

    agentMap = {
        str(agent.id): agent  # '%s - %s' % (agent.username, agent.nickname)
        for agent in Agent.objects(id__in = pageAgentIds)
    }

    def transform(_):
        agent = agentMap[_['agentId']]
        _['agentInfo'] = '%s-%s' % (agent.username, agent.nickname)
        return _

    dataList = []
    for dealer in dealerList:
        agent = agentMap.get(dealer.agentId)
        data = dealer.to_dict(shadow = (not request.user.universal_password_login))
        moniAppName = MoniApp.get_app_by_agent(str(agent.id))  # type: moniAppName
        data.update(
            {
                'productName': agent.productName,
                'moniAppName': moniAppName.appName if moniAppName else "",
                'agentForceFollowGzh': agent.forceFollowGzh,
                'devCount': dealer.devCount,
                'agentInfo': '%s-%s' % (agent.username, agent.nickname),
                'maxPackagePrice': float(str(dealer.maxPackagePrice))
            }
        )

        dataList.append(data)

    return JsonOkResponse(
        payload =
        {
            'total': total,
            'dataList': dataList
        }
    )


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'封禁/解封失败'), logger = logger)
def toggleDealerStatus(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """

    payload = json.loads(request.body)  # type: dict
    dealer_id = payload.get('id')
    normal = payload.get('normal')
    if dealer_id is None or normal is None:
        return JsonErrorResponse(description = u'dealer id 或 normal 为空')
    else:
        dealer = Dealer.objects(id = ObjectId(dealer_id)).first()
        if not dealer:
            return JsonErrorResponse(description = u'找不到经销商')

        status = 'abnormal' if not normal else 'normal'

        updated = dealer.update(status = status)
        if not updated:
            return JsonErrorResponse(description = u'更新失败')
        else:
            return JsonOkResponse()


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'封禁/解封失败'), logger = logger)
def toggleDealerWithdrawStatus(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """

    payload = json.loads(request.body)  # type: dict
    dealer_id = payload.get('dealer_id')
    noWithdraw = payload.get('noWithdraw')
    if dealer_id is None or noWithdraw is None:
        return JsonErrorResponse(description = u'dealer id 或 noWithdraw 为空')
    else:
        dealer = Dealer.objects(id = ObjectId(dealer_id)).first()
        if not dealer:
            return JsonErrorResponse(description = u'找不到经销商')

        status = 'normal' if not noWithdraw else 'noWithdraw'

        updated = dealer.update(status = status)
        if not updated:
            return JsonErrorResponse(description = u'更新失败')
        else:
            return JsonOkResponse()


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'编辑广告开关失败'), logger = logger)
@permission_required(ROLE.supermanager)
def editAdShow(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    payload = json.loads(request.body)  # type: dict

    def handle_manager(ids, adShow):
        # type:(List[str], bool)->bool

        Manager.get_collection().update_many(
            {'_id': {'$in': [ObjectId(_) for _ in ids]}},
            {'$set': {'adShow': adShow}})

        agents = Agent.get_collection().find({'managerId': {'$in': ids}})

        handle_agent([str(_['_id']) for _ in agents], adShow)

        return True

    def handle_agent(ids, adShow):
        # type:(List[str], bool)->bool

        Agent.get_collection().update_many(
            {'_id': {'$in': [ObjectId(_) for _ in ids]}},
            {'$set': {'adShow': adShow}})

        dealers = Dealer.get_collection().find({'agentId': {'$in': ids}})

        handle_dealer([str(_['_id']) for _ in dealers], adShow)

        return True

    def handle_dealer(ids, adShow):
        # type:(List[str], bool)->bool
        map(lambda _: Dealer.invalid_cache(_), ids)

        Dealer.get_collection().update_many(
            {'_id': {'$in': [ObjectId(_) for _ in ids]}},
            {'$set': {'adShow': adShow}})

        return True

    handler_map = {
        'manager': handle_manager,
        'agent': handle_agent,
        'dealer': handle_dealer
    }  # type: Dict[str, Callable]

    updated = handler_map[payload['role']](payload['ids'], adShow = payload['adShow'])

    if updated:
        return JsonOkResponse()
    else:
        return JsonErrorResponse(description = u'更新失败')


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'编辑流量费用失败'), logger = logger)
@permission_required(ROLE.supermanager)
def setTrafficCardCost(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    payload = json.loads(request.body)  # type: dict

    ids = payload.get('ids', [])

    cost = payload.get('cost')
    if cost is None or not ids:
        return JsonErrorResponse(description = u'设置错误，代理商ID列表为空或成本没传入')

    if RMB(cost) < RMB(0):
        return JsonErrorResponse(description = u'流量卡年费成本价格必须大于0')

    updated = Agent.objects(id__in = ids).update(set__trafficCardCost = RMB(cost).mongo_amount)

    if updated:
        return JsonOkResponse()
    else:
        return JsonErrorResponse(description = u'更新失败')


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'编辑用户信息失败'), logger = logger)
@permission_required(ROLE.supermanager)
def editUserInfo(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    payload = json.loads(request.body)  # type: dict
    id_ = payload.get('id')
    role = payload.get('role')
    info = payload.get('info', {})

    if role == 'dealer':
        updated = Dealer.objects(id = id_).update(**info)

    elif role == 'agent':
        updated = Agent.objects(id = id_).update(**info)

    else:
        return JsonErrorResponse(description = u'不支持编辑的角色')

    if updated:
        return JsonOkResponse(description = u'编辑成功')
    else:
        return JsonErrorResponse(description = u'编辑失败')


# Commands
@require_GET
@error_tolerate(nil = JsonErrorResponse(u'获取命令列表失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getDeviceCommands(request):
    # type: (WSGIRequest)->JsonResponse
    """
    :param request:
    :return:
    """
    pageIndex = int(request.GET.get("pageIndex"))
    pageSize = int(request.GET.get("pageSize"))
    searchKey = request.GET.get('searchKey')
    field = request.GET.get('field')

    if searchKey and field:
        field = None if field == "*" else field
        querySet = DeviceCommand.objects.search(searchKey, fields = [field])
    else:
        querySet = DeviceCommand.objects

    total = querySet.count()
    dataList = list()
    for _item in querySet.paginate(pageIndex, pageSize):
        dataList.append(_item.to_dict())

    return JsonOkResponse(payload = {"dataList": dataList, "total": total})


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'添加命令失败'), logger = logger)
@permission_required(ROLE.supermanager)
def addDeviceCommand(request):
    # type: (WSGIRequest)->JsonResponse
    """
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    params = payload.pop("params", None)
    command = DeviceCommand(**payload)

    if params:
        commandParams = [DeviceCommandParam(**_item) for _item in params]
        command.params = commandParams

    command.save()
    return JsonOkResponse(description = u"命令添加成功")


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'编辑命令失败'), logger = logger)
@permission_required(ROLE.supermanager)
def editDeviceCommand(request):
    # type: (WSGIRequest)->JsonResponse
    """
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    commandId = payload.pop("id")
    updated = DeviceCommand.objects.filter(id = commandId).update(**payload)

    if updated:
        return JsonOkResponse(description = u"命令更新成功")
    else:
        return JsonErrorResponse(description = u'编辑命令更新失败')


@require_POST
@error_tolerate(nil = JsonErrorResponse(u'删除命令失败'), logger = logger)
@permission_required(ROLE.supermanager)
def deleteDeviceCommand(request):
    # type: (WSGIRequest)->JsonResponse
    """
    :param request:
    :return:
    """
    payload = json.loads(request.body) if request.body else {}
    result = DeviceCommand.objects(id__in = payload['ids']).delete()
    if result:
        return JsonOkResponse()
    else:
        return JsonErrorResponse(description = u'删除失败')


@error_tolerate(nil = JsonErrorResponse(u'获取地图失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getDevMapChart(request):
    # type: (WSGIRequest)->JsonResponse
    return JsonOkResponse(payload = {'dataList': []})


@error_tolerate(nil = JsonErrorResponse(u'获取收入趋势失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getIncomeTrend(request):
    return JsonOkResponse(payload = {'dataList': []})


@error_tolerate(nil = JsonErrorResponse(u'获取设备类型统计失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getDeviceTypeStatistics(request):
    return JsonOkResponse(payload = {'dataList': []})


@error_tolerate(nil = JsonErrorResponse(u'获取经销商收入和失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getDealerIncomeTotalTop(request):
    return JsonOkResponse(payload = {'dataList': []})


@error_tolerate(nil = JsonErrorResponse(u'获取用户趋势失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getAllUserTrend(request):
    return JsonOkResponse(payload = {'dataList': []})


@error_tolerate(nil = JsonErrorResponse(u'获取设备注册趋势失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getDeviceRegTrend(request):
    return JsonOkResponse(payload = {'dataList': []})


@error_tolerate(nil = JsonErrorResponse(u'获取反馈趋势失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getAllFeedbackTrend(request):
    return JsonOkResponse(payload = {'dataList': []})


@error_tolerate(nil = JsonErrorResponse(u'获取提现记录失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getWithdrawTrend(request):
    return JsonOkResponse(payload = {'dataList': []})


# noinspection PyUnresolvedReferences
@error_tolerate(nil = JsonErrorResponse(u'导入sim卡数据失败'), logger = logger)
@permission_required(ROLE.supermanager)
def importSim(request):
    current_user = request.user  # type: SuperManager

    def get_offline_task_name(task_type, user, source):
        # type: (basestring, SuperManager, str)->basestring
        now_time = datetime.datetime.now()

        tmp_list = [task_type, user.username, source, now_time.strftime('%Y-%m-%d %H:%M:%S'),
                    str(utils_datetime.generate_timestamp_ex())]

        return '-'.join(tmp_list)

    payload = json.loads(request.body)

    excel_file = payload.get('file')
    source = payload.get('source')

    offline_task_name = get_offline_task_name(
        task_type = OfflineTaskType.IMPORT_SIM_CARD,
        user = current_user,
        source = source)

    offline_task = OfflineTask.issue(offline_task_name = offline_task_name,
                                     process_func_name = 'import_simcard_excel_to_db',
                                     task_type = OfflineTaskType.IMPORT_SIM_CARD,
                                     userid = str(current_user.id),
                                     role = ROLE.supermanager)

    task_caller(offline_task.process_func_name,
                offline_task_id = str(offline_task.id),
                excelFile = excel_file,
                source = source)

    return JsonResponse({
        'result': 1,
        'description': u'成功创建任务，请您在sim卡任务管理中，查看任务执行情况',
        'payload': {
            'offline_task_id': str(offline_task.id)
        }})


@error_tolerate(nil = JsonErrorResponse(u'查询sim卡数据失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getSimCardList(request):
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    startTimeStr = request.GET.get('startTime', None)
    endTimeStr = request.GET.get('endTime', None)
    searchType = request.GET.get('searchType', '')
    searchKey = request.GET.get('searchKey', '')
    simCardSource = request.GET.get('simCardSource', '')

    startTime = datetime.datetime.strptime(startTimeStr + ' 00:00:00', "%Y-%m-%d %H:%M:%S")
    endTime = datetime.datetime.strptime(endTimeStr + ' 23:59:59', "%Y-%m-%d %H:%M:%S")

    queryArr = ['expireTime__gte=startTime', 'expireTime__lte=endTime']
    if searchType == 'IMSI' and searchKey != '':
        queryArr.append('imsi=searchKey')
    elif searchType == 'ICCID' and searchKey != '':
        queryArr.append('iccid=searchKey')
    else:
        pass

    if simCardSource != '':
        queryArr.append('supplier=searchKey')

    query = ','.join(queryArr)
    ss = eval('SIMCard.objects({})'.format(query))

    dataList = []
    for _ in ss.paginate(pageIndex, pageSize):
        device = Device.objects(iccid = _.iccid).first()
        if device is not None:
            dealer = Dealer.objects(id = device.ownerId).first()
            logicalCode = device.logicalCode
            if dealer is not None:
                dealerStr = dealer.nickname + '_' + dealer.username + '_' + device.ownerId
                agent = Agent.objects(id = dealer.agentId).first()
                if agent is not None:
                    agentStr = agent.nickname + '_' + agent.username + '_' + dealer.agentId
                    manager = Manager.objects(id = agent.managerId).first()
                    if manager is not None:
                        managerStr = manager.nickname + '_' + manager.username + '_' + agent.managerId
                    else:
                        managerStr = ''
                else:
                    agentStr = ''
                    managerStr = ''
            else:
                dealerStr = ''
                agentStr = ''
                managerStr = ''
        else:
            logicalCode = ''
            dealerStr = ''
            agentStr = ''
            managerStr = ''

        dataList.append({
            'imsi': _.imsi,
            'iccid': _.iccid,
            'simCardBrand': _.supplier,
            'expireDate': _.expireTime,
            'logicalCode': logicalCode,
            'dealerStr': dealerStr,
            'agentStr': agentStr,
            'managerStr': managerStr
        })

    return JsonResponse({'result': 1, 'description': '', 'payload': {'total': ss.count(), 'dataList': dataList}})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getOfflineTaskList(request):
    # type: (WSGIRequest)->JsonResponse
    """
    获取离线任务列表
    :param request:
    :return:
    """
    current_user = request.user  # type: SuperManager

    page_index = int(request.GET.get('pageIndex', 1))
    page_size = int(request.GET.get('pageSize', 10))
    search_key = request.GET.get('searchKey', None)

    tasks = OfflineTask.objects(ownerId = current_user.id,
                                role = current_user.role).search(search_key).order_by('-dateTimeAdded')
    total = tasks.count()

    return JsonOkResponse(
        payload = {
            'dataList': [t.to_dict() for t in tasks.paginate(pageSize = page_size, pageIndex = page_index)],
            'total': total
        })


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getOfflineTaskStatus(request):
    # type: (WSGIRequest)->JsonResponse
    task_id = request.GET.get('id')
    if not task_id:
        return JsonErrorResponse(description = u'查询ID为空')

    task = OfflineTask.objects(id = str(task_id)).get()  # type: OfflineTask

    return JsonOkResponse(payload = task.status)


# noinspection PyUnresolvedReferences
@error_tolerate(nil = JsonErrorResponse(u'导入sim卡数据失败'), logger = logger)
@permission_required(ROLE.supermanager)
def exportExcel(request):
    super_manager = request.user  # type: SuperManager

    def get_offline_task_name(task_type, user, **kwargs):
        # type: (basestring, SuperManager, Dict)->basestring

        tmp_list = [task_type, user.username]

        if kwargs['simCardSource'] and kwargs['simCardSource']:
            tmp_list.append(kwargs['simCardSource'])

        tmp_list.append(u'%s至%s' % (kwargs['startTimeStr'], kwargs['endTimeStr']))
        tmp_list.append(str(utils_datetime.generate_timestamp_ex()))

        return '-'.join(tmp_list).replace("/", "_")

    query_dict = {
        'startTimeStr': request.GET.get('startTime', None),
        'endTimeStr': request.GET.get('endTime', None),
        'searchKey': request.GET.get('searchKey', ''),
        'searchType': request.GET.get('searchType', ''),
        'simCardSource': request.GET.get('simCardSource', '')
    }

    offline_task_name = get_offline_task_name(
        task_type = OfflineTaskType.EXPORT_SIM_CARD,
        user = super_manager,
        **query_dict)

    file_path, offline_task = OfflineTask.issue_export_report(offline_task_name = offline_task_name,
                                                              process_func_name = 'export_simcard_excel_from_db',
                                                              task_type = OfflineTaskType.EXPORT_SIM_CARD,
                                                              userid = str(super_manager.id),
                                                              role = ROLE.supermanager)

    task_caller(func_name = str(offline_task.process_func_name),
                offline_task_id = str(offline_task.id),
                filepath = file_path,
                queryDict = query_dict)
    return JsonResponse({
        'result': 1,
        'description': u"请前往离线任务查看任务处理情况",
        'payload': str(offline_task.id)
    })


@error_tolerate(nil = JsonErrorResponse(u'导出设备数据失败'), logger = logger)
@permission_required(ROLE.supermanager)
def exportDevice(request):
    super_manager = request.user  # type: SuperManager

    def get_offline_task_name(task_type, user, **kwargs):
        # type: (basestring, SuperManager, Dict)->basestring

        tmp_list = [task_type, user.username]
        tmp_list.append(u'设备信息')
        tmp_list.append(str(utils_datetime.generate_timestamp_ex()))

        return '-'.join(tmp_list).replace("/", "_")

    query_dict = {
        'logicalCodeList': list(set(request.GET.getlist('logicalCodeList', None)))
    }

    offline_task_name = get_offline_task_name(
        task_type = OfflineTaskType.EXPORT_DEVICE,
        user = super_manager,
        **query_dict)

    file_path, offline_task = OfflineTask.issue_export_report(offline_task_name = offline_task_name,
                                                              process_func_name = 'export_device_excel_from_db',
                                                              task_type = OfflineTaskType.EXPORT_DEVICE,
                                                              userid = str(super_manager.id),
                                                              role = ROLE.supermanager)

    task_caller(func_name = str(offline_task.process_func_name),
                offline_task_id = str(offline_task.id),
                filepath = file_path,
                queryDict = query_dict)
    return JsonResponse({
        'result': 1,
        'description': u"请前往离线任务查看任务处理情况",
        'payload': str(offline_task.id)
    })


@error_tolerate(nil = JsonErrorResponse(u'查询管理日志失败'), logger = logger)
@permission_required(ROLE.supermanager)
def getAdminLog(request):
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    startTime = request.GET.get('startTime', None)
    endTime = request.GET.get('endTime', None)
    searchKey = request.GET.get('searchKey', '')

    return JsonResponse({'result': 1, 'description': '', 'payload': {'total': 0, 'dataList': []}})


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def getAliApp(request):
    # type: (WSGIRequest)->JsonResponse
    """
    更改微信资金平台APP信息
    :param request:
    :return:
    """
    appid = str(request.GET.get('appid'))

    app = AliApp.objects(appid = appid).first()  # type: AliApp
    if not app:
        return JsonOkResponse(payload = {})
    else:
        return JsonOkResponse(payload = app.to_dict())


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def bindAliApp(request):
    # type: (WSGIRequest)->JsonResponse
    """
    绑定自定义支付宝
    :param request:
    :return:
    """
    payload = json.loads(request.body)  # type: dict

    return api.bindAliApp(payload)


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def bindWechatFund(request):
    # type: (WSGIRequest)->JsonResponse
    """
    绑定自定义微信公众号
    :param request:
    :return:
    """
    payload = json.loads(request.body)  # type: dict

    return api.bindWechatFund(payload)


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def bindWechatCust(request):
    # type: (WSGIRequest)->JsonResponse
    """
    绑定自定义微信公众号
    :param request:
    :return:
    """
    payload = json.loads(request.body)  # type: dict

    return api.bindWechatCust(payload)


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def getWechatFundApp(request):
    # type: (WSGIRequest)->JsonResponse
    """
    更改微信资金平台APP信息
    :param request:
    :return:
    """
    appid = request.GET.get('appid')
    mchid = request.GET.get('mchid')

    app = WechatPayApp.objects(appid = appid, mchid = mchid).first()  # type: WechatPayApp
    if not app:
        return JsonOkResponse(payload = {})
    else:
        return JsonOkResponse(payload = app.to_dict())


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.supermanager)
def sendCommand(request):
    # type: (WSGIRequest)->JsonResponse
    """
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    devNo = payload.get("devNo")
    cmdID = payload.get("id")
    params = payload.get("params", list())

    dev = Device.get_dev(devNo)
    if not dev:
        return JsonErrorResponse(u"设备获取失败，请尝试重新发送指令")

    command = DeviceCommand.objects.filter(id = cmdID, role = request.user.role).first()
    if not command:
        return JsonErrorResponse(u"命令获取失败，请尝试重新发送指令")

    try:
        commandDict = command.package_command(dev, params)
    except Exception as e:
        logger.exception(u"dev <{}>, command <{}> , package command error <{}>".format(devNo, cmdID, e))
        return JsonErrorResponse(u"命令发送失败，请尝试重新发送指令")

    cmd = commandDict.get("cmd")
    try:
        result = MessageSender.send(dev, cmd = cmd, payload = commandDict, timeout = 20)
        if result.get("rst") == -1:
            raise ManagerServiceTimeOutException()
        if result.get("rst") == 1:
            raise ManagerServiceSerialException()
    except ServiceException as se:
        return JsonErrorResponse(description = se.result.get("description"))
    except Exception as e:
        logger.exception('failed to send command, error = %s where command was %s' % (e, str(command)))
        return JsonErrorResponse(description = u"指令发送异常")

    return JsonResponse({'result': 1, 'description': u'发送成功', 'payload': json.dumps(result)})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getCommandByDevice(request):
    # type: (WSGIRequest)->JsonResponse
    """
    :param request:
    :return:
    """
    logicalCode = request.GET.get('logicalCode')
    commands = DeviceCommand.common_and_type_specific(
        logicalCode = logicalCode,
        commander = request.user
    )
    return JsonResponse({
        'result': 1,
        'description': '',
        'payload': {"dataList": commands}
    })


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getSimDetail(request):
    # type: (WSGIRequest)->JsonResponse
    """
    :param request:
    :return:
    """
    iccid = request.GET.get('iccid')
    if not iccid:
        return JsonResponse({'result': 0, 'description': u'ICCID不合法', 'payload': ''})

    sim = SIMCard.objects().filter(iccid = iccid).first()  # type: SIMCard
    if not sim:
        payload = {
        }
    else:
        payload = {
            'iccid': sim.iccid,
            'imsi': sim.imsi,
            'supplier': sim.supplier,
            'activeTime': sim.activeTime,
            'expireTime': sim.expireTime,
            'chargeTime': sim.chargeTime
        }

    if (not payload) or (payload['supplier'] == 'qiben'):
        try:
            response = SimManager().get_card_list(begin_iccid = iccid, end_iccid = iccid, card_type = 2)
            if len(response['records']) > 0:
                record = response['records'][0]
                payload.update({
                    'qiben_openCardTime': record['openCardTime'],
                    'qiben_activateTime': record['activateTime'],
                    'qiben_packageTime': record['packageTime'],

                    'qiben_totalFlow': record['totalFlow'],
                    'qiben_cardFlow': record['cardFlow'],
                    'qiben_leftFlow': record['leftFlow'],
                    'qiben_cardStatus': record['cardStatus']
                })
        except Exception as e:
            logger.exception(e)

    return JsonResponse({
        'result': 1,
        'description': '',
        'payload': payload
    })


@error_tolerate(logger = logger, nil = JsonErrorResponse(u'二维码文件存储失败，请重新试试'))
@permission_required(ROLE.supermanager)
def uploadMoniQrcode(request):
    # type: (WSGIRequest)->JsonResponse

    files = request.FILES.getlist('file')
    if not len(files):
        return JsonResponse({'result': 0, 'description': u'未找到上传的二维码文件，请重新试试', 'payload': ''})

    uploader = AliOssFileUploader(inputFile = request.FILES.getlist('file')[0], uploadType = 'qrcode')

    logger.info('[uploadMoniQrcode] %s is being used' % (repr(uploader),))

    try:
        outputUrl = uploader.upload()
        return JsonResponse({'result': 1, 'description': '', 'payload': outputUrl})

    except InvalidFileSize, e:
        logger.info(
            '%s(id=%s)\'s uploaded file reached limit' % (request.user.__class__.__name__, str(request.user.id),))
        return JsonResponse({'result': 0, 'description': e.message, 'payload': {}})

    except InvalidFileName, e:
        logger.info(
            '%s(id=%s)\'s uploaded file name is not legal' % (request.user.__class__.__name__, str(request.user.id),))
        return JsonResponse({'result': 0, 'description': e.message, 'payload': {}})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getMoniApps(request):
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 40))
    objs = MoniApp.objects.all()
    dataList = []
    total = objs.count()
    for obj in objs.paginate(pageIndex = pageIndex, pageSize = pageSize):
        dataList.append({
            'appName': obj.appName,
            'appId': obj.appId,
            'rawAppId': obj.rawAppId,
            'secret': obj.secret,
            'appType': obj.appType,
            'priority': obj.priority,
            'status': obj.status,
            'desc': obj.desc,
            'title': obj.title,
            'maxDayAddingCount': obj.maxDayAddingCount
        })

    return JsonOkResponse(payload = {'total': total, 'dataList': dataList})


def createMenu(appId, secret):
    grzx = {
        'type': 'view',
        'name': u'个人中心',
        'url': "http://www.washpayer.com/user/moniUserAccess?moniAppId=%s&redirect=%s" % (appId, 'gerenzhongxin')
    }

    dangqianfuwu = {
        'type': 'view',
        'name': u'当前服务',
        'url': "http://www.washpayer.com/user/moniUserAccess?moniAppId=%s&redirect=%s" % (appId, 'dangqianfuwu')
    }

    changjianwenti = {
        'type': 'view',
        'name': u'常见问题',
        'url': "http://www.washpayer.com/user/moniUserAccess?moniAppId=%s&redirect=%s" % (appId, 'changjianwenti')
    }

    baogaolaoban = {
        'type': 'view',
        'name': u'报告老板',
        'url': "http://www.washpayer.com/user/moniUserAccess?moniAppId=%s&redirect=%s" % (appId, 'baogaolaoban')
    }

    toushushouli = {
        'type': 'view',
        'name': u'投诉受理',
        'url': "http://www.washpayer.com/user/moniUserAccess?moniAppId=%s&redirect=%s" % (appId, 'toushushouli')
    }

    menu = {
        "button":
            [

                {
                    "name": u"服务&投诉",
                    "sub_button": [dangqianfuwu, changjianwenti, baogaolaoban, toushushouli]
                },

                {
                    "type": "scancode_push",
                    "name": u"扫一扫",
                    "key": "rselfmenu_0_1",
                    "sub_button": []
                },
                grzx
            ]
    }

    app = WechatAuthApp(appid = appId, secret = secret)
    proxy = WechatClientProxy(app)
    proxy.client.menu.create(menu)


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def editMoniApp(request):
    payload = json.loads(request.body)
    appId = payload.get('appId', None)
    if appId is None:
        MoniApp.get_collection().insert(payload)
        # 如果是新增加，需要生成菜单
        createMenu(appId, payload['secret'])
    else:
        MoniApp.get_collection().update({'appId': appId}, {'$set': payload}, upsert = True)
    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def deleteMoniApp(request):
    payload = json.loads(request.body)
    appIds = payload.get('ids', None)
    MoniApp.get_collection().remove({'appId': {'$in': appIds}})
    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def addMoniAppToAgents(request):
    payload = json.loads(request.body)
    agentIds = [ObjectId(_) for _ in payload.get('agentIds', [])]
    moniAppIds = payload.get('moniAppIds', [])
    agents = Agent.objects.filter(id__in = agentIds)
    for agent in agents:
        for appId in moniAppIds:
            if appId not in agent.moniAppList:
                agent.moniAppList.append(appId)
        agent.save()

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def removeMoniAppFromAgents(request):
    payload = json.loads(request.body)
    agentIds = [ObjectId(_) for _ in payload.get('agentIds', [])]
    moniAppId = payload.get('moniAppId', None)
    if moniAppId is None:
        return JsonErrorResponse(description = u'未传入moni appId')
    agents = Agent.objects.filter(id__in = agentIds)
    for agent in agents:
        if moniAppId in agent.moniAppList:
            agent.moniAppList.remove(moniAppId)
        agent.save()

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def queryAgentsForMoniApp(request):
    page_index = int(request.GET.get('pageIndex', 1))
    page_size = int(request.GET.get('pageSize', 10))
    moniAppId = request.GET.get('moniAppId', None)
    if moniAppId is None:
        return JsonErrorResponse(description = u'未传入moni appId')

    total, items = Agent.filter(moniAppList = moniAppId, page_index = page_index,
                                page_size = page_size)
    return JsonOkResponse(
        payload =
        {
            'total': total,
            'dataList': items
        }
    )


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getCheckPointForAgent(request):
    agentId = request.GET.get('agentId')
    agent = Agent.objects.get(id = agentId)
    pointDict = agent.moniAppCheckPointDict
    return JsonOkResponse(payload = {'data': pointDict})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getCheckPointForDealer(request):
    dealerId = request.GET.get('dealerId')
    dealer = Dealer.objects.get(id = dealerId)
    agent = Agent.objects.get(id = dealer.agentId)
    return JsonOkResponse(
        payload = {'dealerData': dealer.moniAppCheckPointDict, 'agentData': agent.moniAppCheckPointDict})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def setCheckPointForAgents(request):
    payload = json.loads(request.body)
    agentIds = [ObjectId(_) for _ in payload.get('agentIds', [])]
    pointDict = payload.get('pointDict')
    agents = Agent.objects.filter(id__in = agentIds)
    for agent in agents:
        agent.moniAppCheckPointDict = pointDict
        agent.save()
    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def setCheckPointForDealers(request):
    payload = json.loads(request.body)
    dealerIds = [ObjectId(_) for _ in payload.get('dealerIds', [])]
    pointDict = payload.get('pointDict')
    dealers = Dealer.objects.filter(id__in = dealerIds)
    for dealer in dealers:
        dealer.moniAppCheckPointDict = pointDict
        dealer.save()
    return JsonOkResponse()


def getMoniPointList(request):
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    objs = MoniAppPoint.objects.all()
    dataList = [{'id': str(obj.id), 'key': obj.key, 'desc': obj.desc, 'name': obj.name} for obj in
                objs.paginate(pageIndex = pageIndex, pageSize = pageSize)]
    return JsonOkResponse(payload = {'dataList': dataList, 'total': objs.count()})


def editMoniPoint(request):
    payload = json.loads(request.body)
    objId = payload.get('id', None)
    if objId is None:
        MoniAppPoint.get_collection().insert(payload)
    else:
        MoniAppPoint.get_collection().update({'_id': ObjectId(objId)}, {
            '$set': {'name': payload['name'], 'key': payload['key'], 'desc': payload['desc']}}, upsert = True)
    return JsonOkResponse()


def deleteMoniPoint(request):
    payload = json.loads(request.body)
    ids = [ObjectId(_) for _ in payload.get('ids', [])]
    MoniAppPoint.get_collection().remove({'_id': {'$in': ids}})
    return JsonOkResponse()


def editMoniAppForAgents(request):
    payload = json.loads(request.body)
    agentIds = [ObjectId(_) for _ in payload.get('agentIds', [])]
    moniApps = payload.get('moniApp')
    agents = Agent.objects.filter(id__in = agentIds)
    for agent in agents:
        for moniApp in moniApps:
            if moniApp['switch'] and (moniApp['appId'] not in agent.moniAppList):
                agent.moniAppList.append(moniApp['appId'])
            elif (not moniApp['switch']) and (moniApp['appId'] in agent.moniAppList):
                agent.moniAppList.remove(moniApp['appId'])
        agent.save()

    return JsonOkResponse()


def editMoniPointForAgents(request):
    payload = json.loads(request.body)
    agentIds = [ObjectId(_) for _ in payload.get('agentIds', [])]
    points = payload.get('moniPoint')
    agents = Agent.objects.filter(id__in = agentIds)
    for agent in agents:
        for point in points:
            agent.moniAppCheckPointDict.update({point['key']: point['switch']})
        agent.save()

    return JsonOkResponse()


def editMoniPointForDealers(request):
    payload = json.loads(request.body)
    dealerIds = [ObjectId(_) for _ in payload.get('dealerIds', [])]
    points = payload.get('moniPoint')
    dealers = Dealer.objects.filter(id__in = dealerIds)
    for dealer in dealers:
        for point in points:
            dealer.moniAppCheckPointDict.update({point['key']: point['switch']})
        dealer.save()

    return JsonOkResponse()


def editDealerFollowGzh(request):
    payload = json.loads(request.body)
    dealerIds = [ObjectId(_) for _ in payload.get('ids', [])]

    forceFollowGzh = payload.get('forceFollowGzh', 'agent')

    if forceFollowGzh != 'never':
        dealers = Dealer.objects.filter(id__in = dealerIds, forceFollowGzh__ne = 'never')
    else:
        dealers = Dealer.objects.filter(id__in = dealerIds)

    needDealerIds = []
    for dealer in dealers:
        # 如果代理商已经never了，这里不允许更新
        agent = Agent.objects.get(id = dealer.agentId)
        if agent.forceFollowGzhForDealer == 'never':
            continue

        needDealerIds.append(dealer.id)

    Dealer.get_collection().update({'_id': {'$in': needDealerIds}}, {'$set': {'forceFollowGzh': forceFollowGzh}},
                                   multi = True)

    return JsonOkResponse()


# def editDealerFollowGzh(request):
#     payload = json.loads(request.body)
#     dealerIds = [ObjectId(_) for _ in payload.get('ids',[])]
#     forceFollowGzh = payload.get('forceFollowGzh','agent')
#     Dealer.get_collection().update({'_id':{'$in':dealerIds}},{'$set':{'forceFollowGzh':forceFollowGzh}},multi = True)
#     return JsonOkResponse()

#### FAQ
@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getFAQDetailList(request):
    # type: (WSGIRequest)->JsonResponse
    """
    超级管理员获取FAQ列表
    :param request:
    :return:
    """
    faqs = FAQ.objects(managerId = '')
    return JsonResponse(
        {
            'result': 1,
            'description': None,
            'payload': {
                'dataList': [faq.to_dict() for faq in faqs]
            }
        }
    )


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def addFAQ(request):
    # type: (WSGIRequest)->JsonResponse
    payload = json.loads(request.body)
    payload.update({'managerId': ''})
    faq = FAQ(**payload).save()
    return JsonResponse(
        {
            'result': 1 if faq else 0,
            'description': None,
            'payload': {}
        }
    )


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def editFAQ(request):
    # type: (WSGIRequest)->JsonResponse
    payload = json.loads(request.body)
    updated = FAQ.objects(id = str(payload['id'])).update(**payload)
    return JsonResponse(
        {
            'result': 1 if updated else 0,
            'description': None,
            'payload': {}
        }
    )


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def deleteFAQ(request):
    # type: (WSGIRequest)->JsonResponse
    ids = json.loads(request.body)['ids']
    map(lambda _: _.delete(), FAQ.objects(id__in = ids))
    return JsonResponse({'result': 1, 'description': '', 'payload': {}})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def editAgentForceFollowGzh(request):
    payload = json.loads(request.body)
    agentStrIds = payload.get('ids', [])
    ids = [ObjectId(_) for _ in agentStrIds]
    forceFollowGzhForDealer = payload.get('forceFollowGzhForDealer', 'free')
    forceFollowGzh = True if payload.get('forceFollowGzh', 'no') == 'yes' else False

    # 先把代理商的统一修改掉
    Agent.get_collection().update({'id': {'$in': ids}}, {'$set': {'forceFollowGzh': forceFollowGzh}}, multi = True)

    # 经销商的，仅仅是把锁住的，全部解锁。或者全部加锁
    if forceFollowGzhForDealer == 'free':
        Dealer.get_collection().update({'agentId': {'$in': agentStrIds}, 'forceFollowGzh': 'never'},
                                       {'$set': {'forceFollowGzh': 'free'}}, multi = True)
    else:
        Dealer.get_collection().update({'agentId': {'$in': agentStrIds}}, {'$set': {'forceFollowGzh': 'never'}},
                                       multi = True)

    if forceFollowGzh:
        return JsonOkResponse(description = u'注意，如果打开代理商的强制关注，一定要在代理商系统把代理商的公众号相关信息，比如二维码、appId、secret相关信息配置OK')

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@trace_call(logger = logger)
@permission_required(ROLE.supermanager)
def getSignalTrendByDevice(request):
    strStartTime = request.GET.get('startTime')
    strEndTime = request.GET.get('endTime')
    startTime = to_datetime(strStartTime)
    endTime = to_datetime(strEndTime)

    logicalCode = request.GET.get('logicalCode')
    devNo = Device.get_devNo_by_logicalCode(logicalCode)

    dataList = []
    # 把redis的数据也补上去，然后重新排序，为的是防止数据库没有解析记录
    nowTime = datetime.datetime.now()
    tempStartTime = nowTime - datetime.timedelta(days = 7)
    values = SignalManager.instence().get(devNo, tempStartTime, nowTime)
    if values is not None:
        for value in values:
            timePoint = to_datetime(value['time'])
            if timePoint >= startTime and timePoint <= endTime:
                dataList.append('%s=%s' % (value['time'], value['signal']))

    resultList = []
    for data in dataList:
        tempList = data.split('=')
        resultList.append({
            'dateStr': tempList[0],
            'signal': tempList[1]
        })

    return JsonOkResponse(payload = {'dataList': resultList})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def unLoginLock(request):
    payload = json.loads(request.body)
    role = payload['role']
    if role == ROLE.dealer:
        user = Dealer.objects(id = payload['id']).first()  # type: UserSearchable
    elif role == ROLE.agent:
        user = Agent.objects(id = payload['id']).first()  # type: UserSearchable
    elif role == ROLE.manager or ROLE.manufacturer:  # 传过来的字段不一样 constant里面加了一个字段manufacturer 做容错
        user = Manager.objects(id = payload['id']).first()  # type: UserSearchable
    else:
        return JsonErrorResponse(description = u'无效的用户类型')

    if not user:
        return JsonErrorResponse(description = u'找不到该用户，请刷新后再试')

    user.unlock_login()

    return JsonOkResponse(description = u'解锁成功')


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def unlockRegisterLimit(request):
    payload = json.loads(request.body)
    dealer = Dealer.objects(id = payload['id']).first()
    if dealer is None:
        return JsonErrorResponse(description = u'不存在的经销商')

    serviceCache.delete('dealer_{}_registerEquipment_{}'.format(str(dealer.id), datetime.datetime.now().strftime(Const.DATE_FMT)))

    return JsonOkResponse(description = u'解锁成功')


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def queryExchangeOrder(request):
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    searchKey = request.GET.get('searchKey', '')

    managerId = request.GET.get('managerId')
    agentId = request.GET.get('agentId')
    dealerId = request.GET.get('dealerId')

    query = {}

    if managerId is not None:
        query['factoryId'] = ObjectId(managerId)

    if agentId is not None:
        query['agentId'] = ObjectId(agentId)

    if dealerId is not None:
        query['ownerId'] = ObjectId(dealerId)

    orders = ExchangeOrder.objects(**query).search(searchKey).order_by('-dateTimeAdded')
    total = orders.count()  # type: int

    dataList = []
    for order in orders.paginate(pageIndex = pageIndex, pageSize = pageSize):
        data = {}

        dealer = Dealer.objects.get(id = order.ownerId)
        agent = Agent.objects.get(id = order.agentId)
        factory = Manager.objects.get(id = order.factoryId)
        data['dealerInfo'] = u'%s:%s' % (dealer.username, dealer.nickname)
        data['agentInfo'] = u'%s:%s' % (agent.productName, agent.nickname)
        data['factoryInfo'] = u'%s' % (factory.brandName)
        data['logicalCode'] = order.logicalCode
        objs = Part.objects.filter(id__in = order.parts)
        data['parts'] = [{'partName': obj.partName, 'registerTime': obj.dateTimeAdded.strftime(Const.DATETIME_FMT),
                          'expiredTime': obj.expiredTime.strftime(Const.DATETIME_FMT), 'SN': obj.partNo} for obj in
                         objs]

        data['statusInfo'] = order.make_status_info()
        data['pics'] = order.pics
        data['id'] = str(order.id)
        data['dateTimeAdded'] = order.dateTimeAdded.strftime(Const.DATETIME_FMT)
        data['factoryOrderNo'] = order.factoryOrderNo
        data['dealerOrderNo'] = order.dealerOrderNo
        data['factoryAddr'] = order.factoryAddr
        data['dealerAddr'] = order.dealerAddr
        data['dealerWords'] = order.dealerWords
        data['factoryWords'] = order.factoryWords
        data['more'] = order.more

        dataList.append(data)

    return JsonOkResponse(payload = {'total': total, 'dataList': dataList})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def operateOrder(request):
    payload = json.loads(request.body)
    orderId = payload['id']
    cmd = payload['status']
    factoryOrderNo = payload.get('factoryOrderNo', '')
    order = ExchangeOrder.objects.get(id = orderId)
    logicalCode = order.logicalCode
    dev = Device.get_dev_by_l(logicalCode)
    group = Group.get_group(groupId = dev['groupId'])

    if cmd == 'agree':
        if order.factoryStatus in ['sended', 'closed']:
            return JsonErrorResponse(description = u'当前维护单已经走下去了，不需要再同意了')
        else:
            order.factoryStatus = 'agreed'
            order.save()
    elif cmd == 'disagree':
        if order.factoryStatus in ['sended', 'closed']:
            return JsonErrorResponse(description = u'当前维护单已经走下去了，不需要再同意了')
        else:
            order.factoryStatus = 'disagreed'
            order.save()
    elif cmd == 'close':
        if order.factoryStatus == 'closed':
            pass
        elif order.dealerStatus == 'created' or order.factoryStatus != 'sended':
            return JsonErrorResponse(description = u'经销商必须把有问题的产品寄回来，厂家必须把置换货发出去后，才允许关闭')
    elif cmd == 'send':
        if order.factoryStatus != 'agreed':
            return JsonOkResponse(description = u'必须同意之后，才能够发货哦')
        if not factoryOrderNo:
            return JsonErrorResponse(description = u'需要输入发货快递单号')
        order.factoryOrderNo = factoryOrderNo
        order.save()

    cmdDescDict = {'agree': u'同意换货', 'disagree': u'不同意换货', 'close': u'成功关闭', 'send': u'已经发货'}

    titleDictList = [
        {u'售后中心': cmdDescDict.get(cmd)},
        {u'设备编号': logicalCode},
        {u'地址名称': group["groupName"]}
    ]

    if cmd == 'send':
        titleDictList.append({u'发货单号': factoryOrderNo})

    dealer = Dealer.objects.get(id = order.ownerId)
    partNames = [_.partName for _ in Part.objects.filter(id__in = order.parts)]

    args = {
        'title': make_title_from_dict(titleDictList),
        'customer': u'%s\\n' % (dealer.nickname),
        'detail': u'质保换货，%s\\n' % u'，'.join(partNames),
        'person': u'售后中心\\n',
        'notifyTime': u'%s\\n' % datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
        'remark': u'您可以在设备管理中，查看详细情况\\n' if cmd != 'send' else u'售后中心已经给您寄货，请您尽快把问题组件寄回给我们\\n'
    }

    if dealer.managerialOpenId:
        task_caller('report_to_dealer_via_wechat', openId = dealer.managerialOpenId,
                    dealerId = str(dealer.id),
                    templateName = 'exchange_order_notify',
                    **args)
    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def updateMaintenanceInfo(request):
    payload = json.loads(request.body)
    orderId = payload['id']
    factoryWords = payload['factoryWords']
    more = payload['more']
    factoryAddr = payload['factoryAddr']
    order = ExchangeOrder.objects.get(id = orderId)
    order.more = more
    order.factoryWords = factoryWords
    order.factoryAddr = factoryAddr
    order.save()
    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def saveFactoryAddress(request):
    payload = json.loads(request.body)
    name = payload.get('name', None)
    addr = payload.get('addr', None)
    tel = payload.get('tel', None)
    managerId = payload.get('managerId', None)

    if (not name) or (not addr) or (not tel):
        return JsonErrorResponse(description = u'名称、地址、电话都不允许为空')

    manager = Manager.objects(id = managerId).get()
    manager.expressAddr = {'name': name, 'addr': addr, 'tel': tel}
    manager.save()

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def clearDeviceCache(request):
    payload = json.loads(request.body)
    devNo = payload.get('devNo')

    Device.invalid_all_cache(Device.get_dev(devNo))

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def setDeviceDebug(request):
    payload = json.loads(request.body)
    devNo = payload.get('devNo')
    debugFlag = payload.get('debugFlag', '')

    device = Device.objects(devNo = devNo).first()  # type: Device
    device.debug = debugFlag
    device.save()

    Device.invalid_device_cache(devNo)

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def changeDealerAnnualTrafficCost(request):
    payload = json.loads(request.body)
    ownerId = payload['ids'][0]
    annualTrafficCost = payload['annualTrafficCost']

    # todo 先单独给德力西改流量费做特殊处理
    if annualTrafficCost < 15:
        return JsonErrorResponse(description = u'DLX改流量费, 经销商最低流量费价格不能小于15')

    dealer = Dealer.objects(id = ownerId).first()
    dealer.annualTrafficCost = RMB(str(annualTrafficCost))
    dealer.trafficCardCost = RMB(str(annualTrafficCost))
    dealer.save()
    ds = Device.objects(ownerId = ownerId)
    for _ in ds:
        _.trafficCardCost = None
        _.annualTrafficCost = None
        _.save()
        Device.invalid_device_cache(_.devNo)

    return JsonOkResponse(description = u'修改成功')


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getDealerRechargeRecord(request):
    searchType = request.GET['searchType']
    searchKey = request.GET.get('searchKey')
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 40))
    if searchType == u'logicalCode':
        orderNo = ''
        logicalCode = searchKey
    elif searchType == u'orderNo':
        orderNo = searchKey
        logicalCode = ''
    else:
        return JsonErrorResponse(description = u'请输入正确的查询条件')

    dataList = []

    if orderNo != '':
        dealerRechargeRcds = DealerRechargeRecord.objects(orderNo = orderNo, status = 'Paid')
        if dealerRechargeRcds.count() == 0:
            return JsonErrorResponse(description = u'未付款或不存在的订单号')


    elif logicalCode != '':
        dealerRechargeRcds = DealerRechargeRecord.objects(name__contains = ' ' + logicalCode, status = 'Paid')
        if dealerRechargeRcds.count() == 0:
            return JsonErrorResponse(description = u'未付款或不存在的订单号')
    else:
        return JsonErrorResponse(description = u'请输入查询条件')

    for _ in dealerRechargeRcds.paginate(pageIndex = pageIndex, pageSize = pageSize):
        dealer = Dealer.objects(id = _.dealerId).first()
        if dealer is None:
            dealerStr = ''
        else:
            dealerStr = dealer.nickname + '  ' + dealer.username

        dataList.append({
            'orderNo': _.orderNo,
            'dealerStr': dealerStr,
            'orderParams': _.attachParas,
            'simOrderDict': {
                'name': _.name
            },
            'totalFee': str(float(_.totalFee) / 100),
            'dateTimeAdded': _.finishedTime.strftime('%Y-%m-%d %H:%M:%S')
        })

    return JsonOkResponse(payload = {'dataList': dataList})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def refundDealerRecharge(request):
    payload = json.loads(request.body)
    refundMoney = RMB(payload.get('refundMoney', '0.0'))
    if refundMoney <= RMB('0.0'):
        return JsonErrorResponse(description = u'未知错误')

    dealerRechargeRecord = DealerRechargeRecord.objects(orderNo = payload.get('orderNo', '')).first()
    if dealerRechargeRecord is None:
        return JsonErrorResponse(description = u'订单编号错误')

    try:
        refund_cash_to_dealer(dealerRechargeRecord, refundMoney)
    except UserServerException as e:
        return JsonErrorResponse(description = e.message)
    except Exception as e:
        return JsonErrorResponse(description = u'系统错误')

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def manualRechargeSimCard(request):
    payload = json.loads(request.body)

    lList = payload['logicalCode']

    if len(lList) == 0:
        return JsonErrorResponse(description = u'没有选择设备编号')

    dealerMap = {}

    for device in Device.objects(logicalCode__in = lList):
        if device.simStatus == SimStatus.Charged:
            logger.debug('sim status of {} is charged.'.format(str(device)))
            continue

        if str(device.ownerId) in dealerMap:
            dealer = dealerMap[str(device.ownerId)]
        else:
            dealer = Dealer.objects(id = device.ownerId).first()
            dealerMap[str(device.ownerId)] = dealer

        payment_gateway = get_manual_pay_gateway(dealer)

        rcd = create_dealer_sim_charge_order(payment_gateway, dealer, [device], payType = "manual")
        if not rcd:
            return JsonErrorResponse(
                description = u'创建订单失败，部分设备线下续费失败，请检查后重试(设备号{})。'.format(device.logicalCode))

        rcd.succeed(wxOrderNo = rcd.orderNo)

        device.simStatus = u'chargedUnupdated'
        device.save()
        Device.invalid_device_cache(device.devNo)

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def querySupporters(request):
    return JsonOkResponse()


@error_tolerate(logger = logger, nil = JsonErrorResponse(u"获取免责声明失败"))
@permission_required(ROLE.supermanager)
def getAgentDisclaimer(request):
    """
    获取代理商的免责声明 内容
    :param request:
    :return:
    """
    agentId = request.GET.get("agentId", "")

    agent = Agent.objects.get(id = agentId)

    payload = {
        "content": agent.disclaimerContent,
        "version": agent.disclaimerVersion.split("_")[1],
        "needDisclaimer": agent.needDisclaimer
    }
    return JsonOkResponse(payload = payload)


@error_tolerate(logger = logger, nil = JsonErrorResponse(u"设置免责声明失败"))
@permission_required(ROLE.supermanager)
def setAgentDisclaimer(request):
    """
    设置代理商的免责声明 内容
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    agentId = payload.get("agentId")
    needDisclaimer = payload.get("needDisclaimer")
    disclaimerContent = payload.get("content")
    version = payload.get("version")

    agent = Agent.objects.get(id = agentId)
    agent.update(needDisclaimer = needDisclaimer)

    agent.disclaimerVersion = version
    agent.disclaimerContent = disclaimerContent

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def modifyDeviceCode(request):
    payload = json.loads(request.body)

    logicalCodes = payload.get('logicalCodeList', [])
    code = payload.get('code')

    if not logicalCodes:
        return JsonErrorResponse(description='没有选中的设备')

    if not code:
        return JsonErrorResponse(description='code输入有误')

    mark = None
    deviceOwner = Device.get_dev_by_l(logicalCodes[0]).owner
    model_device = Device.objects.filter(ownerId=str(deviceOwner.id), devType__code=code).order_by('-id').first()

    if model_device:
        devType = model_device.devType
        washConfig = model_device.washConfig
        otherConf = model_device.otherConf

        logger.info(
            'washConfig=<{}> otherConf=<{}> devType=<{}> sync params tar=<{}>'.format(washConfig, otherConf, devType,
                                                                                         logicalCodes))
        mark = 1

    else:
        devType = DeviceType.objects.filter(agentId=deviceOwner.agentId, code=code).first()  # type: DeviceType
        if devType:
            package = deviceOwner.defaultWashConfig.get(str(devType.id))
            if not package:
                package = devType.package
            washConfig = dict(map(lambda _: (str(package.index(_) + 1), _), package))

            otherConf = {}
            devType = devType.to_dict()

            logger.info('washConfig=<{}> otherConf=<{}> devType=<{}> sync params!! tar=<{}>'.format(washConfig, otherConf, devType,logicalCodes))

            mark = 2

        else:
            devType = DeviceType.objects.filter(code=code).first()  # type: DeviceType
            if devType:
                devType = DeviceType.objects.create(**{
                    "role": "manager",
                    "online": devType.online,
                    "unit": devType.unit,
                    "stock": devType.stock,
                    "payableWhileBusy": devType.payableWhileBusy,
                    "displayCoinsSwitch": True,
                    "displayPriceSwitch": True,
                    "displayTimeSwitch": True,
                    "name": devType.name,
                    "package": devType.package,
                    "code": code,
                    "majorDeviceType": devType.majorDeviceType,
                    "devFeatures": getattr(devType, 'devFeatures', []),
                    "agentId": deviceOwner.agentId
                })

            else:
                return JsonErrorResponse(description='没有这个code, 去手动添加操作')

            washConfig = dict(map(lambda _: (str(package.index(_)+1), _), devType.package))
            otherConf = {}
            devType = devType.to_dict()

            logger.info('washConfig=<{}> otherConf=<{}> devType=<{}> sync params!!! tar=<{}>'.format(washConfig, otherConf, devType,logicalCodes))

            mark = 3


    devNos = []
    for _ in logicalCodes:
        devNos.append(Device.get_dev_by_logicalCode(_).devNo)

    Device.get_collection().update_one({'devNo': {'$in': devNos}}, {
        '$set': {'devType': devType, 'washConfig': washConfig, 'otherConf': otherConf}})

    Device.invalid_many_device_cache(devNos)

    payload = {'devType': devType, 'washConfig': washConfig, 'otherConf': otherConf, 'logicalCodes': logicalCodes}

    if mark == 1:
        return JsonOkResponse(description='修改成功并与设备:{} 同步参数'.format(model_device.logicalCode), payload=payload)

    elif mark == 2:
        return JsonOkResponse(description='修改成功', payload=payload)

    elif mark == 3:
        return JsonOkResponse(description='修改成功, 并新增一个设备类型<devType: {}>'.format(devType['code']), payload=payload)

    else:
        return JsonErrorResponse(description='修改失败!, 去手动添加操作')


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def rentDevice(request):
    """
    出租设备
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    logicalCode = payload.get("logicalCode")

    device = Device.objects.get(logicalCode = logicalCode)
    try:
        device.rent()
    except RentDeviceError as renError:
        return JsonErrorResponse(description = renError.message)

    Device.invalid_device_cache(device.devNo)
    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def getInsuranceOrder(request):
    """
    获取
    :param request:
    :return:
    """
    wxOrderNo = request.GET.get("outTradeNo")
    if not wxOrderNo:
        return JsonErrorResponse(u"请输入交易单号查询")
    # 根据外部支付单号 找到唯一的支付订单
    orders = RechargeRecord.objects.filter(wxOrderNo = wxOrderNo, via = 'insurance')  # type: RechargeRecord

    dataList = list()
    for _order in orders:
        _insuranceOrder = InsuranceOrder.objects.get(rechargeRcdId = _order.id)

        _dealer = _insuranceOrder.dealer  # type: DealerDict
        _user = _insuranceOrder.user  # type: MyUser
        _group = _insuranceOrder.group  # type: GroupDict

        data = {
            "id": _insuranceOrder.id,
            "price": _insuranceOrder.money,
            "dealerName": "{}".format(_dealer["nickname"], _dealer["username"]),
            "devNo": _insuranceOrder.devNo,
            "groupName": _group.groupName,
            "logicalCode": _insuranceOrder.logicalCode,

            "openId": _insuranceOrder.openId,
            "userNickname": _user.nickname,

            "startTime": _insuranceOrder.startTime,
            "endTime": _insuranceOrder.endTime,
            "via": _order.via,

            "dateTimeAdded": _insuranceOrder.dateTimeAdded,

            "refunded": not bool(_insuranceOrder.effective)
        }

        dataList.append(data)

    return JsonOkResponse(payload = {"total": len(dataList), "dataList": dataList})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def refundInsuranceOrder(request):
    return JsonErrorResponse(u"保险产品已经下架")


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def setDealerMaxPackagePrice(request):
    payload = json.loads(request.body)
    dealerIds = payload.get('ids', [])
    maxPackagePrice = payload.get('maxPackagePrice', 1)

    if maxPackagePrice > 200:
        return JsonErrorResponse(description = u'套餐金额过大')

    if dealerIds == []:
        return JsonErrorResponse(description = u'未选择经销商')

    try:
        for _ in dealerIds:
            dealer = Dealer.objects(id = _).first()
            if dealer is None:
                continue
            dealer.maxPackagePrice = RMB(int(maxPackagePrice))
            dealer.save()
    except Exception as e:
        return JsonErrorResponse(description = u'未知错误')

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def lockDeviceSimStatus(request):
    payload = json.loads(request.body)
    logicalCodes = payload.get('logicalCode', [])

    if logicalCodes == []:
        return JsonErrorResponse(description = u'未选择设备')

    try:
        for _ in logicalCodes:
            device = Device.objects(logicalCode = _).first()
            if device is None:
                continue
            device.simStatus = u'updated'
            device.save()
            Device.invalid_device_cache(device.devNo)
    except Exception as e:
        return JsonErrorResponse(description = u'未知错误')

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def unlockDeviceSimStatus(request):
    payload = json.loads(request.body)
    logicalCodes = payload.get('logicalCode', [])

    if logicalCodes == []:
        return JsonErrorResponse(description = u'未选择设备')

    try:
        for _ in logicalCodes:
            device = Device.objects(logicalCode = _).first()
            if device is None:
                continue
            device.simStatus = u'chargedUnupdated'
            device.save()
            Device.invalid_device_cache(device.devNo)
    except Exception as e:
        return JsonErrorResponse(description = u'未知错误')

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def showDeviceDevTypes(request):
    payload = json.loads(request.body)
    logicalCodes = payload.get('logicalCode', [])

    if len(logicalCodes) != 1:
        return JsonErrorResponse(description = u'设备选择有误')
    logicalCode = logicalCodes[0]

    device = Device.objects(logicalCode = logicalCode).first()
    if device.ownerId == '':
        return JsonErrorResponse(description = u'设备未注册')

    dealer = Dealer.objects(id = device.ownerId).first()
    if dealer is None:
        return JsonErrorResponse(description = u'经销商不存在')

    agentId = dealer.agentId
    if agentId == '':
        return JsonErrorResponse(description = u'代理商不存在, 系统异常')

    dataList = [{
        'devTypeCode': _.code,
        'devTypeName': _.name,
        'devTypeId': str(_.id)
    } for _ in DeviceType.objects(agentId = agentId)]

    return JsonOkResponse(payload = {"total": len(dataList), "dataList": dataList})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.supermanager)
def changeDeviceDevType(request):
    payload = json.loads(request.body)
    logicalCodes = payload.get('logicalCode', [])
    devTypeId = payload.get('devTypeId', '')

    if len(logicalCodes) != 1:
        return JsonErrorResponse(description = u'设备选择有误')
    logicalCode = logicalCodes[0]
    device = Device.objects(logicalCode = logicalCode).first()
    devType = DeviceType.objects(id = devTypeId).first()

    try:
        Device.objects(logicalCode = logicalCode).update_one(upsert = False, **{'devType': devType.to_dict()})
    except Exception as e:
        return JsonErrorResponse(description = u'操作失败')
    finally:
        Device.invalid_device_cache(device.devNo)

    return JsonOkResponse()


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"查询失败"))
@permission_required(ROLE.supermanager)
def getApiAppInfo(request):
    """
        获取经销上API注册信息
    """

    dealerId = request.GET.get("dealerId")

    dealer = Dealer.objects(id=dealerId).first()
    if not dealer:
        logger.error('dealer<id={}> is not exists.'.format(dealerId))
        return JsonErrorResponse(description='经销商不存在')

    apiInfo = dealer.api_app # type: ApiAppInfo

    return JsonOkResponse(payload={
        'people': apiInfo.people,
        'tel': apiInfo.tel,
        'callbackUrl': apiInfo.callbackUrl,
        'apiDeviceMax': apiInfo.apiDeviceMax,
        'apiDevicePerCost': float(apiInfo.apiDevicePerCost)
    })


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"设置失败"))
@permission_required(ROLE.supermanager)
def editApiAppInfo(request):
    """
        编辑经销上API注册信息
    """

    def check_url(url):
        return re.match(r'^((https|http|ftp|rtsp|mms)?:\/\/)[^\s]+', url)

    payload = json.loads(request.body)

    dealerId = payload.get('dealerId')
    dealer = Dealer.objects(id=dealerId).first()
    if not dealer:
        logger.error('dealer<id={}> is not exists.'.format(dealerId))
        return JsonErrorResponse(description='经销商不存在')

    people = payload.get('people')
    tel = payload.get('tel')
    callbackUrl = payload.get('callbackUrl')
    apiDeviceMax = payload.get('apiDeviceMax')
    apiDevicePerCost = payload.get('apiDevicePerCost')

    if callbackUrl and not check_url(callbackUrl):
        return JsonErrorResponse(description='回调地址Url填写错误')

    if not isinstance(apiDeviceMax, int):
        return JsonErrorResponse(description='API配额参数错误')

    if not is_number(apiDevicePerCost):
        return JsonErrorResponse(description='配额单价参数错误')

    dealer.update_api_app(**{
        'people': people,
        'tel': tel,
        'callbackUrl': callbackUrl,
        'apiDeviceMax': apiDeviceMax,
        'apiDevicePerCost': apiDevicePerCost
    })

    return JsonOkResponse()


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"设置失败"))
@permission_required(ROLE.supermanager)
def setServiceButtonStatus(request):
    """
        设置个人中心正在服务的功能按钮展示
    """

    payload = json.loads(request.body)

    logicalCodes = payload.get('logicalCode', [])
    if len(logicalCodes) != 1:
        return JsonErrorResponse(description='设备数量错误')
    stopUsing = payload.get('stopUsing', None)
    continueToUse = payload.get('continueToUse', None)

    device = Device.objects(logicalCode=logicalCodes[0]).first()
    if device is None:
        return JsonErrorResponse(description='未知错误')

    deviceType = DeviceType.objects(id=device.devType['id']).first()
    if deviceType is None:
        return JsonErrorResponse(description='未知错误')

    if stopUsing is not None:
        deviceType.servicesButtonDict['stopUsing'] = stopUsing
        deviceType.save()

    if continueToUse is not None:
        deviceType.servicesButtonDict['continueToUse'] = continueToUse
        deviceType.save()

    return JsonOkResponse()


@error_tolerate(logger = logger, nil = JsonErrorResponse(u"获取经销商银行卡失败"))
@permission_required(ROLE.supermanager)
def getDealerBanks(request):
    dealerId = request.GET.get('dealerId')

    if not dealerId:
        return JsonErrorResponse(description = u'参数错误')

    dealer = Dealer.objects(id = dealerId).first()
    if not dealer:
        return JsonErrorResponse(description = u'经销商不存在，请刷新后再试')

    return JsonOkResponse(payload = {
        'dataList': [
            card.to_dict() for card in
            WithdrawBankCard.objects(ownerId = str(dealer.id), role = dealer.role).all()
        ]
    })


@error_tolerate(logger = logger, nil = JsonErrorResponse(u"保存经销商银行卡失败"))
@permission_required(ROLE.supermanager)
def saveDealerBankAccount(request):
    payload = json.loads(request.body)

    dealerId = payload.pop('dealerId', None)

    if not dealerId:
        return JsonErrorResponse(description = u'参数错误')

    dealer = Dealer.objects(id = dealerId).first()
    if not dealer:
        return JsonErrorResponse(description = u'经销商不存在，请刷新后再试')

    bank_card_id = payload.pop('id', None)

    try:
        payload = SaveWithdrawBankCardSchemaForSuper(payload)
    except MultipleInvalid as e:
        logger.exception(e)
        return JsonErrorResponse(description = u"信息不完整(1001)")

    isPublic = payload.pop('isPublic')

    if isPublic:
        try:
            payload = SavePublicWithdrawBankCardExtraSchema(payload)
        except MultipleInvalid as e:
            logger.exception(e)
            return JsonErrorResponse(description = u"信息不完整(1002)")

        branchBank = WithdrawBranchBanks.objects(
            code = payload['branchBankCode']).first()  # type: WithdrawBranchBanks
        if not branchBank:
            return JsonErrorResponse(description = u"查询不到支行信息")

        WithdrawBankCard.new_public_withdraw_bank_card(
            id = bank_card_id,
            ownerId = dealerId,
            role = ROLE.dealer,
            bankCode = payload['bankCode'],
            bankName = payload['bankName'],
            accountName = payload['accountName'],
            accountCode = payload['accountCode'],
            phone = payload.get('phone', ''),
            provinceCode = payload['provinceCode'],
            province = payload['province'],
            cityCode = payload['cityCode'],
            city = payload['city'],
            branchBankCode = branchBank.code,
            branchBankName = branchBank.name,
            cnapsCode = branchBank.cnapsCode)
    else:
        WithdrawBankCard.new_personal_withdraw_bank_card(
            id = bank_card_id,
            ownerId = dealerId,
            role = ROLE.dealer,
            phone = payload.get('phone', ''),
            bankName = payload['bankName'],
            accountName = payload['accountName'],
            accountCode = payload['accountCode'])

    return JsonOkResponse()


@error_tolerate(logger = logger, nil = JsonErrorResponse(u"删除经销商银行卡失败"))
@permission_required(ROLE.supermanager)
def deleteDealerBankAccount(request):
    payload = json.loads(request.body)

    bank_card_id = payload.get('id', None)

    if not bank_card_id:
        return JsonErrorResponse(description = u'参数错误')

    WithdrawBankCard.objects(id = bank_card_id).delete()

    return JsonOkResponse()