__init__.py

class UserProperty(object):
    def __init__(self,
                 openid = None,
                 nickname = None,
                 time_diff = 0):
	self.openid = openid
	self.nickname = nickname
	self.time_diff = time_diff

auth.py

import logging

from pylons import config, request, response, session, tmpl_context as c
from pylons.controllers.util import abort, redirect_to, url_for

from rpxclock.lib.base import BaseController, render

log = logging.getLogger(__name__)

import urllib2
import md5
import simplejson as json_

class AuthController(BaseController):
    def on_login(self):
	pass

    def on_logout(self):
	pass

    def logout(self):
	session['identifier'] = None
	del session['identifier']
	session.save()
	redirect_to(url_for(controller = "clock", action = "now"))

    def rpx_token_url(self, *args, **kargs):
	'token' in request.params or redirect_to(url_for(controller="clock", action="now"))
	token = request.params['token']

	# contact rpx for the details:                                                                                                 
	url = "https://rpxnow.com/api/v2/auth_info?token=%s&apiKey=%s" % (token, config.get('rpx_token'))
	json = json_.loads(urllib2.urlopen(url).read())

	if(json['stat'] == "ok"):
            json = json["profile"]
            session['identifier'] = json['identifier']
            session.save()

	redirect_to(url_for(controller="clock", action="now"))

auth.py

from pylons.controllers.util import abort, redirect_to, url_for
from pylons import session
from decorator import decorator

def get_identifier():
    if 'identifier' in session:
        return session['identifier']
    else:
        return None

def require_login(func, *args, **kwargs):
    if get_identifier() is None:
        redirect_to(url_for(controller = 'clock', action = 'now'))
    return func(*args, **kwargs)
require_login = decorator(require_login)

clock.py

import logging

from pylons import request, response, session, tmpl_context as c
from pylons.controllers.util import abort, redirect_to

from rpxclock.lib.base import BaseController, render
import datetime

log = logging.getLogger(__name__)

from rpxclock.lib import helpers as h
from rpxclock.lib.auth import *
from rpxclock.lib.sdb import UserPropertySDB

import formencode
from pylons.decorators.rest import restrict
from pylons.decorators import validate

from rpxclock.model import UserProperty

class TimeDiffForm(formencode.Schema):
    allow_extra_fields = True
    filter_extra_fields = True
    nickname = formencode.validators.String(not_empty = True)
    time_diff = formencode.validators.Int(not_empty = True)

class ClockController(BaseController):
    def __init__(self):
        BaseController.__init__(self)
        self.ups = UserPropertySDB()

    def now(self):
        if 'identifier' in session:
            return self._registered()
        else:
            return self._guest_now()

    def _registered(self):
        up = self.ups.find(session['identifier'])
        c.title = 'My Clock'

        if up:
            name = up.nickname
            time_diff = up.time_diff
        else:
            name = session['identifier']
            time_diff = 0

        c.heading = 'Welcome! %s' % name
        c.content = "Current time is %s" % str(datetime.datetime.now() + datetime.timedelta(0, 0, 0, 0, 0, time_diff))

        return render('/derived/clock/registered.html')

    def _guest_now(self):
        c.title = 'My Clock'
        c.heading = 'Welcome!'
        c.content = "Current time is %s" % str(datetime.datetime.now())
        return render('/derived/clock/guest.html')

    @require_login
    def customize(self):
        return render('/derived/clock/customize.html')


    @restrict('POST')
    @validate(schema = TimeDiffForm(), form = 'time_diff')
    @require_login
    def save(self):
        up = UserProperty(session['identifier'],
                          self.form_result['nickname'],
                          int(self.form_result['time_diff']))

        self.ups.save(up)
        redirect_to('now')

development.ini

[app:main]
use = egg:RPXClock
full_stack = true
static_files = true

cache_dir = %(here)s/data
beaker.session.key = rpxclock
beaker.session.secret = somesecret

rpx_token = aabbccddeeff00112233445566778899aabbccdd
sdb_user_domain = dev_rpx_user_domain
sdb_user_openid_domain = dev_rpx_user_openid_domain

guest.html

<%inherit file="/base/index.html"/>
${c.content}
<hr/>
<iframe src="http://YOU HAVE TO GET YOUR OWN CALL BACK URL from RPX" scrolling="no" frameBorder="no" allowtransparency="true" style="width:400px;height:240px"></iframe>

helpers.py

from routes import url_for

from formbuild.helpers import field
from formbuild import start_with_layout as form_start, end_with_layout as form_end
from webhelpers.html.tags import *

index.html

## -*- coding: utf-8 -*-

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
    <title>${self.title()}</title>
    ${self.head()}
</head>
<body>
    ${self.header()}
    ${self.heading()}
    ${next.body()}
</body>
</html>

<%def name="title()">My Clock</%def>
<%def name="head()"></%def>
<%def name="header()"><a name="top"></a></%def>
<%def name="heading()"><h1>${c.heading or 'My Clock'}</h1></%def>

registered.html

<%inherit file="/base/index.html"/>
${c.content}
<br/>
You can <a href="${h.url_for(action = 'customize')}">customize</a>.
<hr/>
<a href="${h.url_for(controller = 'auth', action = 'logout')}">Logout</a>

sdb.py

import boto
import jsonpickle
from pylons import config


class UserPropertySDB(object):
    def __init__(self):
        self.domain_name = config['app_conf']['sdb_user_openid_domain']
        sdb = boto.connect_sdb()
        try:
            self.domain = sdb.get_domain(self.domain_name)
        except boto.exception.SDBResponseError:
            self.domain = sdb.create_domain(self.domain_name)

    def save(self, user_property):
        item = self.domain.get_item(user_property.openid)
        if item is None:
            item = self.domain.new_item(user_property.openid)

	item['object'] = jsonpickle.encode(user_property)
        item.save()

    def find(self, openid):
	item = self.domain.get_attributes(openid, None, True)
	user_property = None

	if item:
            user_property = jsonpickle.decode(item['object'])
	return user_property