From dfd073792ac267fffad108902858a3360926355f Mon Sep 17 00:00:00 2001 From: Luke Macken Date: Tue, 19 Feb 2008 21:53:54 -0500 Subject: Remove the Elixir dependency by using an SQLAlchemy model for now. --- funcweb/funcweb/identity/model.py | 177 ++++++++++++++++++++++++++++++++++++++ funcweb/funcweb/model.py | 99 --------------------- 2 files changed, 177 insertions(+), 99 deletions(-) create mode 100644 funcweb/funcweb/identity/model.py delete mode 100644 funcweb/funcweb/model.py (limited to 'funcweb') diff --git a/funcweb/funcweb/identity/model.py b/funcweb/funcweb/identity/model.py new file mode 100644 index 0000000..9963489 --- /dev/null +++ b/funcweb/funcweb/identity/model.py @@ -0,0 +1,177 @@ +from datetime import datetime +from turbogears.database import metadata, mapper +# import some basic SQLAlchemy classes for declaring the data model +# (see http://www.sqlalchemy.org/docs/04/ormtutorial.html) +from sqlalchemy import Table, Column, ForeignKey +from sqlalchemy.orm import relation +# import some datatypes for table columns from SQLAlchemy +# (see http://www.sqlalchemy.org/docs/04/types.html for more) +from sqlalchemy import String, Unicode, Integer, DateTime +from turbogears import identity + + +# your data tables + +# your_table = Table('yourtable', metadata, +# Column('my_id', Integer, primary_key=True) +# ) + + +# your model classes + + +# class YourDataClass(object): +# pass + + +# set up mappers between your data tables and classes + +# mapper(YourDataClass, your_table) + + +# the identity schema + +visits_table = Table('visit', metadata, + Column('visit_key', String(40), primary_key=True), + Column('created', DateTime, nullable=False, default=datetime.now), + Column('expiry', DateTime) +) + +visit_identity_table = Table('visit_identity', metadata, + Column('visit_key', String(40), primary_key=True), + Column('user_id', Integer, ForeignKey('tg_user.user_id'), index=True) +) + +groups_table = Table('tg_group', metadata, + Column('group_id', Integer, primary_key=True), + Column('group_name', Unicode(16), unique=True), + Column('display_name', Unicode(255)), + Column('created', DateTime, default=datetime.now) +) + +users_table = Table('tg_user', metadata, + Column('user_id', Integer, primary_key=True), + Column('user_name', Unicode(16), unique=True), + Column('email_address', Unicode(255), unique=True), + Column('display_name', Unicode(255)), + Column('password', Unicode(40)), + Column('created', DateTime, default=datetime.now) +) + +permissions_table = Table('permission', metadata, + Column('permission_id', Integer, primary_key=True), + Column('permission_name', Unicode(16), unique=True), + Column('description', Unicode(255)) +) + +user_group_table = Table('user_group', metadata, + Column('user_id', Integer, ForeignKey('tg_user.user_id', + onupdate='CASCADE', ondelete='CASCADE')), + Column('group_id', Integer, ForeignKey('tg_group.group_id', + onupdate='CASCADE', ondelete='CASCADE')) +) + +group_permission_table = Table('group_permission', metadata, + Column('group_id', Integer, ForeignKey('tg_group.group_id', + onupdate='CASCADE', ondelete='CASCADE')), + Column('permission_id', Integer, ForeignKey('permission.permission_id', + onupdate='CASCADE', ondelete='CASCADE')) +) + + +# the identity model + + +class Visit(object): + """ + A visit to your site + """ + def lookup_visit(cls, visit_key): + return cls.query.get(visit_key) + lookup_visit = classmethod(lookup_visit) + + +class VisitIdentity(object): + """ + A Visit that is link to a User object + """ + pass + + +class Group(object): + """ + An ultra-simple group definition. + """ + pass + + +class User(object): + """ + Reasonably basic User definition. + Probably would want additional attributes. + """ + def permissions(self): + perms = set() + for g in self.groups: + perms |= set(g.permissions) + return perms + permissions = property(permissions) + + def by_email_address(cls, email): + """ + A class method that can be used to search users + based on their email addresses since it is unique. + """ + return cls.query.filter_by(email_address=email).first() + + by_email_address = classmethod(by_email_address) + + def by_user_name(cls, username): + """ + A class method that permits to search users + based on their user_name attribute. + """ + return cls.query.filter_by(user_name=username).first() + + by_user_name = classmethod(by_user_name) + + def _set_password(self, password): + """ + encrypts password on the fly using the encryption + algo defined in the configuration + """ + self._password = identity.encrypt_password(password) + + def _get_password(self): + """ + returns password + """ + return self._password + + password = property(_get_password, _set_password) + + +class Permission(object): + """ + A relationship that determines what each Group can do + """ + pass + + +# set up mappers between identity tables and classes + +mapper(Visit, visits_table) + +mapper(VisitIdentity, visit_identity_table, + properties=dict(users=relation(User, backref='visit_identity'))) + +mapper(User, users_table, + properties=dict(_password=users_table.c.password)) + +mapper(Group, groups_table, + properties=dict(users=relation(User, + secondary=user_group_table, backref='groups'))) + +mapper(Permission, permissions_table, + properties=dict(groups=relation(Group, + secondary=group_permission_table, backref='permissions'))) diff --git a/funcweb/funcweb/model.py b/funcweb/funcweb/model.py deleted file mode 100644 index 2997cf0..0000000 --- a/funcweb/funcweb/model.py +++ /dev/null @@ -1,99 +0,0 @@ -from datetime import datetime -# import the basic Elixir classes and functions for declaring the data model -# (see http://elixir.ematia.de/trac/wiki/TutorialDivingIn) -from elixir import Entity, Field, OneToMany, ManyToOne, ManyToMany -from elixir import options_defaults, using_options, setup_all -# import some datatypes for table columns from Elixir -# (see http://www.sqlalchemy.org/docs/04/types.html for more) -from elixir import String, Unicode, Integer, DateTime -from turbogears import identity - -options_defaults['autosetup'] = False - - -# your data model - -# class YourDataClass(Entity): -# pass - - -# the identity model - - -class Visit(Entity): - """ - A visit to your site - """ - using_options(tablename='visit') - - visit_key = Field(String(40), primary_key=True) - created = Field(DateTime, nullable=False, default=datetime.now) - expiry = Field(DateTime) - - @classmethod - def lookup_visit(cls, visit_key): - return Visit.get(visit_key) - - -class VisitIdentity(Entity): - """ - A Visit that is link to a User object - """ - using_options(tablename='visit_identity') - - visit_key = Field(String(40), primary_key=True) - user = ManyToOne('User', colname='user_id', use_alter=True) - - -class Group(Entity): - """ - An ultra-simple group definition. - """ - using_options(tablename='tg_group') - - group_id = Field(Integer, primary_key=True) - group_name = Field(Unicode(16), unique=True) - display_name = Field(Unicode(255)) - created = Field(DateTime, default=datetime.now) - users = ManyToMany('User', tablename='user_group') - permissions = ManyToMany('Permission', tablename='group_permission') - - -class User(Entity): - """ - Reasonably basic User definition. - Probably would want additional attributes. - """ - using_options(tablename='tg_user') - - user_id = Field(Integer, primary_key=True) - user_name = Field(Unicode(16), unique=True) - email_address = Field(Unicode(255), unique=True) - display_name = Field(Unicode(255)) - password = Field(Unicode(40)) - created = Field(DateTime, default=datetime.now) - groups = ManyToMany('Group', tablename='user_group') - - @property - def permissions(self): - perms = set() - for g in self.groups: - perms |= set(g.permissions) - return perms - - -class Permission(Entity): - """ - A relationship that determines what each Group can do - """ - using_options(tablename='permission') - - permission_id = Field(Integer, primary_key=True) - permission_name = Field(Unicode(16), unique=True) - description = Field(Unicode(255)) - groups = ManyToMany('Group', tablename='group_permission') - - -# Set up all Elixir entities declared above - -setup_all() -- cgit