Creating a sitemap is a simple two-step process. First you create sitemap classes that define the URLs to include in the sitemap, and then you enable the sitemap in the URLconf file. The following sections discuss this process.

from django.contrib.sitemaps import Sitemap
from mySite.data.models import report

class ReportSitemap(Sitemap):
    changefreq = "yearly"
    priority = 0.7
    def items(self):
        return report.objects.all()
    def location(self, obj):
        return '/datea/report/%d' % obj.id

sitemaps = { 'report': ReportSitemap, }
urlpatterns += patterns('',
    (r'^sitemap.xml$', 'django.contrib.sitemaps.views.sitemap',
          {'sitemaps': sitemaps}),
)

from django.contrib.sitemaps import Sitemap
from iFriends.People.models import Person

class PersonSitemap(Sitemap):
    changefreq = "Yearly"
    priority = 0.7
    def items(self):
        return Person.objects.all()

    def location(self, obj):
        return '/Person/info/%d' % obj.id

from iFriends.sitemaps import PersonSitemap

sitemaps = {
    'person': PersonSitemap,
}
urlpatterns += patterns('',
    (r'^sitemap.xml$', 'django.contrib.sitemaps.views.sitemap',
                        {'sitemaps': sitemaps}),
)

Django provides a useful shortcut that allows you to create a sitemap for generic views without having to define your own Sitemap class. Instead, you can use the django.contrib.sitemaps.GenericSitemap class.

The GenericSitemap class builds a Sitemap class from the same info dictionary that you pass the generic view. Instead of defining a list() function, the info dictionary needs to contain a queryset entry containing the list of objects. Instead of lastmod, GenericSitemap uses the date_field entry if one is defined in the dictionary. The priority and changefreq values can be specified as arguments when you create an instance of GenericSitemap.

The following is an example of using the GenericSitemap class to build a sitemap for a generic view:

from django.contrib.sitemaps import GenericSitemap
from django.views.generic import date_based
log_info_dict = {
    'queryset' : log.objects.all(),
    'date_field' : 'last_modified',
}
sitemaps = {
    'log': GenericSitemap(log_info_dict, priority=0.2, changefreq='daily'),
}
urlpatterns += patterns('',
    (r'^sitemap.xml$', 'django.contrib.sitemaps.views.sitemap',
    {'sitemaps': sitemaps}),
    (r'^generic/log_arch/$',date_based.archive_index, log_info_dict),
)

from django.contrib.sitemaps import FlatPageSitemap
sitemaps = { 'flat': FlatPageSitemap, }

from django.contrib.sitemaps import GenericSitemap
. . .
blog_detail_info = {
    'queryset' : Blog.objects.all(),
    'date_field' : 'date',
    'template_object_name': 'blog',
    'template_name' : 'Blogs/blog_detail.html',
}
. . .
sitemaps = {
    'person': PersonSitemap,
    'blog': GenericSitemap(blog_detail_info, priority=0.3,
                           changefreq='weekly'),
}
urlpatterns += patterns('',
    (r'^sitemap.xml$', 'django.contrib.sitemaps.views.sitemap',
                        {'sitemaps': sitemaps}),
)

class Blog(models.Model):
    title = models.CharField('Title', max_length=200)
    text = models.TextField('Text', max_length=2048)
    date = models.DateTimeField('Last Modified')

    def __str__(self):
        return '%s' % (self.title)

    def blog_size(self):
        return len(self.text)

    def get_absolute_url(self):
        return '/generic/blog_details/%d' % self.id

    class Admin:
        list_display = ('title', 'date', 'blog_size',)
        list_filter = ('date',)
        date_hierarchy = 'date'
        search_fields = ('title', 'text',)

    class Meta:
        permissions = (
            ('can_blog', 'Allowed to Blog'),
        )

As you add more and more Sitemap classes to your sitemap, you may find the need to index them individually. Django provides a simple solution for indexing the Sitemap classes.

The django.contrib.sitemaps.views.sitemap view function accepts a section argument that is the string value of one of the keys in the sitemaps dictionary.

For example, the following code snippet defines a sitemap with two Sitemap classes, report and log:

sitemaps = {
    'report': ReportSitemap,
    'log': GenericSitemap(log_info_dict, priority=0.2, changefreq='daily'),
}

The following URL pattern displays sitemaps for both the /sitemap-report.xml and /sitemap-log.xml URLs:

(r'^sitemap-(?P<section>.+).xml$', 'django.contrib.sitemaps.views.sitemap',
                   {'sitemaps': sitemaps}),

urlpatterns += patterns('',
    (r'^sitemap.xml$', 'django.contrib.sitemaps.views.sitemap',
                        {'sitemaps': sitemaps}),
    (r'^sitemap-(?P<section>.+).xml$',
   'django.contrib.sitemaps.views.sitemap',
                        {'sitemaps': sitemaps}),
)

Django also provides a simple way to ping Google to notify it that your web content has changed and that your site should be reindexed. The django.contrib.sitemaps.ping_google() function tells Google to reindex your site’s sitemap.

The default value for the sitemap is '/sitemap.xml'. However, you can specify a different value by using the sitemap_url argument. For example:

ping_google(sitemap_url='/sitemap-report.xml')

Using the ping_google() function, you can notify Google every time the data in your database changes. The following example pings Google every time the report object is saved:

from django.contrib.sitemaps import ping_google
class report(models.Model):
    . . .
    def save(self):
        super(report, self).save()
        try:
            ping_google(sitemap_url='/sitemap-report.xml')
        except Exception:
            pass

In this hour, you learned how to create Sitemap classes of the different views on your website. You learned how to enable the sitemaps so that a sitemap.xml document is created. You also learned how to create an index for sitemaps and how to ping Google to notify it that the site has changed.

The workshop consists of a set of questions and answers designed to solidify your understanding of the material covered in this hour. Try answering the questions before looking at the answers.