nostone_loan/apps/order/views.py

# coding=utf-8
import json
from django.db.models import Sum, F
from django.db import transaction
from django.db.models import Q
from rest_framework.views import APIView
from utils.custom_modelviewset import CustomModelViewSet
from .serializers import *
from .filters import *
from apps.log.models import BizLog
from apps.base import Formater
from utils import response_ok, response_error
from utils.permission import isLogin
from apps.order.models import Order
from rest_framework.decorators import action
from django.contrib.auth import get_user_model

User = get_user_model()


class ProductView(APIView):

    def get(self, request):
        data = []
        queryset = Product.objects.filter(enable=True)
        for row in queryset:
            item = {
                'id':row.id,
                'name':row.name,
                'month':row.month,
            }
            data.append(item)
        return response_ok(data)

class DeleteProductImageView(APIView):
    permission_classes = [isLogin, ]

    def post(self, request, *args, **kwargs):
        # 商品图片 删除
        id = request.GET.get('id')
        try:
            instance = ProductImages.getById(id)
            image = Upload.objects.filter(id=instance.image_id).first()
            with transaction.atomic():
                instance.delete()
                image.del_images()
        except CustomError as e:
            return response_error(e.get_error_msg())
        except Exception as e:
            return response_error(str(e))
        return response_ok()

class ProductViewSet(CustomModelViewSet):
    permission_classes = [isLogin, ]
    queryset = Product.objects.filter()
    serializer_class = ProductSerializer

    def filter_queryset(self, queryset):
        f = ProductFilter(self.request.GET, queryset=queryset)
        return f.qs

    @action(methods=['post'], detail=True)
    def upload_image(self, request, pk):
        banner_img = request.FILES.get('banner_img')
        try:
            with transaction.atomic():
                instance = self.get_object()
                upload = Upload.objects._addnew(banner_img, 'commodity_image')
                if upload:
                    if instance.main_image_id:
                        img = Upload.objects.filter(id=instance.main_image_id).first()
                        img.del_images()
                    instance.main_image_id = upload.id
                    instance.save()
                    return response_ok(upload.id)
                return response_error('上传失败，请重新上传！')
        except CustomError as e:
            return response_error(e.get_error_msg())
        except Exception as e:
            return response_error(str(e))

    @action(methods=['post'], detail=True)
    def upload_detail_img(self, request, pk):
        # 上传详情、参数图片
        try:
            with transaction.atomic():
                instance = self.get_object()
                for i in range(10):
                    file = request.data.get('file{}'.format(i))
                    if file:
                        upload = Upload.objects._addnew(file, 'commodity_image')
                        ProductImages.objects.create(product_id=instance.id,
                                                           image_id=upload.id)

                        if not upload:
                            return response_error('上传失败，请重新上传！')
        except CustomError as e:
            return response_error(e.get_error_msg())
        except Exception as e:
            return response_error(str(e))
        return response_ok()

    @action(methods=['post'], detail=True)
    def query_detail_img(self, request, pk):
        # 查看 详情图片
        instance = self.get_object()
        data = []

        commodity_images = ProductImages.objects.filter(product_id=instance.id)
        for commodity_image in commodity_images:
            image = Upload.objects.filter(id=commodity_image.image_id).first()
            image_path = image.get_path()
            commodity_image_item = {
                'id': commodity_image.id,
                'name': commodity_image.name,
                'src': image_path,
            }
            data.append(commodity_image_item)
        return response_ok(data)

class OrderViewSet(CustomModelViewSet):
    permission_classes = [isLogin, ]
    queryset = Order.objects.filter()
    serializer_class = OrderSerializer

    def list(self, request, *args, **kwargs):
        # 底栏合计
        queryset = self.filter_queryset(self.get_queryset())
        total = queryset.aggregate(total_amount=Sum('total_amount'), balance_deduction=Sum('balance_deduction'),
                                   actual_amount=Sum('actual_amount'))
        totalRow = {'totalRow': 1,
                    'total_amount': Formater.formatPriceShow(total['total_amount']),
                    'balance_deduction': Formater.formatPriceShow(total['balance_deduction']),
                    'actual_amount': Formater.formatPriceShow(total['actual_amount'], )}
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            data = serializer.data
            if len(data) > 0:
                data.append(totalRow)
            return self.get_paginated_response(data)

        serializer = self.get_serializer(queryset, many=True)
        return response_ok(serializer.data)

    def filter_queryset(self, queryset):
        queryset = queryset.filter(Q(create_user=self.request.user))
        f = OrderFilter(self.request.GET, queryset=queryset)
        return f.qs

    def create(self, request, *args, **kwargs):
        try:
            with transaction.atomic():
                serializer = self.get_serializer(data=request.data)
                if serializer.is_valid(raise_exception=True):
                    instance = serializer.save()
                    BizLog.objects.addnew(self.request.user, BizLog.INSERT,
                                          u'添加订单[%s]，id=%d' % (instance.id), request.data)
                    return response_ok()
        except CustomError as e:
            return response_error(e.get_error_msg())
        except Exception as e:
            import traceback
            traceback.print_exc()
            return response_error(str(e))