kodo/api/admin_views.py

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

from __future__ import division

import json
from collections import defaultdict
from datetime import datetime

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

from account.models import UserInfo
from api.encrypt_views import get_ciphertext
from coupon.models import CouponInfo, UserCouponInfo
from integral.models import SaleclerkSubmitLogInfo
from logs.models import ComplementCodeLogInfo, MchInfoEncryptLogInfo
from mch.models import AdministratorInfo, BrandInfo, ConsumeInfoSubmitLogInfo, DistributorInfo, ModelInfo
from member.models import (GoodsInfo, GoodsOrderInfo, MemberActivityGroupShareInfo, MemberActivityInfo,
                           MemberActivitySignupInfo)
from pre.custom_message import sendtemplatemessage, sendwxasubscribemessage
from statistic.models import ConsumeModelSaleStatisticInfo, ConsumeSaleStatisticInfo, ConsumeUserStatisticInfo
from utils.error.errno_utils import (AdministratorStatusCode, ComplementCodeStatusCode, 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('-pk')
    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('-pk')
    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', '')
    dupload = request.POST.get('dupload', '')

    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('-pk')

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

    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', '')
    province = request.POST.get('province', '')
    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) | Q(memberusercardcode__icontains=query))).order_by('-pk')

    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 province:
        userinfos = userinfos.filter(province_name=province)

    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
@transaction.atomic
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.select_for_update().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)

    daily_sql = 'select id, Count(*) AS num, Count(code_version=1 or NULL) AS code1 , Count(code_version=2 or NULL) AS code2, Count((code_version=1 AND has_scan=True) or NULL) AS has_code1_scan_num, Count((code_version=2 AND has_scan=True) or NULL) AS has_code2_scan_num FROM integral_saleclerksubmitloginfo where ymd >= %s AND ymd <= %s AND test_user=False AND dupload=False AND test_sn=False AND status=True %s %s GROUP BY ymd;' % (start_time, end_time, ('AND model_uni_name="%s"' % (model_name)) if model_name else '', ('AND distributor_name="%s"' % (distributor_name)) if distributor_name else '')
    daily_logs = SaleclerkSubmitLogInfo.objects.raw(daily_sql)

    daily_logs = [{'ymd': log.ymd, 'num': log.num, 'code1': log.code1, 'code2': log.code2, 'has_code1_scan_num': log.has_code1_scan_num, 'has_code2_scan_num': log.has_code2_scan_num} for log in daily_logs]

    model_logs = []
    if model_name == '':
        model_sql = 'select id, model_uni_name, Count(*) AS num, Count(code_version=1 or NULL) AS code1 , Count(code_version=2 or NULL) AS code2, Count((code_version=1 AND has_scan=True) or NULL) AS has_code1_scan_num, Count((code_version=2 AND has_scan=True) or NULL) AS has_code2_scan_num FROM integral_saleclerksubmitloginfo where ymd >= %s AND ymd <= %s AND test_user=False AND dupload=False AND test_sn=False AND status=True %s GROUP BY model_uni_name;' % (start_time, end_time, ('AND distributor_name="%s"' % (distributor_name)) if distributor_name else '')

        model_logs = SaleclerkSubmitLogInfo.objects.raw(model_sql)
        model_logs = [{'model_uni_name': log.model_uni_name, 'num': log.num, 'code1': log.code1, 'code2': log.code2, 'has_code1_scan_num': log.has_code1_scan_num, 'has_code2_scan_num': log.has_code2_scan_num} for log in model_logs]

    distributor_logs = []
    if distributor_name == '':
        distributor_sql = 'select id, distributor_name, Count(*) AS num, Count(code_version=1 or NULL) AS code1 , Count(code_version=2 or NULL) AS code2, Count((code_version=1 AND has_scan=True) or NULL) AS has_code1_scan_num, Count((code_version=2 AND has_scan=True) or NULL) AS has_code2_scan_num FROM integral_saleclerksubmitloginfo where ymd >= %s AND ymd <= %s AND test_user=False AND dupload=False AND test_sn=False AND status=True %s GROUP BY distributor_name;' % (start_time, end_time, ('AND model_uni_name="%s"' % (model_name)) if model_name else '')

        distributor_logs = SaleclerkSubmitLogInfo.objects.raw(distributor_sql)
        distributor_logs = [{'distributor_name': log.distributor_name, 'num': log.num, 'code1': log.code1, 'code2': log.code2, 'has_code1_scan_num': log.has_code1_scan_num, 'has_code2_scan_num': log.has_code2_scan_num} for log in distributor_logs]

    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', '')
    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)

    # 消费者统计
    daily_sql = 'select id, Count(id) AS num, Count(code_version=1 or NULL) AS code1 , Count(code_version=2 or NULL) AS code2 FROM mch_consumeinfosubmitloginfo where ymd >= %s AND ymd <= %s AND test_user=False AND dupload=False AND status=True %s GROUP BY ymd;' % (start_time, end_time, ('AND model_uni_name="%s"' % (model_name)) if model_name else '')

    daily_logs = ConsumeInfoSubmitLogInfo.objects.raw(daily_sql)
    daily_logs = [{'ymd': log.ymd, 'num': log.num, 'code1': log.code1, 'code2': log.code2} for log in daily_logs]

    model_logs = []
    if model_name == '':
        model_sql = 'select id, model_uni_name, Count(id) AS num, Count(code_version=1 or NULL) AS code1 , Count(code_version=2 or NULL) AS code2 FROM mch_consumeinfosubmitloginfo where ymd >= %s AND ymd <= %s AND test_user=False AND dupload=False AND status=True GROUP BY model_uni_name ORDER BY num desc;' % (start_time, end_time)

        model_logs = ConsumeInfoSubmitLogInfo.objects.raw(model_sql)
        model_logs = [{'model_uni_name': log.model_uni_name, 'num': log.num, 'code1': log.code1, 'code2': log.code2} for log in model_logs]

    province_sql = 'select id, province, Count(id) AS num, Count(code_version=1 or NULL) AS code1, Count(code_version=2 or NULL) AS code2 FROM mch_consumeinfosubmitloginfo where ymd >= %s AND ymd <= %s AND test_user=False AND dupload=False AND status=True %s GROUP BY province ORDER BY num desc;' % (start_time, end_time, ('AND model_uni_name="%s"' % (model_name)) if model_name else '')

    province_logs = ConsumeInfoSubmitLogInfo.objects.raw(province_sql)
    province_logs = [{'province': log.province, 'num': log.num, 'code1': log.code1, 'code2': log.code2} for log in province_logs]

    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)

    # 消费者统计
    if start_time and end_time:
        start_time = datetime.strptime(start_time, '%Y%m%d')
        end_time = datetime.strptime(end_time + ' 23:59:59', '%Y%m%d %H:%M:%S')
        userinfos = UserInfo.objects.filter(test_user=False, level__gte=1, resgister_at__range=(start_time, end_time))
    else:
        userinfos = UserInfo.objects.filter(test_user=False, level__gte=1, status=True)

    # 关注公众号数
    mp_num = userinfos.filter(subscribe=True).count()

    # 领取保卡数
    membercard_num = userinfos.filter(has_membercard=True).count()

    # 会员级别
    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={
        'mp_num': mp_num,
        'membercard_num': membercard_num,
        'level_logs': level_logs,
        'integral_logs': integral_logs,
        'shot_logs': shot_logs,
        'sex_logs': sex_logs,
        'province_logs': province_logs,
    })


def statistic_coupon(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 start_time and end_time:
        start_time = datetime.strptime(start_time, '%Y%m%d')
        end_time = datetime.strptime(end_time + ' 23:59:59', '%Y%m%d %H:%M:%S')
        coupons = UserCouponInfo.objects.filter(active_at__range=(start_time, end_time), status=True)
    else:
        coupons = UserCouponInfo.objects.filter(status=True)

    froms_logs = list(coupons.values('coupon_from').annotate(num=Count('user_coupon_id')))
    type_logs = list(coupons.values('coupon_title', 'coupon_value').annotate(num=Count('user_coupon_id')))

    if start_time and end_time:
        used_coupons = UserCouponInfo.objects.filter(used_at__range=(start_time, end_time), status=True)
    else:
        used_coupons = UserCouponInfo.objects.filter(has_used=True, status=True)

    type_has_used_logs = list(used_coupons.values('coupon_title', 'coupon_value').annotate(num=Count('user_coupon_id')))

    return response(200, 'Get Consumer Statistic Success', u'获取用户劵统计成功', data={
        'froms_logs': froms_logs,
        'type_logs': type_logs,
        'type_has_used_logs': type_has_used_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('-pk')

    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_consumer_batch(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    logs = json.loads(request.POST.get('logs', '[]'))

    infos = []
    unknows = []

    for log in logs:
        try:
            infos.append(ConsumeInfoSubmitLogInfo.objects.get(model_name__icontains=log['model_name'], serialNo=log['code'], status=True, dupload=False).admindata)
        except ConsumeInfoSubmitLogInfo.DoesNotExist:
            unknows.append(log)

    return response(200, 'Batch Get Record Sale Success', u'批量获取销售员销售记录', data={
        'logs': infos,
        'unknows': unknows
    })


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


def record_sale_batch(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    logs = json.loads(request.POST.get('logs', '[]'))

    infos = []
    unknows = []

    for log in logs:
        try:
            infos.append(SaleclerkSubmitLogInfo.objects.get(model_name__icontains=log['model_name'], code=log['code'], status=True, dupload=False).admindata)
        except SaleclerkSubmitLogInfo.DoesNotExist:
            unknows.append(log)

    return response(200, 'Batch Get Record Sale Success', u'批量获取销售员销售记录', data={
        'logs': infos,
        'unknows': unknows
    })


def model_list(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)

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

    infos = list(ModelInfo.objects.filter(status=True).values_list('model_uni_name', flat=True).distinct().order_by('model_uni_name'))

    return response(200, 'Get Model List Success', u'获取型号列表成功', data={
        'models': infos
    })


def distributor_list(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)

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

    infos = list(DistributorInfo.objects.filter(status=True).values_list('distributor_name', flat=True).distinct().order_by('distributor_name'))

    return response(200, 'Get Model List Success', u'获取经销商列表成功', data={
        'distributors': infos
    })


def member_goods_order(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', '')
    good_type = request.POST.get('good_type', '')
    page = request.POST.get('page', 1)
    num = request.POST.get('num', 20)
    order_status = int(request.POST.get('order_status', 0))
    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)

    orders = GoodsOrderInfo.objects.filter(Q(phone__icontains=query) | Q(user_id=query) | Q(title__icontains=query) & Q(status=True)).order_by('-pk')

    if good_type:
        orders = orders.filter(good_type=good_type)

    if start_time and end_time:
        start_time = datetime.strptime(start_time, '%Y%m%d')
        end_time = datetime.strptime(end_time + ' 23:59:59', '%Y%m%d %H:%M:%S')
        orders = orders.filter(created_at__range=(start_time, end_time))

    # 未发货，即快递单号为空
    if order_status == 1:
        orders = orders.filter(Q(tracking_number__isnull=True) | Q(tracking_number=''))
    elif order_status == 2:
        orders = orders.filter(tracking_number__isnull=False).exclude(tracking_number='')

    count = orders.count()
    orders, left = pagination(orders, page, num)
    orders = [order.admindata for order in orders]

    return response(200, 'Get Member Goods Order List Success', u'获取会员商品订单列表成功', data={
        'orders': orders,
        'left': left,
        'count': count
    })


def member_goods_order_update(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    order_id = request.POST.get('order_id', '')
    tracking_number = request.POST.get('tracking_number', '')
    remark = request.POST.get('remark', u'您的礼品正在快马加鞭赶来，请耐心等待呦~')

    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 not send_trackingNumber_message(order_id, tracking_number, remark):
        return response(400001, 'Member Goods Order Update Failure', u'会员商品订单修改失败')

    return response(200, 'Member Goods Order Update Success', u'会员商品订单修改成功')


def member_goods_order_batch_update(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    orders = json.loads(request.POST.get('orders', '[]'))

    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)

    err_orders = []
    for order in orders:
        if not send_trackingNumber_message(order.get('order_id', ''), order.get('tracking_number', ''), order.get('remark', u'您的礼品正在快马加鞭赶来，请耐心等待呦~')):
            err_orders.append(order.get('order_id', ''))

    if err_orders:
        return response(40001, 'Member Goods Order Update Error', u'部分会员商品订单修改失败', data={
            'orders': err_orders
        })

    return response(200, 'Member Goods Order Update Success', u'会员商品订单修改成功')


def send_trackingNumber_message(order_id, tracking_number, remark):
    try:
        order = GoodsOrderInfo.objects.get(order_id=order_id, status=True)
        order.remark = remark
        order.tracking_number = tracking_number
        if tracking_number and order.good_type == GoodsInfo.PHYSICAL and not order.has_send_template_message:
            order.has_send_template_message = True

            # 校验用户是否存在
            user = UserInfo.objects.get(user_id=order.user_id)

            data = {
                "thing6": {
                    "value": order.title,
                    "color": "#173177"
                },
                "character_string7": {
                    "value": tracking_number,
                    "color": "#173177"
                },
                "number2": {
                    "value": order.integral,
                    "color": "#173177"
                },
                "thing5": {
                    "value": order.remark,
                    "color": "#173177"
                },
            }

            res = sendwxasubscribemessage(openid=user.openid_miniapp, template_id=settings.TEMPLATE_ID_TRACKING, data=data, miniprogram_state=None, lang=None, page=None)
            order.send_template_message_res = json.dumps(res)

        order.save()

        return True
    except Exception:
        return False


def record_warehouse(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    model_name = request.POST.get('model_name', '')
    sn = request.POST.get('sn', '')
    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)

    models = ModelInfo.objects.filter(model_name__icontains=model_name, status=True).values_list('pk', flat=True)
    logs = MchInfoEncryptLogInfo.objects.filter(model_pk__in=models, sn__icontains=sn, status=True)

    if start_time and end_time:
        start_time = datetime.strptime(start_time, '%Y%m%d')
        end_time = datetime.strptime(end_time + ' 23:59:59', '%Y%m%d %H:%M:%S')
        logs = logs.filter(created_at__range=(start_time, end_time))

    logs = logs.order_by('-pk')

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

    return response(200, 'Get Warehouse Record Success', u'获取入库记录成功', data={
        'logs': logs,
        'left': left,
        'count': count
    })


def member_activity_list(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    title = request.POST.get('title', '')
    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)

    logs = MemberActivityInfo.objects.filter(title__icontains=title)

    if start_time and end_time:
        start_time = datetime.strptime(start_time, '%Y%m%d')
        end_time = datetime.strptime(end_time + ' 23:59:59', '%Y%m%d %H:%M:%S')
        logs = logs.filter(created_at__range=(start_time, end_time))

    logs = logs.order_by('-pk')

    count = logs.count()
    logs, left = pagination(logs, page, num)
    logs = [log.admindata for log in logs]
    return response(200, 'Get Member Activity Record Success', u'获取会员活动成功', data={
        'logs': logs,
        'left': left,
        'count': count
    })


def member_activity_details(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    activity_id = request.POST.get('activity_id', '')
    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:
        log = MemberActivityInfo.objects.get(activity_id=activity_id)
    except MemberActivityInfo.DoesNotExist:
        return response()

    log = log.admindetails

    return response(200, 'Get Member Activity Record Details Success', u'获取会员活动详情成功', data={
        'log': log,
    })


def member_activity_update(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    activity_id = request.POST.get('activity_id', '')
    title = request.POST.get('title', '')
    subtitle = request.POST.get('subtitle', '')
    date = request.POST.get('date', '')
    city = request.POST.get('city', '')
    location = request.POST.get('location', '')
    integral = int(request.POST.get('integral', 0))
    cover_url = request.POST.get('cover_path', '')
    slider_image = request.POST.get('banner_path', '')
    image = request.POST.get('banner_path', '')
    is_signup = request.POST.get('is_signup', '')
    group_share_max_integral = int(request.POST.get('share_max_integral', 0))
    group_share_integral = int(request.POST.get('share_integral', 0))
    is_slider = request.POST.get('is_slider', '')
    content_rich_text = request.POST.get('content_rich_text', '')
    share_h5_link = request.POST.get('share_h5_link', '')
    activity_state = int(request.POST.get('activity_state', 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:
        log = MemberActivityInfo.objects.get(activity_id=activity_id, status=True)
    except MemberActivityInfo.DoesNotExist:
        return response()

    log.title = title
    log.subtitle = subtitle
    log.date = datetime.strptime(date + ' 23:59:59', '%Y-%m-%d %H:%M:%S')
    log.city = city
    log.location = location
    log.integral = integral
    log.cover = cover_url
    log.slider_image = slider_image
    log.image = slider_image
    log.is_signup = is_signup
    log.group_share_integral = group_share_integral
    log.group_share_max_integral = group_share_max_integral
    log.is_slider = is_slider
    log.content_rich_text = content_rich_text
    log.share_h5_link = share_h5_link
    log.activity_state = activity_state
    log.save()

    return response(200, 'MemberActivityInfo Update Success', u'会员活动更新成功')


def member_activity_create(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    title = request.POST.get('title', '')
    subtitle = request.POST.get('subtitle', '')
    date = request.POST.get('date', '')
    city = request.POST.get('city', '')
    location = request.POST.get('location', '')
    integral = int(request.POST.get('integral', 0))
    cover_url = request.POST.get('cover_path', '')
    slider_image = request.POST.get('banner_path', '')
    image = request.POST.get('banner_path', '')
    is_signup = request.POST.get('is_signup', '')
    group_share_max_integral = int(request.POST.get('share_max_integral', 0))
    group_share_integral = int(request.POST.get('share_integral', 0))
    is_slider = request.POST.get('is_slider', '')
    content_rich_text = request.POST.get('content_rich_text', '')
    share_h5_link = request.POST.get('share_h5_link', '')
    activity_state = int(request.POST.get('activity_state', 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)

    MemberActivityInfo.objects.create(
        brand_id=administrator.brand_id,
        title=title,
        subtitle=subtitle,
        date=date,
        city=city,
        location=location,
        integral=integral,
        cover=cover_url,
        slider_image=slider_image,
        image=image,
        is_signup=is_signup,
        group_share_max_integral=group_share_max_integral,
        group_share_integral=group_share_integral,
        is_slider=is_slider,
        content_rich_text=content_rich_text,
        share_h5_link=share_h5_link,
        activity_state=activity_state
    )

    return response(200, 'MemberActivityInfo Create Success', u'会员活动创建成功')


def member_activity_share_list(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    activity_id = request.POST.get('activity_id', '')
    page = int(request.POST.get('page', 1))
    num = int(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)

    logs = MemberActivityGroupShareInfo.objects.filter(activity_id=activity_id, status=True)

    total_integral = logs.aggregate(Sum('integral'))['integral__sum']

    logs = logs.values('share_user_id').annotate(integral_sum=Sum('integral'), group_count=Count('open_gid'), user_count=Count('click_user_id')).order_by('-user_count')

    count = logs.count()
    logs, left = pagination(logs, page, num)

    return response(200, 'Get Member Activity Record Success', u'获取会员活动成功', data={
        'logs': list(logs),
        'count': count,
        'left': left,
        'total_integral': total_integral
    })


def member_activity_register_list(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    activity_id = request.POST.get('activity_id', '')
    page = int(request.POST.get('page', 1))
    num = int(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)

    logs = MemberActivitySignupInfo.objects.filter(activity_id=activity_id, status=True)

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

    return response(200, 'Get Member Activity Record Success', u'获取会员活动成功', data={
        'logs': list(logs),
        'count': count,
        'left': left,
    })


def coupon_list(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    title = request.POST.get('title', '')
    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)

    logs = CouponInfo.objects.filter(coupon_title__icontains=title, status=True)

    if start_time and end_time:
        start_time = datetime.strptime(start_time, '%Y%m%d')
        end_time = datetime.strptime(end_time + ' 23:59:59', '%Y%m%d %H:%M:%S')
        logs = logs.filter(created_at__range=(start_time, end_time))

    logs = logs.order_by('-pk')

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

    return response(200, 'Get CouponInfo List Success', u'获取劵列表成功', data={
        'logs': logs,
        'left': left,
        'count': count
    })


def coupon_details(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    coupon_id = request.POST.get('coupon_id', '')

    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:
        log = CouponInfo.objects.get(coupon_id=coupon_id)
    except CouponInfo.DoesNotExist:
        return response()

    log = log.admindetails

    return response(200, 'Get Member Activity Record Details Success', u'获取会员活动详情成功', data={
        'log': log,
    })


def coupon_create(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    coupon_title = request.POST.get('coupon_title', '')
    coupon_detail = request.POST.get('coupon_detail', '')
    coupon_value = int(request.POST.get('coupon_value', 0))
    coupon_image = request.POST.get('coupon_image', '')
    coupon_expire_type = int(request.POST.get('coupon_expire_type', 0))
    coupon_valid_period = int(request.POST.get('coupon_valid_period', 0))
    coupon_expire_at = request.POST.get('coupon_expire_at', '')
    is_coupon_admin_writeoff = int(request.POST.get('is_coupon_admin_writeoff', 1))

    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)

    info = CouponInfo.objects.create(
        brand_id=brand_id,
        coupon_title=coupon_title,
        coupon_detail=coupon_detail,
        coupon_value=coupon_value,
        coupon_image=coupon_image,
        coupon_expire_type=coupon_expire_type,
        coupon_valid_period=coupon_valid_period,
        is_coupon_admin_writeoff=is_coupon_admin_writeoff,
    )

    if coupon_expire_at:
        info.coupon_expire_at = datetime.strptime(coupon_expire_at + ' 23:59:59', '%Y-%m-%d %H:%M:%S')
        info.save()

    return response(200, 'CouponInfo Create Success', u'劵创建成功')


def coupon_update(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    coupon_id = request.POST.get('coupon_id', '')
    coupon_title = request.POST.get('coupon_title', '')
    coupon_detail = request.POST.get('coupon_detail', '')
    coupon_value = int(request.POST.get('coupon_value', 0))
    coupon_image = request.POST.get('coupon_image', '')
    coupon_expire_type = int(request.POST.get('coupon_expire_type', 0))
    coupon_valid_period = int(request.POST.get('coupon_valid_period', 0))
    coupon_expire_at = request.POST.get('coupon_expire_at', '')
    is_coupon_admin_writeoff = int(request.POST.get('is_coupon_admin_writeoff', 1))

    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:
        log = CouponInfo.objects.get(coupon_id=coupon_id, status=True)
    except CouponInfo.DoesNotExist:
        return response()

    log.brand_id = brand_id
    log.coupon_title = coupon_title
    log.coupon_detail = coupon_detail
    log.coupon_value = coupon_value
    log.coupon_image = coupon_image
    log.coupon_expire_type = coupon_expire_type
    log.coupon_valid_period = coupon_valid_period
    if coupon_expire_at:
        log.coupon_expire_at = datetime.strptime(coupon_expire_at + ' 23:59:59', '%Y-%m-%d %H:%M:%S')
    log.is_coupon_admin_writeoff = is_coupon_admin_writeoff
    log.save()

    return response(200, 'CouponInfo Update Success', u'劵更新成功')


def coupon_delete(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    coupon_id = request.POST.get('activity_id', '')

    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:
        log = CouponInfo.objects.get(coupon_id=coupon_id, status=True)
    except CouponInfo.DoesNotExist:
        return response()

    log.status = False
    log.save()

    return response(200, 'CouponInfo Delete Success', u'劵删除成功')


def member_goods_list(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    title = request.POST.get('title', '')
    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)

    logs = GoodsInfo.objects.filter(title__icontains=title, only_for_member=False).order_by('-pk')

    count = logs.count()
    logs, left = pagination(logs, page, num)
    logs = [log.admindata for log in logs]
    return response(200, 'Get Member Goods Success', u'获取会员商品成功', data={
        'logs': logs,
        'left': left,
        'count': count
    })


def member_goods_details(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    good_id = request.POST.get('good_id', '')

    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:
        log = GoodsInfo.objects.get(good_id=good_id)
    except GoodsInfo.DoesNotExist:
        return response()

    log = log.admindetails

    return response(200, 'Get Member Goods Details Success', u'获取积分商品详情成功', data={
        'log': log,
    })


def member_goods_update(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    good_id = request.POST.get('good_id', '')
    title = request.POST.get('title', '')
    desc = request.POST.get('desc', '')
    value = int(request.POST.get('value', 0))
    left_num = int(request.POST.get('left_num', 0))
    image = request.POST.get('image_path', '')
    coupon_id = request.POST.get('coupon_id', '')
    slider_image = request.POST.get('slider_path', '')
    integral = int(request.POST.get('integral', 0))
    fee = int(request.POST.get('fee', 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:
        log = GoodsInfo.objects.get(good_id=good_id, status=True)
    except GoodsInfo.DoesNotExist:
        return response()

    log.title = title
    log.desc = desc
    log.value = value
    log.left_num = left_num
    log.image = image
    log.coupon_id = coupon_id
    log.slider_image = slider_image
    log.integral = integral
    log.fee = fee
    log.save()

    return response(200, 'GoodsInfo Update Success', u'积分商品更新成功')


def member_goods_create(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    good_type = int(request.POST.get('good_type', 0))
    title = request.POST.get('title', '')
    desc = request.POST.get('desc', '')
    value = int(request.POST.get('value', 0))
    left_num = int(request.POST.get('left_num', 0))
    image = request.POST.get('image_path', '')
    coupon_id = request.POST.get('coupon_id', '')
    slider_image = request.POST.get('slider_path', '')
    integral = int(request.POST.get('integral', 0))
    fee = int(request.POST.get('fee', 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)

    GoodsInfo.objects.create(
        brand_id=administrator.brand_id,
        good_type=good_type,
        title=title,
        desc=desc,
        value=value,
        left_num=left_num,
        image=image,
        coupon_id=coupon_id,
        slider_image=slider_image,
        integral=integral,
        fee=fee,
    )

    return response(200, 'GoodsInfo Create Success', u'积分商品创建成功')


def complement_code_list(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', '')
    type_ = request.POST.get('type', '')
    query = request.POST.get('query', '')

    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 = ComplementCodeLogInfo.objects.filter(status=True)

    if start_time and end_time:
        start_time = datetime.strptime(start_time, '%Y%m%d')
        end_time = datetime.strptime(end_time + ' 23:59:59', '%Y%m%d %H:%M:%S')
        logs = logs.filter(created_at__range=(start_time, end_time))

    if type_ == 'todo':
        logs = logs.filter(audit_status=ComplementCodeLogInfo.AUDIT_TODO)
    elif type_ == 'pass':
        logs = logs.filter(audit_status=ComplementCodeLogInfo.AUDIT_PASS)
    elif type_ == 'refused':
        logs = logs.filter(audit_status=ComplementCodeLogInfo.AUDIT_REFUSED)
    logs = logs.order_by('audit_status', '-pk')

    if query:
        logs = logs.filter(Q(phone=query) | Q(name__icontains=query) | Q(sn=query))

    count = logs.count()

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

    return response(200, 'Get Complement Code List Success', u'获取补码列表成功', data={
        'logs': logs,
        'left': left,
        'count': count
    })


@transaction.atomic
def complement_code_audit(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    log_id = request.POST.get('log_id', '')
    audit_status = int(request.POST.get('audit_status', 0))  # -1 审核不通过, 1 审核通过

    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 audit_status not in [ComplementCodeLogInfo.AUDIT_REFUSED, ComplementCodeLogInfo.AUDIT_PASS]:
        return response(ComplementCodeStatusCode.COMPLEMENT_CODE_STATUS_INVALID)

    try:
        log = ComplementCodeLogInfo.objects.select_for_update().get(log_id=log_id, status=True)
    except ComplementCodeLogInfo.DoesNotExist:
        return response(ComplementCodeStatusCode.COMPLEMENT_CODE_NOT_FOUND)

    if log.audit_status != ComplementCodeLogInfo.AUDIT_TODO:
        return response(ComplementCodeStatusCode.COMPLEMENT_CODE_HAS_AUDITED)

    log.audit_status = audit_status
    log.save()

    # 如果"审核通过"
    if log.audit_status == ComplementCodeLogInfo.AUDIT_PASS:
        try:
            brand = BrandInfo.objects.get(brand_id=brand_id)
        except BrandInfo.DoesNotExist:
            brand = None

        try:
            model = ModelInfo.objects.get(model_id=log.model_id)
        except ModelInfo.DoesNotExist:
            model = None

        # brand_id#model_id#distributor_id#sn#time
        # AAAA#AAAAAA#AAAAA#AAAAAAAAAAAAAA#180224
        # brand_pk, model_pk, distributor_pk, sn, time = plaintext.split('#')
        plaintext = '{}#{}#{}#{}#{}'.format(
            brand.pk if brand else 0,
            model.pk if model else 0,
            0,
            log.sn,
            tc.local_string(format='%Y%m%d')[2:],
        )
        ciphertext = get_ciphertext(plaintext, admin_id, True)

        log.ciphertext = ciphertext
        log.save()

        try:
            user = UserInfo.objects.get(user_id=log.user_id, status=True)
        except UserInfo.DoesNotExist:
            return response()

        # Send template_message
        data = {
            "first": {
                "value": u'你的补码申请已通过，请点击消息绑定您的电子保修卡',
                "color": "#173177"
            },
            "keyword1": {
                "value": log.name,
                "color": "#173177"
            },
            "keyword2": {
                "value": log.model_name,
                "color": "#173177"
            },
            "keyword3": {
                "value": log.sn,
                "color": "#173177"
            },
            "remark": {
                "value": u'感谢您的使用',
                "color": "#173177"
            }
        }

        wxcfg = WECHAT.get('MINIAPP', {})
        appid = wxcfg.get('appID')

        sendtemplatemessage(openid=user.openid, template_id=settings.TEMPLATE_ID_COMPLEMENT, data=data, miniappid=appid, minipagepath='/pages/register/consumer/consumer?q={}&marketcode=1'.format(ciphertext))

        return response(data={
            'ciphertext': ciphertext,
        })

    return response()


@transaction.atomic
def complement_code_contacted(request):
    brand_id = request.POST.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    admin_id = request.POST.get('admin_id', '')
    log_id = request.POST.get('log_id', '')
    is_contacted = int(request.POST.get('is_contacted', 0))  # 0 未联系, 1 已联系

    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:
        log = ComplementCodeLogInfo.objects.select_for_update().get(log_id=log_id, status=True)
    except ComplementCodeLogInfo.DoesNotExist:
        return response(ComplementCodeStatusCode.COMPLEMENT_CODE_NOT_FOUND)

    log.is_contacted = is_contacted
    log.save()

    return response()