manyi/apps/web/management/views.py

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

"""
    web.management.views
    ~~~~~~~~~
"""
import datetime
import logging
import math
import os
import time,random
from collections import Counter
from itertools import groupby
from operator import itemgetter

import simplejson as json
import xlrd
from bson import ObjectId
from django.conf import settings
from django.contrib import auth
from django.core.cache import cache
from django.core.handlers.wsgi import WSGIRequest
from mongoengine import Q
from mongoengine.errors import NotUniqueError, MultipleObjectsReturned, DoesNotExist
from typing import Iterable, Any, cast, Dict, Optional, TYPE_CHECKING

from apilib import utils_datetime
from apilib.monetary import RMB, Ratio, Percent
from apilib.utils_datetime import to_datetime, dt_to_timestamp, date_to_datetime_ceiling, date_to_datetime_floor, \
    timestamp_timeformat
from apilib.utils_json import JsonResponse
from apps.web.ad.models import Advertisement, Advertiser
from apps.web.agent import api
from apps.web.agent.models import Agent
from apps.web.agent.validation import agentSchema
from apps.web.south_intf.zhejiang_fire import ZhejiangNorther, Company
from apps.web.common.models import FAQ, District, WithdrawRecord
from apps.web.common.proxy import ClientRechargeModelProxy, ClientDealerIncomeModelProxy, ClientConsumeModelProxy
from apps.web.common.transaction import WithdrawStatus
from apps.web.common.validation import PASSWORD_RE
from apps.web.constant import Const, DEALER_CONSUMPTION_AGG_KIND_TRANSLATION, \
    DEALER_CONSUMPTION_AGG_KIND_UNIT, DeviceOnlineStatus,FAULT_RECORD_STATUS
from apps.web.core import ROLE
from apps.web.core.db import prepare_query
from apps.web.core.exceptions import ServiceException, ManagerServiceTimeOutException, ManagerServiceSerialException
from apps.web.core.helpers import ActionDeviceBuilder
from apps.web.core.messages.sms import managerForgotPwdSMSProvider, \
    managerRegisterSMSProvider
from apps.web.core.models import WechatPayApp, OfflineTask, AliApp
from apps.web.core.networking import MessageSender
from apps.web.core.sysparas import SysParas
from apps.web.core.utils import DefaultJsonErrorResponse, JsonErrorResponse, JsonOkResponse
from apps.web.dealer.models import Dealer, DealerRechargeRecord
from apps.web.dealer.proxy import DealerIncomeProxy
from apps.web.device.models import Device, Group, DeviceCommand, DeviceType, PortReport, DeviceDict, \
    ManagerInputDev,FaultRecord
from apps.web.management import OfflineTaskType
from apps.web.management.models import ManagerUpScoreRecord, Manager, DummyManagerData
from apps.web.management.utils import get_dealerMap_by_managerId, query_total_dealer_income_top, get_feed_back_stats, \
    get_user_stats, query_device_consumption, query_device_income, query_user_consume_frequency
from apps.web.report.models import DeviceDailyStat
from apps.web.user.models import Card, MyUser, RechargeRecord, ServiceProgress, CardRechargeOrder, ConsumeRecord
from apps.web.utils import permission_required, manager_login, advertisement_login, error_tolerate, role_from_user
from taskmanager.mediator import task_caller

if TYPE_CHECKING:
    from apps.web.common.models import UserSearchable
    from apps.web.core.db import CustomQuerySet

logger = logging.getLogger(__name__)


def login(request):
    # type: (WSGIRequest)->JsonResponse
    try:
        payload = json.loads(request.body)
        username, password = payload['username'], payload['password']
        if Manager.objects(username = username, domain = settings.MY_DOMAIN).first():
            return manager_login(request, logger, username, password)
        elif Advertisement.objects(username = username).first():
            return advertisement_login(request, logger, username, password)
        else:
            return JsonResponse({'result': 0, 'description': u'用户名或者密码错误', 'payload': {}})
    except Exception as e:
        logger.exception('manager login error = %s' % e)
        return JsonResponse({'result': 0, 'description': u'登录异常', 'payload': {}})


def logout(request):
    # type: (WSGIRequest)->JsonResponse
    auth.logout(request)
    return JsonResponse({'result': 1})


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

    currentManager = request.user  # type: cast(Manager)
    payload = json.loads(request.body)
    password = payload['password']
    if PASSWORD_RE.match(password) is None:
        return JsonErrorResponse(description = u'密码必须大于8位，只能是数字或字母或常见特殊符号')
    currentManager.set_password(payload['password'])
    return JsonResponse({'result': 1})


#: 设备相关

@permission_required(ROLE.manager)
def getDevDetailList(request):
    # type: (WSGIRequest)->JsonResponse
    """
    获取设备详情列表
    searchKey只能是经销商账号, 设备逻辑码
    """
    mid = str(request.user.id)

    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    dealerId = request.GET.get('dealerId', None)
    startLogicalCode = request.GET.get('startLogicalCode', None)
    endLogicalCode = request.GET.get('endLogicalCode', None)

    searchKey = request.GET.get('searchKey', None)

    dealerFilter = Q()
    if not dealerId:
        agentIds = [str(agent['_id']) for agent in Agent.get_collection().find({'managerId': mid}, {'_id': True})]
        dealerFilter &= Q(agentId__in = agentIds)
    if dealerId:
        dealerFilter &= Q(id = ObjectId(dealerId))

    dealerMap = {str(d['_id']): {'nickname': d['nickname'], 'username': d['username']} for d in
                 Dealer.get_collection().find(dealerFilter.to_query(Dealer))}

    dealerIds = dealerMap.keys()

    if startLogicalCode and endLogicalCode and not searchKey:
        import re
        res = re.findall(r'\d+', '{},{}'.format(startLogicalCode, endLogicalCode))
        res = [int(res[0]), int(res[1])]
        if max(res) - min(res) > 1000:
            return JsonResponse({'result': 2, 'description': u'范围超过1000', 'payload': {}})
        start = min(res)
        logicalCode_user_input = []
        while start <= max(res):
            logicalCode_user_input.append(u'{}'.format(start))
            start += 1
        devices = Device.objects(ownerId__in = dealerIds, logicalCode__in = logicalCode_user_input)
        if len(devices) == 0:
            devices = Device.objects(ownerId__in = dealerIds)
            logicalCode_id = []
            for device in devices:
                if len(logicalCode_user_input):
                    dev = re.findall(logicalCode_user_input[0], '{}'.format(device.logicalCode))
                    if len(dev):
                        logicalCode_user_input.pop(0)
                        logicalCode_id.append(device.logicalCode)
            devices = Device.objects(ownerId__in = dealerIds, logicalCode__in = logicalCode_id)

    else:
        devices = Device.objects(ownerId__in = dealerIds).search(searchKey)

    total = devices.count()

    devNos = []
    groupIds = []
    for d in devices.paginate(pageIndex, pageSize):
        devNos.append(d['devNo'])
        if d['groupId']:
            groupIds.append(d['groupId'])

    groupDict = Group.get_groups_by_group_ids(groupIds)

    devs = Device.get_dev_by_nos(devNos)  # type: Optional[Dict[str, DeviceDict]]
    dataList = []
    for devNo, dev in devs.items():
        if dev.ownerId not in dealerIds:
            continue

        group = groupDict.get(dev.groupId, {})

        item = {
            'devName': dev.devNo,
            'devType': dev.devType.get('name', u'未指定'),
            'imei': dev.devNo,
            'createdTime': dev['dateTimeAdded'],
            'logicalCode': dev.logicalCode,
            'dealerName': '',
            'address': u'%s:%s' % (group.get('groupName'), group.get('address')),

            'online': u'在线' if dev.online == DeviceOnlineStatus.DEV_STATUS_ONLINE else u'离线',
            'detail': json.dumps(
                {
                    u'设备类型编码': dev.devType.get('code', ''),
                    u'设备驱动编码': dev.get('driverCode', ''),
                    u'设备驱动版本': dev.get('driverVersion', ''),
                    u'当前设备信号强度': dev.signal,
                    u'设备IMEI': dev.imsi,
                    u'设备SIM卡ICCID': dev.iccid,
                    u'心跳间隔': dev['cycle'],
                    u'脉冲间隔': dev['pulseInterval1'],
                    u'待机电平': dev['battery'],
                    u'备注': dev['remarks'],
                    u'sim卡过期时间': dev.formatSimExpireDate,
                    u'sim卡状态': dev.simStatus,
                    u'脉冲宽度': dev['pulseWidth1'],
                    u'套餐信息': dev.get('washConfig', {}),
                }, ensure_ascii = False, encoding = 'utf-8'),
            'lastOffTime': dev.offTime,
            'serverAddress': dev.server,
            'signal': dev.signal,
            "disableDevice": dev.get("otherConf", {}).get("disableDevice", False)
        }

        if dev.ownerId:
            item.update(
                {'dealerName': u'%s %s' % (dealerMap[dev.ownerId]['nickname'], dealerMap[dev.ownerId]['username'])})

        dataList.append(item)

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

@permission_required(ROLE.manager)
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)})


def setDevicePristine(request):
    """
    暂时不做，暂时不做解绑后防止代理商串货的限制
    厂商侧强制解绑，将设备恢复到只有基本绑定关系等初始值的初始状态
    :param request:
    :return:
    """
    # payload = json.loads(request.body)
    # check if the devices belong to this manager
    return JsonResponse({'result': 0})


#: 处理代理商
@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def addAgents(request):
    # type: (WSGIRequest)->JsonResponse
    """
    后台给代理商开户
    :param request:
    :return:
    """
    currentManager = request.user  # type: cast(Manager)

    primeAgent = Agent.objects(id = currentManager.primeAgentId).first()
    if not primeAgent:
        return JsonErrorResponse(description = u'厂商配置数据错误')

    payload = json.loads(request.body)

    payload.update(
        {
            'productName': currentManager.brandName,
            'productLogo': currentManager.logo,
            'managerId': str(currentManager.id)
        }
    )

    payload.update({'trafficCardCost': primeAgent.trafficCardCost})
    if 'annualTrafficCost' in payload and payload['annualTrafficCost']:
        if RMB(payload['annualTrafficCost']) < primeAgent.trafficCardCost:
            return JsonErrorResponse(description = u'代理商流量卡费用下限不能小于流量卡成本价格({})'.format(primeAgent.trafficCardCost))
        else:
            payload.update({'annualTrafficCost': RMB(payload['annualTrafficCost'])})
    else:
        payload.update({'annualTrafficCost': primeAgent.trafficCardCost})

    payload.update({'withdrawFeeRatioCost': primeAgent.withdrawFeeRatioCost})
    if 'withdrawFeeRatio' in payload and payload['withdrawFeeRatio']:
        if Ratio(payload['withdrawFeeRatio']) < primeAgent.withdrawFeeRatioCost:
            return JsonErrorResponse(
                description = u'代理商提现费率不能小于提现费率成本价格(千分之{})'.format(primeAgent.withdrawFeeRatioCost))
        else:
            payload.update({'withdrawFeeRatio': Ratio(payload['withdrawFeeRatio'])})
    else:
        payload.update({'withdrawFeeRatio': primeAgent.withdrawFeeRatio})

    username = payload.pop('username')
    password = payload.pop('password', '1234567')

    try:
        Agent.create_user(username = username,
                          password = password,
                          adShow = currentManager.adShow,
                          **payload)
    except NotUniqueError:
        return JsonErrorResponse(description = u'已存在相同信息的代理商')

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.manager)
def editAgents(request):
    # type: (WSGIRequest)->JsonResponse
    """
    修改代理商信息
    :param request:
    :return:
    """
    payload = agentSchema(json.loads(request.body))  # type: dict
    agent = Agent.objects(id = str(payload['id'])).get()  # type: Agent

    if 'annualTrafficCost' in payload and RMB(payload['annualTrafficCost']) < agent.trafficCardCost:
        return JsonErrorResponse(description=u'代理商流量卡费用下限不能小于流量卡成本价格({})'.format(agent.trafficCardCost))
    if 'withdrawFeeRatio' in payload and Ratio(payload['withdrawFeeRatio']) < agent.withdrawFeeRatioCost:
        return JsonErrorResponse(description=u'代理商提现费率下限不能低于提现费率成本价格(千分之{})'.format(agent.withdrawFeeRatioCost))
    if 'managerProfitShare' in payload and Percent(payload['managerProfitShare']) < Percent(0):
        return JsonErrorResponse(description=u"代理商设备经营收入比例不能小于0")

    updated = agent.update(**payload)

    if updated:
        return JsonOkResponse()
    else:
        return JsonErrorResponse(description = u'代理商设置失败')


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.manager)
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)  # type: Agent
        agent.set_password(password)

        return JsonResponse({'result': 1, 'description': u'修改成功', 'payload': ''})
    except DoesNotExist:
        return JsonResponse({'result': 0, 'description': u'代理商不存在，请刷新后再试', 'payload': ''})


@permission_required(ROLE.manager)
def getDealersWithdrawalList(request):
    # type: (WSGIRequest)->JsonResponse
    """
    获取经销商提现列表
    :param request:
    :return:
    """
    managerId = str(request.user.id)
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

    status = request.GET.get('status', None)
    searchKey = request.GET.get('searchKey', None)

    agentIds = [str(_['_id']) for _ in Agent.get_collection().find({'managerId': managerId}, {'_id': 1})]
    dealerIds = [str(_['_id']) for _ in Dealer.get_collection().find({'agentId': {'$in': agentIds}}, {'_id': 1})]

    query = WithdrawRecord.objects(ownerId__in = dealerIds, role = ROLE.dealer, status = int(status)).search(
        searchKey)._query

    front = (pageIndex - 1) if pageIndex >= 1 else 0
    records = WithdrawRecord.get_collection().find(query) \
        .sort('postTime', -1) \
        .skip(front * pageSize) \
        .limit(pageSize)  # type: Iterable[dict]

    total = WithdrawRecord.objects(status = int(status), ownerId__in = dealerIds).search(searchKey).count()

    def norm(dict_, key):
        # type: (dict, str)->Any
        return dict_.get(key, '')

    dataList = [
        {
            'name': norm(r, 'dealerName'),
            'tel': norm(r, 'userTel'),
            'dateTime': norm(r, 'postTime'),
            'orderNo': norm(r, 'order'),
            'actualPay': norm(r, 'actualPay'),
            'cardId': norm(r, 'accountCode'),
            'cardUserName': norm(r, 'cardUserName'),
            'bankName': norm(r, 'parentBankName'),
            'subBankName': norm(r, 'subBankName'),
            'operResult': norm(r, 'status'),
            'payType': norm(r, 'payType'),
            'amount': norm(r, 'dealerBalance'),
            'remarks': norm(r, 'remarks')
        }
        for r in records
    ]

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


@permission_required(ROLE.manager)
def suspendDealer(request):
    """
    对部分违反准则的经销商予以禁用
    :param request:
    :return:
    """
    return JsonErrorResponse(description = u'暂不支持')


@error_tolerate(logger = logger)
@permission_required(ROLE.manager)
def updateDeviceCardExpireDate(request):
    payload = json.loads(request.body)

    expireDate = str(payload['expireDate'])
    devNoList = payload['idList']

    newExpire = to_datetime(expireDate, '%Y-%m-%d')

    Device.get_collection().update_many({'devNo': {'$in': devNoList}}, {'$set': {'expireDate': newExpire}}, upsert = False)

    Device.invalid_many_device_cache(devNoList)

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


# third parties
def collectWechatSubscriptionChatEntries(request):
    # type: (WSGIRequest)->JsonResponse
    """
    备份用户发往公众号的聊天记录(微信只保留三天)，为了完整的追溯事件。有必要进行保留
    此接口对应微信推送的请求
    :param request:
    :return:
    """


def getNotificationList(request):
    # type: (WSGIRequest)->JsonResponse
    """
    管理平台获取公告列表
    :param request:
    :return:
    """
    return JsonResponse(
        {
            "result": 1,
            "description": None,
            'payload': {
                "total": 0,
                "dataList": []
            }
        }
    )


# TODO 工人管理
@permission_required(ROLE.manager)
def getStaffDetailList(request):
    # type: (WSGIRequest)->JsonResponse
    return JsonResponse(
        {
            'result': 0,
            'description': None,
            'payload': {
                'dataList': []
            }
        }
    )


# TODO 工人管理
@permission_required(ROLE.manager, ROLE.supermanager)
def getChargeList(request):
    # type: (WSGIRequest)->JsonResponse
    return JsonResponse(
        {
            'result': 1,
            'description': None,
            'payload': {
                'dataList': []
            }
        }
    )


# TODO 添加通告消息
@permission_required(ROLE.manager)
def addNotice(request):
    # type: (WSGIRequest)->JsonResponse
    return JsonResponse(
        {
            'result': 1,
            'description': None,
            'payload': {}
        }
    )


# TODO 修改通告消息
@permission_required(ROLE.manager)
def editNotice(request):
    # type: (WSGIRequest)->JsonResponse
    return JsonResponse(
        {
            'result': 1,
            'description': None,
            'payload': {}
        }
    )


# TODO 删除通告消息
@permission_required(ROLE.manager)
def deleteNotice(request):
    # type: (WSGIRequest)->JsonResponse
    return JsonResponse(
        {
            'result': 1,
            'description': None,
            'payload': {}
        }
    )


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


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


@permission_required(ROLE.manager)
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.manager)
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.manager)
def onPoints(request):
    # type: (WSGIRequest)->JsonResponse
    payload = json.loads(request.body)
    coins = int(payload['coins'])
    devNo = Device.get_devNo_by_logicalCode(payload['logicalCode'])

    if not devNo:
        return JsonResponse({'result': 0, 'description': u'设备号不存在'})

    dev = Device.get_dev(devNo)
    try:
        dealer = Dealer.objects.get(id = ObjectId(dev['ownerId']))
        agent = Agent.objects.get(id = ObjectId(dealer.agentId))
        if agent.managerId != str(request.user.id):
            return JsonResponse({'result': 0, 'description': u'该设备不属于您的厂家哦！', 'payload': {}})
    except (MultipleObjectsReturned, DoesNotExist) as e:
        logger.exception('cannot get agent or dealer, error = %s' % (e,))
        return JsonResponse({'result': 0, 'description': u'没有找到经销商和代理商数据', 'payload': {}})

    packageId = ''
    for pid, conf in dev['washConfig'].items():
        if int(conf['coins']) == coins:
            packageId = pid
            break
        continue
    if not packageId:
        return JsonResponse(
            {
                'result': 0,
                'description': u'没有找到对应的套餐信息，请您重新选择其他分值.或者检查设备是否没有注册到系统',
                'payload': {}
            }
        )

    smartBox = ActionDeviceBuilder.create_action_device(dev)
    try:
        smartBox.start(packageId)
    except ServiceException, e:
        logger.exception('start device(%s) failed error = %s' % (devNo, e.result.get('description')))
        return JsonResponse({'result': 0, 'description': e.result.get('description'), 'payload': {}})
    except Exception, e:
        logger.exception('start device(%s) failed error = %s' % (devNo, e))
        return JsonResponse({'result': 0, 'description': u'系统错误', 'payload': {}})

    dealer = Dealer.objects(id = dev['ownerId']).first()
    group = Group.get_group(dev['groupId'])
    record = ManagerUpScoreRecord(devNo = devNo,
                                  logicalCode = payload['logicalCode'],
                                  coins = coins,
                                  devTypeName = dev['devType']['name'],
                                  dealerTel = getattr(dealer, 'username', ''),
                                  dealerName = getattr(dealer, 'nickname', ''),
                                  address = group.get('address', ''),
                                  groupName = group['groupName'],
                                  managerId = str(request.user.id))

    record.save()

    return JsonResponse({'result': 1, 'description': u'上分成功!', 'payload': {}})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def onPointsRecords(request):
    # type: (WSGIRequest)->JsonResponse
    mid = str(request.user.id)
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    records = ManagerUpScoreRecord.objects(managerId = mid).order_by('-createdTime')
    return JsonResponse(
        {
            'result': 1,
            'description': '',
            'payload': {
                'total': records.count(),
                'dataList': [_.to_dict() for _ in records.skip((pageIndex - 1) * pageSize).limit(pageSize)]
            }
        })


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
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': ''})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def unlockDealer(request):
    # type: (WSGIRequest)->JsonResponse

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

    dealer = Dealer.objects.get(id = str(dealerId))
    dealer.unlock_login()

    return JsonResponse({'result': 1, 'description': u'解锁成功!'})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def unlockAgent(request):
    # type: (WSGIRequest)->JsonResponse

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

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

    return JsonResponse({'result': 1, 'description': u'解锁成功!'})


@permission_required(ROLE.manager, ROLE.advertiser, ROLE.advertisement)
def getCurrentUserInfo(request):
    # type: (WSGIRequest)->JsonResponse

    if request.user.is_authenticated():
        role = role_from_user(request.user)
        if role == ROLE.manager:
            manager = request.user  # type: Manager
        else:
            mid = request.user.managerId
            manager = Manager.objects.get(id = ObjectId(mid))  # type: Manager

        return JsonResponse(
            {
                "result": 1,
                "description": "",
                "payload":
                    {
                        "nickname": request.user.nickname,
                        "brandName": manager.brandName,
                        "feature_map": manager.feature_boolean_map,
                        "logo": manager.logo,
                        "role": role
                    }
            })

    else:
        return JsonResponse(
            {
                "result": 1,
                "description": "",
                "payload":
                    {
                        "nickname": "",
                        "brandName": "管理后台",
                        "logo": ""
                    }
            })


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def getManagerConfigs(request):
    # type: (WSGIRequest)->JsonResponse
    """
    获取厂商定向配置项
    :param request:
    :return:
    """
    return JsonResponse({'result': 1, 'description': '', 'payload': {'configs': request.user.configs}})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def setManagerConfigs(request):
    # type: (WSGIRequest)->JsonResponse
    """
    设置厂商定向配置项
    :param request:
    :return:
    """
    manager = request.user  # type: cast(MyUser)
    payload = json.loads(request.body)
    manager.set_configs(payload['params'])
    return JsonResponse({'result': 1, 'description': u'更新成功', 'payload': {}})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
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)
    # dataList = [ {'name': c.name, 'command': c.template.safe_substitute(IMEI=device['devNo'])} for c in commands ]
    return JsonResponse({'result': 1, 'description': None, 'payload': {'dataList': commands}})


############
#: 离线任务相关
############

@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def newOfflineTask(request):
    # type: (WSGIRequest)->JsonResponse
    """
    新建离线任务
    :param request:
    :return:
    """
    return JsonResponse({'result': 1, 'description': None, 'payload': {}})


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

    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.manager)
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)


#: 广告主相关
@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def getAdvertiserList(request):
    # type: (WSGIRequest)->JsonResponse
    """
    获取广告主列表
    :param request:
    :return:
    """
    managerId = str(request.user.id)
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))
    searchKey = request.GET.get('searchKey')
    activited = request.GET.get('activited')
    if activited:
        cursor = Advertiser.objects(managerId = managerId, activited = json.loads(activited))
    else:
        cursor = Advertiser.objects(managerId = managerId)

    total = cursor.count()

    advertisers = [_.to_dict() for _ in
                   cursor.search(searchKey).order_by('-dateTimeAdded').paginate(pageIndex, pageSize)]

    return JsonResponse({'result': 1, 'description': None, 'payload': {'total': total, 'dataList': advertisers}})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def addAdvertiser(request):
    # type: (WSGIRequest)->JsonResponse
    """
    管理员添加广告主
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    payload['managerId'] = str(request.user.id)
    try:
        Advertiser.create_user(**payload)
    except NotUniqueError:
        return JsonResponse({'result': 0, 'description': u'手机号已经存在'})
    return JsonResponse({'result': 1, 'description': None, 'payload': {}})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def editAdvertiser(request):
    # type: (WSGIRequest)->JsonResponse
    """
    编辑广告主
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    advertiser = Advertiser.objects(id = payload.pop('id')).get()  # type: Advertiser
    updated = advertiser.update(**payload)
    logger.info('{0!r} edited {1!r}, payload={2} updated={3}'.format(request.user, advertiser, payload, updated))
    return JsonResponse({'result': 1, 'description': u'编辑成功', 'payload': {}})

@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def toggleAdvertiserActivation(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    payload = json.loads(request.body)
    advertiser = Advertiser.objects(id = payload['id'], managerId = str(request.user.id)).first()

    if advertiser is None:
        return JsonResponse({'result': 0, 'description': u'广告主不存在'})

    updated = advertiser.update(activited = bool(payload['activited']))

    logger.info('{manager!r} toggled {advertiser!r} status from({old_value}) to ({new_value})  updated={updated}'
                .format(manager = request.user,
                        advertiser = advertiser,
                        old_value = advertiser.activited,
                        new_value = payload['activited'],
                        updated = updated))

    return JsonResponse({'result': 1, 'description': u'修改成功'})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def setAdvertiserQuota(request):
    # type: (WSGIRequest)->JsonResponse
    """
    厂商配置广告商效果额度
    :param request:
    :return:
    """
    payload = json.loads(request.body)
    advertiser = Advertiser.objects(id = payload['id'], managerId = str(request.user.id)).first()

    if advertiser is None:
        return JsonResponse({'result': 0, 'description': u'广告主不存在'})

    old_quota = advertiser.quota
    quota = int(payload['quota'])

    if quota < 0 or quota > Const.A_HUNDRED_MILLION:
        return JsonResponse({'result': 0, 'description': u'额度不合法，最小等于0，最大等于1亿'})

    updated = advertiser.update(quota = quota)

    logger.info('{manager!r} updated {advertiser!r} quota from({old_quota}) to ({new_quota})  updated={updated}'
                .format(manager = request.user,
                        advertiser = advertiser,
                        old_quota = old_quota,
                        new_quota = quota,
                        updated = updated))

    return JsonResponse({'result': 1, 'description': u'配置成功'})


@error_tolerate(nil = DefaultJsonErrorResponse)
# @permission_required(ROLE.manager)
def initCardsBalance(request):
    # type: (WSGIRequest)->JsonResponse
    payload = json.loads(request.body)
    startNo = payload['cardNoStart']
    endNo = payload['cardNoEnd']
    agentId = payload['agentId']
    balance = float(payload['money'])

    while int(endNo) >= int(startNo) > 0:
        try:
            Card.objects.filter(agentId = agentId, cardNo = str(startNo)).delete()
            newCard = Card(balance = balance, agentId = agentId, cardNo = str(startNo), cardType = 'ID')
            newCard.save()
        except Exception as e:
            logger.exception('initCardsBalance error=%s' % e)
            return JsonResponse({'result': 0, 'description': u'操作异常哦'})
        finally:
            startNo = int(startNo) + 1

    return JsonResponse({'result': 1, 'description': u'分配成功'})


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def getChargeSIMCardSettlementList(request):
    # type: (WSGIRequest)->JsonResponse
    managerId = str(request.user.id)
    startTime = datetime.datetime.strptime(request.GET.get('startTime') + ' 00:00:00', '%Y-%m-%d %H:%M:%S')
    endTime = datetime.datetime.strptime(request.GET.get('endTime') + ' 23:59:59', '%Y-%m-%d %H:%M:%S')
    agentId = request.GET.get('agentId', '')
    dealerId = request.GET.get('dealerId', '')

    if agentId == '' and dealerId == '':
        agentsIdList = [str(_['_id']) for _ in Agent.get_collection().find({'managerId': managerId}, {'_id': 1})]
        dealersIdList = [str(_['_id']) for _ in
                         Dealer.get_collection().find({'agentId': {'$in': agentsIdList}}, {'_id': 1})]
        simRechargeRecords = DealerRechargeRecord.objects(
            dealerId__in = dealersIdList,
            status = DealerRechargeRecord.PayState.Paid,
            finishedTime__gte = startTime,
            finishedTime__lte = endTime
        )

    elif agentId != '' and dealerId == '':
        dealersIdList = [str(_['_id']) for _ in Dealer.get_collection().find({'agentId': agentId}, {'_id': 1})]
        simRechargeRecords = DealerRechargeRecord.objects(
            dealerId__in = dealersIdList,
            status = DealerRechargeRecord.PayState.Paid,
            finishedTime__gte = startTime,
            finishedTime__lte = endTime
        )

    elif agentId != '' and dealerId != '':
        simRechargeRecords = DealerRechargeRecord.objects(
            dealerId = dealerId,
            status = DealerRechargeRecord.PayState.Paid,
            finishedTime__gte = startTime,
            finishedTime__lte = endTime
        )

    else:
        return JsonResponse({'result': 0, 'description': u'错误的查询方式'})

    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

    dataList = []
    for simRechargeRecord in simRechargeRecords.order_by('-finishedTime').paginate(pageIndex,
                                                                                   pageSize):  # type: DealerRechargeRecord
        dealer = Dealer.objects(id = simRechargeRecord.dealerId).first()
        if not dealer:
            return JsonResponse({'result': 0, 'description': u'该经销商用户不存在'})
        agent = Agent.objects(id = dealer.agentId).first()
        if not agent:
            return JsonResponse({'result': 0, 'description': u'该代理商用户不存在'})
        device = Device.objects(devNo = simRechargeRecord.items[0]['devNo']).first()
        if not device:
            return JsonResponse({'result': 0, 'description': u'该设备信息不存在'})

        try:
            sumPrice = simRechargeRecord.sum_of_price
        except Exception as e:
            continue

        item = {
            'orderNo': simRechargeRecord.orderNo,
            'dealerName': dealer.nickname,
            'dealerTel': dealer.username,
            'agentName': agent.nickname,
            'logicalCode': device.logicalCode,
            'devType': device.devTypeName,
            'dateTimeAdded': device.dateTimeAdded,
            'chargeMoney': sumPrice,
            'chargeTime': simRechargeRecord.to_js_timestamp(simRechargeRecord.finishedTime)
        }

        dataList.append(item)

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


@error_tolerate(nil = DefaultJsonErrorResponse)
@permission_required(ROLE.manager)
def getWithdrawSettlementList(request):
    # type: (WSGIRequest)->JsonResponse
    managerId = str(request.user.id)
    startTime = datetime.datetime.strptime(request.GET.get('startTime') + ' 00:00:00', '%Y-%m-%d %H:%M:%S')
    endTime = datetime.datetime.strptime(request.GET.get('endTime') + ' 23:59:59', '%Y-%m-%d %H:%M:%S')

    agentsIdList = [str(_['_id']) for _ in Agent.get_collection().find({'managerId': managerId}, {'_id': 1})]
    dealersIdList = [str(_['_id']) for _ in
                     Dealer.get_collection().find({'agentId': {'$in': agentsIdList}}, {'_id': 1})]
    withdrawRecords = WithdrawRecord.objects(
        ownerId__in = dealersIdList, role = ROLE.dealer,
        status = WithdrawStatus.SUCCEEDED,
        postTime__gte = startTime,
        postTime__lte = endTime
    )

    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

    dataList = []
    for withdrawRecord in withdrawRecords.order_by('-postTime').paginate(pageIndex, pageSize):  # type: WithdrawRecord
        dealer = Dealer.objects(id = withdrawRecord.ownerId).first()
        if not dealer:
            return JsonResponse({'result': 0, 'description': u'该经销商用户不存在'})

        payload = {
            'orderNo': withdrawRecord.order,
            'dealerName': dealer.nickname,
            'dealerTel': dealer.username,
            'withdrawMoney': withdrawRecord.amount,
            'withdrawTime': withdrawRecord.to_js_timestamp(withdrawRecord.postTime)
        }

        dataList.append(payload)

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


@error_tolerate(nil = JsonErrorResponse(u'生成报表失败'))
@permission_required(ROLE.manager)
def exportExcel(request):
    # type: (WSGIRequest)->JsonResponse
    manager = request.user  # type: cast(Manager)

    def get_offline_task_name(task_type, user, start_time, end_time):
        tmp_list = [task_type]
        tmp_list.append(user.username)
        tmp_list.append(u'%s至%s' % (start_time, end_time))
        tmp_list.append(str(utils_datetime.generate_timestamp_ex()))

        offline_task_name = '-'.join(tmp_list)

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

    query = prepare_query(request.GET)
    queryAttrs = query.attrs
    queryAttrs['managerId'] = str(manager.id)
    queryAttrs['dateTimeAdded__lte'] = dt_to_timestamp(queryAttrs['dateTimeAdded__lte'])
    queryAttrs['dateTimeAdded__gte'] = dt_to_timestamp(queryAttrs['dateTimeAdded__gte'])

    if queryAttrs['type'] == 'settlementChargeCard':
        task_type = OfflineTaskType.SIM_CHARGE
        process_func_name = 'generate_simCharge_excel_report'

    elif queryAttrs['type'] == 'settlementWithdraw':
        task_type = OfflineTaskType.DEALER_WITHDRAW
        process_func_name = 'generate_dealerWithDraw_excel_report'

    elif queryAttrs['type'] == 'chargeCard':
        task_type = OfflineTaskType.USER_RECHARGE_CARD
        process_func_name = 'generate_biz_stats_for_manager'

    elif queryAttrs['type'] == 'charge':
        task_type = OfflineTaskType.USER_RECHARGE
        process_func_name = 'generate_biz_stats_for_manager'

    elif queryAttrs['type'] == 'consumption':
        task_type = OfflineTaskType.CONSUME_ORDER_REPORT
        process_func_name = 'manager_export_consume_order_excel_from_db'

    else:
        return JsonErrorResponse(description = u'不支持的导出类型')

    offline_task_name = get_offline_task_name(
        task_type = task_type,
        user = manager,
        start_time = query.raw.get('startTime', ''),
        end_time = query.raw.get('endTime', ''))

    file_path, offline_task = OfflineTask.issue_export_report(offline_task_name = offline_task_name,
                                                              process_func_name = process_func_name,
                                                              task_type = task_type,
                                                              userid = str(manager.id),
                                                              role = ROLE.manager)

    task_caller(func_name = str(offline_task.process_func_name),
                offline_task_id = str(offline_task.id),
                filepath = file_path,
                queryAttrs = queryAttrs)

    return JsonResponse({
        'result': 1,
        'description': u'请前往离线任务查看任务处理情况',
        'payload': str(offline_task.id)
    })


@permission_required(ROLE.manager)
def getDevMapChart(request):
    # type: (WSGIRequest)->JsonResponse

    currentManager = request.user  # type: Manager

    agentIdList = [str(_['_id']) for _ in
                   list(Agent.get_collection().find({'managerId': str(currentManager.id)}, {'_id': 1}))]
    dealerIdList = [str(_['_id']) for _ in
                    list(Dealer.get_collection().find({'agentId': {'$in': agentIdList}}, {'_id': 1}))]

    if currentManager.supports('show_for_jiuheng'):
        devList = list(Device.get_collection().find(
            {'ownerId': {'$in': dealerIdList}, 'devType.code': {'$in': ['100206', '100224', '100202']}},
            {'_id': 0, 'devNo': 1, 'logicalCode': 1, 'cycle': 1, 'groupId': 1}
        ))
    else:
        devList = list(Device.get_collection().find(
            {'ownerId': {'$in': dealerIdList}},
            {'_id': 0, 'devNo': 1, 'logicalCode': 1, 'cycle': 1, 'groupId': 1}
        ))

    group_id_list = list(set([dev['groupId'] for dev in devList]))

    groups = Group.get_groups_by_group_ids(group_id_list)

    def get_province(pvc):
        if pvc == u'内蒙古自治区':
            pvc = u'内蒙古'
        elif pvc == u'黑龙江省':
            pvc = u'黑龙江'
        else:
            pvc = pvc[0:2]

        return pvc

    busy = 0
    online = 0
    offline = 0

    deviceDict = {}
    for _ in devList:
        deviceDict[_['devNo']] = {
            'logicalCode': _['logicalCode'],
            'cycle': _.get('cycle', Const.DEV_CYCLE_DEFAULT)
        }

        group = groups.get(_['groupId'])
        if not group:
            logger.error('{} has no group.'.format(_['devNo']))
            province = u'未知'
        else:
            distinct_id = group.get('districtId')
            if not distinct_id:
                logger.error('{} has no distinct_id.'.format(_['devNo']))
            else:
                district = District.get_district(distinct_id)
                if not district:
                    logger.error('distinct({}) of {} not exists.'.format(str(distinct_id), _['devNo']))
                    province = u'未知'
                else:
                    province = district.split(' ')[0]

        deviceDict[_['devNo']].update({'province': province})

    counter = {}

    for item in Device.get_many_device_status_cache(deviceDict).values():
        device = DeviceDict(item)  # type: DeviceDict

        if device.status == 1:
            busy += 1

        if device.online == 1:
            online += 1
        elif device.online == 0:
            offline += 1

        province = device['province']

        if province not in counter:
            counter[province] = 0

        counter[province] += 1

    dataList = [{'name': get_province(province), 'value': count} for province, count in counter.items()]
    
    if currentManager.id == ObjectId('59974b4b8732d6480fb699e5'):
        return JsonResponse({'result': 1, 'description': u"", 'payload': {
            "busy": int(offline*0.7),
            "online": offline,
            "offline": online-2000,
            "dataList": dataList
        }})
    else:
        return JsonResponse({'result': 1, 'description': u"", 'payload': {
            "busy": busy,
            "online": online,
            "offline": offline,
            "dataList": dataList
        }})

@permission_required(ROLE.manager)
def getAllDeviceIncomeList(request):
    # type: (WSGIRequest)->JsonResponse
    def fake_response():
        monthDataList = [{'lineCoins':90000,'payIncome':800000},{'lineCoins':90000,'payIncome':802000},{'lineCoins':90000,'payIncome':804000},
                     {'lineCoins':90000,'payIncome':806000},{'lineCoins':90000,'payIncome':808000},{'lineCoins':90000,'payIncome':810000},
                     {'lineCoins':90000,'payIncome':812000},{'lineCoins':90000,'payIncome':814000},{'lineCoins':90000,'payIncome':816000},
                     {'lineCoins':90000,'payIncome':818000},{'lineCoins':90000,'payIncome':820000},{'lineCoins':90000,'payIncome':822000},
                     {'lineCoins':90000,'payIncome':824000},{'lineCoins':90000,'payIncome':826000},{'lineCoins':90000,'payIncome':828000},
                     {'lineCoins':90000,'payIncome':830000},{'lineCoins':90000,'payIncome':832000},{'lineCoins':90000,'payIncome':834000},
                     {'lineCoins':90000,'payIncome':836000},{'lineCoins':90000,'payIncome':838000},{'lineCoins':90000,'payIncome':840000},
                     {'lineCoins':90000,'payIncome':842000},{'lineCoins':90000,'payIncome':844000},{'lineCoins':90000,'payIncome':846000},
                     {'lineCoins':90000,'payIncome':848000},{'lineCoins':90000,'payIncome':850000},{'lineCoins':90000,'payIncome':852000},
                     {'lineCoins':90000,'payIncome':854000},{'lineCoins':90000,'payIncome':856000},{'lineCoins':90000,'payIncome':858000},
                     ]
        nowTime = datetime.datetime.now()
        result = []
        for ii in range(30):
            result.append({'dateStr':(nowTime-datetime.timedelta(days=30-ii)).strftime('%Y-%m-%d'),'lineCoins':monthDataList[ii]['lineCoins']+random.randint(-2000,2000),'payIncome':monthDataList[ii]['payIncome']+random.randint(-10000,10000)})
        
        return JsonResponse({'result': 1, 'description': None, 'payload': {'dataList': result[::-1]}}) 
    
    if request.user.id == ObjectId('59974b4b8732d6480fb699e5'):
        return fake_response()
    
    data = cache.get('getAllDeviceIncomeList_%s' % request.user.id, None)
    if data is not None:
        return JsonResponse({'result': 1, 'description': None, 'payload': {'dataList': data}})
    else:
        
        
        currentManager = request.user  # type: Manager
 
        agentIdList = [str(_['_id']) for _ in
                       list(Agent.get_collection().find({'managerId': str(currentManager.id)}, {'_id': 1}))]
 
        dealerIdList = [str(_['_id']) for _ in
                        list(Dealer.get_collection().find({'agentId': {'$in': agentIdList}}, {'_id': 1}))]
 
        if currentManager.supports('show_for_jiuheng'):
            dealerIdList = [str(_) for _ in Device.get_collection().find(
                {'ownerId': {'$in': dealerIdList}, 'devType.code': {'$in': ['100206', '100224', '100202']}},
                {'ownerId': 1}).distinct('ownerId')]
 
        return JsonResponse(
            {'result': 1, 'description': None, 'payload': {'dataList': query_device_income(dealerIdList)}})
    
@permission_required(ROLE.manager)
def getAllDeviceConsumption(request):
    # type: (WSGIRequest)->JsonResponse
    def fake_response():
        result =[
                        {
                             'consumptionList':[{'unit':u'百万度','name':u'电量','value':14},{'unit':u'百万','name':u'金币','value':28}],
                             'dateStr':'2022-03'
                             },
                        {
                             'consumptionList':[{'unit':u'百万度','name':u'电量','value':10},{'unit':u'百万','name':u'金币','value':20}],
                             'dateStr':'2022-02'
                             },
                        {
                             'consumptionList':[{'unit':u'百万度','name':u'电量','value':15},{'unit':u'百万','name':u'金币','value':30}],
                             'dateStr':'2022-01'
                             },
                        {
                             'consumptionList':[{'unit':u'百万度','name':u'电量','value':15},{'unit':u'百万','name':u'金币','value':29}],
                             'dateStr':'2021-12'
                             },
                        {
                             'consumptionList':[{'unit':u'百万度','name':u'电量','value':14},{'unit':u'百万','name':u'金币','value':28}],
                             'dateStr':'2021-11'
                             },
                        {
                             'consumptionList':[{'unit':u'百万度','name':u'电量','value':14},{'unit':u'百万','name':u'金币','value':28}],
                             'dateStr':'2021-10'
                             }
                 ]
        
        return JsonResponse({'result': 1, 'description': None, 'payload': {'dataList': result}})
    
    if request.user.id == ObjectId('59974b4b8732d6480fb699e5'):
        return fake_response()
    
    data = cache.get('getAllDeviceConsumption_%s' % request.user.id, None)

    if data is not None:
        return JsonResponse({'result': 1, 'description': None, 'payload': {'dataList': data}})
    else:
        currentManager = request.user  # type: Manager

        agentIdList = [str(_['_id']) for _ in
                       list(Agent.get_collection().find({'managerId': str(currentManager.id)}, {'_id': 1}))]

        dealerIdList = [str(_['_id']) for _ in
                        list(Dealer.get_collection().find({'agentId': {'$in': agentIdList}}, {'_id': 1}))]

        if currentManager.supports('show_for_jiuheng'):
            dealerIdList = [str(_) for _ in Device.get_collection().find(
                {'ownerId': {'$in': dealerIdList}, 'devType.code': {'$in': ['100206', '100224', '100202']}},
                {'ownerId': 1}).distinct('ownerId')]

        return JsonResponse(
            {'result': 1, 'description': None, 'payload': {'dataList': query_device_consumption(dealerIdList)}})


@permission_required(ROLE.manager)
def getAllUserStatistics(request):
    # type: (WSGIRequest)->JsonResponse

    currentManager = request.user  # type: Manager

    if currentManager.supports('dummy_big_data'):
        item = DummyManagerData.objects(managerId = str(currentManager.id), dataKey = 'getAllUserStatistics').first()
        if item:
            return JsonResponse({'result': 1, 'description': None, 'payload': item.value})
        else:
            return JsonResponse({'result': 1, 'description': None, 'payload': {
                "userCount": 320232,
                "femaleCount": 37360,
                "maleCount": 224162,
                "todayActiveUsers": 24353
            }})

    data = cache.get('getAllUserStatistics_%s' % request.user.id, None)
    if data is not None:
        return JsonResponse({'result': 1, 'description': None, 'payload': data})
    else:
        agentIdList = [str(_['_id']) for _ in
                       list(Agent.get_collection().find({'managerId': str(currentManager.id)}, {'_id': 1}))]
        dealerIdList = [str(_['_id']) for _ in
                        list(Dealer.get_collection().find({'agentId': {'$in': agentIdList}}, {'_id': 1}))]

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


@permission_required(ROLE.manager)
def getAllFeedbackStatistics(request):
    # type: (WSGIRequest)->JsonResponse

    data = cache.get('getAllFeedbackStatistics_%s' % request.user.id, None)
    if data is not None:
        return JsonResponse({'result': 1, 'description': None, 'payload': data})

    else:
        currentManager = request.user  # type: cast(Manager)
        agentIdList = [str(_['_id']) for _ in
                       list(Agent.get_collection().find({'managerId': str(currentManager.id)}, {'_id': 1}))]
        dealerIdList = [str(_['_id']) for _ in
                        list(Dealer.get_collection().find({'agentId': {'$in': agentIdList}}, {'_id': 1}))]

        if currentManager.supports('show_for_jiuheng'):
            dealerIdList = [str(_) for _ in Device.get_collection().find(
                {'ownerId': {'$in': dealerIdList}, 'devType.code': {'$in': ['100206', '100224', '100202']}},
                {'ownerId': 1}).distinct('ownerId')]

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


@permission_required(ROLE.manager)
def getDealerIncomeTotalTop(request):
    # type: (WSGIRequest)->JsonResponse

    data = cache.get('getDealerIncomeTotalTop_%s' % request.user.id, None)
    if data is not None:
        return JsonResponse({'result': 1, 'description': None, 'payload': {'dataList': data}})

    else:
        currentManager = request.user  # type: cast(Manager)

        agentIdList = [str(_['_id']) for _ in
                       list(Agent.get_collection().find({'managerId': str(currentManager.id)}, {'_id': 1}))]

        dealerDict = {str(item['_id']): item['nickname'] for item in
                      Dealer.get_collection().find({'agentId': {'$in': agentIdList}}, {'_id': 1, 'nickname': 1})}

        if currentManager.supports('show_for_jiuheng'):
            dealerIdList = [str(_) for _ in Device.get_collection().find(
                {'ownerId': {'$in': dealerDict.keys()}, 'devType.code': {'$in': ['100206', '100224', '100202']}},
                {'ownerId': 1}).distinct('ownerId')]
            for dealerId in dealerIdList:
                dealerDict.pop(dealerId, None)

        return JsonResponse({
            'result': 1,
            'description': None,
            'payload': {'dataList': query_total_dealer_income_top(dealerDict)}})


@permission_required(ROLE.manager)
def getUserConsumeFrequency(request):
    # type: (WSGIRequest)->JsonResponse

    currentManager = request.user

    if currentManager.supports('dummy_big_data'):
        item = DummyManagerData.objects(managerId = str(currentManager.id), dataKey = 'getUserConsumeFrequency').first()
        if item:
            return JsonResponse({'result': 1, 'description': None, 'payload': item.value})
        else:
            return JsonResponse({'result': 1, 'description': None, 'payload': {
                'dataList': [
                    {"name": "1次", "percent": 10},
                    {"name": "2-5次", "percent": 20},
                    {"name": "5-10次", "percent": 30},
                    {"name": "10-20次", "percent": 30},
                    {"name": "20+次", "percent": 10}
                ]}})
    else:
        data = cache.get('getUserConsumeFrequency_%s' % request.user.id, None)
        if data is not None:
            return JsonResponse({'result': 1, 'description': None, 'payload': {'dataList': data}})
        else:
            agentIdList = [str(_['_id']) for _ in
                           list(Agent.get_collection().find({'managerId': str(currentManager.id)}, {'_id': 1}))]
            dealerIdList = [str(_['_id']) for _ in
                            list(Dealer.get_collection().find({'agentId': {'$in': agentIdList}}, {'_id': 1}))]

            return JsonResponse(
                {'result': 1, 'description': None, 'payload': {'dataList': query_user_consume_frequency(dealerIdList)}})


@permission_required(ROLE.manager)
def getDevBeingUsedTrend(request):
    # type: (WSGIRequest)->JsonResponse
    def fake_response():
        datalist = [{'devBeingUsed':50,'time':'00时'},{'devBeingUsed':50,'time':'01时'},{'devBeingUsed':49,'time':'02时'},
                  {'devBeingUsed':47,'time':'03时'},{'devBeingUsed':46,'time':'04时'},{'devBeingUsed':45,'time':'05时'},
                  {'devBeingUsed':39,'time':'06时'},{'devBeingUsed':35,'time':'07时'},{'devBeingUsed':30,'time':'08时'},
                  {'devBeingUsed':30,'time':'09时'},{'devBeingUsed':30,'time':'10时'},{'devBeingUsed':30,'time':'11时'},
                  {'devBeingUsed':28,'time':'12时'},{'devBeingUsed':30,'time':'13时'},{'devBeingUsed':33,'time':'14时'},
                  {'devBeingUsed':33,'time':'15时'},{'devBeingUsed':30,'time':'16时'},{'devBeingUsed':30,'time':'17时'},
                  {'devBeingUsed':30,'time':'18时'},{'devBeingUsed':39,'time':'19时'},{'devBeingUsed':45,'time':'20时'},
                  {'devBeingUsed':46,'time':'21时'},{'devBeingUsed':47,'time':'22时'},{'devBeingUsed':49,'time':'23时'}]
        return JsonResponse(
            {'result': 1, 'description': None, 'payload': {'___comment': '最近24小时内设备使用趋势图', 'dataList': datalist}})
    
    if request.user.id == ObjectId('59974b4b8732d6480fb699e5'):
        return fake_response()
    
    data = cache.get('getDevBeingUsedTrend_%s' % request.user.id, None)
    if data is not None:
        return JsonResponse(
            {'result': 1, 'description': None, 'payload': {'___comment': '最近24小时内设备使用趋势图', 'dataList': data}})
    else:
        currentManager = request.user
        
        agentIdList = [str(_['_id']) for _ in
                       list(Agent.get_collection().find({'managerId': str(currentManager.id)}, {'_id': 1}))]
        dealerIdList = [str(_['_id']) for _ in
                        list(Dealer.get_collection().find({'agentId': {'$in': agentIdList}}, {'_id': 1}))]
#         
             
        if currentManager.supports('show_for_jiuheng'):
            devList = list(Device.get_collection().find(
                {'ownerId': {'$in': dealerIdList}, 'devType.code': {'$in': ['100206', '100224', '100202']}},
                {'devNo': 1, 'groupId': 1, '_id': 0}
            ))
        else:
            devList = list(Device.get_collection().find(
                {'ownerId': {'$in': dealerIdList}},
                {'devNo': 1, 'groupId': 1, '_id': 0}
            ))
            
        devNoList = [_['devNo'] for _ in devList]

        # 找前一天的数据
        def get_hours_time(hoursStr):
            return time.mktime(to_datetime(
                (datetime.date.today() - datetime.timedelta(days = 1)).strftime('%Y-%m-%d') + hoursStr).timetuple())

        yesterdayBegin = get_hours_time(' 00:00:00')
        yesterdayEnd = get_hours_time(' 23:59:59')

        serviceProgress = list(ServiceProgress.get_collection().find(
            {'device_imei': {'$in': devNoList}, 'start_time': {'$gte': int(yesterdayBegin), '$lte': int(yesterdayEnd)}},
            {'_id': 0, 'start_time': 1}
        ))

        dataList = []
        for _ in range(24):
            if _ < 9:
                timeStr = '0' + str(_ + 1) + '时'
            else:
                timeStr = str(_ + 1) + '时'

            dataList.append({
                'time': timeStr,
                'devBeingUsed': 0
            })

        for svs in serviceProgress:
            for _ in range(24):
                if _ < 10:
                    timeStr = ' ' + '0' + str(_)
                else:
                    timeStr = ' ' + str(_)
                begin = timeStr + ':00:00'
                end = timeStr + ':59:59'

                if get_hours_time(begin) <= svs['start_time'] <= get_hours_time(end):
                    dataList[_]['devBeingUsed'] += 1

        return JsonResponse({'result': 1, 'description': None, 'payload': {
            "___comment": "最近24小时内设备使用趋势图",
            "dataList": dataList
        }})


@permission_required(ROLE.manager)
def getRechargeRecords(request):
    # type: (WSGIRequest)->JsonResponse
    """

    :param request:
    :return:
    """
    currentManager = request.user  # type: Manager
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

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

    startTime = date_to_datetime_floor(request.GET.get('startTime'))
    endTime = date_to_datetime_ceiling(request.GET.get('endTime'))

    dealerMap = get_dealerMap_by_managerId(managerId = currentManager.id, agentId = agentId, dealerId = dealerId)

    dealerIds = dealerMap.keys()

    originRecords = ClientRechargeModelProxy.get_data_list(
        startTime = startTime,
        endTime = endTime,
        ownerId__in = dealerIds,
        via = 'recharge',
        result = RechargeRecord.PayResult.SUCCESS)  # type: CustomQuerySet

    total = originRecords.count()
    records = originRecords.paginate(pageIndex = pageIndex, pageSize = pageSize)

    dataList = [
        {
            "orderNo": record.orderNo,
            "gatewayOrderNo": record.wxOrderNo,
            "userNickname": record.nickname,
            "dealerName": dealerMap[record.ownerId]['nickname'],
            "agentName": dealerMap[record.ownerId]['agentName'],
            "logicalCode": record.logicalCode,
            "devType": record.dev_type_name,
            "chargeMoney": record.money,
            "groupName": record.groupName,
            "chargeTime": record.to_js_timestamp(record.dateTimeAdded)
        }
        for record in records
    ]
    cache.set('getRechargeRecords_%s' % currentManager.id, originRecords, 60 * 60)
    return JsonOkResponse(payload = {'total': total, 'dataList': dataList})


@permission_required(ROLE.manager)
def getBusinessTrend(request):
    currentManager = request.user
    type = request.GET['type']
    if type == u'charge':
        cacheData = cache.get('getRechargeRecords_%s' % currentManager.id)
    elif type == u'consumption':
        cacheData = cache.get('getConsumptionRecord_%s' % currentManager.id)
    else:
        cacheData = None

    if cacheData is not None:
        timeData = [_.dateTimeAdded.strftime("%Y-%m-%d") for _ in cacheData]
        dataListTemp = [{'date': k, 'value': v} for k, v in Counter(timeData).items()]
        dataList = sorted(dataListTemp, key = lambda x: x['date'])
        return JsonOkResponse(payload = {'dataList': dataList})
    else:
        return JsonErrorResponse(u'数据缓存超时, 请重新查询订单')


@permission_required(ROLE.manager)
def getUserActivityTrend(request):
    currentManager = request.user
    type = request.GET['type']
    if type == u'charge':
        cacheData = cache.get('getRechargeRecords_%s' % currentManager.id)
    elif type == u'consumption':
        cacheData = cache.get('getConsumptionRecord_%s' % currentManager.id)
    else:
        cacheData = None

    if cacheData is not None:
        timeAndUserData = [{_.dateTimeAdded.strftime("%Y-%m-%d"): _.openId} for _ in cacheData]
        timeAndUserDataStr = list(set([json.dumps(_) for _ in timeAndUserData]))
        timeAndUserDataTemp = [json.loads(_).keys()[0] for _ in timeAndUserDataStr]
        dataListTemp = [{'date': k, 'value': v} for k, v in Counter(timeAndUserDataTemp).items()]
        dataList = sorted(dataListTemp, key = lambda x: x['date'])
        return JsonOkResponse(payload = {'dataList': dataList})
    else:
        return JsonErrorResponse(u'数据缓存超时, 请重新查询订单')


@permission_required(ROLE.manager)
def getConsumptionRecord(request):
    currentManager = request.user
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

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

    startTime = request.GET.get('startTime')
    endTime = request.GET.get('endTime')

    dealerMap = get_dealerMap_by_managerId(managerId = currentManager.id, agentId = agentId, dealerId = dealerId)

    dealerIds = dealerMap.keys()

    originRecords = ClientConsumeModelProxy.get_data_list(startTime = startTime,
                                                          endTime = endTime,
                                                          ownerId__in = dealerIds,
                                                          isNormal = True)  # type: CustomQuerySet

    total = originRecords.count()
    records = originRecords.paginate(pageIndex = pageIndex, pageSize = pageSize)

    dataList = [
        {
            "orderNo": record.orderNo,
            "userNickname": record.nickname,
            "dealerName": dealerMap[record.ownerId]['nickname'],
            "agentName": dealerMap[record.ownerId]['agentName'],
            "logicalCode": record.logicalCode,
            "devType": record.dev_type_name,
            "coins": record.coin,
            "groupName": record.groupName,
            "createdTime": record.to_js_timestamp(record.dateTimeAdded)
        }
        for record in records
    ]
    cache.set('getConsumptionRecord_%s' % currentManager.id, originRecords, 60 * 60)
    return JsonOkResponse(payload = {'total': total, 'dataList': dataList})


@permission_required(ROLE.manager)
def getRechargeCardRecords(request):
    # type: (WSGIRequest)->JsonResponse
    currentManager = request.user  # type: Manager
    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

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

    startTime = date_to_datetime_floor(request.GET.get('startTime'))
    endTime = date_to_datetime_ceiling(request.GET.get('endTime'))

    dealerMap = get_dealerMap_by_managerId(managerId = currentManager.id, agentId = agentId, dealerId = dealerId)

    dealerIds = dealerMap.keys()

    records = ClientRechargeModelProxy.get_data_list(
        startTime = startTime,
        endTime = endTime,
        ownerId__in = dealerIds,
        via = 'chargeCard',
        result = RechargeRecord.PayResult.SUCCESS)  # type: CustomQuerySet

    total = records.count()
    recordsByPage = records.paginate(pageIndex = pageIndex, pageSize = pageSize)

    dataList = []

    for record in recordsByPage:  # type: RechargeRecord

        order = CardRechargeOrder.get_by_rechargeRecord(record)

        entry = {
            "orderNo": record.orderNo,
            "gatewayOrderNo": record.wxOrderNo,
            "cardNo": order.cardNo if order else '',
            "userNickname": record.nickname,
            "dealerName": dealerMap[record.ownerId]['nickname'],
            "agentName": dealerMap[record.ownerId]['agentName'],
            "logicalCode": record.logicalCode,
            "chargeMoney": record.money,
            "groupName": record.groupName,
            "chargeTime": record.to_js_timestamp(record.dateTimeAdded) if order else ''
        }

        dataList.append(entry)

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


@permission_required(ROLE.manager)
def setAgentBanner(request):
    # type: (WSGIRequest)->JsonResponse
    payload = json.loads(request.body)

    agent = Agent.objects(id = str(payload['id'])).first()
    if not agent:
        return JsonErrorResponse(u'不存在的经销商')

    agent.bannerList = payload.get('bannerImgList', [])
    agent.save()

    return JsonOkResponse()


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

    toNumber = request.GET.get('username', '123456')

    manager = Manager.objects(username = toNumber).first()
    if not manager:
        return JsonErrorResponse(u'不存在的厂商')

    productName = manager.brandName

    status, msg = managerForgotPwdSMSProvider.get(phoneNumber = toNumber,
                                                  productName = productName,
                                                  vendor = SysParas.get_sms_vendor(manager.smsVendor))
    if not status:
        return JsonResponse({'result': 0, 'description': msg})
    else:
        return JsonResponse({'result': 1, 'description': ''})


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

    payload = json.loads(request.body)

    username = payload.get('username', None)
    code = payload.get('code', None)
    password = payload.get('password', '')

    manager = Manager.objects(username = username).first()
    while True:
        if manager is None:
            response = JsonErrorResponse(u'该手机号尚未注册，请注册后再进行操作')
            break

        if password == "":
            response = JsonErrorResponse(u"请输入密码")
            break

        status, desc = managerRegisterSMSProvider.verify(username, code)
        if not status:
            response = JsonErrorResponse(desc)
        else:
            manager.set_password(password)
            manager.unlock_login()
            response = JsonResponse({"result": 1, "description": None, "payload": {}})

        break

    return response


@error_tolerate(nil = DefaultJsonErrorResponse)
def editAgentZJFirePlatform(request):
    payload = json.loads(request.body)
    agentId = payload['id']
    northPort = ":".join([payload.get("northIp", ""), payload.get("northPort", "")])
    try:
        norther = ZhejiangNorther.objects.get(tokenId = agentId)
        norther.usernameFromHear = payload['loginUsername']
        norther.passwordFromHear = payload['loginPassword']
        norther.mqUser = payload['mqUsername']
        norther.mqPassword = payload['mqPassword']
        norther.serviceCodeFromNorth = payload['code']
        norther.northPort = northPort

    except Exception, e:
        norther = ZhejiangNorther(usernameFromHear = payload['loginUsername'],
                                  passwordFromHear = payload['loginPassword'],
                                  mqUser = payload['mqUsername'],
                                  mqPassword = payload['mqPassword'],
                                  serviceCodeFromNorth = payload['code'],
                                  tokenId = agentId,
                                  northPort = northPort)

    norther.save()

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse)
def editDealerZJFirePlatform(request):
    payload = json.loads(request.body)
    dealerId = payload['id']
    dealer = Dealer.objects.get(id = dealerId)
    try:
        company = Company.objects.get(ownerId = dealerId)
        company.name = payload['companyName']
        company.code = payload['companyCode']
        company.address = payload['companyAddress']
        company.contactName = payload['contactsName']
        company.telephone = payload['contactsTel']
        company.manufacturer = payload['deviceManufacturer']
        company.dateTimeUpdated = datetime.datetime.now()
    except Exception, e:
        company = Company(
            ownerId = payload['id'],
            agentId = dealer.agentId,
            name = payload['companyName'],
            code = payload['companyCode'],
            address = payload['companyAddress'],
            contactName = payload['contactsName'],
            telephone = payload['contactsTel'],
            manufacturer = payload['deviceManufacturer'],
            dateTimeAdded = datetime.datetime.now())

    company.save()

    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.manager)
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.manager)
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.manager)
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.manager)
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.manager)
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('Manager')
def getDeviceRealtimeData(request):
    # type: (WSGIRequest)->JsonResponse

    logicalCode = request.GET.get('logicalCode')
    port = request.GET.get('port')
    startTimeGet = request.GET.get('startTime')
    endTimeGet = request.GET.get('endTime')

    startTimeGet += ' 00:00:00'
    endTimeGet += ' 23:59:59'
    startTime = int(time.mktime(time.strptime(startTimeGet, "%Y-%m-%d %H:%M:%S")))
    endTime = int(time.mktime(time.strptime(endTimeGet, "%Y-%m-%d %H:%M:%S")))

    report = PortReport.get_collection().find({
        'time': {'$gte': startTime, '$lte': endTime},
        'logicalCode': logicalCode
    }).sort('time', 1)

    reportList = [i for i in report]
    listLength = len(reportList)

    responeData = {'dataList': []}

    if listLength < 1000:
        for _ in reportList:
            electricity = _['portInfo'].get(port)['electricity']
            portInfoDict = {
                "dateStr": timestamp_timeformat(_['time']),
                "voltage": 220,
                "electricity": electricity,
                "temperature": _['temperature'] if electricity else 0,
                "status": _['portInfo'].get(port)['status']
            }
            responeData['dataList'].append(portInfoDict)

    if listLength > 1000:
        index = math.ceil(listLength / 1000)
        for ii in range(1000):
            num = ii * int(index)
            for _ in reportList[num]:
                electricity = _['portInfo'].get(port)['electricity']
                portInfoDict = {
                    "dateStr": timestamp_timeformat(_['time']),
                    "voltage": 220,
                    "electricity": electricity,
                    "temperature": _['temperature'] if electricity else 0,
                    "status": _['portInfo'].get(port)['status']
                }
                responeData['dataList'].append(portInfoDict)

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

@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.manager)
def editDealer(request):
    payload = json.loads(request.body)
    username = payload.get('tel')
    nickname = payload.get('name')
    id = payload.get('id')
    dealer = Dealer.objects.get(id = id)
    dealer.username = username
    dealer.nickname = nickname
    dealer.save()
    return JsonOkResponse()


@error_tolerate(nil = DefaultJsonErrorResponse, logger = logger)
@permission_required(ROLE.manager)
def getIncomeOrderList(request):
    managerId = str(request.user.id)

    startDate = request.GET.get('startTime', '')
    endDate = request.GET.get('endTime', '')

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

    dealersIdList = []
    dealerDict = {}

    if agentId == '' and dealerId == '':
        agentDict = {}
        agentsIdList = []

        for agent in Agent.get_collection().find({'managerId': managerId}, {'_id': 1, 'username': 1, 'nickname': 1}):
            agentDict[str(agent['_id'])] = '%s %s' % (agent['nickname'], agent['username'])
            agentsIdList.append(str(agent['_id']))

        for dealer in Dealer.get_collection().find({'agentId': {'$in': agentsIdList}},
                                                   {'_id': 1, 'username': 1, 'nickname': 1, 'agentId': 1}):
            dealerDict[str(dealer['_id'])] = {'dealerName': '%s %s' % (dealer['nickname'], dealer['username']),
                                              'agentName': agentDict.get(dealer['agentId'], '')}
            dealersIdList.append(str(dealer['_id']))
    elif agentId != '' and dealerId == '':
        agents = Agent.get_collection().find({'_id': ObjectId(agentId)}, {'_id': 1, 'username': 1, 'nickname': 1})

        for dealer in Dealer.get_collection().find({'agentId': agentId},
                                                   {'_id': 1, 'username': 1, 'nickname': 1, 'agentId': 1}):
            dealerDict[str(dealer['_id'])] = {'dealerName': '%s %s' % (dealer['nickname'], dealer['username']),
                                              'agentName': '%s %s' % (agents[0]['nickname'], agents[0]['username'])}
            dealersIdList.append(str(dealer['_id']))

    elif agentId != '' and dealerId != '':
        agents = Agent.get_collection().find({'_id': ObjectId(agentId)}, {'_id': 1, 'username': 1, 'nickname': 1})
        dealers = Dealer.get_collection().find({'_id': ObjectId(dealerId)},
                                               {'_id': 1, 'username': 1, 'nickname': 1, 'agentId': 1})
        dealerDict[str(dealers[0]['_id'])] = {'dealerName': '%s %s' % (dealers[0]['nickname'], dealers[0]['username']),
                                              'agentName': '%s %s' % (agents[0]['nickname'], agents[0]['username'])}
        dealersIdList = [dealerId]
    else:
        return JsonResponse({'result': 0, 'description': u'错误的查询方式'})

    records = ClientRechargeModelProxy.get_data_list(startTime = startDate, endTime = endDate,
                                                     ownerId__in = dealersIdList, result = 'success',
                                                     via__nin = ['sendcoin', 'refund'])  # type: CustomQuerySet

    pageIndex = int(request.GET.get('pageIndex', 1))
    pageSize = int(request.GET.get('pageSize', 10))

    chargeTypeDict = {'recharge': u'扫码充值', 'sendcoin': u'赠币', 'refund': u'退币', 'chargeCard': u'卡充值'}

    total = records.count()
    dataList = []
    for rcd in records.paginate(pageIndex, pageSize):
        # 检查下如果是卡充值，就需要检查是否已经完成整个流程
        if rcd.via == 'chargeCard' and CardRechargeOrder.objects.filter(rechargeNo = rcd.id,
                                                                        status = 'finished').count() == 0:
            continue

        try:
            proxyRcd = ClientDealerIncomeModelProxy.get_one(ref_id = rcd.id,
                                                            groupId = rcd.groupId)  # type: DealerIncomeProxy

            user = MyUser.objects.filter(openId = rcd.openId).only('openId', 'nickname', 'sex', 'groupId').first()
            sex = ''
            if user.sex == 0:
                sex = u'女'
            elif user.sex == 1:
                sex = u'男'
            else:
                pass

        except Exception, e:
            continue

        amountDict = DealerIncomeProxy.get_agent_partner_amount(rcd.ownerId, proxyRcd.partition)

        data = {
            'id': str(rcd.id),
            'amount': proxyRcd.actualAmountMap.get(rcd.ownerId),
            'orderAmount': rcd.money,
            'agentShareAmount': amountDict.get('agentAmount', 0),
            'partnerShareAmount': amountDict.get('partnerAmount', 0),
            'tradeType': chargeTypeDict.get(rcd.via, '-'),
            'gateway': rcd.gateway,
            'status': rcd.result,
            'userNickname': user.nickname,
            'userGender': sex,
            'groupName': rcd.groupName,
            'logicalCode': rcd.logicalCode,
            'devTypeName': rcd.dev_type_name,
            'createTime': rcd.dateTimeAdded.strftime(Const.DATETIME_FMT),
            'gatewayTradeNo': rcd.orderNo,
            'outTradeNo': rcd.wxOrderNo,
            'agentName': dealerDict.get(rcd.ownerId, {}).get('agentName', ''),
            'dealerName': dealerDict.get(rcd.ownerId, {}).get('dealerName', '')
        }

        dataList.append(data)

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


def getConsumptionOrderList(request):
    pageIndex = int(request.GET.get('pageIndex'))
    pageSize = int(request.GET.get('pageSize'))
    managerId = str(request.user.id)

    startDate = request.GET.get('startTime', '')
    endDate = request.GET.get('endTime', '')

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

    dealerDict = {}
    dealersIdList = []

    if agentId == '' and dealerId == '':
        agentDict = {}
        agentsIdList = []
        for agent in Agent.get_collection().find({'managerId': managerId}, {'_id': 1, 'username': 1, 'nickname': 1}):
            agentDict[str(agent['_id'])] = '%s %s' % (agent['nickname'], agent['username'])
            agentsIdList.append(str(agent['_id']))

        for dealer in Dealer.get_collection().find({'agentId': {'$in': agentsIdList}},
                                                   {'_id': 1, 'username': 1, 'nickname': 1, 'agentId': 1}):
            dealerDict[str(dealer['_id'])] = {'dealerName': '%s %s' % (dealer['nickname'], dealer['username']),
                                              'agentName': agentDict.get(dealer['agentId'], '')}
            dealersIdList.append(str(dealer['_id']))

    elif agentId != '' and dealerId == '':
        agents = Agent.get_collection().find({'_id': ObjectId(agentId)}, {'_id': 1, 'username': 1, 'nickname': 1})
        for dealer in Dealer.get_collection().find({'agentId': agentId},
                                                   {'_id': 1, 'username': 1, 'nickname': 1, 'agentId': 1}):
            dealerDict[str(dealer['_id'])] = {'dealerName': '%s %s' % (dealer['nickname'], dealer['username']),
                                              'agentName': '%s %s' % (agents[0]['nickname'], agents[0]['username'])}
            dealersIdList.append(str(dealer['_id']))

    elif agentId != '' and dealerId != '':
        agents = Agent.get_collection().find({'_id': ObjectId(agentId)}, {'_id': 1, 'username': 1, 'nickname': 1})
        dealers = Dealer.get_collection().find({'_id': ObjectId(dealerId)},
                                               {'_id': 1, 'username': 1, 'nickname': 1, 'agentId': 1})
        dealerDict[str(dealers[0]['_id'])] = {'dealerName': '%s %s' % (dealers[0]['nickname'], dealers[0]['username']),
                                              'agentName': '%s %s' % (agents[0]['nickname'], agents[0]['username'])}
        dealersIdList = [dealerId]
    else:
        return JsonResponse({'result': 0, 'description': u'错误的查询方式'})

    records = ClientConsumeModelProxy.get_data_list(startTime = startDate,
                                                    endTime = endDate,
                                                    ownerId__in = dealersIdList,
                                                    isNormal = True)  # type: CustomQuerySet

    dataList = []

    for rcd in records.paginate(pageIndex, pageSize): # type:ConsumeRecord
        try:
            user = MyUser.objects.filter(openId = rcd.openId).only('openId', 'nickname', 'sex', 'groupId').first()
            if user is None:
                continue
            sex = ''
            if user.sex == 0:
                sex = u'女'
            elif user.sex == 1:
                sex = u'男'
            else:
                pass

        except Exception, e:
            continue

        desc = ' '
        for key, value in rcd.servicedInfo.items():
            if key not in DEALER_CONSUMPTION_AGG_KIND_TRANSLATION:
                continue
            desc += " %s:%s%s" % (
                DEALER_CONSUMPTION_AGG_KIND_TRANSLATION.get(key), value, DEALER_CONSUMPTION_AGG_KIND_UNIT.get(key))

        data = {
            'id': str(rcd.id),
            'createTime': rcd.created_date,
            'title': desc,
            'userNickname': user.nickname,
            'userGender': sex,
            'groupName': rcd.groupName,
            'logicalCode': rcd.logicalCode,
            'devTypeName': rcd.dev_type_name,
            'amount': rcd.coin,
            'agentName': dealerDict.get(rcd.ownerId, {}).get('agentName', ''),
            'dealerName': dealerDict.get(rcd.ownerId, {}).get('dealerName', '')
        }

        dataList.append(data)

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


@permission_required(ROLE.manager)
def exportIncomeOrderList(request):
    manager = request.user

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

        tmp_list = [task_type, user.username]

        if 'logicalCode' in kwargs and kwargs['logicalCode']:
            tmp_list.append(u'设备编号_%s' % (kwargs['logicalCode'],))

        if 'groupId' in kwargs and kwargs['groupId']:
            address = Group.get_group(kwargs['groupId']).get('address', '')
            tmp_list.append(u'地址_%s' % (address,))

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

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

    query_dict = {
        'startTime': request.GET.get('startTime', '') + ' 00:00:00',
        'endTime': request.GET.get('endTime', '') + ' 23:59:59',
        'managerId': str(manager.id),
        'agentId': request.GET.get('agentId', ''),
        'dealerId': request.GET.get('dealerId', '')
    }

    offline_task_name = get_offline_task_name(
        task_type = OfflineTaskType.CHARGE_ORDER_REPORT,
        user = manager,
        **query_dict)

    file_path, offline_task = OfflineTask.issue_export_report(offline_task_name = offline_task_name,
                                                              process_func_name = 'manager_export_charge_order_excel_from_db',
                                                              task_type = OfflineTaskType.CHARGE_ORDER_REPORT,
                                                              userid = str(manager.id),
                                                              role = ROLE.manager)

    logger.info('start making charge report=%s' % file_path)

    task_caller(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)
    })


@permission_required(ROLE.manager)
def exportConsumptionOrderList(request):
    manager = request.user

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

        tmp_list = [task_type, user.username]

        if 'logicalCode' in kwargs and kwargs['logicalCode']:
            tmp_list.append(u'设备编号_%s' % (kwargs['logicalCode'],))

        if 'groupId' in kwargs and kwargs['groupId']:
            address = Group.get_group(kwargs['groupId']).get('address', '')
            tmp_list.append(u'地址_%s' % (address,))

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

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

    query_dict = {
        'startTime': request.GET.get('startTime', '') + ' 00:00:00',
        'endTime': request.GET.get('endTime', '') + ' 23:59:59',
        'managerId': str(manager.id),
        'agentId': request.GET.get('agentId', ''),
        'dealerId': request.GET.get('dealerId', '')
    }

    offline_task_name = get_offline_task_name(
        task_type = OfflineTaskType.CONSUME_ORDER_REPORT,
        user = manager,
        **query_dict)

    file_path, offline_task = OfflineTask.issue_export_report(offline_task_name = offline_task_name,
                                                              process_func_name = 'manager_export_consume_order_excel_from_db',
                                                              task_type = OfflineTaskType.CONSUME_ORDER_REPORT,
                                                              userid = str(manager.id),
                                                              role = ROLE.manager)

    logger.info('start making consume report=%s' % file_path)

    task_caller(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)
    })


def inputLogicalCodes(logicalCodes, managerId):
    """
    录入的二维码保存数据库
    :param logicalCodes: 逻辑码 >>> list
    :param managerId: 厂商ID >>> str
    :return: JsonResponse
    """
    for l in logicalCodes:
        dev = Device.objects.filter(logicalCode = l).first()
        if not dev:
            return JsonResponse({'result': 0, 'description': u'无效的二维码编号'})

        if dev.is_registered:
            return JsonResponse({'result': 0, 'description': u'设备已经被注册！录入设备只能录入尚未注册的设备'})

        data = {
            "devNo": dev.devNo,
            "logicalCode": l,
            "managerId": managerId
        }

        try:
            ManagerInputDev.objects.create(**data)
        except Exception as e:
            logger.exception(e)
            return JsonResponse({'result': 0, 'description': u'注册设备出错！'})

    return JsonResponse({'result': 1, 'description': u'录入成功！'})


@permission_required(ROLE.manager)
def inputEquipment(request):
    """
    手动录入设备 只有厂商录入的设备 才能被旗下的经销商所绑定（温州郎鑫特性）
    :param request: WSGIRequest
    :return: JsonResponse
    """
    logicalCode = json.loads(request.body).get("logicalCode")
    if logicalCode is None:
        return JsonResponse({'result': 0, 'description': u'无效的二维码编号'})

    return inputLogicalCodes([logicalCode], str(request.user.id))


@permission_required(ROLE.manager)
def getInputEquipments(request):
    """
    获取厂商的录入设备列表（温州郎鑫特性）
    :param request: WSGIRequest
    :return: JsonResponse
    """
    pageIndex = int(request.GET.get("pageIndex", 1))
    pageSize = int(request.GET.get("pageSize", 10))
    managerId = str(request.user.id)

    queryset = ManagerInputDev.objects.filter(managerId = managerId)

    count = queryset.count()
    dataList = list()
    for item in queryset.skip((pageIndex - 1) * pageSize).limit(pageSize):
        dev = Device.get_dev(item.devNo)
        dealer = Dealer.get_dealer(dev.get("ownerId"))
        group = Group.get_group(dev.get("groupId"))

        tempData = {
            "id": str(item.id),
            "imei": item.devNo,
            "logicalCode": item.logicalCode,
            "devTypeName": dev.get("devType", {}).get('name'),
            "inputTime": item.inputTime,
            "createdTime": dev.get("dateTimeBinded"),
            "dealerName": dealer.get("nickname") if dealer else "",
            "dealerTel": dealer.get("username") if dealer else "",
            "groupName": group.get("groupName") if group else ""

        }
        dataList.append(tempData)

    payload = {
        "count": count,
        "dataList": dataList
    }

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


@permission_required(ROLE.manager)
def deleteInputEquipment(request):
    """
    删除厂商录入的设备（温州郎鑫特性）
    :param request: WSGIRequest
    :return: JsonResponse
    """
    logicalCodes = json.loads(request.body).get("logicalCode")
    managerId = str(request.user.id)

    for logicalCode in logicalCodes:
        equip = ManagerInputDev.objects.filter(logicalCode = logicalCode, managerId = managerId)
        if not equip:
            return JsonResponse({'result': 0, 'description': u'未查找到设备'})
        dev = Device.get_dev_by_l(logicalCode)
        if not dev:
            return JsonResponse({'result': 0, 'description': u'未查找到设备'})

        if dev.is_registered:
            return JsonResponse({'result': 0, 'description': u'设备已经被经销商注册，不能删除'})

    try:
        ManagerInputDev.objects.filter(logicalCode__in = logicalCodes).delete()
    except Exception as e:
        logger.exception(e)
        return JsonResponse({'result': 0, 'description': u'删除设备错误'})

    return JsonResponse({'result': 1, 'description': u'删除成功'})


@permission_required(ROLE.manager)
def uploadLogicalExcel(request):
    """
    上传logical文件
    :param request:
    :return:
    """
    files = request.FILES.getlist('file')
    if not len(files):
        return JsonResponse({'result': 1, 'description': u'未知的逻辑码文件，请重新试试', 'payload': ''})

    logicalFile = request.FILES.getlist('file')[0]
    ext = os.path.splitext(logicalFile.name)[1]

    if ext not in (".xls", ".xlsx"):
        return JsonErrorResponse(description = u"上传失败，请重新上传excel文件！")

    tempFile = xlrd.open_workbook(file_contents = logicalFile.read())
    sh = tempFile.sheet_by_index(0)
    logicalCodes = sh.row_values(0)

    new_codes = list()
    try:
        for l in logicalCodes:
            new_codes.append(str(int(l)))
    except Exception as e:
        logger.exception(e)

    return inputLogicalCodes(new_codes, str(request.user.id))


@error_tolerate(logger = logger, nil = JsonErrorResponse(u'禁用设备失败'))
@permission_required(ROLE.manager)
def disableDevice(request):
    """
    厂商禁用设备 昌源需求 下发协议到设备 设备端锁死
    :param request:
    :return:
    """

    payload = json.loads(request.body)

    logicalcode_list = payload.get('logicalCode')
    disable = payload.get('disable')

    for logicalCode in logicalcode_list:
        dev = Device.get_dev_by_logicalCode(logicalCode)  # type: DeviceDict
        if not dev:
            logger.error(u'device with logicalCode<{}> is not exists.'.format(logicalCode))
            return JsonErrorResponse(description = u'逻辑码{}对应的设备不存在'.format(logicalCode))

        dealer = Dealer.objects(id = dev.ownerId).first()  # type: Dealer
        if not dealer:
            logger.error(u'this device<{}> has invalid owner id<>'.format(repr(dev), dev.ownerId))
            return JsonErrorResponse(description = u'逻辑码{}对应的设备经销商不存在'.format(logicalCode))

        agent = Agent.objects(id = dealer.agentId).first()  # type: Agent
        if not agent:
            logger.error(u'this device<{}> has invalid agent id<>'.format(repr(dev), dealer.agentId))
            return JsonErrorResponse(description = u'逻辑码{}对应的设备代理商不存在'.format(logicalCode))

        if agent.managerId != str(request.user.id):
            return JsonErrorResponse(description = u'该设备不属于您的厂家哦！')

        try:
            smartBox = ActionDeviceBuilder.create_action_device(dev)
            smartBox.set_dev_disable(disable)

            Device.objects.filter(devNo = dev.devNo).update(otherConf__disableDevice = disable)

            Device.invalid_device_cache(dev.devNo)
        except ServiceException as e:
            logger.exception('disable device({}) failed error = {}'.format(repr(dev), e.result.get('description')))
            return JsonErrorResponse(description = u'禁用{}失败'.format(logicalCode))

    return JsonOkResponse(description = u"操作成功")


@error_tolerate(logger = logger, nil = JsonErrorResponse(u'禁用设备失败'))
@permission_required(ROLE.manager)
def disableAllDevice(request):
    """
    厂商禁用设备 昌源需求 下发协议到设备 设备端锁死
    :param request:
    :return:
    """

    payload = json.loads(request.body)

    dealer_id = payload.get('dealerId')
    disable = payload.get('disable')

    dealer = Dealer.objects(id = dealer_id).first()  # type: Dealer
    if not dealer:
        return JsonErrorResponse(description = u'备经销商不存在')

    agent = Agent.objects(id = dealer.agentId).first()  # type: Agent
    if not agent:
        return JsonErrorResponse(description = u'代理商不存在')

    if agent.managerId != str(request.user.id):
        return JsonErrorResponse(description = u'该设备不属于您的厂家哦！')

    dev_no_list = [item['devNo'] for item in
                   Device.get_collection().find({'ownerId': dealer_id}, {'_id': 0, 'devNo': 1})]
    devices = Device.get_dev_by_nos(dev_no_list)
    for dev in devices.values():
        try:
            smartBox = ActionDeviceBuilder.create_action_device(dev)
            smartBox.set_dev_disable(disable)

            Device.objects.filter(devNo = dev.devNo).update(otherConf__disableDevice = disable)

            Device.invalid_device_cache(dev.devNo)
        except ServiceException as e:
            logger.exception('disable device({}) failed error = {}'.format(repr(dev), e.result.get('description')))
            return JsonErrorResponse(description = u'禁用{}失败'.format(dev.devNo))

    return JsonOkResponse(description = u"操作成功")


@error_tolerate(logger = logger, nil = JsonErrorResponse(u"授权失败"))
@permission_required(ROLE.manager)
def dealerDisableDevice(request):
    """
    授权经销商 能否进行禁用设备操作
    :param request:
    :return:
    """
    dealerId = request.GET.get("id", "")
    grant = json.loads(request.GET.get("disable"))

    dealer = Dealer.objects.filter(id = dealerId).first()
    if not dealer:
        return JsonErrorResponse(description = u"无有效的经销商")

    features = dealer.features
    if grant:
        features.append("dealerDisableDevice")
    else:
        try:
            features.remove("dealerDisableDevice")
        except ValueError:
            pass

    Dealer.objects.filter(id = dealerId).update(features = features)
    cache.delete(Dealer.cache_key(dealerId))

    return JsonOkResponse(description = u"操作成功")


@permission_required(ROLE.manager)
def exportDealerDetailList(request):
    def get_offline_task_name(task_type, user, **kwargs):
        # type: (basestring, Dealer, Dict)->basestring

        tmp_list = [task_type, user.username]

        tmp_list.append(str(utils_datetime.generate_timestamp_ex()))

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

    manager = request.user
    query_dict = {"mid": str(request.user.id)}
    offline_task_name = get_offline_task_name(
        task_type = OfflineTaskType.DEALER_INFO_REPORT,
        user = manager,
        **query_dict)

    file_path, offline_task = OfflineTask.issue_export_report(offline_task_name = offline_task_name,
                                                              process_func_name = 'manager_export_dealer_info_excel_from_db',
                                                              task_type = OfflineTaskType.DEALER_INFO_REPORT,
                                                              userid = str(manager.id),
                                                              role = ROLE.manager)
    logger.info('start making charge report=%s' % file_path)

    task_caller(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)
    })