MultiAuth: pydoprovider.py

"""
Author: Adam Svanberg <asvanberg@gmail.com>

Date: 2005-07-06

Decription:
    Simple database provider class for use with the cherryauth module.

Requirements:
    PyDO2 + Supported DBMS of choice.

Usage Example:

    Using this sample Sqlite database with filename 'sample.db'

    CREATE TABLE user (
    name TEXT PRIMARY KEY,
    password TEXT
    );
    CREATE TABLE role (
    user TEXT,
    role TEXT,
    PRIMARY KEY (user,role)
    );
    INSERT INTO user VALUES('the user','the password');
    INSERT INTO role VALUES('the user','admin');
    INSERT INTO role VALUES('the user','guest');

    a provider could be instatiated as

    p = PyDOProvider('sqlite',('sample.db',), enable_roles=True, usercol='name')

    note that the usercol parameter is specified, since it differs from
    the default value.
"""
from pydo import *

class PyDOProvider:
    """
    Provides authentication against any database supported by PyDO2.

    A valid PyDO driver name must be specified along with driver
    specific arguments (see PyDO2 manual). Optional keyword arguments
    may be provided to specify table and column names for the database
    containing user and role data. The use of roles is optional, and
    must be enabled using the 'rolemode' parameter.

    Accepted keyword arguments along with their default values:
    
    usertable <user>
    usercol <username>
    passcol <password>
    enable_roles <False> (Remaining parameters are not parsed if False)
    roletable <role>
    rolecol <role>
    roleusercol <user>
        
    """


    def __init__(self, driver, driver_args, **kw):

        # Initialize db connection.
        self.alias = 'pydo'
        initAlias(self.alias, driver, driver_args, pool=True)

        # Setup table classes.
        self.usertable = kw.get('usertable', 'user')
        self.usercol = kw.get('usercol', 'user')
        self.passcol = kw.get('passcol', 'password')

        userdict = {'table':self.usertable,
                    'fields':(Unique(self.usercol), self.passcol),
                    'connectionAlias':self.alias,
                    'refetch':True}
        PyDOProvider.User = type('User', (PyDO,), userdict)

        self.enable_roles = kw.get('enable_roles', False)
        if self.enable_roles:
            self.roletable = kw.get('roletable', 'role')
            self.rolecol = kw.get('rolecol', 'role')
            self.roleusercol = kw.get('roleusercol', 'user')

            roledict = {'table':self.roletable,
                        'fields':(self.rolecol, self.roleusercol),
                        'connectionAlias':self.alias,
                        'refetch':True}
            PyDOProvider.Role = type('Role', (PyDO,), roledict) 


    def get_roles(self,username):
        """Return list of roles associated with username"""
        if self.enable_roles:
            return [ user[self.rolecol] for user in PyDOProvider.Role.getSome(**{self.roleusercol:username}) ]
        else:
            return []

    def authenticate(self, username, password):
        """Return authentication status and associated roles"""
        user = PyDOProvider.User.getUnique(**{self.usercol:username})
        return user[self.passcol] == password, self.get_roles(username)