branch_labels = None

depends_on = None

from alembic import op

from sqlalchemy import MetaData, Table

meta = MetaData()

def upgrade():

    meta.bind = op.get_bind()

    ui.update(values={

        'ui_key': 'prechangegroup.push_lock_handling',

        'ui_value': 'python:kallithea.lib.hooks.push_lock_handling',

    }).where(ui.c.ui_key == 'prechangegroup.pre_push').execute()

    ui.update(values={

        'ui_value': 'python:kallithea.lib.hooks.pull_lock_handling',

    }).where(ui.c.ui_key == 'preoutgoing.pre_pull').execute()

def downgrade():

    meta.bind = op.get_bind()

    ui.update(values={

        'ui_key': 'prechangegroup.pre_push',

        'ui_value': 'python:kallithea.lib.hooks.pre_push',

    }).where(ui.c.ui_key == 'prechangegroup.push_lock_handling').execute()

    ui.update(values={

depends_on = None

import sqlalchemy as sa

from alembic import op

from sqlalchemy import MetaData, Table

meta = MetaData()

def upgrade():

    with op.batch_alter_table('repositories', schema=None) as batch_op:

        batch_op.drop_column('locked')

        batch_op.drop_column('enable_locking')

    meta.bind = op.get_bind()

    ui.delete().where(ui.c.ui_key == 'prechangegroup.push_lock_handling').execute()

    ui.delete().where(ui.c.ui_key == 'preoutgoing.pull_lock_handling').execute()

def downgrade():

    with op.batch_alter_table('repositories', schema=None) as batch_op:

branch_labels = None

depends_on = None

import sqlalchemy as sa

from alembic import op

def upgrade():

    session = sa.orm.session.Session(bind=op.get_bind())

    # there may be existing duplicates in the database, remove them first

    seen = set()

    # duplicate_values contains one copy of each duplicated pair

    duplicate_values = (

        session

    )

    for pull_request_id, user_id in duplicate_values:

        # duplicate_occurrences contains all db records of the duplicate_value

        # currently being processed

        duplicate_occurrences = (

            session

        )

        for prr in duplicate_occurrences:

            if (pull_request_id, user_id) in seen:

                session.delete(prr)

            else:

                seen.add((pull_request_id, user_id))

import click

import kallithea

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils import REMOVED_REPO_PAT, repo2db_mapper

from kallithea.lib.utils2 import ask_ok

from kallithea.model.scm import ScmModel

@cli_base.register_command(config_file_initialize_app=True)

@click.option('--remove-missing', is_flag=True,

        help='Remove missing repositories from the Kallithea database.')

    command to update the repository cache.

    If no repositories are specified, the caches of all repositories are

    updated.

    """

    if not repositories:

    else:

        repo_names = [n.strip() for n in repositories]

    for repo in repo_list:

        # update latest revision metadata in database

        repo.update_changeset_cache()

        # invalidate in-memory VCS object cache... will be repopulated on

        # first access

import re

from kallithea.config.middleware.pygrack import make_wsgi_app

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.hooks import log_pull_action

from kallithea.lib.utils import make_ui

log = logging.getLogger(__name__)

GIT_PROTO_PAT = re.compile(r'^/(.+)/(info/refs|git-upload-pack|git-receive-pack)$')

        def wrapper_app(environ, start_response):

            if (parsed_request.cmd == 'info/refs' and

                parsed_request.service == 'git-upload-pack'

            ):

                baseui = make_ui()

                scm_repo = repo.scm_instance

                # Run hooks, like Mercurial outgoing.pull_logger does

                log_pull_action(ui=baseui, repo=scm_repo._repo)

            # Note: push hooks are handled by post-receive hook

            return pygrack_app(environ, start_response)

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.indexers import JOURNAL_SCHEMA

from kallithea.lib.page import Page

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

log = logging.getLogger(__name__)

def _journal_filter(user_log, search_term):

            wc_term = remove_suffix(wc_term, suffix='*')

            return func.lower(col).contains(func.lower(wc_term))

    def get_filterion(field, val, term):

        if field == 'repository':

        elif field == 'ip':

        elif field == 'date':

        elif field == 'username':

        else:

        log.debug('filter field: %s val=>%s', field, val)

        # sql filtering

        if isinstance(term, query.Wildcard):

            return wildcard_handler(field, val)

        elif isinstance(term, query.Prefix):

    @LoginRequired(allow_default_user=True)

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

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

    @HasPermissionAnyDecorator('hg.admin')

    def index(self):

        # FILTERING

        c.search_term = request.GET.get('filter')

        users_log = _journal_filter(users_log, c.search_term)

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

        c.users_log = Page(users_log, page=p, items_per_page=10,

                           filter=c.search_term)

from webob.exc import HTTPFound

from kallithea.lib import auth_modules

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import AuthSettingsForm

log = logging.getLogger(__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

                if setting is not None:

                    c.defaults[fullname] = setting.app_settings_value

        if defaults:

            c.defaults.update(defaults)

        # we want to show , separated list of enabled plugins

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

            meta.Session().commit()

            h.flash(_('Auth settings updated successfully'),

                       category='success')

        except formencode.Invalid as errors:

            log.error(traceback.format_exc())

            e = errors.error_dict or {}

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import DefaultsForm

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

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

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

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

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

            meta.Session().commit()

            h.flash(_('Default settings updated successfully'),

                    category='success')

        except formencode.Invalid as errors:

            defaults = errors.value

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.forms import GistForm

from kallithea.model.gist import GistModel

log = logging.getLogger(__name__)

        url_params = {}

        if c.show_public:

            url_params['public'] = 1

        elif c.show_private:

            url_params['private'] = 1

            .filter_by(is_expired=False) \

        # MY private

        if c.show_private and not c.show_public:

        # MY public

        elif c.show_public and not c.show_private:

        # MY public+private

        elif c.show_private and c.show_public:

        # default show ALL public gists

        if not c.show_public and not c.show_private:

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

    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

            nodes = {

                filename: {

                    'content': form_result['content'],

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

                }

            }

            _public = form_result['public']

            gist = GistModel().create(

                description=form_result['description'],

                owner=request.authuser.user_id,

                ip_addr=request.ip_addr,

                gist_mapping=nodes,

                gist_type=gist_type,

            raise HTTPForbidden()

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

    @LoginRequired(allow_default_user=True)

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

        if c.gist.is_expired:

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

                      time_to_datetime(c.gist.gist_expires))

            raise HTTPNotFound()

        try:

            response.content_type = 'text/plain'

            return content

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

    @LoginRequired()

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

        if c.gist.is_expired:

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

                      time_to_datetime(c.gist.gist_expires))

            raise HTTPNotFound()

        try:

        return rendered

    @LoginRequired()

    @jsonify

    def check_revision(self, 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:

from kallithea.lib import auth_modules

from kallithea.lib import helpers as h

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

    @LoginRequired()

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

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

    def __load_data(self):

        if c.user.is_default_user:

            h.flash(_("You can't edit this user since it's"

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

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

    def _load_my_repos_data(self, watched=False):

        if watched:

            admin = False

                                 request.authuser.user_id).all()

        else:

            admin = True

                                 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)

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

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

    def my_account_emails(self):

        c.active = 'emails'

        self.__load_data()

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

    def my_account_emails_add(self):

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

        try:

        h.flash(_("API key successfully created"), category='success')

        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.api_key = generate_api_key()

            meta.Session().commit()

            h.flash(_("API key successfully reset"), category='success')

        elif api_key:

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

            meta.Session().commit()

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import DefaultPermissionsForm

from kallithea.model.permission import PermissionModel

log = logging.getLogger(__name__)

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during update of permissions'),

                        category='error')

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

        defaults = {'anonymous': c.user.active}

        for p in c.user.user_perms:

            if p.permission.permission_name.startswith('repository.'):

                defaults['default_repo_perm'] = p.permission.permission_name

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def permission_ips(self):

        c.active = 'ips'

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

    def permission_perms(self):

        c.active = 'perms'

        c.perm_user = AuthUser(dbuser=c.user)

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

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

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoGroupPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.utils2 import safe_int

from kallithea.model.forms import RepoGroupForm, RepoGroupPermsForm

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.scm import AvailableRepoGroupChoices, RepoGroupList

    def __load_data(self, group_id):

        """

        Load defaults settings for edit, and update

        :param group_id:

        """

        data = repo_group.get_dict()

        data['group_name'] = repo_group.name

        # fill repository group users

        for p in repo_group.repo_group_to_perm:

            data.update({'u_perm_%s' % p.user.username:

        _new = [u for u in form_result['perms_new'] if request.authuser.username == u[0]]

        if _new and _new[0][1] != 'group.admin' or _up and _up[0][1] != 'group.admin':

            return True

        return False

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

        group_iter = RepoGroupList(_list, perm_level='admin')

        repo_groups_data = []

        _tmpl_lookup = app_globals.mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        def repo_group_name(repo_group_name, children_groups):

            # 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_name = group.group_name if group else None

            if HasRepoGroupPermissionLevel('admin')(group_name, 'group create'):

                pass

            else:

                raise HTTPForbidden()

        self.__load_defaults()

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

    @HasRepoGroupPermissionLevelDecorator('admin')

    def update(self, 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!

        if HasPermissionAny('hg.admin')('group edit'):

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

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

        raise HTTPFound(location=url('edit_repo_group', group_name=group_name))

    @HasRepoGroupPermissionLevelDecorator('admin')

    def delete(self, group_name):

        repos = gr.repositories.all()

        if repos:

            h.flash(_('This group contains %s repositories and cannot be '

                      'deleted') % len(repos), category='warning')

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

    def show_by_name(self, group_name):

        """

        This is a proxy that does a lookup group_name -> id, and shows

        the group by id view instead

        """

        group_name = group_name.rstrip('/')

        if id_:

            return self.show(group_name)

        raise HTTPNotFound

    @HasRepoGroupPermissionLevelDecorator('read')

    def show(self, group_name):

        c.active = 'settings'

        repo_groups_list = self.scm_model.get_repo_groups(groups)

        c.data = RepoModel().get_repos_as_dict(repos_list,

                                               repo_groups_list=repo_groups_list,

                                               short_name=True)

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

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit(self, group_name):

        c.active = 'settings'

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

                             exclude=[c.repo_group])

        defaults = self.__load_data(c.repo_group.group_id)

        return htmlfill.render(

            render('admin/repo_groups/repo_group_edit.html'),

            force_defaults=False

        )

    @HasRepoGroupPermissionLevelDecorator('admin')