Remove the Elixir dependency by using an SQLAlchemy model for now.

2 files changed, 177 insertions, 99 deletions

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()