ASJServer/Controller/TestApi.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@Copyright (C) ansjer cop Video Technology Co.,Ltd.All rights reserved.
@AUTHOR: ASJRD018
@NAME: Ansjer
@software: PyCharm
@DATE: 2018/5/22 13:58
@Version: python3.6
@MODIFY DECORD:ansjer dev
@file: Test.py
@Contact: chanjunkai@163.com
"""
import os
import traceback

import botocore
import cv2
from botocore import client

from Controller.DeviceConfirmRegion import Device_Region
from Object.AWS.AmazonS3Util import AmazonS3Util
from Object.RedisObject import RedisObject

'''
http://192.168.136.40:8077/Test
'''
import json
import time
import urllib
from Object.AliPayObject import AliPayObject
import boto3
from boto3.session import Session
import oss2
import paypalrestsdk
import logging
from aliyunsdkcore import client
from aliyunsdksts.request.v20150401 import AssumeRoleRequest
from django.http import JsonResponse, HttpResponse
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt
from django.views.generic.base import View
from django.contrib.auth.hashers import make_password  # 对密码加密模块
from Ansjer.config import OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET, OSS_ROLE_ARN, AWS_ACCESS_KEY_ID, \
    AWS_SECRET_ACCESS_KEY, SERVER_TYPE, AWS_SES_ACCESS_REGION
from Model.models import Order_Model, Store_Meal, VodHlsModel, OssCrdModel, StsCrdModel, DeviceLogModel
from Object.ResponseObject import ResponseObject
from Object.TokenObject import TokenObject
from Service.CommonService import CommonService
from Object.m3u8generate import PlaylistGenerator
from Model.models import Device_Info, UID_Bucket, UID_Preview, UidSetModel
from Ansjer.config import SERVER_DOMAIN_SSL

SERVER_DOMAIN = 'http://test.dvema.com/'
ACCESS_KEY = "AKIA2E67UIMD3CYTIWPA"
SECRET_KEY = "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"
LOGGER = logging.getLogger('info')


# 测试接口sdk
class testView(View):
    @method_decorator(csrf_exempt)
    def dispatch(self, *args, **kwargs):
        return super(testView, self).dispatch(*args, **kwargs)

    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 put(self, request, *args, **kwargs):
        request.encoding = 'utf-8'
        operation = kwargs.get('operation')
        response = ResponseObject()
        return response.json(0, request.body)

    def validation(self, request_dict, request, operation):
        response = ResponseObject()
        # operation => cloudVod/path
        if operation is None:
            return response.json(444, 'error path')
        elif operation == 'tests':
            logger = logging.getLogger('info')
            logger.info('测试打印')
            res = make_password(123456)
            return JsonResponse(status=200, data=res, safe=False)
        elif operation == 'testMiddleWare':
            a = int('a')
            return JsonResponse(status=200, safe=False)
        elif operation == 'testMiddleWare2':
            try:
                a = int('a')
                return JsonResponse(status=200, safe=False)
            except Exception as e:
                return response.json(500, repr(e))
        elif operation == 'cbu':
            return self.createBucket()
        elif operation == 'vodList':
            ip = CommonService.get_ip_address(request)
            userID = '158943594633713800138000'
            return self.do_test_query_vod_list(userID, ip, request_dict, response)
        elif operation == 'signplaym3u8':
            return self.do_sign_play_m3u8(request_dict, response)
        elif operation == 'get_sign_sts':
            ip = CommonService.get_ip_address(request)
            return self.do_test_get_sign_sts(request_dict, ip, response)
        elif operation == 'eqi_query':
            userID = '158943594633713800138000'
            return self.queryInterface(request_dict, userID, response)
        elif operation == 'getAlexa':
            userID = '158943594633713800138000'
            return self.queryInterface(request_dict, userID, response)
        elif operation == 'generateToken':
            userID = '158943604783713800138000'
            return self.generate_token(request_dict, userID)
        elif operation == 'test_upload_s3':
            userID = '158943604783713800138000'
            return self.test_upload_s3(request_dict, response)
        elif operation == 'rekognition':
            userID = '158943604783713800138000'
            return self.testRekognition(request, request_dict)
        elif operation == 'ip':
            return self.ip(response)
        elif operation == 'configType':
            return self.configType(response)
        elif operation == 'createData':
            return self.createData(request_dict, response)
        elif operation == 'findPaypalOrder':
            return self.findPaypalOrder(request_dict, response)
        elif operation == 'comb':
            return self.do_comb(request_dict, response)
        elif operation == 'count_ts':
            return self.count_ts(request_dict, response)
        elif operation == 'upload-s3':
            return self.file_upload_s3(request, request_dict, response)
        elif operation == 'v2/upload-s3':
            return self.file_upload_s3_v2(request, request_dict, response)
        elif operation == 'download-s3':
            return self.file_download_s3(request_dict, response)
        elif operation == 'acl-put':
            return self.s3_acl_put(request_dict, response)
        elif operation == 's3-object-delete':
            return self.object_delete(request_dict, response)
        elif operation == 'head-bucket':
            return self.head_bucket(request_dict, response)
        elif operation == 'write_redis_list':
            return self.write_redis_list(response)
        elif operation == 'read_redis_list':
            return self.read_redis_list(response)
        elif operation == 'playM3u8':
            return self.play_m3u8(request_dict, response)
        elif operation == 'generate_video':
            return self.generate_video(request_dict, response)
        else:
            return 123

    @classmethod
    def generate_video(cls, request_dict, response):
        # 设计抽取图片规则通过消息随机还是时间随机，调试copy S3对象查询是否携带失效时间
        try:
            DIR = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
            arr_list = ['1666756086.jpeg', '1666831275.jpeg', '1666841492.jpeg']
            s3 = AmazonS3Util(AWS_ACCESS_KEY_ID[0], AWS_SECRET_ACCESS_KEY[0], 'cn-northwest-1')
            bucket = 'push-cloud-photo'
            for item in arr_list:
                path = DIR + r'\Ansjer\file\{}'.format(item)
                s3_key = 'HA154GVEDH41RY8Y111A/1/{}'.format(item)
                s3.download_object(bucket, s3_key, path)
            video_dir = DIR + r'\Ansjer\file\result.mp4'  # 输出视频的保存路径
            fps = 0.5  # 帧率
            img_size = (1920, 1080)  # 图片尺寸
            fourcc = cv2.VideoWriter_fourcc(*"mp4v")
            videoWriter = cv2.VideoWriter(video_dir, fourcc, fps, img_size)
            for i in arr_list:
                img_path = DIR + r'\Ansjer\file\{}'.format(i)
                frame = cv2.imread(img_path)
                frame = cv2.resize(frame, img_size)  # 生成视频   图片尺寸和设定尺寸相同
                videoWriter.write(frame)  # 将图片写进视频里
                os.remove(img_path)
            videoWriter.release()  # 释放资源
            data = open(video_dir, 'rb')
            key = 'HA154GVEDH41RY8Y111A/1/20221027.mp4'
            s3.upload_file_obj(bucket, key, data)
            response_url = s3.generate_file_obj_url(bucket, key)
            os.remove(video_dir)
        except Exception as e:
            print(e)
            ex = traceback.format_exc()
            LOGGER.info('--->抽取推送图片异常:{}'.format(ex))
            return response.json(177, ex)
        return response.json(0, response_url)

    @classmethod
    def head_bucket(cls, request_dict, response):
        bucket_name = request_dict.get('bucket', None)
        s3 = AmazonS3Util('AKIA2E67UIMD45Y3HL53', 'ckYLg4Lo9ZXJIcJEAKkzf2rWvs8Xth1FCjqiAqUw', 'us-east-1')
        s3.bucket_exists(bucket_name)
        return response.json(0)

    @classmethod
    def file_upload_s3(cls, request, request_dict, response):
        file = request.FILES.get('file', None)
        file_name = file.name
        file_name = 'app/images/{}'.format(file_name)
        cls.upload_s3(file, file_name)
        return response.json(0)

    @classmethod
    def file_upload_s3_v2(cls, request, request_dict, response):
        """
        'private' | 'public-read' | 'public-read-write' | 'authenticated-read'
        """
        file = request.FILES.get('file', None)
        file_name = file.name
        # S3下文件夹路径+文件名 组成对象key
        file_key = 'app/images/{}'.format(file_name)
        s3 = AmazonS3Util(AWS_ACCESS_KEY_ID[1], AWS_SECRET_ACCESS_KEY[1], AWS_SES_ACCESS_REGION)
        # 存储桶
        bucket = 'ansjerfilemanager'
        s3.upload_file_obj(bucket, file_key, file, {'ContentType': file.content_type, 'ACL': 'public-read'})
        return response.json(0)

    @classmethod
    def object_delete(cls, request_dict, response):
        file_name = request_dict.get('key', None)
        file_key = 'app/images/{}'.format(file_name)
        s3 = AmazonS3Util('AKIA2E67UIMD45Y3HL53', 'ckYLg4Lo9ZXJIcJEAKkzf2rWvs8Xth1FCjqiAqUw', 'us-east-1')
        bucket = "ansjerfilemanager"
        s3.delete_obj(bucket, file_key)
        return response.json(0)

    @staticmethod
    def upload_s3(data, upload_path):
        """
        上传对象到对应存储桶
        @param data:
        @param upload_path:
        @return:
        """
        try:
            aws_key = "AKIA2E67UIMD45Y3HL53"  # 【你的 aws_access_key】
            aws_secret = "ckYLg4Lo9ZXJIcJEAKkzf2rWvs8Xth1FCjqiAqUw"  # 【你的 aws_secret_key】
            session = Session(aws_access_key_id=aws_key,
                              aws_secret_access_key=aws_secret,
                              region_name="us-east-1")
            s3 = session.resource("s3")
            # client = session.client("s3")
            bucket = "ansjerfilemanager"  # 【你 bucket 的名字】 # 首先需要保.证 s3 上已经存在该存储桶，否则报错
            # upload_key = "test"
            s3.Bucket(bucket).put_object(Key=upload_path, Body=data)
            return True
        except Exception as e:
            print(repr(e))
            return False

    @classmethod
    def s3_acl_put(cls, request_dict, response):
        """
        S3通过存储桶对象设置Acl权限
        @param request_dict:
        @param response:
        @return:
        """
        try:
            key = request_dict.get('key', None)
            aws_key = "AKIA2E67UIMD45Y3HL53"  # 【你的 aws_access_key】
            aws_secret = "ckYLg4Lo9ZXJIcJEAKkzf2rWvs8Xth1FCjqiAqUw"  # 【你的 aws_secret_key】
            session = Session(aws_access_key_id=aws_key,
                              aws_secret_access_key=aws_secret,
                              region_name="us-east-1")
            s3 = session.resource("s3")
            # client = session.client("s3")
            bucket = "ansjerfilemanager"  # 【你 bucket 的名字】 # 首先需要保.证 s3 上已经存在该存储桶，否则报错
            # upload_key = "test"
            obj = s3.Object(bucket, key)
            obj.Acl().put(ACL='public-read')
            return response.json(0)
        except Exception as e:
            print(repr(e))
            return False

    @classmethod
    def file_download_s3(cls, request_dict, response):
        """
        S3通过签名获取对象URL
        @param request_dict:
        @param response:
        @return:
        """
        key = request_dict.get('key', None)
        s3_client = AmazonS3Util('AKIA2E67UIMD45Y3HL53', 'ckYLg4Lo9ZXJIcJEAKkzf2rWvs8Xth1FCjqiAqUw', 'us-east-1')
        bucket = "ansjerfilemanager"
        response_url = s3_client.generate_file_obj_url(bucket, key)
        return response.json(0, response_url)

    def do_comb(self, request_dict, response):
        import itertools
        list1 = [1, 2, 3, 4]
        list2 = []
        for i in range(1, len(list1) + 1):
            iter = itertools.combinations(list1, i)
            list2.append(list(iter))
        list3 = []
        for list_ in list2:
            for val in list_:
                print('-------------list')
                print(type(val))
                comb = [str(i) for i in val]
                comb_int = int("".join(comb))
                list3.append(comb_int)

        return HttpResponse(json.dumps(list3))

    def findPaypalOrder(self, request_dict, response):
        PAYPAL_CRD = {
            "mode": "sandbox",  # sandbox or live
            "client_id": "AVLoQVq3xHZ6FrF4mxHwlCPgVBAw4Fw5RtMkuxmYd23SkUTIY643n2g3KdK-Al8wV05I28lza5uoQbAA",
            "client_secret": "EO8kRc8yioDk0i2Qq-QMcVFfwkmyMJorTvBSLDTnxDJJ_wb9VoM_0jkUY9iEng2Flp1ze8wQOGpH5nB2"
        }
        paypalrestsdk.configure(PAYPAL_CRD)
        billing_agreement = paypalrestsdk.BillingAgreement.find('I-7P8BCCKE45HY')
        # json_str = json.dumps(billing_agreement, default=lambda o: o.__dict__)
        # return HttpResponse(json_str)
        print(repr(billing_agreement))
        return HttpResponse(repr(billing_agreement))
        return response.json(json.dumps(list(payment)))
        logger = logging.getLogger('info')
        logger.info('------记录aws bucket init时间')
        logger.info(int(time.time()))
        aws_access_key_id = AWS_ACCESS_KEY_ID[1]
        aws_secret_access_key = AWS_SECRET_ACCESS_KEY[1]
        session = Session(
            aws_access_key_id=aws_access_key_id,
            aws_secret_access_key=aws_secret_access_key,
            region_name='us-east-1'
        )
        conn = session.client('s3')
        logger.info(int(time.time()))
        exit()
        # related_resources = payment['transactions'][0]['related_resources']
        # if not related_resources:
        #     return response.json(805)
        # sale = related_resources[0]['sale']
        # print(related_resources)
        # return HttpResponse(sale)

    def createBucket(self):

        # 查看桶列表
        # url = "https://azvod1.s3-ap-northeast-1.amazonaws.com"
        # session = Session(ACCESS_KEY, SECRET_KEY)
        # s3_client = session.client('s3', endpoint_url=url)
        # results = s3_client.list_buckets()
        # return JsonResponse(status=200, data={'code': 200, 'msg': results['Buckets']})

        # Create bucket
        session = Session(ACCESS_KEY, SECRET_KEY)
        s3_client = session.client('s3')

        # 上传
        # s3_client.put_object(Bucket="azvod1", Key="file/rule.txt", Body=open(r"E:\download\Shadowsocks-4.1.10.0\user-rule.txt", 'rb').read())

        # 下载
        resp = s3_client.get_object(Bucket="azvod1", Key="file/rule.txt")
        with open('local.txt', 'wb') as f:
            f.write(resp['Body'].read())

    # 新查询设备字段
    def queryInterface(self, request_dict, userID, response):
        page = request_dict.get('page', None)
        line = request_dict.get('line', None)
        NickName = request_dict.get('NickName', None)
        uid = request_dict.get('uid', None)
        page = int(page)
        line = int(line)
        response.lang = 'cn'
        userID = userID
        dvqs = Device_Info.objects.filter(userID_id=userID)
        # # 已重置的设备
        # dvqs = dvqs.filter(~Q(isExist=2))
        if NickName:
            dvqs = dvqs.filter(NickName__icontains=NickName)
        if uid:
            dvqs = dvqs.filter(UID=uid)
        # count = dvqs.count()
        # 分页
        dvql = dvqs[(page - 1) * line:page * line].values('id', 'userID', 'NickName', 'UID', 'View_Account',
                                                          'View_Password', 'ChannelIndex', 'Type', 'isShare',
                                                          'primaryUserID', 'primaryMaster', 'data_joined',
                                                          'version',
                                                          'isVod', 'isExist', 'NotificationMode')
        dvls = CommonService.qs_to_list(dvql)
        uid_list = []
        for dvl in dvls:
            uid_list.append(dvl['UID'])
            # if dvl['isShare'] is False:
            #     uid_list.append(dvl['UID'])
        ubqs = UID_Bucket.objects.filter(uid__in=uid_list). \
            values('bucket__content', 'status', 'channel', 'endTime', 'uid')
        upqs = UID_Preview.objects.filter(uid__in=uid_list).order_by('channel').values('id', 'uid', 'channel')
        auth = oss2.Auth(OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET)
        bucket = oss2.Bucket(auth, 'oss-cn-hongkong.aliyuncs.com', 'statres')
        nowTime = int(time.time())
        data = []
        # 设备拓展信息表
        us_qs = UidSetModel.objects.filter(uid__in=uid_list). \
            values('uid', 'version', 'nickname', 'detect_interval')
        uv_dict = {}
        for us in us_qs:
            uv_dict[us['uid']] = {'version': us['version'],
                                  'nickname': us['nickname'],
                                  'detect_interval': us['detect_interval']}
        for p in dvls:
            p['vod'] = []
            for dm in ubqs:
                if p['UID'] == dm['uid']:
                    if dm['endTime'] > nowTime:
                        p['vod'].append(dm)
            p['preview'] = []
            for up in upqs:
                if p['UID'] == up['uid']:
                    obj = 'uid_preview/{uid}/channel_{channel}.png'. \
                        format(uid=up['uid'], channel=up['channel'])
                    img_sign = bucket.sign_url('GET', obj, 300)
                    p['preview'].append(img_sign)
            p_uid = p['UID']
            if p_uid in uv_dict:
                # 设备版本号
                p['uid_version'] = uv_dict[p_uid]['version']
                p['detect_interval'] = uv_dict[p_uid]['detect_interval']
                # 设备昵称 调用影子信息昵称，先阶段不可
                if uv_dict[p_uid]['nickname']:
                    p['NickName'] = uv_dict[p_uid]['nickname']
            else:
                # 设备版本号
                p['uid_version'] = ''
            data.append(p)
        return response.json(0, data)

    # 获取播放列表
    def do_test_query_vod_list(self, userID, ip, request_dict, response):
        uid = 'GZL2PEFJPLY7W6BG111A'
        channel = 2
        userID = '158943594633713800138000'
        dv_qs = Device_Info.objects.filter(UID=uid, userID_id=userID, isShare=False)
        if not dv_qs.exists():
            return response.json(12)
        vod_play_list = []
        bucket_name = 'azvod1'
        aws_access_key_id = 'AKIA2E67UIMD45Y3HL53'
        aws_secret_access_key = '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'
        session = Session(
            aws_access_key_id=aws_access_key_id,
            aws_secret_access_key=aws_secret_access_key,
            region_name='ap-northeast-1'
        )
        conn = session.client('s3')
        thumbspng = '{uid}/vod{channel}/{time}/thumbs.png'. \
            format(uid=uid, channel=channel, time=1590485548)
        response_url = conn.generate_presigned_url(
            'get_object',
            Params={
                'Bucket': bucket_name,
                'Key': thumbspng
            },
            ExpiresIn=3600
        )
        # m3u8 = '{uid}/vod{channel}/{time}/{time}.m3u8'. \
        #     format(uid=uid, channel=channel, time=vod['time'])
        thumb_url = response_url
        vod_url = 'http://192.168.136.191:8000/testApi/signplaym3u8?' \
                  'uid={uid}&channel={channel}&time={time}&sign=tktktktk'. \
            format(ip=ip, uid=uid, channel=channel, time=1590485548)
        vod_play_list.append({
            'name': 1590485548,
            'sign_url': vod_url,
            'thumb': thumb_url,
            'sec': 12})
        return response.json(0, vod_play_list)

    # 生成m3u8列表
    def do_sign_play_m3u8(self, request_dict, response):
        uid = 'GZL2PEFJPLY7W6BG111A'
        channel = 2
        storeTime = 1591344070
        fg = 6
        bucket__region = 'ap-northeast-1'
        bucket_name = 'azvod1'
        aws_access_key_id = 'AKIA2E67UIMD45Y3HL53'
        aws_secret_access_key = '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'
        session = Session(
            aws_access_key_id=aws_access_key_id,
            aws_secret_access_key=aws_secret_access_key,
            region_name=bucket__region
        )
        '''
            http://test.dvema.com/cloudstorage/signplaym3u8?uid=VVDHCVBYDKFMJRWA111A&channel=1&time=1586940120&sign=tktktktk
        '''
        conn = session.client('s3')
        playlist_entries = []

        for i in range(fg):
            thumbspng = '{uid}/vod{channel}/{time}/ts{i}.ts'. \
                format(uid=uid, channel=channel, time=storeTime, i=i)
            response_url = conn.generate_presigned_url(
                'get_object',
                Params={
                    'Bucket': bucket_name,
                    'Key': thumbspng
                },
                ExpiresIn=86400
            )
            # m3u8 = '{uid}/vod{channel}/{time}/{time}.m3u8'. \
            #     format(uid=uid, channel=channel, time=vod['time'])
            playlist_entries.append({
                'name': response_url,
                'duration': 10,
            })
        playlist = PlaylistGenerator(playlist_entries).generate()
        response = HttpResponse(playlist)
        response['Content-Type'] = 'application/octet-stream'
        response['Content-Disposition'] = 'attachment;filename="play.m3u8"'
        return response

        # return HttpResponse(playlist)
        # response = HttpResponse(playlist, content_type="application/vnd.apple.mpegurl")
        # # response = HttpResponse(playlist, content_type="application/octet-stream")
        # return response
        # return HttpResponse(status=200, content=playlist)

    def do_test_get_sign_sts(self, request_dict, ip, response):
        # uid = 'GZL2PEFJPLY7W6BG111A'
        # channel = 2
        uid = 'VVDHCVBYDKFMJRWA111A'
        channel = 1
        now_time = int(time.time())
        ubqs = UID_Bucket.objects.filter(uid=uid, channel=channel, endTime__gte=now_time). \
            values("bucket__mold", "bucket__bucket", "bucket__endpoint", "bucket__region", "endTime")
        if ubqs.exists():
            if ubqs[0]["bucket__mold"] == 0:
                # 阿里云 oss sts
                oc_qs = OssCrdModel.objects.filter(uid=uid, channel=channel). \
                    values("addTime", "data")
                if oc_qs.exists():
                    endTime = int(oc_qs[0]["addTime"]) + 3500
                    if endTime > now_time:
                        print(endTime)
                        print(now_time)
                        res = json.loads(oc_qs[0]["data"])
                        return JsonResponse(status=200, data=res)
                # 套餐id
                storage = '{uid}/vod{channel}/'.format(uid=uid, channel=channel)
                bucket_name = ubqs[0]['bucket__bucket']
                endpoint = ubqs[0]['bucket__endpoint']
                access_key_id = OSS_STS_ACCESS_KEY
                access_key_secret = OSS_STS_ACCESS_SECRET
                region_id = ubqs[0]['bucket__region']
                role_arn = OSS_ROLE_ARN
                clt = client.AcsClient(access_key_id, access_key_secret, region_id)
                req = AssumeRoleRequest.AssumeRoleRequest()
                # 设置返回值格式为JSON。
                req.set_accept_format('json')
                req.set_RoleArn(role_arn)
                req.set_RoleSessionName(uid + '_' + channel)
                req.set_DurationSeconds(3600)
                Resource_access = "acs:oss:*:*:{bucket_name}/{uid_channel}*". \
                    format(bucket_name=bucket_name, uid_channel=storage)
                print(Resource_access)
                policys = {
                    "Version": "1",
                    "Statement": [
                        {
                            "Action": ["oss:PutObject", "oss:DeleteObject", ],
                            "Resource": [Resource_access],
                            "Effect": "Allow",
                            "Condition": {
                                "IpAddress": {"acs:SourceIp": ip}
                                # "IpAddress": {"acs:SourceIp": "120.237.157.184"}
                                # "IpAddress": {"acs:SourceIp": "*"}
                            }
                        }
                    ]
                }
                req.set_Policy(Policy=json.dumps(policys))
                body = clt.do_action(req)
                # 使用RAM账号的AccessKeyId和AccessKeySecret向STS申请临时token。
                token = json.loads(body.decode('utf-8'))
                print(token)
                res = {
                    'AccessKeyId': token['Credentials']['AccessKeyId'],
                    'AccessKeySecret': token['Credentials']['AccessKeySecret'],
                    'SecurityToken': token['Credentials']['SecurityToken'],
                    'Expiration': token['Credentials']['Expiration'],
                    'expire': '3600',
                    'endpoint': endpoint,
                    'bucket_name': bucket_name,
                    'arn': token['AssumedRoleUser']['Arn'],
                    'code': 0,
                    'storage': storage,
                    'endTime': ubqs[0]['endTime'],
                    'ip': ip}
                if oc_qs.exists():
                    oc_qs.update(data=json.dumps(res), addTime=now_time)
                else:
                    OssCrdModel.objects.create \
                        (uid=uid, channel=channel, data=json.dumps(res), addTime=now_time)
                return JsonResponse(status=200, data=res)
            elif ubqs[0]["bucket__mold"] == 1:
                # 亚马逊 s3 sts
                sts_qs = StsCrdModel.objects.filter(uid=uid, channel=channel). \
                    values("addTime", "data")
                if sts_qs.exists():
                    endTime = int(sts_qs[0]["addTime"]) + 3500
                    if endTime > now_time:
                        print(endTime)
                        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 = ubqs[0]['bucket__bucket']
                endpoint = ubqs[0]['bucket__endpoint']
                region_id = ubqs[0]['bucket__region']

                ###############
                REGION_NAME = region_id
                boto3_sts = boto3.client(
                    'sts',
                    aws_access_key_id='AKIA2E67UIMD45Y3HL53',
                    aws_secret_access_key='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',
                    region_name=REGION_NAME
                )
                Policy = {
                    "Version": "2012-10-17",
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "s3:*",
                            "Resource": ["arn:aws:s3:::azvod1/{uid_channel}/*".
                                             format(uid_channel=storage)]
                        }
                    ]
                }
                response = boto3_sts.get_federation_token(
                    Name='{role_name}'.format(role_name=uid + '_' + 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': '3600',
                    'endpoint': endpoint,
                    'bucket_name': bucket_name,
                    'arn': response['FederatedUser']['Arn'],
                    'code': 0,
                    'storage': storage,
                    'endTime': ubqs[0]['endTime'],
                    'ip': ip,
                }
                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)
            else:
                res = {'code': 404, 'msg': 'data not exists!'}
                return HttpResponse(json.dumps(res, ensure_ascii=False),
                                    content_type="application/json,charset=utf-8")

    def do_get_sign_sts(self, request_dict, ip, response):
        # uid = 'GZL2PEFJPLY7W6BG111A'
        # channel = 2
        uid = '86YC8Z192VB1VMKU111A'
        channel = 1
        now_time = int(time.time())
        ubqs = UID_Bucket.objects.filter(uid=uid, channel=channel, endTime__gte=now_time). \
            values("bucket__mold", "bucket__bucket", "bucket__endpoint", "bucket__region", "endTime")
        if ubqs.exists():
            if ubqs[0]["bucket__mold"] == 0:
                # 阿里云 oss sts
                oc_qs = OssCrdModel.objects.filter(uid=uid, channel=channel). \
                    values("addTime", "data")
                if oc_qs.exists():
                    endTime = int(oc_qs[0]["addTime"]) + 3500
                    if endTime > now_time:
                        print(endTime)
                        print(now_time)
                        res = json.loads(oc_qs[0]["data"])
                        return JsonResponse(status=200, data=res)
                # 套餐id
                storage = '{uid}/vod{channel}/'.format(uid=uid, channel=channel)
                bucket_name = ubqs[0]['bucket__bucket']
                endpoint = ubqs[0]['bucket__endpoint']
                access_key_id = OSS_STS_ACCESS_KEY
                access_key_secret = OSS_STS_ACCESS_SECRET
                region_id = ubqs[0]['bucket__region']
                role_arn = OSS_ROLE_ARN
                clt = client.AcsClient(access_key_id, access_key_secret, region_id)
                req = AssumeRoleRequest.AssumeRoleRequest()
                # 设置返回值格式为JSON。
                req.set_accept_format('json')
                req.set_RoleArn(role_arn)
                req.set_RoleSessionName(uid + '_' + channel)
                req.set_DurationSeconds(3600)
                Resource_access = "acs:oss:*:*:{bucket_name}/{uid_channel}*". \
                    format(bucket_name=bucket_name, uid_channel=storage)
                print(Resource_access)
                policys = {
                    "Version": "1",
                    "Statement": [
                        {
                            "Action": ["oss:PutObject", "oss:DeleteObject", ],
                            "Resource": [Resource_access],
                            "Effect": "Allow",
                            "Condition": {
                                "IpAddress": {"acs:SourceIp": ip}
                                # "IpAddress": {"acs:SourceIp": "120.237.157.184"}
                                # "IpAddress": {"acs:SourceIp": "*"}
                            }
                        }
                    ]
                }
                req.set_Policy(Policy=json.dumps(policys))
                body = clt.do_action(req)
                # 使用RAM账号的AccessKeyId和AccessKeySecret向STS申请临时token。
                token = json.loads(body.decode('utf-8'))
                print(token)
                res = {
                    'AccessKeyId': token['Credentials']['AccessKeyId'],
                    'AccessKeySecret': token['Credentials']['AccessKeySecret'],
                    'SecurityToken': token['Credentials']['SecurityToken'],
                    'Expiration': token['Credentials']['Expiration'],
                    'expire': '3600',
                    'endpoint': endpoint,
                    'bucket_name': bucket_name,
                    'arn': token['AssumedRoleUser']['Arn'],
                    'code': 0,
                    'storage': storage,
                    'endTime': ubqs[0]['endTime'],
                    'ip': ip}
                if oc_qs.exists():
                    oc_qs.update(data=json.dumps(res), addTime=now_time)
                else:
                    OssCrdModel.objects.create \
                        (uid=uid, channel=channel, data=json.dumps(res), addTime=now_time)
                return JsonResponse(status=200, data=res)
            elif ubqs[0]["bucket__mold"] == 1:
                # 亚马逊 s3 sts
                sts_qs = StsCrdModel.objects.filter(uid=uid, channel=channel). \
                    values("addTime", "data")
                if sts_qs.exists():
                    endTime = int(sts_qs[0]["addTime"]) + 3500
                    if endTime > now_time:
                        print(endTime)
                        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 = ubqs[0]['bucket__bucket']
                endpoint = ubqs[0]['bucket__endpoint']
                region_id = ubqs[0]['bucket__region']

                ###############
                REGION_NAME = region_id
                boto3_sts = boto3.client(
                    'sts',
                    aws_access_key_id='AKIA2E67UIMD45Y3HL53',
                    aws_secret_access_key='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',
                    region_name=REGION_NAME
                )
                Policy = {
                    "Version": "2012-10-17",
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Action": "s3:*",
                            "Resource": ["arn:aws:s3:::azvod1/{uid_channel}/*".
                                             format(uid_channel=storage)]
                        }
                    ]
                }
                response = boto3_sts.get_federation_token(
                    Name='{role_name}'.format(role_name=uid + '_' + 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': '3600',
                    'endpoint': endpoint,
                    'bucket_name': bucket_name,
                    'arn': response['FederatedUser']['Arn'],
                    'code': 0,
                    'storage': storage,
                    'endTime': ubqs[0]['endTime'],
                    'ip': ip,
                }
                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)
            else:
                res = {'code': 404, 'msg': 'data not exists!'}
                return HttpResponse(json.dumps(res, ensure_ascii=False),
                                    content_type="application/json,charset=utf-8")

    def do_pay_by_ali(self, request_dict, userID, response):
        uid = request_dict.get('uid', None)
        rank = request_dict.get('rank', None)
        channel = request_dict.get('channel', None)
        qs = Device_Info.objects.filter(userID_id=userID, UID=uid, isShare=False)
        if not qs.exists():
            return response.json(12)
        if not channel or not rank:
            return response.json(444, 'channel,rank')
        smqs = Store_Meal.objects.filter(id=rank). \
            values("currency", "price", "content", "day", "bucket__storeDay", "bucket__region", "type")
        if not smqs.exists():
            # 套餐不存在
            return response.json(173)
        if smqs[0]['type'] != 1:
            return response.json(10, '不支持支付宝支付')
        currency = smqs[0]['currency']
        price = smqs[0]['price']
        content = smqs[0]['content']
        day = smqs[0]['day']
        nowTime = int(time.time())
        ubqs = UID_Bucket.objects.filter(uid=uid, channel=channel, endTime__gte=nowTime). \
            values("bucket__storeDay", "bucket__region")
        if ubqs.exists():
            if ubqs[0]['bucket__region'] != smqs[0]['bucket__region']:
                return response.json(712)  # 区域不一致
            elif ubqs[0]['bucket__storeDay'] != smqs[0]['bucket__storeDay']:
                return response.json(713)  # 不可更改套餐
            # 续费流程
        nowTime = int(time.time())
        # 新增流程
        orderID = CommonService.createOrderID()

        try:
            aliPayObj = AliPayObject()
            alipay = aliPayObj.conf()
            order_string = alipay.api_alipay_trade_wap_pay(
                out_trade_no=orderID,
                total_amount=price,
                subject="测试哟",
                return_url="{SERVER_DOMAIN_SSL}cloudVod/payOK".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL),
                notify_url="{SERVER_DOMAIN_SSL}cloudVod/aliPayCallback".format(SERVER_DOMAIN_SSL=SERVER_DOMAIN_SSL)
                # return_url="http://192.168.136.40/cloudVod/payOK",
                # notify_url="http://192.168.136.40/cloudVod/aliPayCallback"
            )
        except Exception as e:
            print(repr(e))
            return response.json(10, repr(e))
        if order_string:
            redirectUrl = aliPayObj.alipay_prefix + order_string
            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=orderID, UID=uid, channel=channel, userID_id=userID, desc=content,
                                       price=price, currency=currency, addTime=nowTime, updTime=nowTime,
                                       endTime=nowTime + int(day) * 3600 * 24, rank_id=rank, payType=1,
                                       store_meal_name=store_meal_name)
            return JsonResponse(status=200,
                                data={'result_code': 0, 'reason': 'success',
                                      'result': {"redirectUrl": redirectUrl, "orderID": orderID},
                                      'error_code': 0})
        else:
            return response.json(10, '生成订单错误')

    def do_filter_playlist(self, request_dict, userID, response):
        startTime = int(request_dict.get('startTime', None))
        endTime = int(request_dict.get('endTime', None))
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)
        dvqs = Device_Info.objects.filter(UID=uid, userID_id=userID, isShare=False)
        if not dvqs.exists():
            return response.json(12)
        ubqs = UID_Bucket.objects.filter(uid=uid, channel=channel).values('status')
        if not ubqs.exists():
            return response.json(10, '设备未购买')
        nowTime = int(time.time())
        # vodqs = VodHlsModel.objects.filter(uid=uid, channel=channel, time__range=(startTime, endTime),
        #                                    endTime__gte=nowTime) \
        #     .values("time", "sec", "bucket__bucket", "bucket__endpoint", "bucket__region")
        vodqs = VodHlsModel.objects.filter(uid=uid, channel=channel) \
            .values("time", "sec", "bucket__bucket", "bucket__endpoint", "bucket__region")
        vod_play_list = []
        print(vodqs)
        auth = oss2.Auth(OSS_STS_ACCESS_KEY, OSS_STS_ACCESS_SECRET)
        for vod in vodqs:
            bucket_name = vod["bucket__bucket"]
            endpoint = vod["bucket__endpoint"]
            bucket = oss2.Bucket(auth, endpoint, bucket_name)
            m3u8 = '{uid}/vod{channel}/{time}/{time}.m3u8'. \
                format(uid=uid, channel=channel, time=vod['time'])
            ts = '{uid}/vod{channel}/{time}/ts0.ts'. \
                format(uid=uid, channel=channel, time=vod['time'])
            url = bucket.sign_url('GET', m3u8, 3600, params={'x-oss-process': 'hls/sign'})
            urllst = url.split('?')
            url_start = urllib.parse.unquote(urllst[0])
            url_end = urllst[1]
            vod_play_url = '{url_start}?{url_end}'. \
                format(url_start=url_start, url_end=url_end)
            thumb = bucket.sign_url('GET', ts, 3600,
                                    params={'x-oss-process': 'video/snapshot,t_10000,m_fast,w_300'})
            vod_play_list.append({'name': vod['time'], 'sign_url': vod_play_url, 'thumb': thumb, 'sec': vod['sec']})
        return response.json(0, vod_play_list)

    def generate_token(self, request_dict, userID):
        # UserIdToken
        tko = TokenObject()
        userID = request_dict.get('userID', None)
        username = request_dict.get('username', None)
        res = tko.generate(
            data={'userID': userID, 'lang': 'cn', 'user': username, 'm_code': username})
        # uidToken
        # utko = UidTokenObject()
        # res = utko.generate(data={'uid': '4UZSEDP93MJ3X7YB111A','channel': 1})

        # from Object.ETkObject import ETkObject
        # etkObj = ETkObject(etk='')
        # res = etkObj.encrypt("4UZSEDP93MJ3X7YB111A")
        return JsonResponse(status=200, data=res, safe=False)

    def test_upload_s3(self, request_dict, response):
        aws_s3_guonei = boto3.client(
            's3',
            aws_access_key_id=AWS_ACCESS_KEY_ID[0],
            aws_secret_access_key=AWS_SECRET_ACCESS_KEY[0],
            config=botocore.client.Config(signature_version='s3v4'),
            region_name='cn-northwest-1'
        )
        download_link = 'ipctest'
        response_url = aws_s3_guonei.generate_presigned_url(
            ClientMethod='put_object',
            Params={
                'Bucket': 'pc-package',
                'Key': download_link
            },
            ExpiresIn=3600
        )
        return response.json(0, {'datas': response_url, 'count': 1})

    def testRekognition(self, request, request_dict):
        # ip = CommonService.get_ip_address(request)
        # ipInfo = CommonService.getIpIpInfo(ip,"CN")
        # # print(type(ipInfo))
        # # exit(ipInfo)
        # addr = CommonService.getAddr(ip)
        # dicts = {
        #     'ipInfo':ipInfo,
        #     'addr':addr,
        # }
        # return HttpResponse(json.dumps(dicts, ensure_ascii=False),
        #                     content_type="application/json,charset=utf-8")
        # client = boto3.client('s3', aws_access_key_id='AKIA2E67UIMD45Y3HL53',aws_secret_access_key='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',region_name='us-east-1')
        # exit(request.FILES)

        files = request.FILES.get('image')
        labels = int(request_dict.get('labels', 5))
        minConfidence = int(request_dict.get('minConfidence', 99))
        if not files:
            return HttpResponse('请上传图片！！！！')
        client = boto3.client('rekognition', aws_access_key_id='AKIA2E67UIMD6JD6TN3J',
                              aws_secret_access_key='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', region_name='us-east-1')
        # image = open('E:/photo/a615fa40b8c476bab0f6eeb332e62a5a-1000.jpg', "rb")
        response = client.detect_labels(Image={'Bytes': files.read()}, MaxLabels=labels, MinConfidence=minConfidence)
        # for obj in response['Labels']:
        #     exit(obj)
        #     if obj['Name'] == 'Person':
        #         jsonstr = json.dumps(obj)
        return HttpResponse(json.dumps(response, ensure_ascii=False),
                            content_type="application/json,charset=utf-8")

    def ip(self, response):
        ip = '67.220.90.13'
        country_id = Device_Region().get_device_region(ip)
        print(country_id)
        return response.json(0)

    def configType(self, response):
        print(SERVER_TYPE)
        return response.json(0)

    def createData(self, request_dict, response):
        uid = request_dict.get('uid', None)
        # filter_date = datetime.datetime.now()-datetime.timedelta(days=4)
        # qs = DeviceLogModel.objects.filter(add_time__lt=filter_date)
        DeviceLogModel.objects.create(uid=uid)
        return response.json(0)

    def count_ts(self, request_dict, response):
        year = request_dict.get('year', None)
        month = request_dict.get('month', None)
        if not year:
            year = CommonService.timestamp_to_str(int(time.time()), '%Y')
        if not month:
            month = CommonService.timestamp_to_str(int(time.time()), '%m')
        year = int(year)
        month = int(month)
        startTime = CommonService.str_to_timestamp('{year}-{month}'.format(year=year, month=month), '%Y-%m')
        endTime = CommonService.str_to_timestamp('{year}-{month}'.format(year=year, month=month + 1), '%Y-%m') - 1
        qsTs = VodHlsModel.objects.filter(time__gte=startTime, time__lte=endTime).values('fg')
        if not qsTs.exists():
            return HttpResponse('查无数据')
        sumTs = 0  # 总ts个数
        sumSec = 0  # 总秒数
        for val in qsTs:
            fg = int(val['fg'])
            sumTs += fg & 0xf
            for i in range(15):
                shift = (i + 1) * 4
                sumSec += (fg >> shift) & 0xf
        size = 0
        return HttpResponse(
            "{year}年{month}月 </br>上传的TS总数：{sumTs} </br> 总秒数：{sumSec} </br> 总大小：{size}GB (1秒约等150KB计算)".format(year=year,
                                                                                                              month=month,
                                                                                                              sumTs=sumTs,
                                                                                                              sumSec=sumSec,
                                                                                                              size=size))

    @staticmethod
    def write_redis_list(response):
        redis_obj = RedisObject()
        for i in range(10):
            redis_obj.rpush('serial_redis_list', i)
        return response.json(0)

    @staticmethod
    def read_redis_list(response):
        redis_obj = RedisObject()
        serial_redis_list_len = redis_obj.llen('serial_redis_list')
        if serial_redis_list_len > 0:
            for i in range(serial_redis_list_len):
                serial = redis_obj.lpop('serial_redis_list')
                print(serial)
        return response.json(0)

    @staticmethod
    def play_m3u8(request_dict, response):  # 根据sts播放m3u8 视频流
        uid = request_dict.get('uid', None)
        channel = request_dict.get('channel', None)
        storeTime = request_dict.get('time', None)
        now_time = int(time.time())
        try:
            vh_qs = VodHlsModel.objects.filter(uid=uid, channel=channel, time=storeTime, 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']

            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:
                    tsFile = '{uid}/vod{channel}/{time}/ts{i}.ts'. \
                        format(uid=uid, channel=channel, time=storeTime, i=i)
                    response_url = conn.generate_presigned_url(
                        'get_object',
                        Params={
                            'Bucket': bucket_name,
                            'Key': tsFile
                        },
                        ExpiresIn=24 * 60 * 60
                    )
                    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
        except Exception as e:
            print(e)
            return response.json(500, repr(e))