# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.admin.users_groups

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    User Groups crud controller for pylons

    :created_on: Jan 25, 2011

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :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

import formencode

from formencode import htmlfill

from pylons import request, session, tmpl_context as c, url, config

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.utils2 import safe_unicode, str2bool

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.meta import Session

from rhodecode.lib.utils import action_logger

from sqlalchemy.orm import joinedload

log = logging.getLogger(__name__)

class UsersGroupsController(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('users_group', 'users_groups')

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(UsersGroupsController, self).__before__()

        c.available_permissions = config['available_permissions']

    def index(self, format='html'):

        """GET /users_groups: All items in the collection"""

        # url('users_groups')

        return render('admin/users_groups/users_groups.html')

    def create(self):

        """POST /users_groups: Create a new item"""

        # url('users_groups')

        try:

            form_result = users_group_form.to_python(dict(request.POST))

                                     active=form_result['users_group_active'])

            gr = form_result['users_group_name']

            action_logger(self.rhodecode_user,

                          'admin_created_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            h.flash(_('created user group %s') % gr, category='success')

            Session().commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/users_groups/users_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during creation of user group %s') \

                    % request.POST.get('users_group_name'), category='error')

        return redirect(url('users_groups'))

    def new(self, format='html'):

        """GET /users_groups/new: Form to create a new item"""

        # url('new_users_group')

        return render('admin/users_groups/users_group_add.html')

    def _load_data(self, id):

        c.users_group.permissions = {

            'repositories': {},

            'repositories_groups': {}

        }

            .all()

        for gr in ugroup_repo_perms:

            c.users_group.permissions['repositories'][gr.repository.repo_name]  \

                = gr.permission.permission_name

            .all()

        for gr in ugroup_group_perms:

            c.users_group.permissions['repositories_groups'][gr.group.group_name] \

                = gr.permission.permission_name

        c.group_members_obj = [x.user for x in c.users_group.members]

        c.group_members = [(x.user_id, x.username) for x in

                           c.group_members_obj]

        c.available_members = [(x.user_id, x.username) for x in

                               User.query().all()]

    def update(self, id):

        """PUT /users_groups/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('users_group', id=ID),

        #           method='put')

        # url('users_group', id=ID)

        self._load_data(id)

        available_members = [safe_unicode(x[0]) for x in c.available_members]

                                          old_data=c.users_group.get_dict(),

                                          available_members=available_members)()

        try:

            form_result = users_group_form.to_python(request.POST)

            gr = form_result['users_group_name']

            action_logger(self.rhodecode_user,

                          'admin_updated_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            h.flash(_('updated user group %s') % gr, category='success')

            Session().commit()

        except formencode.Invalid, errors:

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

                'create_repo_perm': ug_model.has_perm(id,

                                                      'hg.create.repository'),

                'fork_repo_perm': ug_model.has_perm(id,

                                                    'hg.fork.repository'),

                '_method': 'put'

            })

            return htmlfill.render(

                render('admin/users_groups/users_group_edit.html'),

                defaults=defaults,

                errors=e,

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of user group %s') \

                    % request.POST.get('users_group_name'), category='error')

        return redirect(url('edit_users_group', id=id))

    def delete(self, id):

        """DELETE /users_groups/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('users_group', id=ID),

        #           method='delete')

        # url('users_group', id=ID)

        try:

            Session().commit()

            h.flash(_('successfully deleted user group'), category='success')

            h.flash(e, category='error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of user group'),

                    category='error')

        return redirect(url('users_groups'))

    def show(self, id, format='html'):

        """GET /users_groups/id: Show a specific item"""

        # url('users_group', id=ID)

    def edit(self, id, format='html'):

        """GET /users_groups/id/edit: Form to edit an existing item"""

        # url('edit_users_group', id=ID)

        self._load_data(id)

        defaults = c.users_group.get_dict()

        defaults.update({

            'create_repo_perm': ug_model.has_perm(c.users_group,

                                                  'hg.create.repository'),

            'fork_repo_perm': ug_model.has_perm(c.users_group,

                                                'hg.fork.repository'),

        })

        return htmlfill.render(

            render('admin/users_groups/users_group_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    def update_perm(self, id):

        """PUT /users_perm/id: Update an existing item"""

        # url('users_group_perm', id=ID, method='put')

        grant_create_perm = str2bool(request.POST.get('create_repo_perm'))

        grant_fork_perm = str2bool(request.POST.get('fork_repo_perm'))

        inherit_perms = str2bool(request.POST.get('inherit_default_permissions'))

        try:

            users_group.inherit_default_permissions = inherit_perms

            Session().add(users_group)

            if grant_create_perm:

                h.flash(_("Granted 'repository create' permission to user group"),

                        category='success')

            else:

                h.flash(_("Revoked 'repository create' permission to user group"),

                        category='success')

            if grant_fork_perm:

                h.flash(_("Granted 'repository fork' permission to user group"),

                        category='success')

            else:

                h.flash(_("Revoked 'repository fork' permission to user group"),

                        category='success')

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during permissions saving'),

                    category='error')

        return redirect(url('edit_users_group', id=id))

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.api

    ~~~~~~~~~~~~~~~~~~~~~~~~~

    API controller for RhodeCode

    :created_on: Aug 20, 2011

    :author: marcink

    :copyright: (C) 2011-2012 Marcin Kuzminski <marcin@python-works.com>

    :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; 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.

import traceback

import logging

from pylons.controllers.util import abort

from rhodecode.controllers.api import JSONRPCController, JSONRPCError

from rhodecode.lib.auth import PasswordGenerator, AuthUser, \

    HasPermissionAllDecorator, HasPermissionAnyDecorator, \

    HasPermissionAnyApi, HasRepoPermissionAnyApi

from rhodecode.lib.utils import map_groups, repo2db_mapper

from rhodecode.model.meta import Session

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.user import UserModel

from rhodecode.model.permission import PermissionModel

from rhodecode.model.db import Repository, RhodeCodeSetting, UserIpMap

log = logging.getLogger(__name__)

class OptionalAttr(object):

    """

    Special Optional Option that defines other attribute

    """

    def __init__(self, attr_name):

        self.attr_name = attr_name

    def __repr__(self):

        return '<OptionalAttr:%s>' % self.attr_name

    def __call__(self):

        return self

#alias

OAttr = OptionalAttr

class Optional(object):

    """

    Defines an optional parameter::

        param = param.getval() if isinstance(param, Optional) else param

        param = param() if isinstance(param, Optional) else param

    is equivalent of::

        param = Optional.extract(param)

    """

    def __init__(self, type_):

        self.type_ = type_

    def __repr__(self):

        return '<Optional:%s>' % self.type_.__repr__()

    def __call__(self):

        return self.getval()

    def getval(self):

        """

        returns value from this Optional instance

        """

        return self.type_

    @classmethod

    def extract(cls, val):

        if isinstance(val, cls):

            return val.getval()

        return val

def get_user_or_error(userid):

    """

    Get user by id or name or return JsonRPCError if not found

    :param userid:

    """

    user = UserModel().get_user(userid)

    if user is None:

        raise JSONRPCError("user `%s` does not exist" % userid)

    return user

def get_repo_or_error(repoid):

    """

    Get repo by id or name or return JsonRPCError if not found

    :param userid:

    """

    repo = RepoModel().get_repo(repoid)

    if repo is None:

        raise JSONRPCError('repository `%s` does not exist' % (repoid))

    return repo

def get_users_group_or_error(usersgroupid):

    """

    Get user group by id or name or return JsonRPCError if not found

    :param userid:

    """

    if users_group is None:

        raise JSONRPCError('user group `%s` does not exist' % usersgroupid)

    return users_group

def get_perm_or_error(permid):

    """

    Get permission by id or name or return JsonRPCError if not found

    :param userid:

    """

    perm = PermissionModel().get_permission_by_name(permid)

    if perm is None:

        raise JSONRPCError('permission `%s` does not exist' % (permid))

    return perm

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

    Preferably this should be first argument also

    Each function should also **raise** JSONRPCError for any

    errors that happens

    """

    @HasPermissionAllDecorator('hg.admin')

    def pull(self, apiuser, repoid):

        """

        Dispatch pull action on given repo

        :param apiuser:

        :param repoid:

        """

        repo = get_repo_or_error(repoid)

        try:

            ScmModel().pull_changes(repo.repo_name,

                                    self.rhodecode_user.username)

            return 'Pulled from `%s`' % repo.repo_name

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'Unable to pull changes from `%s`' % repo.repo_name

            )

    @HasPermissionAllDecorator('hg.admin')

    def rescan_repos(self, apiuser, remove_obsolete=Optional(False)):

        """

        Dispatch rescan repositories action. If remove_obsolete is set

        than also delete repos that are in database but not in the filesystem.

        aka "clean zombies"

        :param apiuser:

        :param remove_obsolete:

        """

        try:

            rm_obsolete = Optional.extract(remove_obsolete)

            added, removed = repo2db_mapper(ScmModel().repo_scan(),

                                            remove_obsolete=rm_obsolete)

            return {'added': added, 'removed': removed}

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'Error occurred during rescan repositories action'

            )

    def invalidate_cache(self, apiuser, repoid):

        """

        Dispatch cache invalidation action on given repo

        :param apiuser:

        :param repoid:

        """

        repo = get_repo_or_error(repoid)

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            # check if we have admin permission for this repo !

            if HasRepoPermissionAnyApi('repository.admin',

                                       'repository.write')(user=apiuser,

                                            repo_name=repo.repo_name) is False:

                raise JSONRPCError('repository `%s` does not exist' % (repoid))

        try:

            invalidated_keys = ScmModel().mark_for_invalidation(repo.repo_name)

            Session().commit()

            return ('Cache for repository `%s` was invalidated: '

                    'invalidated cache keys: %s' % (repoid, invalidated_keys))

                    password=Optional(None)):

        """

        Updates given user

        :param apiuser:

        :param userid:

        :param username:

        :param email:

        :param firstname:

        :param lastname:

        :param active:

        :param admin:

        :param ldap_dn:

        :param password:

        """

        user = get_user_or_error(userid)

        # call function and store only updated arguments

        updates = {}

        def store_update(attr, name):

            if not isinstance(attr, Optional):

                updates[name] = attr

        try:

            store_update(username, 'username')

            store_update(password, 'password')

            store_update(email, 'email')

            store_update(firstname, 'name')

            store_update(lastname, 'lastname')

            store_update(active, 'active')

            store_update(admin, 'admin')

            store_update(ldap_dn, 'ldap_dn')

            user = UserModel().update_user(user, **updates)

            Session().commit()

            return dict(

                msg='updated user ID:%s %s' % (user.user_id, user.username),

                user=user.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to update user `%s`' % userid)

    @HasPermissionAllDecorator('hg.admin')

    def delete_user(self, apiuser, userid):

        """"

        Deletes an user

        :param apiuser:

        :param userid:

        """

        user = get_user_or_error(userid)

        try:

            UserModel().delete(userid)

            Session().commit()

            return dict(

                msg='deleted user ID:%s %s' % (user.user_id, user.username),

                user=None

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to delete ID:%s %s' % (user.user_id,

                                                              user.username))

    @HasPermissionAllDecorator('hg.admin')

    def get_users_group(self, apiuser, usersgroupid):

        """"

        Get user group by name or id

        :param apiuser:

        :param usersgroupid:

        """

        users_group = get_users_group_or_error(usersgroupid)

        data = users_group.get_api_data()

        members = []

        for user in users_group.members:

            user = user.user

            members.append(user.get_api_data())

        data['members'] = members

        return data

    @HasPermissionAllDecorator('hg.admin')

    def get_users_groups(self, apiuser):

        """"

        Get all user groups

        :param apiuser:

        """

        result = []

            result.append(users_group.get_api_data())

        return result

    @HasPermissionAllDecorator('hg.admin')

    def create_users_group(self, apiuser, group_name, active=Optional(True)):

        """

        Creates an new usergroup

        :param apiuser:

        :param group_name:

        :param active:

        """

            raise JSONRPCError("user group `%s` already exist" % group_name)

        try:

            active = Optional.extract(active)

            Session().commit()

            return dict(

                msg='created new user group `%s`' % group_name,

                users_group=ug.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create group `%s`' % group_name)

    @HasPermissionAllDecorator('hg.admin')

    def add_user_to_users_group(self, apiuser, usersgroupid, userid):

        """"

        Add a user to a user group

        :param apiuser:

        :param usersgroupid:

        :param userid:

        """

        user = get_user_or_error(userid)

        users_group = get_users_group_or_error(usersgroupid)

        try:

            success = True if ugm != True else False

            msg = 'added member `%s` to user group `%s`' % (

                        user.username, users_group.users_group_name

                    )

            msg = msg if success else 'User is already in that group'

            Session().commit()

            return dict(

                success=success,

                msg=msg

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to add member to user group `%s`' % (

                    users_group.users_group_name

                )

            )

    @HasPermissionAllDecorator('hg.admin')

    def remove_user_from_users_group(self, apiuser, usersgroupid, userid):

        """

        Remove user from a group

        :param apiuser:

        :param usersgroupid:

        :param userid:

        """

        user = get_user_or_error(userid)

        users_group = get_users_group_or_error(usersgroupid)

        try:

                                                               user)

            msg = 'removed member `%s` from user group `%s`' % (

                        user.username, users_group.users_group_name

                    )

            msg = msg if success else "User wasn't in group"

            Session().commit()

            return dict(success=success, msg=msg)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to remove member from user group `%s`' % (

                        users_group.users_group_name

                    )

            )

    def get_repo(self, apiuser, repoid):

        """"

        Get repository by name

        :param apiuser:

        :param repoid:

        """

        repo = get_repo_or_error(repoid)

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            # check if we have admin permission for this repo !

            if HasRepoPermissionAnyApi('repository.admin')(user=apiuser,

                                            repo_name=repo.repo_name) is False:

                raise JSONRPCError('repository `%s` does not exist' % (repoid))

        members = []

        followers = []

        for user in repo.repo_to_perm:

            perm = user.permission.permission_name

            user = user.user

            user_data = user.get_api_data()

            user_data['type'] = "user"

            user_data['permission'] = perm

            members.append(user_data)

        for users_group in repo.users_group_to_perm:

            perm = users_group.permission.permission_name

            users_group = users_group.users_group

            users_group_data = users_group.get_api_data()

            users_group_data['type'] = "users_group"

            users_group_data['permission'] = perm

            members.append(users_group_data)

        for user in repo.followers:

            followers.append(user.user.get_api_data())

        data = repo.get_api_data()

        data['members'] = members

        data['followers'] = followers

        return data

    def get_repos(self, apiuser):

        """"

        Get all repositories

        :param apiuser:

        """

        result = []

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            repos = RepoModel().get_all_user_repos(user=apiuser)

        else:

            repos = RepoModel().get_all()

        for repo in repos:

            result.append(repo.get_api_data())

        return result

    @HasPermissionAllDecorator('hg.admin')

    def get_repo_nodes(self, apiuser, repoid, revision, root_path,

                       ret_type='all'):

        """

        returns a list of nodes and it's children

        for a given path at given revision. It's possible to specify ret_type

        to show only files or dirs

        :param apiuser:

        :param repoid: name or id of repository

        :param revision: revision for which listing should be done

        :param root_path: path from which start displaying

        :param ret_type: return type 'all|files|dirs' nodes

        """

        repo = get_repo_or_error(repoid)

        try:

            _d, _f = ScmModel().get_nodes(repo, revision, root_path,

                                          flat=False)

            _map = {

                'all': _d + _f,

                'files': _f,

                'dirs': _d,

            }

            return _map[ret_type]

# -*- coding: utf-8 -*-

"""

    rhodecode.model.db_1_2_0

    ~~~~~~~~~~~~~~~~~~~~~~~~

    Database Models for RhodeCode <=1.2.X

    :created_on: Apr 08, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :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/>.