"""

# The following opaque hexadecimal identifiers ("revisions") are used

# by Alembic to track this migration script and its relations to others.

revision = 'a020f7044fd6'

down_revision = '9358dc3d6828'

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_key': 'preoutgoing.pull_lock_handling',

        '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={

        'ui_key': 'preoutgoing.pre_pull',

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

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

# The following opaque hexadecimal identifiers ("revisions") are used

# by Alembic to track this migration script and its relations to others.

revision = 'ad357ccd9521'

down_revision = 'a020f7044fd6'

branch_labels = None

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('groups', schema=None) as batch_op:

        batch_op.drop_column('enable_locking')

    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:

        batch_op.add_column(sa.Column('enable_locking', sa.BOOLEAN(), nullable=False, default=False))

        batch_op.add_column(sa.Column('locked', sa.VARCHAR(length=255), nullable=True, default=False))

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

        batch_op.add_column(sa.Column('enable_locking', sa.BOOLEAN(), nullable=False, default=False))

"""

# The following opaque hexadecimal identifiers ("revisions") are used

# by Alembic to track this migration script and its relations to others.

revision = 'f62826179f39'

down_revision = 'a0a1bf09c143'

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

    session.commit()

    # after deleting all duplicates, add the unique constraint

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

        batch_op.create_unique_constraint(batch_op.f('uq_pull_request_reviewers_pull_request_id'), ['pull_request_id', 'user_id'])

"""

import datetime

import os

import re

import shutil

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

def repo_scan(remove_missing):

    """Scan filesystem for repositories.

    Search the configured repository root for new repositories and add them

    into Kallithea.

    Additionally, report repositories that were previously known to Kallithea

    Update repository metadata in database from repository content.

    In normal operation, Kallithea will keep caches up-to-date

    automatically. However, if repositories are externally modified, e.g. by

    a direct push via the filesystem rather than via a Kallithea URL,

    Kallithea is not aware of it. In this case, you should manually run this

    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

        repo.set_invalidate()

    meta.Session().commit()

    click.echo('Updated database with information about latest change in the following %s repositories:' % (len(repo_list)))

    click.echo('\n'.join(repo.repo_name for repo in repo_list))

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

"""

import logging

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

cmd_mapping = {

    'git-receive-pack': 'push',

    'git-upload-pack': 'pull',

}

    def _make_app(self, parsed_request):

        """

        Return a pygrack wsgi application.

        """

        pygrack_app = make_wsgi_app(parsed_request.repo_name, self.basepath)

        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)

        return wrapper_app

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

from tg import request

from tg import tmpl_context as c

from whoosh import query

from whoosh.qparser.dateparse import DateParserPlugin

from whoosh.qparser.default import QueryParser

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

    """

    Filters sqlalchemy user_log based on search_term with whoosh Query language

    http://packages.python.org/Whoosh/querylang.html

    :param user_log:

    :param search_term:

            # postfix == endswith

            wc_term = remove_prefix(wc_term, prefix='*')

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

        elif wc_term.startswith('*') and wc_term.endswith('*'):

            # wildcard == ilike

            wc_term = remove_prefix(wc_term, prefix='*')

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

            return func.lower(field).startswith(func.lower(val))

        elif isinstance(term, query.DateRange):

            return and_(field >= val[0], field <= val[1])

        return func.lower(field) == func.lower(val)

    if isinstance(qry, (query.And, query.Term, query.Prefix, query.Wildcard,

    return user_log

class AdminController(BaseController):

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

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('admin/admin_log.html')

        return render('admin/admin.html')

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

class AuthSettingsController(BaseController):

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

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

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

        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

                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

        c.defaults['auth_plugins'] = ','.join(c.enabled_plugin_names)

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

        return formencode.htmlfill.render(

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

            defaults=c.defaults,

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

            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 {}

            return self.__render(

                defaults=errors.value,

                errors=e,

            )

        except Exception:

            log.error(traceback.format_exc())

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

class DefaultsController(BaseController):

    @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

            return htmlfill.render(

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

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

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 import helpers as h

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

class GistsController(BaseController):

    def __load_defaults(self, extra_values=None):

        c.lifetime_values = [

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

    @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

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

    @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

            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,

                lifetime=form_result['lifetime']

            )

            meta.Session().commit()

            new_gist_id = gist.gist_access_id

        except formencode.Invalid as errors:

            defaults = errors.value

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

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

            GistModel().delete(gist)

            meta.Session().commit()

            h.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')

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

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

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

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during update of gist %s') % gist_id,

                        category='error')

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

        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:

            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}

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

log = logging.getLogger(__name__)

class MyAccountController(BaseController):

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

        update = False

        if request.POST:

            _form = UserForm(edit=True,

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

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

            form_result = {}

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

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

            h.flash(_("Added email %s to user") % email, category='success')

        except formencode.Invalid as error:

            msg = error.error_dict['email']

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

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

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