from whoosh.qparser.default import QueryParser

from whoosh.qparser.dateparse import DateParserPlugin

from whoosh import query

from sqlalchemy.sql.expression import or_, and_, func

from kallithea.model.db import UserLog

from kallithea.lib.base import BaseController, render

from kallithea.lib.utils2 import safe_int, remove_prefix, remove_suffix

from kallithea.lib.indexers import JOURNAL_SCHEMA

from kallithea.lib.helpers import Page

class AdminController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(AdminController, self).__before__()

    def index(self):

        users_log = UserLog.query() \

                .options(joinedload(UserLog.user)) \

                .options(joinedload(UserLog.repository))

        #FILTERING

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.compat import formatted_json

from kallithea.lib.base import BaseController, render

from kallithea.lib import auth_modules

from kallithea.model.forms import AuthSettingsForm

from kallithea.model.db import Setting

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class AuthSettingsController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(AuthSettingsController, self).__before__()

    def __load_defaults(self):

        c.available_plugins = [

            'kallithea.lib.auth_modules.auth_internal',

from pylons import request, tmpl_context as c, url

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import DefaultsForm

from kallithea.model.meta import Session

from kallithea import BACKENDS

from kallithea.model.db import Setting

    """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('default', 'defaults')

    @LoginRequired()

    def __before__(self):

        super(DefaultsController, self).__before__()

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

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

        # url('defaults')

from pylons import request, tmpl_context as c, url

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import DefaultPermissionsForm

from kallithea.model.permission import PermissionModel

from kallithea.model.db import User, UserIpMap

from kallithea.model.meta import Session

    """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('permission', 'permissions')

    @LoginRequired()

    def __before__(self):

        super(PermissionsController, self).__before__()

    def __load_data(self):

        c.repo_perms_choices = [('repository.none', _('None'),),

                                   ('repository.read', _('Read'),),

from webob.exc import HTTPFound, HTTPForbidden, HTTPNotFound, HTTPInternalServerError

import kallithea

from kallithea.lib import helpers as h

from kallithea.lib.compat import json

from kallithea.lib.auth import LoginRequired, \

from kallithea.lib.base import BaseController, render

from kallithea.model.db import RepoGroup, Repository

from kallithea.model.scm import RepoGroupList, AvailableRepoGroupChoices

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.forms import RepoGroupForm, RepoGroupPermsForm

from kallithea.model.meta import Session

                category='success')

        raise HTTPFound(location=url('repos_group_home', group_name=gr.group_name))

    def new(self):

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

        # url('new_repos_group')

            #we're global admin, we're ok and we can create TOP level groups

            pass

        else:

            # we pass in parent group into creation form, thus we know

            # what would be the group, we can check perms here !

            group_id = safe_int(request.GET.get('parent_group'))

            group = RepoGroup.get(group_id) if group_id else None

            group_name = group.group_name if group else None

                pass

            else:

                raise HTTPForbidden()

        self.__load_defaults()

        return render('admin/repo_groups/repo_group_add.html')

        c.repo_group = RepoGroupModel()._get_repo_group(group_name)

        self.__load_defaults(extras=[c.repo_group.parent_group],

                             exclude=[c.repo_group])

        # TODO: kill allow_empty_group - it is only used for redundant form validation!

            #we're global admin, we're ok and we can create TOP level groups

            allow_empty_group = True

        elif not c.repo_group.parent_group:

            allow_empty_group = True

        else:

            allow_empty_group = False

from pylons.i18n.translation import _

from sqlalchemy.sql.expression import func

from webob.exc import HTTPFound, HTTPInternalServerError, HTTPForbidden, HTTPNotFound

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, \

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.utils import action_logger, jsonify

from kallithea.lib.vcs import RepositoryError

from kallithea.model.meta import Session

from kallithea.model.db import User, Repository, UserFollowing, RepoGroup, \

    Setting, RepositoryField

                else:

                    h.flash(h.literal(_('Created repository %s') % repo_url),

                            category='success')

            return {'result': True}

        return {'result': False}

    def update(self, repo_name):

        """

        PUT /repos/repo_name: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of repository %s') \

                    % repo_name, category='error')

        raise HTTPFound(location=url('edit_repo', repo_name=changed_name))

    def delete(self, repo_name):

        """

        DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

                    category='error')

        if repo.group:

            raise HTTPFound(location=url('repos_group_home', group_name=repo.group.group_name))

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

    def edit(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        defaults = self.__load_data(repo_name)

        c.repo_fields = RepositoryField.query() \

            .filter(RepositoryField.repository == c.repo_info).all()

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def edit_permissions(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during revoking of permission'),

                    category='error')

            raise HTTPInternalServerError()

    def edit_fields(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        c.repo_fields = RepositoryField.query() \

            .filter(RepositoryField.repository == c.repo_info).all()

        c.active = 'fields'

        if request.POST:

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

        return render('admin/repos/repo_edit.html')

    def create_repo_field(self, repo_name):

        try:

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

            new_field = RepositoryField()

            new_field.repository = Repository.get_by_repo_name(repo_name)

            new_field.field_key = form_result['new_field_key']

            msg = _('An error occurred during creation of field')

            if isinstance(e, formencode.Invalid):

                msg += ". " + e.msg

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

        raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))

    def delete_repo_field(self, repo_name, field_id):

        field = RepositoryField.get_or_404(field_id)

        try:

            Session().delete(field)

            Session().commit()

        except Exception as e:

            log.error(traceback.format_exc())

            msg = _('An error occurred during removal of field')

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

        raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))

    def edit_advanced(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        c.default_user_id = User.get_default_user().user_id

        c.in_public_journal = UserFollowing.query() \

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def edit_advanced_journal(self, repo_name):

        """

        Sets this repository to be visible in public journal,

        in other words asking default user to follow this repo

        :param repo_name:

            h.flash(_('An error occurred during setting this'

                      ' repository in public journal'),

                    category='error')

        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))

    def edit_advanced_fork(self, repo_name):

        """

        Mark given repository as a fork of another

        :param repo_name:

        """

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during this operation'),

                    category='error')

        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))

    def edit_advanced_locking(self, repo_name):

        """

        Unlock repository when it is locked !

        :param repo_name:

        """

        except Exception as e:

            log.error(traceback.format_exc())

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

                    category='error')

        raise HTTPFound(location=url('summary_home', repo_name=repo_name))

    def edit_caches(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        c.active = 'caches'

        if request.POST:

                h.flash(_('An error occurred during cache invalidation'),

                        category='error')

            raise HTTPFound(location=url('edit_repo_caches', repo_name=c.repo_name))

        return render('admin/repos/repo_edit.html')

    def edit_remote(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        c.active = 'remote'

        if request.POST:

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during pull from remote location'),

                        category='error')

            raise HTTPFound(location=url('edit_repo_remote', repo_name=c.repo_name))

        return render('admin/repos/repo_edit.html')

    def edit_statistics(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        repo = c.repo_info.scm_instance

from formencode import htmlfill

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

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.base import BaseController, render

from kallithea.lib.celerylib import tasks, run_task

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.model.db import Ui, Repository, Setting

from kallithea.model.forms import ApplicationSettingsForm, \

            if each.ui_section in ['hooks', 'extensions']:

                v = each.ui_active

            settings[k] = v

        return settings

    def settings_vcs(self):

        """GET /admin/settings: All items in the collection"""

        # url('admin_settings')

        c.active = 'vcs'

        if request.POST:

            application_form = ApplicationUiSettingsForm()()

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def settings_mapping(self):

        """GET /admin/settings/mapping: All items in the collection"""

        # url('admin_settings_mapping')

        c.active = 'mapping'

        if request.POST:

            rm_obsolete = request.POST.get('destroy', False)

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def settings_global(self):

        """GET /admin/settings/global: All items in the collection"""

        # url('admin_settings_global')

        c.active = 'global'

        if request.POST:

            application_form = ApplicationSettingsForm()()

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def settings_visual(self):

        """GET /admin/settings/visual: All items in the collection"""

        # url('admin_settings_visual')

        c.active = 'visual'

        if request.POST:

            application_form = ApplicationVisualisationForm()()

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def settings_email(self):

        """GET /admin/settings/email: All items in the collection"""

        # url('admin_settings_email')

        c.active = 'email'

        if request.POST:

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

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def settings_hooks(self):

        """GET /admin/settings/hooks: All items in the collection"""

        # url('admin_settings_hooks')

        c.active = 'hooks'

        if request.POST:

            if c.visual.allow_custom_hooks_settings:

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def settings_search(self):

        """GET /admin/settings/search: All items in the collection"""

        # url('admin_settings_search')

        c.active = 'search'

        if request.POST:

            repo_location = self._get_hg_ui_settings()['paths_root_path']

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def settings_system(self):

        """GET /admin/settings/system: All items in the collection"""

        # url('admin_settings_system')

        c.active = 'system'

        defaults = Setting.get_app_settings()

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def settings_system_update(self):

        """GET /admin/settings/system/updates: All items in the collection"""

        # url('admin_settings_system_update')

        import json

        import urllib2

        from kallithea.lib.verlib import NormalizedVersion

from webob.exc import HTTPFound, HTTPNotFound

import kallithea

from kallithea.lib.exceptions import DefaultUserException, \

    UserOwnsReposException, UserCreationError

from kallithea.lib import helpers as h

    AuthUser

from kallithea.lib import auth_modules

from kallithea.lib.auth_modules import auth_internal

from kallithea.lib.base import BaseController, render

from kallithea.model.api_key import ApiKeyModel

class UsersController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    @LoginRequired()

    def __before__(self):

        super(UsersController, self).__before__()

        c.available_permissions = config['available_permissions']

        c.EXTERN_TYPE_INTERNAL = kallithea.EXTERN_TYPE_INTERNAL

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

import logging

from sqlalchemy import or_

from kallithea import EXTERN_TYPE_INTERNAL

from kallithea.controllers.api import JSONRPCController, JSONRPCError

from kallithea.lib.auth import (

    HasPermissionAnyDecorator, HasPermissionAnyApi, HasRepoPermissionAnyApi,

    HasRepoGroupPermissionAnyApi, HasUserGroupPermissionAny)

from kallithea.lib.utils import map_groups, repo2db_mapper

from kallithea.lib.utils2 import (

    str2bool, time_to_datetime, safe_int, Optional, OAttr)

from kallithea.model.meta import Session

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

    errors that happens.

    """

    def test(self, apiuser, args):

        return args

    def pull(self, apiuser, repoid):

        """

        Triggers a pull from remote location on given repo. Can be used to

        automatically keep remote repos up to date. This command can be executed

        only using api_key belonging to user with admin rights

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

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

            )

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

        """

        Triggers rescan repositories action. If remove_obsolete is set

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

        aka "clean zombies". This command can be executed only using api_key

        belonging to user with admin rights.

                        ret.append(_api_data)

                else:

                    ret.append(_api_data)

        return ret

    def get_ip(self, apiuser, userid=Optional(OAttr('apiuser'))):

        """

        Shows IP address as seen from Kallithea server, together with all

        defined IP addresses for given user. If userid is not passed data is

        returned for user who's calling this function.

        This command can be executed only using api_key belonging to user with

            user_ips=ips

        )

    # alias for old

    show_ip = get_ip

    def get_server_info(self, apiuser):

        """

        return server info, including Kallithea version and installed packages

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        user = get_user_or_error(userid)

        data = user.get_api_data()

        data['permissions'] = AuthUser(user_id=user.user_id).permissions

        return data

    def get_users(self, apiuser):

        """

        Lists all existing users. This command can be executed only using api_key

        belonging to user with admin rights.

        :param apiuser: filled automatically from apikey

            .filter(User.username != User.DEFAULT_USER) \

            .all()

        for user in users_list:

            result.append(user.get_api_data())

        return result

    def create_user(self, apiuser, username, email, password=Optional(''),

                    firstname=Optional(''), lastname=Optional(''),

                    active=Optional(True), admin=Optional(False),

                    extern_name=Optional(EXTERN_TYPE_INTERNAL),

                    extern_type=Optional(EXTERN_TYPE_INTERNAL)):

        """

                user=user.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

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

    def update_user(self, apiuser, userid, username=Optional(None),

                    email=Optional(None), password=Optional(None),

                    firstname=Optional(None), lastname=Optional(None),

                    active=Optional(None), admin=Optional(None),

                    extern_type=Optional(None), extern_name=Optional(None)):

        """

            log.error(traceback.format_exc())

            raise JSONRPCError('editing default user is forbidden')

        except Exception:

            log.error(traceback.format_exc())

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

    def delete_user(self, apiuser, userid):

        """

        deletes given user if such user exists. This command can

        be executed only using api_key belonging to user with admin rights.

        :param apiuser: filled automatically from apikey

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to delete repository `%s`' % (repo.repo_name,)

            )

    def grant_user_permission(self, apiuser, repoid, userid, perm):

        """

        Grant permission for user on given repository, or update existing one

        if found. This command can be executed only using api_key belonging to user

        with admin rights.

            raise JSONRPCError(

                'failed to edit permission for user: `%s` in repo: `%s`' % (

                    userid, repoid

                )

            )

    def revoke_user_permission(self, apiuser, repoid, userid):

        """

        Revoke permission for user on given repository. This command can be executed

        only using api_key belonging to user with admin rights.

        :param apiuser: filled automatically from apikey

                'failed to edit permission for user group: `%s` in '

                'repo: `%s`' % (

                    user_group.users_group_name, repo.repo_name

                )

            )

    def get_repo_group(self, apiuser, repogroupid):

        """

        Returns given repo group together with permissions, and repositories

        inside the group

        :param apiuser: filled automatically from apikey

            members.append(user_group_data)

        data = repo_group.get_api_data()

        data["members"] = members

        return data

    def get_repo_groups(self, apiuser):

        """

        Returns all repository groups

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        """

        result = []

        for repo_group in RepoGroupModel().get_all():

            result.append(repo_group.get_api_data())

        return result

    def create_repo_group(self, apiuser, group_name, description=Optional(''),

                          owner=Optional(OAttr('apiuser')),

                          parent=Optional(None),

                          copy_permissions=Optional(False)):

        """

        Creates a repository group. This command can be executed only using

            )

        except Exception:

            log.error(traceback.format_exc())

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

    def update_repo_group(self, apiuser, repogroupid, group_name=Optional(''),

                          description=Optional(''),

                          owner=Optional(OAttr('apiuser')),

                          parent=Optional(None), enable_locking=Optional(False)):

        repo_group = get_repo_group_or_error(repogroupid)

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to update repository group `%s`'

                               % (repogroupid,))

    def delete_repo_group(self, apiuser, repogroupid):

        """

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        :param repogroupid: name or id of repository group

    def check_permissions(self):

        """Dummy function for overriding"""

        raise Exception('You have to write this function in child class')