def send_email_reminder(request): """Send reminder email.""" statsd_waffle_incr("users.send_email_reminder", "signin_metrics") if request.method == "POST": statsd_waffle_incr("users.send_email_reminder.POST", "signin_metrics") form = EmailReminderForm(request.POST) if form.is_valid(): error = None username = form.cleaned_data["username"] try: user = User.objects.get(username=username, is_active=True) if user.email: # TODO: should this be on a model or manager instead? statsd_waffle_incr("users.send_email_reminder.SUCCESS", "signin_metrics") send_reminder_email(user) else: statsd_waffle_incr("users.send_email_reminder.NOEMAIL", "signin_metrics") error = "no_email" except User.DoesNotExist: # Don't leak existence of email addresses. statsd_waffle_incr("users.send_email_reminder.NOUSER", "signin_metrics") return jingo.render(request, "users/send_email_reminder_done.html", {"username": username, "error": error}) else: form = EmailConfirmationForm() return jingo.render(request, "users/resend_confirmation.html", {"form": form})
def register(request): """Register a new user.""" form = handle_register(request) if form.is_valid(): return jingo.render(request, 'users/register_done.html') return jingo.render(request, 'users/register.html', {'form': form})
def activity_page(request, slug, page=1): """Fetch a page of project activity. Useful for xhr.""" project = get_object_or_404(Project, slug=slug) start = int(page) * ACTIVITY_PAGE_SIZE end = start + ACTIVITY_PAGE_SIZE all_activities = Activity.objects.filter( entry__link__project=project).select_related( 'entry', 'entry__link', 'entry__link__project').order_by( '-published_on') activities = all_activities[start:end] if not activities: raise Http404 if request.is_ajax(): return jingo.render(request, 'activity/ajax/activity.html', { 'activities': activities, 'show_meta': False, }) else: has_more = len(all_activities) > end return jingo.render(request, 'projects/activity.html', { 'project': project, 'activities': activities, 'has_more': has_more, 'next_page': int(page) + 1 })
def edit(request): webapp = settings.APP_PREVIEW # Don't use request.amo_user since it has too much caching. amouser = UserProfile.objects.get(pk=request.user.id) if request.method == 'POST': # ModelForm alters the instance you pass in. We need to keep a copy # around in case we need to use it below (to email the user) original_email = amouser.email form = forms.UserEditForm(request.POST, request.FILES, request=request, instance=amouser, webapp=webapp) if form.is_valid(): messages.success(request, _('Profile Updated')) if amouser.email != original_email: # Temporarily block email changes. if settings.APP_PREVIEW: messages.error(request, 'Error', 'You cannot change your email on the ' 'developer preview site.') return jingo.render(request, 'users/edit.html', {'form': form, 'amouser': amouser}) l = {'user': amouser, 'mail1': original_email, 'mail2': amouser.email} log.info(u"User (%(user)s) has requested email change from" "(%(mail1)s) to (%(mail2)s)" % l) messages.info(request, _('Email Confirmation Sent'), _(u'An email has been sent to {0} to confirm your new ' 'email address. For the change to take effect, you ' 'need to click on the link provided in this email. ' 'Until then, you can keep logging in with your ' 'current email address.').format(amouser.email)) domain = settings.DOMAIN token, hash = EmailResetCode.create(amouser.id, amouser.email) url = "%s%s" % (settings.SITE_URL, reverse('users.emailchange', args=[amouser.id, token, hash])) t = loader.get_template('users/email/emailchange.ltxt') c = {'domain': domain, 'url': url} send_mail(_('Please confirm your email address ' 'change at %s' % domain), t.render(Context(c)), None, [amouser.email], use_blacklist=False, real_email=True) # Reset the original email back. We aren't changing their # address until they confirm the new one amouser.email = original_email form.save() return redirect('users.edit') else: messages.error(request, _('Errors Found'), _('There were errors in the changes ' 'you made. Please correct them and ' 'resubmit.')) else: form = forms.UserEditForm(instance=amouser, webapp=webapp) return jingo.render(request, 'users/edit.html', {'form': form, 'amouser': amouser, 'webapp': webapp})
def edit_answer(request, question_id, answer_id): """Edit an answer.""" answer = get_object_or_404(Answer, pk=answer_id, question=question_id) answer_preview = None if answer.question.is_locked: raise PermissionDenied # NOJS: upload images, if any upload_imageattachment(request, answer) if request.method == 'GET': form = AnswerForm({'content': answer.content}) return jingo.render(request, 'questions/edit_answer.html', {'form': form, 'answer': answer}) form = AnswerForm(request.POST) if form.is_valid(): answer.content = form.cleaned_data['content'] answer.updated_by = request.user if 'preview' in request.POST: answer.updated = datetime.now() answer_preview = answer else: log.warning('User %s is editing answer with id=%s' % (request.user, answer.id)) answer.save() return HttpResponseRedirect(answer.get_absolute_url()) return jingo.render(request, 'questions/edit_answer.html', {'form': form, 'answer': answer, 'answer_preview': answer_preview})
def add_tag(request, question_id): """Add a (case-insensitive) tag to question. If the question already has the tag, do nothing. """ # If somebody hits Return in the address bar after provoking an error from # the add form, nicely send them back to the question: if request.method == 'GET': return HttpResponseRedirect( reverse('questions.answers', args=[question_id])) try: question, canonical_name = _add_tag(request, question_id) except Tag.DoesNotExist: template_data = _answers_data(request, question_id) template_data['tag_adding_error'] = UNAPPROVED_TAG template_data['tag_adding_value'] = request.POST.get('tag-name', '') return jingo.render(request, 'questions/answers.html', template_data) if canonical_name: # success question.clear_cached_tags() return HttpResponseRedirect( reverse('questions.answers', args=[question_id])) # No tag provided template_data = _answers_data(request, question_id) template_data['tag_adding_error'] = NO_TAG return jingo.render(request, 'questions/answers.html', template_data)
def edit_thread(request, forum_slug, thread_id): """Edit a thread.""" forum = get_object_or_404(Forum, slug=forum_slug) thread = get_object_or_404(Thread, pk=thread_id, forum=forum) if thread.is_locked: raise PermissionDenied if request.method == 'GET': form = EditThreadForm(instance=thread) return jingo.render(request, 'forums/edit_thread.html', {'form': form, 'forum': forum, 'thread': thread}) form = EditThreadForm(request.POST) if form.is_valid(): log.warning('User %s is editing thread with id=%s' % (request.user, thread.id)) thread.title = form.cleaned_data['title'] thread.save() url = reverse('forums.posts', args=[forum_slug, thread_id]) return HttpResponseRedirect(url) return jingo.render(request, 'forums/edit_thread.html', {'form': form, 'forum': forum, 'thread': thread})
def edit_post(request, forum_slug, thread_id, post_id): """Edit a post.""" forum = get_object_or_404(Forum, slug=forum_slug) thread = get_object_or_404(Thread, pk=thread_id, forum=forum) post = get_object_or_404(Post, pk=post_id, thread=thread) if thread.is_locked: raise PermissionDenied if request.method == 'GET': form = EditPostForm({'content': post.content}) return jingo.render(request, 'forums/edit_post.html', {'form': form, 'forum': forum, 'thread': thread, 'post': post}) form = EditPostForm(request.POST) post_preview = None if form.is_valid(): post.content = form.cleaned_data['content'] post.updated_by = request.user if 'preview' in request.POST: post.updated = datetime.now() post_preview = post else: log.warning('User %s is editing post with id=%s' % (request.user, post.id)) post.save() return HttpResponseRedirect(post.get_absolute_url()) return jingo.render(request, 'forums/edit_post.html', {'form': form, 'forum': forum, 'thread': thread, 'post': post, 'post_preview': post_preview})
def edit_thread(request, document_slug, thread_id): """Edit a thread.""" doc = get_document(document_slug, request) thread = get_object_or_404(Thread, pk=thread_id, document=doc) perm = request.user.has_perm('kbforums.change_thread') if not (perm or (thread.creator == request.user and not thread.is_locked)): raise PermissionDenied if request.method == 'GET': form = EditThreadForm(instance=thread) return jingo.render(request, 'kbforums/edit_thread.html', {'form': form, 'document': doc, 'thread': thread}) form = EditThreadForm(request.POST) if form.is_valid(): log.warning('User %s is editing KB thread with id=%s' % (request.user, thread.id)) thread.title = form.cleaned_data['title'] thread.save() url = reverse('wiki.discuss.posts', args=[document_slug, thread_id]) return HttpResponseRedirect(url) return jingo.render(request, 'kbforums/edit_thread.html', {'form': form, 'document': doc, 'thread': thread})
def edit_post(request, document_slug, thread_id, post_id): """Edit a post.""" doc = get_document(document_slug, request) thread = get_object_or_404(Thread, pk=thread_id, document=doc) post = get_object_or_404(Post, pk=post_id, thread=thread) perm = request.user.has_perm('kbforums.change_post') if not (perm or (request.user == post.creator and not thread.is_locked)): raise PermissionDenied if request.method == 'GET': form = EditPostForm({'content': post.content}) return jingo.render(request, 'kbforums/edit_post.html', {'form': form, 'document': doc, 'thread': thread, 'post': post}) form = EditPostForm(request.POST) post_preview = None if form.is_valid(): post.content = form.cleaned_data['content'] post.updated_by = request.user if 'preview' in request.POST: post.updated = datetime.now() post_preview = post else: log.warning('User %s is editing KB post with id=%s' % (request.user, post.id)) post.save() return HttpResponseRedirect(post.get_absolute_url()) return jingo.render(request, 'kbforums/edit_post.html', {'form': form, 'document': doc, 'thread': thread, 'post': post, 'post_preview': post_preview})
def dashboard(request, page=0): """Display first page of activities for a users dashboard.""" start = int(page) * ACTIVITY_PAGE_SIZE end = start + ACTIVITY_PAGE_SIZE profile = request.user.get_profile() all_activities = Activity.objects.filter( entry__link__project__in=profile.projects_following.all() ).select_related('entry', 'entry__link', 'entry__link__project').order_by( '-published_on' ) activities = all_activities[start:end] if request.is_ajax(): if not all_activities: raise Http404 return jingo.render(request, 'activity/ajax/activity.html', { 'activities': activities, 'show_meta': True }) return jingo.render(request, 'users/dashboard.html', { 'profile': profile, 'activities': activities, 'has_more': len(all_activities) > end, 'next_page': int(page) + 1, 'total': len(all_activities) })
def new_thread(request, document_slug): """Start a new thread.""" doc = get_document(document_slug, request) if request.method == 'GET': form = NewThreadForm() return jingo.render(request, 'kbforums/new_thread.html', {'form': form, 'document': doc}) form = NewThreadForm(request.POST) post_preview = None if form.is_valid(): if 'preview' in request.POST: thread = Thread(creator=request.user, title=form.cleaned_data['title']) post_preview = Post(thread=thread, creator=request.user, content=form.cleaned_data['content']) else: thread = doc.thread_set.create(creator=request.user, title=form.cleaned_data['title']) thread.save() post = thread.new_post(creator=request.user, content=form.cleaned_data['content']) post.save() # Send notifications to forum watchers. NewThreadEvent(post).fire(exclude=post.creator) return HttpResponseRedirect( reverse('wiki.discuss.posts', args=[document_slug, thread.id])) return jingo.render(request, 'kbforums/new_thread.html', {'form': form, 'document': doc, 'post_preview': post_preview})
def new_document(request): """Create a new wiki document.""" if request.method == 'GET': doc_form = DocumentForm( can_create_tags=request.user.has_perm('taggit.add_tag')) rev_form = RevisionForm() return jingo.render(request, 'wiki/new_document.html', {'document_form': doc_form, 'revision_form': rev_form}) post_data = request.POST.copy() post_data.update({'locale': request.locale}) doc_form = DocumentForm(post_data, can_create_tags=request.user.has_perm('taggit.add_tag')) rev_form = RevisionForm(post_data) if doc_form.is_valid() and rev_form.is_valid(): doc = doc_form.save(None) _save_rev_and_notify(rev_form, request.user, doc) return HttpResponseRedirect(reverse('wiki.document_revisions', args=[doc.slug])) return jingo.render(request, 'wiki/new_document.html', {'document_form': doc_form, 'revision_form': rev_form})
def edit_image(request, image_id): g = get_object_or_404(Image, pk=image_id) if request.user != g.creator: return http.HttpResponseForbidden() if request.method == 'GET': gal_form = ImageForm(instance=g) gal_form.fields['gallery'].queryset = Gallery.objects.filter(creator=request.user) return jingo.render(request, 'portfolio/edit_image.html', {'gallery_form': gal_form, 'id': g.id, 'imgpath': g.file.file}) gal_form = ImageForm(request.POST, instance=g) gal_form.fields['gallery'].queryset = Gallery.objects.filter(creator=request.user) if gal_form.is_valid(): gal = gal_form.save() return http.HttpResponseRedirect(reverse('portfolio.viewentry', args=[gal.id])) return jingo.render(request, 'portfolio/edit_image.html', {'gallery_form': gal_form, 'id': g.id, 'imgpath': g.file.file})
def render(request, template, context={}, **kwargs): """ Same as jingo's render() shortcut, but with l10n template support. If used like this:: return l10n_utils.render(request, 'myapp/mytemplate.html') ... this helper will render the following template:: l10n/LANG/myapp/mytemplate.html if present, otherwise, it'll render the specified (en-US) template. """ # Look for localized template if not default lang. if request.locale != settings.LANGUAGE_CODE: localized_tmpl = '%s/templates/%s' % (request.locale, template) try: return jingo.render(request, localized_tmpl, context, **kwargs) except TemplateNotFound: # If not found, just go on and try rendering the parent template. pass # Every template gets its own .lang file, so figure out what it is # and pass it in the context path = get_lang_path(template) (base, ext) = os.path.splitext(path) context['langfile'] = base return jingo.render(request, template, context, **kwargs)
def pay_start(request, signed_req, pay_req): cfg = pay_req['_config'] pr = None has_preapproval = False if request.amo_user: pr = request.amo_user.get_preapproval() has_preapproval = request.amo_user.has_preapproval_key() tier, price, currency = _get_price(pay_req, preapproval=pr) webapp = cfg.addon InappPayLog.log(request, 'PAY_START', config=cfg) tasks.fetch_product_image.delay(cfg.pk, _serializable_req(pay_req)) data = dict(price=price, product=webapp, currency=currency, item=pay_req['request']['name'], img=cfg.image_url(pay_req['request'].get('imageURL')), description=pay_req['request']['description'], signed_request=signed_req) if not request.user.is_authenticated(): return jingo.render(request, 'inapp_pay/login.html', data) if not has_preapproval: return jingo.render(request, 'inapp_pay/nowallet.html', data) return jingo.render(request, 'inapp_pay/pay_start.html', data)
def edit(request): webapp = settings.APP_PREVIEW # Don't use request.amo_user since it has too much caching. amouser = UserProfile.objects.get(pk=request.user.id) if request.method == "POST": # ModelForm alters the instance you pass in. We need to keep a copy # around in case we need to use it below (to email the user) original_email = amouser.email form = forms.UserEditForm(request.POST, request.FILES, request=request, instance=amouser, webapp=webapp) if form.is_valid(): messages.success(request, _("Profile Updated")) if amouser.email != original_email: # Temporarily block email changes. if settings.APP_PREVIEW: messages.error(request, "Error", "You cannot change your email on the " "developer preview site.") return jingo.render(request, "users/edit.html", {"form": form, "amouser": amouser}) l = {"user": amouser, "mail1": original_email, "mail2": amouser.email} log.info(u"User (%(user)s) has requested email change from" "(%(mail1)s) to (%(mail2)s)" % l) messages.info( request, _("Email Confirmation Sent"), _( u"An email has been sent to {0} to confirm your new " "email address. For the change to take effect, you " "need to click on the link provided in this email. " "Until then, you can keep logging in with your " "current email address." ).format(amouser.email), ) domain = settings.DOMAIN token, hash = EmailResetCode.create(amouser.id, amouser.email) url = "%s%s" % (settings.SITE_URL, reverse("users.emailchange", args=[amouser.id, token, hash])) t = loader.get_template("users/email/emailchange.ltxt") c = {"domain": domain, "url": url} send_mail( _("Please confirm your email address " "change at %s" % domain), t.render(Context(c)), None, [amouser.email], use_blacklist=False, real_email=True, ) # Reset the original email back. We aren't changing their # address until they confirm the new one amouser.email = original_email form.save() return redirect("users.edit") else: messages.error( request, _("Errors Found"), _("There were errors in the changes " "you made. Please correct them and " "resubmit."), ) else: form = forms.UserEditForm(instance=amouser, webapp=webapp) return jingo.render(request, "users/edit.html", {"form": form, "amouser": amouser, "webapp": webapp})
def send_email_reminder(request): """Send reminder email.""" statsd_waffle_incr('users.send_email_reminder', 'signin_metrics') if request.method == 'POST': statsd_waffle_incr('users.send_email_reminder.POST', 'signin_metrics') form = EmailReminderForm(request.POST) if form.is_valid(): error = None username = form.cleaned_data['username'] try: user = User.objects.get(username=username, is_active=True) if user.email: # TODO: should this be on a model or manager instead? statsd_waffle_incr('users.send_email_reminder.SUCCESS', 'signin_metrics') send_reminder_email(user) else: statsd_waffle_incr('users.send_email_reminder.NOEMAIL', 'signin_metrics') error = 'no_email' except User.DoesNotExist: # Don't leak existence of email addresses. statsd_waffle_incr('users.send_email_reminder.NOUSER', 'signin_metrics') return jingo.render(request, 'users/send_email_reminder_done.html', {'username': username, 'error': error}) else: form = EmailConfirmationForm() return jingo.render(request, 'users/resend_confirmation.html', {'form': form})
def update(request): form = UpdateForm(request.GET) if form.is_valid(): data = form.cleaned_data version, file = data['id'].get_current_version_for_client( data['version'], form.version_int, data['appID'], data['appOS']) if version and file: app = amo.APP_IDS[data['appID'].id] application_version = version.compatible_apps[app] addon_type = amo.ADDON_SLUGS_UPDATE[data['id'].type] url = file.get_mirror(data['id']) return jingo.render(request, 'addons/update.rdf', { 'addon': data['id'], 'application': data['appID'], 'application_version': application_version, 'appversion': data['appVersion'], 'file': file, 'type': addon_type, 'url': url, 'version': version, }, content_type="text/xml") return jingo.render(request, 'addons/update.rdf', {}, content_type="text/xml")
def edit_post(request, document_slug, thread_id, post_id): """Edit a post.""" doc = get_document(document_slug, request) thread = get_object_or_404(Thread, pk=thread_id, document=doc) post = get_object_or_404(Post, pk=post_id, thread=thread) perm = request.user.has_perm("kbforums.change_post") if not (perm or (request.user == post.creator and not thread.is_locked)): raise PermissionDenied if request.method == "GET": form = EditPostForm({"content": post.content}) return jingo.render( request, "kbforums/edit_post.html", {"form": form, "document": doc, "thread": thread, "post": post} ) form = EditPostForm(request.POST) post_preview = None if form.is_valid(): post.content = form.cleaned_data["content"] post.updated_by = request.user if "preview" in request.POST: post.updated = datetime.now() post_preview = post else: log.warning("User %s is editing KB post with id=%s" % (request.user, post.id)) post.save() return HttpResponseRedirect(post.get_absolute_url()) return jingo.render( request, "kbforums/edit_post.html", {"form": form, "document": doc, "thread": thread, "post": post, "post_preview": post_preview}, )
def new_document(request): """Create a new wiki document.""" if request.method == 'GET': doc_form = DocumentForm( can_create_tags=request.user.has_perm('taggit.add_tag')) rev_form = RevisionForm(initial={'review_tags': [t[0] for t in REVIEW_FLAG_TAGS]}) return jingo.render(request, 'wiki/new_document.html', {'document_form': doc_form, 'revision_form': rev_form}) post_data = request.POST.copy() post_data.update({'locale': request.locale}) doc_form = DocumentForm(post_data, can_create_tags=request.user.has_perm('taggit.add_tag')) rev_form = RevisionForm(post_data) if doc_form.is_valid() and rev_form.is_valid(): doc = doc_form.save(None) _save_rev_and_notify(rev_form, request.user, doc) if doc.current_revision.is_approved: view = 'wiki.document' else: view = 'wiki.document_revisions' return HttpResponseRedirect(reverse(view, args=[doc.slug])) return jingo.render(request, 'wiki/new_document.html', {'document_form': doc_form, 'revision_form': rev_form})
def new_thread(request, forum_slug): """Start a new thread.""" forum = get_object_or_404(Forum, slug=forum_slug) user = request.user if not forum.allows_posting_by(user): if forum.allows_viewing_by(user): raise PermissionDenied else: raise Http404 if request.method == "GET": form = NewThreadForm() return jingo.render(request, "forums/new_thread.html", {"form": form, "forum": forum}) form = NewThreadForm(request.POST) post_preview = None if form.is_valid(): if "preview" in request.POST: thread = Thread(creator=request.user, title=form.cleaned_data["title"]) post_preview = Post(thread=thread, author=request.user, content=form.cleaned_data["content"]) else: thread = forum.thread_set.create(creator=request.user, title=form.cleaned_data["title"]) thread.save() post = thread.new_post(author=request.user, content=form.cleaned_data["content"]) post.save() # Send notifications to forum watchers. build_thread_notification.delay(post) return HttpResponseRedirect(reverse("forums.posts", args=[forum_slug, thread.id])) return jingo.render(request, "forums/new_thread.html", {"form": form, "forum": forum, "post_preview": post_preview})
def _collections(request): """Handle the request for collections.""" form = SecondarySearchForm(request.GET) form.is_valid() query = form.cleaned_data.get("q", "") search_opts = {} search_opts["limit"] = form.cleaned_data.get("pp", DEFAULT_NUM_RESULTS) page = form.cleaned_data.get("page") or 1 search_opts["offset"] = (page - 1) * search_opts["limit"] search_opts["sort"] = form.cleaned_data.get("sortby") try: results = CollectionsClient().query(query, **search_opts) except SearchError: return jingo.render(request, "search/down.html", {}, status=503) pager = amo.utils.paginate(request, results, search_opts["limit"]) c = dict( pager=pager, form=form, query=query, opts=search_opts, filter=bandwagon.views.get_filter(request), search_placeholder="collections", ) return jingo.render(request, "search/collections.html", c)
def pay_status(request, config_pk, status): tpl_path = 'inapp_pay/' with transaction.commit_on_success(): cfg = get_object_or_404(InappConfig, pk=config_pk) uuid_ = None try: uuid_ = str(request.GET['uuid']) cnt = Contribution.objects.get(uuid=uuid_) except (KeyError, UnicodeEncodeError, ValueError, Contribution.DoesNotExist): log.error('PayPal returned invalid uuid %r from in-app payment' % uuid_, exc_info=True) return jingo.render(request, 'inapp_pay/error.html') payment = InappPayment.objects.get(config=cfg, contribution=cnt) if status == 'complete': cnt.update(type=amo.CONTRIB_INAPP) tpl = tpl_path + 'complete.html' action = 'PAY_COMPLETE' elif status == 'cancel': tpl = tpl_path + 'payment_cancel.html' action = 'PAY_CANCEL' else: raise ValueError('Unexpected status: %r' % status) _payment_done(request, payment, action=action) return jingo.render(request, tpl, {'product': cnt.addon})
def new_document(request): """Create a new wiki document.""" if request.method == 'GET': doc_form = DocumentForm() rev_form = RevisionForm() return jingo.render(request, 'wiki/new_document.html', {'document_form': doc_form, 'revision_form': rev_form}) doc_form = DocumentForm(request.POST) rev_form = RevisionForm(request.POST) if doc_form.is_valid() and rev_form.is_valid(): doc = doc_form.save() doc.firefox_versions = doc_form.cleaned_data['firefox_versions'] doc.operating_systems = doc_form.cleaned_data['operating_systems'] rev = rev_form.save(commit=False) rev.document = doc rev.creator = request.user rev.save() return HttpResponseRedirect(reverse('wiki.document_revisions', args=[doc.id])) return jingo.render(request, 'wiki/new_document.html', {'document_form': doc_form, 'revision_form': rev_form})
def edit_post(request, forum_slug, thread_id, post_id): """Edit a post.""" forum = get_object_or_404(Forum, slug=forum_slug) thread = get_object_or_404(Thread, pk=thread_id, forum=forum) post = get_object_or_404(Post, pk=post_id, thread=thread) if thread.is_locked: raise PermissionDenied if request.method == "GET": form = EditPostForm({"content": post.content}) return jingo.render( request, "forums/edit_post.html", {"form": form, "forum": forum, "thread": thread, "post": post} ) form = EditPostForm(request.POST) post_preview = None if form.is_valid(): post.content = form.cleaned_data["content"] post.updated_by = request.user if "preview" in request.POST: post.updated = datetime.now() post_preview = post else: log.warning("User %s is editing post with id=%s" % (request.user, post.id)) post.save() return HttpResponseRedirect(post.get_absolute_url()) return jingo.render( request, "forums/edit_post.html", {"form": form, "forum": forum, "thread": thread, "post": post, "post_preview": post_preview}, )
def login_user(request): """Verify user login and password work.""" msg = [] if request.method == 'POST': form = LoginForm(request.POST) if form.is_valid(): username = request.POST['username'] password = request.POST['password'] user = authenticate(username=username, password=password) if user is not None: if user.is_active: login(request, user) return HttpResponseRedirect(reverse('users.user_page', args=[request.user.username])) else: msg.append("You have entered a disabled account") return jingo.render(request, 'users/login.html', {'errors': msg, 'form': form}) else: msg.append("Invalid form") return jingo.render(request, 'users/login.html', {'errors': msg, 'form': form}) else: form = LoginForm() return jingo.render(request, 'users/login.html', {'errors': msg, 'form': form})
def new_thread(request, document_slug): """Start a new thread.""" doc = get_document(document_slug, request) if request.method == "GET": form = NewThreadForm() return jingo.render(request, "kbforums/new_thread.html", {"form": form, "document": doc}) form = NewThreadForm(request.POST) post_preview = None if form.is_valid(): if "preview" in request.POST: thread = Thread(creator=request.user, title=form.cleaned_data["title"]) post_preview = Post(thread=thread, creator=request.user, content=form.cleaned_data["content"]) else: thread = doc.thread_set.create(creator=request.user, title=form.cleaned_data["title"]) thread.save() statsd.incr("kbforums.thread") post = thread.new_post(creator=request.user, content=form.cleaned_data["content"]) post.save() # Send notifications to forum watchers. NewThreadEvent(post).fire(exclude=post.creator) # Add notification automatically if needed. if Setting.get_for_user(request.user, "kbforums_watch_new_thread"): NewPostEvent.notify(request.user, thread) return HttpResponseRedirect(reverse("wiki.discuss.posts", args=[document_slug, thread.id])) return jingo.render( request, "kbforums/new_thread.html", {"form": form, "document": doc, "post_preview": post_preview} )
def resend_confirmation(request): """Resend confirmation email.""" if request.method == 'POST': form = EmailConfirmationForm(request.POST) if form.is_valid(): email = form.cleaned_data['email'] try: reg_prof = RegistrationProfile.objects.get( user__email=email, user__is_active=False) form = try_send_email_with_form( RegistrationProfile.objects.send_confirmation_email, form, 'email', reg_prof) except RegistrationProfile.DoesNotExist: # Don't leak existence of email addresses. pass # Form may now be invalid if email failed to send. if form.is_valid(): return jingo.render(request, 'users/resend_confirmation_done.html', {'email': email}) else: form = EmailConfirmationForm() return jingo.render(request, 'users/resend_confirmation.html', {'form': form})
def edit_settings(request): """Edit user settings""" if request.method == 'POST': form = SettingsForm(request.POST) if form.is_valid(): form.save_for_user(request.user) messages.add_message(request, messages.INFO, _(u'Your settings have been saved.')) return HttpResponseRedirect(reverse('users.edit_settings')) # Invalid form return jingo.render(request, 'users/edit_settings.html', {'form': form}) # Pass the current user's settings as the initial values. values = request.user.settings.values() initial = dict() for v in values: try: # Uses ast.literal_eval to convert 'False' => False etc. # TODO: Make more resilient. initial[v['name']] = literal_eval(v['value']) except (SyntaxError, ValueError): # Attempted to convert the string value to a Python value # but failed so leave it a string. initial[v['name']] = v['value'] form = SettingsForm(initial=initial) return jingo.render(request, 'users/edit_settings.html', {'form': form})
def action_unavailable_response(request, message=None, template_name="action_unavailable.html"): """Generic page for unavailable actions""" context = {'message': message} return jingo.render(request, template_name, context, status=403)
def app_fail(request, template_name='500.html'): return jingo.render(request, template_name, {}, status=500)
def home(request): tx_form = TransactionSearchForm() return jingo.render(request, 'lookup/home.html', {'tx_form': tx_form})
def payments(request, addon_id, addon, webapp=False): premium_form = forms_payments.PremiumForm( request.POST or None, request=request, addon=addon, user=request.amo_user) region_form = forms.RegionForm( request.POST or None, product=addon) upsell_form = forms_payments.UpsellForm( request.POST or None, addon=addon, user=request.amo_user) bango_account_list_form = forms_payments.BangoAccountListForm( request.POST or None, addon=addon, user=request.amo_user) if request.method == 'POST': success = all(form.is_valid() for form in [premium_form, region_form, upsell_form, bango_account_list_form]) if success: region_form.save() try: premium_form.save() except client.Error as err: success = False log.error('Error setting payment information (%s)' % err) messages.error( request, _(u'We encountered a problem connecting to the ' u'payment server.')) raise # We want to see these exceptions! is_now_paid = addon.premium_type in amo.ADDON_PREMIUMS # If we haven't changed to a free app, check the upsell. if is_now_paid and success: try: upsell_form.save() bango_account_list_form.save() except client.Error as err: log.error('Error saving payment information (%s)' % err) messages.error( request, _(u'We encountered a problem connecting to ' u'the payment server.')) success = False raise # We want to see all the solitude errors now. # Test again in case a call to Solitude failed. if is_now_paid and success: # Update the product's price if we need to. try: apa = AddonPaymentAccount.objects.get(addon=addon) apa.update_price(addon.addonpremium.price.price) except AddonPaymentAccount.DoesNotExist: pass except client.Error: log.error('Error updating AddonPaymentAccount (%s) price' % apa.pk) messages.error( request, _(u'We encountered a problem while updating ' u'the payment server.')) success = False raise # We want to see all the solitude errors now. # If everything happened successfully, give the user a pat on the back. if success: messages.success(request, _('Changes successfully saved.')) return redirect(addon.get_dev_url('payments')) # TODO: This needs to be updated as more platforms support payments. cannot_be_paid = ( addon.premium_type == amo.ADDON_FREE and any(premium_form.device_data['free-%s' % x] == y for x, y in [('android-mobile', True), ('android-tablet', True), ('desktop', True), ('firefoxos', False)])) return jingo.render( request, 'developers/payments/premium.html', {'addon': addon, 'webapp': webapp, 'premium': addon.premium, 'form': premium_form, 'upsell_form': upsell_form, 'region_form': region_form, 'DEVICE_LOOKUP': DEVICE_LOOKUP, 'is_paid': addon.premium_type in amo.ADDON_PREMIUMS, 'no_paid': cannot_be_paid, 'is_incomplete': addon.status == amo.STATUS_NULL, 'is_packaged': addon.is_packaged, # Bango values 'bango_account_form': forms_payments.BangoPaymentAccountForm(), 'bango_account_list_form': bango_account_list_form, # Waffles 'payments_enabled': waffle.flag_is_active(request, 'allow-b2g-paid-submission') and not waffle.switch_is_active('disabled-payments')})
def payment_accounts_form(request): bango_account_form = forms_payments.BangoAccountListForm( user=request.amo_user, addon=None) return jingo.render( request, 'developers/payments/includes/bango_accounts_form.html', {'bango_account_list_form': bango_account_form})
def post_preview_async(request, document_slug): """Ajax preview of posts.""" statsd.incr('forums.preview') post = Post(creator=request.user, content=request.POST.get('content', '')) return jingo.render(request, 'kbforums/includes/post_preview.html', {'post_preview': post})
def _error_page(request, status): """Render error pages with jinja2.""" return jingo.render(request, '%d.html' % status, status=status)
from django.conf.urls.defaults import url, patterns, include from django.conf import settings from django.contrib import admin from django.shortcuts import redirect import jingo from django_arecibo.tasks import post as arecibo_post def _error_page(request, status): """Render error pages with jinja2.""" return jingo.render(request, '%d.html' % status, status=status) handler404 = lambda r: _error_page(r, 404) handler_csrf = lambda r, reason: jingo.render(r, 'csrf_error.html') def handler500(request): arecibo = getattr(settings, 'ARECIBO_SERVER_URL', '') if arecibo: arecibo_post(request, 500) return _error_page(request, 500) admin.autodiscover() def unchannel(request):
def select_locale(request, document_slug): """Select a locale to translate the document to.""" doc = get_object_or_404(Document, locale=settings.WIKI_DEFAULT_LANGUAGE, slug=document_slug) return jingo.render(request, 'wiki/select_locale.html', {'document': doc})
def transaction_refund(request, tx_uuid): contrib = get_object_or_404(Contribution, uuid=tx_uuid, type=amo.CONTRIB_PURCHASE) refund_contribs = contrib.get_refund_contribs() refund_contrib = refund_contribs[0] if refund_contribs.exists() else None if refund_contrib: messages.error(request, _('A refund has already been processed.')) return redirect(reverse('lookup.transaction_summary', args=[tx_uuid])) form = TransactionRefundForm(request.POST) if not form.is_valid(): return jingo.render( request, 'lookup/transaction_summary.html', dict({ 'uuid': tx_uuid, 'tx_refund_form': form, 'tx_form': TransactionSearchForm() }.items() + _transaction_summary(tx_uuid).items())) data = {'uuid': contrib.transaction_id} if settings.BANGO_FAKE_REFUNDS: data['fake_response_status'] = { 'responseCode': form.cleaned_data['fake'] } try: res = client.api.bango.refund.post(data) except (HttpClientError, HttpServerError): # Either doing something not supposed to or Solitude had an issue. log.exception('Refund error: %s' % tx_uuid) messages.error( request, _('You cannot make a refund request for this transaction.')) return redirect(reverse('lookup.transaction_summary', args=[tx_uuid])) if res['status'] in [PENDING, COMPLETED]: # Create refund Contribution by cloning the payment Contribution. refund_contrib = Contribution.objects.get(id=contrib.id) refund_contrib.id = None refund_contrib.save() refund_contrib.update( type=amo.CONTRIB_REFUND, related=contrib, uuid=hashlib.md5(str(uuid.uuid4())).hexdigest(), amount=-refund_contrib.amount if refund_contrib.amount else None, transaction_id=client.get(res['transaction'])['uuid']) if res['status'] == PENDING: # Create pending Refund. refund_contrib.enqueue_refund( amo.REFUND_PENDING, request.amo_user, refund_reason=form.cleaned_data['refund_reason']) log.info('Refund pending: %s' % tx_uuid) email_buyer_refund_pending(contrib) messages.success(request, _('Refund for this transaction now pending.')) elif res['status'] == COMPLETED: # Create approved Refund. refund_contrib.enqueue_refund( amo.REFUND_APPROVED, request.amo_user, refund_reason=form.cleaned_data['refund_reason']) log.info('Refund approved: %s' % tx_uuid) email_buyer_refund_approved(contrib) messages.success( request, _('Refund for this transaction successfully approved.')) elif res['status'] == FAILED: # Bango no like. log.error('Refund failed: %s' % tx_uuid) messages.error(request, _('Refund request for this transaction failed.')) return redirect(reverse('lookup.transaction_summary', args=[tx_uuid]))
def logout(request, template_name='cas/logout.html'): url = request.GET.get('url', None) auth_logout(request) return jingo.render(request, template_name, {'return_url': url})
def _login(request, template_name='cas/login.html', success_redirect=settings.LOGIN_REDIRECT_URL): """ Standard CAS login form. Instead of running this directly, we enforce a service whitelist first. See whitelist_login(). """ service = request.GET.get('service', None) # renew=true indicates that we should force the user to log in. if False == request.GET.get('renew', False) and request.user.is_authenticated(): if service is not None: ticket = utils.create_service_ticket(request.user, service) # TODO Parsing and rebuilding the URL here is a much better idea. if service.find('?') == -1: return HttpResponseRedirect(service + '?ticket=' + ticket.ticket) else: return HttpResponseRedirect(service + '&ticket=' + ticket.ticket) else: return HttpResponseRedirect(success_redirect) # gateway=true indicates that we should silently try to authenticate (no # login screen). if request.GET.get('gateway', False): return HttpResponseRedirect(service) errors = [] if request.method == 'POST': username = request.POST.get('username', None) password = request.POST.get('password', None) service = request.POST.get('service', None) lt = request.POST.get('lt', None) try: login_ticket = LoginTicket.objects.get(ticket=lt) except: errors.append('Login ticket expired. Please try again.') else: login_ticket.delete() user = authenticate(username=username, password=password) if user is not None: if user.is_active: auth_login(request, user) if service is not None: ticket = utils.create_service_ticket(user, service) return HttpResponseRedirect(service + '?ticket=' + ticket.ticket) else: return HttpResponseRedirect(success_redirect) else: errors.append('This account is disabled.') else: errors.append('Incorrect username and/or password.') form = LoginForm(service) return jingo.render(request, template_name, { 'form': form, 'errors': errors })
def handler403(request): if request.path_info.startswith('/api/'): # Pass over to handler403 view in api if api was targeted. return api.views.handler403(request) else: return jingo.render(request, 'amo/403.html', status=403)
def request_token_ready(request, token): error = request.GET.get('error', '') ctx = {'error': error, 'token': token} return jingo.render(request, 'piston/request_token_ready.html', ctx)
def reissue(request, addon): reissue = not addon.is_premium() if addon.is_premium() and addon.has_purchased(request.amo_user): reissue = True return jingo.render(request, 'receipts/reissue.html', {'reissue': reissue, 'app': addon})
def csrf_failure(request, reason=''): return jingo.render(request, 'amo/403.html', {'because_csrf': 'CSRF' in reason}, status=403)
def apps_reviewing(request): return jingo.render(request, 'reviewers/apps_reviewing.html', context(request, **{ 'apps': AppsReviewing(request).get_apps(), 'tab': 'reviewing'}))
def index(request): log = ActivityLog.objects.admin_events()[:5] return jingo.render(request, 'zadmin/index.html', {'log': log})
def _review(request, addon, version): if (not settings.ALLOW_SELF_REVIEWS and not acl.action_allowed(request, 'Admin', '%') and addon.has_author(request.amo_user)): messages.warning(request, _('Self-reviews are not allowed.')) return redirect(reverse('reviewers.home')) if (addon.status == amo.STATUS_BLOCKED and not acl.action_allowed(request, 'Apps', 'ReviewEscalated')): messages.warning( request, _('Only senior reviewers can review blocklisted apps.')) return redirect(reverse('reviewers.home')) attachment_formset = forms.AttachmentFormSet(data=request.POST or None, files=request.FILES or None, prefix='attachment') form = forms.get_review_form(data=request.POST or None, files=request.FILES or None, request=request, addon=addon, version=version, attachment_formset=attachment_formset) postdata = request.POST if request.method == 'POST' else None all_forms = [form, attachment_formset] if waffle.switch_is_active('buchets') and version: features_list = [unicode(f) for f in version.features.to_list()] appfeatures_form = AppFeaturesForm(data=postdata, instance=version.features) all_forms.append(appfeatures_form) else: appfeatures_form = None features_list = None queue_type = form.helper.review_type redirect_url = reverse('reviewers.apps.queue_%s' % queue_type) is_admin = acl.action_allowed(request, 'Addons', 'Edit') if request.method == 'POST' and all(f.is_valid() for f in all_forms): old_types = set(o.id for o in addon.device_types) new_types = set(form.cleaned_data.get('device_override')) if waffle.switch_is_active('buchets'): old_features = set(features_list) new_features = set(unicode(f) for f in appfeatures_form.instance.to_list()) if form.cleaned_data.get('action') == 'public': if old_types != new_types: # The reviewer overrode the device types. We need to not # publish this app immediately. if addon.make_public == amo.PUBLIC_IMMEDIATELY: addon.update(make_public=amo.PUBLIC_WAIT) # And update the device types to what the reviewer set. AddonDeviceType.objects.filter(addon=addon).delete() for device in form.cleaned_data.get('device_override'): addon.addondevicetype_set.create(device_type=device) # Log that the reviewer changed the device types. added_devices = new_types - old_types removed_devices = old_types - new_types msg = _(u'Device(s) changed by ' 'reviewer: {0}').format(', '.join( [_(u'Added {0}').format(unicode(amo.DEVICE_TYPES[d].name)) for d in added_devices] + [_(u'Removed {0}').format( unicode(amo.DEVICE_TYPES[d].name)) for d in removed_devices])) amo.log(amo.LOG.REVIEW_DEVICE_OVERRIDE, addon, addon.current_version, details={'comments': msg}) if (waffle.switch_is_active('buchets') and old_features != new_features): # The reviewer overrode the requirements. We need to not # publish this app immediately. if addon.make_public == amo.PUBLIC_IMMEDIATELY: addon.update(make_public=amo.PUBLIC_WAIT) appfeatures_form.save(mark_for_rereview=False) # Log that the reviewer changed the minimum requirements. added_features = new_features - old_features removed_features = old_features - new_features fmt = ', '.join( [_(u'Added {0}').format(f) for f in added_features] + [_(u'Removed {0}').format(f) for f in removed_features]) # L10n: {0} is the list of requirements changes. msg = _(u'Requirements changed by reviewer: {0}').format(fmt) amo.log(amo.LOG.REVIEW_FEATURES_OVERRIDE, addon, addon.current_version, details={'comments': msg}) form.helper.process() if form.cleaned_data.get('notify'): EditorSubscription.objects.get_or_create(user=request.amo_user, addon=addon) messages.success(request, _('Review successfully processed.')) return redirect(redirect_url) canned = AppCannedResponse.objects.all() actions = form.helper.actions.items() try: if not version: raise Version.DoesNotExist show_diff = (addon.versions.exclude(id=version.id) .filter(files__isnull=False, created__lt=version.created, files__status=amo.STATUS_PUBLIC) .latest()) except Version.DoesNotExist: show_diff = None # The actions we should show a minimal form from. actions_minimal = [k for (k, a) in actions if not a.get('minimal')] # We only allow the user to check/uncheck files for "pending" allow_unchecking_files = form.helper.review_type == "pending" versions = (Version.with_deleted.filter(addon=addon) .order_by('-created') .transform(Version.transformer_activity) .transform(Version.transformer)) product_attrs = { 'product': json.dumps( product_as_dict(request, addon, False, 'reviewer'), cls=JSONEncoder), 'manifest_url': addon.manifest_url, } pager = paginate(request, versions, 10) num_pages = pager.paginator.num_pages count = pager.paginator.count ctx = context(request, version=version, product=addon, pager=pager, num_pages=num_pages, count=count, flags=Review.objects.filter(addon=addon, flag=True), form=form, canned=canned, is_admin=is_admin, status_types=amo.STATUS_CHOICES, show_diff=show_diff, allow_unchecking_files=allow_unchecking_files, actions=actions, actions_minimal=actions_minimal, tab=queue_type, product_attrs=product_attrs, attachment_formset=attachment_formset, appfeatures_form=appfeatures_form, default_visibility=DEFAULT_ACTION_VISIBILITY) if features_list is not None: ctx['feature_list'] = features_list return jingo.render(request, 'reviewers/review.html', ctx)
def leaderboard(request): return jingo.render(request, 'reviewers/leaderboard.html', context(request, **{'scores': ReviewerScore.all_users_by_score()}))
def handler500(request): if request.path_info.startswith('/api/'): return api.views.handler500(request) else: return jingo.render(request, 'site/500.html', status=500)
def robots(request): """Generate a robots.txt""" template = jingo.render(request, 'site/robots.txt') return HttpResponse(template, mimetype="text/plain")
def document(request, document_slug, template=None): """View a wiki document.""" fallback_reason = None # If a slug isn't available in the requested locale, fall back to en-US: try: doc = Document.objects.get(locale=request.locale, slug=document_slug) if (not doc.current_revision and doc.parent and doc.parent.current_revision): # This is a translation but its current_revision is None # and OK to fall back to parent (parent is approved). fallback_reason = 'translation_not_approved' elif not doc.current_revision: # No current_revision, no parent with current revision, so # nothing to show. fallback_reason = 'no_content' except Document.DoesNotExist: # Look in default language: doc = get_object_or_404(Document, locale=settings.WIKI_DEFAULT_LANGUAGE, slug=document_slug) # If there's a translation to the requested locale, take it: translation = doc.translated_to(request.locale) if translation: url = translation.get_absolute_url() url = urlparams(url, query_dict=request.GET) return HttpResponseRedirect(url) elif doc.current_revision: # There is no translation # and OK to fall back to parent (parent is approved). fallback_reason = 'no_translation' # Obey explicit redirect pages: # Don't redirect on redirect=no (like Wikipedia), so we can link from a # redirected-to-page back to a "Redirected from..." link, so you can edit # the redirect. redirect_url = (None if request.GET.get('redirect') == 'no' else doc.redirect_url()) if redirect_url: url = urlparams(redirect_url, query_dict=request.GET, redirectslug=doc.slug, redirectlocale=doc.locale) return HttpResponseRedirect(url) # Get "redirected from" doc if we were redirected: redirect_slug = request.GET.get('redirectslug') redirect_locale = request.GET.get('redirectlocale') redirected_from = None if redirect_slug and redirect_locale: try: redirected_from = Document.objects.get(locale=redirect_locale, slug=redirect_slug) except Document.DoesNotExist: pass related = doc.related_documents.order_by('-related_to__in_common')[0:5] # Get the contributors. (To avoid this query, we could render the # the contributors right into the Document's html field.) contributors = set([ r.creator for r in doc.revisions.filter( is_approved=True).select_related('creator') ]) data = { 'document': doc, 'redirected_from': redirected_from, 'related': related, 'contributors': contributors, 'fallback_reason': fallback_reason, 'is_aoa_referral': request.GET.get('ref') == 'aoa' } data.update(SHOWFOR_DATA) return jingo.render(request, template, data)
def handler404(request): if request.path_info.startswith('/api/'): # Pass over to API handler404 view if API was targeted. return api.views.handler404(request) else: return jingo.render(request, 'site/404.html', status=404)
def about(request, project, slug, template_name='ignite/about.html'): if waffle.switch_is_active('announce_winners'): template_name = 'ignite/about-winners.html' return jingo.render(request, template_name)
def translate(request, document_slug, revision_id=None): """Create a new translation of a wiki document. * document_slug is for the default locale * translation is to the request locale """ # TODO: Refactor this view into two views? (new, edit) # That might help reduce the headache-inducing branchiness. parent_doc = get_object_or_404(Document, locale=settings.WIKI_DEFAULT_LANGUAGE, slug=document_slug) user = request.user if settings.WIKI_DEFAULT_LANGUAGE == request.locale: # Don't translate to the default language. return HttpResponseRedirect( reverse('wiki.edit_document', locale=settings.WIKI_DEFAULT_LANGUAGE, args=[parent_doc.slug])) if not parent_doc.is_localizable: message = _lazy(u'You cannot translate this document.') return jingo.render(request, 'handlers/400.html', {'message': message}, status=400) based_on_rev = get_current_or_latest_revision(parent_doc, reviewed_only=False) disclose_description = bool(request.GET.get('opendescription')) try: doc = parent_doc.translations.get(locale=request.locale) except Document.DoesNotExist: doc = None disclose_description = True user_has_doc_perm = ((not doc) or (doc and doc.allows_editing_by(user))) user_has_rev_perm = ((not doc) or (doc and doc.allows_revision_by(user))) if not user_has_doc_perm and not user_has_rev_perm: # User has no perms, bye. raise PermissionDenied doc_form = rev_form = None if user_has_doc_perm: doc_initial = _document_form_initial(doc) if doc else None doc_form = DocumentForm( initial=doc_initial, can_create_tags=user.has_perm('taggit.add_tag')) if user_has_rev_perm: initial = {'based_on': based_on_rev.id, 'comment': ''} if revision_id: r = Revision.objects.get(pk=revision_id) initial.update(content=r.content, summary=r.summary, keywords=r.keywords) elif not doc: initial.update(content=based_on_rev.content, summary=based_on_rev.summary, keywords=based_on_rev.keywords) instance = doc and get_current_or_latest_revision(doc) rev_form = RevisionForm(instance=instance, initial=initial) if request.method == 'POST': which_form = request.POST.get('form', 'both') doc_form_invalid = False if user_has_doc_perm and which_form in ['doc', 'both']: disclose_description = True post_data = request.POST.copy() post_data.update({'locale': request.locale}) doc_form = DocumentForm( post_data, instance=doc, can_create_tags=user.has_perm('taggit.add_tag')) doc_form.instance.locale = request.locale doc_form.instance.parent = parent_doc if which_form == 'both': rev_form = RevisionForm(request.POST) # If we are submitting the whole form, we need to check that # the Revision is valid before saving the Document. if doc_form.is_valid() and (which_form == 'doc' or rev_form.is_valid()): doc = doc_form.save(parent_doc) # Possibly schedule a rebuild. _maybe_schedule_rebuild(doc_form) if which_form == 'doc': url = urlparams(reverse('wiki.edit_document', args=[doc.slug]), opendescription=1) return HttpResponseRedirect(url) doc_slug = doc_form.cleaned_data['slug'] else: doc_form_invalid = True else: doc_slug = doc.slug if doc and user_has_rev_perm and which_form in ['rev', 'both']: rev_form = RevisionForm(request.POST) rev_form.instance.document = doc # for rev_form.clean() if rev_form.is_valid() and not doc_form_invalid: _save_rev_and_notify(rev_form, request.user, doc) url = reverse('wiki.document_revisions', args=[doc_slug]) return HttpResponseRedirect(url) return jingo.render( request, 'wiki/translate.html', { 'parent': parent_doc, 'document': doc, 'document_form': doc_form, 'revision_form': rev_form, 'locale': request.locale, 'based_on': based_on_rev, 'disclose_description': disclose_description })
def addon_detail(request, addon): reviews = Review.objects.latest().filter(addon=addon) src = request.GET.get('src', 'discovery-details') return jingo.render(request, 'discovery/addons/detail.html', {'addon': addon, 'reviews': reviews, 'get_replies': Review.get_replies, 'src': src})
def fail(request, template_name='404.html'): return jingo.render(request, template_name, {}, status=404)
def terms_development(request, project, slug, template_name='static/terms_conditions_development.html'): return jingo.render(request, template_name, {})
def edit_document(request, document_slug, revision_id=None): """Create a new revision of a wiki document, or edit document metadata.""" doc = get_object_or_404(Document, locale=request.locale, slug=document_slug) user = request.user # If this document has a parent, then the edit is handled by the # translate view. Pass it on. if doc.parent: return translate(request, doc.parent.slug, revision_id) if revision_id: rev = get_object_or_404(Revision, pk=revision_id, document=doc) else: rev = doc.current_revision or doc.revisions.order_by( '-created', '-id')[0] disclose_description = bool(request.GET.get('opendescription')) doc_form = rev_form = None if doc.allows_revision_by(user): rev_form = RevisionForm(instance=rev, initial={ 'based_on': rev.id, 'comment': '' }) if doc.allows_editing_by(user): doc_form = DocumentForm( initial=_document_form_initial(doc), can_create_tags=user.has_perm('taggit.add_tag')) if request.method == 'GET': if not (rev_form or doc_form): # You can't do anything on this page, so get lost. raise PermissionDenied else: # POST # Comparing against localized names for the Save button bothers me, so # I embedded a hidden input: which_form = request.POST.get('form') if which_form == 'doc': if doc.allows_editing_by(user): post_data = request.POST.copy() post_data.update({'locale': request.locale}) doc_form = DocumentForm( post_data, instance=doc, can_create_tags=user.has_perm('taggit.add_tag')) if doc_form.is_valid(): # Get the possibly new slug for the imminent redirection: doc = doc_form.save(None) # Do we need to rebuild the KB? _maybe_schedule_rebuild(doc_form) return HttpResponseRedirect( urlparams(reverse('wiki.edit_document', args=[doc.slug]), opendescription=1)) disclose_description = True else: raise PermissionDenied elif which_form == 'rev': if doc.allows_revision_by(user): rev_form = RevisionForm(request.POST) rev_form.instance.document = doc # for rev_form.clean() if rev_form.is_valid(): _save_rev_and_notify(rev_form, user, doc) return HttpResponseRedirect( reverse('wiki.document_revisions', args=[document_slug])) else: raise PermissionDenied return jingo.render( request, 'wiki/edit_document.html', { 'revision_form': rev_form, 'document_form': doc_form, 'disclose_description': disclose_description, 'document': doc })