def blog_homepage(request):
"""
Display the homepage
"""
current_site = get_current_site(request).domain
# if current_site == "gracebreedlove.com":
# page = get_object_or_404(Page, slug="grace-breedlove-photography")
# content = mark_safe(page.richtextpage.content)
# context = { 'page' : page, 'content' : content }
# return render(request, "photo_index.html", context)
if current_site == "solarpoweredyogi.com":
settings.use_editable()
blog_posts = BlogPost.objects.published(for_user=request.user)
slider_posts = blog_posts[:4]
section_posts = blog_posts[0:15]
context = { "slider_posts" : slider_posts, "section_posts": section_posts }
return render(request, "index.html", context)
settings.use_editable()
blog_posts = BlogPost.objects.published(for_user=request.user)
slider_posts = blog_posts[:4]
section_posts = blog_posts[0:15]
context = { "slider_posts" : slider_posts, "section_posts": section_posts }
return render(request, "index.html", context)
def profile(request, username, template="accounts/account_profile.html"):
"""
Display a profile.
"""
lookup = {"username__iexact": username, "is_active": True}
context = {"profile_user": get_object_or_404(User, **lookup)}
return render(request, template, context)
def wiki_page_edit(request, slug, template="mezawiki/wiki_page_edit.html"):
"""
Displays the form for editing and deleting a page.
Custom templates are checked for using the name
``mezawiki/wiki_page_edit_XXX.html``
where ``XXX`` is the wiki pages's slug.
"""
try:
wiki_pages = WikiPage.objects.published(for_user=request.user)
wiki_page = wiki_pages.get(slug=slug)
initial = {}
except WikiPage.DoesNotExist:
wiki_page = WikiPage(slug=slug)
wiki_page.is_initial = True
initial = {"content": _("Describe your new page %s here..." % slug)}
#'message': _('Initial revision')}
if request.method == "POST":
form = WikiPageForm(request.POST, instance=wiki_page)
if form.is_valid():
page = form.save(commit=False)
page.user = request.user
page.title = slug
page.save()
return HttpResponseRedirect(reverse("wiki_page_detail", args=[slug]))
else:
form = WikiPageForm(initial=initial, instance=wiki_page)
context = {"wiki_page": wiki_page, "form": form}
templates = [u"mezawiki/wiki_page_edit_%s.html" % unicode(slug), template]
return render(request, templates, context)
def bookmarks(request, slug=None, username=None):
bookmarks = Bookmark.objects.all().order_by("-publish_date")
keyword = None
user = None
if slug:
try:
keyword = Keyword.objects.get(slug=slug)
except Keyword.DoesNotExist:
raise Http404
bookmarks = bookmarks.filter(keywords__keyword_id=keyword.pk)
if username:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Http404
bookmarks = bookmarks.filter(user__username=username)
bookmarks = paginate(
bookmarks,
request.GET.get("page", 1),
15,
settings.MAX_PAGING_LINKS,
)
return render(request, ["bookmarks/bookmarks.html"], {
"bookmarks": bookmarks,
"tag": keyword,
"username": user,
})
def wiki_page_detail(request, slug, year=None, month=None,
template="mezawiki/wiki_page_detail.html"):
"""
Displays a wiki page.
Redirects to the edit view if the page doesn't exist.
Custom templates are checked for using the name
``mezawiki/wiki_page_detail_XXX.html``
where ``XXX`` is the wiki pages's slug.
"""
slug_original = slug
slug = urlize_title(slug)
if slug != slug_original:
return HttpResponseRedirect(
reverse('wiki_page_detail', args=[slug])
)
try:
wiki_page_exist = WikiPage.objects.get(slug=slug)
if wiki_page_exist.status == 1 and not wiki_page_exist.can_edit_wikipage(request.user):
return HttpResponseForbidden(
_("You don't have permission to view this wiki page."))
wiki_pages = WikiPage.objects.published(for_user=request.user)
wiki_page = wiki_pages.get(slug=slug)
except WikiPage.DoesNotExist:
if can_add_wikipage(request.user):
return HttpResponseRedirect(reverse('wiki_page_edit', args=[slug]))
else:
return HttpResponseForbidden(
_("You don't have permission to add new wiki page."))
context = {"wiki_page": wiki_page}
templates = [u"mezawiki/wiki_page_detail_%s.html" % unicode(slug), template]
return render(request, templates, context)
def displayable_links_js(request, template_name="admin/displayable_links.js"):
"""
Renders a list of url/title pairs for all ``Displayable`` subclass
instances into JavaScript that's used to populate a list of links
in TinyMCE.
"""
links = []
if "mezzanine.pages" in settings.INSTALLED_APPS:
from mezzanine.pages.models import Page
is_page = lambda obj: isinstance(obj, Page)
else:
is_page = lambda obj: False
# For each item's title, we use its model's verbose_name, but in the
# case of Page subclasses, we just use "Page", and then sort the items
# by whether they're a Page subclass or not, then by their URL.
for url, obj in Displayable.objects.url_map(for_user=request.user).items():
title = getattr(obj, "titles", obj.title)
real = hasattr(obj, "id")
page = is_page(obj)
if real:
verbose_name = _("Page") if page else obj._meta.verbose_name
title = "%s: %s" % (verbose_name, title)
links.append((not page and real, url, title))
context = {"links": [link[1:] for link in sorted(links)]}
content_type = "text/javascript"
return render(request, template_name, context, content_type=content_type)
def add(request):
if request.method == "POST":
bookmark_form = BookmarkForm(request.user, request.POST)
if bookmark_form.is_valid():
bookmark_instance = bookmark_form.save()
if bookmark_form.should_redirect():
return HttpResponseRedirect(bookmark.page.url)
else:
return HttpResponseRedirect(reverse("all_bookmarks"))
else:
initial = {}
if "url" in request.GET:
initial["url"] = request.GET["url"]
if "title" in request.GET:
initial["title"] = request.GET["title"]
if "redirect" in request.GET:
initial["redirect"] = request.GET["redirect"]
if initial:
bookmark_form = BookmarkForm(initial=initial)
else:
bookmark_form = BookmarkForm()
bookmarks_add_url = "http://" + Site.objects.get_current().domain + reverse("add_bookmark")
bookmarklet = "javascript:location.href='%s?url='+encodeURIComponent(location.href)+';title='+encodeURIComponent(document.title)+';redirect=on'" % bookmarks_add_url
return render(request, ["bookmarks/add.html"], {
"bookmarklet": bookmarklet,
"bookmark_form": bookmark_form,
})
def account(request, template="account.html"):
"""
Display and handle both the login and signup forms.
"""
login_form = LoginForm(request)
signup_form = SignupForm(request)
if request.method == "POST":
posted_form = None
message = ""
if request.POST.get("login") is not None:
login_form = LoginForm(request, request.POST)
if login_form.is_valid():
posted_form = login_form
message = _("Successfully logged in")
else:
signup_form = SignupForm(request, request.POST)
if signup_form.is_valid():
new_user = signup_form.save()
if not new_user.is_active:
send_verification_mail(request, new_user)
info(request, _("A verification email has been sent with " "a link for activating your account."))
else:
posted_form = signup_form
message = _("Successfully signed up")
if posted_form is not None:
posted_form.login(request)
info(request, message)
return redirect(request.GET.get("next", "/"))
context = {"login_form": login_form, "signup_form": signup_form}
return render(request, template, context)
def invoice(request, order_id, template="shop/order_invoice.html"):
"""
Display a plain text invoice for the given order. The order must
belong to the user which is checked via session or ID if
authenticated, or if the current user is staff.
"""
lookup = {"id": order_id}
if not request.user.is_authenticated():
lookup["key"] = request.session.session_key
elif not request.user.is_staff:
lookup["user_id"] = request.user.id
order = get_object_or_404(Order, **lookup)
context = {"order": order}
context.update(order.details_as_dict())
context = RequestContext(request, context)
if request.GET.get("format") == "pdf":
response = HttpResponse(mimetype="application/pdf")
name = slugify("%s-invoice-%s" % (settings.SITE_TITLE, order.id))
response["Content-Disposition"] = "attachment; filename=%s.pdf" % name
html = get_template(template).render(context)
import ho.pisa
ho.pisa.CreatePDF(html, response)
return response
return render(request, template, context)
def page(request, slug, template="pages/page.html", extra_context=None):
"""
Select a template for a page and render it. The ``extra_context``
arg will include a ``page`` object that's added via
``mezzanine.pages.middleware.PageMiddleware``. The page is loaded
via the middleware so that other apps with urlpatterns that match
the current page can include a page in their template context.
The urlpattern that maps to this view is a catch-all pattern, in
which case the page instance will be None, so raise a 404 then.
"""
page_middleware = "mezzanine.pages.middleware.PageMiddleware"
if page_middleware not in settings.MIDDLEWARE_CLASSES:
raise ImproperlyConfigured(page_middleware + " is missing from " +
"settings.MIDDLEWARE_CLASSES")
extra_context = extra_context or {}
try:
page = extra_context["page"]
except KeyError:
raise Http404
# Check for a template name matching the page's slug. If the homepage
# is configured as a page instance, the template "pages/index.html" is
# used, since the slug "/" won't match a template name.
template_name = unicode(slug) if slug != "/" else "index"
templates = [u"pages/%s.html" % template_name]
# Check for a template matching the page's content model.
if page.content_model is not None:
templates.append(u"pages/%s.html" % page.content_model)
templates.append(template)
return render(request, templates, extra_context)
def article_list(request, public=None):
api_endpoint = '/api/articles/?'
if public:
api_endpoint += "public=%s&" % public
return render(request, ['article_list.html'],
{'api_endpoint': api_endpoint})
def account(request, template="account.html"):
"""
Display and handle both the login and signup forms.
"""
login_form = LoginForm()
signup_form = SignupForm()
if request.method == "POST":
posted_form = None
message = ""
if request.POST.get("login") is not None:
login_form = LoginForm(request.POST)
if login_form.is_valid():
posted_form = login_form
message = _("Successfully logged in")
else:
signup_form = SignupForm(request.POST)
if signup_form.is_valid():
signup_form.save()
posted_form = signup_form
message = _("Successfully signed up")
if posted_form is not None:
posted_form.login(request)
info(request, message)
return redirect(request.GET.get("next", "/"))
context = {"login_form": login_form, "signup_form": signup_form}
return render(request, template, context)
def profile_update(request, template="accounts/account_profile_update.html"):
"""
Profile update form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None, request.FILES or None,
instance=request.user)
if request.method == "POST" and form.is_valid():
user = form.save()
info(request, _("Profile updated"))
try:
customer = request.user.get_profile()
customer_address = customer.address + ', ' + customer.zip_code
loc = location_utils.getLocation(customer_address)
correct_address = location_utils.getAddress(loc[0],loc[1])
customer.location = loc
customer.address = correct_address
customer.save()
request.session['location'] = (loc[0],loc[1])
request.session['age'] = True
request.session['address'] = correct_address
request.session['map'] = True
avail_store_ids, avail_store_names, avail_liquor_types, loc, store_locs = new_location_get_ids(request, loc)
return redirect("profile", username=user.username)
except NoReverseMatch:
return redirect("profile_update")
context = {"form": form, "title": _("Update Profile")}
return render(request, template, context)
def login(request, template="accounts/account_login.html"):
"""
Login form.
"""
isAjax = False
form = LoginForm(request.POST or None)
next = get_login_redirect_url(request)
if request.method == "POST" and form.is_valid():
authenticated_user = form.save()
#info(request, _("Successfully logged in"))
auth_login(request, authenticated_user)
if request.is_ajax():
if request.user.is_authenticated():
return HttpResponse(simplejson.dumps(dict(url=next,
success=True)))
else:
return HttpResponse(simplejson.dumps(dict(success=False)))
else:
return login_redirect(request)
elif form.errors:
return HttpResponse(simplejson.dumps(dict(errors=form.errors, success=False)))
if request.is_ajax():
template = "accounts/ajax_account_login.html"
context = {"form": form, "title": _("Log in"), "next":next}
return render(request, template, context)
def comment(request, template="generic/comments.html"):
"""
Handle a ``ThreadedCommentForm`` submission and redirect back to its
related object.
"""
try:
model = get_model(*request.POST["content_type"].split(".", 1))
obj = model.objects.get(id=request.POST["object_pk"])
if request.method != "POST":
raise ObjectDoesNotExist()
except (KeyError, TypeError, AttributeError, ObjectDoesNotExist):
# Something was missing from the post so abort.
return HttpResponseRedirect("/")
form = ThreadedCommentForm(request, obj, request.POST or None)
if form.is_valid():
comment = form.get_comment_object()
if request.user.is_authenticated():
comment.user = request.user
comment.by_author = request.user == getattr(obj, "user", None)
comment.ip_address = request.META.get("HTTP_X_FORWARDED_FOR", request.META["REMOTE_ADDR"])
comment.replied_to_id = request.POST.get("replied_to")
comment.save()
response = HttpResponseRedirect(comment.get_absolute_url())
# Store commenter's details in a cookie for 90 days.
cookie_expires = 60 * 60 * 24 * 90
for field in ThreadedCommentForm.cookie_fields:
cookie_name = ThreadedCommentForm.cookie_prefix + field
cookie_value = request.POST.get(field, "")
set_cookie(response, cookie_name, cookie_value, cookie_expires)
return response
else:
# Show errors with stand-alone comment form.
context = {"obj": obj, "posted_comment_form": form}
return render(request, template, context)
def login(request, template="accounts/account_login.html"):
"""
Login form.
"""
form = LoginForm(request.POST or None)
if request.method == "POST" and form.is_valid():
authenticated_user = form.save()
info(request, _("Successfully logged in"))
auth_login(request, authenticated_user)
customer = request.user.get_profile()
request.session['location'] = customer.location
request.session['address'] = customer.address
request.session['age'] = True
loc = ast.literal_eval(request.session['location'])
avail_store_ids, avail_store_names, avail_liquor_types, loc, store_locs = new_location_get_ids(request, loc)
# return login_redirect(request)
if 'cart loaded' in request.session:
return redirect('/shop/cart/')
else:
return redirect('/shop/')
context = {"form": form, "title": _("Log in")}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html",
extra_context=None):
"""
Signup form.
"""
#Staat in admin_forms
form = NewUserCreationForm(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(request, _("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Sign up")}
context.update(extra_context or {})
return render(request, template, context)
def frontpage(request):
# @TODO: Use weight and featured fields, which need to be implemented.
articles = Article.objects.filter(public=True).order_by('-updated_at')[:5]
articles = paginate(articles, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
return render(request, ['frontpage.html'], {'articles': articles})
def cart(request, template="shop/cart.html"):
"""
Display cart and handle removing items from the cart.
"""
cart_formset = CartItemFormSet(instance=request.cart)
discount_form = DiscountForm(request, request.POST or None)
if request.method == "POST":
valid = True
if request.POST.get("update_cart"):
valid = request.cart.has_items()
if not valid:
# Session timed out.
info(request, _("Your cart has expired"))
else:
cart_formset = CartItemFormSet(request.POST,
instance=request.cart)
valid = cart_formset.is_valid()
if valid:
cart_formset.save()
recalculate_discount(request)
info(request, _("Cart updated"))
else:
valid = discount_form.is_valid()
if valid:
discount_form.set_discount()
if valid:
return redirect("shop_cart")
context = {"cart_formset": cart_formset}
settings.use_editable()
if (settings.SHOP_DISCOUNT_FIELD_IN_CART and
DiscountCode.objects.active().count() > 0):
context["discount_form"] = discount_form
return render(request, template, context)
def comment(request, template="generic/comments.html"):
"""
Handle a ``ThreadedCommentForm`` submission and redirect back to its
related object.
"""
response = initial_validation(request, "comment")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
form = ThreadedCommentForm(request, obj, post_data)
if form.is_valid():
url = obj.get_absolute_url()
if is_spam(request, form, url):
return redirect(url)
comment = form.save(request)
response = redirect(add_cache_bypass(comment.get_absolute_url()))
# Store commenter's details in a cookie for 90 days.
for field in ThreadedCommentForm.cookie_fields:
cookie_name = ThreadedCommentForm.cookie_prefix + field
cookie_value = post_data.get(field, "")
set_cookie(response, cookie_name, cookie_value)
return response
elif request.is_ajax() and form.errors:
return HttpResponse(dumps({"errors": form.errors}))
# Show errors with stand-alone comment form.
context = {"obj": obj, "posted_comment_form": form}
response = render(request, template, context)
return response
def user_bike_list(request, template="pages/bikeListMain.html"):
u = User.objects.get(username=request.user.username)
if u.bikes.count() == 0:
messages.info(request, _("Your bikes list is empty"))
return HttpResponseRedirect("/bikelist/addbike/")
context = {"bicycles": u.bikes.all(), "user_name": request.user.username}
return render(request, template, context)
def wiki_page_revert(request, slug, revision_pk):
slug_original = slug
slug = urlize_title(slug)
if slug != slug_original:
return HttpResponseRedirect(
reverse('wiki_page_revert', args=[slug, revision_pk])
)
try:
wiki_pages = WikiPage.objects.published(for_user=request.user)
wiki_page = wiki_pages.get(slug=slug)
except WikiPage.DoesNotExist:
return HttpResponseRedirect(reverse('wiki_page_edit', args=[slug]))
src_revision = get_object_or_404(WikiPageRevision, page=wiki_page, pk=revision_pk)
new_revision = WikiPageRevision(page=wiki_page,
user=request.user if request.user.is_authenticated() else User.objects.get(id=-1))
if request.method == 'POST':
form = WikiPageForm(data=request.POST or None, instance=wiki_page)
if form.is_valid():
form.save()
new_revision.content = form.cleaned_data["content"]
new_revision.description = form.cleaned_data["summary"]
new_revision.save()
return HttpResponseRedirect(reverse('wiki_page_detail', kwargs={'slug': slug}))
else:
if src_revision.user:
description = _("Reverted to revision of %(time)s by %(user)s.") % \
{'time': src_revision.created, 'user': src_revision.user.username}
else:
description = _("Reverted to anonymous revision of %(time)s.") % \
{'time': src_revision.created}
form = WikiPageForm(data=request.POST or None, instance=wiki_page,
initial={'content': src_revision.content, 'summary': description})
return render(request, 'mezawiki/wiki_page_edit.html',
{'wiki_page': wiki_page, 'form': form, 'src_revision': src_revision})
def link_dump_tag_list(request, keyword_slug,
template="linkdump/tag_list.html"):
"""Display a list of links for a specific Keyword."""
keyword = get_object_or_404(Keyword, slug=keyword_slug)
dumps = Dump.objects.filter(tags_string__contains=keyword.title).order_by(
'-views')
return render(request, template, {'keyword': keyword, 'dumps': dumps})
def wiki_page_diff(request, slug,
template="mezawiki/wiki_page_diff.html"):
slug_original = slug
slug = urlize_title(slug)
if slug != slug_original:
return HttpResponseRedirect(
reverse('wiki_page_diff', args=[slug])
)
try:
wiki_pages = WikiPage.objects.published(for_user=request.user)
wiki_page = wiki_pages.get(slug=slug)
except WikiPage.DoesNotExist:
return HttpResponseRedirect(reverse('wiki_page_edit', args=[slug]))
try:
from_rev = wiki_page.wikipagerevision_set.get(pk=request.REQUEST['from_revision_pk'])
to_rev = wiki_page.wikipagerevision_set.get(pk=request.REQUEST['to_revision_pk'])
except (KeyError, WikiPage.DoesNotExist):
return HttpResponseNotFound()
dmp = diff_match_patch()
diff = dmp.diff_compute(from_rev.content, to_rev.content, True, 2)
undo_error = False
if 'undo' in request.REQUEST and request.REQUEST['undo'] == 'error':
undo_error = True
return render(request, 'mezawiki/wiki_page_diff.html',
{'wiki_page': wiki_page, 'from_revision': from_rev, 'to_revision': to_rev, 'diff': diff, 'undo_error': undo_error})
def comment(request, template="generic/comments.html"):
"""
Handle a ``ReviewForm`` submission and redirect back to its
related object.
"""
response = initial_validation(request, "comment")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
form = ReviewForm(request, obj, request.POST )
if form.is_valid():
url = obj.get_absolute_url()
if is_spam(request, form, url):
return redirect(url)
comment = form.save(request)
response = redirect(add_cache_bypass(comment.get_absolute_url()))
# Store commenter's details in a cookie for 90 days.
for field in ReviewForm.cookie_fields:
cookie_name = ReviewForm.cookie_prefix + field
cookie_value = post_data.get(field, "")
set_cookie(response, cookie_name, cookie_value)
"""
Send activity feed to those who follow this vendor page.
"""
if request.user.is_authenticated():
action.send(obj, verb=settings.GOT_REVIEW_VERB, target=comment )
return response
elif request.is_ajax() and form.errors:
return HttpResponse(dumps({"errors": form.errors}))
# Show errors with stand-alone comment form.
context = {"obj": obj, "posted_comment_form": form}
response = render(request, template, context)
return response
def wiki_page_revision(request, slug, rev_id,
template="mezawiki/wiki_page_revision.html"):
"""
Displays a wiki page revision.
Redirects to the edit view if the page doesn't exist.
Custom templates are checked for using the name
``mezawiki/wiki_page_detail_XXX.html``
where ``XXX`` is the wiki pages's slug.
"""
slug_original = slug
slug = urlize_title(slug)
if slug != slug_original:
return HttpResponseRedirect(
reverse('wiki_page_revision', args=[slug])
)
try:
wiki_pages = WikiPage.objects.published(for_user=request.user)
wiki_page = wiki_pages.get(slug=slug)
revision = WikiPageRevision.objects.get(id=rev_id)
except WikiPage.DoesNotExist:
return HttpResponseRedirect(reverse('wiki_page_edit', args=[slug]))
if not wiki_page.can_view_wikipage(request.user):
return HttpResponseForbidden(
_("You don't have permission to view this wiki page revision."))
context = {"wiki_page": wiki_page, "revision": revision}
templates = [u"mezawiki/wiki_page_detail_%s.html" % unicode(slug), template]
return render(request, templates, context)
def retail_signup(request, template="accounts/retail_signup.html"):
form = ProfileForm(request.POST or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
# Add to campaign monitor
if bool(form.cleaned_data.get("optin")):
cm_api = CampaignMonitorApi(settings.CM_API_KEY, settings.CM_CLIENT_ID)
listid = settings.CM_RETAIL_LIST_ID
custom_fields = {}
#try:
cm_api.subscriber_add(
listid,
form.cleaned_data.get("email"),
form.cleaned_data.get("first_name") + ' ' + form.cleaned_data.get("last_name"),
custom_fields=custom_fields)
#except:
# pass
if not new_user.is_active:
send_verification_mail(request, new_user, "signup_verify")
info(request, "A verification email has been sent with a link for activating your account.")
else:
info(request, "Successfully signed up")
auth_login(request, new_user)
return my_login_redirect(request)
context = {"form": form, "title": "Customer Registration"}
return render(request, template, context)
def page(request, slug, template="pages/page.html", extra_context=None):
"""
Display content for a page. First check for any matching page processors
and handle them. Secondly, build the list of template names to choose
from given the slug and type of page being viewed.
"""
page = get_object_or_404(Page.objects.published(request.user), slug=slug)
if page.login_required and not request.user.is_authenticated():
path = urlquote(request.get_full_path())
url = "%s?%s=%s" % (settings.LOGIN_URL, REDIRECT_FIELD_NAME, path)
return redirect(url)
context = {"page": page}
if extra_context is not None:
context.update(extra_context)
model_processors = page_processors.processors[page.content_model]
slug_processors = page_processors.processors["slug:%s" % page.slug]
for processor in model_processors + slug_processors:
response = processor(request, page)
if isinstance(response, HttpResponse):
return response
elif response:
try:
context.update(response)
except (TypeError, ValueError):
name = "%s.%s" % (processor.__module__, processor.__name__)
error = ("The page processor %s returned %s but must return "
"HttpResponse or dict." % (name, type(response)))
raise ValueError(error)
templates = [u"pages/%s.html" % slug]
if page.content_model is not None:
templates.append(u"pages/%s.html" % page.content_model)
templates.append(template)
return render(request, templates, context)
def contact(request, template_name = 'index.html'):
if request.method == 'POST':
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
post_data = contact_form.cleaned_data
nom = post_data.get('nom','')
tel = post_data.get('tel','')
from_email = post_data.get('email')
body = post_data.get('message')
recipient_list = list(settings.RECIPIENT_LIST)
subject = 'HorizonPlus : Vous avez recu un email de %s' % from_email
message = body
message += '<br />------------------------------------'
message += '<br />%s (%s)' % (nom, tel)
send_mail(subject, message, from_email, recipient_list)
message = '<strong>votre message a bien ete envoye. Nous vous repondrons dans les plus brefs delais.</strong>'
info(request, message, extra_tags='success')
else:
contact_form = ContactForm()
context = {
'contact_form' : contact_form,
}
return render(request, template_name, context)
def cart_item_view(request, template="shop/product.html", form_class=AddProductForm, extra_content=None, cart_id="", item_id=""):
cart = Cart.objects.filter(id=cart_id).first()
item = next(item for item in cart.items.iterator() if item.id == int(item_id))
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products, slug=item.url.split('/')[-1])
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([dict([(f, getattr(v, f))
for f in fields + ["sku", "image_id"]]) for v in variations])
variation = ProductVariation.objects.filter(sku=item.sku).first()
v_json = dict([(f, getattr(variation, f))
for f in fields + ["sku", "image_id"] if getattr(variation, f) is not None])
initial_data = dict(quantity=item.quantity, **v_json)
initial_data['embroidery_type'] = item.personalization.embroidery_type
initial_data['value'] = item.personalization.value
add_product_form = form_class(request.POST or None, product=product,
initial=initial_data, to_cart=False)
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"add_product_form": add_product_form,
"item": item
}
return render(request, template, context)
def event_detail(request,
slug,
year=None,
month=None,
day=None,
template="agenda/event_detail.html"):
""". Custom templates are checked for using the name
``agenda/event_detail_XXX.html`` where ``XXX`` is the agenda
events's slug.
"""
events = Event.objects.published(for_user=request.user).select_related()
event = get_object_or_404(events, slug=slug)
context = {
"event": event,
}
templates = [u"agenda/event_detail_%s.html" % str(slug), template]
return render(request, templates, context)
def wiki_page_revert(request, slug, revision_pk):
slug_original = slug
slug = urlize_title(slug)
if slug != slug_original:
return HttpResponseRedirect(
reverse('wiki_page_revert', args=[slug, revision_pk]))
try:
wiki_pages = WikiPage.objects.published(for_user=request.user)
wiki_page = wiki_pages.get(slug=slug)
except WikiPage.DoesNotExist:
return HttpResponseRedirect(reverse('wiki_page_edit', args=[slug]))
src_revision = get_object_or_404(WikiPageRevision,
page=wiki_page,
pk=revision_pk)
new_revision = WikiPageRevision(
page=wiki_page,
user=request.user
if request.user.is_authenticated() else User.objects.get(id=-1))
if request.method == 'POST':
form = WikiPageForm(data=request.POST or None, instance=wiki_page)
if form.is_valid():
form.save()
new_revision.content = form.cleaned_data["content"]
new_revision.description = form.cleaned_data["summary"]
new_revision.save()
return HttpResponseRedirect(
reverse('wiki_page_detail', kwargs={'slug': slug}))
else:
if src_revision.user:
description = _("Reverted to revision of %(time)s by %(user)s.") % \
{'time': src_revision.created, 'user': src_revision.user.username}
else:
description = _("Reverted to anonymous revision of %(time)s.") % \
{'time': src_revision.created}
form = WikiPageForm(data=request.POST or None,
instance=wiki_page,
initial={
'content': src_revision.content,
'summary': description
})
return render(request, 'mezawiki/wiki_page_edit.html', {
'wiki_page': wiki_page,
'form': form,
'src_revision': src_revision
})
def personalization(request,
template="personalization.html",
form_class=PersonalizationForm,
extra_context=None):
model = Personalization
initial_data = {'type': None, 'personal_value': None}
personalize_product = form_class(request.POST or None,
initial=initial_data)
context = {
'editable_obj': model,
'personalize_product': personalize_product
}
if 'POST' == request.method:
if personalize_product.is_valid():
model = personalize_product.save()
return JsonResponse({'personalization_id': model.id})
response = render(request, template, {})
return response
def order_history(request, template="shop/order_history.html"):
"""
Display a list of the currently logged-in user's past orders.
"""
all_orders = Order.objects.filter(user_id=request.user.id)
orders = paginate(all_orders.order_by('-time'),
request.GET.get("page", 1),
settings.SHOP_PER_PAGE_CATEGORY,
settings.MAX_PAGING_LINKS)
# Add the total quantity to each order - this can probably be
# replaced with fetch_related and Sum when we drop Django 1.3
order_quantities = defaultdict(int)
for item in OrderItem.objects.filter(order__user_id=request.user.id):
order_quantities[item.order_id] += item.quantity
for order in orders.object_list:
setattr(order, "quantity_total", order_quantities[order.id])
context = {"orders": orders}
return render(request, template, context)
def blog_post_list(request, tag=None, year=None, month=None, username=None,
category=None, template="blog/blog_post_list.html",
extra_context=None):
"""
Display a list of blog posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
templates = []
blog_posts = BlogPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
blog_posts = blog_posts.filter(keywords__keyword=tag)
if year is not None:
blog_posts = blog_posts.filter(publish_date__year=year)
if month is not None:
blog_posts = blog_posts.filter(publish_date__month=month)
try:
month = month_name[int(month)]
except IndexError:
raise Http404()
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
blog_posts = blog_posts.filter(categories=category)
templates.append(u"blog/blog_post_list_%s.html" %
str(category.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
blog_posts = blog_posts.filter(user=author)
templates.append(u"blog/blog_post_list_%s.html" % username)
prefetch = ("categories", "keywords__keyword")
blog_posts = blog_posts.select_related("user").prefetch_related(*prefetch)
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {"blog_posts": blog_posts, "year": year, "month": month,
"tag": tag, "category": category, "author": author}
context.update(extra_context or {})
templates.append(template)
return render(request, templates, context)
def form_processor(request, page):
"""
Display a built form and handle submission.
"""
if request.method == 'POST':
form = FormForForm(page.form,
request.POST or None,
request.FILES or None)
if form.is_valid():
if form.cleaned_data['field_5'] == 'Are_you_attentive?':
if request.regstage:
request.regstage.task_2 = True
request.regstage.save()
else:
errors = form._errors.setdefault("field_5", ErrorList())
errors.append(u'wrong key!')
return render(request, 'pages/form.html', {'form': form})
return {'stage': True}
def wishlist(request, template="shop/wishlist.html"):
"""
Display the wishlist and handle removing items from the wishlist and
adding them to the cart.
"""
skus = request.wishlist
error = None
if request.method == "POST":
to_cart = request.POST.get("add_cart")
add_product_form = AddProductForm(request.POST or None,
to_cart=to_cart)
if to_cart:
if add_product_form.is_valid():
request.cart.add_item(add_product_form.variation, 1)
recalculate_discount(request)
message = _("Item added to cart")
url = "shop_cart"
else:
error = add_product_form.errors.values()[0]
else:
message = _("Item removed from wishlist")
url = "shop_wishlist"
sku = request.POST.get("sku")
if sku in skus:
skus.remove(sku)
if not error:
info(request, message)
response = redirect(url)
set_cookie(response, "wishlist", ",".join(skus))
return response
# Remove skus from the cookie that no longer exist.
published_products = Product.objects.published(for_user=request.user)
f = {"product__in": published_products, "sku__in": skus}
wishlist = ProductVariation.objects.filter(**f).select_related(depth=1)
wishlist = sorted(wishlist, key=lambda v: skus.index(v.sku))
context = {"wishlist_items": wishlist, "error": error}
response = render(request, template, context)
if len(wishlist) < len(skus):
skus = [variation.sku for variation in wishlist]
set_cookie(response, "wishlist", ",".join(skus))
return response
def direct_to_template(request, template, extra_context=None, **kwargs):
"""
Replacement for Django's ``direct_to_template`` that uses
``TemplateResponse`` via ``mezzanine.utils.views.render``.
"""
context = extra_context or {}
context["params"] = kwargs
blog_posts = BlogPost.objects.published(for_user=request.user)
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context['blog_posts'] = blog_posts
for (key, value) in context.items():
if callable(value):
context[key] = value()
return render(request, template, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(request.GET.get("next", "/"))
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Signup")}
return render(request, template, context)
def cart(request, template="shop/cart.html"):
"""
Display cart and handle removing items from the cart.
"""
cart_formset = CartItemFormSet(instance=request.cart)
discount_form = DiscountForm(request, request.POST or None)
if request.method == "POST":
valid = True
if request.POST.get("update_cart"):
valid = request.cart.has_items()
if not valid:
# Session timed out.
info(request, _("Your cart has expired"))
else:
cart_formset = CartItemFormSet(request.POST,
instance=request.cart)
valid = cart_formset.is_valid()
if valid:
cart_formset.save()
recalculate_discount(request)
info(request, _("Cart updated"))
else:
# Reset the cart formset so that the cart
# always indicates the correct quantities.
# The user is shown their invalid quantity
# via the error message, which we need to
# copy over to the new formset here.
errors = cart_formset._errors
cart_formset = CartItemFormSet(instance=request.cart)
cart_formset._errors = errors
else:
valid = discount_form.is_valid()
if valid:
discount_form.set_discount()
if valid:
return redirect("shop_cart")
context = {"cart_formset": cart_formset}
settings.use_editable()
if (settings.SHOP_DISCOUNT_FIELD_IN_CART
and DiscountCode.objects.active().count() > 0):
context["discount_form"] = discount_form
return render(request, template, context)
def profile_update(request,
template="accounts/account_profile_update.html",
extra_context=None):
"""
Profile update form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None,
request.FILES or None,
instance=request.user)
if request.method == "POST" and form.is_valid():
user = form.save()
info(request, _("Profile updated"))
try:
return redirect("profile", username=user.username)
except NoReverseMatch:
return redirect("profile_update")
context = {"form": form, "title": _("Update Profile")}
context.update(extra_context or {})
return render(request, template, context)
def profile(request, username, template="accounts/account_profile.html"):
"""
Display a profile.
"""
profile_user = get_object_or_404(User, username=username, is_active=True)
profile_fields = SortedDict()
Profile = get_profile_model()
if Profile is not None:
profile = profile_user.get_profile()
user_fieldname = get_profile_user_fieldname()
exclude = tuple(settings.ACCOUNTS_PROFILE_FORM_EXCLUDE_FIELDS)
for field in Profile._meta.fields:
if field.name not in ("id", user_fieldname) + exclude:
value = getattr(profile, field.name)
profile_fields[field.verbose_name.title()] = value
context = {
"profile_user": profile_user,
"profile_fields": profile_fields.items(),
}
return render(request, template, context)
def cart_item_view(request,
template="shop/product.html",
form_class=AddProductForm,
extra_content=None,
cart_id="",
item_id=""):
cart = Cart.objects.filter(id=cart_id).first()
item = next(item for item in cart.items.iterator()
if item.id == int(item_id))
published_products = Product.objects.published(for_user=request.user)
product = get_object_or_404(published_products,
slug=item.url.split('/')[-1])
fields = [f.name for f in ProductVariation.option_fields()]
variations = product.variations.all()
variations_json = dumps([
dict([(f, getattr(v, f)) for f in fields + ["sku", "image_id"]])
for v in variations
])
variation = ProductVariation.objects.filter(sku=item.sku).first()
v_json = dict([(f, getattr(variation, f))
for f in fields + ["sku", "image_id"]
if getattr(variation, f) is not None])
initial_data = dict(quantity=item.quantity, **v_json)
initial_data['embroidery_type'] = item.personalization.embroidery_type
initial_data['value'] = item.personalization.value
add_product_form = form_class(request.POST or None,
product=product,
initial=initial_data,
to_cart=False)
context = {
"product": product,
"editable_obj": product,
"images": product.images.all(),
"variations": variations,
"variations_json": variations_json,
"has_available_variations": any([v.has_price() for v in variations]),
"add_product_form": add_product_form,
"item": item
}
return render(request, template, context)
def complete(request, template="shop/complete.html"):
"""
Redirected to once an order is complete - pass the order object
for tracking items via Google Anayltics, and displaying in
the template if required.
"""
try:
order = Order.objects.from_request(request)
except Order.DoesNotExist:
raise Http404
items = order.items.all()
# Assign product names to each of the items since they're not
# stored.
"""
skus = [item.sku for item in items]
variations = ProductVariation.objects.filter(sku__in=skus)
"""
#wni for refer to quantity
skus = [item.sku for item in items]
tmp_dict = {}
for item in items:
tmp_dict[item.sku] = item.quantity
variations = ProductVariation.objects.filter(sku__in=skus)
#variations = ProductVariation.objects.filter(sku__in=skus).extra(select={'sale_count': tmp_dict[sku]})
#variations = ProductVariation.objects.filter(sku__in=skus).extra(select={'sale_count': tmp_dict[F('sku')]})
names = {}
for variation in variations.select_related(depth=1):
names[variation.sku] = variation.product.title
#wni added for plus saled when order completed
variation.product.saled += tmp_dict[variation.sku]
variation.product.save()
for i, item in enumerate(items):
setattr(items[i], "name", names[item.sku])
context = {
"order": order,
"items": items,
"has_pdf": pisa is not None,
"steps": checkout.CHECKOUT_STEPS
}
return render(request, template, context)
def CustomSizeStep(request,
slug,
template="multiStepForm/customSizesStepForm.html"):
form = CustomSizeStepForm(request.POST or None, request=request)
if request.method == 'POST':
if form.is_valid():
sizeData = form.cleaned_data
#add dimensions to request.session json
#checking to see if dimensions are among json fields
# for field in request.session.iteritems():
# print "data/fields in SUBMITTED DIMENSIONS: " + str(field)
variation = ProductVariation.objects.get(
product__sku=request.session['sku'])
variation.height = sizeData['height']
variation.weight = sizeData['weight']
variation.neck_size = sizeData['neck_size']
variation.chest_around = sizeData['chest_around']
variation.sleeve_length = sizeData['sleeve_length']
variation.wrist_size = sizeData['wrist_size']
variation.full_back_length = sizeData['full_back_length']
variation.half_back_length = sizeData['half_back_length']
variation.full_shoulder_width = sizeData['full_shoulder_width']
variation.stomach = sizeData['stomach']
variation.waist_size = sizeData['waist_size']
variation.hip_size = sizeData['hip_size']
variation.pants_length = sizeData['pants_length']
variation.crotch_size = sizeData['crotch_size']
variation.fabrics = Fabric.objects.get(
name=request.session['fabrics'])
request.cart.add_item(variation, int(request.session['quantity']))
recalculate_cart(request)
return redirect("shop_cart")
context = {"form": form}
return render(request, template, context)
def direct_to_template(request, template, extra_context=None, **kwargs):
"""
Replacement for Django's ``direct_to_template`` that uses
``TemplateResponse`` via ``mezzanine.utils.views.render``.
"""
context = extra_context or {}
context["params"] = kwargs
for (key, value) in context.items():
if callable(value):
context[key] = value()
posts = []
latest_post = BlogPost.objects.filter(status=2).order_by('-created')[0:3]
for post in latest_post:
posts.append(post.__dict__)
context["posts"] = posts
context["posts_len"] = len(posts)
# import pdb;pdb.set_trace()
from django.utils import timezone
context["now_date"] = timezone.now()
return render(request, template, context)
def spam(request, template="generic/comments.html"):
response = initial_validation(request, "spam")
if isinstance(response, HttpResponse):
return response
obj, post_data = response
form = CommentFlagForm(request, obj, post_data)
if form.is_valid():
url = obj.get_absolute_url()
if is_spam(request, form, url):
return redirect(url)
form.save(request)
messages.info(request, _('Se guardó como spam'))
response = redirect(add_cache_bypass(obj.get_absolute_url()))
# for field in CommentFlagForm.cookie_fields:
# cookie_name = CommentFlagForm.cookie_prefix + field
# cookie_value = post_data.get(field, "")
# set_cookie(response, cookie_name, cookie_value)
return response
context = {"obj": obj, "spam_form": form}
response = render(request, template, context)
return response
def service(request, pk):
service = get_object_or_404(Service, pk=pk)
form_is_ok = False
context = {
'service': service,
'form_is_ok': form_is_ok,
}
if request.method == 'POST':
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
template = loader.get_template("email_feedback.html")
email_context = Context({
"form": contact_form,
"obj": service,
})
if service.manager:
send_mail(u"Получен новый вопрос",
template.render(email_context),
"*****@*****.**", [service.manager.email],
fail_silently=True)
else:
mail_admins(
u"Получен новый вопрос",
template.render(email_context),
fail_silently=True,
)
form_is_ok = True
else:
contact_form = ContactForm()
context.update({
'contact_form': contact_form,
'form_is_ok': form_is_ok,
})
return render(request, "work/service_detail.html", context)
def iyph_post_list(request, tag=None, year=None, month=None, username=None,
category=None, template="iyph/iyph_post_list.html"):
"""
Display a list of iyph posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``iyph/iyph_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
print(' --- SON qui!!!!!!!!!!')
settings.use_editable()
templates = []
iyph_posts = IyphPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
iyph_posts = iyph_posts.filter(keywords__in=tag.assignments.all())
if year is not None:
iyph_posts = iyph_posts.filter(publish_date__year=year)
if month is not None:
iyph_posts = iyph_posts.filter(publish_date__month=month)
month = month_name[int(month)]
if category is not None:
category = get_object_or_404(IyphCategory, slug=category)
iyph_posts = iyph_posts.filter(categories=category)
templates.append(u"iyph/iyph_post_list_%s.html" %
unicode(category.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
iyph_posts = iyph_posts.filter(user=author)
templates.append(u"iyph/iyph_post_list_%s.html" % username)
prefetch = ("categories", "keywords__keyword")
iyph_posts = iyph_posts.select_related("user").prefetch_related(*prefetch)
iyph_posts = paginate(iyph_posts, request.GET.get("page", 1),
settings.IYPH_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {"iyph_posts": iyph_posts, "year": year, "month": month,
"tag": tag, "category": category, "author": author,}#"data": data
templates.append(template)
return render(request, templates, context)
def paypal_execute(request, template="shop/payment_confirmation.html"):
"""
Recebe a confirmação de pagamento do paypal
"""
token = request.GET['token']
payer_id = request.GET['PayerID']
logger.debug("integration.views.paypal_execute(token=%s,payer_id=%s)" %
(token, payer_id))
order = get_object_or_404(Order, paypal_redirect_token=token)
payment = Payment.find(order.transaction_id)
payment.execute({"payer_id": payer_id})
# Pago, falta enviar
order.status = 3
order.save()
context = {"order": order}
response = render(request, template, context)
return response
def invoice(request, order_id, template="shop/order_invoice.html",
template_pdf="shop/order_invoice_pdf.html"):
"""
Display a plain text invoice for the given order. The order must
belong to the user which is checked via session or ID if
authenticated, or if the current user is staff.
"""
try:
order = Order.objects.get_for_user(order_id, request)
except Order.DoesNotExist:
raise Http404
context = {"order": order}
context.update(order.details_as_dict())
context = RequestContext(request, context)
if request.GET.get("format") == "pdf":
response = HttpResponse(content_type="application/pdf")
name = slugify("%s-invoice-%s" % (settings.SITE_TITLE, order.id))
response["Content-Disposition"] = "attachment; filename=%s.pdf" % name
html = get_template(template_pdf).render(context)
pisa.CreatePDF(html, response)
return response
return render(request, template, context)
def wiki_page_new(request, template="mezawiki/wiki_page_new.html"):
"""
Displays the form for creating a page.
"""
if not can_add_wikipage(request.user):
return HttpResponseForbidden(
_("You don't have permission to create wiki page."))
if request.method == 'POST':
form = WikiPageForm(request.POST)
if form.is_valid():
page = form.save(commit=False)
try:
page.user = request.user
except:
# anonymous
page.user_id = -1
page.slug = urlize_title(form.cleaned_data["title"])
# TODO Check slug, it is not a unique field
page.save()
revision = WikiPageRevision()
revision.content = page.content
revision.description = form.cleaned_data["summary"]
revision.page = page
try:
revision.user = request.user
except:
# anonymous
revision.user_id = -1
revision.save()
return HttpResponseRedirect(
reverse('wiki_page_detail', args=[page.slug]))
else:
form = WikiPageForm(initial={'status': 1})
context = {'form': form}
return render(request, template, context)
def complete(request, template="shop/complete.html"):
"""
Redirected to once an order is complete - pass the order object
for tracking items via Google Anayltics, and displaying in
the template if required.
"""
try:
order = Order.objects.from_request(request)
except Order.DoesNotExist:
raise Http404
items = order.items.all()
# Assign product names to each of the items since they're not
# stored.
skus = [item.sku for item in items]
variations = ProductVariation.objects.filter(sku__in=skus)
names = {}
for variation in variations.select_related(depth=1):
names[variation.sku] = variation.product.title
for i, item in enumerate(items):
setattr(items[i], "name", names[item.sku])
context = {"order": order, "items": items,
"steps": checkout.CHECKOUT_STEPS}
return render(request, template, context)
def search(request, template="search_results.html"):
"""
Display search results. Takes an optional "contenttype" GET parameter
in the form "app-name.ModelName" to limit search results to a single model.
"""
settings.use_editable()
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
per_page = settings.SEARCH_PER_PAGE
max_paging_links = settings.MAX_PAGING_LINKS
try:
search_model = get_model(*request.GET.get("type", "").split(".", 1))
search_model.objects.search # Attribute check
except (ValueError, TypeError, LookupError, AttributeError):
search_model = Displayable
search_type = _("Everything")
else:
search_type = search_model._meta.verbose_name_plural.capitalize()
results = search_model.objects.search(query, for_user=request.user)
paginated = paginate(results, page, per_page, max_paging_links)
context = {"query": query, "results": paginated,
"search_type": search_type}
return render(request, template, context)
def blog_post_detail(request,
slug,
year=None,
month=None,
day=None,
template="blog_post_detail.html"):
""". Custom templates are checked for using the name
``blog/blog_post_detail_XXX.html`` where ``XXX`` is the blog
posts's slug.
"""
blog_posts = BlogProxy.secondary.published(for_user=request.user).filter(
slug=slug)
if len(blog_posts) != 1:
raise Http404(_('Slug %s does not exist.' % slug))
blog_post = blog_posts[0]
context = {"blog_post": blog_post, "editable_obj": blog_post}
templates = [
u"%sblog_post_detail_%s.html" %
(blog_post.template_dir, unicode(slug)),
u"%s%s" % (blog_post.template_dir, template)
]
return render(request, templates, context)
def blog_post_detail(request,
slug,
year=None,
month=None,
day=None,
template="blog/blog_post_detail.html",
extra_context=None):
""". Custom templates are checked for using the name
``blog/blog_post_detail_XXX.html`` where ``XXX`` is the blog
posts's slug.
"""
blog_posts = BlogPost.objects.published(
for_user=request.user).select_related()
blog_post = get_object_or_404(blog_posts, slug=slug)
related_posts = blog_post.related_posts.published(for_user=request.user)
context = {
"blog_post": blog_post,
"editable_obj": blog_post,
"related_posts": related_posts
}
context.update(extra_context or {})
templates = [u"blog/blog_post_detail_%s.html" % str(slug), template]
return render(request, templates, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = UserRegistrationLeadForm
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
data = form.cleaned_data.copy()
# ensure user is not a robot
honeypot = data.pop('superpriority')
if honeypot:
raise PermissionDenied
# save the user
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(
request,
_("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(
request,
_("A verification email has been sent with "
"a link for activating your account."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Sign up")}
return render(request, template, context)
def signup(request, template="accounts/account_signup.html"):
"""
Signup form.
"""
profile_form = get_profile_form()
form = profile_form(request.POST or None, request.FILES or None)
if request.method == "POST" and form.is_valid():
new_user = form.save()
if not new_user.is_active:
if settings.ACCOUNTS_APPROVAL_REQUIRED:
send_approve_mail(request, new_user)
info(request, _("Thanks for signing up! You'll receive "
"an email when your account is activated."))
else:
send_verification_mail(request, new_user, "signup_verify")
info(request, _("A verification email has been sent with "
"a link for activating your account."))
return redirect(next_url(request) or "/")
else:
info(request, _("Successfully signed up"))
auth_login(request, new_user)
return login_redirect(request)
context = {"form": form, "title": _("Sign up")}
return render(request, template, context)
def wiki_page_detail(request,
slug,
year=None,
month=None,
template="mezawiki/wiki_page_detail.html"):
"""
Displays a wiki page.
Redirects to the edit view if the page doesn't exist.
Custom templates are checked for using the name
``mezawiki/wiki_page_detail_XXX.html``
where ``XXX`` is the wiki pages's slug.
"""
slug_original = slug
slug = urlize_title(slug)
if slug != slug_original:
return HttpResponseRedirect(reverse('wiki_page_detail', args=[slug]))
try:
wiki_page_exist = WikiPage.objects.get(slug=slug)
if wiki_page_exist.status == 1 and not wiki_page_exist.can_edit_wikipage(
request.user):
return HttpResponseForbidden(
_("You don't have permission to view this wiki page."))
wiki_pages = WikiPage.objects.published(for_user=request.user)
wiki_page = wiki_pages.get(slug=slug)
except WikiPage.DoesNotExist:
if can_add_wikipage(request.user):
return HttpResponseRedirect(reverse('wiki_page_edit', args=[slug]))
else:
return HttpResponseForbidden(
_("You don't have permission to add new wiki page."))
context = {"wiki_page": wiki_page}
templates = [
u"mezawiki/wiki_page_detail_%s.html" % unicode(slug), template
]
return render(request, templates, context)
def invoice(request, order_id, template="shop/order_invoice.html"):
"""
Display a plain text invoice for the given order. The order must
belong to the user which is checked via session or ID if
authenticated, or if the current user is staff.
"""
lookup = {"id": order_id}
if not request.user.is_authenticated():
lookup["key"] = request.session.session_key
elif not request.user.is_staff:
lookup["user_id"] = request.user.id
order = get_object_or_404(Order, **lookup)
context = {"order": order}
context.update(order.details_as_dict())
context = RequestContext(request, context)
if request.GET.get("format") == "pdf":
response = HttpResponse(mimetype="application/pdf")
name = slugify("%s-invoice-%s" % (settings.SITE_TITLE, order.id))
response["Content-Disposition"] = "attachment; filename=%s.pdf" % name
html = get_template(template).render(context)
import ho.pisa
ho.pisa.CreatePDF(html, response)
return response
return render(request, template, context)
