first permissions commit: added permission managment on repository edit. Changed db rmissions, validators.

pylons_app/controllers/repos.py

@@ -1,175 +1,181 b''
 #!/usr/bin/env python
 # encoding: utf-8
 # repos controller for pylons
 # Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
 # as published by the Free Software Foundation; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 # 
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 """
 Created on April 7, 2010
 admin controller for pylons
 @author: marcink
 """
 from operator import itemgetter
 from pylons import request, response, session, tmpl_context as c, url, \
     app_globals as g
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 from pylons_app.lib import helpers as h
 from pylons_app.lib.auth import LoginRequired
 from pylons_app.lib.base import BaseController, render
 from pylons_app.lib.utils import invalidate_cache
 from pylons_app.model.repo_model import RepoModel
 from pylons_app.model.hg_model import HgModel
 from pylons_app.model.forms import RepoForm
 from pylons_app.model.meta import Session
 from datetime import datetime
 import formencode
 from formencode import htmlfill
 import logging
 import os
 import shutil
 log = logging.getLogger(__name__)
 
 class ReposController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repo', 'repos')
     @LoginRequired()
     def __before__(self):
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
         super(ReposController, self).__before__()
                 
     def index(self, format='html'):
         """GET /repos: All items in the collection"""
         # url('repos')
         cached_repo_list = HgModel().get_repos()
         c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))
         return render('admin/repos/repos.html')
     
     def create(self):
         """POST /repos: Create a new item"""
         # url('repos')
         repo_model = RepoModel()
         _form = RepoForm()()
         try:
             form_result = _form.to_python(dict(request.POST))
             repo_model.create(form_result, c.hg_app_user)
             invalidate_cache('cached_repo_list')
             h.flash(_('created repository %s') % form_result['repo_name'],
                     category='success')
                                                              
         except formencode.Invalid as errors:
             c.form_errors = errors.error_dict
             c.new_repo = errors.value['repo_name']
             return htmlfill.render(
                  render('admin/repos/repo_add.html'),
                 defaults=errors.value,
                 encoding="UTF-8")        
 
         except Exception:
             h.flash(_('error occured during creation of repository %s') \
                     % form_result['repo_name'], category='error')
             
         return redirect('repos')
 
     def new(self, format='html'):
         """GET /repos/new: Form to create a new item"""
         new_repo = request.GET.get('repo', '')
         c.new_repo = h.repo_name_slug(new_repo)
 
         return render('admin/repos/repo_add.html')
 
     def update(self, id):
         """PUT /repos/id: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('repo', id=ID),
         #           method='put')
         # url('repo', id=ID)
         repo_model = RepoModel()
         _form = RepoForm(edit=True)()
         try:
             form_result = _form.to_python(dict(request.POST))
             repo_model.update(id, form_result)
             invalidate_cache('cached_repo_list')
-            h.flash(_('Repository updated succesfully'), category='success')
+            h.flash(_('Repository %s updated succesfully' % id), category='success')
                            
         except formencode.Invalid as errors:
             c.repo_info = repo_model.get(id)
+            errors.value.update({'user':c.repo_info.user.username})
             c.form_errors = errors.error_dict
             return htmlfill.render(
                  render('admin/repos/repo_edit.html'),
                 defaults=errors.value,
                 encoding="UTF-8")
         except Exception:
             h.flash(_('error occured during update of repository %s') \
                     % form_result['repo_name'], category='error')
         return redirect(url('repos'))
     
     def delete(self, id):
         """DELETE /repos/id: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('repo', id=ID),
         #           method='delete')
         # url('repo', id=ID)
         
         repo_model = RepoModel()
         repo = repo_model.get(id)
         if not repo:
             h.flash(_('%s repository is not mapped to db perhaps' 
                       ' it was moved or renamed  from the filesystem'
                       ' please run the application again'
                       ' in order to rescan repositories') % id, category='error')
         
             return redirect(url('repos'))
         try:
             repo_model.delete(repo)            
             invalidate_cache('cached_repo_list')
             h.flash(_('deleted repository %s') % id, category='success')
         except Exception:
             h.flash(_('An error occured during deletion of %s') % id,
                     category='error')
         
         return redirect(url('repos'))
         
     def show(self, id, format='html'):
         """GET /repos/id: Show a specific item"""
         # url('repo', id=ID)
         
     def edit(self, id, format='html'):
         """GET /repos/id/edit: Form to edit an existing item"""
         # url('edit_repo', id=ID)
         repo_model = RepoModel()
         c.repo_info = repo = repo_model.get(id)
         if not repo:
             h.flash(_('%s repository is not mapped to db perhaps' 
                       ' it was created or renamed from the filesystem'
                       ' please run the application again'
                       ' in order to rescan repositories') % id, category='error')
         
             return redirect(url('repos'))        
         defaults = c.repo_info.__dict__
-        defaults.update({'user':c.repo_info.user.username})        
+        defaults.update({'user':c.repo_info.user.username})
+        
+        for p in c.repo_info.repo2perm:
+            defaults.update({'perm_%s' % p.user.username: 
+                             p.permission.permission_name})
+                
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )          

pylons_app/lib/db_manage.py

@@ -1,126 +1,142 b''
 #!/usr/bin/env python
 # encoding: utf-8
 # database managment for hg app
 # Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
  
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
 # as published by the Free Software Foundation; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 # 
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 """
 Created on April 10, 2010
 database managment and creation for hg app
 @author: marcink
 """
 
 from os.path import dirname as dn, join as jn
 import os
 import sys
 ROOT = dn(dn(dn(os.path.realpath(__file__))))
 sys.path.append(ROOT)
 
 from pylons_app.lib.auth import get_crypt_password
 from pylons_app.model import init_model
 from pylons_app.model.db import User, Permission
 from pylons_app.model.meta import Session, Base
 from sqlalchemy.engine import create_engine
 import logging
 
 log = logging.getLogger('db manage')
 log.setLevel(logging.DEBUG)
 console_handler = logging.StreamHandler()
 console_handler.setFormatter(logging.Formatter("%(asctime)s.%(msecs)03d" 
                                     " %(levelname)-5.5s [%(name)s] %(message)s"))
 log.addHandler(console_handler)
 
 class DbManage(object):
     def __init__(self, log_sql):
         self.dbname = 'hg_app.db'
         dburi = 'sqlite:////%s' % jn(ROOT, self.dbname)
         engine = create_engine(dburi, echo=log_sql) 
         init_model(engine)
         self.sa = Session()
         self.db_exists = False
     
     def check_for_db(self, override):
         log.info('checking for exisiting db')
         if os.path.isfile(jn(ROOT, self.dbname)):
             self.db_exists = True
             log.info('database exisist')
             if not override:
                 raise Exception('database already exists')
 
     def create_tables(self, override=False):
         """
         Create a auth database
         """
         self.check_for_db(override)
         if override:
             log.info("database exisist and it's going to be destroyed")
             if self.db_exists:
                 os.remove(jn(ROOT, self.dbname))
         Base.metadata.create_all(checkfirst=override)
         log.info('Created tables for %s', self.dbname)
     
     def admin_prompt(self):
         import getpass
         username = raw_input('Specify admin username:')
         password = getpass.getpass('Specify admin password:')
         self.create_user(username, password, True)
         
     def create_user(self, username, password, admin=False):
+        
+        log.info('creating default user')
+        #create default user for handling default permissions.
+        def_user = User()
+        def_user.username = 'default'
+        def_user.password = 'default'
+        def_user.name = 'default'
+        def_user.lastname = 'default'
+        def_user.email = 'default@default'
+        def_user.admin = False
+        def_user.active = False
+        
+        self.sa.add(def_user)
+        
         log.info('creating administrator user %s', username)
-        
         new_user = User()
         new_user.username = username
         new_user.password = get_crypt_password(password)
-        new_user.name = 'Admin'
+        new_user.name = 'Hg'
         new_user.lastname = 'Admin'
         new_user.email = 'admin@localhost'
         new_user.admin = admin
         new_user.active = True
         
         try:
             self.sa.add(new_user)
             self.sa.commit()
         except:
             self.sa.rollback()
             raise
     
     def create_permissions(self):
         #module.(access|create|change|delete)_[name]
-        perms = [('admin.access_home', 'Access to admin user view'),
-                 
+        #module.(read|write|owner)
+        perms = [('repository.none', 'Repository no access'),
+                 ('repository.read', 'Repository read access'),
+                 ('repository.write', 'Repository write access'),
+                 ('repository.admin', 'Repository admin access'),
                  ]
         
         for p in perms:
             new_perm = Permission()
             new_perm.permission_name = p[0]
             new_perm.permission_longname = p[1]
             try:
                 self.sa.add(new_perm)
                 self.sa.commit()
             except:
                 self.sa.rollback()
                 raise
         
         
         
 if __name__ == '__main__':
     dbmanage = DbManage(log_sql=True)
     dbmanage.create_tables(override=True)
     dbmanage.admin_prompt()
     dbmanage.create_permissions()  
 
 

pylons_app/model/db.py

@@ -1,55 +1,71 b''
 from pylons_app.model.meta import Base
 from sqlalchemy.orm import relation, backref
 from sqlalchemy import *
 from vcs.utils.lazy import LazyProperty
 
 class User(Base): 
     __tablename__ = 'users'
     __table_args__ = {'useexisting':True}
     user_id = Column("user_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)
     username = Column("username", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     password = Column("password", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     active = Column("active", BOOLEAN(), nullable=True, unique=None, default=None)
     admin = Column("admin", BOOLEAN(), nullable=True, unique=None, default=None)
     name = Column("name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     lastname = Column("lastname", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     email = Column("email", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     last_login = Column("last_login", DATETIME(timezone=False), nullable=True, unique=None, default=None)
     
     user_log = relation('UserLog')
     
     @LazyProperty
     def full_contact(self):
         return '%s %s <%s>' % (self.name, self.lastname, self.email)
         
     def __repr__(self):
         return "<User('%s:%s')>" % (self.user_id, self.username)
       
 class UserLog(Base): 
     __tablename__ = 'user_logs'
     __table_args__ = {'useexisting':True}
-    user_log_id = Column("user_log_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=1)
+    user_log_id = Column("user_log_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", INTEGER(), ForeignKey(u'users.user_id'), nullable=False, unique=None, default=None)
-    repository = Column("repository", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    user_ip = Column("user_ip", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None) 
+    repository = Column("repository", TEXT(length=None, convert_unicode=False, assert_unicode=None), ForeignKey(u'repositories.repo_name'), nullable=False, unique=None, default=None)
     action = Column("action", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     action_date = Column("action_date", DATETIME(timezone=False), nullable=True, unique=None, default=None)
     
     user = relation('User')
-
+    
 class Repository(Base):
     __tablename__ = 'repositories'
+    __table_args__ = {'useexisting':True}
     repo_name = Column("repo_name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", INTEGER(), ForeignKey(u'users.user_id'), nullable=False, unique=False, default=None)
     private = Column("private", BOOLEAN(), nullable=True, unique=None, default=None)
     description = Column("description", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    
     user = relation('User')
+    repo2perm = relation('Repo2Perm', cascade='all')
     
 class Permission(Base):
     __tablename__ = 'permissions'
     __table_args__ = {'useexisting':True}
-    permission_id = Column("id", INTEGER(), nullable=False, unique=True, default=None, primary_key=1)
+    permission_id = Column("permission_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)
     permission_name = Column("permission_name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     permission_longname = Column("permission_longname", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     
     def __repr__(self):
         return "<Permission('%s:%s')>" % (self.permission_id, self.permission_name)
+
+class Repo2Perm(Base):
+    __tablename__ = 'repo_to_perm'
+    __table_args__ = (UniqueConstraint('user_id', 'permission_id', 'repository'), {'useexisting':True})
+    repo2perm_id = Column("repo2perm_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", INTEGER(), ForeignKey(u'users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", INTEGER(), ForeignKey(u'permissions.permission_id'), nullable=False, unique=None, default=None)
+    repository = Column("repository", TEXT(length=None, convert_unicode=False, assert_unicode=None), ForeignKey(u'repositories.repo_name'), nullable=False, unique=None, default=None) 
+    
+    user = relation('User')
+    permission = relation('Permission')
+    

pylons_app/model/forms.py

@@ -1,203 +1,238 b''
 """ this is forms validation classes
 http://formencode.org/module-formencode.validators.html
 for list off all availible validators
 
 we can create our own validators
 
 The table below outlines the options which can be used in a schema in addition to the validators themselves
 pre_validators          []     These validators will be applied before the schema
 chained_validators      []     These validators will be applied after the schema
 allow_extra_fields      False     If True, then it is not an error when keys that aren't associated with a validator are present
 filter_extra_fields     False     If True, then keys that aren't associated with a validator are removed
 if_key_missing          NoDefault If this is given, then any keys that aren't available but are expected will be replaced with this value (and then validated). This does not override a present .if_missing attribute on validators. NoDefault is a special FormEncode class to mean that no default values has been specified and therefore missing keys shouldn't take a default value.
 ignore_key_missing      False     If True, then missing keys will be missing in the result, if the validator doesn't have .if_missing on it already    
   
   
 <name> = formencode.validators.<name of validator>
 <name> must equal form name
 list=[1,2,3,4,5]
 for SELECT use formencode.All(OneOf(list), Int())
     
 """
 from formencode import All
 from formencode.validators import UnicodeString, OneOf, Int, Number, Regex, \
     Email, Bool, StringBoolean
 from pylons import session
 from pylons.i18n.translation import _
 from pylons_app.lib.auth import get_crypt_password
 import pylons_app.lib.helpers as h
 from pylons_app.model import meta
 from pylons_app.model.db import User, Repository
 from sqlalchemy.exc import OperationalError
 from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
 from webhelpers.pylonslib.secure_form import authentication_token
 import datetime
 import formencode
 import logging
 log = logging.getLogger(__name__)
 
 
 #this is needed to translate the messages using _() in validators
 class State_obj(object):
     _ = staticmethod(_)
     
 #===============================================================================
 # VALIDATORS
 #===============================================================================
 class ValidAuthToken(formencode.validators.FancyValidator):
     messages = {'invalid_token':_('Token mismatch')}
 
     def validate_python(self, value, state):
 
         if value != authentication_token():
             raise formencode.Invalid(self.message('invalid_token', state,
                                             search_number=value), value, state)
 class ValidUsername(formencode.validators.FancyValidator):
 
     def validate_python(self, value, state):
-        pass
+        if value in ['default', 'new_user']:
+            raise formencode.Invalid(_('Invalid username'), value, state)
     
 class ValidPassword(formencode.validators.FancyValidator):
     
     def to_python(self, value, state):
         return get_crypt_password(value)
         
 class ValidAuth(formencode.validators.FancyValidator):
     messages = {
             'invalid_password':_('invalid password'),
             'invalid_login':_('invalid user name'),
             'disabled_account':_('Your acccount is disabled')
             
             }
     #error mapping
     e_dict = {'username':messages['invalid_login'],
               'password':messages['invalid_password']}
     e_dict_disable = {'username':messages['disabled_account']}
     
     def validate_python(self, value, state):
         sa = meta.Session
         crypted_passwd = get_crypt_password(value['password'])
         username = value['username']
         try:
             user = sa.query(User).filter(User.username == username).one()
         except (NoResultFound, MultipleResultsFound, OperationalError) as e:
             log.error(e)
             user = None
             raise formencode.Invalid(self.message('invalid_password',
                                      state=State_obj), value, state,
                                      error_dict=self.e_dict)            
         if user:
             if user.active:
                 if user.username == username and user.password == crypted_passwd:
                     from pylons_app.lib.auth import AuthUser
                     auth_user = AuthUser()
                     auth_user.username = username
                     auth_user.is_authenticated = True
                     auth_user.is_admin = user.admin
                     auth_user.user_id = user.user_id
                     session['hg_app_user'] = auth_user
                     session.save()
                     log.info('user %s is now authenticated', username)
                     
                     try:
                         user.last_login = datetime.datetime.now()
                         sa.add(user)
                         sa.commit()                        
                     except (OperationalError) as e:
                         log.error(e)
                         sa.rollback()
                     
                     return value
                 else:
                     log.warning('user %s not authenticated', username)
                     raise formencode.Invalid(self.message('invalid_password',
                                              state=State_obj), value, state,
                                              error_dict=self.e_dict)
             else:
                 log.warning('user %s is disabled', username)
                 raise formencode.Invalid(self.message('disabled_account',
                                          state=State_obj),
                                          value, state,
                                          error_dict=self.e_dict_disable)
             
             
 class ValidRepoUser(formencode.validators.FancyValidator):
             
     def to_python(self, value, state):
         sa = meta.Session
         try:
             self.user_db = sa.query(User).filter(User.username == value).one()
         except Exception:
             raise formencode.Invalid(_('This username is not valid'),
                                      value, state)
         return self.user_db.user_id
 
 def ValidRepoName(edit=False):    
     class _ValidRepoName(formencode.validators.FancyValidator):
             
         def to_python(self, value, state):
             slug = h.repo_name_slug(value)
             
             sa = meta.Session
             if sa.query(Repository).get(slug) and not edit:
                 raise formencode.Invalid(_('This repository already exists'),
                                          value, state)
                         
             return slug 
     return _ValidRepoName
+
+class ValidPerms(formencode.validators.FancyValidator):
+    messages = {'perm_new_user_name':_('This username is not valid')}
+    
+    def to_python(self, value, state):
+        perms_update = []
+        perms_new = []
+        #build a list of permission to update and new permission to create
+        for k, v in value.items():
+            print k, v
+            if k.startswith('perm_'):
+                if  k.startswith('perm_new_user'):
+                    new_perm = value.get('perm_new_user', False)
+                    new_user = value.get('perm_new_user_name', False)
+                    if new_user and new_perm:
+                        if (new_user, new_perm) not in perms_new:
+                            perms_new.append((new_user, new_perm))
+                else:
+                    perms_update.append((k[5:], v))
+                #clear from form list
+                #del value[k]
+        value['perms_updates'] = perms_update
+        value['perms_new'] = perms_new
+        sa = meta.Session
+        for k, v in perms_new:
+            try:
+                self.user_db = sa.query(User).filter(User.username == k).one()
+            except Exception:
+                msg = self.message('perm_new_user_name',
+                                     state=State_obj)
+                raise formencode.Invalid(msg, value, state, error_dict={'perm_new_user_name':msg})            
+        return value
+                
 #===============================================================================
 # FORMS        
 #===============================================================================
 class LoginForm(formencode.Schema):
     allow_extra_fields = True
     filter_extra_fields = True
     username = UnicodeString(
                              strip=True,
                              min=3,
                              not_empty=True,
                              messages={
                                        'empty':_('Please enter a login'),
                                        'tooShort':_('Enter a value %(min)i characters long or more')}
                             )
 
     password = UnicodeString(
                             strip=True,
                             min=3,
                             not_empty=True,
                             messages={
                                       'empty':_('Please enter a password'),
                                       'tooShort':_('Enter a value %(min)i characters long or more')}
                                 )
 
 
     #chained validators have access to all data
     chained_validators = [ValidAuth]
     
 def UserForm(edit=False):
     class _UserForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         username = All(UnicodeString(strip=True, min=3, not_empty=True), ValidUsername)
         if edit:
             new_password = All(UnicodeString(strip=True, min=3, not_empty=False), ValidPassword)
         else:
             password = All(UnicodeString(strip=True, min=3, not_empty=False), ValidPassword)
         active = StringBoolean(if_missing=False)
         name = UnicodeString(strip=True, min=3, not_empty=True)
         lastname = UnicodeString(strip=True, min=3, not_empty=True)
         email = Email(not_empty=True)
         
     return _UserForm
 
 def RepoForm(edit=False):
     class _RepoForm(formencode.Schema):
         allow_extra_fields = True
-        filter_extra_fields = True
+        filter_extra_fields = False
         repo_name = All(UnicodeString(strip=True, min=1, not_empty=True), ValidRepoName(edit))
         description = UnicodeString(strip=True, min=3, not_empty=True)
         private = StringBoolean(if_missing=False)
         
         if edit:
             user = All(Int(not_empty=True), ValidRepoUser)
         
+        chained_validators = [ValidPerms]
     return _RepoForm

pylons_app/model/repo_model.py

@@ -1,106 +1,145 b''
 #!/usr/bin/env python
 # encoding: utf-8
 # model for handling repositories actions
 # Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
 # as published by the Free Software Foundation; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 # 
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 """
 Created on Jun 5, 2010
 model for handling repositories actions
 @author: marcink
 """
 from pylons_app.model.meta import Session
-from pylons_app.model.db import Repository
+from pylons_app.model.db import Repository, Repo2Perm, User, Permission
 import shutil
 import os
 from datetime import datetime
 from pylons_app.lib.utils import check_repo
 from pylons import app_globals as g
+import traceback
 import logging
 log = logging.getLogger(__name__)
 
 class RepoModel(object):
     
     def __init__(self):
         self.sa = Session()
     
     def get(self, id):
         return self.sa.query(Repository).get(id)
         
     
-    def update(self, id, form_data):
+    def update(self, repo_id, form_data):
         try:
-            if id != form_data['repo_name']:
-                self.__rename_repo(id, form_data['repo_name'])
-            cur_repo = self.sa.query(Repository).get(id)
+            if repo_id != form_data['repo_name']:
+                self.__rename_repo(repo_id, form_data['repo_name'])
+            cur_repo = self.sa.query(Repository).get(repo_id)
             for k, v in form_data.items():
                 if k == 'user':
                     cur_repo.user_id = v
                 else:
                     setattr(cur_repo, k, v)
+            
+            #update permissions
+            for username, perm in form_data['perms_updates']:
+                r2p = self.sa.query(Repo2Perm)\
+                        .filter(Repo2Perm.user == self.sa.query(User)\
+                                .filter(User.username == username).one())\
+                        .filter(Repo2Perm.repository == repo_id).one()
                 
+                r2p.permission_id = self.sa.query(Permission).filter(
+                                                Permission.permission_name == 
+                                                perm).one().permission_id
+                self.sa.add(r2p)
+            
+            for username, perm in form_data['perms_new']:
+                r2p = Repo2Perm()
+                r2p.repository = repo_id
+                r2p.user = self.sa.query(User)\
+                                .filter(User.username == username).one()
+                
+                r2p.permission_id = self.sa.query(Permission).filter(
+                                                Permission.permission_name == 
+                                                perm).one().permission_id
+                self.sa.add(r2p)
+                                    
             self.sa.add(cur_repo)
             self.sa.commit()
-        except Exception as e:
-            log.error(e)
+        except:
+            log.error(traceback.format_exc())
             self.sa.rollback()
             raise    
     
-    def create(self, form_data, cur_user):
+    def create(self, form_data, cur_user, just_db=False):
         try:
+            repo_name = form_data['repo_name']
             new_repo = Repository()
             for k, v in form_data.items():
                 setattr(new_repo, k, v)
                 
             new_repo.user_id = cur_user.user_id
             self.sa.add(new_repo)
+
+            #create default permission
+            repo2perm = Repo2Perm()
+            repo2perm.permission_id = self.sa.query(Permission)\
+                    .filter(Permission.permission_name == 'repository.read')\
+                    .one().permission_id
+                        
+            repo2perm.repository = repo_name
+            repo2perm.user_id = self.sa.query(User)\
+                    .filter(User.username == 'default').one().user_id 
+            
+            self.sa.add(repo2perm)
             self.sa.commit()
-            self.__create_repo(form_data['repo_name'])
-        except Exception as e:
-            log.error(e)
+            if not just_db:
+                self.__create_repo(repo_name)
+        except:
+            log.error(traceback.format_exc())
             self.sa.rollback()
             raise    
                      
     def delete(self, repo):
         try:
             self.sa.delete(repo)
             self.sa.commit()
             self.__delete_repo(repo.repo_name)
-        except Exception as e:
-            log.error(e)
+        except:
+            log.error(traceback.format_exc())
             self.sa.rollback()
             raise
        
     def __create_repo(self, repo_name):        
         repo_path = os.path.join(g.base_path, repo_name)
         if check_repo(repo_name, g.base_path):
             log.info('creating repo %s in %s', repo_name, repo_path)
             from vcs.backends.hg import MercurialRepository
             MercurialRepository(repo_path, create=True)
 
     def __rename_repo(self, old, new):
         log.info('renaming repoo from %s to %s', old, new)
         old_path = os.path.join(g.base_path, old)
         new_path = os.path.join(g.base_path, new)
         shutil.move(old_path, new_path)
     
     def __delete_repo(self, name):
         rm_path = os.path.join(g.base_path, name)
         log.info("Removing %s", rm_path)
         #disable hg 
         shutil.move(os.path.join(rm_path, '.hg'), os.path.join(rm_path, 'rm__.hg'))
         #disable repo
-        shutil.move(rm_path, os.path.join(g.base_path, 'rm__%s-%s' % (datetime.today(), id)))
+        shutil.move(rm_path, os.path.join(g.base_path, 'rm__%s__%s' \
+                                          % (datetime.today(), name)))

pylons_app/templates/admin/repos/repo_edit.html

@@ -1,49 +1,109 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('Repositories administration')}
 </%def>
 <%def name="breadcrumbs()">
 	${h.link_to(u'Admin',h.url('admin_home'))}
 	 /  
 	 ${_('Repos')}
 </%def>
 <%def name="page_nav()">
 	${self.menu('admin')}
 	${self.submenu('repos')}
 </%def>
 <%def name="main()">
 	<div>
         <h2>${_('Repositories')} - ${_('edit')}</h2>
         ${h.form(url('repo', id=c.repo_info.repo_name),method='put')}
         <table>
         	<tr>
         		<td>${_('Name')}</td>
         		<td>${h.text('repo_name')}</td>
         		<td>${self.get_form_error('repo_name')}</td>
         	</tr>
         	<tr>
         		<td>${_('Description')}</td>
         		<td>${h.textarea('description',cols=23,rows=5)}</td>
         		<td>${self.get_form_error('description')}</td>
         	</tr>
         	<tr>
         		<td>${_('Private')}</td>
         		<td>${h.checkbox('private')}</td>
         		<td>${self.get_form_error('private')}</td>
         	</tr>
         	<tr>
         		<td>${_('Owner')}</td>
         		<td>${h.text('user')}</td>
         		<td>${self.get_form_error('user')}</td>
         	</tr>
         	<tr>
+        		<td>${_('Permissions')}</td>
+        		<td>
+        			<table>
+        				<tr>
+        					<td>${_('none')}</td>
+        					<td>${_('read')}</td>
+        					<td>${_('write')}</td>
+        					<td>${_('admin')}</td>
+        					<td>${_('user')}</td>
+        				</tr>
+        				
+        				%for r2p in c.repo_info.repo2perm:
+	        				<tr>
+	        					<td>${h.radio('perm_%s' % r2p.user.username,'repository.none')}</td>
+	        					<td>${h.radio('perm_%s' % r2p.user.username,'repository.read')}</td>
+	        					<td>${h.radio('perm_%s' % r2p.user.username,'repository.write')}</td>
+	        					<td>${h.radio('perm_%s' % r2p.user.username,'repository.admin')}</td>
+	        					<td>${r2p.user.username}</td>
+	        				</tr>
+						%endfor
+
+						
+						<%
+							
+							if not hasattr(c,'form_errors'):
+								d = 'display:none;'
+							else:
+								d=''
+						%>
+
+        				<tr id="add_perm_input" style="${d}">
+        					<td>${h.radio('perm_new_user','repository.none')}</td>
+        					<td>${h.radio('perm_new_user','repository.read')}</td>
+        					<td>${h.radio('perm_new_user','repository.write')}</td>
+        					<td>${h.radio('perm_new_user','repository.admin')}</td>
+        					<td>${h.text('perm_new_user_name',size=10)}</td>
+        					<td>${self.get_form_error('perm_new_user_name')}</td>     					
+        				</tr>
+        				<tr>
+        					<td colspan="4">
+        						<span id="add_perm" class="add_icon" style="cursor: pointer;">
+        						${_('Add another user')}
+        						</span>
+        					</td>
+        				</tr>
+        			</table>
+        		</td>
+        		
+        	</tr>
+        	<tr>
         		<td></td>
         		<td>${h.submit('update','update')}</td>
         	</tr>
         	        	        	
         </table>
         ${h.end_form()}
+        <script type="text/javascript">
+        	YAHOO.util.Event.onDOMReady(function(){
+				var D = YAHOO.util.Dom;
+				YAHOO.util.Event.addListener('add_perm','click',function(){
+					D.setStyle('add_perm_input','display','');
+					D.setStyle('add_perm','opacity','0.6');
+					D.setStyle('add_perm','cursor','default');
+				});
+            });
+        </script>
     </div>
 </%def>