Architecture & DesignModeling Content Types with Schemata

Modeling Content Types with Schemata content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.

Object oriented analysis, design, and programming solves a wide array of problems. Relational databases make persistence of data a snap. How can you bring the best of these two worlds together? In this article, you’ll look at using an object schema to define the attributes of content types. You’ll explore Archetypes, a content schema system, and see how it fits in with content management systems. And, you’ll create new content types to tackle simple but real-world challenge, managing your DVD library, and all with a pretty user interface.

Presenting Pages in Portals

In the last article, you got a whirlwind introduction to Plone, a content management system (CMS) that lets you create, edit, and publish content through the web to maintain a portal, intranet, public-facing company website, or other web presence. But, CMSs can do a lot more than lower the bar for non-technical people to take web publishing into their own hands. And that’s where content types come into play.

A portal’s job, regardless of the kind of application in which it’s situated, is to publish content. Out of the box, CMSs like Plone and others include content types that reflect traditional web usage: web pages and images that appear on those pages. Plone adds a few additional content types as well, again reflecting the typical use of portals and similar web applications: news items, events, folders in which to make hierarchies of content, and a few others.

But, Plone goes one step further in letting web developers define content types of their own. By modeling application objects as content types, you can go on to define complete web applications in terms of content management. This has the immediate effect of simplifying web application development by hooking into all of the features that a CMS provides “for free”: persistence into a database, authentication and authorization, form and page generation, data validation, and so forth.

How do you define content types? By using a schema language called Archetypes. Try it out!

Plone Goes to the Movies

Almost any domestic challenge, whether organizing recipes, scheduling sports meets, or publishing the family newsletter, can be made worse with computer technology. Yet occasionally, computers do help out. And, that’s what you’ll attempt to do with Plone: Develop a small web application to manage your DVD collection. Rather than futilely try to keep DVDs in order on a shelf by genre or title or age-appropriate rating, you’ll put them in an arbitrary but numbered order, and let Plone index them to make locating the right film trivial. And, rather than simply create a free-text web page for each DVD, you’ll define a new content type that captures all of the metadata (that is, data about data, in this case, data about a DVD) for each DVD. So, grab a Sharpie and number those DVDs—and then head back to the computer.

With Plone, you use the Archetypes schema language to define your own content types. Content types are defined in products. Products are add-ons to Plone (through its underlying Zope application server) that provide new features. To define a new product, you create a subdirectory in your Plone installation’s Products directory. You also create a few standard subdirectories under this directory that holds the initialization code and user interface elements for the product. For the DVD Collection product, we’ll make a directory called DVDCollection. Windows users can use Windows Explorer to make the directories, or you might enter the following commands at the Command Prompt:

C:>cd "c:Program FilesPlone 2DataProducts"
C:Program FilesPlone 2DataProducts>mkdir DVDCollection
C:Program FilesPlone 2DataProducts>mkdir
C:Program FilesPlone 2DataProducts>mkdir DVDCollectionskins
C:Program FilesPlone 2DataProducts>mkdir

Mac OS X and other Unix users would do something similar to this:

% cd /Applications/Plone-2.5.2/Instance/Products
% mkdir DVDCollection
% mkdir DVDCollection/Extensions
% mkdir DVDCollection/skins
% mkdir DVDCollection/skins/DVDCollection

Now, fire up your favorite text editor. The first file you need to make in the DVDCollection directory is called Yes, the py extension means you’ll be writing some Python code. Plone, Archetypes, and even the Zope application server on which Plone runs are written in Python, an object-oriented scripting language that focuses on readability and programmer productivity. By learning a little bit of Python, you’ll be joining such ranks as NASA, Google, YouTube, and more, all of whom use Python prodigiously.

What do you put in this file? Mostly just boilerplate. Here it is:

from Products.Archetypes.public import process_types, listTypes
from Products.CMFCore.DirectoryView import registerDirectory
from Products.CMFCore.permissions import AddPortalContent
from Products.CMFCore.utils import ContentInit

registerDirectory(SKINS_DIR, GLOBALS)

def initialize(context):
   import DVD
   contentTypes, constructors, facTypeInfo =
      process_types(listTypes(PROJECT_NAME), PROJECT_NAME)
   ContentInit(PROJECT_NAME + ' Content',
      content_types=contentTypes, permission=AddPortalContent,

Seasoned Python programmers know that having a file called makes the directory in which it’s located a Python package. However, because the directory DVDCollection is under your Plone installation’s Products directory, it’s also a product for the application server on which Plone is running. In other words, products are special kinds of Python packages.

The file referenced a module called config, so next you need to create that in the DVDCollection directory by making another Python file, Its contents should be:

PROJECT_NAME = 'DVDCollection'
GLOBALS      = globals()
SKINS_DIR    = 'skins'

This file just provides definitions for the name of the project, the currently available global symbols, and also the location of the “skins” directory. The skins directory is where user-interface elements of your product go, such as images, CSS files, page templates, and so forth.

Lastly, you need one more file of boilerplate. This file should be called and it needs to go under the Extensions subdirectory. Here’s what you put inside that file:

from Products.Archetypes.Extensions.utils import installTypes,
from Products.Archetypes.public import listTypes
from Products.DVDCollection.config import PROJECT_NAME, GLOBALS
from StringIO import StringIO

def install(context):
   log = StringIO()
   installTypes(context, log, listTypes(PROJECT_NAME), PROJECT_NAME)
   print >>log, 'Installed %s content types' % PROJECT_NAME
   install_subskin(context, log, GLOBALS)
   print >>log, 'Installed skin layer'
   return log.getvalue()

Where’s your DVD content type in all this? Nowhere, yet! You’ll create one more Python file in the DVDCollection directory, this time called Inside this file, you’ll use the Archetypes schema language to define the attributes of a DVD in your collection, as well as create a Python class definition for a new class called DVD.

Introducing Archetypes

Calling Archetypes a schema language is a stretch. It’s really just a collection of Python class definitions and functions that you use in a specific way to define the data fields of a content type. The field definitions include the name and data type of each field, validation to apply to incoming data, on-page widgets to use to display the field and to provide for users to edit their values, and so forth. You can mix in other schemata and build re-usable libraries of schemata to make defining new content types a piece of cake.

After specifying the schema for your content type, you define a new Python class that refers to that schema. Plone uses that class definition to create objects of your content type, persist them into its object database, display them on a web page, and so forth.

For your DVD collection, you need to define one content type: a DVD. You’ll do all this in a file called in the DVDCollection directory. Because you’re giving each DVD its own number, start out this file with the field definition for a field called dvdNumber:

from Products.Archetypes.public import Schema, IntegerField,
idSchema = Schema((
   IntegerField('dvdNumber', required=True, index='FieldIndex:schema',
      widget=IntegerWidget(label='DVD Number',
         description='Numeric ID assigned to each DVD.')),

You now have a complete schema called idSchema with a single field called dvdNumber. Setting the required flag to True says that when users create a new DVD in your web application, they must provide a value for this field—leaving it blank will give an error message. The index attribute says that you want Plone to index this field for quick lookup and retrieval. Finally, you tell Archetypes what on-screen widget to use: in this case, an IntegerWidget. This widget automatically checks what users enter for values to make sure they’re valid integers.

Now, create another schema that’ll give you ways to classify DVDs. Add the following to the file:

from Products.Archetypes.public import StringField, SelectionWidget,
classifierSchema = Schema((
   IntegerField('runningTime', required=False,
      widget=IntegerWidget(label='Running Time',
      description='Length of the movie in minutes.')),
   StringField('rating', required=False, index='FieldIndex',
      vocabulary=['G', 'PG', 'PG-13', 'R', 'NC-17'],
      description='MPAA rating assigned to the movie.')),
   StringField('genre', required=True, index='FieldIndex',
      vocabulary=['Action/Adventure', 'Comedy', 'Drama', 'Family',
                  'Romance', 'Spaghetti Western'],
         description='Artisitic style of the movie.',

This second schema, classifierSchema, has three fields in it:

  1. The first field, runningTime, is an optional integer field that tells how long the movie on the DVD lasts. It’s optional because the required flag is set to False. (You also could just leave out the required flag because False is the default.)
  2. The second field, rating, tells the rating assigned by the Motion Picture Association of America. (You can substitute whatever other rating scheme you prefer.) This is a string-based field that’s also optional. It’s also indexed for quick lookup by setting the index attribute. The vocabulary attribute lists the valid values users may enter for this field, in this case, the MPAA rating codes. You also listed the widget for this field as a SelectionWidget. This kind of widget displays either radio buttons or a drop-down menu (depending on how many values are in the vocabulary), enabling the user to select one and only one value.
  3. The last field, genre, is a required field. Like rating, it’s indexed and it uses a controlled vocabulary for values. Unlike rating, it also includes the multiValued flag, set to True, meaning that movies may belong to more than one genre. In addition, the widget for this field is the MultiSelectionWidget that displays either checkboxes or a multi-select list. You added the format attribute to force the widget to use checkboxes (mostly because I don’t like multi-select lists).

And now you’re done defining the fields of a DVD! Wait, what about the title of the movie? Well, why define your own title field when you can reuse an existing schema that already provides it? Add these lines to

from Products.Archetypes.public import BaseSchema
dvdSchema = BaseSchema.copy() + idSchema + classifierSchema

The schema called BaseSchema comes with Archetypes; it provides several fields, such as title, description, subject keywords, last modification date, and so forth—all of which could be useful for your DVD content type. You then just “add ’em up”: the dvdSchema is a copy of the BaseSchema plus the idSchema plus the classifierSchema.

You’re now the proud owner of a complete schema. But, although Archetypes letsyou define schemata, Plone, its underlying application server, and its object database deal with objects, not schemata. And, before Plone can make objects, you need to provide a class definition for those objects. Luckily, Archetypes helps out again by providing base classes from which you can inherit all the necessary behavior. Add these lines to

from Products.Archetypes.public import BaseContent
class DVD(BaseContent):
   schema = dvdSchema
   archetype_name = portal_type = meta_type = 'DVD'
   typeDescription = "A DVD object captures a DVD's ID number,
                      title, genre, and other attributes."
   content_icon = 'dvd.gif'

This block of code defines a class called DVD, whose schema is the dvdSchema. It also tells Archetypes and other parts of Plone and Zope the name to use (“DVD”, in thise case), plus some descriptive “help text” explaining what the DVD class does. Lastly, it tells what icon to use on-screen to represent DVD objects, in this case dvd.gif. Where do you get the DVD icon dvd.gif? Help yourself to this one: . Just save it as a file to the DVDCollection subdirectory under the skins subdirectory (all user-interface elements go under skins).

The coding’s complete! You should now have the following files and directories:

Activating and Trying the Product

You’re entering the home stretch now. All that remains is to install the product into Plone and give it a try. You see, merely having the DVDCollection directory in the Products directory isn’t quite enough. You’ve got to tell Plone to make that product active. You do so through the web with a browser.

Start up your Plone instance using the same technique as in the last article. Log in with your administrator account and click on the “site setup” link at the top. Then, click on “Add/Remove Products”. You should see “DVDCollection” appear in the list of installable products. Check the box next to it, and click the Install button to make it active:

The DVD content type is now ready to use. By default, objects of the DVD type may be added anywhere, although you can control that with other features of Archetypes. For now, try out creating a few DVDs in a convenient place. Where’s a convenient place? Your account’s home folder is always nearby; just click “my folder” in the blue personal bar to jump there.

Once there, click the green “add item” menu and choose “dvd” from the list:

You’ll have a form you can fill in to create a DVD object. Fill in the fields and press Save.

Congratulations! You now have a new DVD object in your Plone site. You can search for this DVD by using Plone’s LiveSearch or advanced search, see it in folder listings, and update its items. Archetypes applies validation to the data you enter (for example, by displaying an error if you enter a non-integer for the DVD number field) and also generates the edit form and view web pages for DVDs. Archetypes and Plone take care of saving this object to the Zope application server’s object database, and cataloging its fields in the Plone catalog for quick searches and other uses. You can cut and paste DVD objects between folders and have DVDs appear in Plone’s “smart folders.” Plone also applies security and workflow to the content type.

Admittedly, this isn’t much of a web application: all you can do is create, retrieve, update, and delete DVD objects. But, building content types serves as the foundation for web applications—and you’ll use this DVD content type in a future article. See you next month!

About the Author

Sean Kelly is a software consultant to the media, medical, and aerospace industries. He spends much of his time modeling the real world in terms of content types, their workflows, and their interactions with each other. Apparently, he’s not been keeping up with his medication. He lives in a “house” object with his “wife” and “daughter” objects in an undisclosed object store.

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

Related Stories