ASJServer/Controller/RegionController.py

import json
import time

from django.db.models import F
from django.views import View

from Model.models import RegionModel, CountryModel, LanguageModel, CountryLanguageModel, App_Info
from Object.TokenObject import TokenObject
from Object.uidManageResponseObject import uidManageResponseObject
from Service.CommonService import CommonService


class RegionView(View):

    def get(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation', None)
        request_dict = request.GET
        return self.validate(request_dict, operation)

    def post(self, request, *arg, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation', None)
        request_dict = request.POST
        return self.validate(request_dict, operation)

    def validate(self, request_dict, operation):
        response = uidManageResponseObject()
        if operation == 'getCountry':
            return self.get_country(request_dict, response)
        elif operation == 'getCountryAndDomainName':  # 获取国家和域名
            return self.get_country_and_domain_name(request_dict, response)
        else:
            token = TokenObject(request_dict.get('token', None))
            if token.code != 0:
                return response.json(token.code)

            if operation == 'add':
                return self.do_add(token.userID, request_dict, response)
            elif operation == 'update':
                return self.do_update(token.userID, request_dict, response)
            elif operation == 'delete':
                return self.do_delete(token.userID, request_dict, response)
            elif operation == 'list':
                return self.do_list(token.userID, request_dict, response)
            elif operation == 'addCountry':
                return self.do_add_country(token.userID, request_dict, response)
            elif operation == 'updateCountry':
                return self.do_update_country(token.userID, request_dict, response)
            elif operation == 'deleteCountry':
                return self.do_delete_country(token.userID, request_dict, response)
            elif operation == 'listCountry':
                return self.do_list_country(token.userID, request_dict, response)
            else:
                return response.json(404)

    def do_add(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        name = request_dict.get('region', None)

        if name:
            region = RegionModel(name=name)
            region.save()

            return response.json(0)
        else:
            return response.json(444)

    def do_update(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        id = request_dict.get('id', None)
        name = request_dict.get('region', None)

        if id and name:
            region_qs = RegionModel.objects.filter(id=id)
            if region_qs.exists():
                region = region_qs[0]
                region.name = name
                region.save()
                return response.json(0)
            else:
                return response.json(173)
        else:
            return response.json(444)

    def do_delete(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        id = request_dict.get('id', None)

        if id:
            region_qs = RegionModel.objects.filter(id=id)
            if region_qs.exists():
                region_qs.delete()
                return response.json(0)
            else:
                return response.json(173)
        else:
            return response.json(444)

    def do_list(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        page = request_dict.get('page', None)
        line = request_dict.get('limit', None)

        if page and line:
            page = int(page)
            line = int(line)

            start = (page - 1) * line
            end = start + line

            region_qs = RegionModel.objects.filter()
            count = region_qs.count()

            region_qs = region_qs[start: end].values()

            res = {
                'count': count,
                'data': list(region_qs)
            }

            return response.json(0, res)
        else:
            return response.json(444)

    def do_add_country(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        number = request_dict.get('number', None)
        region_id = request_dict.get('region_id', None)
        countries = request_dict.get('countries', None)
        countries_en = request_dict.get('countries_en', None)

        if number and region_id and countries:
            res = {
                '1': countries,
                '2': countries_en
            }
            now_time = int(time.time())
            # countries = json.loads(countries)

            country_qs = CountryModel.objects.filter(number=number)
            if not country_qs.exists():
                country = CountryModel(number=number, region_id=region_id, add_time=now_time, update_time=now_time,
                                       country_name=countries)
                country.save()
            else:
                country = country_qs[0]

            for item in res:
                country_language_qs = CountryLanguageModel.objects.filter(language_id=item, country_id=country.id)
                if not country_language_qs.exists():
                    countryLanguage = CountryLanguageModel(
                        country_name=res[item], language_id=item, country_id=country.id, add_time=now_time,
                        update_time=now_time)
                    countryLanguage.save()
            return response.json(0)
        else:
            return response.json(444)

    def do_update_country(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        id = request_dict.get('country_id', None)
        number = request_dict.get('number', None)
        region_id = request_dict.get('region_id', None)
        countries = request_dict.get('countries', None)

        if id and number and region_id and countries:

            country_qs = CountryModel.objects.filter(id=id)
            if not country_qs.exists():
                return response.json(173)

            now_time = int(time.time())
            countries = json.loads(countries)
            country = {
                'number': number,
                'region_id': region_id,
                'update_time': now_time,
            }

            country_qs.update(**country)

            return response.json(0)
        else:
            return response.json(444)

    def do_delete_country(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        id = request_dict.get('id', None)

        if id:
            country_qs = CountryModel.objects.filter(id=id)
            if country_qs.exists():
                country_qs.delete()
                return response.json(0)
            else:
                return response.json(173)
        else:
            return response.json(444)

    def do_list_country(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        region_id = request_dict.get('region_id', None)
        page = request_dict.get('page', None)
        line = request_dict.get('limit', None)

        if page and line:
            page = int(page)
            line = int(line)

            start = (page - 1) * line
            end = start + line

            region_qs = CountryLanguageModel.objects.filter(language_id=1)
            if region_id:
                region_qs = region_qs.filter(country__region__id=region_id)

            count = region_qs.count()

            if region_qs.exists():
                region_qs = region_qs[start: end].values('country_id', 'country_name', 'country__number',
                                                         'country__region__name', 'add_time', 'update_time')
            else:
                region_qs = []
            res = {
                'count': count,
                'data': list(region_qs)
            }

            return response.json(0, res)
        else:
            return response.json(444)

    def get_country(self, request_dict, response):
        type = request_dict.get('type', None)
        token = request_dict.get('token', None)
        time_stamp = request_dict.get('time_stamp', None)

        if token and time_stamp and type:
            token = int(CommonService.decode_data(token))
            time_stamp = int(time_stamp)

            now_time = int(time.time())
            distance = now_time - time_stamp

            if token != time_stamp or distance > 60000 or distance < -60000:  # 为了全球化时间控制在一天内
                return response.json(404)

            lang_qs = LanguageModel.objects.filter(lang=type)

            if not lang_qs.exists():
                lang_qs = LanguageModel.objects.filter(lang='en')

            lang = lang_qs[0]
            country_qs = CountryLanguageModel.objects.filter(language_id=lang.id).annotate(
                country__number=F('country')).values('country_name', 'country__number')

            return response.json(0, list(country_qs))
        else:
            return response.json(444)

    @staticmethod
    def get_country_and_domain_name(request_dict, response):
        """
        获取国家和域名
        @param request_dict: 请求数据
        @request_dict lang: 语言
        @request_dict app_bundle_id: app包id
        @request_dict time_stamp: 时间戳
        @request_dict time_stamp_token: 时间戳token
        @param response: 响应
        @return: response
        """
        lang = request_dict.get('lang', None)
        app_bundle_id = request_dict.get('app_bundle_id', None)
        time_stamp = request_dict.get('time_stamp', None)
        time_stamp_token = request_dict.get('time_stamp_token', None)

        if not all([lang, time_stamp, time_stamp_token]):
            return response.json(444)

        # AVSS不传app_bundle_id
        is_app = True
        if app_bundle_id is None:
            app_bundle_id = 'com.ansjer.zccloud'
            is_app = False

        try:
            # 时间戳token校验
            if not CommonService.check_time_stamp_token(time_stamp_token, time_stamp):
                return response.json(13)

            # 查询app名
            app_inf_qs = App_Info.objects.filter(appBundleId=app_bundle_id).values('appName')
            if not app_inf_qs.exists():
                return response.json(173)

            lang_qs = LanguageModel.objects.filter(lang=lang)
            if not lang_qs.exists():
                lang_qs = LanguageModel.objects.filter(lang='en')
            lang = lang_qs[0]

            # 根据app名返回相应域名
            app_name = app_inf_qs[0]['appName']
            country_qs = CountryLanguageModel.objects.filter(language_id=lang.id). \
                annotate(push_api=F('country__region__push_api'))
            if 'Zosi' in app_name:
                country_qs = country_qs.annotate(api=F('country__region__zosi_api'))
            elif 'Loocam' in app_name:
                country_qs = country_qs.annotate(api=F('country__region__loocam_api'))
            elif '新中性' in app_name:
                country_qs = country_qs.annotate(api=F('country__region__neutral_api'))
            else:
                country_qs = country_qs.annotate(api=F('country__region__api'))
            country_qs = country_qs.values('country_id', 'country_name', 'api', 'push_api').order_by('country_id')

            # app选择中国且不为中性,返回美洲域名
            if is_app:
                if '新中性' not in app_name:
                    for country in country_qs:
                        if country['country_id'] == 1:
                            country['push_api'] = 'https://push.dvema.com/'
                            if 'Zosi' in app_name:
                                country['api'] = 'https://api.zositech2.com/'
                            elif 'Loocam' in app_name:
                                country['api'] = 'https://api.loocam2.com/'
                            else:
                                country['api'] = 'https://www.dvema.com/'
                            break
            # AVSS
            else:
                for country in country_qs:
                    if country['country_id'] == 1:
                        country['api'] = 'https://www.zositechc.cn/'

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

    def get_country_info(self, userID, request_dict, response):
        # perm = ModelService.check_perm_uid_manage(userID, 0)
        # if not perm:
        #     return response.json(309)

        country_number = request_dict.get('country_number', None)

        if country_number:
            country_language_qs = CountryLanguageModel.objects.filter(country__number=country_number)
            if country_language_qs.exists():
                country_language_qs = country_language_qs
        pass