ASJServer/AdminController/CloudServiceManage/AgentCustomerController.py

# -*- encoding: utf-8 -*-
"""
@File    : AgentCustomerController.py
@Time    : 2024/3/7 16:56
@Author  : stephen
@Email   : zhangdongming@asj6.wecom.work
@Software: PyCharm
"""
import time
import json

from django.http import QueryDict
from django.views import View
from django.core.paginator import Paginator
from datetime import datetime

from AgentModel.models import AgentCustomerInfo, AgentCustomerCard, AgentCustomerPackage, AgentCloudServicePackage, \
    AgentDeviceOrder
from Model.models import UnicomCombo, Store_Meal, Device_User

from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject


class AgentCustomerView(View):
    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation')
        return self.validation(request.GET, request, operation)

    def post(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation')
        return self.validation(request.POST, request, operation)

    def delete(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation')
        delete = QueryDict(request.body)
        if not delete:
            delete = request.GET
        return self.validation(delete, request, operation)

    def put(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation')
        put = QueryDict(request.body)
        return self.validation(put, request, operation)

    def validation(self, request_dict, request, operation):
        AgentCustomerInfo.objects.filter()
        language = request_dict.get('language', 'en')
        response = ResponseObject(language, 'pc')
        if operation == 'getUnicomAndIcloud':
            return self.get_unicom_and_icloud(response)
        else:
            tko = TokenObject(
                request.META.get('HTTP_AUTHORIZATION'),
                returntpye='pc')
            if tko.code != 0:
                return response.json(tko.code)
            response.lang = tko.lang
            userID = tko.userID
            # 代理用户界面（代理顾客个人信息）
            if operation == 'getAgentInfo':
                return self.get_agent_info(userID, response)

            # 代理云存套餐
            elif operation == 'getAgentServicePackage':
                return self.get_agent_service_package(request_dict, response)
            elif operation == 'addAgentServicePackage':
                return self.add_agent_service_package(userID, request_dict, response)
            elif operation == 'updateAgentServicePackage':
                return self.update_agent_service_package(userID, request_dict, response)
            elif operation == 'delAgentServicePackage':
                return self.del_agent_service_package(request_dict, response)

            # 代理客户绑定套餐
            elif operation == 'getCustomerList':
                return self.get_customer_list(request_dict, response)
            elif operation == 'getCustomerPackageList':
                return self.get_cumstomer_package_list(request_dict, response)
            elif operation == 'batchAddCustomerPackage':
                return self.batch_add_customer_package(userID, request_dict, response)
            elif operation == 'batchDeleteCustomerPackage':
                return self.batch_del_cumstomer_package(request_dict, response)
            elif operation == 'getAgentServicePackageList':
                return self.get_agent_service_package_list(response)
            else:
                return response.json(444, 'operation')

    def get_unicom_and_icloud(self, response):
        """
        查询云存储套餐和物联网卡套餐列表
        @param response: 响应对象
        @return:
        """
        try:
            # 云存储套餐查询，只包括is_show=1的记录
            store_meals = Store_Meal.objects.filter(is_show=1).values('id', 'bucket__bucket').distinct()

            # 联通套餐查询，只包括is_show=1且未被删除的记录
            unicom_combos = UnicomCombo.objects.filter(is_show=1, is_del=False).values('id', 'combo_name').distinct()

            # 将查询结果转换为列表
            store_meal_list = [{'id': meal['id'], 'name': meal['bucket__bucket']} for meal in store_meals]
            unicom_combo_list = [{'id': combo['id'], 'name': combo['combo_name']} for combo in unicom_combos]

            # 合并结果并返回
            return response.json(0, {
                'storeMeals': store_meal_list,
                'unicomCombos': unicom_combo_list,
            })
        except Exception as e:
            print(e)
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    def get_agent_info(self, userID, response):
        """
        查询用户信息
        @param userID: userID
        @param response: 响应对象
        @return:
        """
        try:
            # 使用userID查询AgentCustomerInfo获取基本信息
            agent_info = AgentCustomerInfo.objects.filter(user_id=userID, status=1).first()
            if not agent_info:
                return response.json(444, {'error': '没有找到这个代理用户'})
            # userID查询用户电话
            device_user_qs = Device_User.objects.filter(userID=userID).first()

            # 代理客户ID（ac_id）查询AgentCustomerCard获取银行卡信息。
            card_details = AgentCustomerCard.objects.filter(ac_id=agent_info.id, status=1).first()

            # ac_id查询AgentCustomerPackage来找到关联的云服务套餐ID（cs_id）
            package_ids = AgentCustomerPackage.objects.filter(ac_id=agent_info.id).values_list('cs_id',
                                                                                               flat=True)
            # cs_id查询AgentCloudServicePackage获取服务套餐详情。
            service_packages = AgentCloudServicePackage.objects.filter(id__in=package_ids, status=1).values()

            result = {
                'agent_info': {
                    'ac_id': agent_info.id,
                    'company_name': agent_info.company_name,
                    'phone': device_user_qs.phone,
                    'created_time': agent_info.created_time,
                    'service_packages': list(service_packages),
                }
            }

            if card_details:
                result['agent_info'].update({
                    'card_name': card_details.name,
                    'card_no': card_details.card_no,
                    'card_address': card_details.card_address,
                })

            return response.json(0, result)
        except Exception as e:
            return response.json({'error': str(e)}, status=500)



    def get_agent_service_package(self, request_dict, response):
        """
        查询所有代理云服务套餐
        @param request_dict: 请求参数
        @request_dict page: 页码
        @request_dict page_size: 查询分页数
        @param response: 响应对象
        @return:
        """
        page = int(request_dict.get('page', 1))
        page_size = int(request_dict.get('page_size', 10))
        try:
            # 查询所有有效的代理云服务套餐
            all_packages = AgentCloudServicePackage.objects.filter(status=1).order_by('-created_time')
            # 创建分页对象
            paginator = Paginator(all_packages, page_size)
            # 获取请求页的数据
            packages_page = paginator.page(page)
            # 准备响应数据，转换查询集为列表形式
            packages_list = list(packages_page.object_list.values(
                'id', 'service_name', 'package_id', 'type',
                'profit_type', 'cost', 'profit', 'status',
                'created_time', 'updated_time'
            ))
            # 返回分页数据
            return response.json(0, {
                'page': page,
                'page_size': page_size,
                'total': paginator.count,
                'num_pages': paginator.num_pages,
                'list': packages_list
            })
        except Exception as e:
            # 出错时返回错误信息
            return response.json({'error': str(e)}, status=500)

    def add_agent_service_package(self, userID, request_dict, response):
        """
        添加代理云服务套餐
        @param request_dict: 请求参数
        @request_dict package_id: 代理服务id
        @request_dict service_name: 代理服务名称
        @request_dict package_type: 套餐类型 1:云存,2:4G
        @response_dict profit_type: 利润分配类型 1:固定值,2:百分比
        @response_dict cost: 成本
        @response_dict profit: 利润值
        @param response: 响应对象
        @return:
        """
        package_id = request_dict.get('package_id', None)
        service_name = request_dict.get('service_name', None)
        package_type = int(request_dict.get('package_type', 0))  # 默认为0，确保类型安全
        profit_type = int(request_dict.get('profit_type', 1))  # 默认值为1
        profit = request_dict.get('profit', 0)
        cost = request_dict.get('cost', 0)

        try:
            # 创建AgentCloudServicePackage实例并保存
            if not all([package_id, service_name]):
                return response.json(444)
            if package_type == 1:
                query_set = Store_Meal.objects.filter(is_show=1, id=package_id)
            elif package_type == 2:
                query_set = UnicomCombo.objects.filter(is_show=1, is_del=False, id=package_id)
            else:
                return response.json(444, 'error package_type')
            if not query_set.exists():
                return response.json(173)
            AgentCloudServicePackage.objects.create(
                service_name=service_name,
                package_id=package_id,
                type=package_type,
                profit_type=profit_type,
                profit=profit,
                status=1,
                cost=cost,
                created_by=userID,
                created_time=int(time.time()),
                updated_by=userID,
                updated_time=int(time.time())
            )
            return response.json(0)
        except Exception as e:
            return response.json({'error': str(e)}, status=500)

    def update_agent_service_package(self, userID, request_dict, response):
        """
        更新代理云服务套餐
        @param request_dict: 请求参数
        @request_dict package_id: 代理服务id
        @request_dict service_name: 代理服务名称
        @response_dict profit_type: 利润分配类型 1:固定值,2:百分比
        @response_dict cost: 成本
        @response_dict profit: 利润值
        @param response: 响应对象
        @return:
        """
        id = request_dict.get('id', None)
        service_name = request_dict.get('service_name', None)
        profit_type = request_dict.get('profit_type', None)
        cost = request_dict.get('cost', None)
        profit = request_dict.get('profit', None)

        if not all([id, service_name, profit_type, cost, profit]):
            return response.json(444)

        try:
            ac_service_package = AgentCloudServicePackage.objects.get(pk=id)
            ac_service_package.service_name = service_name
            ac_service_package.profit_type = profit_type
            ac_service_package.cost = cost
            ac_service_package.profit = profit
            ac_service_package.updated_time = int(time.time())
            ac_service_package.updated_by = userID
            ac_service_package.save()
            return response.json(0)

        except AgentCloudServicePackage.DoesNotExist:
            return response.json(173)
        except Exception as e:
            return response.json({'error': str(e)}, status=500)

    def del_agent_service_package(self, request_dict, response):
        """
        删除代理云服务套餐
        @param userID: 用户ID（执行删除操作的用户）
        @param request_dict: 请求参数
        @request_dict package_id: 代理服务id
        @param response: 响应对象
        @return:
        """
        id = request_dict.get('id', None)
        if not id:
            return response.json(444, 'Missing package_id')
        try:
            ac_service_package = AgentCloudServicePackage.objects.get(pk=id)
            ac_service_package.delete()
            return response.json(0)

        except AgentCloudServicePackage.DoesNotExist:
            return response.json(173, 'Package does not exist.')

        except Exception as e:
            return response.json(500, {'error': str(e)})

    def get_customer_list(self, request_dict, response):
        """
        查询代理商信息，并进行分页处理
        @param request_dict: 请求对象，用于接收分页参数
        @param response: 响应对象
        @return:
        """
        # 接收分页参数
        page = int(request_dict.get('page', 1))
        page_size = int(request_dict.get('page_size', 10))

        # 查询AgentCustomerInfo表以获取代理商基本信息
        agent_infos = AgentCustomerInfo.objects.filter(status=1).values(
            'id', 'user_id', 'company_name'
        ).order_by('id')
        try:
            # 使用Paginator进行分页处理
            paginator = Paginator(agent_infos, page_size)
            # 获取请求页的数据
            packages_page = paginator.page(page)
            # 准备最终的代理商列表
            agents_list = []
            for agent_info in packages_page:
                # 查询Device_User表获取用户信息
                user_info = Device_User.objects.filter(userID=agent_info['user_id']).values('phone',
                                                                                            'userEmail').first()
                # 查询AgentCustomerCard表获取卡信息
                card_info = AgentCustomerCard.objects.filter(ac_id=agent_info['id']).values('name', 'card_no',
                                                                                            'card_address').first()

                # 组合信息
                agent_record = {
                    'id': agent_info['id'],
                    'company_name': agent_info['company_name'],
                    'user_id': agent_info['user_id'],
                    'phone': user_info.get('phone') if user_info else None,
                    'userEmail': user_info.get('userEmail') if user_info else None,
                    'card_name': card_info.get('name') if card_info else None,
                    'card_no': card_info.get('card_no') if card_info else None,
                    'card_address': card_info.get('card_address') if card_info else None,
                }
                agents_list.append(agent_record)
            return response.json(0, {'page': page, 'page_size': page_size, 'total': paginator.count,
                                     'num_pages': paginator.num_pages, 'list': agents_list})
        except Exception as e:
            print(e)
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    def get_cumstomer_package_list(self, request_dict, response):
        """
        查询代理商服务套餐列表
        @param response: 响应对象
        @return:
        """
        ac_id = request_dict.get('id', None)
        try:
            if ac_id is None:
                return response.json(444, 'Missing ac_id')
            # ac_id查询AgentCustomerPackage来找到关联的云服务套餐ID（cs_id）
            package_ids = AgentCustomerPackage.objects.filter(ac_id=ac_id).values_list('cs_id', flat=True)
            # cs_id查询AgentCloudServicePackage获取服务套餐详情。
            service_packages = AgentCloudServicePackage.objects.filter(id__in=package_ids, status=1).values()
            service_packages_list = list(service_packages)
            return response.json(0, {'service_packages': service_packages_list})

        except Exception as e:
            print(e)
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    def batch_add_customer_package(self, userID, request_dict, response):
        """
        代理商批量绑定服务套餐
        @param userID: 操作用户的ID
        @param request_dict: 请求参数，包含代理商ID和服务套餐ID列表
        @param response: 响应对象
        @return:
        """
        ac_id = request_dict.get('ac_id', None)  # 代理客户ID
        cs_ids = json.loads(request_dict.get('cs_ids', '[]'))  # 服务套餐ID列表

        # 校验输入
        if not ac_id:
            return response.json(444, 'Missing agent customer ID.')
        try:
            # 查询该代理客户已经绑定的服务套餐ID
            existing_cs_ids = AgentCustomerPackage.objects.filter(ac_id=ac_id).values_list('cs_id', flat=True)
            # 确定尚未绑定的服务套餐ID
            new_cs_ids = [cs_id for cs_id in cs_ids if cs_id not in existing_cs_ids]
            if not new_cs_ids:
                return response.json(444)
            # 过滤出存在且状态为有效的套餐ID
            valid_new_cs_ids = AgentCloudServicePackage.objects.filter(id__in=new_cs_ids, status=1).values_list('id',
                                                                                                                flat=True)
            # 准备批量创建的数据
            packages_to_bind = [
                AgentCustomerPackage(
                    ac_id=ac_id,
                    cs_id=cs_id,
                    created_by=userID,
                    updated_by=userID,
                    created_time=int(time.time()),
                    updated_time=int(time.time())
                )
                for cs_id in valid_new_cs_ids
            ]

            # 批量创建绑定关系
            AgentCustomerPackage.objects.bulk_create(packages_to_bind)

            return response.json(0)
        except Exception as e:
            print(e)
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    def batch_del_cumstomer_package(self, request_dict, response):
        """
        代理商解绑服务套餐
        @param request_dict: 请求参数
        @param request_dict ac_id: 代理客户id
        @param request_dict cs_ids: 代理套餐id表
        @param response: 响应对象
        @return:
        """
        ac_id = request_dict.get('ac_id', None)
        cs_ids = json.loads(request_dict.get('cs_id', '[]'))
        if ac_id is None or not cs_ids:
            return response.json(444)
        try:
            AgentCustomerPackage.objects.filter(ac_id=ac_id, cs_id__in=cs_ids).delete()
            return response.json(0)
        except Exception as e:
            print(e)
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))

    def get_agent_service_package_list(self, response):
        """
        查询云服务套餐列表 id + service_name
        @param response: 响应对象
        @return:
        """
        try:
            # 查询所有有效的代理云服务套餐
            all_packages = AgentCloudServicePackage.objects.filter(status=1).order_by('-created_time').values('id',
                                                                                                              'service_name')
            # 转换查询集为列表形式
            packages_list = list(all_packages)
            # 返回数据
            return response.json(0, {'packages': packages_list})
        except Exception as e:
            # 出错时返回错误信息
            return response.json(500, 'error_line:{}, error_msg:{}'.format(e.__traceback__.tb_lineno, repr(e)))