Beardy Geek » Web Development

Django Training in the UK

BeardyGeek — Fri, 30 Jul 2010 21:48:02 +0000

In Autumn 2010 I will be running several Django courses throughout the UK. The dates and locations will be based on demand, so please signup here to express your interest, and I’ll contact you when the venues have been arranged.

There will be 2 different types of courses:

Django template design – 1 day – for html/css coders who need to be able to fashion a template around the data being passed through by Django
Django introduction for programmers – 2 days – for those with web development experience who want to hit the ground running.

The cost will be around the £200 per day mark. I’ll publish more firm details soon.

New Django Site – Blog Twin

BeardyGeek — Tue, 18 May 2010 22:30:08 +0000

I created Blog Twin after reading a blog post by Viper Chill entitled The Secret to growing your blog twice as fast with half the effort, I decided to create a site that would help people find a blogging partner.

Blog Twin is written in Django (naturally!). You register, add details of your blog, and wait for someone else to come along and find you. Or you can browse through and try and find a site in a similar niche with similar stats to you.

There’s also the ability to tag entries, and filter by the tags.

It’s still a very early beta (I only started doing it 2 days ago), so any feedback, or bug reports, are most welcome.

Enjoy!

Website Stress testing using JMeter

BeardyGeek — Wed, 31 Mar 2010 13:33:54 +0000

Here’s my latest screencast, showing you how to stress test your website and web applications using JMeter.

www.youtube.com/watch?v=8NLeq-QxkSw

Adding Views to the Django Admin

BeardyGeek — Fri, 26 Mar 2010 11:01:19 +0000

I recently had to write a view that exported data to csv. The view had to be contained within the Django admin area, on a separate page from the rest of the apps and models. Here is the approach I took.

The Urls

There are 2 ways to add urls to the admin: the quick and easy way, or the not so quick and easy way. In this case, as I was only adding a single url, I went for the quick and easy way. The other way involves extending the get_urls() method of AdminSite, adding to the existing admin url pattern. I did this:


(r'^admin/mypage/$', 'myapp.views.my_admin_view'),
(r'^admin/', include(admin.site.urls)),

Make sure you add your page before the main admin include.

The View

When you write your view make sure you use the staff_member_required decorator.


from django.contrib.admin.views.decorators import staff_member_required
...
@staff_member_required
def my_admin_view(request):
    # view code

When rendering your view, also make sure you pass RequestContext to the template:


return render_to_response('my_template.html',
  context_instance=RequestContext(request))

The Template

So that your view looks like it belongs in the admin area, you need to extend the admin base site template:


{% extends 'admin/base_site.html' %}

You’ll also want to add in i18n support, and the admin media:


{% load i18n adminmedia %}

If you want to add in extra styles you can use {% block extrastyle %}, and you could put javascript in {% block extrahead %}.

Adding form date widgets

If you have a form on your page that includes date fields, you might want to have the nice django javascript form widgets. First you need to add the widgets to your form:


from django.contrib.admin import widgets

class AdminForm(forms.Form):
    start_date = forms.DateField(label="Start date",
         widget=widgets.AdminDateWidget())

Next you need to add in the following to your extrahead block (replace admin-media with whatever you’ve set your admin media url to):




{{ form.media }}

You also need to add the admin forms css in the extrastyles block:


{{ block.super }}

Breadcrumbs

If you want to have the breadcrumb trail at the top of the page, you need to create your own breadcrumb:


{% block breadcrumbs %}
{% trans "Home" %} > My View{% endblock %}

Adding a link to the admin index

When I add a link in, I like it to go in one of the right column boxes, so I usually create a new one and put it above the recent actions box. To do this, you need to override the admin index.html file.

Create a directory in your templates directory called admin. Then copy the index.html file from django/contrib/admin/templates to your new directory.

You’ll see a block called ’sidebar’. Under the ‘content-related’ div, place the following:



  Admin tools
    
      
        My View

Enjoy!

New Django Site – The Great British Sleep Survey

BeardyGeek — Wed, 24 Mar 2010 20:05:29 +0000

I’ve very recently finished a django based site for a company called Sleepio. The project was to create a survey site, called the Great British Sleep Survey. Once completed, it calculates your sleep score and creates a report tailored to your issues (or lack of).

Also working on the site, doing all the xhtml and css magic was Rui Zhang from borderleft. If you ever need anyone to turn your designs into an actual web site, he’s your man. Thanks Rui.

One of the co-founders of Sleepio is Professor Colin Espie, who runs the sleep centre at Glasgow University. The site is also a collaboration with Boots Web MD, which offers health and medical advice.

So check it out, complete the survey (you get a free sleep report!), and any feedback is always welcome.

Django Tips – Unique Date Querysets

BeardyGeek — Sun, 15 Feb 2009 18:50:26 +0000

I swear this particular feature of querysets was made especially for the archive listing of a blog. You know, the month and year listing in the side bar for all your previous posts. This solves that problem exactly.

Let’s say you have a BlogPost model, and a post_date field within said model. You want a list on the sidebar of all the unique month and year combinations. Here’s what you do:


queryset = BlogPost.objects.dates('post_date', 'month')

And that’s it. You’ll now have a query set full of datetime objects with all your unique months and years.

To get unique years only, substitute ‘year’ for ‘month’, and for unique day, month and year, substitute ‘day’ for ‘month’.

From Wordpress to Django – Part 2

BeardyGeek — Tue, 27 Jan 2009 18:59:08 +0000

View Part 1
Beardy Geek Git Hub Repository

Welcome back. In part 2 I’ll be getting to the meat of the issue, which is retrieving the data from an existing Wordpress blog, and feeding the data into my own models.

Models

I’ve decided to start the models from scratch, rather than trying to copy the way Wordpress has laid them out. It should keep things simpler that way. I’ll be using the contrib comments system for the post comments, and I’ll also be creating 3 other models, Category, Tag, and Post. Here’s the code for the models:


from django.db import models
from django.contrib.auth.models import User
from datetime import datetime

POST_STATUS = (
               ('P', 'Published'),
               ('U', 'Unpublished'),
)

class Tag(models.Model):
    text = models.CharField(max_length=75)
    slug = models.CharField(max_length=75)

    def __unicode__(self):
        return self.text

class Category(models.Model):
    text = models.CharField(max_length=75)
    slug = models.CharField(max_length=75)

    def __unicode__(self):
        return self.text

    class Meta:
        verbose_name_plural = "categories"

class Post(models.Model):
    title = models.CharField(max_length=75)
    slug = models.CharField(max_length=75)
    content = models.TextField()
    author = models.ForeignKey(User)
    post_date = models.DateTimeField(default=datetime.now)
    status = models.CharField(max_length=1, choices=POST_STATUS)
    categories = models.ManyToManyField(Category)
    tags = models.ManyToManyField(Tag)

    def __unicode__(self):
        return self.title

Wordpress Export

Just a quick note: I am using Wordpress Version 2.6.1. Things may be different in other versions, but the code here works on this version. I’ll go through the code so you should see where the problem is if it doesn’t work with your version.

OK, if you didn’t already know, you can export all your Wordpress data into an xml file. Go to your dashboard, click ‘Manage’, and then ‘Export’. Select which authors to restrict (if any) and hit the download button. You should now have the data in an xml file.

XML File Editing

When I first tried to parse this file, I got an error as one of the namespaces used in the document is undeclared. To rectify this, you need to open up the file in a text editor (not an xml editor, you may get the same parse error). Near the top of the file, you should see something like this:

The missing namespace is ‘excerpt’, and we need to add this. It doesn’t matter what value you give it. I did this:

Save the file and we’re ready to start parsing the data.

XML Parsing

To parse the XML I have used ElementTree. This is included in Python 2.5, but if you’re using an earlier version, you can get ElementTree from Effbot.org.

I won’t include all the code here, just some snippets as examples. To view the full source, please check out the BeardyGeek Github Repository.

First we need to load our xml file.


tree = ElementTree.parse('c:/wordpress.xml')

Then find the top level under which our data resides, which is the ‘channel’ tag.


chan = tree.find('channel')

Now I want to create some shortcut variables for the namespaces that we will use when finding tags.


wp_ns = '{http://wordpress.org/export/1.0/}'
content_ns = '{http://purl.org/rss/1.0/modules/content/}'

Now we can get all the category, tag and item(post) entries:


cats = chan.findall('{http://wordpress.org/export/1.0/}category')
tags = chan.findall('{http://wordpress.org/export/1.0/}tag')
items = chan.findall('item')

This will give us lists of all the elements for those three items.

Finding and Saving Data

I’ll give an example of saving the data using the category tag.


for cat in cats:
        c = Category(text=cat.find(wp_ns + 'cat_name').text,
                 slug=cat.find(wp_ns + 'category_nicename').text)
        c.save()

The tag data is the same as the above.

The item data is a bit more complex. If you look at the xml you’ve exported, you’ll see that the item data includes both posts and pages. But it also gives all previous revisions of each post, which will include any drafts saved whilst writing a post. So we need to find all those with a status of ‘publish’ and a page type of ‘post’. We’ll deal with the ‘page’ data another time, using Flatpages.


if item.find(wp_ns + 'status').text == 'publish' and
               item.find(wp_ns + 'post_type').text == 'post':
            i = Post(title=item.find('title').text,
                     slug=item.find(wp_ns + 'post_name').text,
                     content=item.find(content_ns + 'encoded').text, author=u,
                     post_date=item.find(wp_ns + 'post_date').text,
                     status='P')
            i.save()

The ‘u’ (value for author) is a User object I create earlier in the code that I’ve used as the default author of each post (see source).

Post Categories

Now we have to find out which categories and tags this post has. Within each ‘item’ we have ‘category’ data. A bit confusingly this ‘category’ data also includes the tags, and to discover that you need to look at the ‘domain’ attribute to see which it is. Plus we only need the category with the ‘nicename’ in it (slugified).


post_cats = item.findall('category')

for pc in post_cats:
     #check for attributes
     if pc.get('nicename'):
         if pc.attrib['domain'] == 'category':
              c2 = Category.objects.get(slug=pc.attrib['nicename'])
              i.categories.add(c2)
         elif pc.attrib['domain'] == 'tag':
              t2 = Tag.objects.get(slug=pc.attrib['nicename'])
              i.tags.add(t2)

Comments

The last section deals with comments. I am using the django.contrib.comments module for this.



comments = item.findall(wp_ns + 'comment')
for comm in comments:

    if not comm.find(wp_ns + 'comment_author_email').text:

        comm_email = ''

    else:

        comm_email = comm.find(wp_ns + 'comment_author_email').text
        if not comm.find(wp_ns + 'comment_author_url').text:

            comm_url = ''

        else:

            comm_url = comm.find(wp_ns + 'comment_author_url').text
        db_comm = Comment(comment=comm.find(wp_ns + 'comment_content').text,

            ip_address=comm.find(wp_ns + 'comment_author_IP').text,

            object_pk=i.id, submit_date=comm.find(wp_ns + 'comment_date').text,

            user_email=comm_email,

            user_name=comm.find(wp_ns + 'comment_author').text[:50],

            user_url=comm_url,

            content_type=ct, site=site)

        db_comm.save()





Conclusion
Well that wraps it up for this post. I'll cover extracting the data for Flatpages in the next post, but this should give you enough to get started. You can see how to extract the required data from the xml document, so if you want to extend the models beyond what I have, you shouldn't have any problems.  Again, check out the fully code, plus the other file changes (url.py etc) at the Beardy Geek Git Hub Repository. Have fun.

From Wordpress to Django – Part 1

BeardyGeek — Wed, 14 Jan 2009 18:55:00 +0000

Now don’t get me wrong, there’s nothing wrong with Wordpress. It’s just that I like to play with stuff, so I thought it would be fun to create a blog in Django, copy all my Wordpress posts across, and add at least some of the functionality that Wordpress has built in.

Open Source

Throughout this process, so that you can follow along, I will be storing the code in a GitHub repository. Click here to view the BeardyGeek repository

A Few Considerations

There are a few things to think about before getting started:

Data Conversion – getting the data from Wordpress into my Django models. Do I want to keep the same database structure as Wordpress, or create my own? If I create my own, how will I get the data across?
Services – how much do I try and implement? The main ones are comments, tags, pings, anti-spam.

I’m sure more will come to mind as I go through this

Conclusion

Well, I’d better stop jabbering and get on with it then! Keep an eye on the blog, or watch the Git repo for updates. I’ll get done whatever my current workload allows.

How to Call a .Net Webservice using Python

BeardyGeek — Thu, 01 Jan 2009 12:51:46 +0000

My day job involves working with software that automatically creates webservices on the .Net platform. Up until now I have used C# to create web applications to use these webservices.

But it would be nice to have the flexibility to use another programming language to create a solutions, and consume the webservices from there.

So, here’s a short tutorial on calling your .net webservice using Python.

Pre-requisites

I’m currently using Python 2.5, so I can’t speak for other versions
You will need the ElementSoap package from effbot.org. You can get it from here
You’re also going to need a .Net webservice with which to test this out. If you’re reading this tutorial, you probably already have one.

SOAP

Firstly we need to look at the SOAP examples on your .Net webservice. Go your webservice’s asmx page, and then click on one of your webservices to view the details. You will see some example SOAP requests and responses. The one we’re interested in here is SOAP 1.1. Mine looks like this:


POST /lookserver/webservices.asmx HTTP/1.1
Host: localhost
Content-Type: text/xml; charset=utf-8
Content-Length: length
SOAPAction: "http://tempuri.org/GetVersion"



  
    
  


HTTP/1.1 200 OK
Content-Type: text/xml; charset=utf-8
Content-Length: length



  
    
      string

As we can see here, I have a webservice called GetVersion, the namespace is http://tempuri.org, and the SOAPAction is http://tempuri.org/GetVersion. Note these down for your webservice.

Into the Python

Fire up an interactive session, and we’ll go through calling this service.

Firstly we need to import the ElementSOAP library:

from elementsoap import ElementSOAP as ES

If you get an error message, then you haven’t installed ElementSoap properly.

Next we create a SoapRequest:

sr = ES.SoapRequest("{http://tempuri.org/}GetVersion")

And now we initialize a SoapService object:

serv = ES.SoapService("http://localhost/lookserver/webservices.asmx")

Obviously put in your own url for your webservice.

Now we call the webservice, using the SOAPAction value:

result = serv.call("http://tempuri.org/GetVersion", sr)

The result is an xml element which should contain the response from your webservice. When I type result I get:

If you look at the xml at the top of the article, you’ll see that the result returns inside a GetVersionResponse tag. To get the value of the result we type:

result.find("{http://tempuri.org/}GetVersionResult").text

This finds the appropriate tag, and returns the text.

Conclusion

I hope this has helped. When I searched, I found that the other tutorials were either confusing, or out of date. Take a look at the various libraries at effbot.org, especially ElementTree for parsing XML, very useful. Enjoy!

Django and Ajax – using Prototype and Scriptaculous

BeardyGeek — Fri, 12 Dec 2008 18:53:00 +0000

I started adding a sprinkling of Ajax in one of my Django projects, so I thought I’d share a few snippets that might help you add some Ajax goodness into your app.

To handle the Ajax callbacks, I’ll be using Prototype, a lightweight Ajax library. And for a couple of effects, like fade-in, I’ll be using Scriptaculous.

Ajax Voting

I wanted to add a Digg-like voter to my app, where you have the number of votes showing with a vote button, and when you click on the vote button, the number disappears, then fades back in with an increase in the vote. The new vote will be added to the database. I also wanted to only allow each user to only vote on each item once (for obvious reasons!)

Overview

Here’s how it hangs together. The user presses the vote button. This calls back to a url, which has a view, which retrieves and/or stores data, which then renders the output to a template, which is then inserted by magic under the button with the new stored value.

Now on with some code.

Urls

First we need to define a url for the callback.

url(r'^callback/vote/(?P\d+)/$', 'vote', name='callback_vote'),

Models

For the purposes of this post, I’ll create 2 models. The first is an item model, where we can store an item description, and the number of the votes that item has:


class Item(models.Model):
    item_desc = models.CharField(max_length=200)
    votes = models.IntegerField()

Now we can create a Voter model, which stores who voted for which item, so we can prevent multiple voting for each user:


from django.contrib.auth.models import User

class Voter(models.Model):
    voter = models.ForeignKey(User)
    item = models.ForeignKey(Item)

Script Tags

Now we need to import the Javascript for Prototype and Scriptaculous. We can either do this in our base.html, which means the javascript will be loaded on every page, or we could add a block into the header, and just load the javascript on a per page basis. I have also stored the scripts in my MEDIA_URL.

You’ll see the load=effects option after the scriptaculous url. This is so it doesn’t load all of the modules. You can if you want, but for this example we only need the effect module.

Prototype Script

For the prototype script to work, and update our vote number, we need to have a page element to update. You could have a div or a span, but you need to give the element an id and a name.

Now for the script.

I’m assuming we’ve called the span or div id ‘item’. The $(‘item’) is a short cut to get a reference to the element. Firstly we call the function with the item id as a parameter. Then we set the display to ‘none’ before doing the callback. The callback is done, we update the div element using result.update, and the final line uses the Scriptaculous ‘appear()’ function, which fades the div back in.

Don’t forget to add an onclick() or similar event to what ever you want to use to trigger the callback. In my case I used the tick image.

I used n as a context for my item on the view for this page, in case you’re wondering what the {{ n.id }} is for.

Callback Code

Now we have the client side script, we need to take that item id and do something with it, then return the result for display.

First we need to create the vote view.


def vote(request, item_id):
    i = Item.objects.get(pk=item_id)
    #see if user has voted
    voter = Voter.objects.filter(voter=request.user, item=i)

    if not voter:
        v = Voter(voter=request.user, item=i)
        v.save()
        i.votes += 1
        i.save()

    return render_to_response('item/callback_vote.html', {'votes':i.votes})

We get our item object first, then check the Voter model to see if the current logged in user has already voted for this item. If they haven’t, then we create a Voter entry, and increase the number of votes by one. We then return the number of votes in the context.

Callback Template

Now we create a simple template to display the vote view.


{{ votes }}

Conclusion

And there we have it. That’s the basics of Ajax in Django. There’s a lot more to Scriptaculous than just the fade and appear, so check it out.