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

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

"""

kallithea.controllers.admin.auth_settings

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

pluggable authentication controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Nov 26, 2010

:author: akesterson

"""

import logging

import traceback

import formencode.htmlfill

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import AuthSettingsForm

log = logging.getLogger(__name__)

class AuthSettingsController(BaseController):

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

    def _before(self, *args, **kwargs):

        super(AuthSettingsController, self)._before(*args, **kwargs)

    def __load_defaults(self):

        c.available_plugins = [

            'kallithea.lib.auth_modules.auth_internal',

            'kallithea.lib.auth_modules.auth_container',

            'kallithea.lib.auth_modules.auth_ldap',

            'kallithea.lib.auth_modules.auth_crowd',

            'kallithea.lib.auth_modules.auth_pam'

        ]

        self.enabled_plugins = auth_modules.get_auth_plugins()

        c.enabled_plugin_names = [plugin.__class__.__module__ for plugin in self.enabled_plugins]

    def __render(self, defaults, errors):

        c.defaults = {}

        c.plugin_settings = {}

        c.plugin_shortnames = {}

        for plugin in self.enabled_plugins:

            module = plugin.__class__.__module__

            c.plugin_shortnames[module] = plugin.name

            c.plugin_settings[module] = plugin.plugin_settings()

            for v in c.plugin_settings[module]:

                fullname = "auth_%s_%s" % (plugin.name, v["name"])

                if "default" in v:

                    c.defaults[fullname] = v["default"]

                # Current values will be the default on the form, if there are any

                setting = db.Setting.get_by_name(fullname)

                if setting is not None:

                    c.defaults[fullname] = setting.app_settings_value

        if defaults:

            c.defaults.update(defaults)

        log.debug('defaults: %s', defaults)

        return formencode.htmlfill.render(

            render('admin/auth/auth_settings.html'),

            defaults=c.defaults,

            errors=errors,

            prefix_error=False,

            encoding="UTF-8",

            force_defaults=False)

    def index(self):

        self.__load_defaults()

        return self.__render(defaults=None, errors=None)

    def auth_settings(self):

        """POST create and store auth settings"""

        self.__load_defaults()

        log.debug("POST Result: %s", dict(request.POST))

        # First, parse only the plugin list (not the plugin settings).

        _auth_plugins_validator = AuthSettingsForm([]).fields['auth_plugins']

        try:

            new_enabled_plugins = _auth_plugins_validator.to_python(request.POST.get('auth_plugins'))

        except formencode.Invalid:

            # User provided an invalid plugin list. Just fall back to

            # the list of currently enabled plugins. (We'll re-validate

            # and show an error message to the user, below.)

            pass

        else:

            # Hide plugins that the user has asked to be disabled, but

            # do not show plugins that the user has asked to be enabled

            # (yet), since that'll cause validation errors and/or wrong

            # settings being applied (e.g. checkboxes being cleared),

            # since the plugin settings will not be in the POST data.

            c.enabled_plugin_names = [p for p in c.enabled_plugin_names if p in new_enabled_plugins]

        # Next, parse everything including plugin settings.

        _form = AuthSettingsForm(c.enabled_plugin_names)()

        try:

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

            for k, v in form_result.items():

                if k == 'auth_plugins':

                    # we want to store it comma separated inside our settings

                    v = ','.join(v)

                log.debug("%s = %s", k, str(v))

                setting = db.Setting.create_or_update(k, v)

            meta.Session().commit()

                       category='success')

        except formencode.Invalid as errors:

            log.error(traceback.format_exc())

            e = errors.error_dict or {}

            return self.__render(

                defaults=errors.value,

                errors=e,

            )

        except Exception:

            log.error(traceback.format_exc())

                    category='error')

        raise HTTPFound(location=url('auth_home'))

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

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

"""

kallithea.controllers.admin.defaults

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

default settings controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 27, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from tg import request

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import DefaultsForm

log = logging.getLogger(__name__)

class DefaultsController(BaseController):

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

    def _before(self, *args, **kwargs):

        super(DefaultsController, self)._before(*args, **kwargs)

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

        defaults = db.Setting.get_default_repo_settings()

        return htmlfill.render(

            render('admin/defaults/defaults.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    def update(self, id):

        _form = DefaultsForm()()

        try:

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

            for k, v in form_result.items():

                setting = db.Setting.create_or_update(k, v)

            meta.Session().commit()

                    category='success')

        except formencode.Invalid as errors:

            defaults = errors.value

            return htmlfill.render(

                render('admin/defaults/defaults.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    category='error')

        raise HTTPFound(location=url('defaults'))

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

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

"""

kallithea.controllers.admin.gists

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

gist controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: May 9, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode.htmlfill

from sqlalchemy.sql.expression import or_

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.lib.auth import LoginRequired

from kallithea.lib.base import BaseController, jsonify, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, safe_str, time_to_datetime

from kallithea.lib.vcs.exceptions import NodeNotChangedError, VCSError

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import GistForm

from kallithea.model.gist import GistModel

log = logging.getLogger(__name__)

class GistsController(BaseController):

    def __load_defaults(self, extra_values=None):

        c.lifetime_values = [

            (str(-1), _('Forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

        ]

        if extra_values:

            c.lifetime_values.append(extra_values)

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

    @LoginRequired(allow_default_user=True)

    def index(self):

        not_default_user = not request.authuser.is_default_user

        c.show_private = request.GET.get('private') and not_default_user

        c.show_public = request.GET.get('public') and not_default_user

        url_params = {}

        if c.show_public:

            url_params['public'] = 1

        elif c.show_private:

            url_params['private'] = 1

        gists = db.Gist().query() \

            .filter_by(is_expired=False) \

            .order_by(db.Gist.created_on.desc())

        # MY private

        if c.show_private and not c.show_public:

            gists = gists.filter(db.Gist.gist_type == db.Gist.GIST_PRIVATE) \

                             .filter(db.Gist.owner_id == request.authuser.user_id)

        # MY public

        if not c.show_public and not c.show_private:

            gists = gists.filter(db.Gist.gist_type == db.Gist.GIST_PUBLIC)

        c.gists = gists

        p = safe_int(request.GET.get('page'), 1)

        c.gists_pager = Page(c.gists, page=p, items_per_page=10,

                             **url_params)

        return render('admin/gists/index.html')

    @LoginRequired()

    def create(self):

        self.__load_defaults()

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        try:

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

            # TODO: multiple files support, from the form

            filename = form_result['filename'] or db.Gist.DEFAULT_FILENAME

            nodes = {

                filename: {

                    'content': form_result['content'],

                    'lexer': form_result['mimetype']  # None is autodetect

                }

            }

            _public = form_result['public']

            gist_type = db.Gist.GIST_PUBLIC if _public else db.Gist.GIST_PRIVATE

            gist = GistModel().create(

                description=form_result['description'],

                owner=request.authuser.user_id,

                ip_addr=request.ip_addr,

                gist_mapping=nodes,

                gist_type=gist_type,

                lifetime=form_result['lifetime']

            )

            meta.Session().commit()

            new_gist_id = gist.gist_access_id

        except formencode.Invalid as errors:

            defaults = errors.value

            return formencode.htmlfill.render(

                render('admin/gists/new.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception as e:

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('new_gist'))

        raise HTTPFound(location=url('gist', gist_id=new_gist_id))

    @LoginRequired()

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

        self.__load_defaults()

        return render('admin/gists/new.html')

    @LoginRequired()

    def delete(self, gist_id):

        gist = GistModel().get_gist(gist_id)

        owner = gist.owner_id == request.authuser.user_id

        if auth.HasPermissionAny('hg.admin')() or owner:

            GistModel().delete(gist)

            meta.Session().commit()

        else:

            raise HTTPForbidden()

        raise HTTPFound(location=url('gists'))

    @LoginRequired(allow_default_user=True)

    def show(self, gist_id, revision='tip', format='html', f_path=None):

        c.gist = db.Gist.get_or_404(gist_id)

        if c.gist.is_expired:

            log.error('Gist expired at %s',

                      time_to_datetime(c.gist.gist_expires))

            raise HTTPNotFound()

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id,

                                                            revision=revision)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        if format == 'raw':

            content = '\n\n'.join(

                safe_str(f.content)

                for f in c.files if (f_path is None or f.path == f_path)

            )

            response.content_type = 'text/plain'

            return content

        return render('admin/gists/show.html')

    @LoginRequired()

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

        c.gist = db.Gist.get_or_404(gist_id)

        if c.gist.is_expired:

            log.error('Gist expired at %s',

                      time_to_datetime(c.gist.gist_expires))

            raise HTTPNotFound()

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        self.__load_defaults(extra_values=('0', _('Unmodified')))

        rendered = render('admin/gists/edit.html')

        if request.POST:

            rpost = request.POST

            nodes = {}

            for org_filename, filename, mimetype, content in zip(

                                                    rpost.getall('org_files'),

                                                    rpost.getall('files'),

                                                    rpost.getall('mimetypes'),

                                                    rpost.getall('contents')):

                nodes[org_filename] = {

                    'org_filename': org_filename,

                    'filename': filename,

                    'content': content,

                    'lexer': mimetype,

                }

            try:

                GistModel().update(

                    gist=c.gist,

                    description=rpost['description'],

                    owner=c.gist.owner, # FIXME: request.authuser.user_id ?

                    ip_addr=request.ip_addr,

                    gist_mapping=nodes,

                    gist_type=c.gist.gist_type,

                    lifetime=rpost['lifetime']

                )

                meta.Session().commit()

            except NodeNotChangedError:

                # raised if nothing was changed in repo itself. We anyway then

                # store only DB stuff for gist

                meta.Session().commit()

            except Exception:

                log.error(traceback.format_exc())

                        category='error')

            raise HTTPFound(location=url('gist', gist_id=gist_id))

        return rendered

    @LoginRequired()

    @jsonify

    def check_revision(self, gist_id):

        c.gist = db.Gist.get_or_404(gist_id)

        last_rev = c.gist.scm_instance.get_changeset()

        success = True

        revision = request.POST.get('revision')

        # TODO: maybe move this to model ?

        if revision != last_rev.raw_id:

            log.error('Last revision %s is different than submitted %s',

                      revision, last_rev)

            # our gist has newer version than we

            success = False

        return {'success': success}

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

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

"""

kallithea.controllers.admin.my_account

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

my account controller for Kallithea admin

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: August 20, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib.auth import AuthUser, LoginRequired

from kallithea.lib.base import BaseController, IfSshEnabled, render

from kallithea.lib.utils2 import generate_api_key, safe_int

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.api_key import ApiKeyModel

from kallithea.model.forms import PasswordChangeForm, UserForm

from kallithea.model.repo import RepoModel

from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

class MyAccountController(BaseController):

    @LoginRequired()

    def _before(self, *args, **kwargs):

        super(MyAccountController, self)._before(*args, **kwargs)

    def __load_data(self):

        c.user = db.User.get(request.authuser.user_id)

        if c.user.is_default_user:

                      " crucial for entire application"), category='warning')

            raise HTTPFound(location=url('users'))

    def _load_my_repos_data(self, watched=False):

        if watched:

            admin = False

            repos_list = meta.Session().query(db.Repository) \

                         .join(db.UserFollowing) \

                         .filter(db.UserFollowing.user_id ==

                                 request.authuser.user_id).all()

        else:

            admin = True

            repos_list = meta.Session().query(db.Repository) \

                         .filter(db.Repository.owner_id ==

                                 request.authuser.user_id).all()

        return RepoModel().get_repos_as_dict(repos_list, admin=admin)

    def my_account(self):

        c.active = 'profile'

        self.__load_data()

        c.perm_user = AuthUser(user_id=request.authuser.user_id)

        managed_fields = auth_modules.get_managed_fields(c.user)

        def_user_perms = AuthUser(dbuser=db.User.get_default_user()).global_permissions

        if 'hg.register.none' in def_user_perms:

            managed_fields.extend(['username', 'firstname', 'lastname', 'email'])

        c.readonly = lambda n: 'readonly' if n in managed_fields else None

        defaults = c.user.get_dict()

        update = False

        if request.POST:

            _form = UserForm(edit=True,

                             old_data={'user_id': request.authuser.user_id,

                                       'email': request.authuser.email})()

            form_result = {}

            try:

                post_data = dict(request.POST)

                post_data['new_password'] = ''

                post_data['password_confirmation'] = ''

                form_result = _form.to_python(post_data)

                # skip updating those attrs for my account

                skip_attrs = ['admin', 'active', 'extern_type', 'extern_name',

                              'new_password', 'password_confirmation',

                             ] + managed_fields

                UserModel().update(request.authuser.user_id, form_result,

                                   skip_attrs=skip_attrs)

                        category='success')

                meta.Session().commit()

                update = True

            except formencode.Invalid as errors:

                return htmlfill.render(

                    render('admin/my_account/my_account.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            except Exception:

                log.error(traceback.format_exc())

                        % form_result.get('username'), category='error')

        if update:

            raise HTTPFound(location='my_account')

        return htmlfill.render(

            render('admin/my_account/my_account.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def my_account_password(self):

        c.active = 'password'

        self.__load_data()

        managed_fields = auth_modules.get_managed_fields(c.user)

        c.can_change_password = 'password' not in managed_fields

        if request.POST and c.can_change_password:

            _form = PasswordChangeForm(request.authuser.username)()

            try:

                form_result = _form.to_python(request.POST)

                UserModel().update(request.authuser.user_id, form_result)

                meta.Session().commit()

            except formencode.Invalid as errors:

                return htmlfill.render(

                    render('admin/my_account/my_account.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            except Exception:

                log.error(traceback.format_exc())

                        category='error')

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

    def my_account_repos(self):

        c.active = 'repos'

        self.__load_data()

        # data used to render the grid

        c.data = self._load_my_repos_data()

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

    def my_account_watched(self):

        c.active = 'watched'

        self.__load_data()

        # data used to render the grid

        c.data = self._load_my_repos_data(watched=True)

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

    def my_account_perms(self):

        c.active = 'perms'

        self.__load_data()

        c.perm_user = AuthUser(user_id=request.authuser.user_id)

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

    def my_account_emails(self):

        c.active = 'emails'

        self.__load_data()

        c.user_email_map = db.UserEmailMap.query() \

            .filter(db.UserEmailMap.user == c.user).all()

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

    def my_account_emails_add(self):

        email = request.POST.get('new_email')

        try:

            UserModel().add_extra_email(request.authuser.user_id, email)

            meta.Session().commit()

        except formencode.Invalid as error:

            msg = error.error_dict['email']

        except Exception:

            log.error(traceback.format_exc())

                    category='error')

        raise HTTPFound(location=url('my_account_emails'))

    def my_account_emails_delete(self):

        email_id = request.POST.get('del_email_id')

        user_model = UserModel()

        user_model.delete_extra_email(request.authuser.user_id, email_id)

        meta.Session().commit()

        raise HTTPFound(location=url('my_account_emails'))

    def my_account_api_keys(self):

        c.active = 'api_keys'

        self.__load_data()

        show_expired = True

        c.lifetime_values = [

            (str(-1), _('Forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

        ]

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

        c.user_api_keys = ApiKeyModel().get_api_keys(request.authuser.user_id,

                                                     show_expired=show_expired)

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

    def my_account_api_keys_add(self):

        lifetime = safe_int(request.POST.get('lifetime'), -1)

        description = request.POST.get('description')

        ApiKeyModel().create(request.authuser.user_id, description, lifetime)

        meta.Session().commit()

        raise HTTPFound(location=url('my_account_api_keys'))

    def my_account_api_keys_delete(self):

        api_key = request.POST.get('del_api_key')

        if request.POST.get('del_api_key_builtin'):

            user = db.User.get(request.authuser.user_id)

            user.api_key = generate_api_key()

            meta.Session().commit()

        elif api_key:

            ApiKeyModel().delete(api_key, request.authuser.user_id)

            meta.Session().commit()

        raise HTTPFound(location=url('my_account_api_keys'))

    @IfSshEnabled

    def my_account_ssh_keys(self):

        c.active = 'ssh_keys'

        self.__load_data()

        c.user_ssh_keys = SshKeyModel().get_ssh_keys(request.authuser.user_id)

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

    @IfSshEnabled

    def my_account_ssh_keys_add(self):

        description = request.POST.get('description')

        public_key = request.POST.get('public_key')

        try:

            new_ssh_key = SshKeyModel().create(request.authuser.user_id,

                                               description, public_key)

            meta.Session().commit()

            SshKeyModel().write_authorized_keys()

        except SshKeyModelException as e:

        raise HTTPFound(location=url('my_account_ssh_keys'))

    @IfSshEnabled

    def my_account_ssh_keys_delete(self):

        fingerprint = request.POST.get('del_public_key_fingerprint')

        try:

            SshKeyModel().delete(fingerprint, request.authuser.user_id)

            meta.Session().commit()

            SshKeyModel().write_authorized_keys()

        except SshKeyModelException as e:

        raise HTTPFound(location=url('my_account_ssh_keys'))

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

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

"""

kallithea.controllers.admin.permissions

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

permissions controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 27, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback