Python widget.add_onsite_js_files函数代码示例

def detail_members(request, slug):
    #just other tab of detail view
    q = request.REQUEST.get('q')
    
    team = Team.get(slug, request.user)
    
    qs = team.members.all()
    if q:
        qs = qs.filter(Q(user__first_name__icontains=q)|Q(user__last_name__icontains=q) \
                       |Q(user__username__icontains=q)|Q(user__biography__icontains=q))

    extra_context = widget.add_onsite_js_files({})  

    extra_context.update({
        'team': team,
        'query': q
    })
    
    if team.video:
        extra_context['widget_params'] = base_widget_params(request, {
            'video_url': team.video.get_video_url(), 
            'base_state': {}
        })    
    return object_list(request, queryset=qs, 
                       paginate_by=MEMBERS_ON_PAGE, 
                       template_name='teams/detail_members.html', 
                       extra_context=extra_context, 
                       template_object_name='team_member')

def detail(request, slug):
    team = Team.get(slug, request.user)
    
    languages = get_user_languages_from_request(request)
    languages.append('')
    video_ids = team.teamvideo_set.values_list('video_id', flat=True)
    
    qs = SubtitleLanguage.objects.filter(video__in=video_ids).filter(language__in=languages) \
        .exclude(Q(writelock_time__gte=datetime.datetime.now()-datetime.timedelta(seconds=WRITELOCK_EXPIRATION))) \
        .extra(where=['NOT ((SELECT COUNT(vs.id) FROM videos_subtitleversion AS vs INNER JOIN videos_subtitlelanguage AS vsl ON (vsl.id = vs.language_id) WHERE vsl.is_original = %s AND vsl.video_id = videos_subtitlelanguage.video_id) <= 0 AND videos_subtitlelanguage.is_original=%s)'], params=(True, False,)) \
        .distinct()

    qs1 = qs.filter(is_forked=False, is_original=False).filter(percent_done__lt=100, percent_done__gt=0)
    qs2 = qs.filter(is_forked=False, is_original=False).filter(percent_done=0)
    qs3 = qs.filter(is_original=True).filter(subtitleversion__isnull=True)
    qs4 = qs.filter(is_forked=False, is_original=False).filter(percent_done=100)
    qs5 = qs.filter(Q(is_forked=True)|Q(is_original=True)).filter(subtitleversion__isnull=False)
       
    extra_context = widget.add_onsite_js_files({})    
    extra_context.update({
        'team': team
    })

    if team.video:
        extra_context['widget_params'] = base_widget_params(request, {
            'video_url': team.video.get_video_url(), 
            'base_state': {}
        })
    return object_list(request, queryset=MultyQuerySet(qs1, qs2, qs3, qs4, qs5), 
                       paginate_by=VIDEOS_ON_PAGE, 
                       template_name='teams/detail.html', 
                       extra_context=extra_context, 
                       template_object_name='team_video_lang')

def index(request):
    context = widget.add_onsite_js_files({})
    context['all_videos'] = Video.objects.count()
    context['popular_videos'] = VideoIndex.get_popular_videos("-today_views")[:VideoIndex.IN_ROW]
    context['featured_videos'] = VideoIndex.get_featured_videos()[:VideoIndex.IN_ROW]
    return render_to_response('index.html', context,
                              context_instance=RequestContext(request))

def video(request, video_id, video_url=None, title=None):
    video = get_object_or_404(Video, video_id=video_id)
    if video_url:
        video_url = get_object_or_404(VideoUrl, pk=video_url)
    
    if (video.title and not video.title_for_url() == title) or (not video.title and title):
        return redirect(video, permanent=True)
    
    video.update_view_counter()
    
    # TODO: make this more pythonic, prob using kwargs
    context = widget.add_onsite_js_files({})
    context['video'] = video
    context['site'] = Site.objects.get_current()
    context['autosub'] = 'true' if request.GET.get('autosub', False) else 'false'
    translations = list(video.subtitlelanguage_set.filter(had_version=True) \
        .filter(is_original=False).select_related('video'))
    translations.sort(key=lambda f: f.get_language_display())
    context['translations'] = translations
    context['widget_params'] = _widget_params(request, video, None, '')
    _add_share_panel_context_for_video(context, video)
    context['lang_count'] = video.subtitlelanguage_set.filter(has_version=True).count()
    context['original'] = video.subtitle_language()
    return render_to_response('videos/video.html', context,
                              context_instance=RequestContext(request))

def diffing(request, first_pk, second_pk):
    first_version = get_object_or_404(SubtitleVersion, pk=first_pk)
    language = first_version.language
    second_version = get_object_or_404(SubtitleVersion, pk=second_pk, language=language)

    video = first_version.language.video
    if second_version.datetime_started > first_version.datetime_started:
        first_version, second_version = second_version, first_version

    second_captions = dict([(item.subtitle_id, item) for item in second_version.ordered_subtitles()])
    first_captions = dict([(item.subtitle_id, item) for item in first_version.ordered_subtitles()])

    subtitles = {}

    for id, item in first_captions.items():
        if not id in subtitles:
            subtitles[id] = item.start_time

    for id, item in second_captions.items():
        if not id in subtitles:
            subtitles[id] = item.start_time

    subtitles = [item for item in subtitles.items()]
    subtitles.sort(key=lambda item: item[1])

    captions = []
    for subtitle_id, t in subtitles:
        try:
            scaption = second_captions[subtitle_id]
        except KeyError:
            scaption = None
        try:
            fcaption = first_captions[subtitle_id]
        except KeyError:
            fcaption = None

        if fcaption is None or scaption is None:
            changed = dict(text=True, time=True)
        else:
            changed = {
                "text": (not fcaption.text == scaption.text),
                "time": (not fcaption.start_time == scaption.start_time),
                "end_time": (not fcaption.end_time == scaption.end_time),
            }
        data = [fcaption, scaption, changed]
        captions.append(data)

    context = widget.add_onsite_js_files({})
    context["video"] = video
    context["captions"] = captions
    context["language"] = language
    context["first_version"] = first_version
    context["second_version"] = second_version
    context["latest_version"] = language.latest_version()
    context["widget0_params"] = _widget_params(request, video, first_version.version_no)
    context["widget1_params"] = _widget_params(request, video, second_version.version_no)
    return render_to_response("videos/diffing.html", context, context_instance=RequestContext(request))

def onsite_widget(request):
    """Used for onsite subtitling

    Temporary kludge for http://bugzilla.pculture.org/show_bug.cgi?id=13694"""
    context = widget.add_onsite_js_files({})
    spaces = ' ' * 9
    params = base_widget_params(request, extra_params={'returnURL': request.GET['return_url']})
    context['widget_params'] = params
    return render_to_response('widget/onsite_widget.html',
                              context,
                              context_instance=RequestContext(request))

def history(request, video_id, lang=None, lang_id=None):
    video = get_object_or_404(Video, video_id=video_id)
    video.update_view_counter()

    context = widget.add_onsite_js_files({})

    if lang_id:
        try:
            language = video.subtitlelanguage_set.get(pk=lang_id)
        except SubtitleLanguage.DoesNotExist:
            raise Http404
    else:
        language = video.subtitle_language(lang)

    if not language:
        if lang in dict(settings.ALL_LANGUAGES):
            config = {}
            config["videoID"] = video.video_id
            config["languageCode"] = lang
            url = reverse('onsite_widget')+'?config='+urlquote_plus(json.dumps(config))
            return redirect(url)
        else:
            raise Http404

    qs = language.subtitleversion_set.select_related('user')
    ordering, order_type = request.GET.get('o'), request.GET.get('ot')
    order_fields = {
        'date': 'datetime_started', 
        'user': 'user__username', 
        'note': 'note', 
        'time': 'time_change', 
        'text': 'text_change'
    }
    if ordering in order_fields and order_type in ['asc', 'desc']:
        qs = qs.order_by(('-' if order_type == 'desc' else '')+order_fields[ordering])
        context['ordering'], context['order_type'] = ordering, order_type

    context['video'] = video
    translations = list(video.subtitlelanguage_set.filter(is_original=False) \
        .filter(had_version=True).select_related('video'))
    translations.sort(key=lambda f: f.get_language_display())
    context['translations'] = translations    
    context['last_version'] = language.latest_version()
    context['widget_params'] = _widget_params(request, video, version_no=None, language=language)
    context['language'] = language
    context['edit_url'] = language.get_widget_url()
    _add_share_panel_context_for_history(context, video, lang)
    return object_list(request, queryset=qs, allow_empty=True,
                       paginate_by=settings.REVISIONS_ONPAGE, 
                       page=request.GET.get('page', 1),
                       template_name='videos/history.html',
                       template_object_name='revision',
                       extra_context=context)

def revision(request, pk):
    version = get_object_or_404(SubtitleVersion, pk=pk)
    context = widget.add_onsite_js_files({})
    context["video"] = version.video
    context["version"] = version
    context["next_version"] = version.next_version()
    context["prev_version"] = version.prev_version()
    language = version.language
    context["language"] = language
    context["widget_params"] = _widget_params(request, language.video, version.version_no, language.language)
    context["latest_version"] = language.latest_version()
    return render_to_response("videos/revision.html", context, context_instance=RequestContext(request))

def revision(request, pk):
    version = get_object_or_404(SubtitleVersion, pk=pk)
    context = widget.add_onsite_js_files({})
    context['video'] = version.video
    context['version'] = version
    context['next_version'] = version.next_version()
    context['prev_version'] = version.prev_version()
    language = version.language
    context['language'] = language
    context['widget_params'] = _widget_params(request, \
            language.video.get_video_url(), version.version_no, language.language)
    context['latest_version'] = language.latest_finished_version()
    return render_to_response('videos/revision.html', context,
                              context_instance=RequestContext(request))     

def detail(request, slug):
    team = Team.get(slug, request.user)
    
    languages = get_user_languages_from_request(request)
    languages.extend([l[:l.find('-')] for l in languages if l.find('-') > -1])
    
    langs_pairs = []
    
    for l1 in languages:
        for l0 in languages:
            if not l1 == l0:
                langs_pairs.append('%s_%s' % (l1, l0))
    
    qs = TeamVideoLanguagePair.objects.filter(language_pair__in=langs_pairs, team=team) \
        .select_related('team_video', 'team_video__video')
    lqs = TeamVideoLanguage.objects.filter(team=team).select_related('team_video', 'team_video__video')
    
    qs1 = qs.filter(percent_complete__gt=0,percent_complete__lt=100)
    qs2 = qs.filter(percent_complete=0)
    qs3 = lqs.filter(is_original=True, is_complete=False)
    qs4 = lqs.filter(is_original=False, forked=True, is_complete=True)
    
    mqs = TeamMultyQuerySet(qs1, qs2, qs3, qs4)

    extra_context = widget.add_onsite_js_files({})    
    extra_context.update({
        'team': team,
        'can_edit_video': team.can_edit_video(request.user)
    })

    if len(mqs) == 0:
        mqs = TeamMultyQuerySet(TeamVideoLanguagePair.objects.filter(team=team) \
                                .select_related('team_video', 'team_video__video'))

    general_settings = {}
    add_general_settings(request, general_settings)
    extra_context['general_settings'] = json.dumps(general_settings)

    if team.video:
        extra_context['widget_params'] = base_widget_params(request, {
            'video_url': team.video.get_video_url(), 
            'base_state': {}
        })
        
    return object_list(request, queryset=mqs, 
                       paginate_by=VIDEOS_ON_PAGE, 
                       template_name='teams/detail.html', 
                       extra_context=extra_context, 
                       template_object_name='team_video_md')

def history(request, video_id, lang=None):
    video = get_object_or_404(Video, video_id=video_id)
    video.update_view_counter()

    context = widget.add_onsite_js_files({})
    language = video.subtitle_language(lang)

    if not language:
        if lang in dict(settings.ALL_LANGUAGES):
            config = {}
            config["videoID"] = video.video_id
            config["languageCode"] = lang
            url = reverse("onsite_widget") + "?config=" + urlquote_plus(json.dumps(config))
            return redirect(url)
        else:
            raise Http404

    qs = language.subtitleversion_set.all()
    ordering, order_type = request.GET.get("o"), request.GET.get("ot")
    order_fields = {
        "date": "datetime_started",
        "user": "user__username",
        "note": "note",
        "time": "time_change",
        "text": "text_change",
    }
    if ordering in order_fields and order_type in ["asc", "desc"]:
        qs = qs.order_by(("-" if order_type == "desc" else "") + order_fields[ordering])
        context["ordering"], context["order_type"] = ordering, order_type

    context["video"] = video
    context["site"] = Site.objects.get_current()
    translations = list(video.subtitlelanguage_set.filter(is_original=False).filter(was_complete=True))
    translations.sort(key=lambda f: f.get_language_display())
    context["translations"] = translations
    context["last_version"] = language.latest_version()
    context["widget_params"] = _widget_params(request, video, None, lang or "")
    context["language"] = language
    _add_share_panel_context_for_history(context, video, lang)
    return object_list(
        request,
        queryset=qs,
        allow_empty=True,
        paginate_by=settings.REVISIONS_ONPAGE,
        page=request.GET.get("page", 1),
        template_name="videos/history.html",
        template_object_name="revision",
        extra_context=context,
    )

def video(request, video_id):
    video = get_object_or_404(Video, video_id=video_id)
    video.view_count += 1
    video.save()
    # TODO: make this more pythonic, prob using kwargs
    context = widget.add_onsite_js_files({})
    context['video'] = video
    context['site'] = Site.objects.get_current()
    context['autosub'] = 'true' if request.GET.get('autosub', False) else 'false'
    context['translations'] = video.subtitlelanguage_set.filter(was_complete=True) \
        .filter(is_original=False)
    context['widget_params'] = _widget_params(request, video.get_video_url(), None, '')
    _add_share_panel_context_for_video(context, video)
    context['lang_count'] = video.subtitlelanguage_set.filter(is_complete=True).count()
    context['original'] = video.subtitle_language()
    return render_to_response('videos/video.html', context,
                              context_instance=RequestContext(request))

def detail(request, slug, is_debugging=False, languages=None):
    team = Team.get(slug, request.user)

    if languages is None:
        languages = get_user_languages_from_request(request)
    if bool(is_debugging):
        languages = request.GET.get("langs", "").split(",")

    data = team.get_videos_for_languages(languages, CUTTOFF_DUPLICATES_NUM_VIDEOS_ON_TEAMS)
    mqs = data['videos']
    
    extra_context = widget.add_onsite_js_files({})    
    extra_context.update({
        'team': team,
        'can_edit_video': team.can_edit_video(request.user)
    })

    


    general_settings = {}
    add_general_settings(request, general_settings)
    extra_context['general_settings'] = json.dumps(general_settings)


    if team.video:
        extra_context['widget_params'] = base_widget_params(request, {
            'video_url': team.video.get_video_url(), 
            'base_state': {}
        })

    if bool(is_debugging) and request.user.is_staff:
        extra_context.update(data)
        extra_context.update({
            'languages': languages,
            })
        return render_to_response("teams/detail-debug.html", extra_context, RequestContext(request))
    
    return object_list(request, queryset=mqs, 
                       paginate_by=VIDEOS_ON_PAGE, 
                       template_name='teams/detail.html', 
                       extra_context=extra_context, 
                       template_object_name='team_video_md')

def diffing(request, first_pk, second_pk):
    first_version = get_object_or_404(SubtitleVersion, pk=first_pk)
    language = first_version.language
    second_version = get_object_or_404(SubtitleVersion, pk=second_pk, language=language)
    
    video = first_version.language.video
    if second_version.datetime_started > first_version.datetime_started:
        first_version, second_version = second_version, first_version
    
    second_captions = dict([(item.subtitle_id, item) for item in second_version.subtitles()])
    captions = []

    for caption in first_version.subtitles():
        try:
            scaption = second_captions[caption.subtitle_id]
        except KeyError:
            scaption = None
            changed = dict(text=True, time=True)
        else:
            changed = {
                'text': (not caption.subtitle_text == scaption.subtitle_text), 
                'time': (not caption.start_time == scaption.start_time),
                'end_time': (not caption.end_time == scaption.end_time)
            }
        data = [caption, scaption, changed]
        captions.append(data)
        
    context = widget.add_onsite_js_files({})
    context['video'] = video
    context['captions'] = captions
    context['language'] = language
    context['first_version'] = first_version
    context['second_version'] = second_version
    context['latest_version'] = language.latest_finished_version()
    context['widget0_params'] = \
        _widget_params(request, video.get_video_url(), 
                       first_version.version_no)
    context['widget1_params'] = \
        _widget_params(request, video.get_video_url(),
                       second_version.version_no)
    return render_to_response('videos/diffing.html', context,
                              context_instance=RequestContext(request)) 

def team_video(request, team_video_pk):
    team_video = get_object_or_404(TeamVideo, pk=team_video_pk)
    
    if not team_video.can_edit(request.user):
        raise Http404
    
    form = EditTeamVideoForm(request.POST or None, request.FILES or None, instance=team_video)

    if form.is_valid():
        form.save()
        messages.success(request, _('Video has been updated.'))
        return redirect(team_video)

    context = widget.add_onsite_js_files({})
    
    context.update({
        'team': team_video.team,
        'team_video': team_video,
        'form': form,
        'widget_params': base_widget_params(request, {'video_url': team_video.video.get_video_url(), 'base_state': {}})
    })
    return context