lhyt_shop/apps/wechat/customer/views.py

# coding=utf-8

from django.db import transaction
from rest_framework.views import APIView
from rest_framework.decorators import action
from rest_framework import generics
from utils import response_ok
from apps.account import tenant_log
from apps.foundation.models import BizLog
from rest_framework.exceptions import NotFound

from .serializers import *
from apps.customer.filters import *
from apps.vehicle_order.filters import *
from apps.product_order.filters import *
from apps.maint_order.filters import *


class VehicleDriveReserveViewSet(generics.ListAPIView):
    queryset = VehicleDriveReserve.objects.filter(delete=False)
    serializer_class = VehicleDriveReserveSerializer

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

    def list(self, request, *args, **kwargs):
        try:
            data = super(VehicleDriveReserveViewSet, self).list(request)
        except NotFound:
            return response_ok([])
        return data

    def perform_create(self, serializer):
        super(VehicleDriveReserveViewSet, 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)

class VehicleInquiryViewSet(generics.ListAPIView):
    queryset = VehicleInquiry.objects.filter(delete=False)
    serializer_class = VehicleInquirySerializer

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

    def list(self, request, *args, **kwargs):
        try:
            data = super(VehicleInquiryViewSet, self).list(request)
        except NotFound:
            return response_ok([])
        return data

    def perform_create(self, serializer):
        super(VehicleInquiryViewSet, 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)


class UsedVehicleInquiryViewSet(generics.ListAPIView):
    queryset = UsedVehicleInquiry.objects.filter(delete=False)
    serializer_class = UsedVehicleInquirySerializer

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

    def list(self, request, *args, **kwargs):
        try:
            data = super(UsedVehicleInquiryViewSet, self).list(request)
        except NotFound:
            return response_ok([])
        return data

    def perform_create(self, serializer):
        super(UsedVehicleInquiryViewSet, 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)


class UsedVehicleEstimateViewSet(generics.ListAPIView):
    queryset = UsedVehicleEstimate.objects.filter(delete=False)
    serializer_class = UsedVehicleEstimateSerializer

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

    def list(self, request, *args, **kwargs):
        try:
            data = super(UsedVehicleEstimateViewSet, self).list(request)
        except NotFound:
            return response_ok([])
        return data

    def perform_create(self, serializer):
        super(UsedVehicleEstimateViewSet, 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)


class MaintOrderReserveViewSet(generics.ListAPIView):
    queryset = MaintOrderReserve.objects.filter(delete=False)
    serializer_class = MaintOrderReserveSerializer

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

    def list(self, request, *args, **kwargs):
        try:
            data = super(MaintOrderReserveViewSet, self).list(request)
        except NotFound:
            return response_ok([])
        return data

    def perform_create(self, serializer):
        super(MaintOrderReserveViewSet, 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)


class ProductOrderViewSet(generics.ListAPIView):
    queryset = ProductOrder.objects.filter(delete=False)
    serializer_class = ProductOrderSerializer

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

    def list(self, request, *args, **kwargs):
        try:
            data = super(ProductOrderViewSet, self).list(request)
        except NotFound:
            return response_ok([])
        return data


class CustomerVehicleViewSet(generics.ListAPIView):
    queryset = CustomerVehicle.objects.filter()
    serializer_class = CustomerVehicleSerializer

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

    def list(self, request, *args, **kwargs):
        try:
            data = super(CustomerVehicleViewSet, self).list(request)
        except NotFound:
            return response_ok([])
        return data

    def perform_create(self, serializer):
        super(CustomerVehicleViewSet, 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 vehicle_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()


class CustomerAddressViewSet(generics.ListAPIView):
    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):
        try:
            data = super(CustomerAddressViewSet, self).list(request)
        except NotFound:
            return response_ok([])
        return 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

            if instance.default:
                CustomerAddress.objects.filter(Q(customer=request.customer, delete=False), ~Q(id=instance.id)).update(default=False)

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


class MaintReserveOptionsView(APIView):
    def get(self, request):
        data = {
            'maint_types': Option.objects.filter(type=Option.MAINT_TYPE, delete=False, enable=True).values('id', 'name'), #品牌
            'vehicles': CustomerVehicle.objects.filter(customer=request.customer, delete=False).values('id', 'number') #车辆
        }
        return response_ok(data)