def settings(request=None):
"""
Add the settings object to the template context.
"""
from mezzanine.conf import settings
settings_dict = None
cache_settings = request and cache_installed()
if cache_settings:
cache_key = cache_key_prefix(request) + "context-settings"
settings_dict = cache_get(cache_key)
if not settings_dict:
settings.use_editable()
settings_dict = TemplateSettings()
for k in settings.TEMPLATE_ACCESSIBLE_SETTINGS:
settings_dict[k] = getattr(settings, k, "")
for k in DEPRECATED:
settings_dict[k] = getattr(settings, k, DEPRECATED)
if cache_settings:
cache_set(cache_key, settings_dict)
# This is basically the same as the old ADMIN_MEDIA_PREFIX setting,
# we just use it in a few spots in the admin to optionally load a
# file from either grappelli or Django admin if grappelli isn't
# installed. We don't call it ADMIN_MEDIA_PREFIX in order to avoid
# any confusion.
if settings.GRAPPELLI_INSTALLED:
settings_dict["MEZZANINE_ADMIN_PREFIX"] = "grappelli/"
else:
settings_dict["MEZZANINE_ADMIN_PREFIX"] = "admin/"
return {"settings": settings_dict}
def correios_billship_handler(request, order_form):
"""
Default billing/shipping handler - called when the first step in
the checkout process with billing/shipping address fields is
submitted. Implement your own and specify the path to import it
from via the setting ``SHOP_HANDLER_BILLING_SHIPPING``.
This function will typically contain any shipping calculation
where the shipping amount can then be set using the function
``cartridge.shop.utils.set_shipping``. The Cart object is also
accessible via ``request.cart``
"""
logger.debug("integration.checkout.correios_billship_handler()")
if not request.session.get("free_shipping"):
settings.use_editable()
# http://www.correios.com.br/webservices/default.cfm
# http://www.correios.com.br/webServices/PDF/SCPP_manual_implementacao_calculo_remoto_de_precos_e_prazos.pdf
client = Client("http://ws.correios.com.br/calculador/CalcPrecoPrazo.asmx?wsdl")
"""
40010 = SEDEX
"""
origin_cep = settings.CEP_ORIGIN
data = order_form.cleaned_data
dest_cep = data["billing_detail_postcode"]
logger.debug("cep de %s para %s" % (origin_cep,dest_cep) )
# Propriedades fixas apenas para testar por enquanto
result = client.service.CalcPreco("","",40010, origin_cep, dest_cep , "1.0",1, 50.0, 50.0, 50.0, 50.0, "N", 0 , "N")
price = Decimal(result.Servicos[0][0].Valor.replace(",","."))
logger.debug("preço %s" % price)
set_shipping(request, _("SEDEX"), price)
def search(request, template="search_results.html", extra_context=None):
"""
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:
parts = request.GET.get("type", "").split(".", 1)
search_model = apps.get_model(*parts)
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}
context.update(extra_context or {})
return render(request, template, context)
def __init__(self, *args, **kwargs):
"""
Use the title and description of the Blog page for the feed's
title and description. If the blog page has somehow been
removed, fall back to the ``SITE_TITLE`` and ``SITE_TAGLINE``
settings.
"""
self.tag = kwargs.pop("tag", None)
self.category = kwargs.pop("category", None)
self.username = kwargs.pop("username", None)
super(PostsRSS, self).__init__(*args, **kwargs)
self._public = True
try:
page = Page.objects.published().get(slug=settings.BLOG_SLUG)
except Page.DoesNotExist:
page = None
else:
self._public = not page.login_required
if self._public:
if page is not None:
self.title = page.title
self.description = strip_tags(page.description)
else:
settings.use_editable()
self.title = settings.SITE_TITLE
self.description = settings.SITE_TAGLINE
def send_store_order_email(request, order):
"""
Send order email to store on successful order.
"""
settings.use_editable()
address = request.session['address']
store = request.session['stores']
store_name = store[0].name
store_email = [store[0].email]
store_name_no_spaces = store_name.replace(" ", "")
order_context = {"order": order, "request": request,
"order_items": order.items.all(), "address": address,
"store_name": store_name, "store_name_no_spaces": store_name_no_spaces}
order_context.update(order.details_as_dict())
try:
get_template("shop/email/store_order.html")
except TemplateDoesNotExist:
receipt_template = "email/store_order"
else:
receipt_template = "shop/email/store_order"
from warnings import warn
warn("Shop email receipt templates have moved from "
"templates/shop/email/ to templates/email/")
send_mail_template(settings.SHOP_STORE_ORDER_EMAIL_SUBJECT,
receipt_template, settings.SHOP_ORDER_FROM_EMAIL,
store_email, context=order_context,
fail_silently=settings.DEBUG)
def __init__(self, *args, **kwargs):
super(SettingsForm, self).__init__(*args, **kwargs)
# Create a form field for each editable setting's from its type.
active_language = get_language()
for name in sorted(registry.keys()):
setting = registry[name]
if setting["editable"]:
codes = [active_language]
if settings.USE_MODELTRANSLATION and setting["translatable"]:
codes = SortedDict(settings.LANGUAGES)
field_class = FIELD_TYPES.get(setting["type"], forms.CharField)
for code in codes:
try:
activate(code)
except:
pass
else:
# refresh settings cache for each language to properly
# handle initial values.
settings.use_editable()
kwargs = {
"label": setting["label"] + ":",
"required": setting["type"] in (int, float),
"initial": getattr(settings, name),
"help_text":
self.format_help(setting["description"]),
}
if setting["choices"]:
field_class = forms.ChoiceField
kwargs["choices"] = setting["choices"]
field_instance = field_class(**kwargs)
self.fields[name + "/" + code] = field_instance
css_class = field_class.__name__.lower()
field_instance.widget.attrs["class"] = css_class
activate(active_language)
def send_order_email(request, order):
"""
Send order receipt email on successful order.
"""
settings.use_editable()
address = request.session['address']
store = request.session['stores']
store_name = store[0].name
store_address = store[0].address
store_contact = store[0].contact_number
order_context = {"order": order, "request": request,
"order_items": order.items.all(), "address": address,
"store_name": store_name, "store_address": store_address,
"store_contact": store_contact}
order_context.update(order.details_as_dict())
try:
get_template("shop/email/order_receipt.html")
except TemplateDoesNotExist:
receipt_template = "email/order_receipt"
else:
receipt_template = "shop/email/order_receipt"
from warnings import warn
warn("Shop email receipt templates have moved from "
"templates/shop/email/ to templates/email/")
send_mail_template(settings.SHOP_ORDER_EMAIL_SUBJECT,
receipt_template, settings.SHOP_ORDER_FROM_EMAIL,
order.billing_detail_email, context=order_context,
fail_silently=settings.DEBUG)
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)
page_template = "search_results_page.html"
# per_page = settings.SEARCH_PER_PAGE
# max_paging_links = settings.MAX_PAGING_LINKS
try:
search_model = get_model(*request.GET.get("type", "").split(".", 1))
if not issubclass(search_model, Displayable):
raise TypeError
except TypeError:
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)
if request.is_ajax():
template = page_template
article_map = get_article_map(True)
context = {
"query": query,
"results": results,
"search_type": search_type,
"page_template": page_template,
"form": MapFormForSideBar(initial={"map": article_map}),
"latest_commented_articles": article_service.get_latest_unique_commented_on_articles(),
}
return render(request, template, context, context_instance=RequestContext(request))
def run(self):
"""
Request new tweets from the Twitter API.
"""
urls = {
QUERY_TYPE_USER: (
"https://api.twitter.com/1.1/statuses/"
"user_timeline.json?screen_name=%s"
"&include_rts=true" % self.value.lstrip("@")
),
QUERY_TYPE_LIST: (
"https://api.twitter.com/1.1/lists/statuses.json"
"?list_id=%s&include_rts=true" % self.value.encode("utf-8")
),
QUERY_TYPE_SEARCH: "https://api.twitter.com/1.1/search/tweets.json"
"?q=%s" % quote(self.value.encode("utf-8")),
}
try:
url = urls[self.type]
except KeyError:
raise TwitterQueryException("Invalid query type: %s" % self.type)
settings.use_editable()
auth_settings = (
settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
settings.TWITTER_ACCESS_TOKEN_KEY,
settings.TWITTER_ACCESS_TOKEN_SECRET,
)
if not all(auth_settings):
raise TwitterQueryException("Twitter OAuth settings missing")
try:
tweets = requests.get(url, auth=OAuth1(*auth_settings)).json()
except Exception, e:
raise TwitterQueryException("Error retrieving: %s" % e)
def save(self, *args, **kwargs):
kwargs["commit"] = False
user = super(AddUserForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
username = "******" % self.cleaned_data
if not username.strip():
username = self.cleaned_data["email"].split("@")[0]
qs = User.objects.exclude(id=self.instance.id) # @UndefinedVariable PyDev limitation ("exclude")
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
user.save()
# Save profile model.
ProfileFieldsForm(self.data, self.files, instance=user.profile).save()
settings.use_editable()
#if (settings.ACCOUNTS_VERIFICATION_REQUIRED or
# settings.ACCOUNTS_APPROVAL_REQUIRED):
# user.is_active = False
# user.save()
return user
def get_redirect_url(self, *args, **kwargs):
code = self.request.GET.get("code")
settings.use_editable()
site = Site.objects.get_current()
conf = {
"redirect_uri": "http://{0}{1}".format(site.domain, reverse('instagram_oauth')),
"client_id": settings.INSTAGRAM_CLIENT_ID,
"client_secret": settings.INSTAGRAM_CLIENT_SECRET,
}
unauthorized_api = InstagramAPI(**conf)
logger.debug(unauthorized_api)
access_token = unauthorized_api.exchange_code_for_access_token(code)
try:
instagram = Instagram.objects.all()[0]
instagram.access_token = access_token[0]
instagram.user_id = int(access_token[1]['id'])
instagram.full_name = access_token[1]['full_name']
instagram.username = access_token[1]['username']
instagram.save()
except IndexError:
Instagram.objects.create(access_token=access_token[0],
user_id=int(access_token[1]['id']),
full_name=access_token[1]['full_name'],
username=access_token[1]['username'])
return "/admin/"
def blog_post_list(request, tag=None, year=None, month=None, username=None,
category=None, template="blog/blog_post_list.html"):
"""
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.
"""
settings.use_editable()
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__in=tag.assignments.all())
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)
month = month_name[int(month)]
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" %
unicode(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)
# Create dicts mapping blog post IDs to lists of categories and
# keywords, and assign these to each blog post, to avoid querying
# the database inside the template loop for posts.
blog_posts = list(blog_posts.select_related("user"))
categories = defaultdict(list)
if blog_posts:
ids = ",".join([str(p.id) for p in blog_posts])
for cat in BlogCategory.objects.raw(
"SELECT * FROM blog_blogcategory "
"JOIN blog_blogpost_categories "
"ON blog_blogcategory.id = blogcategory_id "
"WHERE blogpost_id IN (%s)" % ids):
categories[cat.blogpost_id].append(cat)
keywords = defaultdict(list)
blogpost_type = ContentType.objects.get(app_label="blog", model="blogpost")
assigned = AssignedKeyword.objects.filter(blogpost__in=blog_posts,
content_type=blogpost_type).select_related("keyword")
for a in assigned:
keywords[a.object_pk].append(a.keyword)
for i, post in enumerate(blog_posts):
setattr(blog_posts[i], "category_list", categories[post.id])
setattr(blog_posts[i], "keyword_list", keywords[post.id])
blog_posts = paginate(blog_posts,
request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {"blog_page": blog_page(), "blog_posts": blog_posts,
"year": year, "month": month, "tag": tag,
"category": category, "author": author}
templates.append(template)
return render(request, templates, context)
def get_app_setting(app_label, setting):
settings.use_editable()
setting_root_slug_key = "{0}_{1}".format(app_label.upper(), setting.upper())
slug = getattr(settings, setting_root_slug_key, None)
if not slug:
raise ImproperlyConfigured("The {0} setting must not be empty.".format(setting_root_slug_key))
return slug
def sign_agreement(request):
"""Display the user agreement and allow the user to sign it."""
settings.use_editable()
form = AgreementForm()
agreement = get_object_or_404(
Agreement, version=settings.DOWNLOAD_AGREEMENT_VERSION)
if request.method == "POST":
form = AgreementForm(request.POST)
if form.is_valid():
ip = (request.META.get('HTTP_X_FORWARDED_FOR', '').split(',')[0]
or request.META.get('REMOTE_ADDR'))
SignedAgreement.objects.create(
user=request.user,
ip=ip,
agreement=agreement,
)
redirect_field_name = 'next'
default_next = '/'
next_page = request.POST.get(
redirect_field_name, request.GET.get(redirect_field_name))
next_page = next_page or default_next
if not is_safe_url(url=next_page, host=request.get_host()):
next_page = default_next
if 'waiting_download' in request.session:
request.session['ready_download'] = request.session[
'waiting_download']
del request.session['waiting_download']
return redirect(next_page)
return render(request, 'protected_assets/download-agreement.html', {
'form': form,
'agreement': agreement,
})
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 process_request(self, request):
settings.use_editable()
force_host = settings.SSL_FORCE_HOST
response = None
if force_host and request.get_host().split(":")[0] != force_host:
url = "http://%s%s" % (force_host, request.get_full_path())
response = HttpResponsePermanentRedirect(url)
elif settings.SSL_ENABLED and not settings.DEV_SERVER:
url = "%s%s" % (request.get_host(), request.get_full_path())
if request.path.startswith(settings.SSL_FORCE_URL_PREFIXES):
if not request.is_secure():
response = HttpResponseRedirect("https://%s" % url)
elif request.is_secure() and settings.SSL_FORCED_PREFIXES_ONLY:
response = HttpResponseRedirect("http://%s" % url)
if response and request.method == "POST":
if resolve(request.get_full_path()).url_name == "fb_do_upload":
# The handler for the flash file uploader in filebrowser
# doesn't have access to the http headers Django will use
# to determine whether the request is secure or not, so
# in this case we don't attempt a redirect - note that
# when /admin is restricted to SSL using Mezzanine's SSL
# setup, the flash uploader will post over SSL, so
# someone would need to explictly go out of their way to
# trigger this.
return
# Tell the client they need to re-POST.
response.status_code = 307
return response
def send_order_email(request, order):
"""
Send order receipt email on successful order.
"""
settings.use_editable()
order_context = {"order": order, "request": request,
"order_items": order.items.all()}
if order.has_reservables:
order_context["has_reservables"] = True
else:
order_context["has_reservables"] = False
order_context["hide_shipping"] = settings.SHOP_ALWAYS_SAME_BILLING_SHIPPING
order_context.update(order.details_as_dict())
try:
get_template("shop/email/order_receipt.html")
except TemplateDoesNotExist:
receipt_template = "email/order_receipt"
else:
receipt_template = "shop/email/order_receipt"
from warnings import warn
warn("Shop email receipt templates have moved from "
"templates/shop/email/ to templates/email/")
send_mail_template(settings.SHOP_ORDER_EMAIL_SUBJECT,
receipt_template, settings.SHOP_ORDER_FROM_EMAIL,
order.billing_detail_email, context=order_context,
addr_bcc=settings.SHOP_ORDER_EMAIL_BCC or None)
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))
if not issubclass(search_model, Displayable):
raise TypeError
except TypeError:
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)
if 'location' and 'age' in request.session:
if 'cart loaded' in request.session:
stores = request.session['stores']
else:
avail_store_ids = request.session['store ids']
if avail_store_ids:
stores = Store.objects.filter(id__in=avail_store_ids)
else:
return HttpResponseRedirect('/shop/no-stores-yet')
avail_prod_ids = []
for p in stores:
for k in results:
if p == k.store:
avail_prod_ids.append(k.id)
results = Product.objects.filter(id__in=avail_prod_ids)
sort_options = [(slugify(option[0]), option[1])
for option in settings.SHOP_PRODUCT_SORT_OPTIONS]
sort_by = request.GET.get("sort", sort_options[0][1])
results = paginate(results.order_by(sort_by),
request.GET.get("page", 1),
settings.SHOP_PER_PAGE_CATEGORY,
settings.MAX_PAGING_LINKS)
results.sort_by = sort_by
else:
# return render(request, template, {"have_loc": False})
info(request, _("Enter your location to use the search"))
return HttpResponseRedirect('/')
# paginated = paginate(results, page, per_page, max_paging_links)
paginated = results
context = {"query": query, "results": paginated,
"search_type": search_type, "have_loc": True}
return render(request, template, context)
def protected_download(request, path):
"""Check for a signed download agreement before delivering the asset."""
settings.use_editable()
agreement = Agreement.objects.filter(user=request.user, version=settings.DOWNLOAD_AGREEMENT_VERSION)
if not agreement.exists():
params = {'next': request.path}
previous = request.META.get('HTTP_REFERER', None) or None
if previous is not None:
params['next'] = previous
request.session['waiting_download'] = request.path
agreement_url = '%s?%s' % (
reverse('page', kwargs={'slug': 'download-agreement'}),
urllib.urlencode(params))
return redirect(agreement_url)
if settings.DEBUG:
response = serve(request, path, document_root=os.path.join(settings.MEDIA_ROOT, FILEBROWSER_DIRECTORY, 'protected'))
else:
response = HttpResponse()
response['X-Accel-Redirect'] = '/__protected__/%s' % path
response['Content-Disposition'] = 'attachment; filename=%s' % os.path.basename(path)
if request.path == request.session.get('waiting_download'):
del request.session['waiting_download']
if request.path == request.session.get('ready_download'):
del request.session['ready_download']
return response
def process_request(self, request):
"""
Adds cart and wishlist attributes to the current request, and
handles any redirections required for SSL. If SHOP_FORCE_HOST
is set and is not the current host, redirect to it if
SHOP_SSL_ENABLED is True, and ensure checkout views are
accessed over HTTPS and all other views are accessed over HTTP.
"""
request.cart = Cart.objects.from_request(request)
wishlist = request.COOKIES.get("wishlist", "").split(",")
if not wishlist[0]:
wishlist = []
request.wishlist = wishlist
settings.use_editable()
force_host = settings.SHOP_FORCE_HOST
if force_host and request.get_host().split(":")[0] != force_host:
url = "http://%s%s" % (force_host, request.get_full_path())
return HttpResponsePermanentRedirect(url)
if settings.SHOP_SSL_ENABLED and not settings.DEV_SERVER:
url = "%s%s" % (request.get_host(), request.get_full_path())
if request.path in map(reverse, settings.SHOP_FORCE_SSL_VIEWS):
if not request.is_secure():
return HttpResponseRedirect("https://%s" % url)
elif request.is_secure():
return HttpResponseRedirect("http://%s" % url)
def save(self, *args, **kwargs):
"""
Create the new user using their email address as their username.
"""
user = super(ProfileForm, self).save(*args, **kwargs)
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
user.save()
# Save profile model.
if self._has_profile:
profile = user.get_profile()
profile_fields_form = self.get_profile_fields_form()
profile_fields_form(self.data, instance=profile).save()
if self._signup:
settings.use_editable()
if settings.ACCOUNTS_VERIFICATION_REQUIRED:
user.is_active = False
user.save()
else:
user = authenticate(username=user.username,
password=password, is_active=True)
return user
def download_agreement(request, page):
form = AgreementForm()
if request.method == "POST":
form = AgreementForm(request.POST)
if form.is_valid():
settings.use_editable()
if "HTTP_X_FORWARDED_FOR" in request.META:
parts = request.META["HTTP_X_FORWARDED_FOR"].split(",", 1)
ip = parts[0]
else:
ip = request.META.get('REMOTE_ADDR') or None
Agreement.objects.create(
user=request.user,
ip=ip,
version=settings.DOWNLOAD_AGREEMENT_VERSION
)
redirect_field_name = 'next'
default_next = '/'
next_page = request.POST.get(redirect_field_name, request.GET.get(redirect_field_name))
next_page = next_page or default_next
if not is_safe_url(url=next_page, host=request.get_host()):
next_page = default_next
if 'waiting_download' in request.session:
request.session['ready_download'] = request.session['waiting_download']
del request.session['waiting_download']
return redirect(next_page)
return {"form": form}
def article_list(request, tag=None, category=None, template="article/article_list.html"):
"""
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.
"""
settings.use_editable()
templates = []
articles = Article.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
articles = articles.filter(keywords__in=tag.assignments.all())
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
articles = articles.filter(categories=category)
# templates.append(u"article/blog_post_list_%s.html" %
# str(category.slug))
author = None
prefetch = ("categories", "keywords__keyword")
articles = articles.select_related("user").prefetch_related(*prefetch)
articles = paginate(articles, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {"articles": articles,
"tag": tag, "category": category, "author": author}
templates.append(template)
return render(request, templates, context)
def blog_post_home(request, template="index.html"):
settings.use_editable()
templates = []
cnt = 8
news = BlogPost.objects.published(for_user=request.user).filter(categories=cate_dics['news'])[:cnt]
acts = list(BlogPost.objects.published(for_user=request.user).filter(categories=cate_dics['activity'])[:cnt])
briefs = BlogPost.objects.published(for_user=request.user).filter(categories=cate_dics['brief'])[:cnt]
coms = BlogPost.objects.published(for_user=request.user).filter(categories=cate_dics['company'])[:cnt]
clubs = BlogPost.objects.published(for_user=request.user).filter(categories=cate_dics['club'])[:cnt]
jobs = BlogPost.objects.published(for_user=request.user).filter(categories=cate_dics['job'])[:cnt]
ap_links = ApplyLink.objects.filter(permit=True)
images = []
for a in acts:
if a.featured_image:
images.append(a.featured_image.url)
if len(images) < 6:
images += static_images[:cnt-len(images)]
#print images
context = {"news":news, "blog_posts": acts, "briefs":briefs, "coms":coms, "clubs":clubs, "jobs":jobs, 'imgs':images, 'ap_links':ap_links}
templates.append(template)
return render(request, templates, context)
def blog_post_list(request, tag=None, year=None, month=None, username=None,
category=None, template="blog/blog_post_list.html"):
"""
Display a list of blog posts.
"""
settings.use_editable()
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=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)
month = month_name[int(month)]
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
blog_posts = blog_posts.filter(category=category)
user = None
if username is not None:
user = get_object_or_404(User, username=username)
blog_posts = blog_posts.filter(user=user)
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.BLOG_POST_MAX_PAGING_LINKS)
context = {"blog_posts": blog_posts, "year": year, "month": month,
"tag": tag, "category": category, "user": user,
"use_disqus": bool(settings.COMMENTS_DISQUS_SHORTNAME),
"blog_page": blog_page()}
return render_to_response(template, context, RequestContext(request))
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 settings(request):
"""
Add the settings object to the template context.
"""
from mezzanine.conf import settings
settings.use_editable()
return {"settings": settings}
def test_settings(self):
"""
Test that an editable setting can be overridden with a DB
value and that the data type is preserved when the value is
returned back out of the DB. Also checks to ensure no
unsupported types are defined for editable settings.
"""
# Find an editable setting for each supported type.
names_by_type = {}
for setting in registry.values():
if setting["editable"] and setting["type"] not in names_by_type:
names_by_type[setting["type"]] = setting["name"]
# Create a modified value for each setting and save it.
values_by_name = {}
for (setting_type, setting_name) in names_by_type.items():
setting_value = registry[setting_name]["default"]
if setting_type in (int, float):
setting_value += 1
elif setting_type is bool:
setting_value = not setting_value
elif setting_type is str:
setting_value += "test"
elif setting_type is bytes:
setting_value += b"test"
else:
setting = "%s: %s" % (setting_name, setting_type)
self.fail("Unsupported setting type for %s" % setting)
values_by_name[setting_name] = setting_value
Setting.objects.create(name=setting_name, value=setting_value)
# Load the settings and make sure the DB values have persisted.
settings.use_editable()
for (name, value) in values_by_name.items():
self.assertEqual(getattr(settings, name), value)
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
table_name = BlogPost._meta.db_table
try:
search_model = get_model(*request.GET.get("type", "").split(".", 1))
if not issubclass(search_model, Displayable):
raise TypeError
except TypeError:
search_model = BlogPost#Displayable
search_type = _("blog.BlogPost")#_("Everything")
else:
search_type = search_model._meta.verbose_name_plural.capitalize()
queryWithQuotes = '"%s"' % query
results = search_model.objects.search(queryWithQuotes, for_user=request.user)
filters = request.GET.get("filter", '')
filter_arr = []
if filters != '':
filter_arr = filters.split('-')
filter_sum = ''
if len(filter_arr) > 0:
for i in range(len(filter_arr)):
if is_valid_search_filter(filter_arr[i]):
if i == 0:
filter_sum += filter_arr[i].lower()+'_average'
else:
filter_sum += '+' + filter_arr[i].lower()+'_average'
if filter_sum != '':
'''
If filters are apllied, order vendors by sum of the filter parameter values.
In case filter values are equal, order them as per their overall average.
For now tie between equal overall_average is not broken. To break add more parameters ahead in order of priority.
'''
results = results.extra(select={'filtersum': filter_sum,
'fieldsum':'price_average + website_ex_average + quality_average + service_average',
'followers': 'SELECT COUNT(*) FROM %s WHERE target_blogpost_id=%s.id' % (Follow._meta.db_table, table_name)},
order_by=('-filtersum', '-overall_average', '-fieldsum', '-comments_count', '-followers',)).distinct()
else:
'''
In absence of any filters, order vendors by overall_average by default.
'''
results = results.extra(select={'fieldsum':'price_average + website_ex_average + quality_average + service_average',
'followers': 'SELECT COUNT(*) FROM %s WHERE target_blogpost_id=%s.id' % (Follow._meta.db_table, table_name)},
order_by=('-overall_average', '-fieldsum', '-comments_count', '-followers',)).distinct()
#results.sort(searchComparator, reverse=True)
paginated = paginate(results, page, per_page, max_paging_links)
context = {"query": query, "results": paginated,
"search_type": search_type}
return render(request, template, context)
def test_default_handler_exists(self):
"""
Ensure that the handler specified in default settings exists as well as
the default setting itself.
"""
settings.use_editable()
handler = lambda s: import_dotted_path(s) if s else lambda *args: None
self.assertTrue(handler(settings.SHOP_HANDLER_TAX) is not None)
def forum_post_list(request,
tag=None,
year=None,
month=None,
username=None,
category=None,
template="forum/list.html"):
"""
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.
"""
settings.use_editable()
templates = []
forum_posts = ForumPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
forum_posts = forum_posts.filter(keywords__keyword=tag)
if year is not None:
forum_posts = forum_posts.filter(publish_date__year=year)
if month is not None:
forum_posts = forum_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)
forum_posts = forum_posts.filter(categories=category)
templates.append(u"forum/list_%s.html" % str(category.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
forum_posts = forum_posts.filter(user=author)
templates.append(u"forum/list_%s.html" % username)
prefetch = ("categories", "keywords__keyword")
forum_posts = forum_posts.order_by('-publish_date')
forum_posts = forum_posts.select_related("user").prefetch_related(
*prefetch)
forum_posts = paginate(forum_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {
"forum_posts": forum_posts,
"year": year,
"month": month,
"tag": tag,
"category": category,
"author": author
}
templates.append(template)
return render(request, templates, context)
def search(request, template="search_results.html"):
"""
Display search results.
"""
settings.use_editable()
query = request.GET.get("q", "")
page = request.GET.get("page", 1)
results = paginate(Displayable.objects.search(query), page,
settings.SEARCH_PER_PAGE, settings.MAX_PAGING_LINKS)
context = {"query": query, "results": results}
return render(request, template, context)
def cart(request, template="shop/cart.html",
cart_formset_class=CartItemFormSet,
discount_form_class=DiscountForm,
extra_context=None):
"""
Display cart and handle removing items from the cart.
"""
cart_formset = cart_formset_class(instance=request.cart)
discount_form = discount_form_class(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 = cart_formset_class(request.POST,
instance=request.cart)
valid = cart_formset.is_valid()
if valid:
cart_formset.save()
recalculate_cart(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 = cart_formset_class(instance=request.cart)
cart_formset._errors = errors
else:
valid = discount_form.is_valid()
if valid:
discount_form.set_discount()
# Potentially need to set shipping if a discount code
# was previously entered with free shipping, and then
# another was entered (replacing the old) without
# free shipping, *and* the user has already progressed
# to the final checkout step, which they'd go straight
# to when returning to checkout, bypassing billing and
# shipping details step where shipping is normally set.
recalculate_cart(request)
if valid:
return redirect("shop_cart")
context = {"cart_formset": cart_formset}
context.update(extra_context or {})
settings.use_editable()
if (settings.SHOP_DISCOUNT_FIELD_IN_CART and
DiscountCode.objects.active().exists()):
context["discount_form"] = discount_form
return TemplateResponse(request, template, context)
def search(request, template="search_results.html"):
"""
Display search results.
"""
settings.use_editable()
query = request.GET.get("q", "")
results = Displayable.objects.search(query)
results = paginate(results, request.GET.get("page", 1),
settings.SEARCH_PER_PAGE, settings.SEARCH_MAX_PAGING_LINKS)
context = {"query": query, "results": results}
return render_to_response(template, context, RequestContext(request))
def keywords_for(*args):
"""
Return a list of ``Keyword`` objects for the given model instance
or a model class. In the case of a model class, retrieve all
keywords for all instances of the model and apply a ``weight``
attribute that can be used to create a tag cloud.
"""
if args[0] is None:
return []
# Handle a model instance.
if isinstance(args[0], Model):
obj = args[0]
if hasattr(obj, "get_content_model"):
obj = obj.get_content_model()
# There can only be one ``KeywordsField``, find it.
for field in obj._meta.many_to_many:
if isinstance(field, KeywordsField):
break
else:
return []
keywords_manager = getattr(obj, field.name)
return [a.keyword for a in keywords_manager.select_related("keyword")]
# Handle a model class.
try:
app_label, model = args[0].split(".", 1)
except ValueError:
error = ("The first argument `%s` given for the keywords_for tag "
"must be either a model instance or a model class in the "
"format: app_name.model_name" % args[0])
raise TemplateSyntaxError(error)
content_type = ContentType.objects.get(app_label=app_label, model=model)
assigned = AssignedKeyword.objects.filter(content_type=content_type)
keywords = Keyword.objects.filter(assignments__in=assigned)
keywords = keywords.annotate(item_count=Count("assignments"))
if not keywords:
return []
settings.use_editable()
counts = [keyword.item_count for keyword in keywords]
min_count, max_count = min(counts), max(counts)
sizes = settings.TAG_CLOUD_SIZES
step = (max_count - min_count) / (sizes - 1)
if step == 0:
steps = [sizes / 2]
else:
steps = range(min_count, max_count, step)[:sizes]
for keyword in keywords:
c = keyword.item_count
diff = min([(abs(s - c), (s - c)) for s in steps])[1]
keyword.weight = steps.index(c + diff) + 1
return keywords
def send_order_email(request, order):
"""
Send order receipt email on successful order.
"""
settings.use_editable()
order_context = {"order": order, "request": request,
"order_items": order.items.all()}
order_context.update(order.details_as_dict())
send_mail_template(settings.SHOP_ORDER_EMAIL_SUBJECT,
"shop/email/order_receipt", settings.SHOP_ORDER_FROM_EMAIL,
order.billing_detail_email, context=order_context,
fail_silently=settings.DEBUG)
def save(self, *args, **kwargs):
"""
Create the new user. If no username is supplied (may be hidden
via ``ACCOUNTS_PROFILE_FORM_EXCLUDE_FIELDS`` or
``ACCOUNTS_NO_USERNAME``), we generate a unique username, so
that if profile pages are enabled, we still have something to
use as the profile's slug.
"""
kwargs["commit"] = False
user = super(ProfileForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
username = "******" % self.cleaned_data
if not username.strip():
username = self.cleaned_data["email"].split("@")[0]
qs = User.objects.exclude(id=self.instance.id)
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
elif self._signup:
try:
user.set_unusable_password()
except AttributeError:
# This could happen if using a custom user model that
# doesn't inherit from Django's AbstractBaseUser.
pass
user.save()
# Save profile model.
if self._has_profile:
try:
profile = user.get_profile()
except Profile.DoesNotExist:
profile = Profile(user=user)
profile_fields_form = self.get_profile_fields_form()
profile_fields_form(self.data, self.files, instance=profile).save()
if self._signup:
settings.use_editable()
if (settings.ACCOUNTS_VERIFICATION_REQUIRED or
settings.ACCOUNTS_APPROVAL_REQUIRED):
user.is_active = False
user.save()
else:
token = default_token_generator.make_token(user)
user = authenticate(uidb36=int_to_base36(user.id),
token=token,
is_active=True)
return user
def get_auth_settings():
"""
Returns all the key/secret settings for Twitter access,
only if they're all defined.
"""
from mezzanine.conf import settings
settings.use_editable()
auth_settings = (settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
settings.TWITTER_ACCESS_TOKEN_KEY,
settings.TWITTER_ACCESS_TOKEN_SECRET)
return auth_settings if all(auth_settings) else None
def getDQComments(self): # http://disqus.com/api/docs/posts/list/ # https://github.com/disqus/disqus-python from disqusapi import DisqusAPI from mezzanine.conf import settings settings.use_editable() disqus = DisqusAPI(settings.COMMENTS_DISQUS_API_SECRET_KEY, settings.COMMENTS_DISQUS_API_PUBLIC_KEY) posts = disqus.forums.listPosts(forum='digipal') for post in posts: print post print posts
def tweets_default(*args):
"""
Tweets for the default settings.
"""
settings.use_editable()
query_type = settings.TWITTER_DEFAULT_QUERY_TYPE
args = (settings.TWITTER_DEFAULT_QUERY,
settings.TWITTER_DEFAULT_NUM_TWEETS)
per_user = None
if query_type == QUERY_TYPE_LIST:
per_user = 1
return tweets_for(query_type, args, per_user=per_user)
def default_tax_handler(request, order_form):
"""
Default tax handler - called immediately after the handler defined
by ``SHOP_HANDLER_BILLING_SHIPPING``. Implement your own and
specify the path to import it from via the setting
``SHOP_HANDLER_TAX``. This function will typically contain any tax
calculation where the tax amount can then be set using the function
``cartridge.shop.utils.set_tax``. The Cart object is also
accessible via ``request.cart``
"""
settings.use_editable()
set_tax(request, _("Tax"), 0)
def __init__(self, *args, **kwargs):
super(SettingsForm, self).__init__(*args, **kwargs)
settings.use_editable()
# Create a form field for each editable setting's from its type.
for name in sorted(registry.keys()):
setting = registry[name]
if setting["editable"]:
field_class = FIELD_TYPES.get(setting["type"], forms.CharField)
self.fields[name] = field_class(
label=setting["label"] + ":",
required=False,
initial=getattr(settings, name),
help_text=setting["description"])
def process_request(self, request):
settings.use_editable()
force_host = settings.SSL_FORCE_HOST
if force_host and request.get_host().split(":")[0] != force_host:
url = "http://%s%s" % (force_host, request.get_full_path())
return HttpResponsePermanentRedirect(url)
if settings.SSL_ENABLED and not settings.DEV_SERVER:
url = "%s%s" % (request.get_host(), request.get_full_path())
if request.path.startswith(settings.SSL_FORCE_URL_PREFIXES):
if not request.is_secure():
return HttpResponseRedirect("https://%s" % url)
elif request.is_secure() and settings.SSL_FORCED_PREFIXES_ONLY:
return HttpResponseRedirect("http://%s" % url)
def get_agreement_or_404(request):
settings.use_editable()
request_language = getattr(request, 'LANGUAGE_CODE',
settings.LANGUAGE_CODE)
agreements = {
agreement.language: agreement
for agreement in Agreement.objects.filter(
version=settings.DOWNLOAD_AGREEMENT_VERSION)
}
agreement = agreements.get(request_language, agreements.get('en'))
if not agreement:
raise Http404
return agreement
def search(request, template="search_results.html"):
"""
Display search results.
"""
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
results = Displayable.objects.search(query, for_user=request.user)
paginated = paginate(results, page, per_page, max_paging_links)
context = {"query": query, "results": paginated}
return render(request, template, context)
def event_post_list(request,
tag=None,
year=None,
month=None,
username=None,
category=None,
template="event/event_post_list.html"):
"""
Display a list of event posts that are filtered by tag, year, month,
author or category. Custom templates are checked for using the name
``event/event_post_list_XXX.html`` where ``XXX`` is either the
category slug or author's username if given.
"""
settings.use_editable()
templates = []
event_posts = EventPost.objects.published(for_user=request.user)
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
event_posts = event_posts.filter(keywords__in=tag.assignments.all())
if year is not None:
event_posts = event_posts.filter(publish_date__year=year)
if month is not None:
event_posts = event_posts.filter(publish_date__month=month)
month = month_name[int(month)]
if category is not None:
category = get_object_or_404(EventCategory, slug=category)
event_posts = event_posts.filter(categories=category)
templates.append(u"event/event_post_list_%s.html" %
unicode(category.slug))
author = None
if username is not None:
author = get_object_or_404(User, username=username)
event_posts = event_posts.filter(user=author)
templates.append(u"event/event_post_list_%s.html" % username)
prefetch = ("categories", "keywords__keyword")
event_posts = event_posts.select_related("user").prefetch_related(
*prefetch)
event_posts = paginate(event_posts, request.GET.get("page", 1),
settings.EVENT_POST_PER_PAGE,
settings.MAX_PAGING_LINKS)
context = {
"event_posts": event_posts,
"year": year,
"month": month,
"tag": tag,
"category": category,
"author": author
}
templates.append(template)
return render(request, templates, context)
def category_processor(request, page, extra_context=None):
"""
Add paging/sorting to the products for the category.
"""
settings.use_editable()
products = Product.objects.published(for_user=request.user).filter(
page.category.filters()).distinct()
featured_products = Product.objects.published(
for_user=request.user).filter(
shoppage=True).distinct().order_by('-publish_date')[:4]
sort_options = [(slugify(option[0]), option[1])
for option in settings.SHOP_PRODUCT_SORT_OPTIONS]
sort_by = request.GET.get("sort", sort_options[0][1])
products = paginate(products.order_by(sort_by), request.GET.get("page", 1),
settings.SHOP_PER_PAGE_CATEGORY,
settings.MAX_PAGING_LINKS)
products.sort_by = sort_by
sub_categories = page.category.children.published()
child_categories = Category.objects.filter(id__in=sub_categories)
classes_category = Category.objects.get(slug="shop/classes")
# find prices to display for each product
products_discounts = []
for p in products.object_list:
# create list of tuples, then iterate through them in template
try:
discount = DiscountCode.objects.filter(
title="{}+{}".format(p.sku, request.user.membership.level))[0]
discount_deduction = discount.discount_deduct
except:
discount_deduction = 0
products_discounts.append((p, discount_deduction))
# try:
# discount = DiscountCode.objects.filter(title=request.user.membership.level)[0]
# discount_percent = (100 - discount.discount_percent)/ 100
# except:
# discount_percent = 1
context = {
"products": products,
"featured_products": featured_products,
"child_categories": child_categories,
"classes_category": classes_category,
"products_discounts": products_discounts,
'page_template': 'pages/category_page.html',
}
# print(sort_options)
# if extra_context is not None:
#
# if request.is_ajax():
# template = page_template
# context.update({"template":template})
return context
def default_billship_handler(request, order_form):
"""
Default billing/shipping handler - called when the first step in
the checkout process with billing/shipping address fields is
submitted. Implement your own and specify the path to import it
from via the setting ``SHOP_HANDLER_BILLING_SHIPPING``.
This function will typically contain any shipping calculation
where the shipping amount can then be set using the function
``cartridge.shop.utils.set_shipping``. The Cart object is also
accessible via ``request.cart``
"""
settings.use_editable()
set_shipping(request, _("Flat rate shipping"),
settings.SHOP_DEFAULT_SHIPPING_VALUE)
def test_editable_override(self):
"""
Test that an editable setting is always overridden by a settings.py
setting of the same name.
"""
Setting.objects.all().delete()
django_settings.FOO = "Set in settings.py"
db_value = Setting(name="FOO", value="Set in database")
db_value.save()
settings.use_editable()
first_value = settings.FOO
settings.SITE_TITLE # Triggers access?
second_value = settings.FOO
self.assertEqual(first_value, second_value)
def jobpost_list(request,
tag=None,
year=None,
month=None,
template="careers/jobpost_list.html"):
"""
Display a list of job posts that are filtered by year, month.
"""
settings.use_editable()
templates = []
jobposts = JobPost.objects.published()
if tag is not None:
tag = get_object_or_404(Keyword, slug=tag)
jobposts = jobposts.filter(keywords__in=tag.assignments.all())
if year is not None:
jobposts = jobposts.filter(publish_date__year=year)
if month is not None:
jobposts = jobposts.filter(publish_date__month=month)
month = month_name[int(month)]
# We want to iterate keywords and categories for each blog post
# without triggering "num posts x 2" queries.
#
# For Django 1.3 we create dicts mapping blog post IDs to lists of
# categories and keywords, and assign these to attributes on each
# blog post. The Blog model then uses accessor methods to retrieve
# these attributes when assigned, which will fall back to the real
# related managers for Django 1.4 and higher, which will already
# have their data retrieved via prefetch_related.
jobposts = jobposts.select_related("user")
if VERSION >= (1, 4):
jobposts = jobposts.prefetch_related("keywords__keyword")
else:
if jobposts:
ids = ",".join([str(p.id) for p in jobposts])
keywords = defaultdict(list)
jobpost_type = ContentType.objects.get(app_label="careers",
model="jobpost")
assigned = AssignedKeyword.objects.filter(
jobpost__in=jobposts,
content_type=jobpost_type).select_related("keyword")
for a in assigned:
keywords[a.object_pk].append(a.keyword)
for i, post in enumerate(jobposts):
setattr(jobposts[i], "_keywords", keywords[post.id])
jobposts = paginate(jobposts, request.GET.get("page", 1),
settings.CAREERS_PER_PAGE, settings.MAX_PAGING_LINKS)
context = {"jobposts": jobposts, "year": year, "month": month, "tag": tag}
templates.append(template)
return render(request, templates, context)
def clean_tipologies(self):
"""
Additional validation for 'tipologies' field. If the number of
tipologies selected is greater than
'OPENHELPDESK_MAX_TIPOLOGIES_FOR_TICKET' setting, raise an ValidationError
"""
settings.use_editable()
max_tipologies = settings.OPENHELPDESK_MAX_TIPOLOGIES_FOR_TICKET
tipologies = self.cleaned_data['tipologies']
if len(tipologies) > max_tipologies:
msg = _('Too many tipologies selected. You can select a maximum'
' of %(max)s.') % {'max': max_tipologies}
raise ValidationError(msg, code='too_many_tipologies')
return self.cleaned_data['tipologies']
def blog_post_list(request,
tag=None,
year=None,
month=None,
username=None,
category=None,
template="blog/blog_post_list.html"):
"""
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.
"""
settings.use_editable()
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=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)
month = month_name[int(month)]
if category is not None:
category = get_object_or_404(BlogCategory, slug=category)
blog_posts = blog_posts.filter(categories=category)
templates.append("blog/blog_post_list_%s.html" % 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("blog/blog_post_list_%s.html" % username)
blog_posts = paginate(blog_posts, request.GET.get("page", 1),
settings.BLOG_POST_PER_PAGE,
settings.BLOG_POST_MAX_PAGING_LINKS)
context = {
"blog_page": blog_page(),
"blog_posts": blog_posts,
"year": year,
"month": month,
"tag": tag,
"category": category,
"author": author
}
templates.append(template)
request_context = RequestContext(request, context)
t = select_template(templates, request_context)
return HttpResponse(t.render(request_context))
def category_processor(request, page):
"""
Add paging/sorting to the products for the category.
"""
settings.use_editable()
products = Product.objects.published(for_user=request.user).filter(
page.category.filters()).distinct()
sort_options = [(slugify(option[0]), option[1])
for option in settings.SHOP_PRODUCT_SORT_OPTIONS]
sort_by = request.GET.get("sort", sort_options[0][1])
products = paginate(products.order_by(sort_by), request.GET.get("page", 1),
settings.SHOP_PER_PAGE_CATEGORY,
settings.MAX_PAGING_LINKS)
products.sort_by = sort_by
return {"products": products}
def test_editable_override(self):
"""
Test that an editable setting is always overridden by a settings.py
setting of the same name.
"""
Setting.objects.all().delete()
django_settings.SITE_TAGLINE = "This tagline is set in settings.py."
db_tagline = Setting(name="SITE_TAGLINE",
value="This tagline is set in the database.")
db_tagline.save()
settings.use_editable()
first_tagline = settings.SITE_TAGLINE
settings.SITE_TITLE
second_tagline = settings.SITE_TAGLINE
self.assertEqual(first_tagline, second_tagline)
def visible(self):
"""
Return the comments that are visible based on the
``COMMENTS_XXX_VISIBLE`` settings. When these settings
are set to ``True``, the relevant comments are returned
that shouldn't be shown, and are given placeholders in
the template ``generic/includes/comment.html``.
"""
settings.use_editable()
visible = self.all()
if not settings.COMMENTS_UNAPPROVED_VISIBLE:
visible = visible.filter(is_public=True)
if not settings.COMMENTS_REMOVED_VISIBLE:
visible = visible.filter(is_removed=False)
return visible
def handle(self, *apps, **options):
settings.use_editable()
mc = Mailchimp(settings.MAILCHIMP_API_KEY)
result_list = mc.lists.list(filters={})
# result_list = mc.lists.list(filters={'list_name': 'list_2'})
print(result_list)
for mc_list in result_list['data']:
result_members = mc.lists.members(mc_list['id'])
pprint.pprint(result_members)
result_info = mc.lists.member_info(
mc_list['id'], [{
'email': '*****@*****.**'
}])
print("***********************")
pprint.pprint(result_info)
def keywords_for(*args):
"""
Return a list of ``Keyword`` objects for the given model instance
or a model class. In the case of a model class, retrieve all
keywords for all instances of the model and apply a ``weight``
attribute that can be used to create a tag cloud.
"""
# Handle a model instance.
if isinstance(args[0], Model):
obj = args[0]
if hasattr(obj, "get_content_model"):
obj = obj.get_content_model() or obj
keywords_name = obj.get_keywordsfield_name()
keywords_queryset = getattr(obj, keywords_name).all()
# Keywords may have been prefetched already. If not, we
# need select_related for the actual keywords.
prefetched = getattr(obj, "_prefetched_objects_cache", {})
if keywords_name not in prefetched:
keywords_queryset = keywords_queryset.select_related("keyword")
return [assigned.keyword for assigned in keywords_queryset]
# Handle a model class.
try:
app_label, model = args[0].split(".", 1)
except ValueError:
return []
content_type = ContentType.objects.get(app_label=app_label, model=model)
assigned = AssignedKeyword.objects.filter(content_type=content_type)
keywords = Keyword.objects.filter(assignments__in=assigned)
keywords = keywords.annotate(item_count=Count("assignments"))
if not keywords:
return []
settings.use_editable()
counts = [keyword.item_count for keyword in keywords]
min_count, max_count = min(counts), max(counts)
sizes = settings.TAG_CLOUD_SIZES
step = (max_count - min_count) / (sizes - 1)
if step == 0:
steps = [sizes / 2]
else:
steps = range(min_count, max_count, step)[:sizes]
for keyword in keywords:
c = keyword.item_count
diff = min([(abs(s - c), (s - c)) for s in steps])[1]
keyword.weight = steps.index(c + diff) + 1
return keywords
def __init__(self, *args, **kwargs):
"""
Use the title and description of the Blog page for the feed's
title and description. If the blog page has somehow been
removed, fall back to the ``SITE_TITLE`` and ``SITE_TAGLINE``
settings.
"""
super(PostsRSS, self).__init__(*args, **kwargs)
page = blog_page()
if page is not None:
self.title = page.title
self.description = strip_tags(page.description)
else:
settings.use_editable()
self.title = settings.SITE_TITLE
self.description = settings.SITE_TAGLINE
def settings(request):
"""
Add the settings object to the template context.
"""
settings_dict = None
if cache_installed():
cache_key = cache_key_prefix(request) + "context-settings"
settings_dict = cache_get(cache_key)
if not settings_dict:
from mezzanine.conf import settings
settings.use_editable()
settings_dict = dict([(k, getattr(settings, k, ""))
for k in settings.TEMPLATE_ACCESSIBLE_SETTINGS])
if cache_installed():
cache_set(cache_key, settings_dict)
return {"settings": type("Settings", (), settings_dict)}
def generate_short_url(self):
"""
Returns a new short URL generated using bit.ly if credentials for the
service have been specified.
"""
from mezzanine.conf import settings
settings.use_editable()
if settings.BITLY_ACCESS_TOKEN:
url = "https://api-ssl.bit.ly/v3/shorten?%s" % urlencode({
"access_token": settings.BITLY_ACCESS_TOKEN,
"uri": self.get_absolute_url_with_host(),
})
response = loads(urlopen(url).read().decode("utf-8"))
if response["status_code"] == 200:
return response["data"]["url"]
return SHORT_URL_UNSET
