kallithea Changeset - 2ccb32ddcfd7

Changeset - 2ccb32ddcfd7

Parent rev.

Child rev.

[Not reviewed]

beta

0 3 2

Nicolas VINOT - 14 years ago 2011-10-02 17:39:52
aeris@imirhil.fr

Transplanted from: fecfb43a75f2

Add API for repositories and groups (creation, permission)

5 files changed with 232 insertions and 58 deletions:

rhodecode/controllers/api/api.py

rhodecode/model/db.py

rhodecode/model/repo_permission.py

rhodecode/model/user.py

rhodecode/model/users_group.py

0 comments (0 inline, 0 general)

rhodecode/controllers/api/api.py

➞

Show inline comments

 import traceback
 import logging
 from rhodecode.controllers.api import JSONRPCController, JSONRPCError
 from rhodecode.lib.auth import HasPermissionAllDecorator, HasPermissionAnyDecorator
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.db import User, UsersGroup, UsersGroupMember, Group, Repository
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.users_group import UsersGroupModel
 from rhodecode.model.repo_permission import RepositoryPermissionModel
 log = logging.getLogger(__name__)
 class ApiController(JSONRPCController):
     """
     API Controller
     Each method needs to have USER as argument this is then based on given
     API_KEY propagated as instance of user object
@@ @@ -39,155 +42,203 @@ class ApiController(JSONRPCController): @@
         if Repository.is_valid(repo) is False:
             raise JSONRPCError('Unknown repo "%s"' % repo)
         try:
             ScmModel().pull_changes(repo, self.rhodecode_user.username)
             return 'Pulled from %s' % repo
         except Exception:
             raise JSONRPCError('Unable to pull changes from "%s"' % repo)
     @HasPermissionAllDecorator('hg.admin')
     def create_user(self, apiuser, username, password, name,
     def list_users(self, apiuser):
         """"
         Lists all users
         :param apiuser
         """
         result = []
         for user in User.getAll():
             result.append( dict(id = user.user_id,
                                 username = user.username,
                                 firstname = user.name,
                                 lastname = user.lastname,
                                 email = user.email,
                                 active = user.active,
                                 admin = user.admin) )
         return result
     @HasPermissionAllDecorator('hg.admin')
     def create_user(self, apiuser, username, password, firstname,
                     lastname, email, active=True, admin=False, ldap_dn=None):
         """
         Creates new user
         :param apiuser:
         :param username:
         :param password:
         :param name:
         :param lastname:
         :param email:
         :param active:
         :param admin:
         :param ldap_dn:
         """
         try:
         form_data = dict(username=username,
                          password=password,
                          active=active,
                          admin=admin,
-                         name=name,
+                             name=firstname,
                          lastname=lastname,
                          email=email,
                          ldap_dn=ldap_dn)
         try:
             u = User.create(form_data)
             return {'id':u.user_id,
                     'msg':'created new user %s' % name}
             UserModel().create_ldap(username, password, ldap_dn, form_data)
             return dict(msg='created new user %s' % username)
         except Exception:
             log.error(traceback.format_exc())
-            raise JSONRPCError('failed to create user %s' % name)
+            raise JSONRPCError('failed to create user %s' % username)
     @HasPermissionAllDecorator('hg.admin')
-    def list_users(self, apiuser):
+    def list_users_groups(self, apiuser):
         """"
         Lists all users
+        Lists all users groups
         :param apiuser
         """
         result = []
         for user in User.getAll():
             result.append({ 'username':user.username,
                             'name': user.name,
                             'lastname': user.lastname,
                             'email': user.email })
         for users_group in UsersGroup.getAll():
             result.append( dict(id=users_group.users_group_id,
                                 name=users_group.users_group_name,
                                 active=users_group.users_group_active) )
         return result
     @HasPermissionAllDecorator('hg.admin')
     def create_users_group(self, apiuser, name, active=True):
         """
         Creates an new usergroup
         :param name:
         :param active:
         """
         form_data = {'users_group_name':name,
                      'users_group_active':active}
         try:
             ug = UsersGroup.create(form_data)
             return {'id':ug.users_group_id,
                     'msg':'created new users group %s' % name}
             form_data = dict(users_group_name=name,
                              users_group_active=active)
             ug = UsersGroupModel().create(form_data)
             return dict(id=ug.users_group_id,
                         msg='created new users group %s' % name)
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create group %s' % name)
     @HasPermissionAllDecorator('hg.admin')
     def list_users_groups(self, apiuser):
         """"
         Lists all users groups
         :param apiuser
         """
         result = []
         for users_group in UsersGroup.getAll():
             result.append({ 'name': users_group.name })
         return result
     @HasPermissionAllDecorator('hg.admin')
     def add_user_to_group(self, apiuser, user_name, group_name):
     def add_user_to_users_group(self, apiuser, user_name, group_name):
         """"
         Add a user to a group
         :param apiuser
         :param user_name
         :param group_name
         """
         try:
         users_group = UsersGroup.get_by_group_name(group_name)
         if not users_group:
             raise JSONRPCError('unknown users group %s' % group_name)
         user = User.by_username(user_name)
         if not user:
             raise JSONRPCError('unknown user %s' % user_name)
         try:
             UsersGroupMember.create(user, users_group)
             ugm = UsersGroupModel().add_user_to_group(users_group, user)
             return dict(id=ugm.users_group_member_id,
                         msg='created new users group member')
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create users group member')
     @HasPermissionAnyDecorator('hg.admin')
     def list_repos(self, apiuser):
         """"
         Lists all repositories
         :param apiuser
         """
         result = []
         for repository in Repository.getAll():
             result.append( dict(id=repository.repo_id,
                                 name=repository.repo_name,
                                 type=repository.repo_type,
                                 description=repository.description) )
         return result
     @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
     def create_repo(self, apiuser, name, owner_name, description=None, repo_type='hg', \
                     private=False, group_name=None):
         """
         Create a repository
         :param apiuser
         :param name
         :param description
         :param type
         :param private
         :param owner_name
         :param group_name
         :param clone
         """
         try:
         if group_name:
             group = Group.get_by_group_name(group_name)
             if group is None:
                 raise JSONRPCError('unknown group %s' % group_name)
         else:
             group = None
         owner = User.by_username(owner_name)
         if owner is None:
             raise JSONRPCError('unknown user %s' % owner)
         try:
             RepoModel().create({ "repo_name" : name,
                                  "repo_name_full" : name,
                                  "description" : description,
                                  "private" : private,
                                  "repo_type" : repo_type,
                                  "repo_group" : group,
                                  "clone_uri" : None }, owner)
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create repository %s' % name)
     @HasPermissionAnyDecorator('hg.admin')
     def add_user_perm_to_repo(self, apiuser, repo_name, user_name, perm):
         """
         Add permission for a user to a repository
         :param apiuser
         :param repo_name
         :param user_name
         :param perm
         """
         try:
             repo = Repository.by_repo_name(repo_name)
             if repo is None:
                 raise JSONRPCError('unknown repository %s' % repo)
             user = User.by_username(user_name)
             if user is None:
                 raise JSONRPCError('unknown user %s' % user)
             RepositoryPermissionModel() \
                 .updateOrDeleteUserPermission(repo, user, perm)
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to edit permission %(repo)s for %(user)s'
                             % dict( user = user_name, repo = repo_name ) )

rhodecode/model/db.py

➞

Show inline comments

@@ @@ -445,40 +445,24 @@ class UsersGroupMember(Base, BaseModel): @@
     users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     user = relationship('User', lazy='joined')
     users_group = relationship('UsersGroup')
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
         self.user_id = u_id
     @classmethod
     def create(cls, user, users_group):
         try:
             users_group_member = cls()
             users_group_member.user = user
             users_group_member.users_group = users_group
             Session.add(users_group_member)
             Session.commit()
             return users_group_member
         except:
             log.error(traceback.format_exc())
             Session.rollback()
             raise
 class Repository(Base, BaseModel):
     __tablename__ = 'repositories'
     __table_args__ = (UniqueConstraint('repo_name'), {'extend_existing':True},)
     repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     repo_name = Column("repo_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
     clone_uri = Column("clone_uri", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=False, default=None)
     repo_type = Column("repo_type", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=False, default='hg')
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
     private = Column("private", Boolean(), nullable=True, unique=None, default=None)
     enable_statistics = Column("statistics", Boolean(), nullable=True, unique=None, default=True)
     enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True)
@@ @@ -809,28 +793,24 @@ class Permission(Base, BaseModel): @@
     permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     permission_name = Column("permission_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     permission_longname = Column("permission_longname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     def __repr__(self):
         return "<%s('%s:%s')>" % (self.__class__.__name__,
                                   self.permission_id, self.permission_name)
     @classmethod
     def get_by_key(cls, key):
         return cls.query().filter(cls.permission_name == key).scalar()
     @classmethod
     def get_by_name(cls, name):
         return cls.query().filter(cls.permission_name == name).one()
 class RepoToPerm(Base, BaseModel):
     __tablename__ = 'repo_to_perm'
     __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'extend_existing':True})
     repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
     user = relationship('User')
     permission = relationship('Permission')
     repository = relationship('Repository')

rhodecode/model/repo_permission.py

➞

Show inline comments

@@ new file 100644 @@
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.users_group
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
     repository permission model for RhodeCode
     :created_on: Oct 1, 2011
     :author: nvinot
     :copyright: (C) 2011-2011 Nicolas Vinot <aeris@imirhil.fr>
     :license: GPLv3, see COPYING for more details.
 """
 # 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, either version 3 of the License, or
 # (at your option) any later version.
+#
 # 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, see <http://www.gnu.org/licenses/>.
 import logging
 from rhodecode.model.db import BaseModel, RepoToPerm, Permission
 from rhodecode.model.meta import Session
 log = logging.getLogger(__name__)
 class RepositoryPermissionModel(BaseModel):
     def getUserPermission(self, repository, user):
         return RepoToPerm.query() \
                 .filter(RepoToPerm.user == user) \
                 .filter(RepoToPerm.repository == repository) \
                 .scalar()
     def updateUserPermission(self, repository, user, permission):
         permission = Permission.get_by_key(permission)
         current = self.getUserPermission(repository, user)
         if current:
             if not current.permission is permission:
                 current.permission = permission
         else:
             p = RepoToPerm()
             p.user = user
             p.repository = repository
             p.permission = permission
             Session.add(p)
         Session.commit()
     def deleteUserPermission(self, repository, user):
         current = self.getUserPermission(repository, user)
         Session.delete(current)
         Session.commit()
     def updateOrDeleteUserPermission(self, repository, user, permission):
         if permission:
             self.updateUserPermission(repository, user, permission)
         else:
             self.deleteUserPermission(repository, user)
@@ \ No newline at end of file @@

rhodecode/model/user.py

➞

Show inline comments

@@ @@ -39,25 +39,24 @@ from sqlalchemy.exc import DatabaseError @@
 from rhodecode.lib import generate_api_key
 from sqlalchemy.orm import joinedload
 log = logging.getLogger(__name__)
 PERM_WEIGHTS = {'repository.none': 0,
                 'repository.read': 1,
                 'repository.write': 3,
                 'repository.admin': 3}
 class UserModel(BaseModel):
     def get(self, user_id, cache=False):
         user = self.sa.query(User)
         if cache:
             user = user.options(FromCache("sql_cache_short",
                                           "get_user_%s" % user_id))
         return user.get(user_id)
     def get_by_username(self, username, cache=False, case_insensitive=False):
         if case_insensitive:
             user = self.sa.query(User).filter(User.username.ilike(username))
         else:
@@ @@ -77,24 +76,25 @@ class UserModel(BaseModel): @@
                                           "get_user_%s" % api_key))
         return user.scalar()
     def create(self, form_data):
         try:
             new_user = User()
             for k, v in form_data.items():
                 setattr(new_user, k, v)
             new_user.api_key = generate_api_key(form_data['username'])
             self.sa.add(new_user)
             self.sa.commit()
             return new_user
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
     def create_ldap(self, username, password, user_dn, attrs):
         """
         Checks if user is in database, if not creates this user marked
         as ldap user
         :param username:
         :param password:
         :param user_dn:

rhodecode/model/users_group.py

➞

Show inline comments

@@ new file 100644 @@
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.users_group
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
     users group model for RhodeCode
     :created_on: Oct 1, 2011
     :author: nvinot
     :copyright: (C) 2011-2011 Nicolas Vinot <aeris@imirhil.fr>
     :license: GPLv3, see COPYING for more details.
 """
 # 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, either version 3 of the License, or
 # (at your option) any later version.
+#
 # 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, see <http://www.gnu.org/licenses/>.
 import logging
 import traceback
 from rhodecode.model import BaseModel
 from rhodecode.model.caching_query import FromCache
 from rhodecode.model.db import UsersGroupMember, UsersGroup
 log = logging.getLogger(__name__)
 class UsersGroupModel(BaseModel):
     def get(self, users_group_id, cache=False):
         users_group = UsersGroup.query()
         if cache:
             users_group = users_group.options(FromCache("sql_cache_short",
                                           "get_users_group_%s" % users_group_id))
         return users_group.get(users_group_id)
     def get_by_name(self, name, cache=False, case_insensitive=False):
         users_group = UsersGroup.query()
         if case_insensitive:
             users_group = users_group.filter(UsersGroup.users_group_name.ilike(name))
         else:
             users_group = users_group.filter(UsersGroup.users_group_name == name)
         if cache:
             users_group = users_group.options(FromCache("sql_cache_short",
                                           "get_users_group_%s" % name))
         return users_group.scalar()
     def create(self, form_data):
         try:
             new_users_group = UsersGroup()
             for k, v in form_data.items():
                 setattr(new_users_group, k, v)
             self.sa.add(new_users_group)
             self.sa.commit()
             return new_users_group
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
     def add_user_to_group(self, users_group, user):
         try:
             users_group_member = UsersGroupMember()
             users_group_member.user = user
             users_group_member.users_group = users_group
             self.sa.add(users_group_member)
             self.sa.commit()
             return users_group_member
         except:
             log.error(traceback.format_exc())
             self.sa.rollback()
             raise
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)