SandBox: axiomguarded.tac

from datetime import datetime

from zope.interface import implements, Interface

from twisted.application import service, strports
from twisted.cred import portal, checkers, credentials
from twisted.cred.credentials import UsernamePassword
from twisted.python.components import registerAdapter

from nevow import appserver, guard, inevow, loaders, rend, stan, tags as T, url
from formless import annotate, webform

from axiom import attributes, item, store, substore, userbase

LOGIN_URL_SEGMENT = "login"

##############################
class NewsItem(item.Item):
    title = attributes.text(allowNone=False)
    story = attributes.text(allowNone=False)
    authorName = attributes.text(allowNone=False)
    dateLastUpdated = attributes.bytes()
    
class INewsManager(Interface):
    def list(offset=None, limit=None):
        pass
    
    def save(title, story, storeId):
        pass
    
    def delete(storeId):
        pass
    
class NewsManager(object):
    implements(INewsManager)
    def __init__(self, avatar, store):
        self.avatar = avatar
        self.store = store
    
    def list(self, offset=None, limit=None):
        return self.store.query(NewsItem)
    
    def save(self, title, story, storeId=None):
        if storeId:
            item = self.store.getItemById(storeId)
            item.title = title
            item.story = story
        else:
            item = NewsItem(
                store=self.store,
                title=title,
                story=story,
                authorName=IPerson(self.avatar).fullName())
        
        item.dateLastUpdated = datetime.now().strftime("%Y-%m-%d")

def avatarToNewsManagerAdapter(avatar):
    if avatar.parent is None:
        return NewsManager(avatar, avatar)
    else:
        return NewsManager(avatar, avatar.parent)

registerAdapter(avatarToNewsManagerAdapter, store.Store, INewsManager)

#############################
class NewsSaveFragment(rend.Fragment):
    def __init__(self, *args, **kwargs):
        self.avatar = kwargs.pop('avatar')
        super(NewsSaveFragment, self).__init__(*args, **kwargs)

    def bind_save(self, ctx):
        return [
            ('title', annotate.String(required=True, unicode=True)),
            ('story', annotate.Text(required=True, unicode=True)),
        ]
    
    def save(self, title, story):
        INewsManager(self.avatar).save(title, story)
    
    def render_inputform(self, ctx, data):
        return webform.renderForms("NewsSaveFragment")
    
class NewsListFragment(rend.Fragment):
    def __init__(self, *args, **kwargs):
        self.avatar = kwargs.pop('avatar', None)
        super(NewsListFragment, self).__init__(*args, **kwargs)
        
    def data_items(self, ctx, data):
        return INewsManager(self.avatar).list()

    def render_axiomitem(self, ctx, data):
        for k, v in data.getSchema():
            ctx.tag.fillSlots(k, getattr(data, k))
        return ctx.tag

class LoginStatusFragment(rend.Fragment):
    def __init__(self, *args, **kwargs):
        self.avatar = kwargs.pop('avatar', None)
        super(LoginStatusFragment, self).__init__(*args, **kwargs)
    
    def rend(self, ctx, data):
        res = rend.Fragment.rend(self, ctx, data)
        person = IPerson(self.avatar, None)
        if person:
            pattern = res.tag.onePattern("loggedin")
            pattern.fillSlots('username', person.firstName)
        else:
            pattern = res.tag.onePattern("anonymous")

        res.tag[pattern]
        return res

##############################
class GuardedResourceWrapper:
    implements(inevow.IResource)
    
    def __init__(self, wrapped, avatar):
        self.wrapped = wrapped
        self.avatar = avatar
    
    def renderHTTP(self, ctx):
        req = inevow.IRequest(ctx)
        if self.avatar.avatarId is checkers.ANONYMOUS:
            return url.root.child(LOGIN_URL_SEGMENT).add('nextUri', req.uri)
        else:
            return self.wrapped.renderHTTP(ctx)
        
    def locateChild(self, ctx, segments):
        req = inevow.IRequest(ctx)
        if self.avatar.avatarId is checkers.ANONYMOUS:
            return url.root.child(LOGIN_URL_SEGMENT).add('nextUri', req.uri), []
        else:
            return self.wrapped, segments

class UnauthorisedFragment:
    implements(inevow.IRenderer)
    def __init__(self, avatar, requiredRole):
        self.avatar = avatar
        self.requiredRole = requiredRole
        
    def rend(self, ctx, data):
        req = inevow.IRequest(ctx)
        if self.requiredRole in IRole(self.avatar).allRoles():
            return self.wrappedFactory(avatar=self.avatar, **self.kwargs).rend(ctx, data)
        else:
            return T.fieldset[
                T.legend["You must be logged in with role %s to use this fragment." % self.requiredRole], 
                T.p[
                    "[",
                    T.a(href=url.root.child(LOGIN_URL_SEGMENT).add('nextUri', req.uri))["Login"],
                    "]"
                ]
            ]

def guardFrag(wrappedFactory, requiredRole):
    def fragFactory(**kwargs):
        avatar = kwargs.get('avatar')
        if requiredRole in IRole(avatar).allRoles():
            return wrappedFactory(**kwargs)
        else:
            return UnauthorisedFragment(avatar, requiredRole)
    return fragFactory

##############################
class PageWithAvatar(rend.Page):
    def __init__(self, *args, **kwargs):
        self.avatar = kwargs.pop('avatar')
        super(PageWithAvatar, self).__init__(*args, **kwargs)

class IPatternFactory(Interface):
    pass

class BasePage(PageWithAvatar):
    addSlash = False
    docFactory = loaders.xmlstr("""
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
           "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns:n="http://nevow.com/ns/nevow/0.1" n:render="pattern page"></html>
""")
    patternFactory = None
    
    def __init__(self, *args, **kwargs):
        super(BasePage, self).__init__(*args, **kwargs)
        store = IRole(self.avatar).store
        
        EVERYONE = getEveryoneRole(store)
        AUTHENTICATED = getAuthenticatedRole(store)
        
        self.allowedFragments = dict(
            LoginStatusFragment = guardFrag(LoginStatusFragment, EVERYONE),
            NewsListFragment = guardFrag(NewsListFragment, EVERYONE),
            NewsSaveFragment = guardFrag(NewsSaveFragment, AUTHENTICATED),
        )

    def beforeRender(self, ctx):
        if self.patternFactory:
            ctx.remember(self.patternFactory, IPatternFactory)
            
    def locateChild(self, ctx, segments):
        name = segments[0]
        # XXX: Hack to allow formless to find the configurables in fragments
        if name.startswith('freeform_post!'):
            configurableName, bindingName = name.split('!')[1:3]
            fragFactory = self.allowedFragments.get(configurableName, None)
            if fragFactory is not None:
                frag = fragFactory(avatar=self.avatar)
                #print "LOCATECHILD SETTING: configurable_", frag.__class__.__name__, " TO ", frag
                setattr(self, "configurable_%s" % frag.__class__.__name__, lambda ctx: frag)
                
        if self.patternFactory:
            ctx.remember(self.patternFactory, IPatternFactory)
        return super(BasePage, self).locateChild(ctx, segments)

    def locateFragment(self, fragmentName, **kwargs):
        fragFactory = self.allowedFragments[fragmentName]
        frag = fragFactory(**kwargs)
        # So that fragments work with formless
        #print "LOCATEFRAG SETTING: configurable_", frag.__class__.__name__, " TO ", frag
        setattr(self, "configurable_%s" % frag.__class__.__name__, lambda ctx: frag)
        return frag
        
    def render_fragment(self, name, *args):
        def f(ctx, data):
            kwargs = dict(
                avatar=self.avatar,
                docFactory = loaders.stan(ctx.tag.children)
            )
            return ctx.tag.clear()[self.locateFragment(name, **kwargs)]
        return f

    def render_pattern(self, name):
        def f(ctx, data):
            pattern = self.findPattern(ctx, name)
            if pattern is not None:
                return ctx.tag.clear()[pattern.children]
            return ctx.tag
        return f

    def findPattern(self, ctx, name, depth=1):
        try:
            doc = ctx.locate(IPatternFactory, depth)
        except KeyError:
            return None
        try:
            return inevow.IQ(doc).onePattern(name)
        except stan.NodeNotFound:
            return self.findPattern(ctx, name, depth+1)

class LoginPage(BasePage):
    
    patternFactory = loaders.xmlstr("""
<html xmlns:n="http://nevow.com/ns/nevow/0.1">
    <head>
        <title n:pattern="page_title">Login</title>
    </head>
    <body>
        <div n:pattern="page_body_content">
            <h1>Login</h1>
            <n:invisible n:render="loginform" />
        </div>
    </body>
</html>
""")
    
    def bind_login(self, ctx):
        return [
            ('ctx', annotate.Context()),
            ('username', annotate.String(required=True)),
            ('password', annotate.PasswordEntry(required=True)),
        ]
    
    def login(self, ctx, username, password):
        sess = inevow.ISession(ctx)
        req = inevow.IRequest(ctx)
        credentials = UsernamePassword(username, password)
        
        def errorHandler(error):
            raise annotate.ValidateError(
                {}, 
                formErrorMessage="Your username and / or password were not recognised.", 
                partialForm={'username':username})
        
        def successHandler(pageAndRemainingSegments):
            return url.root
        
        return sess.guard.login(req, sess, credentials, []).addCallback(successHandler).addErrback(errorHandler)

    def render_loginform(self, ctx, data):
        return ctx.tag.clear()[webform.renderForms()]
    
###################################
class RootPage(BasePage):
    addSlash = True
    patternFactory = loaders.xmlstr("""
<html xmlns:n="http://nevow.com/ns/nevow/0.1">
    <head>
        <title n:pattern="page_title">Homepage</title>
    </head>
    <body>
        <div n:pattern="page_body_menu">
            <ul>
                <li><a href="/">Home</a></li>
                <li><a href="/admin">Administration</a></li>
                <li><a href="/news">News</a></li>
            </ul>
        </div>
        <div n:pattern="page_body_content">
            <h1>Homepage</h1>
            <p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam vestibulum pretium augue. Maecenas a risus. Morbi quis ante sit amet orci ultrices iaculis. Nullam ut ante nec lacus elementum sagittis. Duis non magna vitae erat gravida pellentesque. In sit amet purus sed quam hendrerit luctus. Nullam ac turpis ac orci dictum sollicitudin. Fusce sem ligula, vehicula in, hendrerit a, tempus vitae, sem. Phasellus odio. In vitae tellus nec nunc lobortis venenatis.</p>
        </div>
    </body>
</html>
""")
    
    def child_form_css(self, ctx):
        return webform.defaultCSS
    
    def child_login(self, ctx):
        return LoginPage(avatar=self.avatar)

    def child_news(self, ctx):
        return NewsPage(avatar=self.avatar)

    def child_admin(self, ctx):
        return AdminPage(avatar=self.avatar)

class AdminPage(BasePage):
    patternFactory = loaders.xmlstr("""
<html xmlns:n="http://nevow.com/ns/nevow/0.1">
    <head>
        <title n:pattern="page_title">Administration</title>
    </head>
    <body>
        <div n:pattern="page_body_menu">
            <ul>
                <li><a href="/admin/news">News Admin</a></li>
            </ul>
        </div>
        <div n:pattern="page_body_content">
            <h1>Administration</h1>
            <p>Welcome to the administration page.</p>
        </div>
    </body>
</html>
""")

    def child_news(self, ctx):
        return NewsAdminPage(avatar=self.avatar)

class NewsAdminPage(BasePage):
    patternFactory = loaders.xmlstr("""
<html xmlns:n="http://nevow.com/ns/nevow/0.1">
    <head>
        <title n:pattern="page_title">News Administration</title>
    </head>
    <body>
        <div n:pattern="page_body_menu">
            <ul>
                <li><a href="/admin/news">News Admin</a></li>
            </ul>
        </div>
        <div n:pattern="page_body_content">
            <h1>News Administration</h1>
            <n:invisible  n:render="fragment NewsSaveFragment">
            <div n:render="inputform" />
            </n:invisible>

            <div n:render="fragment NewsListFragment">
                <h2 class="tab">Existing News</h2>
                <table n:render="sequence" n:data="items" class="" style="width:100%;" cellpadding="0" cellspacing="0" border="1" id="feedback-grid">
                    <thead n:pattern="header">
                        <tr>
                            <td>Title</td>
                            <td>Author</td>
                            <td>Date</td>
                        </tr>
                    </thead>
                    <tbody>      
                        <tr n:pattern="item">
                        <n:invisible n:render="axiomitem">
                            <td><n:slot name="title" /></td>
                            <td><n:slot name="authorName" /></td>
                            <td><n:slot name="dateLastUpdated" /></td>
                        </n:invisible>
                        </tr>
                    </tbody>
                    <tr n:pattern="empty">
                        <td colspan="3">No items found</td>
                    </tr>
                </table>
            </div>
        </div>
    </body>
</html>
""")

class NewsPage(BasePage):
    patternFactory = loaders.xmlstr("""
<html xmlns:n="http://nevow.com/ns/nevow/0.1">
    <head>
        <title n:pattern="page_title">News List</title>
    </head>
    <body>
        <div n:pattern="page_body_content">
            <h1>Latest News</h1>
            <p>This is a list of the latest news items in our database</p>
            <n:invisible n:render="fragment NewsListFragment">
                <ul n:render="sequence" n:data="items">
                    <li n:pattern="item">
                        <n:invisible n:render="axiomitem">
                            <h3><n:slot name="title" /></h3>
                            <p><n:slot name="story" /></p>
                            <p>
                                By: <strong><n:slot name="authorName" /></strong>, 
                                Last Updated: <strong><n:slot name="dateLastUpdated" /></strong>
                            </p>
                        </n:invisible>
                    </li>
                    <li n:pattern="empty">
                        No items found
                    </li>
                </ul>
            </n:invisible>
        </div>
    </body>
</html>
""")

def siteRootFactory(avatar):
    root = RootPage(avatar=avatar)
    return root
registerAdapter(siteRootFactory, store.Store, inevow.IResource)

################################
class IPerson(Interface):
    pass

class Person(item.Item):
    implements(IPerson)
    
    typeName = "Person"
    
    firstName = attributes.text(allowNone=False)
    lastName = attributes.text(allowNone=False)
    
    installedOn = attributes.reference()
    
    def installOn(self, other):
        assert self.installedOn is None, 'cannot install Person on more than one User'
        self.installedOn = other
        other.powerUp(self, IPerson)
        
    def fullName(self):
        return u"%s %s" % (self.firstName, self.lastName)

##############################
class IAxiomStore(Interface):
    pass
registerAdapter(lambda substoreItem: substoreItem.open(), substore.SubStore, IAxiomStore)

class IRole(Interface):
    pass

def storeToRoleAdapter(store):
    if store.parent is None: #anonymous avatar is the main store
        return getEveryoneRole(store)
    else: # logged in avatar is a user substore.
        return getSelfRole(store)

registerAdapter(storeToRoleAdapter, store.Store, IRole)

##############################
def createAccount(store, username, domain, password, firstName, lastName):
    def transaction():
        loginSystem = store.findFirst(userbase.LoginSystem)
        loginSystem.installOn(store)
        
        account = loginSystem.addAccount(username, domain, password)
        substore = IAxiomStore(account.avatars)

        person = Person(store=substore, firstName=firstName, lastName=lastName)
        person.installOn(substore)
        return account
    return store.transact(transaction)

##################################
import os

DB_PATH = os.tmpnam()
s = store.Store(DB_PATH)
loginSystem = s.findOrCreate(userbase.LoginSystem)
createAccount(s, u"joebloggs", u"localhost", u"password", u"Joe", u"Bloggs")
createAccount(s, u"Janedoe", u"localhost", u"password", u"Jane", u"Doe")

###################################
porta = portal.Portal(realm = loginSystem)
porta.registerChecker(checkers.AllowAnonymousAccess(), credentials.IAnonymous)
porta.registerChecker(loginSystem)
root = guard.SessionWrapper(porta)

patternFactory = loaders.xmlstr("""
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
           "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns:n="http://nevow.com/ns/nevow/0.1" n:pattern="page">
    <head>
        <title n:render="pattern page_title">Page Title</title>
        <style>
            #login-status{
                border-bottom : 1px solid Black;
            }
        </style>
        <link rel="stylesheet" href="/form_css" type="text/css" />
    </head>
    <body>
        <div n:render="pattern page_header">
            <div n:render="fragment LoginStatusFragment" id="login-status">
            <p n:pattern="loggedin">
                Welcome <strong><n:slot name="username" /></strong>, [<a href="/__logout__">Logout</a>]
            </p>
            <p n:pattern="anonymous">
                You are not logged in, [<a href="/login">Login</a>]
            </p>
            </div>
        </div>
        <div n:render="pattern page_body">
            <table width="100%" border="1">
                <tr>
                    <td n:render="pattern page_body_menu" width="20%" valign="top">
                    <ul>
                        <li><a href="/">Home</a></li>
                    </ul>
                    </td>
                    <td n:render="pattern page_body_content" width="80%" valign="top">
                        <h1>Site Title</h1>
                        <p>Placeholder</p>
                    </td>
                </tr>
            </table>
        </div>
        <div n:render="pattern page_footer">
            <p>&copy;Default Site Footer 2006</p>
        </div>
    </body>
</html>
""")
site = appserver.NevowSite(root)
site.remember(patternFactory, IPatternFactory)
application = service.Application("examples")
strports.service("8080", site).setServiceParent(application)

####################################
from twisted.internet import reactor

def cleanUp():
    print "DELETING DATABASE: ", DB_PATH
    for root, dirs, files in os.walk(DB_PATH, topdown=False):
        for name in files:
            os.remove(os.path.join(root, name))
        for name in dirs:
            os.rmdir(os.path.join(root, name))
    os.removedirs(DB_PATH)
reactor.addSystemEventTrigger("after", "shutdown", cleanUp)

#############################
# STOLEN from http://divmod.org/trac/browser/branches/sharing-382-5/Mantissa/xmantissa/sharing.py
class RoleRelationship(item.Item):
    schemaVersion = 1
    typeName = 'sharing_relationship'

    member = attributes.reference()
    group = attributes.reference()

class Role(item.Item):
    schemaVersion = 1
    typeName = 'sharing_role'
    externalID = attributes.text(allowNone=False)
    description = attributes.text()

    def becomeMemberOf(self, groupRole):
        self.store.findOrCreate(RoleRelationship,
                                group=groupRole,
                                member=self)

    def allRoles(self, memo=None):
        if memo is None:
            memo = set()
        elif self in memo:
            # this is bad, but we have successfully detected and prevented the
            # only really bad symptom, an infinite loop.
            return
        memo.add(self)
        yield self
        for groupRole in self.store.query(Role,
                                          attributes.AND(RoleRelationship.member == self,
                                              RoleRelationship.group == Role.storeID)):
            for roleRole in groupRole.allRoles(memo):
                yield roleRole

    def __repr__(self):
        return self.externalID.upper()

#############################
def getEveryoneRole(store):
    """
    Get a base 'Everyone' role for this store, which is the role that every user has no matter what.
    """
    return store.findOrCreate(Role, externalID=u'Everyone')

def getAuthenticatedRole(store):
    """
    Get the base 'Authenticated' role for this store, which is the role that
    every user with a proper username has, no matter what.
    """
    def tx():
        def addToEveryone(newAuthenticatedRole):
            newAuthenticatedRole.becomeMemberOf(getEveryoneRole(store))
            return newAuthenticatedRole
        return store.findOrCreate(Role, addToEveryone, externalID=u'Authenticated')
    return store.transact(tx)

def getPrimaryRole(store, primaryRoleName, createIfNotFound=False):
    """
    Get Role object corresponding to an identifier name.  If the role name
    passed is the empty string, it is assumed that the user is not
    authenticated, and the 'Everybody' role is primary.  If the role name
    passed is non-empty, but has no corresponding role, the 'Authenticated'
    role - which is a member of 'Everybody' - is primary.  Finally, a specific
    role can be primary if one exists for the user's given credentials, that
    will automatically always be a member of 'Authenticated', and by extension,
    of 'Everybody'.
    """
    if not primaryRoleName:
        return getEveryoneRole(store)
    ff = store.findUnique(Role, Role.externalID == primaryRoleName, default=None)
    if ff is not None:
        return ff
    authRole = getAuthenticatedRole(store)
    if createIfNotFound:
        role = Role(store=store,
                    externalID=primaryRoleName)
        role.becomeMemberOf(authRole)
        return role
    return authRole

def getSelfRole(store):
    """
    Retrieve the Role which corresponds to the user to whom the given store
    belongs.
    """
    for (localpart, domain) in userbase.getAccountNames(store):
        return getPrimaryRole(store, u'%s@%s' % (localpart, domain), createIfNotFound=True)
    raise ValueError("Cannot get self-role for unnamed account.")