from rhodecode.model.user import UserModel

from rhodecode.model.users_group import UsersGroupModel

from rhodecode.model.repo_permission import RepositoryPermissionModel

    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,

            form_data = dict(username=username,

                             password=password,

                             active=active,

                             admin=admin,

                             name=firstname,

                             lastname=lastname,

                             email=email,

                             ldap_dn=ldap_dn)

            UserModel().create_ldap(username, password, ldap_dn, form_data)

            return dict(msg='created new user %s' % username)

            raise JSONRPCError('failed to create user %s' % username)

    def list_users_groups(self, apiuser):

        Lists all users groups

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

            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)

    def add_user_to_users_group(self, apiuser, user_name, 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)

            ugm = UsersGroupModel().add_user_to_group(users_group, user)

            return dict(id=ugm.users_group_member_id,

                        msg='created new 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

        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)

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

# -*- 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)

            return new_user

# -*- 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