Have you always been annoyed by how you set up this elaborate big database schema and weren't able to have **ON DELETE CASCADE ON UPDATE CASCADE** in dbshell?
This solves the problem; create the two files and and empty *__init__.py* and put them somewhere in your path.
Then say DATABASE_ENGINE='postgresql_psycopg2_cascade' in settings.
Really I'd like this to be in the ForeignKey object, were it upstream Django or an own version of it, but it doesn't seem possible.
Ideas on how to make this configurable are more than welcome!
Props go out to Ari Flinkman for the inspiration to do this!
The counter initializes the variable to 0, and next it increments one by one:
{% load counter_tag %}
{% for pet in pets %}
{% if pet.is_cat %}
{% counter cats %}
{% else %}
{% counter dogs %}
{% endif %}
{% endfor %}
# cats: {{cats}}
# dogs: {{dogs}}
This is a basic view for exporting data from models. It is designed so that you can provide the GET variables used for searching/filtering within listdisplay pages in the admin, and the code will filter the same way.
It allows ouputting of model data in various formats using serializers.
This should be used as a urlpattern through get_url, so that you can use the admin_view decorator to properly secure the data.
I don't understand why the cache is accumulated between the tests. I thought one of the axioms of unit testing is that the tests should not affect each other.
Couldn't find anything that explains why it's done this way but it seems a bit strange. Anybody know if there's a reason or is this a reason for me to upload a patch to Django code?
Say you have a ModelChoiceField and you want the choices to depend on the value of another field in the form... that's what these bits are for.
They need to be used in conjunction with the Ajax views from:
[code.google.com/p/django-ajax-filtered-fields/](http://code.google.com/p/django-ajax-filtered-fields/)
See my blog for full details:
[anentropic.wordpress.com](http://anentropic.wordpress.com)
...um, this is work in progress and the explanatory blog post is not up yet...
This template filter converts email text to image with the email text. It uses PIL and it makes the image as high and wide as the text.
This template filter is intended to be used as **anti-spider** protection.
Sometimes it is useful to have a ChoiceField which calculates its choices at runtime, when a new instance of a form containing it, is generated. And this is what `LazyChoiceField` does.
The `choices` argument must be an *iterable* as for `ChoiceField`.
**Usage example**
from django import forms
DynamicApplicationList = []
class MyForm(forms.Form):
dynamic_choice = LazyChoiceField(choices = DynamicApplicationList)
`DynamicApplicationList` can now be updated dynamically.
This command, `runtester` will run the test suite whenever files are modified. It takes the apps to test as arguments; if no apps are given the entire test suite is run.
Use this command just as `runserver` is used; fire it up in a shell and it does its thing.
Copy this snippet into `django/core/management/commands/runtester.py`.
put this code into your application's `__init__.py`
it adds a mixin to the `Paginator` class that implements a digg style pagination. the mixin has just one method called `digg_page_range` that takes the current page object as the parameter. this method is an iterator which yields page numbers with `None` values representing gaps. this iterator is similar to the original paginator's method `page_range` and it can be used in your code to emit the needed markup.
You can use `UrlModel` to provide URL functionality to any instance of any model and any language (language support can be removed from this). Each model must have own view method, that returns HttpResponse. I was inspired by Flatpages. It is useful for small sites and static pages.
`class Page(UrlModel):
text = models.TextField()
def view(self, request)
# do something here
return HttpResponse(...)`
If you request static files such as images, javascript or css using http rather than https, the browser will complain that your site is not secure.
This simple context processor will replace http:// with https:// in your MEDIA_URL if your static files are being included from an https page.
In your settings.py just replace 'django.core.context_processors.media' with your new context processor.
This get_sorted_items tag takes app.model, a number n, a a field name to sort ,and a variable-name as arguments and will deliver the n first objects of the model.
it checks if a Manager *publicmgr* exists and calls this if the user isn't authenticated.
Additionally it write the count of the model to the context
A decorator that can be applied to your views to turn ObjectDoesNotExist exceptions into Http404 exceptions. This means people will see a "Page not found" error rather than an "Internal Server Error" when they are request something that does not exist in the database.
Example:
@raise_404
def show_event(request, id):
event = Event.objects.get(id)
return render_to_response('events/show_event.html', { 'event' : event })
This Template Tag computes the font-size of two given arguments and returns a CSS-encoded string like "font-size: XXpx;", which can be used to format the font-size of link. (The minium font-size must be set with CSS.)
Requires two arguments:
1. occurrence of the current tag
2. sum of all occurrences
It works great for my tag-cloud.
[Source of the logarithmic formula](http://www.php.de/php-fortgeschrittene/44928-tag-cloud-algorithmus-fuer-schriftgroessye.html)
**Usage**
`<a href="http://www.anything.com" {% cloudify variable.occurrence overall. occurrence_sum %} title="anything">any tag</a>`
You're looking at the top-rated snippets currently on the site; if you'd like to contribute, sign up for an account and you'll be able to rate any snippet you see.