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

"""rename hooks

Revision ID: a020f7044fd6

Revises: 9358dc3d6828

Create Date: 2017-11-24 13:35:14.374000

"""

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

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

"""Drop locking

Revision ID: ad357ccd9521

Revises: a020f7044fd6

Create Date: 2019-01-08

"""

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

    # Note: not restoring hooks

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

"""add unique constraint on PullRequestReviewer

Revision ID: f62826179f39

Revises: a0a1bf09c143

Create Date: 2020-06-15 12:30:37.420321

"""

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

def downgrade():

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

        batch_op.drop_constraint(batch_op.f('uq_pull_request_reviewers_pull_request_id'), type_='unique')

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

"""

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

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

:created_on: Feb 9, 2013

:author: marcink

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

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

"""

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

    but are no longer present on the filesystem. If option --remove-missing is

    given, remove the missing repositories from the Kallithea database.

    """

    click.echo('Now scanning root location for new repos ...')

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

                                    remove_obsolete=remove_missing)

    click.echo('Scan completed.')

    if added:

        click.echo('Added: %s' % ', '.join(added))

    if removed:

        click.echo('%s: %s' % ('Removed' if remove_missing else 'Missing',

                          ', '.join(removed)))

@cli_base.register_command(config_file_initialize_app=True)

@click.argument('repositories', nargs=-1)

def repo_update_metadata(repositories):

    """

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

@cli_base.register_command(config_file_initialize_app=True)

@click.option('--ask/--no-ask', default=True, help='Ask for confirmation or not. Default is --ask.')

@click.option('--older-than',

        help="""Only purge repositories that have been removed at least the given time ago.

        For example, '--older-than=30d' purges repositories deleted 30 days ago or longer.

        Possible suffixes: d (days), h (hours), m (minutes), s (seconds).""")

def repo_purge_deleted(ask, older_than):

    """Purge backups of deleted repositories.

    When a repository is deleted via the Kallithea web interface, the actual

    data is still present on the filesystem but set aside using a special name.

    This command allows to delete these files permanently.

    """

    def _parse_older_than(val):

        regex = re.compile(r'((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')

        parts = regex.match(val)

        if not parts:

            return

        parts = parts.groupdict()

        time_params = {}

        for name, param in parts.items():

            if param:

                time_params[name] = int(param)

        return datetime.timedelta(**time_params)

    def _extract_date(name):

        """

        Extract the date part from rm__<date> pattern of removed repos,

        and convert it to datetime object

        :param name:

        """

        date_part = name[4:19]  # 4:19 since we don't parse milliseconds

        return datetime.datetime.strptime(date_part, '%Y%m%d_%H%M%S')

    repos_location = kallithea.CONFIG['base_path']

    to_remove = []

    for dn_, dirs, f in os.walk(repos_location):

        alldirs = list(dirs)

        del dirs[:]

        if ('.hg' in alldirs or

            '.git' in alldirs or

            '.svn' in alldirs or

            'objects' in alldirs and ('refs' in alldirs or 'packed-refs' in f)

        ):

            continue

        for loc in alldirs:

            if REMOVED_REPO_PAT.match(loc):

                to_remove.append([os.path.join(dn_, loc),

                                  _extract_date(loc)])

            else:

                dirs.append(loc)

        if dirs:

            click.echo('Scanning: %s' % dn_)

    if not to_remove:

        click.echo('There are no deleted repositories.')

        return

    # filter older than (if present)!

    if older_than:

        now = datetime.datetime.now()

        to_remove_filtered = []

        older_than_date = _parse_older_than(older_than)

        for name, date_ in to_remove:

            repo_age = now - date_

            if repo_age > older_than_date:

                to_remove_filtered.append([name, date_])

        to_remove = to_remove_filtered

        if not to_remove:

            click.echo('There are no deleted repositories older than %s (%s)'

                    % (older_than, older_than_date))

            return

        click.echo('Considering %s deleted repositories older than %s (%s).'

            % (len(to_remove), older_than, older_than_date))

    else:

        click.echo('Considering %s deleted repositories.' % len(to_remove))

    if not ask:

        remove = True

    else:

        remove = ask_ok('The following repositories will be removed completely:\n%s\n'

            'Do you want to proceed? [y/n] ' %

            '\n'.join('%s deleted on %s' % (path, date_) for path, date_ in to_remove))

    if remove:

        for path, date_ in to_remove:

            click.echo('Purging repository %s' % path)

            shutil.rmtree(path)

    else:

        click.echo('Nothing done, exiting...')

# -*- 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.lib.middleware.simplegit

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

SimpleGit middleware for handling Git protocol requests (push/clone etc.)

It's implemented with basic auth function

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 28, 2010

:author: marcink

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

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

}

class SimpleGit(BaseVCSController):

    scm_alias = 'git'

    @classmethod

    def parse_request(cls, environ):

        path_info = get_path_info(environ)

        m = GIT_PROTO_PAT.match(path_info)

        if m is None:

            return None

        class parsed_request(object):

            # See https://git-scm.com/book/en/v2/Git-Internals-Transfer-Protocols#_the_smart_protocol

            repo_name = m.group(1).rstrip('/')

            cmd = m.group(2)

            query_string = environ['QUERY_STRING']

            if cmd == 'info/refs' and query_string.startswith('service='):

                service = query_string.split('=', 1)[1]

                action = cmd_mapping.get(service)

            else:

                service = None

                action = cmd_mapping.get(cmd)

        return parsed_request

    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

# -*- 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.admin

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

Controller for Admin panel of 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 7, 2010

:author: marcink

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

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

"""

import logging

from sqlalchemy.orm import joinedload

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:

    """

    log.debug('Initial search term: %r', search_term)

    qry = None

    if search_term:

        qp = QueryParser('repository', schema=JOURNAL_SCHEMA)

        qp.add_plugin(DateParserPlugin())

        qry = qp.parse(search_term)

        log.debug('Filtering using parsed query %r', qry)

    def wildcard_handler(col, wc_term):

        if wc_term.startswith('*') and not wc_term.endswith('*'):

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

                        query.DateRange)):

        if not isinstance(qry, query.And):

            qry = [qry]

        for term in qry:

            field = term.fieldname

            val = (term.text if not isinstance(term, query.DateRange)

                   else [term.startdate, term.enddate])

            user_log = user_log.filter(get_filterion(field, val, term))

    elif isinstance(qry, query.Or):

        filters = []

        for term in qry:

            field = term.fieldname

            val = (term.text if not isinstance(term, query.DateRange)

                   else [term.startdate, term.enddate])

            filters.append(get_filterion(field, val, term))

        user_log = user_log.filter(or_(*filters))

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

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

    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

                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,

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