Changeset 5349

Timestamp:

09/03/08 14:46:32 (4 months ago)

Author:

deets

Message:

added elixir support + identity implementations for that

Files:

• projects/tg.devtools/trunk/devtools/commands/quickstart.py (modified) (1 diff)
• projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/model/identity.py_tmpl (modified) (2 diffs)
• projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/model/__init__.py_tmpl (modified) (4 diffs)

projects/tg.devtools/trunk/devtools/commands/quickstart.py

@@ -105 +105 @@
-            help="dry run (don't actually do anything)",
-            action="store_true", dest="dry_run")
+    parser.add_option("-e", "--elixir", 
+            help="use elixir as ORM.", action="store_true",
+            dest="elixir", default = False,)
+
-
-    def command(self):

projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/model/identity.py_tmpl

@@ -1 +1 @@
-{{if identity == "sqlalchemy"}}
+{{if not elixir}}
-import md5
-import sha
@@ -173 +174 @@
-    groups = relation(Group, secondary=group_permission_table,
-                      backref='permissions')
-
-{{endif}}
+{{if elixir}}
+
+from sqlalchemy.orm import scoped_session, sessionmaker
+from datetime import datetime
+import elixir
+from elixir import Entity, Field
+from elixir import DateTime, Unicode
+from elixir import using_options
+from elixir import ManyToMany
+
+from tg import config
+
+# Global session manager.  DBSession() returns the session object
+# appropriate for the current web request.
+maker = sessionmaker(autoflush=True, autocommit=False)
+DBSession = scoped_session(maker)
+
+metadata = elixir.metadata
+
+metadata.bind = "sqlite:///:memory:"
+metadata.bind.echo = True
+
+class User(Entity):
+    """Reasonably basic User definition. Probably would want additional
+    attributes.
+    """
+    using_options(tablename="tg_user", auto_primarykey="user_id")
+
+    user_name = Field(Unicode(16), required=True, unique=True)
+    
+    email_address = Field(Unicode(255), required=True, unique=True)
+
+    display_name = Field(Unicode(255))
+
+    created = Field(DateTime, default=datetime.now)
+
+    _password = Field(Unicode(40), colname="password", required=True)
+
+    groups = ManyToMany(
+        "Group",
+        inverse="users",
+        tablename="tg_user_group",
+        local_colname="group_id",
+        remote_colname="user_id",
+        )
+    
+    def __repr__(self):
+        return '<User: email="%s", display name="%s">' % (
+                self.email_address, self.display_name)
+
+
+
+    @property
+    def permissions(self):
+        perms = set()
+        for g in self.groups:
+            perms = perms | set(g.permissions)
+        return perms
+
+    @classmethod
+    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 DBSession.query(cls).filter(cls.email_address==email).first()
+
+    @classmethod
+    def by_user_name(cls, username):
+        """A class method that permits to search users
+        based on their user_name attribute.
+        """
+        return DBSession.query(cls).filter(cls.user_name==username).first()
+
+
+    def _set_password(self, password):
+        """encrypts password on the fly using the encryption
+        algo defined in the configuration
+        """
+        algorithm = config.get('authorize.hashmethod', None)
+        self._password = self.__encrypt_password(algorithm, password)
+
+    def _get_password(self):
+        """returns password
+        """
+        return self._password
+
+    password = descriptor=property(_get_password, _set_password)
+
+    def __encrypt_password(self, algorithm, password):
+        """Hash the given password with the specified algorithm. Valid values
+        for algorithm are 'md5' and 'sha1'. All other algorithm values will
+        be essentially a no-op."""
+        hashed_password = password
+
+        if isinstance(password, unicode):
+            password_8bit = password.encode('UTF-8')
+
+        else:
+            password_8bit = password
+
+        if "md5" == algorithm:
+            hashed_password = md5.new(password_8bit).hexdigest()
+
+        elif "sha1" == algorithm:
+            hashed_password = sha.new(password_8bit).hexdigest()
+
+        # TODO: re-add the possibility to provide own hasing algo
+        # here... just get the real config...
+
+        #elif "custom" == algorithm:
+        #    custom_encryption_path = turbogears.config.get(
+        #        "identity.custom_encryption", None )
+        #
+        #    if custom_encryption_path:
+        #        custom_encryption = turbogears.util.load_class(
+        #            custom_encryption_path)
+
+        #    if custom_encryption:
+        #        hashed_password = custom_encryption(password_8bit)
+
+        # make sure the hased password is an UTF-8 object at the end of the
+        # process because SQLAlchemy _wants_ a unicode object for Unicode columns
+        if not isinstance(hashed_password, unicode):
+            hashed_password = hashed_password.decode('UTF-8')
+
+        return hashed_password
+
+    def validate_password(self, password):
+        """Check the password against existing credentials.
+        """
+        identity = config.get('identity', None)
+        if identity is None:
+            return password
+        algorithm = identity.get('password_encryption_method', None)
+        return self.password == self.__encrypt_password(algorithm, password)
+
+
+class Group(Entity):
+    """An ultra-simple group definition.
+    """
+    using_options(tablename="tg_group", auto_primarykey="group_id")
+    
+    group_name = Field(Unicode(16), unique=True)
+    
+    display_name = Field(Unicode(255))
+    
+    created = Field(DateTime, default=datetime.now)
+    
+    users = ManyToMany("User")
+
+    permissions = ManyToMany(
+        "Permission",
+        inverse="groups",
+        tablename="tg_group_permission",
+        local_colname="group_id",
+        remote_colname="permission_id",
+        )
+
+    def __repr__(self):
+        return '<Group: name=%s>' % self.group_name
+
+
+class Permission(Entity):
+    """A relationship that determines what each Group can do
+    """
+    using_options(tablename="tg_permission", auto_primarykey="permission_id")
+    
+    permission_name = Field(Unicode(16), unique=True)
+    
+    description = Field(Unicode(255))
+
+    groups = ManyToMany("Group")
+    
+{{endif}}
+{{endif}}

projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/model/__init__.py_tmpl

@@ -4 +4 @@
-from zope.sqlalchemy import ZopeTransactionExtension
-from sqlalchemy.orm import scoped_session, sessionmaker
+{{if not elixir}}
-#from sqlalchemy import MetaData
-from sqlalchemy.ext.declarative import declarative_base
-
+
+
+
+
-
-# Global session manager.  DBSession() returns the session object
@@ -17 +21 @@
-# extension, but if you need more control, you can switch to the traditional
-# method.
+{{if not elixir}}
-DeclarativeBase = declarative_base()
-
@@ -22 +27 @@
-# The default metadata is the one from the declarative base.
-metadata = DeclarativeBase.metadata
+{{endif}}
+{{if elixir}}
+metadata = elixir.metadata
+{{endif}}
-# If you have multiple databases with overlapping table names, you'll need a
-# metadata for each database. Feel free to rename 'metadata2'.
@@ -62 +71 @@
-{{endif}}
-
+{{if elixir}}
+# setup the elixir models
+elixir.setup_all()
+{{endif}}