Ticket #70: database.py

# -*- coding: utf-8 -*-
#
# AccountManagerPlugin component to store user accounts in the database.
# Copyright (C) 2005 Lukáš LalinskÜ <lalinsky@gmail.com>
#

from __future__ import generators

from sha import sha

from trac.core import *
from trac.db_default import Table, Column, Index
from trac.env import IEnvironmentSetupParticipant
from api import IPasswordStore

class SHADatabasePasswordStore(Component):
    """Manages user accounts stored in the database using SHA to encode passwords.

    To use this implementation add the following configuration section to trac.ini
    {{{
    [account-manager]
    password_format = sha_db
    }}}
    """
    
    implements(IPasswordStore, IEnvironmentSetupParticipant)

    # IPasswordStore methods

    def config_key(self):
        """Returns a string used to identify this implementation in the config.
        This password storage implementation will be used if the value of
        the config property "account-manager.password_format" matches.
        """
        return 'sha_db'
        
    def get_users(self):
        """Returns an iterable of the known usernames
        """
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT name FROM user ORDER BY name")
        return [row[0] for row in cursor]

    def has_user(self, user):
        """Returns whether the user account exists.
        """
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        cursor.execute("SELECT COUNT(*) FROM user WHERE name=%s", (user,))
        return int(cursor.fetchone()[0]) > 0
    
    def set_password(self, user, password):
        """Sets the password for the user.  This should create the user account
        if it doesn't already exist.
        Returns True if a new account was created, False if an existing account
        was updated.
        """     
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        password = sha(password).hexdigest()
        if self.has_user(user):
            cursor.execute("UPDATE user SET password=%s WHERE name=%s", (password, user))
            created = False
        else:
            cursor.execute("INSERT INTO user (name, password) VALUES (%s, %s)", (user, password))
            created = True
        db.commit()
        return created
 
    def check_password(self, user, password):
        """Checks if the password is valid for the user.
        """
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        password = sha(password).hexdigest()
        cursor.execute("SELECT COUNT(*) FROM user WHERE name=%s AND password=%s", (user, password))
        return int(cursor.fetchone()[0]) > 0
         
    def delete_user(self, user):
        """Deletes the user account.
        Returns True if the account existed and was deleted, False otherwise.
        """
        db = self.env.get_db_cnx()
        cursor = db.cursor()
        if self.has_user(user):
            cursor.execute("DELETE FROM user WHERE name=%s", (user,))
            db.commit()
            return True
        else:    
            return False
        
     # IEnvironmentSetupParticipant methods

    version = 1
    
    schema = [
        Table('user', key=('name'))[
            Column('name'),
            Column('password')],
        ]

    def environment_created(self):
        """Called when a new Trac environment is created."""
        pass
    
    def environment_needs_upgrade(self, db):
        """Called when Trac checks whether the environment needs to be upgraded.
        
        Should return `True` if this participant needs an upgrade to be
        performed, `False` otherwise.
        """
        cursor = db.cursor()
        try:
            cursor.execute("SELECT value FROM system WHERE name='shauserdb_version'")
            return int(cursor.fetchone()[0]) != self.version
        except:
            return True
        return False
    
    def upgrade_environment(self, db):
        """Actually perform an environment upgrade.
        
        Implementations of this method should not commit any database
        transactions. This is done implicitly after all participants have
        performed the upgrades they need without an error being raised.
        """
        cursor = db.cursor()
        for table in self.schema:
            for stmt in db.to_sql(table):
                cursor.execute(stmt)
        cursor.execute("INSERT INTO system VALUES ('shauserdb_version', %s)", (self.version,))