decorate/apps/customer/views.py

# coding=utf-8
from rest_framework.views import APIView
from django.db.models import Q
import datetime
from django.utils import timezone
from rest_framework.decorators import action
from utils.permission import isLogin, permission_required, check_permission
from utils.custom_modelviewset import CustomModelViewSet
from utils import response_ok, response_error
from utils.exceptions import CustomError
from apps.log.models import BizLog
from apps.option.models import Option
from apps.option.serializers import OptionComboboxSerializer
from .models import ReportCustomer,NewCustomer
from .serializers import ReportCustomerSerializer,NewCustomerSerializer
from .filters import ReportCustomerFilter,NewCustomerFilter
from django.contrib.auth import get_user_model
User = get_user_model()

class ReportCustomerViewSet(CustomModelViewSet):
    permission_classes = [isLogin]
    queryset = ReportCustomer.objects.filter()
    serializer_class = ReportCustomerSerializer

    @permission_required('customer.view_report_customer')
    def filter_queryset(self, queryset):
        queryset = queryset.filter(
            Q(store_id__in=self.request.user.get_manager_range()) |
            Q(create_user=self.request.user))
        f = ReportCustomerFilter(self.request.GET, queryset=queryset)
        return f.qs

    @permission_required('customer.add_report_customer')
    def perform_create(self, serializer):
        super(ReportCustomerViewSet, self).perform_create(serializer)
        instance = serializer.instance
        validated_data = serializer.validated_data
        BizLog.objects.addnew(self.request.user, BizLog.INSERT,
                              u'添加客户报备[%s]，id=%d' % (instance.name, instance.id), validated_data)

    @permission_required('customer.add_report_customer')
    def perform_update(self, serializer):
        super(ReportCustomerViewSet, self).perform_update(serializer)
        instance = serializer.instance
        validated_data = serializer.validated_data
        BizLog.objects.addnew(self.request.user, BizLog.UPDATE,
                              u'修改客户报备[%s]，id=%d' % (instance.name, instance.id), validated_data)

    @permission_required('customer.delete_report_customer')
    def perform_destroy(self, instance):
        BizLog.objects.addnew(self.request.user, BizLog.DELETE,
                              u'删除客户报备[%s]，id=%d' % (instance.name, instance.id))
        super(ReportCustomerViewSet, self).perform_destroy(instance)

    @action(methods=['post'], detail=True)
    def dispatch_customer(self, request, pk):
        check_permission(request, 'customer.check_report_customer')
        # 审核
        user = request.POST.get('user')
        user = User.objects.filter(id=user).first()
        try:
            instance = ReportCustomer.objects.filter(id=pk).first()
            if not instance:
                raise CustomError('当前客户报备信息有误,请刷新重试！')
            instance.check_user = self.request.user
            instance.report_status = ReportCustomer.CHECKED
            instance.check_time = timezone.now()
            instance.save()
            BizLog.objects.addnew(request.user, BizLog.INSERT,
                                  u'分配客户报备[%s],id=%d' % (instance.name,  instance.id))
            # 创建潜客跟踪表
            potential_level = Option.objects.filter(type=Option.POTENTIAL_LEVEL).order_by('sort').first()
            stage_progress = Option.objects.filter(type=Option.STAGE_PROGRESS).order_by('sort').first()
            if not potential_level.track_day:
                raise CustomError('当前潜客级别，没有可用跟踪天数！')
            next_time = (timezone.now() + datetime.timedelta(days=potential_level.track_day)).strftime('%Y-%m-%d')
            NewCustomer.objects.create(report_customer=instance, potential_level=potential_level,
                                       track_user=user, next_time=next_time, stage_progress=stage_progress,
                                       create_user=instance.create_user,
                                       )
        except CustomError as e:
            return response_error(e.get_error_msg())
        except Exception as e:
            return response_error(str(e))
        return response_ok()


class ReportCustomerDictView(APIView):
    permission_classes = [isLogin]

    def get(self, request):
        source = Option.objects.filter(type=Option.CUSTOMER_SOURCE, enable=True)
        project = Option.objects.filter(type=Option.CATEGORY, enable=True)
        serializer_source = OptionComboboxSerializer(source, many=True)
        serializer_project = OptionComboboxSerializer(project, many=True)
        return response_ok({
            'source': serializer_source.data,
            'project': serializer_project.data,
        })

class UserDictView(APIView):
    permission_classes = [isLogin]

    def get(self, request):
        store = request.user.store
        if not store:
            return response_error('当前账号未绑定门店，禁止分配客户！')
        users = User.objects.filter(store=store).values('id', 'name')
        users = [{'value': user['id'], 'lable': user['name']} for user in users]
        return response_ok(users)


class NewCustomerViewSet(CustomModelViewSet):
    permission_classes = []
    queryset = NewCustomer.objects.filter()
    serializer_class = NewCustomerSerializer

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


class StageCountView(APIView):
    permission_classes = [isLogin]

    def get(self,request):
        data = []
        stage_progress = Option.objects.filter(type=Option.STAGE_PROGRESS, enable=True).order_by('sort')
        user = request.user
        time_now = timezone.now().strftime('%Y-%m-%d')
        for stage in stage_progress:
            new_customers = NewCustomer.objects.filter(track_user=user, stage_progress=stage)
            stage_count = {
                'stage': stage.name,
                'total': 0,
                'today_count': 0,
                'overdue_count': 0,
            }
            if new_customers:
                stage_count = {
                    'stage': stage.name,    # 阶段名称
                    'total': new_customers.count(),   # 总人数
                    'today_count': new_customers.filter(next_time=time_now).count(),  # 今日人数
                    'overdue_count': new_customers.filter(next_time__lt=time_now).count()  # 逾期人数
                }
            data.append(stage_count)
        return response_ok(data)