ASJServer/Controller/CloudStorage.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import base64
import json
import time
from urllib.parse import quote, parse_qs, unquote

import boto3
import paypalrestsdk
import datetime
import logging
import sys
from boto3.session import Session
from django.http import JsonResponse, HttpResponseRedirect, HttpResponse
from django.db import transaction
from django.views.generic.base import View
import jwt
from Ansjer.config import SERVER_DOMAIN, PAYPAL_CRD, SERVER_DOMAIN_SSL, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, \
    AWS_ARN, OAUTH_ACCESS_TOKEN_SECRET
from Controller.CheckUserData import DataValid
from Model.models import Device_Info, Order_Model, Store_Meal, VodHlsModel, UID_Bucket, StsCrdModel, \
    ExperienceContextModel, Pay_Type, CDKcontextModel, Device_User, SysMsgModel, Unused_Uid_Meal, PromotionRuleModel, \
    VideoPlaybackTimeModel, CouponModel, VodBucketModel, VodHlsSummary
from Object.AWS.S3Email import S3Email
from Object.AliPayObject import AliPayObject
from Object.AliSmsObject import AliSmsObject
from Object.RedisObject import RedisObject
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Object.UidTokenObject import UidTokenObject
from Service.CommonService import CommonService
from Object.m3u8generate import PlaylistGenerator
from Object.WechatPayObject import WechatPayObject
from django.db.models import Q, F, Count
from Controller.PaymentCycle import Paypal
from decimal import Decimal
from Service.PayService import PaymentService


# 设备信息添加
class CloudStorageView(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 validation(self, request_dict, request, operation):
        lang = request_dict.get('lang', 'en')
        response = ResponseObject(lang)
        if operation is None:
            return response.json(444, 'error path')
        elif operation == 'dopaypalcallback':  # paypal支付回调
            return self.do_pay_by_paypal_callback(request_dict, response)
        elif operation == 'doalicallback':  # 阿里支付回调
            return self.do_pay_by_ali_callback(request)
        elif operation == 'dowechatnotify':  # 微信支付回调
            return self.do_pay_by_wechat_callback(request, response)
        elif operation == 'getsignsts':  # 设备调用，获取sts令牌
            ip = CommonService.get_ip_address(request)
            return self.do_get_sign_sts(request_dict, ip, response)
        elif operation == 'storeplaylist':  # 设备调用，设备把视频上传到s3，同时把视频数据信息传给服务器，服务器存储播放内容
            return self.do_store_playlist(request_dict, response)
        elif operation == 'signplaym3u8':  # 根据sts播放m3u8 视频流
            return self.do_sign_play_m3u8(request_dict, response)
        elif operation == 'payOK':  # 支付成功
            return self.do_pay_ok(request_dict)
        elif operation == 'vodMsgEnd':  # 云存到期续费提醒   提前1天
            return self.do_vod_msg_end()
        elif operation == 'doRefund':  # 退款
            return self.do_refund(request_dict, response)

        else:
            token = request_dict.get('token', None)
            # 设备主键uid
            tko = TokenObject(token)
            if tko.code != 0:
                return response.json(tko.code)
            user_id = tko.userID
            if operation == 'createpayorder':  # 创建支付订单
                ip = CommonService.get_ip_address(request)
                return self.do_create_pay_order(request_dict, user_id, ip, response)
            elif operation == 'changevodstatus':  # 修改云存状态，传送两个url，即getsignsts接口和storeplaylist接口
                return self.do_change_vod_status(request_dict, user_id, response)
            elif operation == 'queryvodlist':  # 获取视频播放列表
                return self.do_query_vod_list(request_dict, user_id, response)
            elif operation == 'commoditylist':  # 查询套餐列表
                return self.do_commodity_list(request_dict, response)
            elif operation == 'queryorder':  # 查询订单列表
                return self.do_query_order(request_dict, user_id, response)
            elif operation == 'experienceorder':  # 生成体验订单
                return self.do_experience_order(request_dict, user_id, response)
            elif operation == 'experiencereset':  # 重置设备云存体验
                return self.do_experience_reset(request_dict, response)
            elif operation == 'deletevodlist':  # 删除播放列表
                return self.delete_vod_list(request_dict, user_id, response)
            elif operation == 'devicecommodity':  # 设备关联套餐列表
                return self.device_commodity(request_dict, user_id, response)
            elif operation == 'switchdevicecommodity':  # 提前使用设备关联套餐
                return self.switch_device_commodity(request_dict, user_id, response)
            elif operation == 'hasvod':  # APP的回放界面，日历表显示当天有无录像
                return self.has_vod(request_dict, user_id, response)
            elif operation == 'videoPlaybackTime':  # 记录app播放时间
                return self.video_playback_time(request_dict, user_id, response)
            else:
                return response.json(414)

    @staticmethod
    def do_query_order(request_dict, user_id, response):  # 查询订单列表
        status = request_dict.get('status', None)
        page = int(request_dict.get('page', None))
        line = int(request_dict.get('line', None))
        uid = request_dict.get('uid', None)
        order_qs = Order_Model.objects.filter(userID_id=user_id)
        if status:
            order_qs = order_qs.filter(status=status)
        # 筛选指定设备id的订单
        if uid:
            order_qs = order_qs.filter(UID=uid)
        if not order_qs.exists():
            return response.json(173)
        count = order_qs.count()
        order_ql = order_qs[(page - 1) * line:page * line].values("orderID", "UID", "channel", "desc", "price",
                                                                  "currency", "addTime", "updTime", "endTime",
                                                                  "pay_url", "payType", "status", "commodity_type",
                                                                  "commodity_code")
        order_list = list(order_ql)
        data = []
        new_time = int(time.time())
        # 这里需要进行优化
        uid_list = []
        for od in order_list:
            uid_list.append(od['UID'])
        did_qs = Device_Info.objects.filter(userID_id=user_id, UID__in=uid_list).values('id', 'UID', 'Type')
        for d in order_list:
            if d['status'] == 0:
                if d['addTime'] + 3600 < new_time:
                    d['status'] = 3
            for did in did_qs:
                if d['UID'] == did['UID']:
                    d['did'] = did['id']
                    d['Type'] = did['Type']
                    data.append(d)
        return response.json(0, {'data': data, 'count': count})

    @staticmethod
    def do_commodity_list(request_dict, response):  # 查询套餐列表
        mold = request_dict.get('mold', None)
        uid = request_dict.get('uid', None)
        lang = request_dict.get('lang', 'en')
        new_time = int(time.time())
        # DVR/NVR设备暂不返回云存套餐列表
        device_info_qs = Device_Info.objects.filter(Q(UID=uid), Q(Type__lte=4) | Q(Type=10001))
        if device_info_qs.exists():
            return response.json(0)

        qs = Store_Meal.objects
        eq = ExperienceContextModel.objects.filter(uid=uid, experience_type=0).values('id')

        if mold:
            qs = qs.filter(bucket__mold=mold, lang__lang=lang)
        else:
            qs = qs.filter(lang__lang=lang)

        if eq:
            qs = qs.filter(~Q(pay_type='10'))
        else:
            qs = qs.filter(pay_type='10')

        qs = qs.filter(~Q(pay_type='11'))  # 过滤不显示激活码套餐
        qs = qs.filter(is_show=0)  # 过滤隐藏套餐
        qs = qs.annotate(title=F('lang__title'), content=F('lang__content'),
                         discount_content=F('lang__discount_content'))
        qs = qs.order_by('sort').values("id", "title", "content", "price", "day", "currency", "bucket__storeDay",
                                        "bucket__bucket", "bucket__area", "commodity_code",
                                        "commodity_type", "is_discounts", "virtual_price", "expire",
                                        "discount_price", "discount_content", "symbol", "cycle_config_id")

        if qs.exists():
            ql = list(qs)
            from operator import itemgetter
            from itertools import groupby
            ql.sort(key=itemgetter('bucket__area'))
            res = []
            for area, items in groupby(ql, key=itemgetter('bucket__area')):
                items_list = list(items)
                for key, val in enumerate(items_list):
                    pay_types = Pay_Type.objects.filter(store_meal=items_list[key]['id']).values("id", "payment")
                    items_list[key]['pay_type'] = list(pay_types)
                    items_list[key]['is_pay_cycle'] = 1 if items_list[key]['cycle_config_id'] else 0
                    del items_list[key]['cycle_config_id']
                res_c = {'area': area, 'items': items_list}
                res.append(res_c)
            # 是否促销
            promotion = PromotionRuleModel.objects.filter(status=1, startTime__lte=new_time,
                                                          endTime__gte=new_time).values('id', 'ruleConfig', 'ruleName',
                                                                                        'startTime', 'endTime',
                                                                                        'ruleDesc')
            if promotion.exists():
                promotion = {
                    'is_promotion': 1,
                    'promotionStartTime': promotion[0]['startTime'],
                    'promotionEndTime': promotion[0]['endTime'],
                    'promotionName': json.loads(promotion[0]['ruleName']).get(lang, ''),
                    'promotionDesc': json.loads(promotion[0]['ruleDesc']).get(lang, ''),
                    'nowTime': int(time.time())
                }
            else:
                promotion = {
                    'is_promotion': 0
                }
            result = {
                'meals': res,
                'extra':
                    {
                        'cloud_banner': SERVER_DOMAIN + 'web/images/cloud_cn_banner.png',
                        'cloud_en_baner': SERVER_DOMAIN_SSL + 'web/images/cloud_en_banner.png'
                    },
                'promotion': promotion,
            }
            return response.json(0, result)
        else:
            return response.json(0)

    @staticmethod
    def do_sign_play_m3u8(request_dict, response):  # 根据sts播放m3u8 视频流
        uid = request_dict.get('uid', None)
        uid = jwt.decode(uid, OAUTH_ACCESS_TOKEN_SECRET, algorithms='HS256').get('uid', '')
        channel = request_dict.get('channel', None)
        store_time = request_dict.get('time', None)
        now_time = int(time.time())
        vh_qs = VodHlsModel.objects.filter(uid=uid, channel=channel, time=store_time, endTime__gte=now_time).values(
            "sec", "fg", "bucket__bucket", "bucket__endpoint", "bucket__region", "bucket__mold")
        if not vh_qs.exists():
            return response.json(173)
        fg = vh_qs[0]['fg']
        bucket__region = vh_qs[0]['bucket__region']
        bucket_name = vh_qs[0]['bucket__bucket']
        print(bucket__region)
        print(bucket_name)

        session = Session(
            aws_access_key_id=AWS_ACCESS_KEY_ID[vh_qs[0]["bucket__mold"]],
            aws_secret_access_key=AWS_SECRET_ACCESS_KEY[vh_qs[0]["bucket__mold"]],
            region_name=bucket__region
        )

        conn = session.client('s3')
        playlist_entries = []
        fg = int(fg)
        # ts_count = fg & 0xf
        # fg 64位整型，低四位代表ts文件总数，然后进行位运算，一次移四位，每四位转为十进制即为当前ts文件的秒数
        for i in range(15):
            shift = (i + 1) * 4
            duration = (fg >> shift) & 0xf
            if duration > 0:
                ts_file = '{uid}/vod{channel}/{time}/ts{i}.ts'.format(uid=uid, channel=channel, time=store_time, i=i)
                response_url = conn.generate_presigned_url(
                    'get_object',
                    Params={
                        'Bucket': bucket_name,
                        'Key': ts_file
                    },
                    ExpiresIn=3600
                )
                playlist_entries.append({
                    'name': response_url,
                    'duration': duration,
                })

        playlist = PlaylistGenerator(playlist_entries).generate()
        response = HttpResponse(playlist)
        response['Content-Type'] = 'application/octet-stream'
        response['Content-Disposition'] = 'attachment;filename="play.m3u8"'
        return response

    @staticmethod
    def do_get_sign_sts(request_dict, ip, response):  # 获取sts令牌
        uid_token = request_dict.get('uidToken', None)
        utko = UidTokenObject(uid_token)
        if utko.flag is False:
            return response.json(444, 'uidToken')
        uid = utko.UID
        channel = utko.channel
        print(channel)
        print(uid)
        now_time = int(time.time())
        ub_qs = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time, channel=channel).values("bucket__mold",
                                                                                                  "bucket__bucket",
                                                                                                  "bucket__endpoint",
                                                                                                  "bucket__region",
                                                                                                  "endTime").order_by(
            'addTime')[:1]
        if ub_qs.exists():
            # 亚马逊 s3 sts
            sts_qs = StsCrdModel.objects.filter(uid=uid, channel=channel). \
                values("addTime", "data")
            if sts_qs.exists():
                end_time = int(sts_qs[0]["addTime"]) + 5000
                if end_time > now_time:
                    print(end_time)
                    print(now_time)
                    res = json.loads(sts_qs[0]["data"])
                    return JsonResponse(status=200, data=res)
                # 套餐id
            storage = '{uid}/vod{channel}/'.format(uid=uid, channel=channel)
            bucket_name = ub_qs[0]['bucket__bucket']
            endpoint = ub_qs[0]['bucket__endpoint']
            region_id = ub_qs[0]['bucket__region']

            try:
                aws_access_key_id = AWS_ACCESS_KEY_ID[ub_qs[0]["bucket__mold"]]
                aws_secret_access_key = AWS_SECRET_ACCESS_KEY[ub_qs[0]["bucket__mold"]]
                aws_arn = AWS_ARN[ub_qs[0]["bucket__mold"]]
            except:
                res = {'code': 404, 'msg': 'mold not exists!'}
                return HttpResponse(json.dumps(res, ensure_ascii=False), content_type="application/json,charset=utf-8")

            boto3_sts = boto3.client(
                'sts',
                aws_access_key_id=aws_access_key_id,
                aws_secret_access_key=aws_secret_access_key,
                region_name=region_id
            )
            policy = {
                "Version": "2012-10-17",
                "Statement": [
                    {
                        "Effect": "Allow",
                        "Action": "s3:*",
                        "Resource": ["{aws_arn}:::{bucket_name}/{uid_channel}*".
                                     format(aws_arn=aws_arn, bucket_name=bucket_name, uid_channel=storage)]
                    }
                ]
            }
            response = boto3_sts.get_federation_token(
                Name='{role_name}'.format(role_name=uid + '_' + str(channel)),
                Policy=json.dumps(policy),
                DurationSeconds=7200
            )
            res = {
                'AccessKeyId': response['Credentials']['AccessKeyId'],
                'AccessKeySecret': response['Credentials']['SecretAccessKey'],
                'SessionToken': response['Credentials']['SessionToken'],
                'Expiration': response['Credentials']['Expiration'],
                'expire': 900,
                'endpoint': endpoint,
                'bucket_name': bucket_name,
                'arn': response['FederatedUser']['Arn'],
                'code': 0,
                'storage': storage,
                'endTime': ub_qs[0]['endTime'],
                'ip': ip,
                'region': region_id,
                'bucket_mold': ub_qs[0]['bucket__mold']
            }
            if sts_qs.exists():
                sts_qs.update(data=json.dumps(res, default=str), addTime=now_time)
            else:
                StsCrdModel.objects.create(uid=uid, channel=channel, data=json.dumps(res, default=str),
                                           addTime=now_time, type=1)
            return JsonResponse(status=200, data=res)
        res = {'code': 405, 'msg': 'Not purchased or expired!'}
        return HttpResponse(json.dumps(res, ensure_ascii=False), content_type="application/json,charset=utf-8")

    @staticmethod
    def do_query_vod_list(request_dict, user_id, response):  # 获取视频播放列表
        logger = logging.getLogger('info')
        into_time = int(time.time())

        start_time = int(request_dict.get('startTime', None))
        end_time = int(request_dict.get('endTime', None))
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)

        if uid == 'UWE2ZJ52SE4FX75U111A':
            logger.info({
                "intoTime": into_time,
            })

        dv_qs = Device_Info.objects.filter(userID_id=user_id, UID=uid, isShare=False).values('vodPrimaryUserID',
                                                                                             'vodPrimaryMaster')
        if not dv_qs.exists():
            return response.json(12)

        dv_qs_model_time_over = int(time.time())
        if uid == 'UWE2ZJ52SE4FX75U111A':
            logger.info({
                "intoTime": into_time,
                "dvQsModelOverTime": dv_qs_model_time_over,
            })

        if dv_qs[0]['vodPrimaryUserID'] != user_id:
            return response.json(10034)
        now_time = int(time.time())
        bv_qs = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time, channel=channel).values('bucket_id').order_by(
            'addTime')
        if not bv_qs.exists():
            return response.json(10030)

        uid_bucket_model_mime_over = int(time.time())
        logger.info({
            "intoTime": into_time,
            "dvQsModelOverTime": dv_qs_model_time_over,
            "UidBucketModelOverTime": uid_bucket_model_mime_over,
        })

        vh_qs = VodHlsModel.objects.filter(uid=uid, channel=channel, endTime__gte=now_time,
                                           time__range=(start_time, end_time)).values("id", "time", "sec", "fg",
                                                                                      "bucket_id")

        vod_play_list = []
        if not vh_qs.exists():
            return response.json(0, vod_play_list)

        # 不用关联外键查询，因为会查询非常慢
        bucket_qs = VodBucketModel.objects.values()
        regroup_bucket_qs = {}
        for bucket_dict in bucket_qs:
            regroup_bucket_qs[bucket_dict['id']] = bucket_dict

        vod_hls_model_time_over = int(time.time())
        logger.info({
            "intoTime": into_time,
            "dvQsModelOverTime": dv_qs_model_time_over,
            "UidBucketModelOverTime": uid_bucket_model_mime_over,
            "vodHlsModelOverTime": vod_hls_model_time_over,
        })
        bucket_mold = regroup_bucket_qs[vh_qs[0]['bucket_id']]['mold']
        bucket_region = regroup_bucket_qs[vh_qs[0]['bucket_id']]['region']
        aws_access_key_id = AWS_ACCESS_KEY_ID[bucket_mold]
        aws_secret_access_key = AWS_SECRET_ACCESS_KEY[bucket_mold]
        session = Session(
            aws_access_key_id=aws_access_key_id,
            aws_secret_access_key=aws_secret_access_key,
            region_name=bucket_region
        )
        conn = session.client('s3')
        uid_token = TokenObject().encryption(data={'uid': uid})

        aws_object_over_time = int(time.time())
        logger.info({
            "intoTime": into_time,
            "dvQsModelOverTime": dv_qs_model_time_over,
            "UidBucketModelOverTime": uid_bucket_model_mime_over,
            "vodHlsModelOverTime": vod_hls_model_time_over,
            "awsObjectOverTime": aws_object_over_time,
        })

        for vod in vh_qs:
            bucket_name = regroup_bucket_qs[vod['bucket_id']]['bucket']
            thumbs_png = '{uid}/vod{channel}/{time}/Thumb.jpeg'.format(uid=uid, channel=channel, time=vod['time'])
            response_url = conn.generate_presigned_url(
                'get_object',
                Params={
                    'Bucket': bucket_name,
                    'Key': thumbs_png
                },
                ExpiresIn=3600
            )
            vod_url = '{server_domain}/cloudstorage/signplaym3u8?' \
                      'uid={uid}&channel={channel}&time={time}&sign=tktktktk'. \
                format(server_domain=SERVER_DOMAIN_SSL, uid=uid_token, channel=channel, time=vod['time'])
            ts_num = int(vod['fg']) & 0xf
            vod_play_list.append({
                'start_time': vod['time'],
                'sign_url': vod_url,
                'thumb': response_url,
                'sec': vod['sec'],
                'ts_num': ts_num,
                'vod_id': vod['id']
            }),

        generate_presigned_over_time = int(time.time())
        if uid == 'UWE2ZJ52SE4FX75U111A':
            logger.info({
                "intoTime": into_time,
                "dvQsModelOverTime": dv_qs_model_time_over,
                "UidBucketModelOverTime": uid_bucket_model_mime_over,
                "vodHlsModelOverTime": vod_hls_model_time_over,
                "awsObjectOverTime": aws_object_over_time,
                "generatePresignedOverTime": generate_presigned_over_time,
            })

        return response.json(0, vod_play_list)

    @staticmethod
    def do_store_playlist(request_dict, response):  # 设备调用，上传视频到s3，同时把视频数据信息传给服务器，服务器存储播放内容
        uid_token = request_dict.get('uidToken', None)
        store_time = request_dict.get('time', None)
        sec = request_dict.get('sec', None)
        fg = request_dict.get('fg', None)
        utko = UidTokenObject(uid_token)
        if utko.flag is False:
            return response.json(444, 'uidToken')
        if not uid_token or not store_time or not sec:
            return response.json(0)
        pass
        sec = int(sec)
        uid = utko.UID
        channel = utko.channel
        print('UID:')
        print(uid)
        print('channel:')
        print(channel)
        now_time = int(time.time())
        ub_qs = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time, channel=channel).values("bucket__mold",
                                                                                                  "bucket__bucket",
                                                                                                  "bucket__endpoint",
                                                                                                  "bucket__region",
                                                                                                  "status",
                                                                                                  "bucket__storeDay",
                                                                                                  "bucket__id").order_by(
            'addTime')[:1]
        if ub_qs.exists():
            ub_qs_data = ub_qs[0]
            store_day = ub_qs_data['bucket__storeDay']
            bucket_id = ub_qs_data['bucket__id']
            end_time = int(store_time) + store_day * 86400
            if ub_qs_data['status'] == 1:
                VodHlsModel.objects.create(
                    uid=uid,
                    channel=channel,
                    time=store_time,
                    endTime=end_time,
                    bucket_id=bucket_id,
                    fg=fg,
                    sec=sec,
                )
                end_time_stamp = datetime.datetime.fromtimestamp(int(end_time))
                end_time_str = datetime.datetime(end_time_stamp.year, end_time_stamp.month, 1)
                end_time_stamp = CommonService.str_to_timestamp(end_time_str.strftime('%Y-%m-%d %H:%M:%S'))
                vod_hls_qs = VodHlsSummary.objects.filter(uid=uid, time=end_time_stamp)
                if vod_hls_qs.exists():
                    vod_hls = vod_hls_qs.first()
                    vod_hls.upload_frequency += 1
                    vod_hls.upload_duration += sec
                    vod_hls.updated_time = now_time
                    vod_hls.save()
                else:
                    VodHlsSummary.objects.create(uid=uid, time=end_time_stamp, created_time=now_time,
                                                 updated_time=now_time,
                                                 upload_duration=sec, upload_frequency=1)

                res = {'code': 0, 'msg': '存储成功'}
                return HttpResponse(json.dumps(res, ensure_ascii=False),
                                    content_type="application/json,charset=utf-8")
            else:
                res = {'code': 404, 'msg': '设备未开启'}
                return HttpResponse(json.dumps(res, ensure_ascii=False), content_type="application/json,charset=utf-8")
        else:
            res = {'code': 404, 'msg': '设备未购买'}
            return HttpResponse(json.dumps(res, ensure_ascii=False), content_type="application/json,charset=utf-8")

    @staticmethod
    def do_change_vod_status(request_dict, user_id, response):  # 修改云存状态
        uid = request_dict.get('uid', None)
        status = request_dict.get('status', None)
        channel = request_dict.get('channel', None)
        if not uid or not status or not channel:
            return response.json(444, 'uid,status,channel')
        dv_qs = Device_Info.objects.filter(userID_id=user_id, UID=uid, isShare=False, isExist=1).values(
            'vodPrimaryUserID')
        if not dv_qs.exists() or dv_qs[0]['vodPrimaryUserID'] != user_id:
            return response.json(12)
        ub_qs = UID_Bucket.objects.filter(channel=channel, uid=uid)
        if not ub_qs.exists():
            return response.json(10030)
        now_time = int(time.time())
        if now_time > ub_qs[0].endTime:
            return response.json(10031)
        ub_qs.update(status=status)
        if status == 0:
            return response.json(0)
        utko = UidTokenObject()
        utko.generate(data={'uid': uid, 'channel': channel})
        uid_tk_url = "{SERVER_DOMAIN_SSL}cloudstorage/getsignsts?uidToken={uidToken}". \
            format(uidToken=utko.token, SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
        store_hls_url = "{SERVER_DOMAIN_SSL}cloudstorage/storeplaylist?uidToken={uidToken}". \
            format(uidToken=utko.token, SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
        return response.json(0, {'uidTkUrl': uid_tk_url, 'storeHlsUrl': store_hls_url})

    @staticmethod
    def do_pay_error():
        response = HttpResponse()
        response.content = PaymentService.get_pay_error_content()
        return response

    @staticmethod
    def do_pay_ok(request_dict):  # 支付成功
        response = HttpResponse()
        lang = request_dict.get('lang', 'en')
        pay_type = request_dict.get('paytype', None)

        response.content = PaymentService.get_pay_ok_content(lang, pay_type)
        return response

    def do_pay_by_ali_callback(self, request):  # 阿里支付回调
        response = ResponseObject()
        data = request.POST.dict()
        try:
            pass_back_params = data["passback_params"]
            parmap = dict([(k, v[0]) for k, v in parse_qs(unquote(pass_back_params)).items()])
            lang = parmap["lang"]
            signature = data["sign"]
            data.pop('sign')
            order_id = data['out_trade_no']

            # redis加锁，防止订单重复
            redis_obj = RedisObject()
            is_lock = redis_obj.CONN.setnx(order_id + 'do_notify', 1)
            redis_obj.CONN.expire(order_id + 'do_notify', 60)
            if not is_lock:
                return response.json(5)

            order_qs = Order_Model.objects.filter(orderID=order_id, status=0)
            ali_pay_obj = AliPayObject()
            alipay = ali_pay_obj.conf()
            success = alipay.verify(data, signature)
            if success and data["trade_status"] in ("TRADE_SUCCESS", "TRADE_FINISHED"):
                print("trade succeed")

                order_list = order_qs.values("UID", "channel", "commodity_code", "rank", "isSelectDiscounts",
                                             "userID__userID", "userID__username", "coupon_id")
                userid = order_list[0]['userID__userID']
                username = order_list[0]['userID__username']
                uid = order_list[0]['UID']
                channel = order_list[0]['channel']
                rank = order_list[0]['rank']

                sm_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire")
                bucket_id = sm_qs[0]['bucket_id']
                if not sm_qs.exists():
                    return response.json(173)
                ub_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__storeDay",
                                                                  "bucket__region", "endTime", "use_status")
                expire = sm_qs[0]['expire']
                if order_list[0]['isSelectDiscounts'] == 1:
                    expire = sm_qs[0]['expire'] * 2
                # 是否有促销
                now_time = int(time.time())
                promotion = PromotionRuleModel.objects.filter(status=1, startTime__lte=now_time,
                                                              endTime__gte=now_time).values('id', 'ruleConfig')
                promotion_rule_id = ''
                if promotion.exists():
                    promotion_rule_id = promotion[0]['id']
                    expire = expire * 2
                with transaction.atomic():
                    if ub_qs.exists():
                        ubq = ub_qs[0]
                        if ubq['use_status'] == 1 and ubq['bucket_id'] == bucket_id:  # 套餐使用中并且相同套餐叠加过期时间
                            end_time = CommonService.calcMonthLater(expire, ubq['endTime'])
                            UID_Bucket.objects.filter(id=ubq['id']).update(uid=uid, channel=channel,
                                                                           bucket_id=bucket_id, endTime=end_time,
                                                                           updateTime=now_time)
                        else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
                            has_unused = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucket_id).values("id")
                            nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
                            if promotion.exists():
                                nums = nums + 1
                            if has_unused.exists():
                                Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
                            else:
                                Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=now_time, num=nums,
                                                               expire=sm_qs[0]['expire'], bucket_id=bucket_id)
                            UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                        uid_bucket_id = ubq['id']
                    else:
                        end_time = CommonService.calcMonthLater(expire)
                        ub_cqs = UID_Bucket.objects.create(uid=uid, channel=channel, bucket_id=bucket_id,
                                                           endTime=end_time, addTime=now_time, updateTime=now_time,
                                                           use_status=1)
                        uid_bucket_id = ub_cqs.id

                    dvq = Device_Info.objects.filter(UID=uid, vodPrimaryUserID='', vodPrimaryMaster='')
                    if dvq.exists():
                        dvq_set_update_dict = {
                            'vodPrimaryUserID': userid,
                            'vodPrimaryMaster': username
                        }
                        dvq.update(**dvq_set_update_dict)

                    # 核销coupon
                    if order_list[0]['coupon_id']:
                        CouponModel.objects.filter(id=order_list[0]['coupon_id']).update(use_status=2,
                                                                                         update_time=now_time)

                    order_qs.update(status=1, updTime=now_time, uid_bucket_id=uid_bucket_id,
                                    promotion_rule_id=promotion_rule_id)
                    date_time = time.strftime("%Y-%m-%d", time.localtime())
                    # 如果存在序列号,消息提示用序列号
                    device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
                    serial_number = device_info_qs[0]['serial_number']
                    device_type = device_info_qs[0]['Type']
                    if serial_number:
                        device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
                    else:
                        device_name = uid
                    sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + date_time + '已成功购买云存套餐',
                                         'Dear customer,you already subscribed the cloud storage package successfully for device ' + device_name + ' on ' + time.strftime(
                                             "%b %dth,%Y", time.localtime())]
                    self.do_vod_msg_notice(uid, channel, userid, lang, sys_msg_text_list, 'SMS_219738485')
                    red_url = "{SERVER_DOMAIN_SSL}web/paid2/success.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                    if lang != 'cn':
                        red_url = "{SERVER_DOMAIN_SSL}web/paid2/en_success.html".format(
                            SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                    redis_obj.del_data(key=order_id + 'do_notify')
                    return HttpResponseRedirect(red_url)
            return response.json(0, signature)
        except Exception as e:
            logger = logging.getLogger('info')
            logger.info('alipay----notify---------')
            logger.info(repr(e))
            logger.info(sys.exc_info())
            logger.info('alipay支付失败：----')
            logger.info("错误行数：{errLine}".format(errLine=e.__traceback__.tb_lineno))
            logger.info(repr(e))
            if order_qs:
                order_qs.update(status=10, promotion_rule_id=promotion_rule_id)
            redis_obj.del_data(key=order_id + 'do_notify')
            red_url = "{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            if lang != 'cn':
                red_url = "{SERVER_DOMAIN_SSL}web/paid2/en_fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            return HttpResponseRedirect(red_url)

    def do_pay_by_paypal_callback(self, request_dict, response):  # paypal支付回调
        logger = logging.getLogger('info')
        logger.info('---------进入paypal异步回调')
        payment_id = request_dict.get('paymentId', None)
        payer_id = request_dict.get('PayerID', None)
        order_id = request_dict.get('orderID', None)
        lang = request_dict.get('lang', 'en')

        logger.info("paymentID={paymentId},payerID={PayerID}".format(paymentId=payment_id, PayerID=payer_id))

        # redis加锁，防止订单重复
        redis_obj = RedisObject()
        is_lock = redis_obj.CONN.setnx(order_id + 'do_notify', 1)
        redis_obj.CONN.expire(order_id + 'do_notify', 60)
        if not is_lock:
            return response.json(5)
        try:
            order_qs = Order_Model.objects.filter(orderID=order_id, status=0)

            if not order_id:
                red_url = "{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                if lang != 'cn':
                    red_url = "{SERVER_DOMAIN_SSL}web/paid2/en_fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                return HttpResponseRedirect(red_url)

            paypalrestsdk.configure(PAYPAL_CRD)
            payment = paypalrestsdk.Payment.find(payment_id)
            print(payment)

            logger.info("payment------")
            logger.info(payment)

            payers = payment.execute({"payer_id": payer_id})
            logger.info(payers)
            print(payers)
            if not payers:
                red_url = "{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                if lang != 'cn':
                    red_url = "{SERVER_DOMAIN_SSL}web/paid2/en_fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                redis_obj.del_data(key=order_id + 'do_notify')
                return HttpResponseRedirect(red_url)
            print("Payment execute successfully")

            order_list = order_qs.values("UID", "channel", "commodity_code", "rank", "isSelectDiscounts",
                                         "userID__userID", "userID__username", "coupon_id")
            userid = order_list[0]['userID__userID']
            username = order_list[0]['userID__username']
            uid = order_list[0]['UID']
            channel = order_list[0]['channel']
            rank = order_list[0]['rank']
            sm_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire")
            bucket_id = sm_qs[0]['bucket_id']
            if not sm_qs.exists():
                return response.json(173)
            ub_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__storeDay", "bucket__region",
                                                              "endTime", "use_status")
            expire = sm_qs[0]['expire']

            if order_list[0]['isSelectDiscounts'] == 1:
                expire = sm_qs[0]['expire'] * 2
            # 是否有促销
            now_time = int(time.time())
            promotion = PromotionRuleModel.objects.filter(status=1, startTime__lte=now_time,
                                                          endTime__gte=now_time).values('id', 'ruleConfig')
            promotion_rule_id = ''
            if promotion.exists():
                promotion_rule_id = promotion[0]['id']
                expire = expire * 2
            with transaction.atomic():
                if ub_qs.exists():
                    ubq = ub_qs[0]
                    if ubq['use_status'] == 1 and ubq['bucket_id'] == bucket_id:  # 套餐使用中并且相同套餐叠加过期时间
                        end_time = CommonService.calcMonthLater(expire, ubq['endTime'])
                        UID_Bucket.objects.filter(id=ubq['id']).update(uid=uid, channel=channel, bucket_id=bucket_id,
                                                                       endTime=end_time, updateTime=now_time)
                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
                        has_unused = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucket_id).values("id")
                        nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
                        if promotion.exists():
                            nums = nums + 1
                        if has_unused.exists():
                            Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
                        else:
                            Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=now_time, num=nums,
                                                           expire=sm_qs[0]['expire'], bucket_id=bucket_id)
                        UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                    uid_bucket_id = ubq['id']
                else:
                    end_time = CommonService.calcMonthLater(expire)
                    ub_cqs = UID_Bucket.objects.create(uid=uid, channel=channel, bucket_id=bucket_id, endTime=end_time,
                                                       addTime=now_time, updateTime=now_time, use_status=1)
                    uid_bucket_id = ub_cqs.id

                dvq = Device_Info.objects.filter(UID=uid, vodPrimaryUserID='', vodPrimaryMaster='')
                if dvq.exists():
                    dvq_set_update_dict = {
                        'vodPrimaryUserID': userid,
                        'vodPrimaryMaster': username
                    }
                    dvq.update(**dvq_set_update_dict)

                # 核销coupon
                if order_list[0]['coupon_id']:
                    CouponModel.objects.filter(id=order_list[0]['coupon_id']).update(use_status=2, update_time=now_time)

                order_qs.update(status=1, updTime=now_time, uid_bucket_id=uid_bucket_id,
                                promotion_rule_id=promotion_rule_id)
                date_time = time.strftime("%Y-%m-%d", time.localtime())
                # 如果存在序列号,消息提示用序列号
                device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
                serial_number = device_info_qs[0]['serial_number']
                device_type = device_info_qs[0]['Type']
                if serial_number:
                    device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
                else:
                    device_name = uid
                sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + date_time + '已成功购买云存套餐',
                                     'Dear customer,you already subscribed the cloud storage package successfully for device ' + device_name + ' on ' + time.strftime(
                                         "%b %dth,%Y", time.localtime())]

                self.do_vod_msg_notice(uid, channel, userid, lang, sys_msg_text_list, 'SMS_219738485')

                red_url = "{SERVER_DOMAIN_SSL}web/paid2/success.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                if lang != 'cn':
                    red_url = "{SERVER_DOMAIN_SSL}web/paid2/en_success.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                redis_obj.del_data(key=order_id + 'do_notify')
                return HttpResponseRedirect(red_url)
        except Exception as e:
            logger.info('paypal支付失败：----')
            logger.info("错误行数：{errLine}".format(errLine=e.__traceback__.tb_lineno))
            logger.info(repr(e))
            if order_qs:
                order_qs.update(status=10, promotion_rule_id=promotion_rule_id)
            red_url = "{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            if lang != 'cn':
                red_url = "{SERVER_DOMAIN_SSL}web/paid2/en_fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            redis_obj.del_data(key=order_id + 'do_notify')
            return HttpResponseRedirect(red_url)

    def do_pay_by_wechat_callback(self, request, response):  # 微信支付回调

        logger = logging.getLogger('info')
        try:
            pay = WechatPayObject()
            data = pay.weixinpay_call_back(request.body)
            attach = data["attach"]
            parmap = dict([(k, v[0]) for k, v in parse_qs(unquote(attach)).items()])
            lang = parmap["lang"]
            trade_status = data['result_code']  # 业务结果  SUCCESS/FAIL
            out_trade_no = data['out_trade_no']  # 商户订单号
            order_qs = Order_Model.objects.filter(orderID=out_trade_no, status=0)
            promotion_rule_id = ''
            if trade_status == "SUCCESS":
                check_sign = pay.get_notifypay(data)
                order_list = order_qs.values("UID", "channel", "commodity_code", "rank", "isSelectDiscounts",
                                             "userID__userID", "userID__username", "status", "coupon_id")
                if not check_sign:
                    return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': '签名失败'}))
                order_id = out_trade_no

                # redis加锁，防止订单重复
                redis_obj = RedisObject()
                is_lock = redis_obj.CONN.setnx(order_id + 'do_notify', 1)
                redis_obj.CONN.expire(order_id + 'do_notify', 60)
                if not is_lock:
                    return response.json(5)

                logger.info(order_list[0]['UID'])
                logger.info(order_id)

                userid = order_list[0]['userID__userID']
                username = order_list[0]['userID__username']
                uid = order_list[0]['UID']
                channel = order_list[0]['channel']
                rank = order_list[0]['rank']
                sm_qs = Store_Meal.objects.filter(id=rank).values("day", "bucket_id", "bucket__storeDay", "expire")
                bucket_id = sm_qs[0]['bucket_id']
                if not sm_qs.exists():
                    return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': '套餐不存在'}))
                ub_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__storeDay",
                                                                  "bucket__region", "endTime", "use_status")
                expire = sm_qs[0]['expire']
                if order_list[0]['isSelectDiscounts'] == 1:
                    expire = sm_qs[0]['expire'] * 2
                # 是否有促销
                now_time = int(time.time())
                promotion = PromotionRuleModel.objects.filter(status=1, startTime__lte=now_time,
                                                              endTime__gte=now_time).values('id', 'ruleConfig')
                if promotion.exists():
                    promotion_rule_id = promotion[0]['id']
                    expire = expire * 2
                with transaction.atomic():
                    if ub_qs.exists():
                        ubq = ub_qs[0]
                        if ubq['use_status'] == 1 and ubq['bucket_id'] == bucket_id:  # 套餐使用中并且相同套餐叠加过期时间
                            end_time = CommonService.calcMonthLater(expire, ubq['endTime'])
                            UID_Bucket.objects.filter(id=ubq['id']).update(uid=uid, channel=channel,
                                                                           bucket_id=bucket_id,
                                                                           endTime=end_time, updateTime=now_time)
                        else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
                            has_unused = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucket_id).values("id")
                            nums = 2 if order_list[0]['isSelectDiscounts'] == 1 else 1
                            if promotion.exists():
                                nums = nums + 1
                            if has_unused.exists():
                                Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
                            else:
                                Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=now_time, num=nums,
                                                               expire=sm_qs[0]['expire'], bucket_id=bucket_id)
                            UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                        uid_bucket_id = ubq['id']
                    else:
                        end_time = CommonService.calcMonthLater(expire)
                        ub_cqs = UID_Bucket.objects.create(uid=uid, channel=channel, bucket_id=bucket_id,
                                                           endTime=end_time, addTime=now_time,
                                                           updateTime=now_time, use_status=1)
                        uid_bucket_id = ub_cqs.id

                    dvq = Device_Info.objects.filter(UID=uid, vodPrimaryUserID='', vodPrimaryMaster='')
                    if dvq.exists():
                        dvq_set_update_dict = {
                            'vodPrimaryUserID': userid,
                            'vodPrimaryMaster': username
                        }
                        dvq.update(**dvq_set_update_dict)

                    # 核销coupon
                    if order_list[0]['coupon_id']:
                        CouponModel.objects.filter(id=order_list[0]['coupon_id']).update(use_status=2,
                                                                                         update_time=now_time)

                    order_qs.update(status=1, updTime=now_time, uid_bucket_id=uid_bucket_id,
                                    promotion_rule_id=promotion_rule_id)
                    date_time = time.strftime("%Y-%m-%d", time.localtime())
                    # 如果存在序列号,消息提示用序列号
                    device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
                    serial_number = device_info_qs[0]['serial_number']
                    device_type = device_info_qs[0]['Type']
                    if serial_number:
                        device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
                    else:
                        device_name = uid
                    sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + date_time + '已成功购买云存套餐',
                                         'Dear customer,you already subscribed the cloud storage package successfully for device ' + device_name + ' on ' + time.strftime(
                                             "%b %dth,%Y", time.localtime())]
                    self.do_vod_msg_notice(uid, channel, userid, lang, sys_msg_text_list, 'SMS_219738485')
                    redis_obj.del_data(key=order_id + 'do_notify')
                    return HttpResponse("<xml>\
                      <return_code><![CDATA[SUCCESS]]></return_code>\
                      <return_msg><![CDATA[OK]]></return_msg>\
                    </xml>")
            else:
                order_qs.update(status=10, promotion_rule_id=promotion_rule_id)
            return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': '参数格式校验错误'}))
        except Exception as e:
            logger.info('wechat支付失败：----')
            logger.info("错误行数：{errLine}".format(errLine=e.__traceback__.tb_lineno))
            logger.info(repr(e))
            if order_qs:
                order_qs.update(status=10, promotion_rule_id=promotion_rule_id)
            redis_obj.del_data(key=order_id + 'do_notify')
            return HttpResponse(pay.xml_to_dict({'return_code': 'FAIL', 'return_msg': repr(e)}))

    @staticmethod
    def do_create_pay_order(request_dict, user_id, ip, response):  # 创建支付订单
        logger = logging.getLogger('info')
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)
        pay_type = int(request_dict.get('pay_type', None))
        rank = request_dict.get('rank', None)
        is_select_discount = request_dict.get('is_select_discount', 0)
        coupon_id = request_dict.get('coupon_id', 0)
        lang = request_dict.get('lang', 'en')
        if not all([uid, channel, pay_type, rank]):
            return response.json(444)
        dv_qs = Device_Info.objects.filter(userID_id=user_id, UID=uid, isShare=False, isExist=1).values(
            'vodPrimaryUserID',
            'vodPrimaryMaster')
        if not dv_qs.exists():
            return response.json(12)

        dvq = Device_Info.objects.filter(UID=uid)
        dvq = dvq.filter(~Q(vodPrimaryUserID='')).values('vodPrimaryUserID')
        if dvq.exists():
            if dvq[0]['vodPrimaryUserID'] != user_id:
                return response.json(10033)

        now_time = int(time.time())
        sm_qs = Store_Meal.objects.filter(id=rank, pay_type=pay_type, lang__lang=lang, is_show=0). \
            values('currency', 'price', 'lang__content', 'day', 'commodity_type', 'lang__title', 'expire',
                   'commodity_code', 'discount_price', 'bucket__mold', 'cycle_config_id')
        if not sm_qs.exists():
            return response.json(173)
        store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
                                                                                              'lang__content')
        if store_meal_qs.exists():
            store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
        else:
            store_meal_name = '未知套餐'
        currency = sm_qs[0]['currency']
        price = sm_qs[0]['price']
        if is_select_discount == '1':
            price = float(sm_qs[0]['price']) + float(sm_qs[0]['discount_price'])
        content = sm_qs[0]['lang__content']
        commodity_code = sm_qs[0]['commodity_code']
        commodity_type = sm_qs[0]['commodity_type']

        is_mold = 0  # 判断国内外
        if sm_qs[0]['bucket__mold'] == 0:
            is_mold = 1

        order_qs = Order_Model.objects.filter(UID=uid, rank__bucket__mold=is_mold)
        if order_qs.exists():
            return response.json(10041)

        order_id = CommonService.createOrderID()
        # 优惠券
        if coupon_id:
            coupon_obj = CouponModel.objects.filter(id=coupon_id, use_status=0, distribute_time__lte=now_time,
                                                    valid_time__gt=now_time)
            coupon_query = coupon_obj.values("id", "coupon_config__type", "coupon_config__coupon_discount")
            if not coupon_query.exists():
                return response.json(10049)
            price = Decimal(price)
            coupon_discount = Decimal(coupon_query[0]['coupon_config__coupon_discount'])
            if coupon_query[0]['coupon_config__type'] == 1:  # 打折
                price = coupon_discount / 10 * price
            elif coupon_query[0]['coupon_config__type'] == 2:  # 抵扣
                price = price - coupon_discount
        price = float(price)
        if price < 0 or price == 0 or price < 0.01:
            price = 0.01
        price = round(price, 2)
        if pay_type == 1:
            # 订阅周期扣款
            if sm_qs[0]['cycle_config_id']:
                # 查询是否有订阅过，活跃状态
                check_has_subscribe = Paypal.checkSubscriptions(user_id, uid, rank)
                if check_has_subscribe is False:
                    return response.json(10050)
                sub_info = Paypal.subscriptions(store_info=sm_qs[0], lang=lang, orderID=order_id, price=price)
                if not sub_info:
                    return response.json(10048)
                Order_Model.objects.create(orderID=order_id, UID=uid, channel=channel, userID_id=user_id,
                                           desc=content, payType=pay_type, payTime=now_time,
                                           price=price, currency=currency, addTime=now_time, updTime=now_time,
                                           pay_url=sub_info['url'], isSelectDiscounts=is_select_discount,
                                           commodity_code=commodity_code, commodity_type=commodity_type,
                                           rank_id=rank, plan_id=sub_info['plan_id'], coupon_id=coupon_id, ai_rank_id=1,
                                           store_meal_name=store_meal_name
                                           )

                return response.json(0, {"redirectUrl": sub_info['url'], "orderID": order_id})
            # 正常扣款
            cal_url = "{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            if lang != 'cn':
                cal_url = "{SERVER_DOMAIN_SSL}web/paid2/en_fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            call_sub_url = "{SERVER_DOMAIN_SSL}cloudstorage/dopaypalcallback?orderID={orderID}&lang={lang}". \
                format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, orderID=order_id, lang=lang)

            call_clc_url = cal_url
            paypalrestsdk.configure(PAYPAL_CRD)
            payment = paypalrestsdk.Payment({
                "intent": "sale",
                "payer": {"payment_method": "paypal"},
                "redirect_urls": {"return_url": call_sub_url, "cancel_url": call_clc_url},
                "transactions": [{
                    "item_list": {"items": [
                        {"name": "Cloud video", "sku": "1", "price": price, "currency": "USD", "quantity": 1}]},
                    "amount": {"total": price, "currency": currency},
                    "description": content}]})
            if payment.create():
                print("Payment created successfully")
            else:
                print(payment.error)
                return response.json(10, payment.error)
            print(payment)
            logger.info('paypal创建订单返回----------')
            logger.info(payment)
            payment_id = payment['id']  # 获取paymentID
            for link in payment.links:
                if link.rel == "approval_url":
                    approval_url = str(link.href)
                    print("Redirect for approval: %s" % approval_url)
                    Order_Model.objects.create(orderID=order_id, UID=uid, channel=channel, userID_id=user_id,
                                               desc=content, payType=pay_type, payTime=now_time,
                                               price=price, currency=currency, addTime=now_time, updTime=now_time,
                                               pay_url=approval_url, isSelectDiscounts=is_select_discount,
                                               commodity_code=commodity_code, commodity_type=commodity_type,
                                               rank_id=rank, paymentID=payment_id, coupon_id=coupon_id, ai_rank_id=1,
                                               store_meal_name=store_meal_name)
                    return response.json(0, {"redirectUrl": approval_url, "orderID": order_id})
            return response.json(10, 'generate_order_false')
        elif pay_type == 2:
            try:
                ali_pay_obj = AliPayObject()
                alipay = ali_pay_obj.conf()
                subject = sm_qs[0]['lang__title'] + sm_qs[0]['lang__content']
                order_string = alipay.api_alipay_trade_wap_pay(
                    out_trade_no=order_id,
                    total_amount=price,
                    subject=subject,
                    return_url="{SERVER_DOMAIN_SSL}web/paid2/success.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL),
                    notify_url="{SERVER_DOMAIN_SSL}cloudstorage/doalicallback".format(
                        SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL),
                    quit_url="{SERVER_DOMAIN_SSL}web/paid2/fail.html".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL),
                    passback_params=quote("lang=" + lang)
                )

            except Exception as e:
                print(repr(e))
                return response.json(10, repr(e))
            else:
                if order_string:
                    redirect_url = ali_pay_obj.alipay_prefix + order_string
                    print(redirect_url)
                    Order_Model.objects.create(orderID=order_id, UID=uid, channel=channel, userID_id=user_id,
                                               desc=content, payType=pay_type, payTime=now_time,
                                               price=price, currency=currency, addTime=now_time, updTime=now_time,
                                               pay_url=redirect_url, isSelectDiscounts=is_select_discount,
                                               commodity_code=commodity_code, commodity_type=commodity_type,
                                               rank_id=rank, coupon_id=coupon_id, ai_rank_id=1,
                                               store_meal_name=store_meal_name)

                    return JsonResponse(status=200, data={'result_code': 0, 'reason': 'success',
                                                          'result': {"redirectUrl": redirect_url, "orderID": order_id},
                                                          'error_code': 0})
                else:
                    return response.json(10, '生成订单错误.')

        elif pay_type == 3:
            pay = WechatPayObject()
            notify_url = "{SERVER_DOMAIN_SSL}cloudstorage/dowechatnotify".format(
                SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
            # 获取参数
            parameter_dict = pay.get_parameter(order_id, content, float(price) * 100, ip, notify_url,
                                               quote("lang=" + lang))
            print('parameter_dict', parameter_dict)
            # parameter_dict 参数中获取MWEB_URL 调转页面在路径后面添加redirect_url
            # 统一调用接口
            response = pay.re_finall(orderid=order_id)
            if not response:
                return response.json(10, '生成订单错误.')
            # 回调函数
            Order_Model.objects.create(orderID=order_id, UID=uid, channel=channel, userID_id=user_id,
                                       desc=content, payType=pay_type, payTime=now_time,
                                       price=price, currency=currency, addTime=now_time, updTime=now_time,
                                       pay_url=notify_url, isSelectDiscounts=is_select_discount,
                                       commodity_code=commodity_code, commodity_type=commodity_type, rank_id=rank,
                                       ai_rank_id=1, store_meal_name=store_meal_name)
            return JsonResponse(status=200, data={'result_code': 0, 'reason': 'success',
                                                  'result': response,
                                                  'orderId': order_id,
                                                  'error_code': 0})

    # 生成体验订单
    def do_experience_order(self, request_dict, user_id, response):
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)
        commodity_code = request_dict.get('commodity_code', None)
        pay_type = int(request_dict.get('pay_type', None))
        rank = request_dict.get('rank', None)
        cdk = request_dict.get('cdk', None)
        lang = request_dict.get('lang', 'en')

        if not all([uid]):
            return response.json(444)
        redis_obj = RedisObject()
        is_lock = redis_obj.CONN.setnx(uid + 'do_experience_order', 1)
        redis_obj.CONN.expire(uid + 'do_experience_order', 60)
        logger = logging.getLogger('info')
        if not is_lock:
            return response.json(5)

        if pay_type == 10:  # 判断是否已体验过套餐
            ec_qs = ExperienceContextModel.objects.filter(uid=uid, experience_type=0)
            if ec_qs.exists():
                return response.json(5)

        if cdk is not None and pay_type == 11:
            cdk_qs = CDKcontextModel.objects.filter(cdk=cdk).values('is_activate', 'rank__id', 'rank__commodity_code')
            if not cdk_qs.exists():
                return response.json(10040)
            if cdk_qs[0]['is_activate'] == 1:
                return response.json(10039)
            rank = cdk_qs[0]['rank__id']
            commodity_code = cdk_qs[0]['rank__commodity_code']

        if uid is None or channel is None or commodity_code is None or pay_type is None or rank is None:
            redis_obj.del_data(key=uid + 'do_experience_order')
            return response.json(13, '参数有误.')

        dvq = Device_Info.objects.filter(UID=uid)
        dvq = dvq.filter(~Q(vodPrimaryUserID='')).values('vodPrimaryUserID')
        if dvq.exists():
            if dvq[0]['vodPrimaryUserID'] != user_id:
                if pay_type == 10:
                    return response.json(10035)
                if pay_type == 11:
                    return response.json(10036)

        dv_qs = Device_Info.objects.filter(userID_id=user_id, UID=uid, isShare=False, isExist=1)
        if not dv_qs.exists():
            return response.json(12)

        order_id = CommonService.createOrderID()
        now_time = int(time.time())
        sm_qs = Store_Meal.objects.filter(id=rank, lang__lang=lang, is_show=0).values("day", "bucket_id",
                                                                                      "bucket__storeDay", "expire",
                                                                                      'lang__content', 'price',
                                                                                      'currency', 'commodity_type')
        if not sm_qs.exists():
            return response.json(173)
        bucket_id = sm_qs[0]['bucket_id']
        ub_qs = UID_Bucket.objects.filter(uid=uid).values("id", "bucket_id", "bucket__storeDay", "bucket__region",
                                                          "endTime", "use_status")
        expire = sm_qs[0]['expire']
        try:
            with transaction.atomic():
                if ub_qs.exists():
                    ubq = ub_qs[0]
                    if ubq['use_status'] == 1 and ubq['bucket_id'] == bucket_id:  # 套餐使用中并且相同套餐叠加过期时间
                        end_time = CommonService.calcMonthLater(expire, ubq['endTime'])
                        UID_Bucket.objects.filter(id=ubq['id']).update(uid=uid, channel=channel, bucket_id=bucket_id,
                                                                       endTime=end_time, updateTime=now_time)
                    else:  # 已过期或者不相同的套餐加入未使用的关联套餐表
                        has_unused = Unused_Uid_Meal.objects.filter(uid=uid, bucket_id=bucket_id).values("id")
                        nums = 1
                        if has_unused.exists():
                            Unused_Uid_Meal.objects.filter(id=has_unused[0]['id']).update(num=F('num') + nums)
                        else:
                            Unused_Uid_Meal.objects.create(uid=uid, channel=channel, addTime=now_time, num=nums,
                                                           expire=sm_qs[0]['expire'], bucket_id=bucket_id)
                        UID_Bucket.objects.filter(id=ubq['id']).update(has_unused=1)
                    uid_bucket_id = ubq['id']
                else:
                    end_time = CommonService.calcMonthLater(expire)
                    ub_cqs = UID_Bucket.objects.create(uid=uid, channel=channel, bucket_id=bucket_id, endTime=end_time,
                                                       addTime=now_time,
                                                       updateTime=now_time, use_status=1)
                    uid_bucket_id = ub_cqs.id
                store_meal_qs = Store_Meal.objects.filter(id=rank, lang__lang='cn', is_show=0).values('lang__title',
                                                                                                      'lang__content')
                if store_meal_qs.exists():
                    store_meal_name = store_meal_qs[0]['lang__title'] + '-' + store_meal_qs[0]['lang__content']
                else:
                    store_meal_name = '未知套餐'
                Order_Model.objects.create(orderID=order_id, UID=uid, channel=channel, userID_id=user_id,
                                           desc=sm_qs[0]['lang__content'], payType=pay_type, payTime=now_time,
                                           price=sm_qs[0]['price'], currency=sm_qs[0]['currency'], addTime=now_time,
                                           updTime=now_time,
                                           pay_url="体验版", store_meal_name=store_meal_name,
                                           commodity_code=commodity_code, commodity_type=sm_qs[0]['commodity_type'],
                                           rank_id=rank, status=1, uid_bucket_id=uid_bucket_id, ai_rank_id=1)

                duq = Device_User.objects.filter(userID=user_id).values('username')
                dvq = Device_Info.objects.filter(UID=uid, vodPrimaryUserID='', vodPrimaryMaster='')

                if dvq.exists():
                    dvq_set_update_dict = {
                        'vodPrimaryUserID': user_id,
                        'vodPrimaryMaster': duq[0]['username']
                    }
                    dvq.update(**dvq_set_update_dict)

                sms = 'SMS_219738485'
                date_time = time.strftime("%Y-%m-%d", time.localtime())
                # 如果存在序列号,消息提示用序列号
                device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
                serial_number = device_info_qs[0]['serial_number']
                device_type = device_info_qs[0]['Type']
                if serial_number:
                    device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
                else:
                    device_name = uid
                sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + date_time + '已成功购买云存套餐',
                                     'Dear customer,you already subscribed the cloud storage package successfully for device ' + device_name + ' on ' + time.strftime(
                                         "%b %dth,%Y", time.localtime())]

                return_url = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?lang={lang}".format(
                    SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, lang=lang)
                if pay_type == 10:
                    ExperienceContextModel.objects.create(
                        experience_type=0,
                        uid=uid,
                        do_time=now_time
                    )
                    return_url = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?paytype=10&lang={lang}".format(
                        SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, lang=lang)
                    date_time = time.strftime("%Y-%m-%d", time.localtime())
                    sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + date_time + '已成功开通云存体验套餐',
                                         'Dear customer,you already subscribed the free trial cloud storage service successfully for device ' + device_name + ' on ' + time.strftime(
                                             "%b %dth,%Y", time.localtime())]
                    sms = 'SMS_222870823'
                if pay_type == 11:
                    update_dict = {'is_activate': 1, 'order': order_id}
                    CDKcontextModel.objects.filter(cdk=cdk).update(**update_dict)
                    return_url = "{SERVER_DOMAIN_SSL}cloudstorage/payOK?paytype=11&lang={lang}".format(
                        SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL, lang=lang)

                    date_time = time.strftime("%Y-%m-%d", time.localtime())
                    sys_msg_text_list = ['温馨提示：尊敬的客户，您的' + device_name + '设备在' + date_time + '已成功兑换云存套餐',
                                         'Dear customer, you already redeemed for the cloud storage package successfully for device ' + device_name + ' on ' + time.strftime(
                                             "%b %dth,%Y", time.localtime())]
                    sms = 'SMS_219748439'

                self.do_vod_msg_notice(uid, channel, user_id, lang, sys_msg_text_list, sms)
                result = return_url
                redis_obj.del_data(key=uid + 'do_experience_order')
                return response.json(0, result)
        except Exception as e:
            logger.info('出错了~体验云存异常,errLine:{}, errMsg:{}'.format(e.__traceback__.tb_lineno, repr(e)))
            redis_obj.del_data(key=uid + 'do_experience_order')
            return response.json(474)

    # 重置设备云存体验
    @staticmethod
    def do_experience_reset(request_dict, response):
        bid = request_dict.get("id", None)
        ubq = UID_Bucket.objects.filter(id=bid)
        if ubq:
            eq = ExperienceContextModel.objects.filter(uid=ubq[0].uid)
            if eq:
                eq.delete()
                Order_Model.objects.filter(uid_bucket_id=bid).delete()
                ubq.delete()
            else:
                return response.json(10007)

        else:
            return response.json(0, '重置云存体验失败')

        return response.json(0, '重置云存体验成功')

    @staticmethod
    def delete_vod_list(request_dict, user_id, response):  # 删除播放列表
        uid = request_dict.get('uid', None)
        dv_qs = Device_Info.objects.filter(userID_id=user_id, UID=uid, isShare=False, isExist=1).values(
            'vodPrimaryUserID')
        if not dv_qs.exists() or dv_qs[0]['vodPrimaryUserID'] != user_id:
            return response.json(12)
        vod_id_list = json.loads(request_dict.get('vod_id_list', None))
        is_del_all = request_dict.get('is_del_all', 0)
        try:
            if is_del_all == 1:
                VodHlsModel.objects.filter(uid=uid).delete()
            else:
                if type(vod_id_list).__name__ != 'list':
                    return response.json(444)
                VodHlsModel.objects.filter(id__in=vod_id_list).delete()
        except Exception as e:
            return response.json(424, repr(e))
        else:
            return response.json(0)

    # 设备关联套餐列表
    @staticmethod
    def device_commodity(request_dict, user_id, response):
        uid = request_dict.get('uid', None)
        lang = request_dict.get('lang', 'en')
        dv_qs = Device_Info.objects.filter(userID_id=user_id, UID=uid, isShare=False, isExist=1).values(
            'vodPrimaryUserID', 'serial_number', 'Type')
        if not dv_qs.exists() or dv_qs[0]['vodPrimaryUserID'] != user_id:
            return response.json(12)
        now_time = int(time.time())
        bucket_id_list = []
        store_list = []
        uid_bucket = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time).values("id", "uid", "bucket__content",
                                                                                      "use_status", "endTime",
                                                                                      "has_unused", "bucket__id")
        if not uid_bucket:
            return response.json(10030)

        # 如果存在序列号返回完整序列号
        device_id = uid
        serial_number = dv_qs[0]['serial_number']
        device_type = dv_qs[0]['Type']
        if serial_number:
            device_id = CommonService.get_full_serial_number(uid, serial_number, device_type)

        uid_bucket[0]['uid'] = device_id
        uid_bucket[0]['storage'] = 0
        has_unused = uid_bucket[0]['has_unused']
        del uid_bucket[0]['has_unused']
        store_list.append(uid_bucket[0])
        bucket_id_list.append(uid_bucket[0]['bucket__id'])
        if has_unused == 1:
            unuseds = Unused_Uid_Meal.objects.filter(uid=uid).annotate(unused_id=F('id')).values("unused_id", "uid",
                                                                                                 "bucket__content",
                                                                                                 "num", "bucket__id",
                                                                                                 "expire")
            month = 'month' if lang != 'cn' else '个月'
            for ub in unuseds:
                storage_time = ub['num'] * ub['expire']
                if lang != 'cn' and storage_time > 1:  # 英文大于一个月使用复数
                    month += 's'
                storage = "{storage_time}{month}".format(storage_time=storage_time, month=month)
                unused_dict = {
                    "id": ub['unused_id'],
                    "uid": device_id,
                    "bucket__content": ub['bucket__content'],
                    "use_status": 0,
                    "endTime": 0,
                    "bucket__id": ub['bucket__id'],
                    "storage": storage,
                }
                store_list.append(unused_dict)
                bucket_id_list.append(ub['bucket__id'])
        sm_qs = Store_Meal.objects.filter(bucket__id__in=bucket_id_list, lang__lang=lang).annotate(
            title=F('lang__title'), content=F('lang__content')).values('lang__content', 'lang__lang',
                                                                       'bucket__id',
                                                                       'lang__title')
        for index, value in enumerate(store_list):
            for sm in sm_qs:
                if value['bucket__id'] == sm['bucket__id']:
                    value['bucket__content'] = sm['lang__title'] + '-' + sm['lang__content']

        return response.json(0, list(store_list))

    # 提前使用设备关联套餐
    @staticmethod
    def switch_device_commodity(request_dict, user_id, response):
        uid = request_dict.get('uid', None)
        dv_qs = Device_Info.objects.filter(userID_id=user_id, UID=uid, isShare=False, isExist=1).values(
            'vodPrimaryUserID')
        if not dv_qs.exists() or dv_qs[0]['vodPrimaryUserID'] != user_id:
            return response.json(12)
        unused_id = request_dict.get('switch_commodity_id', None)
        if unused_id:
            # 切换设备套餐关联
            using_uid_bucket = UID_Bucket.objects.filter(uid=uid, has_unused=1).values("id", "uid", "endTime",
                                                                                       "bucket__content", "addTime")
            unuseds = Unused_Uid_Meal.objects.filter(id=unused_id).values("id", "uid", "channel", "addTime", "expire",
                                                                          "num", "bucket_id")
            if not unuseds.exists() or not using_uid_bucket.exists():
                return response.json(10030)
            unused = unuseds[0]
            now_time = int(time.time())
            try:
                with transaction.atomic():
                    count_unused = Unused_Uid_Meal.objects.filter(uid=uid).count()
                    has_unused = 1 if count_unused > 1 else 0
                    end_time = CommonService.calcMonthLater(unused['expire'] * unused['num'])
                    UID_Bucket.objects.filter(uid=uid).update(channel=unused['channel'], endTime=end_time,
                                                              bucket_id=unused['bucket_id']
                                                              , updateTime=now_time, use_status=1,
                                                              has_unused=has_unused)
                    Unused_Uid_Meal.objects.filter(id=unused_id).delete()
                    StsCrdModel.objects.filter(uid=uid).delete()  # 删除sts记录
                    # VodHlsModel.objects.filter(uid=uid).delete()  # 删除播放列表,后期数据量多时应该考虑延后删除
            except Exception:
                return response.json(474)
            return response.json(0)
        return response.json(444)

    @staticmethod
    def has_vod(request_dict, user_id, response):
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', 1)
        dv_qs = Device_Info.objects.filter(userID_id=user_id, UID=uid, isShare=False).values('vodPrimaryUserID',
                                                                                             'vodPrimaryMaster')
        if not dv_qs.exists():
            return response.json(12)
        if dv_qs[0]['vodPrimaryUserID'] != user_id:
            return response.json(10034)
        now_time = int(time.time())
        bv_qs = UID_Bucket.objects.filter(uid=uid, endTime__gte=now_time, channel=channel).values('bucket_id').order_by(
            'addTime')
        if not bv_qs.exists():
            return response.json(10030)

        had_vod_query = VodHlsModel.objects.extra(select={'date': "FROM_UNIXTIME(time,'%%Y-%%m-%%d')"}).values(
            'date').filter(uid=uid, endTime__gte=now_time, channel=channel).annotate(count=Count('time')).order_by(
            '-date')[:31]

        had_vod_list = []
        for vod in had_vod_query:
            had_vod_list.append({
                'timestamp': CommonService.str_to_timestamp(vod['date'], '%Y-%m-%d'),
                'vod_count': vod['count'],
                'date_format': vod['date'],
            })

        return response.json(0, had_vod_list)

    @staticmethod
    def video_playback_time(request_dict, user_id, response):
        parms = request_dict.get('parms', None)

        if not parms:
            return response.json(444)

        try:
            parms = eval(parms)
            bulk = []
            for parm in parms:
                parm['userID'] = user_id
                # 解密uid
                for i in range(1, 4):
                    parm['uid'] = base64.b64decode(parm['uid'])
                    parm['uid'] = parm['uid'].decode('utf-8')
                    parm['uid'] = parm['uid'][i:-i]
                video_playback_time = VideoPlaybackTimeModel(**parm)
                bulk.append(video_playback_time)
            VideoPlaybackTimeModel.objects.bulk_create(bulk)
            return response.json(0)
        except Exception as e:
            print(e)
            return response.json(500, repr(e))

    # 云存操作系统消息
    def do_vod_msg_notice(self, uid, channel, user_id, lang, sys_msg_text_list, sms):
        try:
            logger = logging.getLogger('log')
            logger.info('进来了')
            if lang == 'cn':
                sys_msg_text = sys_msg_text_list[0]
            else:
                sys_msg_text = sys_msg_text_list[1]
            now_time = int(time.time())
            create_data = {'userID_id': user_id, 'msg': sys_msg_text, 'addTime': now_time,
                           'updTime': now_time, 'uid': uid, 'eventType': 0}
            SysMsgModel.objects.create(**create_data)

            user_qs = Device_User.objects.filter(userID=user_id)
            if user_qs.exists():
                user = user_qs[0]
                username = user.username
                data_valid = DataValid()
                if data_valid.email_validate(username):
                    S3Email().faEmail(sys_msg_text, username)
                elif data_valid.mobile_validate(username):
                    # 如果存在序列号,消息提示用序列号
                    device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
                    serial_number = device_info_qs[0]['serial_number']
                    device_type = device_info_qs[0]['Type']
                    if serial_number:
                        device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
                    else:
                        device_name = uid
                    params = u'{"devname":"' + device_name + '","submittime":"' + time.strftime("%Y-%m-%d",
                                                                                                time.localtime()) + '"}'
                    self.send_message(username, params, sms)

            logger.info('出去了')
        except Exception as e:
            return repr(e)

    # 云存到期续费提醒   提前3天
    def do_vod_msg_end(self):
        response = ResponseObject()
        now_time = int(time.time())

        # 过期前第7天提示一次
        uid_bucket_qs = UID_Bucket.objects.filter(
            Q(endTime__gt=now_time + 3600 * 144) & Q(endTime__lte=(now_time + 3600 * 168))).values('id', 'uid',
                                                                                                   'bucket__area',
                                                                                                   'channel', 'endTime')
        self.do_vod_msg(now_time, uid_bucket_qs)

        # 过期前第3天提示一次
        uid_bucket_qs = UID_Bucket.objects.filter(
            Q(endTime__gt=now_time + 3600 * 48) & Q(endTime__lte=(now_time + 3600 * 72))).values('id', 'uid',
                                                                                                 'bucket__area',
                                                                                                 'channel', 'endTime')
        self.do_vod_msg(now_time, uid_bucket_qs)
        return response.json(0)

    def do_vod_msg(self, now_time, qs):
        uq_list = []
        ids = []
        for ub in qs:
            ids.append(ub['id'])

        oq_list = Order_Model.objects.filter(uid_bucket_id__in=ids).values('userID_id', 'uid_bucket_id')

        for ub in qs:
            for oo in oq_list:
                if ub['id'] == oo['uid_bucket_id']:
                    # 如果存在序列号,消息提示用序列号
                    uid = ub['uid']
                    device_info_qs = Device_Info.objects.filter(UID=uid).values('serial_number', 'Type')
                    serial_number = device_info_qs[0]['serial_number']
                    device_type = device_info_qs[0]['Type']
                    if serial_number and device_type == 101:
                        device_name = CommonService.get_full_serial_number(uid, serial_number, device_type)
                    else:
                        device_name = uid
                    if ub['bucket__area'] == 'cn':
                        sys_msg_text = "温馨提示：尊敬的客户，您%s设备的云存套餐将在%s到期" % (
                            device_name, time.strftime("%Y-%m-%d", time.localtime(ub['endTime'])))
                    else:
                        sys_msg_text = 'Dear customer,the cloud storage package for your device %s will expire on %s' % \
                                       (device_name, time.strftime('%m-%d-%y', time.localtime(ub['endTime'])))
                    uq_list.append(SysMsgModel(
                        userID_id=oo['userID_id'],
                        addTime=now_time,
                        updTime=now_time,
                        uid=ub['uid'],
                        eventType=0,
                        msg=sys_msg_text,
                        status=0
                    ))
                    SysMsgModel.objects.bulk_create(uq_list)
                    user_qs = Device_User.objects.filter(userID=oo['userID_id'])
                    if user_qs.exists():
                        user = user_qs[0]
                        username = user.username
                        data_valid = DataValid()

                        if data_valid.email_validate(username):
                            S3Email().faEmail(sys_msg_text, username)
                        elif data_valid.mobile_validate(username):
                            params = u'{"devname":"%s","submittime":"%s"}' % (
                                device_name, time.strftime("%Y-%m-%d", time.localtime(ub['endTime'])))
                            self.send_message(username, params, 'SMS_219748440')

    @staticmethod
    def send_message(phone, params, temp_msg):
        # 购买成功
        sign_ms = '周视'
        # 发送手机验证码
        ali_sms = AliSmsObject()
        ali_sms.send_code_sms_cloud(phone=phone, params=params, sign_name=sign_ms, temp_msg=temp_msg)

    @staticmethod
    def do_refund(request_dict, response):
        order_id = request_dict.get('orderID', None)  # 商户订单号
        refund_amount = request_dict.get('refund_amount', None)  # 退款金额
        if not all([order_id, refund_amount]):
            return response.json(444)
        try:
            order_qs = Order_Model.objects.filter(orderID=order_id).values('status', 'payType', 'price',
                                                                           'refunded_amount', 'currency', 'paymentID')
            if not order_qs.exists():
                return response.json(173)

            # 支付状态不为支付成功和退款失败和部分退款
            status = order_qs[0]['status']
            if status != 1 and status != 4 and status != 6:
                return response.json(805)

            refund_amount = float(refund_amount)
            now_time = int(time.time())
            pay_type = order_qs[0]['payType']
            price = order_qs[0]['price']  # 订单金额
            refunded_amount = order_qs[0]['refunded_amount']  # 已退款金额
            currency = order_qs[0]['currency']  # 货币

            # 判断是否符合付款条件
            if refunded_amount == float(price):  # 已全额退款
                return response.json(805)
            if refund_amount + refunded_amount > float(price):  # 退款金额超出订单价格
                return response.json(805)
            # 部分退款标识
            is_partial_refund = True if (float(price) > refund_amount + refunded_amount) else False

            out_request_no = str(time.strftime('%Y%m%d%H%M%S', time.localtime(now_time)))  # 退款请求号
            # 根据支付类型处理退款
            if pay_type == 1:  # PayPal
                payment_id = order_qs[0]['paymentID']  # PayPal PAYMENT_ID
                if not payment_id:
                    return response.json(805)
                paypalrestsdk.configure(PAYPAL_CRD)
                payment = paypalrestsdk.Payment.find(payment_id)
                print('payment', payment)
                related_resources = payment['transactions'][0]['related_resources']
                print('related_resources: ', related_resources)
                if not related_resources:
                    return response.json(805)
                sale = related_resources[0]['sale']
                print('sale: ', sale)
                # 没退款过 'state' 不为 'completed' 或 已退款过但 'state' 不为 'partially_refunded'
                if (refunded_amount == 0 and sale['state'] != 'completed') or (
                        refunded_amount != 0 and sale['state'] != 'partially_refunded'):
                    return response.json(805)
                sale_id = sale['id']
                paypal_sale = paypalrestsdk.Sale.find(sale_id)
                refund = paypal_sale.refund({
                    'amount': {
                        'total': refund_amount,
                        'currency': currency
                    }
                })
                refund_success = True if refund.success() else False
            elif pay_type == 2:  # 支付宝
                ali_pay_obj = AliPayObject()
                alipay = ali_pay_obj.conf()
                refund_response = alipay.api_alipay_trade_refund(refund_amount=refund_amount, out_trade_no=order_id,
                                                                 out_request_no=out_request_no)
                refund_success = True if (refund_response['code'] == '10000') else False
            elif pay_type == 3:  # 微信
                ali_pay_obj = WechatPayObject()
                refund_fee = int(refund_amount * 100)  # 退款金额,单位为分,只能为整数
                success = ali_pay_obj.refund(out_trade_no=order_id, out_refund_no=out_request_no,
                                             total_fee=refund_fee, refund_fee=refund_fee)
                refund_success = True if success else False
            else:  # 不支持退款的支付类型
                return response.json(805)

            # 更新订单状态和已退款金额
            update_dict = {'updTime': now_time}
            if refund_success:
                update_dict['status'] = 6 if is_partial_refund else 5
                update_dict['refunded_amount'] = refunded_amount + refund_amount
            else:
                update_dict['status'] = 4
            order_qs.update(**update_dict)
            return response.json(0)
        except Exception as e:
            print(e)
            return response.json(500, repr(e))