1. First download jQuery and put it in your MEDIA_ROOT or use Google’s AJAX Libraries API:http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js
2. Next, download WYMeditor and put it in your MEDIA_ROOT
3. Create a JavaScript file “fancyedit.js” with the following Javascript code:// fancyedit.js
$(document).ready(function() {
  $("#id_FIELDNAME").wymeditor({ // "FIELDNAME" is the name of the field you want to give the wysiwyg features
    updateSelector: "input:submit",
    updateEvent: "click"
  });
});
4. Now we have to make sure that the correct JavaScript is loaded when a model has a rich text editor field:import settings
media = settings.MEDIA_URL
class FooAdmin(admin.ModelAdmin):
  class Media:
    js = ('http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js', media+'/js/wymeditor/jquery.wymeditor.js', media+'/js/editor.js')

That should be it!

class Foo(models.Model):
    a = models.CharField(max_length=10)

def get_foo():
    return Foo.objects.get(id=1)

class Bar(models.Model):
    b = models.CharField(max_length=10)
    a = models.ForeignKey(Foo, default=get_foo)

Hope this helps someone (I’ve been looking for this quite some time…). If anyone know a better/neater way, please let us know in the comments!!

Justin Bronn (djangopeople.net/jbronn/), the lead developer of GeoDjango was kind enough to point me in the right direction. I thought I share the concept here as it might be helpful to someone:

Define the function:

def get_random_point(extent):
   xrange = extent[2] - extent[0]
   yrange = extent[3] - extent[1]
   randx = xrange * random.random() + extent[0]
   randy = yrange * random.random() + extent[1]
   return Point(randx, randy)

And then:

extent = mpoly.extent
pnt = get_random_point(extent)
while not mpoly.contains(pnt):
   pnt = get_randomPoint(extent)

Let me know what you think or if you’ve got any improvements!

If you use the following statement in you code:
import pdb; pdb.set_trace()

You can debug you app by running the server with the python command
manage.py runserver -p 8888

Then, after you visit the page where the set_trace() function is called, the server will break the code execution. If you then go to your terminal window, it will show you a prompt, at which you can go throught your code and variables.

Pretty good stuff!!

After exchanging some mails with the Webfaction support team (which is absolutely awesome by the way: very helpfull and best response time i’ve seen!) I got it working! Thought I’d share the problem and the solution and might help save someone some frustration.

The problem:

I could not access the site when I tried the following in my httpd.conf:
(xxx.xxx.xxx.xxx being the IP I wanted to grant access to)

…
<Location "/">
Order Deny,Allow
Deny from all
Allow from xxx.xxx.xxx.xxx
…

I found the following line in my error_log:
[Fri Oct 03 06:10:47 2008] [error] [client 127.0.0.1] client denied by server configuration


This made something clear to me: Webfaction uses the apache2 webserver on a custom port, and the main webserver forwards the request through to the Django site. This works great but the problem here is that all the requests appear to be from 127.0.0.1 so I can’t exclude any ip’s in the httpd.conf file.

The solution

The solution is to use the Apache setenvif_module module to check for which ip the request was forwarded. Here’s part of an example httpd.conf file:
. . .
LoadModule authz_host_module modules/mod_authz_host.so
LoadModule setenvif_module modules/mod_setenvif.so
…
<Location "/">

Order Deny,Allow
Deny from all
Allow from env=allowed_ip
…

If you got any questions about this, please use the comments below. If you’re looking for a good Django host for a reasonable price check out Webfaction !

The old way of connecting to a signal was:
dispatcher.connect(myFunction, signal=models.signals.post_save, sender=myModel)

The new way is:
models.signals.pre_save.connect(myFunction, sender=myModel)

So when you want to send an email whenever there’s a new comment posted by someone, without changing existing code you will have to do something like this:

from django.contrib.comments.models import Comment
from django.core.mail import send_mail
from django.db.models import signals

def mail_comment(instance, **kwargs):
subject = 'subject of the mail'
msg = 'Comment text:\n\n%s' % instance.comment
send_mail(subject, msg, 'noreply@djangodays', ['email@djangodays.com'])

signals.post_save.connect(mail_comment, sender=Comment)

If you put this code in your __init__.py file it should work fine. Putting this in there is probably not the Django way of doing things, but I’m not sure where to put it instead… I anyone found a better way of doing this, please share it in the comments!

http://www.mercurytide.co.uk/whitepapers/django-cheat-sheet/

Caught an exception while rendering: Reverse for '' not found.

After some searching I read somewhere I had to delete the old .pyc files (from before the Django upgrade). After doing that, everything worked as it should!

Also, make sure you have the right path in your urls.py:
(r'^comments/', include('django.contrib.comments.urls')),

Hope this is usefull to anyone!

Django allows you to create a models.py file based on an existing database. To do this, you first have to make sure your database settings are properly specified in the settings.py file. Here’s an example of what the database settings in your settings.py file should look like:
DATABASE_ENGINE = ‘mysql’ # ‘postgresql_psycopg2′, ‘postgresql’, ‘mysql’, ’sqlite3′ or ‘oracle’.
DATABASE_NAME = ‘YourDataBaseName’ # Or path to database file if using sqlite3.
DATABASE_USER = ‘YourDataBaseUser’ # Not used with sqlite3.
DATABASE_PASSWORD = ’YourVerySecretPassword’ # Not used with sqlite3.
DATABASE_HOST = ” # Set to empty string for localhost. Not used with sqlite3.
DATABASE_PORT = ” # Set to empty string for default. Not used with sqlite3.

Then, from the command line, type:

python mysite/manage.py inspectdb > mysite/myapp/models.py

That should be all! Django created a models.py for you, based on the contents of the existing database.