kodo/api/admin_views.py

# -*- coding: utf-8 -*-

from __future__ import division

import json
from collections import defaultdict
from datetime import datetime
from itertools import chain, groupby

from django.conf import settings
from django.db import transaction
from django.db.models import Count, Sum, Q
from django_logit import logit
from django_response import response
from paginator import pagination
from TimeConvert import TimeConvert as tc
from django.utils.timezone import utc

from account.models import UserInfo
from integral.models import SaleclerkSubmitLogInfo
from logs.models import MchInfoEncryptLogInfo
from coupon.models import UserCouponInfo
from mch.models import AdministratorInfo, ConsumeInfoSubmitLogInfo, ModelInfo, SaleclerkInfo
from statistic.models import (ConsumeModelSaleStatisticInfo, ConsumeSaleStatisticInfo, ConsumeUserStatisticInfo,
                              ModelSaleStatisticInfo)
from utils.error.errno_utils import (AdministratorStatusCode, ProductBrandStatusCode, ProductCouponStatusCode,
                                     ProductMachineStatusCode, UserStatusCode)


WECHAT = settings.WECHAT


@logit
def querysn(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    model_id = request.POST.get('model_id', '')
    sn = request.POST.get('sn', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    if not AdministratorInfo.objects.filter(admin_id=admin_id, admin_type=AdministratorInfo.MAINTENANCE, user_status=AdministratorInfo.ACTIVATED, status=True).exists():
        return response(AdministratorStatusCode.MAINTENANCE_NOT_FOUND)

    log = ConsumeInfoSubmitLogInfo.objects.filter(brand_id=brand_id, model_id=model_id, serialNo=sn, submit_during_activity=True, status=True).order_by('has_used', '-pk').first()

    if not log:
        log = ConsumeInfoSubmitLogInfo.objects.filter(brand_id=brand_id, model_id=model_id, serialNo=sn, status=True).order_by('-submit_during_activity', 'dupload').first()

    if not log:
        return response(ProductMachineStatusCode.SN_NOT_FOUND)

    return response(200, 'Query SN Success', u'查询序列号成功', data=log.data)


@logit
def queryusedsn(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    if not AdministratorInfo.objects.filter(admin_id=admin_id, admin_type=AdministratorInfo.MAINTENANCE, user_status=AdministratorInfo.ACTIVATED, status=True).exists():
        return response(AdministratorStatusCode.MAINTENANCE_NOT_FOUND)

    logs = ConsumeInfoSubmitLogInfo.objects.filter(brand_id=brand_id, admin_id=admin_id, has_used=True, status=True).order_by('-used_at')
    logs = [log.data for log in logs]

    return response(200, 'Query Used SN Success', u'查询核销序列号成功', data={
        'logs': logs,
    })


@logit
@transaction.atomic
def usecoupon(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    model_id = request.POST.get('model_id', '')
    sn = request.POST.get('sn', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    if not AdministratorInfo.objects.filter(
        admin_id=admin_id,
        admin_type=AdministratorInfo.MAINTENANCE,
        user_status=AdministratorInfo.ACTIVATED,
        status=True
    ).exists():
        return response(AdministratorStatusCode.MAINTENANCE_NOT_FOUND)

    log = ConsumeInfoSubmitLogInfo.objects.filter(
        brand_id=brand_id,
        model_id=model_id,
        serialNo=sn,
        submit_during_activity=True,
        has_used=False, 
        status=True
    ).first()
    if not log:
        return response(ProductMachineStatusCode.SN_NOT_FOUND)

    logdata = log.data
    if logdata.get('final_coupon_info', {}).get('coupon_has_expired', True):
        return response(ProductCouponStatusCode.COUPON_HAS_EXPIRED)

    log.has_used = True
    log.used_at = tc.utc_datetime()
    log.save()

    return response(200, 'Use Coupon Success', u'核销优惠券成功')


@logit
def userinfo(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    page = request.POST.get('page', 1)
    num = request.POST.get('num', 20)

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    userinfos = UserInfo.objects.filter(status=True).order_by('-created_at')
    count = userinfos.count()
    userinfos, left = pagination(userinfos, page, num)
    userinfos = [userinfo.admindata for userinfo in userinfos]

    return response(200, 'Userinfo Success', u'用户列表获取成功', data={
        'userinfos': userinfos,
        'count': count,
        'left': left,
    })


@logit
def query_usercoupons(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    user_id = request.POST.get('user_id', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    # 校验用户是否存在
    try:
        user = UserInfo.objects.get(user_id=user_id)
    except UserInfo.DoesNotExist:
        return response(UserStatusCode.USER_NOT_FOUND)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    coupons = UserCouponInfo.objects.filter(brand_id=administrator.brand_id, user_id=user_id, status=True).order_by('-created_at')
    coupons = [coupon.admindata for coupon in coupons]

    return response(200, 'User Coupon Success', u'用户劵列表获取成功', data={
        'coupons': coupons,
    })

@logit
def query_usergoods(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    user_id = request.POST.get('user_id', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    # 校验用户是否存在
    try:
        user = UserInfo.objects.get(user_id=user_id)
    except UserInfo.DoesNotExist:
        return response(UserStatusCode.USER_NOT_FOUND)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    logs = ConsumeInfoSubmitLogInfo.objects.filter(brand_id=administrator.brand_id, user_id=user_id, status=True).order_by('-created_at')
    logs = [log.adminuserdata for log in logs]

    return response(200, 'Userinfo Goods Success', u'用户商品列表获取成功', data={
        'logs': logs,
    })


@logit
def query_userinfo(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    query = request.POST.get('query', '')
    level = request.POST.get('level', '')
    is_member = request.POST.get('is_member', '')
    code_version = request.POST.get('code_version', 0)
    sex = request.POST.get('sex', '')
    subscribe = request.POST.get('subscribe', '')
    has_membercard = request.POST.get('has_membercard', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')
    page = request.POST.get('page', 1)
    num = request.POST.get('num', 20)

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    userinfos = UserInfo.objects.filter(Q(status=True) & (Q(user_id__icontains=query) | Q(nickname__icontains=query) | Q(phone__icontains=query))).order_by('-created_at')

    if level:
        userinfos = userinfos.filter(level=level)
    
    if code_version:
        userinfos = userinfos.filter(code_version=code_version)
    
    if subscribe:
        userinfos = userinfos.filter(subscribe=subscribe)
    
    if has_membercard:
        userinfos = userinfos.filter(has_membercard=has_membercard)
    
    if is_member:
        userinfos = userinfos.filter(level__gte=1)
    
    if sex:
        userinfos = userinfos.filter(sex=sex)
    
    if start_time and end_time:
        ftime = datetime.strptime(start_time + ' 00:00:00', '%Y%m%d %H:%M:%S')
        ttime = datetime.strptime(end_time + ' 23:59:59', '%Y%m%d %H:%M:%S')
        userinfos = userinfos.filter(created_at__range=[ftime, ttime])

    count = userinfos.count()
    userinfos, left = pagination(userinfos, page, num)
    userinfos = [userinfo.admindata for userinfo in userinfos]

    return response(200, 'Userinfo Success', u'用户列表获取成功', data={
        'userinfos': userinfos,
        'count': count,
        'left': left
    })


@logit
def userinfo_update(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    user_id = request.POST.get('user_id', '')
    integral = int(request.POST.get('integral', 0))

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    # 校验用户是否存在
    try:
        user = UserInfo.objects.get(user_id=user_id, status=True)
    except UserInfo.DoesNotExist:
        return response(UserStatusCode.USER_NOT_FOUND)

    user.integral = integral

    user.save()

    return response(200, 'Userinfo Update Success', u'修改用户信息成功', data={})


# 统计
def statistic_userprofile(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')
    model_name = request.POST.get('model_name', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    if model_name:
        logs = ConsumeModelSaleStatisticInfo.objects.filter(model_name=model_name, ymd__gte=start_time, ymd__lte=end_time)
    else:
        logs = ConsumeModelSaleStatisticInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time)

    sexs = {0: 0, 1: 0, 2: 0}
    subscribes = {0: 0, 1: 0}
    has_membercards = {0: 0, 1: 0}
    provinces = defaultdict(int)
    for log in logs:
        for user in log.users:
            try:
                user = UserInfo.objects.get(user_id=user, status=True)
            except UserInfo.DoesNotExist:
                continue

            provinces[user.province_name] += 1
            sexs[user.sex] += 1
            subscribes[user.subscribe] += 1
            has_membercards[user.has_membercard] += 1

    return response(200, 'Get User Profile Success', u'获取用户画像成功', data={
        'provinces': provinces,
        'sexs': sexs,
        'subscribe': subscribes,
        'has_membercards': has_membercards,
    })


def statistic_daily(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    sale_logs = ConsumeSaleStatisticInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time)
    user_logs = ConsumeUserStatisticInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time)

    sale_logs = [log.data for log in sale_logs]
    user_logs = [log.data for log in user_logs]

    return response(200, 'Get User Sales Statistic Success', u'获取销量统计成功', data={
        'sale_logs': sale_logs,
        'user_logs': user_logs,
    })


def statistic_model(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    logs = ConsumeModelSaleStatisticInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time).values_list('model_name').annotate(Sum('num'))

    logs = [{'model_name': log[0], 'num': log[1]} for log in logs]
    return response(200, 'Get Model Statistic Success', u'获取型号统计成功', data={
        'logs': logs
    })


def statistic_distributor(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')
    model_name = request.POST.get('model_name', '')
    distributor_name = request.POST.get('distributor_name', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    logs = SaleclerkSubmitLogInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time, distributor_name__contains=distributor_name, model_uni_name__contains=model_name, test_user=False, dupload=False, test_sn=False, status=True)

    daily_logs = list(logs.values('ymd').annotate(num=Count('pk')).order_by('ymd'))
    daily_code1_logs = list(logs.filter(code_version=1).values('ymd').annotate(num=Count('pk')).order_by('ymd'))
    daily_code1_hasScan_logs = list(logs.filter(code_version=1, has_scan=True).values('ymd').annotate(num=Count('pk')).order_by('ymd'))
    daily_code2_logs = list(logs.filter(code_version=2).values('ymd').annotate(num=Count('pk')).order_by('ymd'))
    daily_code2_hasScan_logs = list(logs.filter(code_version=2, has_scan=True).values('ymd').annotate(num=Count('pk')).order_by('ymd'))

    i1 = 0
    i2 = 0
    i3 = 0
    i4 = 0
    for i in range(0, len(daily_logs)):
        daily_logs[i]['code1'] = 0
        daily_logs[i]['code2'] = 0
        daily_logs[i]['has_code1_scan_num'] = 0
        daily_logs[i]['has_code2_scan_num'] = 0
        if i1 < len(daily_code1_hasScan_logs) and daily_logs[i]['ymd'] == daily_code1_hasScan_logs[i1]['ymd']:
            daily_logs[i]['has_code1_scan_num'] = daily_code1_hasScan_logs[i1]['num']
            i1 += 1

        if i2 < len(daily_code1_logs) and daily_logs[i]['ymd'] == daily_code1_logs[i2]['ymd']:
            daily_logs[i]['code1'] = daily_code1_logs[i2]['num']
            i2 += 1

        if i3 < len(daily_code2_logs) and daily_logs[i]['ymd'] == daily_code2_logs[i3]['ymd']:
            daily_logs[i]['code2'] = daily_code2_logs[i3]['num']
            i3 += 1

        if i4 < len(daily_code2_hasScan_logs) and daily_logs[i]['ymd'] == daily_code2_hasScan_logs[i4]['ymd']:
            daily_logs[i]['has_code2_scan_num'] = daily_code2_hasScan_logs[i4]['num']
            i4 += 1

    model_logs = list(logs.values('model_uni_name').annotate(num=Count('pk')).order_by('model_uni_name'))
    model_code1_logs = list(logs.filter(code_version=1).values('model_uni_name').annotate(num=Count('pk')).order_by('model_uni_name'))
    model_code1_hasScan_logs = list(logs.filter(code_version=1, has_scan=True).values('model_uni_name').annotate(num=Count('pk')).order_by('model_uni_name'))
    model_code2_logs = list(logs.filter(code_version=2).values('model_uni_name').annotate(num=Count('pk')).order_by('model_uni_name'))
    model_code2_hasScan_logs = list(logs.filter(code_version=2, has_scan=True).values('model_uni_name').annotate(num=Count('pk')).order_by('model_uni_name'))

    i1 = 0
    i2 = 0
    i3 = 0
    i4 = 0
    for i in range(0, len(model_logs)):
        model_logs[i]['code1'] = 0
        model_logs[i]['code2'] = 0
        model_logs[i]['has_code1_scan_num'] = 0
        model_logs[i]['has_code2_scan_num'] = 0
        if i1 < len(model_code1_hasScan_logs) and model_logs[i]['model_uni_name'] == model_code1_hasScan_logs[i1]['model_uni_name']:
            model_logs[i]['has_code1_scan_num'] = model_code1_hasScan_logs[i1]['num']
            i1 += 1

        if i2 < len(model_code1_logs) and model_logs[i]['model_uni_name'] == model_code1_logs[i2]['model_uni_name']:
            model_logs[i]['code1'] = model_code1_logs[i2]['num']
            i2 += 1

        if i3 < len(model_code2_logs) and model_logs[i]['model_uni_name'] == model_code2_logs[i3]['model_uni_name']:
            model_logs[i]['code2'] = model_code2_logs[i3]['num']
            i3 += 1

        if i4 < len(model_code2_hasScan_logs) and model_logs[i]['model_uni_name'] == model_code2_hasScan_logs[i4]['model_uni_name']:
            model_logs[i]['has_code2_scan_num'] = model_code2_hasScan_logs[i4]['num']
            i4 += 1

    model_logs.sort(key=lambda k: (-k['num']))

    distributor_logs = list(logs.values('distributor_name').annotate(num=Count('pk')).order_by('distributor_name'))
    distributor_code1_logs = list(logs.filter(code_version=1).values('distributor_name').annotate(num=Count('pk')).order_by('distributor_name'))
    distributor_code1_hasScan_logs = list(logs.filter(code_version=1, has_scan=True).values('distributor_name').annotate(num=Count('pk')).order_by('distributor_name'))
    distributor_code2_logs = list(logs.filter(code_version=2).values('distributor_name').annotate(num=Count('pk')).order_by('distributor_name'))
    distributor_code2_hasScan_logs = list(logs.filter(code_version=2, has_scan=True).values('distributor_name').annotate(num=Count('pk')).order_by('distributor_name'))

    i1 = 0
    i2 = 0
    i3 = 0
    i4 = 0
    for i in range(0, len(distributor_logs)):
        distributor_logs[i]['code1'] = 0
        distributor_logs[i]['code2'] = 0
        distributor_logs[i]['has_code1_scan_num'] = 0
        distributor_logs[i]['has_code2_scan_num'] = 0
        if i1 < len(distributor_code1_hasScan_logs) and distributor_logs[i]['distributor_name'] == distributor_code1_hasScan_logs[i1]['distributor_name']:
            distributor_logs[i]['has_code1_scan_num'] = distributor_code1_hasScan_logs[i1]['num']
            i1 += 1

        if i2 < len(distributor_code1_logs) and distributor_logs[i]['distributor_name'] == distributor_code1_logs[i2]['distributor_name']:
            distributor_logs[i]['code1'] = distributor_code1_logs[i2]['num']
            i2 += 1

        if i3 < len(distributor_code2_logs) and distributor_logs[i]['distributor_name'] == distributor_code2_logs[i3]['distributor_name']:
            distributor_logs[i]['code2'] = distributor_code2_logs[i3]['num']
            i3 += 1

        if i4 < len(distributor_code2_hasScan_logs) and distributor_logs[i]['distributor_name'] == distributor_code2_hasScan_logs[i4]['distributor_name']:
            distributor_logs[i]['has_code2_scan_num'] = distributor_code2_hasScan_logs[i4]['num']
            i4 += 1

    distributor_logs.sort(key=lambda k: (-k['num']))

    return response(200, 'Get Distributor Statistic Success', u'获取经销商统计成功', data={
        'daily_logs': daily_logs,
        'model_logs': model_logs,
        'distributor_logs': distributor_logs
    })


def dashboard(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    # 销售员统计
    sale_logs = SaleclerkSubmitLogInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time, test_user=False, dupload=False, test_sn=False, status=True)

    sale_count = sale_logs.count()

    sale_daily_logs = list(sale_logs.values('ymd').annotate(num=Count('pk')))

    sale_model_logs = list(sale_logs.values('model_uni_name').annotate(num=Count('pk')).order_by('-num'))[:10]

    sale_distributor_logs = list(sale_logs.values('distributor_name').annotate(num=Count('pk')).order_by('-num'))[:10]

    # 消费者统计
    logs = ConsumeInfoSubmitLogInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time, test_user=False, dupload=False, status=True)

    consumer_count = logs.count()

    consumer_daily_logs = list(logs.values('ymd').annotate(num=Count('pk')).order_by('ymd'))

    consumer_model_logs = list(logs.values('model_uni_name').annotate(num=Count('pk')).order_by('-num'))[:10]

    consumer_province_logs = list(logs.values('province').annotate(num=Count('pk')).order_by('-num'))[:10]

    return response(200, 'Get Distributor Statistic Success', u'获取经销商统计成功', data={
        'sale_daily_logs': sale_daily_logs,
        'sale_model_logs': sale_model_logs,
        'sale_distributor_logs': sale_distributor_logs,
        'consumer_daily_logs': consumer_daily_logs,
        'consumer_model_logs': consumer_model_logs,
        'consumer_province_logs': consumer_province_logs,
        'sale_count': sale_count,
        'consumer_count': consumer_count,
    })


def statistic_consumer(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    # 消费者统计
    logs = ConsumeInfoSubmitLogInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time, test_user=False, dupload=False, status=True)

    daily_logs = list(logs.values('ymd').annotate(num=Count('pk')).order_by('ymd'))
    daily_code1_logs = list(logs.filter(code_version=1).values('ymd').annotate(num=Count('pk')).order_by('ymd'))
    daily_code2_logs = list(logs.filter(code_version=2).values('ymd').annotate(num=Count('pk')).order_by('ymd'))

    j = 0
    k = 0
    for i in range(0, len(daily_logs)):
        daily_logs[i]['code1'] = 0
        daily_logs[i]['code2'] = 0
        if j < len(daily_code1_logs) and daily_logs[i]['ymd'] == daily_code1_logs[j]['ymd']:
            daily_logs[i]['code1'] = daily_code1_logs[j]['num']
            j += 1

        if k < len(daily_code2_logs) and daily_logs[i]['ymd'] == daily_code2_logs[k]['ymd']:
            daily_logs[i]['code2'] = daily_code2_logs[k]['num']
            k += 1

    model_logs = list(logs.values('model_uni_name').annotate(num=Count('pk')).order_by('model_uni_name'))
    model_code1_logs = list(logs.filter(code_version=1).values('model_uni_name').annotate(num=Count('pk')).order_by('model_uni_name'))
    model_code2_logs = list(logs.filter(code_version=2).values('model_uni_name').annotate(num=Count('pk')).order_by('model_uni_name'))

    j = 0
    k = 0
    for i in range(0, len(model_logs)):
        model_logs[i]['code1'] = 0
        model_logs[i]['code2'] = 0
        if j < len(model_code1_logs) and model_logs[i]['model_uni_name'] == model_code1_logs[j]['model_uni_name']:
            model_logs[i]['code1'] = model_code1_logs[j]['num']
            j += 1

        if k < len(model_code2_logs) and model_logs[i]['model_uni_name'] == model_code2_logs[k]['model_uni_name']:
            model_logs[i]['code2'] = model_code2_logs[k]['num']
            k += 1

    model_logs.sort(key=lambda k: (-k['num']))

    province_logs = list(logs.values('province').annotate(num=Count('pk')).order_by('province'))
    province_code1_logs = list(logs.filter(code_version=1).values('province').annotate(num=Count('pk')).order_by('province'))
    province_code2_logs = list(logs.filter(code_version=2).values('province').annotate(num=Count('pk')).order_by('province'))

    j = 0
    k = 0
    for i in range(0, len(province_logs)):
        province_logs[i]['code1'] = 0
        province_logs[i]['code2'] = 0
        if j < len(province_code1_logs) and province_logs[i]['province'] == province_code1_logs[j]['province']:
            province_logs[i]['code1'] = province_code1_logs[j]['num']
            j += 1

        if k < len(province_code2_logs) and province_logs[i]['province'] == province_code2_logs[k]['province']:
            province_logs[i]['code2'] = province_code2_logs[k]['num']
            k += 1

    province_logs.sort(key=lambda k: (-k['num']))

    return response(200, 'Get Consumer Statistic Success', u'获取消费者统计成功', data={
        'daily_logs': daily_logs,
        'model_logs': model_logs,
        'province_logs': province_logs,
    })

def statistic_member(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)

    # 消费者统计
    users = ConsumeInfoSubmitLogInfo.objects.filter(ymd__gte=start_time, ymd__lte=end_time, test_user=False, dupload=False, status=True).values('user_id').distinct()

    userinfos = UserInfo.objects.none()

    for user in users:
        userinfos |= UserInfo.objects.filter(user_id=user.get('user_id', ''))
    
    # 会员级别
    level_logs = list(userinfos.values('level').annotate(num=Count('user_id')))

    # 会员积分
    integral_logs = list(userinfos.values('integral').annotate(num=Count('user_id')))

    # 镜头数
    shot_logs = list(userinfos.values('shots_num').annotate(num=Count('user_id')))

    # 性别
    sex_logs = list(userinfos.values('sex').annotate(num=Count('user_id')))

    # 省份
    province_logs = list(userinfos.values('province_name').annotate(num=Count('user_id')).order_by('-num'))

    return response(200, 'Get Consumer Statistic Success', u'获取消费者统计成功', data={
        'level_logs': level_logs,
        'integral_logs': integral_logs,
        'shot_logs': shot_logs,
        'sex_logs': sex_logs,
        'province_logs': province_logs,
    })

def record_consumer(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    page = request.POST.get('page', 1)
    num = request.POST.get('num', 20)
    admin_id = request.POST.get('admin_id', '')
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')
    query = request.POST.get('query', '')
    dupload = request.POST.get('dupload', '')
    code_version = request.POST.get('code_version', 0)

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)
    
    logs = ConsumeInfoSubmitLogInfo.objects.filter(Q(status=True) & Q(test_user=False) & (Q(model_name__icontains=query) | Q(phone__icontains=query) | Q(serialNo__icontains=query))).order_by('-created_at')

    if dupload:
        logs = logs.filter(dupload=dupload)
    
    if code_version:
        logs = logs.filter(code_version=code_version)
    
    if start_time and end_time:
        logs = logs.filter(ymd__gte=start_time, ymd__lte=end_time)

    count = logs.count()
    logs, left = pagination(logs, page, num)
    logs = [log.admindata for log in logs]

    return response(200, 'Get Consumer Record Success', u'获取消费者销售记录成功', data={
        'logs': logs,
        'count': count,
        'left': left
    })

def record_sale(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    page = request.POST.get('page', 1)
    num = request.POST.get('num', 20)
    start_time = request.POST.get('start_time', '')
    end_time = request.POST.get('end_time', '')
    query = request.POST.get('query', '')
    dupload = request.POST.get('dupload', '')
    has_scan = request.POST.get('has_scan', '')
    code_version = request.POST.get('code_version', 0)
    is_online_sale = request.POST.get('is_online_sale', '')

    if brand_id != settings.KODO_DEFAULT_BRAND_ID:
        return response(ProductBrandStatusCode.BRAND_NOT_MATCH)

    try:
        administrator = AdministratorInfo.objects.get(admin_id=admin_id, user_status=AdministratorInfo.ACTIVATED, status=True)
    except AdministratorInfo.DoesNotExist:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_FOUND)
    
    logs = SaleclerkSubmitLogInfo.objects.filter(Q(status=True) & Q(test_user=False) & Q(test_sn=False) & (Q(model_name__icontains=query) | Q(clerk_name__icontains=query) | Q(distributor_name__icontains=query)| Q(code__icontains=query))).order_by('-created_at')

    if dupload:
        logs = logs.filter(dupload=dupload)
    
    if code_version:
        logs = logs.filter(code_version=code_version)
    
    if has_scan:
        logs = logs.filter(has_scan=has_scan)

    if start_time and end_time:
        logs = logs.filter(ymd__gte=start_time, ymd__lte=end_time)

    if is_online_sale:
        logs = logs.filter(remark=('扫描条形码' if is_online_sale == '1' else ''))
    

    count = logs.count()
    logs, left = pagination(logs, page, num)
    logs = [log.admindata for log in logs]

    return response(200, 'Get Sale Record Success', u'获取销售员销售记录成功', data={
        'logs': logs,
        'count': count,
        'left': left
    })