Changeset 1603

Show
Ignore:
Timestamp:
06/30/06 00:26:28 (2 years ago)
Author:
kevin
Message:

the remainder of my sqlalchemy support package

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/1.0/setup.py

    r1554 r1603  
    7979    sqlobject = turbogears.visit.sovisit:SqlObjectVisitManager 
    8080    sqlalchemy = turbogears.visit.savisit:SqlAlchemyVisitManager 
     81     
    8182    [turbogears.toolboxcommand] 
    8283    widgets = turbogears.toolbox.base:WidgetBrowser 

  • branches/1.0/turbogears/command/base.py

    r1591 r1603  
    77 
    88import pkg_resources 
     9import dispatch 
    910 
    1011import turbogears 
    1112from turbogears.util import get_model, load_project_config 
    1213from turbogears.identity import SecureObject 
     14from turbogears import config, database 
    1315 
    1416 
    …… 
    4648            self.dburi = self.dburi[8:] 
    4749 
     50[dispatch.generic()] 
     51def sacommand(command, args): 
     52    pass 
     53 
     54[sacommand.when("command == 'help'")] 
     55def sahelp(command, args): 
     56    print """TurboGears SQLAlchemy Helper 
     57 
     58help    this display 
     59create  create the database tables 
     60""" 
     61[sacommand.when("command == 'create'")] 
     62def sacreate(command, args): 
     63    print "Creating tables at %s" % (config.get("sqlalchemy.dburi")) 
     64    from turbogears.database import bind_meta_data, metadata 
     65    get_model() 
     66    metadata.create_all() 
     67     
    4868class SQL(CommandWithDB): 
    4969    """Wrapper command for sqlobject-admin. 
    …… 
    86106        else: 
    87107            sqlobjcommand = sys.argv[1] 
    88  
     108             
     109            if config.get("sqlalchemy.dburi"): 
     110                try: 
     111                    sacommand(sqlobjcommand, sys.argv) 
     112                except dispatch.interfaces.NoApplicableMethods: 
     113                    sacommand("help", []) 
     114                return 
     115                 
    89116            if sqlobjcommand not in no_connection_param: 
    90117                if not self.dburi: 
    …… 
    152179        "Run the shell" 
    153180        self.find_config() 
    154  
     181         
    155182        mod = get_model() 
    156183        if mod: 
    …… 
    158185        else: 
    159186            locals = dict(__name__="tg-admin") 
     187             
     188        if config.get("sqlalchemy.dburi"): 
     189            using_sqlalchemy = True 
     190            database.bind_meta_data() 
     191            locals.update(session=database.session, 
     192                          metadata=database.metadata) 
     193        else: 
     194            using_sqlalchemy = False 
     195 
    160196        try: 
    161197            # try to use IPython if possible 
    …… 
    165201                def raw_input(self, *args, **kw): 
    166202                    try: 
    167                         return IPython.iplib.InteractiveShell.raw_input(self, *args, **kw) 
     203                        return \ 
     204                         IPython.iplib.InteractiveShell.raw_input(self, 
     205                                                    *args, **kw) 
    168206                    except EOFError: 
    169                         b = raw_input("Do you wish to commit your database changes? [yes]") 
    170                         if not b.startswith("n"): 
    171                             self.push("hub.commit()") 
     207                        if not using_sqlalchemy: 
     208                            b = raw_input("Do you wish to commit your " 
     209                                        "database changes? [yes]") 
     210                            if not b.startswith("n"): 
     211                                self.push("hub.commit()") 
    172212                        raise EOFError 
    173213 
    174             shell = IPython.Shell.IPShell(user_ns=locals, shell_class=CustomIPShell) 
     214            shell = IPython.Shell.IPShell(user_ns=locals, 
     215                                          shell_class=CustomIPShell) 
    175216            shell.mainloop() 
    176217        except ImportError: 
    …… 
    180221                def raw_input(self, *args, **kw):  
    181222                    try: 
    182                         return code.InteractiveConsole.raw_input(self, *args, **kw) 
     223                        return code.InteractiveConsole.raw_input(self, 
     224                                                        *args, **kw) 
    183225                    except EOFError: 
    184                         b = raw_input("Do you wish to commit your database changes? [yes]") 
    185                         if not b.startswith("n"): 
    186                             self.push("hub.commit()") 
     226                        if not using_sqlalchemy: 
     227                            b = raw_input("Do you wish to commit your " 
     228                                          "database changes? [yes]") 
     229                            if not b.startswith("n"): 
     230                                self.push("hub.commit()") 
    187231                        raise EOFError 
    188232 

  • branches/1.0/turbogears/command/quickstart.py

    r1593 r1603  
    9797    package = None 
    9898    templates = "turbogears" 
    99     identity = None 
     99    sqlalchemy = False 
     100    identity = False 
    100101     
    101102    def __init__(self, version): 
    …… 
    112113            help="user specific templates", 
    113114            dest="templates", default = self.templates) 
    114         parser.add_option("-i", "--identity",  
    115             help="identity provider to use (sqlobject (default)," 
    116                  " sqlalchemy, none)", 
    117             dest="identity", default = self.identity) 
     115        parser.add_option("-s", "--sqlalchemy", 
     116            help="use SQLAlchemy instead of SQLObject", 
     117            action="store_true", dest="sqlalchemy", default = False) 
     118        parser.add_option("-i", "--identity", 
     119            help="provide Identity support", 
     120            action="store_true", dest="identity", default = False) 
    118121 
    119122        (options, args) = parser.parse_args() 
    …… 
    137140                self.package = package 
    138141 
    139         doidentity = None 
     142        doidentity = self.identity 
    140143        while not doidentity: 
    141144            doidentity = raw_input("Do you need Identity " 
    …… 
    146149                break 
    147150            if doidentity.startswith("y"): 
     151                doidentity = True 
    148152                break 
    149153            print "Please enter y(es) or n(o)." 
    150154            doidentity = None 
    151  
    152         while not self.identity: 
    153             self.identity = raw_input("Select your provider sqlobject or sqlalchemy [sqlobject]: ") 
    154             if not self.identity: 
     155         
     156        if doidentity is True: 
     157            if self.sqlalchemy: 
     158                self.identity = "sqlalchemy" 
     159            else: 
    155160                self.identity = "sqlobject" 
    156             if self.identity not in ["sqlobject", "sqlalchemy"]: 
    157                 print "Please enter one of 'sqlobject', 'sqlalchemy'" 
    158                 self.identity = "" 
    159                 continue 
    160      
    161161        self.name = pkg_resources.safe_name(self.name) 
    162162 
    …… 
    187187            cmd_args.append("--template=%s" % template) 
    188188        cmd_args.append(self.name) 
    189         cmd_args.append("package=%s" %self.package) 
    190         cmd_args.append("identity=%s" %self.identity) 
     189        cmd_args.append("package=%s" % self.package) 
     190        cmd_args.append("identity=%s" % self.identity) 
     191        cmd_args.append("sqlalchemy=%s" % self.sqlalchemy) 
    191192        if self.dry_run: 
    192193            cmd_args.append("--simulate") 

  • branches/1.0/turbogears/database.py

    r1600 r1603  
    2525     
    2626    def get_engine(): 
     27        "Retreives the engine based on the current configuration" 
    2728        global _engine 
    2829        if not _engine: 
    …… 
    3132                raise KeyError("No sqlalchemy database config found!") 
    3233            _engine = sqlalchemy.create_engine(dburi) 
     34            metadata.connect(_engine) 
    3335        return _engine 
    3436         
    3537    def create_session(): 
     38        "Creates a session with the appropriate engine" 
    3639        return sqlalchemy.create_session(bind_to=get_engine()) 
    3740         
    …… 
    4144     
    4245    def bind_meta_data(): 
    43         metadata.connect(get_engine()) 
    44          
     46        get_engine() 
     47     
    4548except ImportError: 
    4649    sqlalchemy = None 
    …… 
    272275        transaction.rollback() 
    273276        raise 
    274     session.clear() 
    275277 
    276278def so_to_dict(sqlobj): 
    …… 
    312314class EndTransactionsFilter(BaseFilter): 
    313315    def on_end_resource(self): 
     316        if _use_sa(): 
     317            session.clear() 
    314318        end_all() 
    315319 

  • branches/1.0/turbogears/identity/saprovider.py

    r1491 r1603  
    33import md5 
    44import random 
     5from datetime import * 
     6 
    57import turbogears 
     8from turbogears import identity 
     9from turbogears.util import load_class 
     10from turbogears.database import session 
    611from turbojson.jsonify import * 
    7 from datetime import * 
    8 from sqlalchemy import * 
    9 from sqlalchemy.ext.activemapper import * 
    1012 
    1113import logging 
    1214log = logging.getLogger("turbogears.identity.saprovider") 
    13  
    14 from turbogears import identity 
    15  
    16 __engine__= turbogears.database.PackageEngine( 'turbogears.identity' ) 
    17  
    18 from turbogears.util import load_class 
    1915 
    2016try: 
    …… 
    2420 
    2521# Global class references -- these will be set when the Provider is initialised. 
    26 user_class= None 
    27 group_class= None 
    28 permission_class= None 
    29 visit_class= None 
     22user_class = None 
     23group_class = None 
     24permission_class = None 
     25visit_class = None 
    3026 
    3127class SqlAlchemyIdentity(object): 
    3228    def __init__(self, visit_key, user=None): 
    3329        if user: 
    34             self._user= user 
    35         self.visit_key= visit_key 
     30            self._user = user 
     31        self.visit_key = visit_key 
    3632     
    3733    def _get_user(self): 
    …… 
    4339        # Attempt to load the user. After this code executes, there *WILL* be 
    4440        # a _user attribute, even if the value is None. 
    45         visit= visit_class.get_by( visit_key= self.visit_key ) 
     41        visit = visit_class.get_by(visit_key = self.visit_key) 
    4642        if not visit: 
    47             self._user= None 
     43            self._user = None 
    4844            return None 
    49         self._user= user_class.get( visit.user_id ) 
     45        self._user = user_class.get(visit.user_id) 
    5046        return self._user 
    51     user= property(_get_user) 
     47    user = property(_get_user) 
    5248     
    5349    def _get_user_name(self): 
    …… 
    5551            return None 
    5652        return self.user.user_name 
    57     user_name= property(_get_user_name) 
     53    user_name = property(_get_user_name) 
    5854 
    5955    def _get_anonymous(self): 
    6056        return not self.user 
    61     anonymous= property(_get_anonymous) 
     57    anonymous = property(_get_anonymous) 
    6258     
    6359    def _get_permissions(self): 
    …… 
    6864            pass 
    6965        if not self.user: 
    70             self._permissions= frozenset() 
     66            self._permissions = frozenset() 
    7167        else: 
    72             self._permissions= frozenset([p.permission_name for p in self.user.permissions]) 
     68            self._permissions = frozenset([p.permission_name for p in self.user.permissions]) 
    7369        return self._permissions 
    74     permissions= property(_get_permissions) 
     70    permissions = property(_get_permissions) 
    7571     
    7672    def _get_groups(self): 
    …… 
    8177            pass 
    8278        if not self.user: 
    83             self._groups= frozenset() 
     79            self._groups = frozenset() 
    8480        else: 
    85             self._groups= frozenset([g.group_name for g in self.user.groups]) 
     81            self._groups = frozenset([g.group_name for g in self.user.groups]) 
    8682        return self._groups 
    87     groups= property(_get_groups) 
     83    groups = property(_get_groups) 
    8884 
    8985    def logout(self): 
    …… 
    9490            return 
    9591        try: 
    96             visit= visit_class.get_by(visit_key=self.visit_key) 
    97             objectstore.delete( visit ) 
     92            visit = visit_class.get_by(visit_key=self.visit_key) 
     93            session.delete(visit) 
    9894            # Clear the current identity 
    99             anon= SqlAlchemyIdentity(None,None) 
    100             anon.anonymous= True 
    101             identity.set_current_identity( anon ) 
     95            anon = SqlAlchemyIdentity(None,None) 
     96            anon.anonymous = True 
     97            identity.set_current_identity(anon) 
    10298        except: 
    10399            pass 
    …… 
    111107    def __init__(self): 
    112108        super(SqlAlchemyIdentityProvider, self).__init__() 
    113         get=cherrypy.config.get 
     109        get=turbogears.config.get 
    114110         
    115111        global user_class, group_class, permission_class, visit_class 
    116112         
    117         user_class_path= get( "identity.saprovider.model.user",  
    118                               __name__ + ".User" ) 
    119         user_class= load_class(user_class_path) 
    120         group_class_path= get( "identity.saprovider.model.group", 
    121                                 __name__ + ".Group" ) 
    122         group_class= load_class(group_class_path) 
    123         permission_class_path= get( "identity.saprovider.model.permission", 
    124                                     __name__ + ".Permission" ) 
    125         permission_class= load_class(permission_class_path) 
    126         visit_class_path= get( "identity.saprovider.model.visit", 
    127                                __name__ + ".VisitIdentity" ) 
    128         visit_class= load_class(visit_class_path) 
     113        user_class_path = get("identity.saprovider.model.user",  
     114                              None) 
     115        user_class = load_class(user_class_path) 
     116        group_class_path = get("identity.saprovider.model.group", 
     117                                None) 
     118        group_class = load_class(group_class_path) 
     119        permission_class_path = get("identity.saprovider.model.permission", 
     120                                    None) 
     121        permission_class = load_class(permission_class_path) 
     122        visit_class_path = get("identity.saprovider.model.visit", 
     123                               None) 
     124        log.info("Loading: %s", visit_class_path) 
     125        visit_class = load_class(visit_class_path) 
    129126        # Default encryption algorithm is to use plain text passwords 
    130         algorithm= get( "identity.saprovider.encryption_algorithm", None ) 
     127        algorithm = get("identity.saprovider.encryption_algorithm", None) 
    131128        if "md5"==algorithm: 
    132             self.encrypt_password= lambda pw: md5.new(pw).hexdigest() 
     129            self.encrypt_password = lambda pw: md5.new(pw).hexdigest() 
    133130        elif "sha1"==algorithm: 
    134             self.encrypt_password= lambda pw: sha.new(pw).hexdigest() 
     131            self.encrypt_password = lambda pw: sha.new(pw).hexdigest() 
    135132        else: 
    136             self.encrypt_password= lambda pw: pw 
     133            self.encrypt_password = lambda pw: pw 
    137134 
    138     def create_provider_model( self ): 
    139         # create the database tables 
     135    def create_provider_model(self): 
     136        "Not implemented. You must create your model tables another way." 
     137        # model is not created through this mechanism 
    140138        return 
    141         try: 
    142             global user_group, group_permission 
    143139 
    144             visit_class.table.create() 
    145             user_class.table.create() 
    146             group_class.table.create() 
    147             permission_class.table.create() 
    148             user_group.create() 
    149             group_permission.create() 
    150             objectstore.commit() 
    151         except SQLError: 
    152             return 
    153         except KeyError: 
    154             log.warning( "No database is configured: SqlAlchemyIdentityProvider is disabled." ) 
    155             return 
    156  
    157     def validate_identity( self, user_name, password, visit_key ): 
     140    def validate_identity(self, user_name, password, visit_key): 
    158141        ''' 
    159142        Look up the identity represented by user_name and determine whether the 
    …… 
    167150            permissions: a set of permission IDs 
    168151        ''' 
    169         user= user_class.get_by( user_name=user_name ) 
     152        user = user_class.get_by(user_name=user_name) 
    170153        if not user: 
    171             log.warning( "No such user: %s", user_name ) 
     154            log.warning("No such user: %s", user_name) 
    172155            return None 
    173156        if user.password!=self.encrypt_password(password): 
    174             log.info( "Passwords don't match for user: %s", user_name ) 
     157            log.info("Passwords don't match for user: %s", user_name) 
    175158            return None 
    176159         
    177         log.info( "associating user (%s) with visit (%s)", user.user_name,  
    178                   visit_key ) 
     160        log.info("associating user (%s) with visit (%s)", user.user_name,  
     161                  visit_key) 
    179162        # Link the user to the visit 
    180         link= visit_class.get_by( visit_key=visit_key ) 
     163        link = visit_class.get_by(visit_key=visit_key) 
    181164        if not link: 
    182             link= visit_class( visit_key=visit_key, user_id=user.user_id ) 
     165            link = visit_class(visit_key=visit_key, user_id=user.user_id) 
    183166        else: 
    184             link.user_id= user.user_id 
    185         link.commit() 
    186         return SqlAlchemyIdentity( visit_key, user ) 
     167            link.user_id = user.user_id 
     168        return SqlAlchemyIdentity(visit_key, user) 
    187169             
    188     def load_identity( self, visit_key ): 
     170    def load_identity(self, visit_key): 
    189171        ''' 
    190172        Lookup the principal represented by user_name. Return None if there is no 
    …… 
    197179            permissions: a set of permission IDs 
    198180        ''' 
    199         return SqlAlchemyIdentity( visit_key ) 
     181        return SqlAlchemyIdentity(visit_key) 
    200182     
    201     def anonymous_identity( self ): 
     183    def anonymous_identity(self): 
    202184        ''' 
    203185        Must return an object with the following properties: 
    …… 
    207189            permissions: a set of permission IDs 
    208190        ''' 
    209         return SqlAlchemyIdentity( None ) 
    210          
    211  
    212 user_group = Table("tg_user_group", __engine__,  
    213                       Column("user_id", Integer, 
    214                               ForeignKey("tg_user.user_id"), 
    215                               primary_key = True), 
    216                       Column("group_id", Integer, 
    217                               ForeignKey("tg_group.group_id"), 
    218                               primary_key = True)) 
    219                        
    220 group_permission = Table("tg_group_permission", __engine__, 
    221                             Column("group_id", Integer, 
    222                                     ForeignKey("tg_group.group_id"), 
    223                                     primary_key = True), 
    224                             Column("permission_id", Integer, 
    225                                 ForeignKey("permission.permission_id"), 
    226                                     primary_key = True)) 
    227  
    228  
    229 class VisitIdentity(ActiveMapper): 
    230     class mapping: 
    231         __table__ = "tg_visit_identity" 
    232         visit_key = column(String, # foreign_key = "visit.visit_key", 
    233                           primary_key = True) 
    234         user_id = column(Integer, foreign_key = "tg_user.user_id", index = True) 
    235  
    236  
    237 class Group(ActiveMapper): 
    238     """ 
    239     An ultra-simple group definition. 
    240     """ 
    241     class mapping: 
    242         __table__ = "tg_group" 
    243         group_id = column(Integer, primary_key = True) 
    244         group_name = column(Unicode(16), unique = True) 
    245         display_name = column(Unicode(255)) 
    246         created = column(DateTime, default = datetime.now) 
    247  
    248         #users = many_to_many("User", user_group, backref = "groups") 
    249         #permissions = many_to_many("Permission", group_permission, 
    250         #                           backref = "groups") 
    251  
    252  
    253 class User(ActiveMapper): 
    254     """ 
    255     Reasonably basic User definition. Probably would want additional attributes. 
    256     """ 
    257     class mapping: 
    258         __table__ = "tg_user" 
    259         user_id = column(Integer, primary_key = True) 
    260         user_name = column(Unicode(16), unique = True) 
    261         email_address = column(Unicode(255), unique = True) 
    262         display_name = column(Unicode(255)) 
    263         password = column(Unicode(40)) 
    264         created = column(DateTime, default = datetime.now) 
    265  
    266         groups = many_to_many("Group", user_group, backref = "users") 
    267  
    268     @property 
    269     def permissions(self): 
    270         perms = set() 
    271         for g in self.groups: 
    272             perms = perms | set(g.permissions) 
    273         return perms 
    274          
    275  
    276 class Permission(ActiveMapper): 
    277     class mapping: 
    278         __table__ = "tg_permission" 
    279         permission_id = column(Integer, primary_key = True) 
    280         permission_name = column(Unicode(16), unique = True) 
    281         description = column(Unicode(255)) 
    282          
    283         groups = many_to_many("Group", group_permission, 
    284                               backref = "permissions") 
    285  
     191        return SqlAlchemyIdentity(None) 

  • branches/1.0/turbogears/identity/soprovider.py

    r1512 r1603  
    176176            log.info("Succesfully loaded \"%s\"" % permission_class_path) 
    177177         
    178         visit_class_path= get( "visit.soprovider.model", 
     178        visit_class_path= get( "identity.soprovider.model.visit", 
    179179                                __name__ + ".TG_VisitIdentity" ) 
    180180        visit_class= load_class(visit_class_path) 

  • branches/1.0/turbogears/qstemplates/quickstart/dev.cfg_tmpl

    r1380 r1603  
    77# DATABASE 
    88 
     9#if $sqlalchemy == "True" 
     10# driver://username:password@host:port/database 
     11# pick the form for your database 
     12# sqlalchemy.dburi="postgres://username@hostname/databasename" 
     13# sqlalchemy.dburi="mysql://username:password@hostname:port/databasename" 
     14# sqlalchemy.dburi="sqlite:///file_name_and_path" 
     15 
     16# If you have sqlite, here's a simple default to get you started 
     17# in development 
     18sqlalchemy.dburi="sqlite:///devdata.sqlite" 
     19#else 
    920# pick the form for your database 
    1021# sqlobject.dburi="postgres://username@hostname/databasename" 
    …… 
    2435# for Windows users, sqlite URIs look like: 
    2536# sqlobject.dburi="sqlite:///drive_letter:/path/to/file" 
    26  
     37#end if 
    2738 
    2839# SERVER 

  • branches/1.0/turbogears/qstemplates/quickstart/+package+/config/app.cfg_tmpl

    r1578 r1603  
    6363#if $identity == "sqlobject" 
    6464# Database class to use for visit tracking 
    65 visit.soprovider.model = "${package}.model.VisitIdentity" 
     65visit.soprovider.model = "${package}.model.Visit" 
    6666#else if $identity == "sqlalchemy" 
    6767# Database class to use for visit tracking 
    68 visit.saprovider.model = "${package}.model.VisitIdentity" 
     68visit.saprovider.model = "${package}.model.Visit" 
    6969#end if 
    7070 

  • branches/1.0/turbogears/qstemplates/quickstart/+package+/controllers.py_tmpl

    r1567 r1603  
    77#if $identity != "none" 
    88from turbogears import identity 
     9#end if 
     10#if $sqlalchemy == "True" 
     11from turbogears.database import session 
    912#end if 
    1013 

  • branches/1.0/turbogears/qstemplates/quickstart/+package+/model.py_tmpl

    r1567 r1603  
    33 
    44#end if 
     5#if $sqlalchemy != "True" 
    56from sqlobject import * 
    67 
    7 #if $identity == "sqlobject" 
     8#else 
     9from sqlalchemy import * 
     10from sqlalchemy.ext.activemapper import ActiveMapper, column, \ 
     11                                    one_to_many, one_to_one, many_to_many 
     12 
     13#end if 
     14#if $identity != "none" 
    815from turbogears import identity  
    916#end if 
     17#if $sqlalchemy != "True" 
    1018from turbogears.database import PackageHub 
    1119 
    1220hub = PackageHub("${package}") 
    1321__connection__ = hub 
    14  
    15 #if $identity == "sqlalchemy" 
    16 from sqlalchemy import * 
    17 from sqlalchemy.ext.activemapper import * 
    18  
    19 from turbogears.database import PackageEngine  
    20 engine = __engine__ = PackageEngine("${package}") 
    21 #end if 
    22  
    23 #if $identity=="sqlobject" 
     22#else 
     23from turbogears.database import metadata 
     24#end if 
     25 
     26#if $sqlalchemy!="True" 
    2427# class YourDataClass(SQLObject): 
    2528#     pass 
    2629 
     30#end if 
     31#if $identity=="sqlobject" 
     32class Visit(SQLObject): 
     33    class sqlmeta: 
     34        table="visit" 
     35 
     36    visit_key= StringCol( length=40, alternateID=True, 
     37                          alternateMethodName="by_visit_key" ) 
     38    created= DateTimeCol( default=datetime.now ) 
     39    expiry= DateTimeCol() 
     40 
     41    def lookup_visit( cls, visit_key ): 
     42        try: 
     43            return cls.by_visit_key( visit_key ) 
     44        except SQLObjectNotFound: 
     45            return None 
     46    lookup_visit= classmethod(lookup_visit) 
    2747 
    2848class VisitIdentity(SQLObject): 
    29     visit_key = StringCol( length=40, alternateID=True, 
    30                           alternateMethodName="by_visit_key" ) 
     49    visit_key = StringCol(length=40, alternateID=True, 
     50                          alternateMethodName="by_visit_key") 
    3151    user_id = IntCol() 
    3252 
    …… 
    4262        table="tg_group" 
    4363     
    44     group_name = UnicodeCol( length=16, alternateID=True, 
    45                             alternateMethodName="by_group_name" ) 
    46     display_name = UnicodeCol( length=255 ) 
    47     created = DateTimeCol( default=datetime.now ) 
     64    group_name = UnicodeCol(length=16, alternateID=True, 
     65                            alternateMethodName="by_group_name") 
     66    display_name = UnicodeCol(length=255) 
     67    created = DateTimeCol(default=datetime.now) 
    4868 
    4969    # collection of all users belonging to this group 
    50     users = RelatedJoin( "User", intermediateTable="user_group", 
    51                         joinColumn="group_id", otherColumn="user_id" ) 
     70    users = RelatedJoin("User", intermediateTable="user_group", 
     71                        joinColumn="group_id", otherColumn="user_id") 
    5272 
    5373    # collection of all permissions for this group 
    54     permissions = RelatedJoin( "Permission", joinColumn="group_id",  
     74    permissions = RelatedJoin("Permission", joinColumn="group_id",  
    5575                              intermediateTable="group_permission", 
    56                               otherColumn="permission_id" ) 
     76                              otherColumn="permission_id") 
    5777 
    5878 
    …… 
    6686        table="tg_user" 
    6787 
    68     user_name = UnicodeCol( length=16, alternateID=True, 
    69                            alternateMethodName="by_user_name" ) 
    70     email_address = UnicodeCol( length=255, alternateID=True, 
    71                                alternateMethodName="by_email_address" ) 
    72     display_name = UnicodeCol( length=255 ) 
    73     password = UnicodeCol( length=40 ) 
    74     created = DateTimeCol( default=datetime.now ) 
     88    user_name = UnicodeCol(length=16, alternateID=True, 
     89                           alternateMethodName="by_user_name") 
     90    email_address = UnicodeCol(length=255, alternateID=True, 
     91                               alternateMethodName="by_email_address") 
     92    display_name = UnicodeCol(length=255) 
     93    password = UnicodeCol(length=40) 
     94    created = DateTimeCol(default=datetime.now) 
    7595 
    7696    # groups this user belongs to 
    77     groups = RelatedJoin( "Group", intermediateTable="user_group", 
    78                          joinColumn="user_id", otherColumn="group_id" ) 
    79  
    80     def _get_permissions( self ): 
     97    groups = RelatedJoin("Group", intermediateTable="user_group", 
     98                         joinColumn="user_id", otherColumn="group_id") 
     99 
     100    def _get_permissions(self): 
    81101        perms = set() 
    82102        for g in self.groups: 
    …… 
    84104        return perms 
    85105         
    86     def _set_password( self, cleartext_password ): 
     106    def _set_password(self, cleartext_password): 
    87107        "Runs cleartext_password through the hash algorithm before saving." 
    88108        hash = identity.encrypt_password(cleartext_password) 
    89109        self._SO_set_password(hash) 
    90110         
    91     def set_password_raw( self, password ): 
     111    def set_password_raw(self, password): 
    92112        "Saves the password as-is to the database." 
    93113        self._SO_set_password(password) 
    …… 
    96116 
    97117class Permission(SQLObject): 
    98     permission_name = UnicodeCol( length=16, alternateID=True, 
    99                                  alternateMethodName="by_permission_name" ) 
    100     description = UnicodeCol( length=255 ) 
     118    permission_name = UnicodeCol(length=16, alternateID=True, 
     119                                 alternateMethodName="by_permission_name") 
     120    description = UnicodeCol(length=255) 
    101121     
    102     groups = RelatedJoin( "Group", 
     122    groups = RelatedJoin("Group", 
    103123                        intermediateTable="group_permission", 
    104124                         joinColumn="permission_id",  
    105                          otherColumn="group_id" ) 
     125                         otherColumn="group_id") 
    106126 
    107127 
    108128#else if $identity=="sqlalchemy" 
     129 
     130class Visit(ActiveMapper): 
     131    class mapping: 
     132        __table__ = "visit" 
     133        visit_key = column(String(40), primary_key=True) 
     134        created = column(DateTime, nullable = False, default=datetime.now) 
     135        expiry = column(DateTime) 
     136         
     137    def lookup_visit(cls, visit_key): 
     138        return Visit.get( visit_key ); 
     139    lookup_visit= classmethod(lookup_visit) 
     140 
    109141# tables for SQLAlchemy identity 
    110 user_group = Table( "user_group", __engine__,  
    111                       Column( "user_id", Integer, 
    112                               ForeignKey("user.user_id"), 
    113                               primary_key=True ), 
    114                       Column( "group_id", Integer, 
    115                               ForeignKey("group.group_id"), 
    116                               primary_key=True ) ) 
     142user_group = Table("user_group", metadata,  
     143                      Column("user_id", Integer, 
     144                              ForeignKey("tg_user.user_id"), 
     145                              primary_key=True), 
     146                      Column("group_id", Integer, 
     147                              ForeignKey("tg_group.group_id"), 
     148                              primary_key=True)) 
    117149                       
    118 group_permission = Table( "group_permission", __engine__, 
    119                             Column( "group_id", Integer, 
    120                                     ForeignKey("group.group_id"), 
    121                                     primary_key=True ), 
    122                             Column( "permission_id", Integer, 
     150group_permission = Table("group_permission", metadata, 
     151                            Column("group_id", Integer, 
     152                                    ForeignKey("tg_group.group_id"), 
     153                                    primary_key=True), 
     154                            Column("permission_id", Integer, 
    123155                                ForeignKey("permission.permission_id"), 
    124                                     primary_key=True ) ) 
     156                                    primary_key=True)) 
    125157 
    126158 
    …… 
    128160    class mapping: 
    129161        __table__="visit_identity" 
    130         visit_key = column( String, # foreign_key="visit.visit_key", 
    131                           primary_key=True ) 
    132         user_id = column( Integer, foreign_key="user.user_id", index=True ) 
     162        visit_key = column(String, # foreign_key="visit.visit_key", 
     163                          primary_key=True) 
     164        user_id = column(Integer, foreign_key="tg_user.user_id", index=True) 
    133165 
    134166 
    …… 
    139171    class mapping: 
    140172        __table__="tg_group" 
    141         group_id = column( Integer, primary_key=True ) 
    142         group_name = column( Unicode(16), unique=True ) 
    143         display_name = column( Unicode(255) ) 
    144         created = column( DateTime, default=datetime.now ) 
    145  
    146         users = many_to_many( "User", user_group, backref="groups" ) 
    147         permissions = many_to_many( "Permission", group_permission, 
    148                                    backref="groups" ) 
     173        group_id = column(Integer, primary_key=True) 
     174        group_name = column(Unicode(16), unique=True) 
     175        display_name = column(Unicode(255)) 
     176        created = column(DateTime, default=datetime.now) 
     177 
     178        users = many_to_many("User", user_group, backref="groups") 
     179        permissions = many_to_many("Permission", group_permission, 
     180                                   backref="groups") 
    149181 
    150182 
    …… 
    155187    class mapping: 
    156188        __table__="tg_user" 
    157         user_id = column( Integer, primary_key=True ) 
    158         user_name = column( Unicode(16), unique=True ) 
    159         email_address = column( Unicode(255), unique=True ) 
    160         display_name = column( Unicode(255) ) 
    161         password = column( Unicode(40) ) 
    162         created = column( DateTime, default=datetime.now ) 
    163  
    164         groups = many_to_many( "Group", user_group, backref="users" ) 
    165  
    166     def permissions( self ): 
     189        user_id = column(Integer, primary_key=True) 
     190        user_name = column(Unicode(16), unique=True) 
     191        email_address = column(Unicode(255), unique=True) 
     192        display_name = column(Unicode(255)) 
     193        password = column(Unicode(40)) 
     194        created = column(DateTime, default=datetime.now) 
     195 
     196        groups = many_to_many("Group", user_group, backref="users") 
     197 
     198    def permissions(self): 
    167199        perms = set() 
    168200        for g in self.groups: 
    …… 
    175207    class mapping: 
    176208        __table__="permission" 
    177         permission_id = column( Integer, primary_key=True ) 
    178         permission_name = column( Unicode(16), unique=True ) 
    179         description = column( Unicode(255) ) 
    180          
    181         groups = many_to_many( "Group", group_permission, 
    182                               backref="permmissions" ) 
    183 #end if 
     209        permission_id = column(Integer, primary_key=True) 
     210        permission_name = column(Unicode(16), unique=True) 
     211        description = column(Unicode(255)) 
     212         
     213        groups = many_to_many("Group", group_permission, 
     214