import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils import REMOVED_REPO_PAT, repo2db_mapper

from kallithea.model.db import Repository, Ui

from kallithea.model.meta import Session

from kallithea.model.scm import ScmModel

    if not repositories:

        repo_list = Repository.query().all()

    else:

        repo_list = list(Repository.query()

                        .filter(Repository.repo_name.in_(repo_names)))

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        if format == 'raw':

            response.content_type = 'text/plain'

            return content

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

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.model.db import RepoGroup, Repository

from kallithea.model.forms import RepoGroupForm, RepoGroupPermsForm

from kallithea.model.meta import Session

        )

        for repo_gr in group_iter:

            repo_count = repo_gr.repositories.count()

            repo_groups_data.append({

                "raw_name": repo_gr.group_name,

    Session().commit()

    data = {

    }

    if comment is not None:

        c.comment = comment

            desc_msg.append('\n\n')

            desc_msg.append(safe_unicode(raw_diff))

        desc_msg.append('</pre>')

    def _feed(self, repo_name, feeder):

        """Produce a simple feed"""

from kallithea.config.routing import url

from kallithea.lib.caching_query import FromCache

from kallithea.lib.utils import conditional_cache, get_repo_group_slug, get_repo_slug, get_user_group_slug

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.model.db import (

    Permission, RepoGroup, Repository, User, UserApiKeys, UserGroup, UserGroupMember, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserGroupToPerm, UserGroupUserGroupToPerm, UserIpMap, UserToPerm)

        self.required_perms = set(perms)

    def __call__(self, authuser, repo_name, purpose=None):

        try:

            ok = authuser.permissions['repositories'][repo_name] in self.required_perms

        except KeyError:

from kallithea.lib import auth_modules

from kallithea.lib.compat import hybrid_property

from kallithea.model.db import Setting

        user_data = {

            'username': username,

            'groups': [],

            'email': email or '',

            'admin': admin or False,

from kallithea.lib import auth_modules

from kallithea.lib.compat import hybrid_property

from kallithea.lib.exceptions import LdapConnectionError, LdapImportError, LdapPasswordError, LdapUsernameError

log = logging.getLogger(__name__)

            user_data = {

                'username': username,

                'groups': [],

                'email': get_ldap_attr('attr_email') or email,

                'admin': admin,

                return

            log.debug('Found repository in database %s with state `%s`',

            route = getattr(request.environ.get('routes.route'), 'name', '')

            # allow to delete repos that are somehow damages in filesystem

class _FilesBreadCrumbs(object):

    def __call__(self, repo_name, rev, paths):

        url_l = [link_to(repo_name, url('files_home',

                                        repo_name=repo_name,

                                        revision=rev, f_path=''),

        suf = ''

        if len(nodes) > 30:

            suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)

                                             for x in nodes[:30]]) + suf)

    else:

        return ': ' + _('No files')

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.model.db import Repository, User

    #logging.config.fileConfig(ini_file_path) # Note: we are in a different process - don't use configured logging

    kallithea.config.middleware.make_app(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)

    # fix if it's not a bare repo

    if repo_path.endswith(os.sep + '.git'):

        repo_path = repo_path[:-5]

        # filter repo list

        if repo_list:

            self.filtered_repo_paths = {}

            for repo_name, repo in self.repo_paths.items():

                if repo_name in repo_list:

            self.initial = False

    def _get_index_revision(self, repo):

        landing_rev = 'tip'

        if db_repo:

            _rev_type, _rev = db_repo.landing_rev

            u_content = u''

            indexed += 1

        writer.add_document(

            content=u_content,

            modtime=self.get_node_mtime(node),

            extension=node.extension

            indexed += 1

            log.debug('    >> %s %s/%s', cs, indexed, total)

            writer.add_document(

                date=cs._timestamp,

                author=cs.author,

                message=cs.message,

                last=cs.last,

            )

        return indexed

                ri_cnt = 0   # indexed

                riwc_cnt = 0  # indexed with content

                for path in self.get_paths(repo):

                    if path in to_index or path not in indexed_paths:

                        # This is either a file that's changed, or a new file

                        # that wasn't indexed before. So index it!

                        i, iwc = self.add_doc(writer, path, repo, repo_name)

from webob import Request, Response, exc

import kallithea

from kallithea.lib.vcs import subprocessio

        :param path:

        """

        assert path.startswith('/' + self.repo_name + '/')

        return path[len(self.repo_name) + 2:].strip('/')

from kallithea.lib.hooks import log_pull_action

from kallithea.lib.middleware.pygrack import make_wsgi_app

from kallithea.lib.utils import make_ui

from kallithea.model.db import Repository

        class parsed_request(object):

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

            cmd = m.group(2)

            query_string = environ['QUERY_STRING']

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.utils import make_ui

log = logging.getLogger(__name__)

            return None

        class parsed_request(object):

            query_string = environ['QUERY_STRING']

import kallithea.config.conf

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.vcs.backends.git.repository import GitRepository

from kallithea.lib.vcs.backends.hg.repository import MercurialRepository

from kallithea.lib.vcs.conf import settings

    user_log = UserLog()

    user_log.user_id = user_obj.user_id

    user_log.username = user_obj.username

    user_log.repository = repo_obj

    user_log.repository_name = repo_name

    meta.Session().add(user_log)

    log.info('Logging action:%s on %s by user:%s ip:%s',

    if commit:

        meta.Session().commit()

    for name, repo in initial_repo_dict.items():

        group = map_groups(name)

        # found repo that is on filesystem not in Kallithea database

        if not db_repo:

            log.info('repository %s not found, creating now', name)

    removed = []

    # remove from database those repositories that are not in the filesystem

    for repo in sa.query(Repository).all():

            if remove_obsolete:

                log.debug("Removing non-existing repository found in db `%s`",

                          repo.repo_name)

def get_clone_url(clone_uri_tmpl, prefix_url, repo_name, repo_id, username=None):

    parsed_url = urlobject.URLObject(prefix_url)

    try:

        system_user = pwd.getpwuid(os.getuid()).pw_name

    except Exception: # TODO: support all systems - especially Windows

        system_user = 'kallithea' # hardcoded default value ...

    args = {

        'scheme': parsed_url.scheme,

        'netloc': parsed_url.netloc + prefix,  # like "hostname:port/prefix" (with optional ":port" and "/prefix")

        'prefix': prefix, # undocumented, empty or starting with /

        'repo': repo_name,

        'repoid': str(repo_id),

        'hostname': parsed_url.hostname,

    }

    url = re.sub('{([^{}]+)}', lambda m: args.get(m.group(1), m.group(0)), clone_uri_tmpl)

    if not url_obj.username:

        url_obj = url_obj.with_username(None)

def get_changeset_safe(repo, rev):

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

    ChangesetError, EmptyRepositoryError, NodeAlreadyAddedError, NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError, NodeDoesNotExistError, NodeNotChangedError, RepositoryError)

from kallithea.lib.vcs.utils.helpers import get_dict_for_attrs

from kallithea.lib.vcs.utils.lazy import LazyProperty

                message=self.message,

                date=self.date,

                author=self.author,

            )

        else:

            return dict(

        data = get_dict_for_attrs(self, ['raw_id', 'short_id',

            'revision', 'date', 'message'])

        data['author'] = {'name': self.author_name, 'email': self.author_email}

        return data

    @LazyProperty

    def __init__(self, repo_path, create=False, src_url=None,

                 update_after_clone=False, bare=False):

        self.repo = self._get_repo(create, src_url, update_after_clone, bare)

        self.bare = self.repo.bare

from kallithea.lib.hooks import log_pull_action

from kallithea.lib.utils import make_ui

from kallithea.lib.vcs.backends.ssh import BaseSshHandler

log = logging.getLogger(__name__)

            ssh_command_parts[0] in ['git-upload-pack', 'git-receive-pack'] and

            ssh_command_parts[1].startswith('/')

        ):

        return None

from kallithea.lib.utils import make_ui

from kallithea.lib.vcs.backends.ssh import BaseSshHandler

log = logging.getLogger(__name__)

        >>> MercurialSshHandler.make(shlex.split('git-upload-pack "/foo"')) # not handled here

        """

        if ssh_command_parts[:2] == ['hg', '-R'] and ssh_command_parts[3:] == ['serve', '--stdio']:

        return None

        Returns name of the node so if its path

        then only last part is returned.

        """

    def _get_kind(self):

        return self._kind

        Returns name of the node so if its path

        then only last part is returned.

        """

        return u'%s @ %s' % (org, self.changeset.short_id)

from tg.i18n import ugettext as _

from kallithea.lib import helpers as h

from kallithea.model.db import ChangesetComment, PullRequest, Repository, User

from kallithea.model.meta import Session

from kallithea.model.notification import NotificationModel

                repo_name=repo.repo_name,

                revision=revision,

                anchor='comment-%s' % comment.comment_id)

                          {'desc': desc, 'line': line},

            # get the current participants of this changeset

            recipients = _list_changeset_commenters(revision)

            # add changeset author if it's known locally

                                                          h.canonical_hostname()))

            comment_url = pull_request.url(canonical=True,

                anchor='comment-%s' % comment.comment_id)

                          {'desc': desc,

                           'pr_nice_id': comment.pull_request.nice_id(),

                           'line': line},

            # get the current participants of this pull request

            recipients = _list_pull_request_commenters(pull_request)

            recipients.append(pull_request.owner)

        info = {

            'modules': sorted(mods, key=lambda k: k[0].lower()),

            'py_version': platform.python_version(),

            'kallithea_version': kallithea.__version__,

            'git_path': kallithea.CONFIG.get('git_path')

        }

        return info

        # names in the database, but that eventually needs to be converted

        # into a valid system path

        p += self.repo_name.split(Repository.url_sep())

    @property

    def cache_keys(self):

    @revisions.setter

    def revisions(self, val):

    @property

    def org_ref_parts(self):

import traceback

from kallithea.lib import ext_json

from kallithea.model.db import Gist, Session, User

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

        gist.gist_access_id = gist_access_id

        gist.owner_id = owner.user_id

        gist.gist_expires = gist_expires

        Session().add(gist)

        Session().flush() # make database assign gist.gist_id

        if gist_type == Gist.GIST_PUBLIC:

from tg.i18n import ugettext as _

from kallithea.lib import helpers as h

from kallithea.model.db import ChangesetStatus, PullRequest, PullRequestReviewer, User

from kallithea.model.meta import Session

from kallithea.model.notification import NotificationModel

        threading = ['%s-pr-%s@%s' % (pr.other_repo.repo_name,

                                      pr.pull_request_id,

                                      h.canonical_hostname())]

                {'user': user.username,

                 'pr_title': pr.title,

                 'pr_nice_id': pr.nice_id()},

        body = pr.description

        _org_ref_type, org_ref_name, _org_rev = pr.org_ref.split(':')

        _other_ref_type, other_ref_name, _other_rev = pr.other_ref.split(':')

from kallithea.lib.exceptions import AttachedForksError

from kallithea.lib.hooks import log_delete_repository

from kallithea.lib.utils import is_valid_repo_uri, make_ui

from kallithea.lib.vcs.backends import get_backend

from kallithea.model.db import (

    Permission, RepoGroup, Repository, RepositoryField, Session, Statistics, Ui, User, UserGroup, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserRepoGroupToPerm, UserRepoToPerm)

        fork_of = Repository.guess_instance(fork_of)

        repo_group = RepoGroup.guess_instance(repo_group)

        try:

            # repo name is just a name of repository

            # while repo_name_full is a full qualified name that is combined

            # with name and path of group

            raise Exception('This path %s is a valid group' % repo_path)

        log.info('creating repo %s in %s from url: `%s`',

            obfuscate_url_pw(clone_uri))

        backend = get_backend(repo_type)

            raise Exception('Not supported repo_type %s expected hg/git' % repo_type)

        log.debug('Created repo %s with %s backend',

        return repo

    def _rename_filesystem_repo(self, old, new):

from kallithea.lib.exceptions import IMCCommitError, NonRelativePathError

from kallithea.lib.hooks import process_pushed_raw_ids

from kallithea.lib.utils import action_logger, get_filesystem_repos, make_ui

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import RepositoryError

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        path = safe_str(f_path)

        imc = IMC(repo)

        imc.change(FileNode(path, content, mode=cs.get_file_mode(f_path)))

        try:

                content = content.read()

            processed_nodes.append((f_path, content))

        committer = user.full_contact

        IMC = self._get_IMC_module(scm_instance.alias)

        imc = IMC(scm_instance)

        user = User.guess_instance(user)

        scm_instance = repo.scm_instance_no_cache()

        committer = user.full_contact

        imc_class = self._get_IMC_module(scm_instance.alias)

        imc = imc_class(scm_instance)

            content = nodes[f_path].get('content')

            processed_nodes.append((f_path, content))

        committer = user.full_contact

        IMC = self._get_IMC_module(scm_instance.alias)

        imc = IMC(scm_instance)

from kallithea.lib.caching_query import FromCache

from kallithea.lib.exceptions import DefaultUserException, UserOwnsReposException

from kallithea.model.db import Permission, User, UserEmailMap, UserIpMap, UserToPerm

from kallithea.model.meta import Session

            new_user.admin = admin

            new_user.email = email

            new_user.active = active

            new_user.name = firstname

            new_user.lastname = lastname

            % for cnt, file in enumerate(c.files):

                <div id="body" class="panel panel-default form-inline">

                    <div class="panel-heading">

                        <select class="form-control" id="mimetype_${h.FID('f',file.path)}" name="mimetypes"></select>

                    </div>

                    <div class="panel-body no-padding">

              <div class="panel panel-default">

                <div id="${h.FID('G', file.path)}" class="panel-heading clearfix">

                    <div class="pull-left">

                    </div>

                    <div class="pull-right">

                    </div>

                </div>

                <div class="panel-body no-padding">

                %for fid, url_fid, op, a_path, path, diff, stats in file_diff_data:

                    <div class="cs_${op} clearfix">

                      <span class="node">

                      </span>

                      <div class="changes">${h.fancy_file_stats(stats)}</div>

                    </div>

<div class="comments inline-comments">

  %for f_path, lines in c.inline_comments:

    %for line_no, comments in lines.items():

        %for co in comments:

            ${comment_block(co)}

        %endfor