lhyt_shop/apps/wechat/views.py

# coding=utf-8

import requests
from django.db import transaction
from rest_framework.views import APIView
from rest_framework import generics
from rest_framework.decorators import action
from rest_framework_jwt.views import ObtainJSONWebToken,VerifyJSONWebToken,RefreshJSONWebToken
from rest_framework.serializers import ValidationError
from rest_framework import permissions

from utils import response_ok, response_error
from utils.exceptions import CustomError
from utils.custom_modelviewset import CustomModelViewSet
from utils.wx.WXBizDataCrypt import WXBizDataCrypt
from utils.permission import IsCustomerUser
from apps.images.models import Images
from apps.customer.models import CustomerAddress
from apps.customer.filters import CustomerAddressFilter
from apps.foundation.models import Config
from apps.account import tenant_log


from .serializers import *


class CustomerLoginView(APIView):
    serializer_class = CustomerMobileSignSerializer

    def post(self, request, *args, **kwargs):
        ser = self.serializer_class(data=request.data)
        if ser.is_valid():
            return response_ok(ser.validated_data)
        else:
            return response_error('参数错误')


class CustomerRefreshTokenView(RefreshJSONWebToken):
    def post(self, request, *args, **kwargs):
        try:
            ser = self.serializer_class(data=request.data)
            if ser.is_valid(raise_exception=True):
                return response_ok({'token': ser.validated_data['token']})
        except ValidationError as e:
            return response_error(u'登录状态失效，请重新登录[' + e.detail['error'][0] + ']')


class CustomerVerifyTokenView(VerifyJSONWebToken):
    def post(self, request, *args, **kwargs):
        try:
            ser = self.serializer_class(data=request.data)
            if ser.is_valid(raise_exception=True):
                return response_ok({'token': ser.validated_data['token']})
        except ValidationError as e:
            return response_error(u'登录状态失效，请重新登录[' + e.detail['error'][0] + ']')


class WxLoginView(APIView):
    serializer_class = WechatLoginSerializer

    def post(self, request, *args, **kwargs):
        ser = self.serializer_class(data=request.data)
        if ser.is_valid():
            return response_ok(ser.validated_data)
        else:
            return response_error('参数错误')


class WxBindView(APIView):
    serializer_class = WechatBindSerializer

    def post(self, request, *args, **kwargs):
        ser = self.serializer_class(data=request.data)
        if ser.is_valid():
            return response_ok(ser.validated_data)
        else:
            return response_error('参数错误')


class SetUserInfoView(APIView):
    permission_classes = [IsCustomerUser, ]

    def post(self, request, *args, **kwargs):
        appid = request.POST.get('appid')
        openid = request.POST.get('openid')
        encryptedData = request.POST.get('encryptedData')
        iv = request.POST.get('iv')

        customer_wechat = CustomerWechat.objects.filter(openid=openid, wechat_app__authorizer_appid=appid).first()
        if not customer_wechat:
            raise CustomError(u'未找到相应的微信客户！')
        customer = request.customer
        if customer_wechat.customer and customer_wechat.customer.id != customer.id:
            raise CustomError(u'该微信已同步其他客户！')
        if not customer_wechat.customer:
            customer_wechat.customer = customer
            customer_wechat.save()
        pc = WXBizDataCrypt(customer_wechat.wechat_app.authorizer_appid, customer_wechat.session_key)
        result = pc.decrypt(encryptedData, iv)
        with transaction.atomic():
            customer.setInfo(result['nickName'], result['gender'], result['avatarUrl'])
            tenant_log(customer.user, BizLog.INSERT, u'客户设置信息，id=%d' % customer.id, result)
        return response_ok()



class CustomerInfoView(generics.RetrieveAPIView):
    permission_classes = [IsCustomerUser, ]
    # queryset = Customer.objects.filter()
    serializer_class = CustomerSerializer

    def get_object(self):
        # queryset = self.filter_queryset(self.get_queryset())
        # obj = queryset.filter(id=self.request.customer.id).first()
        obj = self.request.customer
        return obj

    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return response_ok(serializer.data)


class CustomerAddressViewSet(CustomModelViewSet):
    permission_classes = [IsCustomerUser, ]
    queryset = CustomerAddress.objects.filter(delete=False)
    serializer_class = CustomerAddressSerializer

    def filter_queryset(self, queryset):
        queryset = queryset.filter(customer=self.request.customer)
        f = CustomerAddressFilter(self.request.GET, queryset=queryset)
        return f.qs

    def list(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())
        serializer = self.get_serializer(queryset, many=True)
        return response_ok(serializer.data)

    def perform_create(self, serializer):
        super(CustomerAddressViewSet, self).perform_create(serializer)
        instance = serializer.instance
        validated_data = serializer.validated_data
        tenant_log(instance.customer.user, BizLog.INSERT, u'客户添加收货地址，id=%d' % instance.id, validated_data)

    @action(methods=['post'], detail=True)
    def addr_update(self, request, *args, **kwargs):
        with transaction.atomic():
            instance = self.get_object()
            serializer = self.get_serializer(instance, data=request.data)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            instance = serializer.instance
            validated_data = serializer.validated_data
            tenant_log(instance.customer.user, BizLog.UPDATE, u'客户修改收货地址，id=%d' % instance.id, validated_data)
        return response_ok()

    @action(methods=['get'], detail=True)
    def addr_destroy(self, request, *args, **kwargs):
        with transaction.atomic():
            instance = self.get_object()
            queryset = self.get_queryset().filter(customer=self.request.customer).exclude(id=instance.id)
            instance.destory(queryset)
            tenant_log(instance.customer.user, BizLog.INSERT, u'客户删除收货地址，id=%d' % instance.id)
        return response_ok()

    @action(methods=['get'], detail=True)
    def set_default(self, request, *args, **kwargs):
        with transaction.atomic():
            instance = self.get_object()
            self.get_queryset().filter(customer=self.request.customer, default=True).update(default=False)
            instance.default = True
            instance.save()
            tenant_log(instance.customer.user, BizLog.INSERT, u'客户设置默认收货地址，id=%d' % instance.id)
        return response_ok()