Esempio n. 1
0
def video(id):
    video = Video.get_by_id(id)
    if video is None:
        return {}, 404

    if request.method == 'GET':
        video_dict = video.as_dict()
        response = jsonify(video_dict)
        response.status_code = 200
        return response

    if is_valid_admin(request):
        if request.method == 'PUT':
            result = request.get_json()
            video = Video.update_data(id, result)
            if video:
                video_dict = video.as_dict()
                response = jsonify(video_dict)
                response.status_code = 200
                return response
            else:
                return error_response('Video não atualizado', 500)

        elif request.method == 'DELETE':
            if Video.delete(id):
                # deletar no youtube
                return {}, 200
            else:
                return error_response('Video não deletado', 500)
    else:
        return error_response('Permissão negada', 401)
Esempio n. 2
0
 def test_job_zencoder(self):
     self.video = Video(formato = 'webm', file = "%stestes/video_teste.mp4" % settings.MEDIA_URL)
     self.video.save()
     self.job = self.video.schedule_zencoder_job()
     self.assertNotEqual(self.job.body['id'], 0)
     self.assertEqual(self.job.code, 201)
     self.assertEqual(self.job.body['outputs'][0]['url'], "http://nandotorres.s3.amazonaws.com/video_teste.mp4.webm")        
Esempio n. 3
0
def upload(request):
    if request.method == "POST":
        uf = VideoForm(request.POST, request.FILES)
        if uf.is_valid():  # if valid
            videoname = uf.cleaned_data['videoname']
            Frame = uf.cleaned_data['Frame']
            File = uf.cleaned_data['File']
            # save file
            video = Video()
            video.videoname = videoname
            video.Frame = Frame
            video.File = File
            result = video
            result.save()
            x = requests.post(url,data={"videoname":videoname},files=request.FILES)
            with open(os.path.join("app/static/video", videoname+".mp4"),"wb") as f:
                f.write(x.content)
            with open(os.path.join("app/static/headers", videoname+".json"),"w") as f:
                f.write(json.dumps(dict(x.headers)))
            v = os.path.join("/static/video", videoname+".mp4")
            h = os.path.join("/static/headers", videoname + ".json")
            x={"v":v,"h":h}
            return render_to_response('video.html',x)
    else:
        uf = VideoForm()

    return render_to_response('upload.html',{'uf':uf})
Esempio n. 4
0
def add_video():
    form = VideoForm()
    if form.validate_on_submit():
        video = Video(description=form.description.data, url=form.url.data)
        video.save()
        return redirect(url_for('main.videos'))
    return render_template('admin/add_video.html', form=form)
Esempio n. 5
0
class SimpleTest(TestCase):
    """
     Testando o response da index
    """ 
    def test_index(self):
        resp = self.client.get('/')
        self.assertEqual(resp.status_code, 200)
    
    """
     Testando criar um video
    """
    def test_criar_video(self):
        self.video = Video(formato = 'WEBM', file = "%stestes/video_teste.mp4" % settings.MEDIA_URL)
        self.video.save()
        self.assertNotEqual(self.video.id, 0)
        self.assertEqual(self.video.formato, 'WEBM')
        self.assertEqual(self.video.file.name, "%stestes/video_teste.mp4" % settings.MEDIA_URL)
    
    """
     Testando o retorno de um job enviado para o zencoder
    """
    def test_job_zencoder(self):
        self.video = Video(formato = 'webm', file = "%stestes/video_teste.mp4" % settings.MEDIA_URL)
        self.video.save()
        self.job = self.video.schedule_zencoder_job()
        self.assertNotEqual(self.job.body['id'], 0)
        self.assertEqual(self.job.code, 201)
        self.assertEqual(self.job.body['outputs'][0]['url'], "http://nandotorres.s3.amazonaws.com/video_teste.mp4.webm")        
Esempio n. 6
0
def deploy():
    '''Run deployment tasks'''
    upgrade()
    Video.load_video()
    for v in Video.query.all():
        v.difficulties = randint(0,2)
    db.session.commit()
    search.create_index()
    search.update_index()
Esempio n. 7
0
def deploy():
    '''Run deployment tasks'''
    # migrate database to latest revision
    from flask_migrate import upgrade
    upgrade()

    verbose = False
    if app.debug:
        verbose_mode = input('Run in verbose mode? [yes/No]: ')
        if verbose_mode.lower() in ['y', 'yes']:
            verbose = True

    # insert data
    data = 'common'

    from app.models import Permission
    Permission.insert_entries(data=data, verbose=verbose)

    from app.models import Role
    Role.insert_entries(data=data, verbose=verbose)

    from app.models import Room
    Room.insert_entries(data=data, verbose=verbose)

    from app.models import DeviceType
    DeviceType.insert_entries(data=data, verbose=verbose)

    from app.models import LessonType
    LessonType.insert_entries(data=data, verbose=verbose)

    from app.models import Lesson
    Lesson.insert_entries(data=data, verbose=verbose)

    from app.models import Video
    Video.insert_entries(data=data, verbose=verbose)

    data = input(
        'Enter data identifier (e.g.: 20180805 or press the enter/return key for initial data): '
    )
    if data == '':
        data = 'initial'
    datadir = os.path.join(app.config['DATA_DIR'], data)
    if os.path.exists(datadir):
        from app.models import User
        User.insert_entries(data=data, verbose=verbose)

        from app.models import Punch
        Punch.insert_entries(data=data, verbose=verbose)

        from app.models import Device
        Device.insert_entries(data=data, verbose=verbose)

        from app.models import DeviceLessonType
        DeviceLessonType.insert_entries(data=data, verbose=verbose)

        from app.models import UserLog
        UserLog.insert_entries(data=data, verbose=verbose)
Esempio n. 8
0
def upload(request):

    feedback = {}  #sera usado para o retorno da acao

    if request.is_ajax() or request.method == 'POST':
        form = VideoForm(request.POST, request.FILES)
        video = Video(file=request.FILES['file'])
        video.formato = request.POST['formato']
        video.save()
        job = video.schedule_zencoder_job()

        if job.code == 201:
            feedback["status"] = "201"
            feedback["job_id"] = job.body['id']
            feedback["video_id"] = video.id
            video.job_id = job.body['id']
            video.save()
        else:
            feedback["status"] = "422"
            feedback["job_id"] = "0"

        return HttpResponse(simplejson.dumps(feedback),
                            mimetype="application/json")
    else:
        form = VideoForm()

    feedback["status"] = "nok"
    feedback["job_id"] = "0"

    return HttpResponse(simplejson.dumps(feedback),
                        mimetype="application/json")
Esempio n. 9
0
def upload_video():
    if request.method == "UPDATE":
        duration = request.values.get('duration')
        v_id = request.values.get('v_id')
        video = Video.query.get(v_id)
        if video:
            video.duration = duration
            db.session.add(video)
            db.session.commit()
            video.course.update_duration()
            for uv in video.u_videos:
                uv.update_duration()
            return jsonify({
                'resCode': 'ok',
                'msg': '时长更新完毕!'
            })
    file = request.files.get('file')
    c_id = request.values.get('c_id')
    course = Course.query.get_or_404(c_id)
    filename = file.filename
    title = filename.split('.')[0] if isinstance(filename, str) else 'None'
    video = Video(title=title)
    video.course = course
    db.session.add(video)
    db.session.commit()
    v_id = video.id
    base_path = 'app/static/videos/'
    base_name = 'course{}-{}'.format(c_id, v_id)
    _filename = '{}.{}'.format(base_name, filename.split('.')[1])
    path = '/static/videos/' + _filename
    try:
        file.save(base_path + _filename)
        video.video_src = path
        db.session.add(video)

        choices = course.choices.all()
        users = [choice.user for choice in choices]
        for user in users:
            uv = UserVideo.create(user, video)

    except Exception as e:
        print(e)
        db.session.delete(video)

    return jsonify({
        'id': v_id,
        'duration': video.duration or '-',
        'order': video.order,
        'resCode': 'ok',
        'msg': 'ok',
        'filename': video.get_filename()
    })
def enqueue_video():
    key = request.args.get('key', default=None, type=str)
    question_id = request.args.get('question_id', default=None, type=int)
    submission_id = request.args.get('submission_id', default=None, type=int)

    v = Video(applicant=current_user._get_current_object(),
              question=Question.query.get(question_id),
              s3_key=key,
              user_agent=UserAgentSchema().dump(request.user_agent).data,
              submission=Submission.query.get(submission_id))
    db.session.add(v)
    db.session.commit()
    return jsonify(v.to_dict())
Esempio n. 11
0
def upload(request):
    
    feedback = {} #sera usado para o retorno da acao
    
    if request.is_ajax() or request.method == 'POST':        
        form = VideoForm(request.POST, request.FILES)
        video = Video(file = request.FILES['file'])
        video.formato = request.POST['formato']
        video.save()
        job = video.schedule_zencoder_job()
        
        if job.code == 201:
            feedback["status"] = "201" 
            feedback["job_id"] = job.body['id']
            feedback["video_id"] = video.id
            video.job_id = job.body['id']
            video.save()
        else:
            feedback["status"] = "422"
            feedback["job_id"] = "0"
        
        return HttpResponse(simplejson.dumps(feedback), mimetype="application/json")
    else:
        form = VideoForm()

    feedback["status"] = "nok"
    feedback["job_id"] = "0"
    
    return HttpResponse(simplejson.dumps(feedback), mimetype="application/json")
Esempio n. 12
0
    def test_videos_ordered_by_id(self):
        v1 = Video(embed_url="test1")
        db.session.add(v1)
        db.session.commit()
        v2 = Video(embed_url="test2")
        db.session.add(v2)
        db.session.commit()

        response = self.app.get('/videos')
        v1 = Video.query.get(1)
        v2 = Video.query.get(2)
        v1Index = response.data.find(b'test1')
        v2Index = response.data.find(b'test2')
        self.assertLess(v1Index, v2Index)

        v1.id = -1
        v2.id = -2
        db.session.commit()
        v1.id = 2
        v2.id = 1
        db.session.commit()

        response = self.app.get('/videos')
        v1Index = response.data.find(b'test1')
        v2Index = response.data.find(b'test2')
        self.assertLess(v2Index, v1Index)
Esempio n. 13
0
def handle_video_upload(id):
    vid = request.files['video']
    size = request.form['size']
    if vid:
        content = vid.content_type
        if int(size) < (10 * 1024 * 1024):
            try:
                filename = secure_filename(vid.filename)
                s3.Bucket(BUCKET_NAME).put_object(Body=vid,
                                                  Key=filename,
                                                  ContentType=content,
                                                  ACL='public-read')
                newVideo = Video(
                    content=f'https://bbscouting.s3.amazonaws.com/{filename}',
                    content_type=content,
                    player_id=id)
                db.session.add(newVideo)
                db.session.commit()
                return jsonify({
                    'video_url':
                    f'https://bbscouting.s3.amazonaws.com/{filename}',
                    'type': content
                })
            except:
                return jsonify({'upload': False})
        else:
            try:
                filename = secure_filename(vid.filename)
                s3.Object(BUCKET_NAME,
                          filename).upload_fileobj(vid,
                                                   ExtraArgs={
                                                       'ContentType': content,
                                                       'ACL': 'public-read'
                                                   },
                                                   Config=multi_config)
                newVideo = Video(
                    content=f'https://bbscouting.s3.amazonaws.com/{filename}',
                    content_type=content,
                    player_id=id)
                db.session.add(newVideo)
                db.session.commit()
                return jsonify({
                    'video_url':
                    f'https://bbscouting.s3.amazonaws.com/{filename}',
                    'type': content
                })
            except:
                return jsonify({'upload': False})
Esempio n. 14
0
    def search(name):
        """搜索接口2"""
        logger.info(f'引擎 {__name__} 正在搜索: {name}')
        result = []
        search_api = 'http://service-agbhuggw-1259251677.gz.apigw.tencentcs.com/android/search'
        info_api = 'http://service-agbhuggw-1259251677.gz.apigw.tencentcs.com/android/video/list_ios'

        req = Engine.post(search_api, data={'userid': '', 'key': name})
        if req.status_code != 200 or req.json().get('errorCode') != 0:
            return result
        video_id_list = [int(v['videoId']) for v in req.json().get('data')]  # 搜索结果: 视频 id
        for vid in video_id_list:
            req = Engine.get(info_api, {'userid': '', 'videoId': vid})
            if req.status_code != 200 or req.json().get('errorCode') != 0:
                continue
            info = req.json().get('data')  # 视频详情信息
            video_list = VideoList()
            video_list.engine = __name__
            video_list.title = info['videoName']
            video_list.cover = info['videoImg']
            video_list.desc = info['videoDoc'] or '视频简介弄丢了 (/▽\)'
            video_list.cat = info['videoClass'].split('/')
            logger.info(f"引擎 {__name__} 正在处理: {video_list.title}")
            for video in info['videoSets'][0]['list']:
                name = f"第 {video['ji']} 集"
                video_list.add_video(Video(name, raw_url=video['playid'], handler=PlayIdHandler))  # playid: xxx-x-x
            result.append(video_list)
        return result
Esempio n. 15
0
def add_video():
    form = AddVideoForm()
    form.classname.choices = [(_classroom.id, _classroom.name)
                              for _classroom in Classroom.query.filter_by(
                                  creator_id=current_user.id).all()]
    if form.validate_on_submit():
        id = db.session.query(func.max(Video.id)).scalar()
        if id is None:
            id = 0
        id += 1
        file_name = 'file' + str(id)
        data = request.files[form.video.name].read()
        open(os.path.join(current_app.config['UPLOAD_PATH'], file_name),
             'wb').write(data)

        classroom = Classroom.query.filter_by(
            id=int(form.classname.data)).first_or_404()
        video = Video(file=file_name,
                      name=form.name.data,
                      creator_id=current_user.id)
        video.classes.append(classroom)

        db.session.add(video)
        db.session.commit()
        flash('Your new video has been saved.')
        return redirect(url_for('main.index'))
    return render_template('video/add_video.html',
                           title='Add Video',
                           form=form)
Esempio n. 16
0
 def test_04_get_by_id(self):
     course = Course.add({'name': 'Curso de Teste'})
     user = User.register('*****@*****.**', '12345678')
     video = Video.add(1, {'title': 'Video 1'})
     watches = Watches.add(1, 1)
     watches = Watches.get_by_ids(1, 1)
     assert watches is not None
Esempio n. 17
0
def videos(id):
    course = Course.get_by_id(id)
    if course is None:
        return {}, 404

    if request.method == 'GET':
        videos = course.get_videos_as_dict()
        response = jsonify(videos)
        response.status_code = 200
        return response

    elif request.method == 'POST':
        if is_valid_admin(request):
            request_video = {}
            if request.files:
                upload_succeded, video = upload_video(request.files['video'],
                                                      request.form)
                if upload_succeded:
                    info = video['snippet']
                    request_video = {
                        'youtube_code': video['id'],
                        'title': info['title'],
                        'description': info['description'],
                        'thumbnail': info['thumbnails']['high']['url'],
                        'duration': request.form['duration'],
                        'course_order': int(request.form['course_order'])
                    }
            else:
                request_video = request.get_json()
            video = Video.add(id, request_video)
            if video:
                return {}, 200
            return error_response('Vídeo não adicionado', 500)
        return error_response('Permissão negada', 401)
Esempio n. 18
0
def eyewitness():
    form = UploadForm()

    if form.validate_on_submit():

        f = form.upload.data
        if not allowed_video_file(f.filename):
            flash("Invalid file type")
            return redirect(url_for('eyewitness'))

        filename = secure_filename(f.filename)
        f.save(os.path.join(app.config['UPLOAD_FOLDER'], 'video', filename))

        video = Video(title=form.title.data, description=form.description.data, filename=filename, author=current_user)
        db.session.add(video)
        db.session.commit()
        flash("Video successfully uploaded.")
        return redirect(url_for('eyewitness'))

    page = request.args.get('page', 1, type=int)
    videos = current_user.followed_videos().paginate(
        page, app.config['VIDEOS_PER_PAGE'], False)

    next_url = url_for('eyewitness', page=videos.next_num) if videos.has_next else None
    prev_url = url_for('eyewitness', page=videos.prev_num) if videos.has_prev else None

    return render_template('eyewitness.html', title="The Frontlines", form=form, videos=videos.items, next_url=next_url, prev_url=prev_url)
Esempio n. 19
0
    def parserVideo(self):

        url = 'http://v8.ccut.edu.cn/article.php?/%s' % self.v_index
        print url

        try:
            html = urllib2.urlopen(url).read().decode("gb2312")

            patName = re.compile(r'<font class=bigfont><b>(.*)</b>')
            patURL = re.compile(r'href="(.*\.rmvb|.*\.mp4)"')
            patList = re.compile(
                r'<a href="http://v8\.ccut\.edu\.cn/sort\.php\?/\d*">(.*?)</a>'
            )

            resName = re.findall(patName, html)[0]
            resURL = re.findall(patURL, html)[0]
            resList = re.findall(patList, html)

            video = Video(id=self.v_index,
                          title=resName,
                          url=resURL,
                          leve1=resList[0],
                          leve2=resList[1])
            db.session.add(video)
            db.session.commit()

            print("Success save to database --- %s" % resName)
        except Exception, e:
            print("Error:%s" % e)
            db.session.rollback()
            self.v_index += 1

            return
Esempio n. 20
0
 def test_03_get_videos_as_dict(self):
     course = Course.add({'name': "Curso de Teste"})
     course = Course.get_by_id(1)
     video = Video.add(1, {'youtube_code': 'test_code', 'course_order': 1})
     videos = course.get_videos_as_dict()
     assert list(videos[0].keys()) == ['id', 'youtube_code', 'title', \
         'description', 'duration', 'thumbnail', 'course_order'] and videos[0]['youtube_code'] == 'test_code'
Esempio n. 21
0
def postVideoId():

    video_id = request.form['videoid']
    msg = request.form['msg-txt']
    ip = str(get_ip())

    try:
        video = pafy.new(video_id)
    except (OSError, ValueError) as e:
        return jsonify(result='404', error=e)

    post = Video(videoId=video.videoid,
                 length=video.length // 60,
                 message=msg,
                 title=video.title,
                 timestamp=datetime.utcnow())  # add a Post db obj

    # check for user in db
    user = User.query.filter_by(ip=ip).first()

    if user == None or user.ip != ip:  #if user do not exist
        new_user = User(ip=ip)

        db.session.add(new_user)
        new_user.videos.append(post)

    else:  #user already exist in db
        user.videos.append(post)

    db.session.commit()

    return jsonify(result='saved successfully')
Esempio n. 22
0
def add_video():
    new_video = Video(name=request.form['name'],
                      embed_url=request.form['embedurl'])
    db.session.add(new_video)
    db.session.commit()
    flash('success')
    return redirect(url_for('videos'))
Esempio n. 23
0
def scrape_channel(channel_id):
    for videoId in get_channel_videos(channel_id):
        videoData = get_video_data(videoId)
        video = db.session.query(Video).filter_by(videoId=videoId).first()
        if video:
            pass
        else:
            video = Video(videoId=videoId,
                          title=videoData['title'],
                          channelId=channel_id,
                          publishedAt=videoData['publishedAt'],
                          description=videoData['description'],
                          thumbnail=videoData['thumbnail'])
            db.session.add(video)
            db.session.commit()
            if videoData['tags']:
                for tag in videoData['tags']:
                    video.tags.append(get_or_create_tag(tag))
                    db.session.commit()

        stats = Stats(videoId=video.id,
                      viewCount=videoData['viewCount'],
                      commentCount=videoData['commentCount'],
                      likeCount=videoData['likeCount'],
                      dislikeCount=videoData['dislikeCount'],
                      favoriteCount=videoData['favoriteCount'])
        db.session.add(stats)
        db.session.commit()
Esempio n. 24
0
def videos():
    vs = Video.objects()
    page = request.args.get('page', 1, type=int)
    paginated_videos = vs.paginate(page=page,
                                   per_page=current_app.config['PIC_PER_PAGE'])
    current_page = paginated_videos.page
    total_page = paginated_videos.pages

    page_start = 1
    page_end = 5
    if total_page < 5:
        page_end = total_page
    else:
        page_start = current_page - 2
        page_end = current_page + 2
        if page_start < 1:
            page_start = 1
            page_end = 5
        if page_end > total_page:
            page_start = total_page - 4
            page_end = total_page

    url_list = []
    for p in range(1, total_page + 1):  # so page number start from 1
        url = url_for('main.videos', page=p)
        url_list.append(url)
    return render_template('main/videos.html',
                           videos=paginated_videos.items,
                           current_page=current_page,
                           total_page=total_page,
                           page_start=page_start,
                           page_end=page_end,
                           url_list=url_list)
Esempio n. 25
0
def upload_video():
    if current_user.email not in current_app.config['ADMINS']:
        flash("You are not authorized to access this page.")
        return redirect(url_for('main.index'))

    form = UploadVideoForm()
    if form.validate_on_submit():
        f = form.upload.data

        if not allowed_video_file(f.filename):
            flash("Invalid file type")
            return redirect(url_for('media.upload_video'))

        filename = secure_filename(f.filename)
        f.save(
            os.path.join(current_app.config['UPLOAD_FOLDER'], 'videos',
                         filename))
        video = Video(title=form.title.data,
                      description=form.description.data,
                      filename=filename)

        db.session.add(video)
        db.session.commit()
        flash("Video uploaded successfully.")
        return redirect(url_for('media.video', video_id=video.id))

    return render_template('media/upload_video.html',
                           title="Upload Video",
                           form=form)
Esempio n. 26
0
def subscribe():
    form = SubscribeForm()
    if form.validate_on_submit():
        videos = get_channel_videos(form.channel.data)

        if not videos:
            raise DownloadError('Channel \'{}\' not found'.format(
                form.channel.data))

        channel = Channel(name=videos[0]['uploader_id'],
                          channel_id=videos[0]['channel_id'])
        db.session.add(channel)
        db.session.commit()

        for v in videos:
            if v and 'id' in v:
                video = Video(video_id=v['id'],
                              title=v['title'],
                              channel_id=channel.id,
                              description=v['description'],
                              thumbnail_url=v['thumbnail'],
                              duration=v['duration'],
                              upload_date=datetime.strptime(
                                  v['upload_date'], '%Y%m%d'),
                              view_count=v['view_count'])
                db.session.add(video)
        db.session.commit()

    return redirect('/channels')
Esempio n. 27
0
 def create_db_entry(self):
     v = Video(self.currentVideo[0])
     v.timestamp = datetime.datetime.fromtimestamp(self.start_time)
     v.length = self.currentVideo[1]
     v.watched = int(time.time() - self.start_time)
     if v.watched > v.length:
         v.watched = v.length
     v.viewers = len(self.ip_list)
     v.skips = len(self.skip_list)
     v.title = self.currentVideo[2]
     v.query = self.currentVideo[3]
     db.session.add(v)
     db.session.commit()
Esempio n. 28
0
    def test_adding_video_adds_to_video_page(self):
        v = Video(embed_url="test/embed/test")
        db.session.add(v)
        db.session.commit()

        response = self.app.get('/videos')
        v = Video.query.get(1)
        self.assertIn(bytes(v.embed_url, 'utf-8'), response.data)
Esempio n. 29
0
 def test_03_as_dict(self):
     course = Course.add({'name': 'Curso de Teste'})
     user = User.register('*****@*****.**', '12345678')
     video = Video.add(1, {'title': 'Video 1'})
     watches = Watches.add(1, 1)
     watches_dict = watches.as_dict()
     assert list(watches_dict.keys()) == ['user_id', 'video_id', 'watched_time', 'finished'] and \
         watches_dict['finished'] == False
Esempio n. 30
0
    def search_one_page(name, page) -> list:
        """处理一页的数据"""
        logger.info(f'引擎 {__name__} 正在搜索: {name} (第 {page} 页)')
        result = []
        search_api = 'http://59.110.16.198/app.php/XyySearch/get_search_data'
        data = {'keyword': name, 'uid': 0, 'page': page, 'type': 1}
        resp = Engine.post(search_api, data)
        if resp.status_code != 200:
            return result
        if resp.text.startswith(u'\ufeff'):  # 解决 UTF-8 BOM 编码的问题
            resp = resp.text.encode('utf8')[3:].decode('utf8')
        resp = json.loads(resp)

        if not resp['data']:
            return result

        for item in resp['data']:
            video_list = VideoList()
            is_rubbish_flag = False  # 有些视频是有问题的,应该抛弃
            if not item['video_lists']:  # 有可能出现视频列表为空的情况
                continue
            video_list.engine = __name__
            video_list.title = item['video_subject'].strip()
            video_list.cover = item['video_image']
            video_list.desc = item['video_describe'] or '视频简介弄丢了 (/▽\)'

            logger.info(f"引擎 {__name__} 正在处理: {video_list.title}")
            if item['video_type']:
                video_list.cat = [
                    cat['video_type_name'] for cat in item['video_type']
                ]
            else:
                video_list.cat = ['默认']
            for video in item['video_lists']:
                url = video['vod_id']  # 有可能出现 URL 有误的情况(迷)
                if not url.startswith('http'):
                    is_rubbish_flag = True  # 有问题的视频,标记起来

                if 'www.iqiyi.com' in url:
                    is_rubbish_flag = True  # 爱奇艺的加密算法太麻烦,暂时不解析
                elif 'youku.com' in url:
                    is_rubbish_flag = True  # 优酷视频,暂时不解析
                elif 'dilidili' in url:
                    is_rubbish_flag = True  # 嘀哩嘀哩已挂

                name = f"第 {video['video_number']} 集"
                video_type = 'mp4'
                handler = None
                if url.endswith('m3u8'):
                    handler = M3U8Handler
                    video_type = 'hls'  # m3u8 格式类型为 hls(播放器要求)
                elif 'bilibili' in url:
                    handler = BilibiliHandler
                    video_type = 'mp4'
                video_list.add(Video(name, url, video_type, handler))
            if not is_rubbish_flag:
                result.append(video_list)
        return result
Esempio n. 31
0
 def test_07_update_fail(self):
     course = Course.add({'name': 'Curso de Teste'})
     user = User.register('*****@*****.**', '12345678')
     video = Video.add(1, {'title': 'Video 1'})
     watches = Watches.add(1, 1)
     updated = Watches.update_data(1, 1, {
         'watched_time': 200,
         'finish': False
     })
Esempio n. 32
0
def load_files():
    if request.method == 'POST':
        owner_id = request.form.get('id', None)
        file = request.files["video_file"] or None
        if file == None:
            return jsonify({"error": "requires file"})
        file.filename = secure_filename(file.filename)
        folder = f'{owner_id}/videos/{file.filename}'
        # file_path = BUCKET_NAME + '.s3-us-west-1.amazonaws.com/' + folder
        s3 = AwsS3UploadClass(ACCESS_ID, ACCESS_KEY, BUCKET_NAME)
        key = file.filename
        # file.save(key)
        response = s3.create_presigned_post(folder)
        if response is None:
            return jsonify({"error": "key cannot be None"})
        files = [('file', open(key, 'rb'))]
        upload_response = requests.post(response['url'],
                                        data=response['fields'],
                                        files=files)
        if upload_response.status_code == 204:
            os.remove(key)
        # unprotected file upload
        # s3.upload_fileobj(file, BUCKET_NAME, file_path, ExtraArgs={'ACL': 'public-read', "ContentType": file.content_type})
        video = Video(
            title=request.form.get('title', None),
            description=request.form.get('description', None),
            link=folder,
            thumbnail=request.form.get('thumbnail', None),
            owner_id=owner_id,
        )
        db.session.add(video)
        db.session.commit()
        return {"response": response}
        # return {"video": video.to_dict()}, 200
    else:
        if 'user' in session:
            user = session['user']
            videos = Video.query.filter(Video.owner_id != user["id"]).all()
            data = [video.to_dict() for video in videos]
            return {"videos": data}, 200
        else:
            videos = Video.query.all()
            data = [video.to_dict() for video in videos]
            return {"videos": data}, 200
Esempio n. 33
0
 def test_criar_video(self):
     self.video = Video(formato = 'WEBM', file = "%stestes/video_teste.mp4" % settings.MEDIA_URL)
     self.video.save()
     self.assertNotEqual(self.video.id, 0)
     self.assertEqual(self.video.formato, 'WEBM')
     self.assertEqual(self.video.file.name, "%stestes/video_teste.mp4" % settings.MEDIA_URL)