decorate/apps/customer/views.py

# coding=utf-8
from rest_framework.views import APIView
from django.db.models import Q
import traceback
import datetime
from django.db import transaction
from rest_framework.serializers import ValidationError
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, Review, NewCustomerRemind
from .serializers import ReportCustomerSerializer, NewCustomerSerializer, ReviewSerializer
from .filters import ReportCustomerFilter, NewCustomerFilter, ReviewFilter
from django.contrib.auth import get_user_model
from apps.order.models import ProgressDetails
from apps.order.serializers import Order, OrderSerializer
from apps.upload.models import Upload

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_id = request.POST.get('user')
        try:
            with transaction.atomic():
                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, enable=True).order_by(
                    'sort').first()
                stage_progress = Option.objects.filter(type=Option.STAGE_PROGRESS, enable=True).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')

                customer = NewCustomer.objects.create(report_customer=instance, potential_level=potential_level,
                                                      track_user_id=user_id, stage_progress=stage_progress,
                                                      create_user=instance.create_user, store=instance.store,
                                                      name=instance.name, tel=instance.tel, village=instance.village,
                                                      address=instance.address, source=instance.source,
                                                      notes=instance.notes,
                                                      )
                projects = instance.project.all()
                for project in projects:
                    customer.project.add(project.id)
                NewCustomerRemind.objects.create(customer=customer, next_time=next_time, remind_user_id=user_id,)
                # 根据分配人所在店面，创建内部跟踪提醒
                remind_users = request.user.get_remind_users()
                for remind_user in remind_users:
                    NewCustomerRemind.objects.create(customer=customer, next_time=next_time, remind_user_id=remind_user,
                                                     is_employee=False)
        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 sign_hit(self, request, pk):
        check_permission(request, 'customer.check_report_customer')
        # 报备客户标记撞单
        try:
            with transaction.atomic():
                instance = ReportCustomer.objects.filter(id=pk).first()
                if not instance:
                    raise CustomError('当前客户报备信息有误,请刷新重试！')
                instance.check_user = self.request.user

                instance.report_status = ReportCustomer.REPEAT_REPORT
                instance.check_time = timezone.now()
                instance.save()
                BizLog.objects.addnew(request.user, BizLog.INSERT,
                                      u'标记客户[%s]为撞单,id=%d' % (instance.name, instance.id))

        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)
        level = Option.objects.filter(type=Option.POTENTIAL_LEVEL, enable=True)
        serializer_source = OptionComboboxSerializer(source, many=True)
        serializer_project = OptionComboboxSerializer(project, many=True)
        serializer_level = OptionComboboxSerializer(level, many=True)

        return response_ok({
            'source': serializer_source.data,
            'project': serializer_project.data,
            'level': serializer_level.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 = [isLogin, ]
    queryset = NewCustomer.objects.filter()
    serializer_class = NewCustomerSerializer

    @permission_required('customer.view_new_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) |
            Q(track_user=self.request.user)
        )
        f = NewCustomerFilter(self.request.GET, queryset=queryset)
        return f.qs

    def paginate_queryset(self, queryset):
        if self.paginator is None or self.request.GET.get('export'):
            return None
        return self.paginator.paginate_queryset(queryset, self.request, view=self)

    @action(methods=['post'], detail=True)
    def add_review(self, request, pk):
        # 添加跟踪报告
        check_permission(request, 'customer.add_review')
        description = request.POST.get('description')
        instruction = request.POST.get('instruction')
        is_entry = request.POST.get('is_entry') == '1'
        is_giveup = request.POST.get('is_giveup') == '1'
        potential_level = request.POST.get('potential_level')
        next_time = request.POST.get('next_time')

        try:
            with transaction.atomic():
                instance = NewCustomer.objects.filter(id=pk).first()
                if not instance:
                    raise CustomError('当前客户信息有误,请刷新重试！')
                data = {
                    'customer': instance.id,
                    'store': instance.store.id,
                    'create_user': request.user.id,
                    'description': description,
                    'instruction': instruction or None,
                    'is_entry': is_entry,
                    'is_giveup': is_giveup,
                }
                serializer = ReviewSerializer(data=data)
                if serializer.is_valid(raise_exception=True):
                    serializer.save()

            sort = 1
            track_day = 1
            try:
                sort = int(instance.stage_progress.sort)
                track_day = int(instance.stage_progress.track_day)
            except:
                pass
            # 预定客户，sort排序大于1，提交跟踪报告此字段为空
            if sort > 1 or not next_time:
                next_time = (timezone.now() + datetime.timedelta(days=track_day)).strftime('%Y-%m-%d')
            data = {
                'potential_level':potential_level or None, #预定客户，sort排序大于1，，无客户等级
                'next_time':next_time,
                'end_time':timezone.now(),
                'stage_progress':instance.stage_progress.id,
                'status':NewCustomer.NORMAL,
            }
            # TODO 如果客户已放弃，再次跟踪后自动改成正常客户，同时工单状态改成正常
            if instance.status == NewCustomer.ABANDONED:
                data['status'] = NewCustomer.NORMAL
                order = Order.objects.filter(customer=instance).first()
                if order:
                    order.status = Order.NORMAL
                    order.save()
            ser = self.serializer_class(instance, data=data, partial=True)
            if ser.is_valid(raise_exception=True):
                ser.save()

        except ValidationError as e:
            traceback.print_exc()
            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 add_order(self, request, pk):
        # 更新订单进度
        check_permission(request, 'order.update_order_process')
        stage_progress = request.POST.get('stage_progress')
        notes = request.POST.get('notes')

        try:
            with transaction.atomic():
                instance = NewCustomer.objects.filter(id=pk).first()
                if not instance:
                    raise CustomError('当前客户信息有误,请刷新重试！')
                order = Order.objects.filter(customer=instance).first()
                if order:
                    if order.stage_progress.end_stage:
                        raise CustomError('当前客户订单进度已到最后阶段，请勿重复更新！')
                    if order.status == Order.WAIT_DISPATCH:
                        raise CustomError('当前客户订单等待分配中，请勿重复更新！')
                    data = {
                        'status': Order.WAIT_DISPATCH,
                        'stage_progress': stage_progress,
                    }
                    ser = OrderSerializer(order, data=data, partial=True)
                    if ser.is_valid(raise_exception=True):
                        ser.save()
                else:
                    data = {
                        'status': Order.WAIT_DISPATCH,
                        'stage_progress_id': stage_progress,
                        'customer': instance,
                        'service_user': instance.track_user,
                        'store': instance.store,
                    }
                    ser = Order.objects.create(**data)
                    ser.notes = instance.notes
                    ser.no = ser.get_no()
                    ser.save()
                    projects = instance.project.all()
                    for project in projects:
                        ser.project.add(project.id)
                # 创建订单流程,保存图片
                user = self.request.user
                operation = u'更新进度为：{}'.format(order.stage_progress.name)
                progress_details = ProgressDetails.objects.create(order=order, user=user, operation=operation,
                                                                  notes=notes)
                for i in range(6):
                    file = request.data.get('file{}'.format(i))
                    if file:
                        upload = Upload.objects._addnew(instance.store, progress_details, user, file)
                        if not upload:
                            return response_error('上传失败，请重新上传！')

        except ValidationError as e:
            traceback.print_exc()
            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()


class StageCountView(APIView):
    permission_classes = [isLogin]

    @permission_required('customer.view_new_customer')
    def get(self, request):
        type = request.query_params.get('type') or 'user'
        id = request.query_params.get('id') or request.user.id
        data = []
        stage_progress = Option.objects.filter(type=Option.STAGE_PROGRESS, enable=True).order_by('sort').values('id','name')
        time_now = timezone.now().strftime('%Y-%m-%d')
        for stage in stage_progress:
            reminds = NewCustomerRemind.objects.filter(customer__stage_progress=stage['id'])
            if type == 'store':
                reminds = reminds.filter(customer__store_id=id, is_employee=True)
            elif type == 'user':
                reminds = reminds.filter(remind_user_id=id)
            elif type == 'agent':
                reminds = reminds.filter(customer__store__agent_id=id, is_employee=True)
            elif type == 'general_agent':
                reminds = reminds.filter(customer__store__agent__general_agent_id=id, is_employee=True)

            # new_customers = NewCustomer.objects.filter(
            #     Q(track_user=user) |
            #     Q(track_user__store_id__in=request.user.get_manager_range()),
            #     stage_progress=stage['id'])

            stage_count = {
                'stage_id': stage['id'],  # 阶段id
                'stage': stage['name'],  # 阶段名称
                'total_count': reminds.count(),  # 总人数
                'today_count': reminds.filter(next_time=time_now).count(),  # 今日人数
                'overdue_count': reminds.filter(next_time__lt=time_now).count()  # 逾期人数
            }
            data.append(stage_count)
        return response_ok(data)


class GetReviewViewSet(CustomModelViewSet):
    permission_classes = [isLogin]
    queryset = Review.objects.filter()
    serializer_class = ReviewSerializer

    @permission_required('customer.view_new_customer')
    def filter_queryset(self, queryset):
        queryset = queryset.filter()
        f = ReviewFilter(self.request.GET, queryset=queryset)
        return f.qs


class ReviewViewSet(CustomModelViewSet):
    permission_classes = [isLogin]
    queryset = Review.objects.filter()
    serializer_class = ReviewSerializer

    @permission_required('customer.check_review')
    def filter_queryset(self, queryset):
        queryset = queryset.filter(store_id__in=self.request.user.get_manager_range(), instruction__isnull=False)
        f = ReviewFilter(self.request.GET, queryset=queryset)
        return f.qs

    @action(methods=['post'], detail=True)
    def track_review(self, request, pk):
        check_permission(request, 'customer.check_review')
        # 跟踪审核
        check_status = request.POST.get('check_status')
        check_comment = request.POST.get('check_comment')
        next_time = request.POST.get('next_time')
        try:
            instance = Review.objects.filter(id=pk).first()
            if int(check_status) == Review.KEEPUP:
                instance.check_user = request.user
                instance.check_status = check_status
                instance.check_comment = check_comment
                instance.check_time = timezone.now()
                instance.save()
            if int(check_status) == Review.ABANDON:
                instance.check_user = request.user
                instance.check_status = check_status
                instance.check_comment = check_comment
                instance.check_time = timezone.now()
                instance.save()
                instance.customer.status = NewCustomer.ABANDONED
                # TODO 如果客户已下单，把工单状态改成放弃
                order = Order.objects.filter(customer=instance.customer).first()
                if order:
                    order.status = Order.ABANDONED
                    order.save
            instance.customer.next_time = next_time
            instance.customer.save()
        except CustomError as e:
            return response_error(e.get_error_msg())
        except Exception as e:
            return response_error(str(e))
        return response_ok()