Iraniblog

Was having trouble finding the language abbreviations everyone was using with localization. Apparently it’s a standard: ISO 639-1

Also when setting up localization you need to create a ‘locale’ folder. The location is your choice.
Then add one by one the locales from the same level as where your locale folder is. So if ‘locale’ is in app
app/$ django/bin/make-messages.py -l en

To update the ‘.po’ files later run:
app/$ django/bin/make-messages.py -a

To build the object files (‘.mo’) run:
app/$ django/bin/compile-messages.py

To: /etc/apache2/httpd.conf
Add:

<Location "/">
SetHandler python-program
PythonHandler django.core.handlers.modpython
SetEnv DJANGO_SETTINGS_MODULE <project>.settings
PythonDebug On
PythonPath "['/parent', '/parent/project'] + sys.path"
</Location>


I found the instructions a bit confusing on the site. So I hope this clears up things a bit. My thought is they think the setup for live systems and where those files reside is different in the minds of the developers although that pathway isn’t really brought to light in the docs. It’s kind of hinted at, but here it goes.

In order to get my project up on Apache I had to include both the path for my project as well as its parent. The reason being is that it needs to be able to tie into your settings.py file and wants to know the project that’s a part of. In order to get that relationship it needs the folder of the project itself. I also added the path for the project so that it could tie into the applications.

What this means.
Replace <project>: with the name of your project
Replace /parent:  with the directory of the parent directory to your project
Replace /parent/project: with the directory of your project
Save the file and then restart apache:

apache2ctl restart

Go to the shell and navigate to a directory that you want to leave the Django codebase. then enter the following code to check out the current codebase from Django:
svn co http://code.djangoproject.com/svn/django/trunk/ django-trunk

Next you will need to make a symbolic link to the Django codebase:

sudo ln -s `pwd`/django-trunk/django/ /usr/lib/python2.5/site-packages/django


Link to django-admin, which is used to create Django projects:

sudo ln -s `pwd`/django-trunk/django/bin/django-admin.py /usr/local/bin


Make sure not to use regular apostrophes around pwd or else you could run into an error with your libraries.  I was getting this error (since the mapping was going to the wrong place)
Traceback (most recent call last):

File "manage.py", line 2, in <module>
from django.core.management import execute_manager
ImportError: No module named django.core.management


Django registration

svn checkout http://django-registration.googlecode.com/svn/trunk/registration/ registration/
sudo ln -s `pwd`/registration /usr/lib/python2.5/site-packages/registration


Within my Django project I wanted to have a page within the site for example “/page”. For that site I want there to be an optional value the page can take. So any of the following examples are acceptable: “/page/1″, “/page/2″, “/page”

There are two ways to do this.

First way (which is probably the right way) is to use the urls.py to handle this logic, like this:


(r'^pages/$', 'my_messages', {'page': page}),
(r'^pages/(\d*)$', 'my_messages'),


The other way is to handle it within the view with the following check:

if page == u'':


While putting a site together I was trying to clean up the code a bit and insert a piece of logic in a couple places. In some frameworks this concept is called a “component.” Regardless, I found out that Django had this thing called an Inclusion Tag. Which allows you to insert the output from a function/template pair into another template.

The resources online confused me a bit, so here’s the summary of what you need to do.

First create a folder named “templatetags” within your application’s directory. Within that folder you will need to add two files, one named “__init__.py” and the other the name of your tags, I’ve named it “tags.py”. This name is important since it will be the way you call this piece of code. You will also need to add a template for this “component”, I named mine “temp_mesages.html”

The tags.py file looks like this:

from lamalo.microBlogApp.models
import Message Profile
from django import template

register = template.Library()

@register.inclusion_tag('temp_messages.html')
def show_messages(userProfile):
message_list = Message.objects.filter(profile=userProfile).order_by('-timestamp')[:5]
return {'message_list': message_list}

temp_messages.html looks like this

{% for message in message_list %}
<table border="1" width="100%">
<tr>
<td>{{ message.timestamp|date:"F j, Y h:i:s A" }}: {{ message.text }}</td>
</tr>
</table>
{% endfor %}

Now the code is ready to be used… The way that you make use of it is by first loading the tags.py by calling ‘load tags’ and then calling the function. This code goes within one of your templates:

{% load tags %}
{% show_messages userProfile %}