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