Ticket #2456: user_API_r6033.diff

trac/env.py

@@ -28 +28 @@
 from trac.core import Component, ComponentManager, implements, Interface, \
                       ExtensionPoint, TracError
 from trac.db import DatabaseManager
+from trac.user import UserManager, User
 from trac.util import get_pkginfo
 from trac.versioncontrol import RepositoryManager
 from trac.web.href import Href
@@ -339 +340 @@
 
         This function generates one tuple for every user, of the form
         (username, name, email) ordered alpha-numerically by username.
-
-        @param cnx: the database connection; if ommitted, a new connection is
-                    retrieved
         """
-        if not cnx:
-            cnx = self.get_db_cnx()
-        cursor = cnx.cursor()
-        cursor.execute("SELECT DISTINCT s.sid, n.value, e.value "
-                       "FROM session AS s "
-                       " LEFT JOIN session_attribute AS n ON (n.sid=s.sid "
-                       "  and n.authenticated=1 AND n.name = 'name') "
-                       " LEFT JOIN session_attribute AS e ON (e.sid=s.sid "
-                       "  AND e.authenticated=1 AND e.name = 'email') "
-                       "WHERE s.authenticated=1 ORDER BY s.sid")
-        for username,name,email in cursor:
-            yield username, name, email
+        for user in UserManager(self).get_all_users():
+            yield user.username, user['name'], user['email']
 
     def backup(self, dest=None):
         """Simple SQLite-specific backup of the database.

trac/notification.py

@@ -22 +22 @@
 from trac import __version__
 from trac.config import BoolOption, IntOption, Option
 from trac.core import *
+from trac.user import UserManager
 from trac.util.text import CRLF
 from trac.web.chrome import Chrome
 
@@ -158 +159 @@
     smtp_port = 25
     from_email = 'trac+tickets@localhost'
     subject = ''
+    server = None
     template_name = None
     nodomaddr_re = re.compile(r'[\w\d_\.\-]+')
     addrsep_re = re.compile(r'[;\s,]+')
@@ -179 +181 @@
         self._init_pref_encoding()
         domains = self.env.config.get('notification', 'ignore_domains', '')
         self._ignore_domains = [x.strip() for x in domains.lower().split(',')]
-        # Get the email addresses of all known users
-        self.email_map = {}
-        for username, name, email in self.env.get_known_users(self.db):
-            if email:
-                self.email_map[username] = email
-                
+
     def _init_pref_encoding(self):
         from email.Charset import Charset, QP, BASE64
         self._charset = Charset()
@@ -270 +267 @@
         if not is_email(address):
             if address == 'anonymous':
                 return None
-            if self.email_map.has_key(address):
-                address = self.email_map[address]
+            
+            email = UserManager(self.env).get_user(address)['email']
+            if email and len(email) > 0:
+                address = email
             elif NotifyEmail.nodomaddr_re.match(address):
                 if self.config.getbool('notification', 'use_short_addr'):
                     return address

trac/perm.py

@@ -20 +20 @@
 
 from trac.config import ExtensionOption, OrderedExtensionsOption
 from trac.core import *
+from trac.user import UserManager
 from trac.util.compat import set
 from trac.util.translation import _
 
@@ -160 +161 @@
         db = self.env.get_db_cnx()
         cursor = db.cursor()
         result = set()
-        users = set([u[0] for u in self.env.get_known_users()])
+        users = set([username for username
+                    in UserManager(self.env).get_usernames()])
         for user in users:
             userperms = self.get_user_permissions(user)
             for group in permissions:

trac/prefs/web_ui.py

@@ -22 +22 @@
 
 from trac.core import *
 from trac.prefs.api import IPreferencePanelProvider
+from trac.user import UserManager, User
 from trac.util.datefmt import all_timezones, get_timezone
 from trac.util.translation import _
 from trac.web import HTTPNotFound, IRequestHandler
@@ -93 +94 @@
                 self._do_save(req)
             req.redirect(req.href.prefs(panel or None))
 
+        name = email = ''
+        if req.authname != 'anonymous':
+            user = UserManager(self.env).get_user(req.authname)
+            name, email = user['name'], user['email']
+        else:
+            name = req.session.get('name')
+            email = req.session.get('email')
         return 'prefs_%s.html' % (panel or 'general'), {
-            'settings': {'session': req.session, 'session_id': req.session.sid},
+            'settings': {'session': req.session, 'session_id': req.session.sid,
+                         'name': name, 'email': email},
             'timezones': all_timezones, 'timezone': get_timezone
         }
 
@@ -118 +127 @@
                 elif field == 'newsid' and val:
                     req.session.change_sid(val)
                 else:
-                    req.session[field] = val
-            elif field in req.session and (field in req.args or
-                                           field + '_cb' in req.args):
-                del req.session[field]
+                    if req.authname != 'anonymous' and \
+                            field in ('name', 'email'):
+                        user = UserManager(self.env).get_user(req.authname)
+                        user[field] = val
+                    else:
+                        req.session[field] = val
+            elif field in req.args and field + '_cb' in req.args:
+                if req.authname != 'anonymous' and \
+                        field in ('name', 'email'):
+                    user = UserManager(self.env).get_user(req.authname)
+                    user[field] = ''
+                elif field in req.session:
+                    del req.session[field]
 
     def _do_load(self, req):
         if req.authname == 'anonymous':

trac/ticket/admin.py

@@ -107 +107 @@
 
         if self.config.getbool('ticket', 'restrict_owner'):
             perm = PermissionSystem(self.env)
-            def valid_owner(username):
-                return perm.get_user_permissions(username).get('TICKET_MODIFY')
-            data['owners'] = [username for username, name, email
-                              in self.env.get_known_users()
-                              if valid_owner(username)]
+            data['owners'] = perm.get_users_with_permission('TICKET_MODIFY')
         else:
             data['owners'] = None
 

trac/ticket/report.py

@@ -27 +27 @@
 from trac.core import *
 from trac.db import get_column_names
 from trac.perm import IPermissionRequestor
+from trac.user import UserManager
 from trac.util import sorted
 from trac.util.datefmt import format_datetime, format_time
 from trac.util.text import to_unicode, unicode_urlencode
@@ -369 +370 @@
         # Get the email addresses of all known users
         email_map = {}
         if Chrome(self.env).show_email_addresses:
-            for username, name, email in self.env.get_known_users():
-                if email:
-                    email_map[username] = email
+            email_map = UserManager(self.env).get_attribute_mapper('email')
 
         data.update({'header_groups': header_groups,
                      'row_groups': row_groups,

trac/timeline/web_ui.py

@@ -30 +30 @@
 from trac.perm import IPermissionRequestor
 from trac.timeline.api import ITimelineEventProvider, TimelineEvent
 from trac.util.compat import sorted
+from trac.user import UserManager
 from trac.util.datefmt import format_date, format_datetime, parse_date, \
                               to_timestamp, utc, pretty_timedelta
 from trac.util.text import to_unicode
@@ -167 +168 @@
             # Get the email addresses of all known users
             email_map = {}
             if Chrome(self.env).show_email_addresses:
-                for username, name, email in self.env.get_known_users():
-                    if email:
-                        email_map[username] = email
+                email_map = UserManager(self.env).get_attribute_mapper('email')
             data['email_map'] = email_map
             return 'timeline.rss', data, 'application/rss+xml'
 

trac/user.py

@@ +1 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2006 Waldemar Kornewald, wkornewald@haiku-os.org
+# All rights reserved.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://trac.edgewall.org/wiki/TracLicense.
+#
+# This software consists of voluntary contributions made by many
+# individuals. For the exact contribution history, see the revision
+# history and logs, available at http://trac.edgewall.org/log/.
+#
+# Author: Waldemar Kornewald, wkornewald@haiku-os.org
+
+from trac.core import *
+from trac.config import *
+
+
+class IUserStore(Interface):
+    """
+    Extension point interface for backends that store known users.
+    """
+
+    def supports_user_operation(self, operation):
+        """
+        Returns whether the operation (a method name) is supported.
+
+        @return supported
+        """
+
+    def create_user(self, username, password):
+        """
+        Creates a new user with the given username and password.
+
+        @return success
+        """
+
+    def get_usernames(self):
+        """
+        Generator that yields an ordered list of known usernames.
+
+        @return username
+        """
+
+    def check_password(self, username, password):
+        """
+        Checks if the password is correct for the given user.
+        """
+
+    def change_password(self, username, password):
+        """
+        Changes a user's password.
+
+        @return success
+        """
+
+    def delete_user(self, username):
+        """
+        Deletes a user.
+
+        @return success
+            Returns False if the user didn't exist.
+        """
+
+
+class IUserAttributeProvider(Interface):
+    """
+    Extension point interface for backends that store user attributes.
+    """
+
+    def supports_attribute_operation(self, operation):
+        """
+        Returns whether the operation (a method name) is supported.
+
+        @return supported
+        """
+
+    def get_user_attribute(self, username, attribute):
+        """
+        Returns a user attribute.
+
+        If the attribute is not set it returs an empty string.
+        If the attribute is not supported None is returned.
+        """
+
+    def set_user_attribute(self, username, attribute, value):
+        """
+        Sets a user attribute.
+
+        @return success
+            Returns False if setting the attribute is not supported.
+        """
+
+    def delete_all_user_attributes(self, username):
+        """
+        Deletes all of the given user's attributes.
+        """
+
+class UserAttributeMapper(object):
+    """
+    Dict that maps usernames to attributes and caches those values to
+    increase efficiency.
+    """
+
+    _usernames_cache = None
+    _cache = {}
+
+    def __init__(self, attribute, manager):
+        self._attribute = attribute
+        self._manager = manager
+
+    def __getitem__(self, username):
+        if not self._usernames_cache:
+            self._usernames_cache = [username for username
+                                     in self._manager.get_usernames()]
+        if username not in self._usernames_cache:
+            return None
+        if username not in self._cache:
+            value = self._manager.get_user(username)[self._attribute]
+            if value:
+                self._cache[username] = value
+            return value
+        else:
+            return self._cache.get(username)
+
+    def __contains__(self, username):
+        value = self[username]
+        return value is not None and len(value) > 0
+
+    def __setitem__(self,key,value):
+        raise NotImplementedError, "dict is immutable"
+    def __delitem__(self,key):
+        raise NotImplementedError, "dict is immutable"
+    def clear(self):
+        raise NotImplementedError, "dict is immutable"
+    def setdefault(self,k,default=None):
+        raise NotImplementedError, "dict is immutable"
+    def popitem(self):
+        raise NotImplementedError, "dict is immutable"
+    def update(self,other):
+        raise NotImplementedError, "dict is immutable"
+
+
+class UserManager(Component):
+    """
+    Component responsible for managing users and user attributes.
+    """
+
+    store = ExtensionOption('users',
+        'store', IUserStore, 'SessionUserStore',
+        doc="""The user store that should be used for authentication
+            (''since 0.11'').""")
+    attribute_providers = OrderedExtensionsOption('users',
+        'attribute_providers', IUserAttributeProvider,
+        doc="""Ordered list of user attribute providers (''since 0.11'').""")
+
+    # public API
+
+    def supports_operation(self, operation):
+        if self.store.supports_user_operation(operation):
+            return True
+        for provider in self.attribute_providers:
+            if self.provider.supports_attribute_operation(operation):
+                return True
+        return False
+
+    # IUserStore methods
+
+    def create_user(self, username, password):
+        """
+        Creates a new user with the given username and password.
+
+        @return User object or None if the user couldn't be created
+        """
+        if not self.store.supports_user_operation('create_user'):
+            return None
+        if self.store.create_user(username, password):
+            return User(username, self.store, self.attribute_providers)
+
+    def get_user(self, username):
+        """
+        Returns a User object for the username.
+
+        @return User object or None if the user doesn't exist
+        """
+        return User(username, self.store, self.attribute_providers)
+
+    def get_all_users(self):
+        """
+        Generator for User objects.
+        """
+        if not self.store.supports_user_operation('get_usernames'):
+            return
+        for username in self.store.get_usernames():
+            yield User(username, self.store, self.attribute_providers)
+
+    def get_usernames(self):
+        """
+        Generator for usernames.
+        """
+        if not self.store.supports_user_operation('get_usernames'):
+            return
+        return self.store.get_usernames()
+
+    def get_attribute_mapper(self, attribute):
+        return UserAttributeMapper(attribute, self)
+
+
+class User(object):
+    """
+    Object representing a user.
+    """
+
+    def __init__(self, username, store, attribute_providers):
+        self._username = username
+        self.store = store
+        self.attribute_providers = attribute_providers
+
+    # public API
+
+    @property
+    def username(self):
+        return self._username
+
+    def exists(self):
+        return self.username in [username for username
+                                 in self.store.get_usernames()]
+
+    # IUserStore methods
+
+    def check_password(self, password):
+        if not self.store.supports_user_operation('check_password'):
+            return False
+        return self.store.check_password(self.username, password)
+
+    def change_password(self, password):
+        if not self.store.supports_user_operation('change_password'):
+            return False
+        return self.store.change_password(self.username, password)
+
+    def delete(self):
+        if not self.store.supports_user_operation('delete_user'):
+            return False
+        self.delete_all_attributes()
+        return self.store.delete_user(self.username)
+
+    # IUserAttributeProvider methods
+
+    def __getitem__(self, attribute):
+        for provider in self.attribute_providers:
+            if not provider.supports_attribute_operation('get_user_attribute'):
+                continue
+            value = provider.get_user_attribute(self.username, attribute)
+            if value is not None:
+                return value
+        return None
+
+    def __setitem__(self, attribute, value):
+        for provider in self.attribute_providers:
+            if provider.supports_attribute_operation('set_user_attribute') \
+                    and provider.set_user_attribute(self.username, attribute,
+                                                    value):
+                return True
+        return False
+
+    def delete_all_attributes(self):
+        for provider in self.attribute_providers:
+            if provider.supports_attribute_operation('delete_all_user_attributes'):
+                provider.delete_all_user_attributes(username)
+
+
+class SessionUserStore(Component):
+    """
+    Component for managing authenticated users stored in sessions.
+    """
+
+    implements(IUserStore)
+
+    def supports_user_operation(self, operation):
+        return hasattr(self, operation)
+
+    def get_usernames(self):
+        db = self.env.get_db_cnx()
+        cursor = db.cursor()
+        cursor.execute("SELECT sid FROM session "
+                       "WHERE authenticated=1 "
+                       "ORDER BY sid")
+        for row in cursor:
+            yield row[0]
+
+
+class SessionUserAttributeProvider(Component):
+    """
+    Component for providing user attributes via Trac sessions.
+    """
+
+    implements(IUserAttributeProvider)
+
+    def supports_attribute_operation(self, operation):
+        return hasattr(self, operation)
+
+    def get_user_attribute(self, username, attribute):
+        db = self.env.get_db_cnx()
+        cursor = db.cursor()
+        cursor.execute("SELECT value FROM session_attribute "
+                       "WHERE sid=%s AND name=%s AND authenticated=1",
+                       (username, attribute))
+        row = cursor.fetchone()
+        if row:
+            return row[0]
+
+        # if the attribute doesn't exist we return an empty string to
+        # indicate that the attribute is supported, but not set
+        return ''
+
+    def set_user_attribute(self, username, attribute, value):
+        db = self.env.get_db_cnx()
+        cursor = db.cursor()
+
+        if not value or value == '':
+            cursor.execute("DELETE FROM session_attribute "
+                           "WHERE sid=%s AND name=%s AND authenticated=1",
+                          (username, attribute))
+            db.commit()
+            return True
+
+        # check if attribute exists
+        cursor.execute("SELECT value FROM session_attribute "
+                       "WHERE sid=%s AND name=%s AND authenticated=1",
+                       (username, attribute))
+        if cursor.fetchone():
+            # update the attribute
+            cursor.execute("UPDATE session_attribute SET value=%s "
+                           "WHERE sid=%s AND name=%s AND authenticated=1",
+                           (value, username, attribute))
+        else:
+            # create new attribute
+            cursor.execute("INSERT INTO session_attribute "
+                           "(sid,authenticated,name,value) "
+                           "VALUES(%s,1,%s,%s)",
+                           (username, attribute, value))
+        db.commit()
+        return True
+
+    def delete_all_user_attributes(self, username):
+        db = self.env.get_db_cnx()
+        cursor = db.cursor()
+        cursor.execute("DELETE FROM session_attribute "
+                       "WHERE sid=%s AND authenticated=1",
+                      (username,))
+        db.commit()

trac/versioncontrol/web_ui/log.py

@@ -23 +23 @@
 from trac.context import Context
 from trac.core import *
 from trac.perm import IPermissionRequestor
+from trac.user import UserManager
 from trac.util import Ranges
 from trac.util.datefmt import http_date
 from trac.util.html import html
@@ -193 +194 @@
         if format == 'rss':
             # Get the email addresses of all known users
             if Chrome(self.env).show_email_addresses:
-                for username,name,email in self.env.get_known_users():
-                    if email:
-                        email_map[username] = email
+                email_map = UserManager(self.env).get_attribute_mapper('email')
         elif format == 'changelog':
             for rev in revs:
                 changeset = changes[rev]