Changeset 4550

Timestamp:

04/30/08 12:30:38 (3 months ago)

Author:

fredlin

Message:

enable identity option in quickstart and import tgrepozewho middleware

Files:

• projects/tg.devtools/trunk/devtools/commands/quickstart.py (modified) (3 diffs)
• projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/config/middleware.py_tmpl (modified) (2 diffs)
• projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/controllers/root.py_tmpl (modified) (2 diffs)
• projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/model/__init__.py_tmpl (modified) (2 diffs)
• projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/templates/login.html (added)
• projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/websetup.py_tmpl (modified) (1 diff)
• projects/tg.devtools/trunk/setup.py (modified) (1 diff)

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

@@ -99 +99 @@
-            help="use SQLAlchemy Elixir instead of SQLObject",
-            action="store_true", dest="elixir", default = False)
-#
-#
-#
+
+
+
-    parser.add_option("-p", "--package",
-            help="package name for the code",
@@ -140 +140 @@
-
-        doidentity = self.identity
-"""
+
-            doidentity = raw_input("Do you need Identity "
-                        "(usernames/passwords) in this project? [no] ")
-            doidentity = doidentity.lower()
-            if not doidentity or doidentity.startswith('n'):
-="none"
+ = False
-                break
-            if doidentity.startswith("y"):
@@ -158 +158 @@
-            else:
-                self.identity = "sqlobject"
-
+
-        self.name = pkg_resources.safe_name(self.name)
-

projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/config/middleware.py_tmpl

@@ -14 +14 @@
-
-from {{package}}.config.environment import load_environment
+{{if identity == "sqlalchemy"}}
+from tgrepozewho.middleware import make_who_middleware
+from {{package}}.model import User, Group, Permission, DBSession
+
+# the criterion (ie instance of column) against which to mach
+# the user name coming from a tentative login form
+user_criterion = User.user_name
+# the name of the column which is used as a unique identifier
+user_id_col = 'user_id'
+{{endif}}
-
-def make_app(global_conf, full_stack=True, **app_conf):
@@ -50 +60 @@
-    app = TGWidgetsMiddleware(app, host_framework)
-
+{{if identity == "sqlalchemy"}}
+    # Identity Middleware
+    app = make_who_middleware(app, config, User, user_criterion, user_id_col,
+            DBSession)
+{{endif}}
+
-    if asbool(full_stack):
-        # Handle Python exceptions

projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/controllers/root.py_tmpl

@@ -4 +4 @@
-from pylons.i18n import ugettext as _
-#from tg import redirect, validate
-
+
+
+
+
+
+
+
-
-class RootController(BaseController):
-
+
+
+
-    @expose('{{package}}.templates.index')
-    def index(self):
@@ -16 +24 @@
-    def about(self):
-        return dict(page='about')
+
+{{if identity == "sqlalchemy"}}
+    @expose('{{package}}.templates.about')
+    @authorize.require(authorize.has_permission('manage'))
+    def manage_permission_only(self, **kw):
+        return dict(page='about')
+
+    @expose('{{package}}.templates.about')
+    @authorize.require(authorize.is_user('editor'))
+    def editor_user_only(self, **kw):
+        return dict(page='about')
+
+    @expose('{{package}}.templates.login')
+    def login(self, **kw):
+        came_from = kw.get('came_from', '/')
+        return dict(page='login', header=lambda *arg: None,
+                    footer=lambda *arg: None, came_from=came_from)
+{{endif}}

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

@@ -5 +5 @@
-from pylons import config
-
-
+Integer, Unicode, DateTime, 
-from sqlalchemy.orm import mapper, relation
-
-
+
+
+
+
+
+
+
+
-# appropriate for the current web request.
-DBSession = scoped_session(sessionmaker(autoflush=True, transactional=True))
@@ -33 +39 @@
-    #mapper(Reflected, t_reflected)
-
+{{if identity == "sqlalchemy"}}
+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.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.datetime.now)
+)
+
+permissions_table = Table('tg_permission', metadata,
+    Column('permission_id', Integer, primary_key=True),
+    Column('permission_name', Unicode(16), unique=True),
+    Column('description', Unicode(255))
+)
+
+user_group_table = Table('tg_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('tg_group_permission', metadata,
+    Column('group_id', Integer, ForeignKey('tg_group.group_id',
+        onupdate="CASCADE", ondelete="CASCADE")),
+    Column('permission_id', Integer, ForeignKey('tg_permission.permission_id',
+        onupdate="CASCADE", ondelete="CASCADE"))
+)
+# identity model
+class Group(object):
+    """An ultra-simple group definition.
+    """
+    def __repr__(self):
+        return '<Group: name=%s>' % self.group_name
+
+class User(object):
+    """Reasonably basic User definition. Probably would want additional
+    attributes.
+    """
+    def __repr__(self):
+        return '<User: email="%s", display name="%s">' % (
+                self.email_address, self.display_name)
+
+    def permissions(self):
+        perms = set()
+        for g in self.groups:
+            perms = perms | set(g.permissions)
+        return perms
+    permissions = property(permissions)
+
+    def by_email_address(klass, email):
+        """A class method that can be used to search users
+        based on their email addresses since it is unique.
+        """
+        session = DBSession()
+        return session.query(klass).filter(klass.email_address==email).first()
+
+    by_email_address = classmethod(by_email_address)
+
+    def by_user_name(klass, username):
+        """A class method that permits to search users
+        based on their user_name attribute.
+        """
+        session = DBSession()
+        return session.query(klass).filter(klass.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
+        """
+        algorithm = config.get('authorize.hashmethod', None)
+        self._password = self.__encrypt_password(algorithm, password)
+
+    def _get_password(self):
+        """returns password
+        """
+        return self._password
+
+    password = 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.
+        """
+        algorithm = config.get('authorize.hashmethod', None)
+        return self.password == self.__encrypt_password(algorithm, password)
+
+class Permission(object):
+    """A relationship that determines what each Group can do
+    """
+    pass
+
+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')))
+{{endif}}
-# Normal tables may be defined and mapped at module level.
-

projects/tg.devtools/trunk/devtools/templates/turbogears/+package+/websetup.py_tmpl

@@ -18 +18 @@
-    print "Creating tables"
-    model.metadata.create_all(bind=config['pylons.app_globals'].sa_engine)
+
+    {{if identity == "sqlalchemy"}}
+    u = model.User()
+    u.user_name = u'manager'
+    u.display_name = u'Exemple manager'
+    u.email_address = u'manager@somedomain.com'
+    u.password = u'managepass'
+
+    model.DBSession.save(u)
+
+    g = model.Group()
+    g.group_name = u'managers'
+    g.display_name = u'Managers Group'
+
+    g.users.append(u)
+
+    model.DBSession.save(g)
+
+    p = model.Permission()
+    p.permission_name = u'manage'
+    p.description = u'This permission give an administrative right to the bearer'
+    p.groups.append(g)
+
+    model.DBSession.save(p)
+    model.DBSession.flush()
+
+    u1 = model.User()
+    u1.user_name = u'editor'
+    u1.display_name = u'Exemple editor'
+    u1.email_address = u'editor@somedomain.com'
+    u1.password = u'editpass'
+
+    model.DBSession.save(u1)
+    model.DBSession.flush()
+    {{endif}}
+
-    model.DBSession.commit()
-    print "Successfully setup"

projects/tg.devtools/trunk/setup.py

@@ -21 +21 @@
-        'TurboGears2', 'sqlalchemy-migrate >= 0.4.4',
-        'tw.forms', 'DBSprockets',
+        'tgrepozewho'
-    ],
-    entry_points='''