kodo/api/mch_views.py

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

from __future__ import division

import json

from django.conf import settings
from django.contrib.auth.hashers import check_password
from django.db import transaction
from django_logit import logit
from django_response import response
from pywe_miniapp import get_phone_number
from pywe_storage import RedisStorage
from TimeConvert import TimeConvert as tc

from account.models import UserInfo
from coupon.models import CouponInfo, UserCouponInfo
from integral.models import SaleclerkSubmitLogInfo
from logs.models import MchInfoEncryptLogInfo
from mch.models import (ActivityInfo, AdministratorInfo, BrandInfo, ConsumeInfoSubmitLogInfo, DistributorInfo,
                        LatestAppInfo, LatestAppScreenInfo, ModelInfo, OperatorInfo)
from statistic.models import ConsumeModelSaleStatisticInfo, ConsumeSaleStatisticInfo, ConsumeUserStatisticInfo
from utils.error.errno_utils import (AdministratorStatusCode, OperatorStatusCode, ProductBrandStatusCode,
                                     ProductModelStatusCode, UserStatusCode)
from utils.redis.connect import r
from utils.redis.rkeys import MEMBER_SEND_COUPON_LIST, MEMBER_UPGRADE_INFO, MINI_PROGRAM_GIS_LIST


WECHAT = settings.WECHAT


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

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

    phone = request.POST.get('phone', '')
    password = request.POST.get('password', '')

    try:
        operator = OperatorInfo.objects.get(phone=phone, status=True)
    except OperatorInfo.DoesNotExist:
        return response(OperatorStatusCode.OPERATOR_NOT_FOUND)

    if operator.user_status == OperatorInfo.DISABLED:
        return response(OperatorStatusCode.OPERATOR_NOT_ACTIVATED)
    elif operator.user_status == OperatorInfo.DELETED:
        return response(OperatorStatusCode.OPERATOR_HAS_DELETED)

    if not check_password(password, operator.encryption):
        return response(OperatorStatusCode.OPERATOR_PASSWORD_ERROR)

    return response(200, 'Optor Login Success', u'操作员登录成功', data=operator.kododata)


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

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

    phone = request.POST.get('phone', '')
    password = request.POST.get('password', '')

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

    if administrator.user_status == AdministratorInfo.DISABLED:
        return response(AdministratorStatusCode.ADMINISTRATOR_NOT_ACTIVATED)
    elif administrator.user_status == AdministratorInfo.DELETED:
        return response(AdministratorStatusCode.ADMINISTRATOR_HAS_DELETED)

    if not check_password(password, administrator.encryption):
        return response(AdministratorStatusCode.ADMINISTRATOR_PASSWORD_ERROR)

    request.session['admin_id'] = administrator.admin_id

    return response(200, 'Admin Login Success', u'管理员登录成功', data={
        'admin_id': administrator.admin_id,
        'admin_type': administrator.admin_type,
        'admin_name': administrator.name,
        'qrurl': settings.KODO_CLERK_AUTH_URL.format(administrator.brand_id),
    })


@logit
def bmd_infos(request):
    optor_id = request.POST.get('optor_id', '')

    try:
        operator = OperatorInfo.objects.get(operator_id=optor_id, status=True)
    except OperatorInfo.DoesNotExist:
        return response(OperatorStatusCode.OPERATOR_NOT_FOUND)

    if operator.user_status == OperatorInfo.DISABLED:
        return response(OperatorStatusCode.OPERATOR_NOT_ACTIVATED)

    brands = BrandInfo.objects.filter(brand_id=operator.brand_id, status=True).order_by('position')
    brands = [brand.data for brand in brands]

    tmpmodels = ModelInfo.objects.filter(brand_id=operator.brand_id, display=True, status=True).order_by('position')
    models = [model.data for model in tmpmodels]
    # jancodes = {model.jancode: model.data for model in tmpmodels}

    distributors = DistributorInfo.objects.filter(brand_id=operator.brand_id, status=True).order_by('position')
    distributors = [distributor.data for distributor in distributors]

    return response(200, data={
        'optor_id': operator.operator_id,
        'brands': brands,
        'models': models,
        # 'jancodes': jancodes,
        'distributors': distributors,
    })


@logit
def brands_list(request):
    brands = BrandInfo.objects.filter(status=True).order_by('position')
    brands = [brand.data for brand in brands]

    return response(200, data={
        'brands': brands,
    })


@logit
def models_list(request):
    models = ModelInfo.objects.filter(status=True).order_by('position')
    models = [model.data for model in models]

    return response(200, data={
        'models': models,
    })


@logit
def distributors_list(request):
    distributors = DistributorInfo.objects.filter(status=True).order_by('position')
    distributors = [distributor.data for distributor in distributors]

    return response(200, data={
        'distributors': distributors,
    })


@logit
def upgrade_api(request):
    """ APP 升级 """
    src = request.POST.get('src', '')

    if src == 'datascreen':
        latestappmodel = LatestAppScreenInfo
    else:
        latestappmodel = LatestAppInfo

    try:
        appinfo = latestappmodel.objects.filter(status=True)[0].adr
    except IndexError:
        appinfo = {
            'latest_version_code': '',
            'latest_version_name': '',
            'latest_url': '',
        }

    return response(200, 'Get Latest App Success', u'获取最新版信息成功', {
        'appinfo': appinfo,
    })


def getPhoneNumber(request):
    user_id = request.POST.get('user_id', '')

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

    appid = wxcfg.get('appID')

    # Just for compatible because of store session_key has changed
    session_key = None if user_id else RedisStorage(r).get('{0}:{1}:sessionKey'.format(appid, ''))

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

    appid = wxcfg.get('appID')
    secret = wxcfg.get('appsecret')

    iv = request.POST.get('iv', '')
    encryptedData = request.POST.get('encryptedData', '')

    # {
    #     "phoneNumber": "13580006666",
    #     "purePhoneNumber": "13580006666",
    #     "countryCode": "86",
    #     "watermark":
    #         {
    #             "appid": "APPID",
    #             "timestamp": TIMESTAMP
    #         }
    # }
    phone_number = get_phone_number(appid=appid, secret=secret, unid=user_id, session_key=session_key, encryptedData=encryptedData, iv=iv, storage=RedisStorage(r))

    return phone_number.get('purePhoneNumber', '')


@logit(res=True)
def consumer_phone_api(request):
    return response(200, 'Get Consumer Phone Success', u'获取消费者手机号成功', {
        'purePhoneNumber': getPhoneNumber(request),
    })


@logit(res=True)
@transaction.atomic
def consumer_info_api(request):
    user_id = request.POST.get('user_id', '')
    lat = request.POST.get('lat', .0)
    lon = request.POST.get('lon', .0)
    brandID = request.POST.get('brand_id', '') or request.POST.get('BrandID', '')
    modelID = request.POST.get('ModelID', '')
    distributorID = request.POST.get('DistributorID', '')
    serialNo = request.POST.get('SerialNo', '')
    verifyResult = request.POST.get('verifyResult', 0)
    code_version = request.POST.get('code_version', '')
    activities = json.loads(request.POST.get('activities', '[]'))

    if lat == 'undefined':
        lat = .0
    if lon == 'undefined':
        lon = .0

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

    try:
        brand = BrandInfo.objects.get(brand_id=brandID)
    except BrandInfo.DoesNotExist:
        brand = None

    if not brand:
        try:
            brand = BrandInfo.objects.get(pk=brandID)
        except BrandInfo.DoesNotExist:
            return response(ProductBrandStatusCode.BRAND_NOT_FOUND)
        except ValueError:
            return response(ProductBrandStatusCode.BRAND_NOT_FOUND)

    try:
        model = ModelInfo.objects.get(pk=modelID)
    except ModelInfo.DoesNotExist:
        return response(ProductModelStatusCode.MODEL_NOT_FOUND)
    except ValueError:
        return response(ProductModelStatusCode.MODEL_NOT_FOUND)

    # 是否是新二维码，即统览码2
    if not code_version:
        code_version = 1
        code = filter(lambda ch: ch in '0123456789', serialNo)
        encrypt_logs = MchInfoEncryptLogInfo.objects.filter(model_pk=model.pk, sn=code)

        if encrypt_logs:
            code_version = encrypt_logs[0].version

    user.code_version = code_version
    user.save()

    # try:
    #     distributor = DistributorInfo.objects.get(pk=distributorID)
    # except DistributorInfo.DoesNotExist:
    #     return response(ProductDistributorStatusCode.DISTRIBUTOR_NOT_FOUND)
    # except ValueError:
    #     return response(ProductDistributorStatusCode.DISTRIBUTOR_NOT_FOUND)

    dupload = ConsumeInfoSubmitLogInfo.objects.filter(
        brand_id=brand.brand_id,
        model_id=model.model_id,
        # distributor_id=distributor.distributor_id,
        distributor_id='',
        serialNo=serialNo,
        verifyResult=1,
        test_user=False,
        status=True
    ).exists()

    if dupload:
        act = None
        during_activity = False
    else:
        during_activity = True if activities else False

        # 更新销售员提交的表
        SaleclerkSubmitLogInfo.objects.filter(code=serialNo, model_pk=model.pk, status=True).update(has_scan=True)

    ymd = tc.local_string(format='%Y%m%d')

    # 记录用户信息提交记录
    log = ConsumeInfoSubmitLogInfo.objects.create(
        user_id=user_id,
        phone=user.phone,
        lat=lat,
        lon=lon,
        brand_id=brand.brand_id,
        brand_name=brand.brand_name,
        model_id=model.model_id,
        model_name=model.model_name,
        model_uni_name=model.model_uni_name,
        # distributor_id=distributor.distributor_id,
        # distributor_name=distributor.distributor_name,
        distributor_id='',
        distributor_name='',
        serialNo=serialNo,
        verifyResult=verifyResult,
        dupload=dupload,
        test_user=user.test_user,
        code_version=code_version,
        ym=ymd[:6],
        ymd=ymd,
        province=user.province_name if lat == 0.0 and lon == 0.0 else '',
        submit_during_activity=during_activity
    )

    for act in activities:
        try:
            coupon = CouponInfo.objects.get(coupon_id=act['coupon_id'])
        except CouponInfo.DoesNotExist:
            continue

        try:
            activity = ActivityInfo.objects.get(activity_id=act['activity_id'])
        except ActivityInfo.DoesNotExist:
            continue

        UserCouponInfo.objects.create(
            brand_id=coupon.brand_id,
            brand_name=coupon.brand_name,
            coupon_id=coupon.coupon_id,
            user_id=user_id,
            coupon_title=coupon.coupon_title,
            coupon_detail=coupon.coupon_detail,
            coupon_value=coupon.coupon_value,
            coupon_image=coupon.coupon_image,
            active_at=tc.utc_datetime(),
            expire_at=coupon.final_expire_at,
            is_coupon_admin_writeoff=coupon.is_coupon_admin_writeoff,
            coupon_valid_period=coupon.coupon_valid_period,
            coupon_limit_model_ids=coupon.coupon_limit_model_ids,
            coupon_from='PROMOTION',
            activity_id=activity.activity_id,
            activity_name=activity.activity_name,
            submit_pk=log.pk,
        )

    # 更新注册时间
    if not dupload:
        user.resgister_at = log.created_at
        user.save()

    if not user.test_user and not dupload:

        # TODO: Make statistic async
        cusi, _ = ConsumeUserStatisticInfo.objects.get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd,
        )
        cusi.users = list(set(cusi.users + [log.user_id]))
        cusi.num = len(cusi.users)
        cusi.save()
        cusi, _ = ConsumeUserStatisticInfo.objects.get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd[:6],
        )
        cusi.users = list(set(cusi.users + [log.user_id]))
        cusi.num = len(cusi.users)
        cusi.save()
        cusi, _ = ConsumeUserStatisticInfo.objects.get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd[:4],
        )
        cusi.users = list(set(cusi.users + [log.user_id]))
        cusi.num = len(cusi.users)
        cusi.save()

        # 日销量统计
        cssi, _ = ConsumeSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd,
        )
        cssi.num += 1
        cssi.save()
        # 月销量统计
        cssi, _ = ConsumeSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd[:6],
        )
        cssi.num += 1
        cssi.save()
        # 年销量统计
        cssi, _ = ConsumeSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            ymd=ymd[:4],
        )
        cssi.num += 1
        cssi.save()

        # 日型号销量统计
        cmssi, _ = ConsumeModelSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            model_name=model.model_uni_name,
            ymd=ymd,
        )
        cmssi.users = list(set(cmssi.users + [user_id]))
        cmssi.num = len(cmssi.users)
        cmssi.save()
        # 月型号销量统计
        cmssi, _ = ConsumeModelSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            model_name=model.model_uni_name,
            ymd=ymd[:6],
        )
        cmssi.users = list(set(cmssi.users + [user_id]))
        cmssi.num = len(cmssi.users)
        cmssi.save()
        # 年型号销量统计
        cmssi, _ = ConsumeModelSaleStatisticInfo.objects.select_for_update().get_or_create(
            brand_id=brand.brand_id,
            model_name=model.model_uni_name,
            ymd=ymd[:4],
        )
        cmssi.users = list(set(cmssi.users + [user_id]))
        cmssi.num = len(cmssi.users)
        cmssi.save()

        r.rpushjson(MINI_PROGRAM_GIS_LIST, {
            'brand_id': log.brand_id,
            'user_id': log.user_id,
            'lat': log.lat,
            'lon': log.lon,
            'phone': log.phone,
            'ymd': ymd,
            'serialNo': serialNo,
            'model_id': model.model_id,
            'pk': log.pk,
        })

    if not dupload:
        log.integral = model.shot_member_integral
        log.save()
        user.shots_num += 1
        user.integral += model.shot_member_integral
        # 配件不增加会员等级，只发放积分。
        to_send_coupon = False
        if user.level < UserInfo.MEMBER_BLACK_GOLD and model.category != '调焦器' and model.category != '增倍镜':
            user.level += 1
            to_send_coupon = True
        user.save()

        if to_send_coupon:
            # 发放会员权益
            r.rpushjson(MEMBER_SEND_COUPON_LIST, {
                'brand_id': brand.brand_id,
                'user_id': user_id,
            })
            # 会员升级提示
            r.set(MEMBER_UPGRADE_INFO % (brand.brand_id, user_id), 1)

    return response(200, 'Submit Consumer Info Success', u'提交消费者信息成功')


@logit(res=True)
@transaction.atomic
def consumer_snlist_api(request):
    user_id = request.POST.get('user_id', '')

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

    # 用户信息提交列表
    logs = ConsumeInfoSubmitLogInfo.objects.filter(user_id=user_id, status=True).distinct()
    seen = set()
    seen_add = seen.add
    logs = [log.data for log in logs if not ((log.serialNo, log.model_name) in seen or seen_add((log.serialNo, log.model_name)))]

    return response(200, 'Get Consumer Submit List Success', u'获取消费者提交列表成功', {
        'logs': logs,
    })


@logit(res=True)
@transaction.atomic
def consumer_model_list(request):
    user_id = request.POST.get('user_id', '')

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

    # 返回型号列表
    models = ModelInfo.objects.filter(shot_type_id__isnull=False, status=True).order_by('-shot_member_name')
    models = [model.consumer_shot_data for model in models]

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