from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.exceptions import NonRelativePathError

from kallithea.lib.utils import action_logger

from kallithea.lib.utils2 import convert_line_endings, detect_mode, safe_int, safe_str, str2bool

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

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, ImproperArchiveTypeError, NodeAlreadyExistsError,

                                          NodeDoesNotExistError, NodeError, RepositoryError, VCSError)

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

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

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

            c.authors = []

            for a in set([x.author for x in _hist]):

                c.authors.append((h.email(a), h.person(a)))

            return render('files/files_history_box.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def rawfile(self, repo_name, revision, f_path):

        cs = self.__get_cs(revision)

        file_node = self.__get_filenode(cs, f_path)

        response.content_disposition = \

        response.content_type = file_node.mimetype

        return file_node.content

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def raw(self, repo_name, revision, f_path):

        cs = self.__get_cs(revision)

        file_node = self.__get_filenode(cs, f_path)

        raw_mimetype_mapping = {

            # map original mimetype to a mimetype used for "show as raw"

import mercurial.error

import mercurial.ui

import kallithea.config.conf

from kallithea.lib.exceptions import InvalidCloneUriException

from kallithea.lib.utils2 import ascii_bytes, aslist, get_current_authuser, safe_bytes, safe_str

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

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError

from kallithea.lib.vcs.utils.fakemod import create_module

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

from kallithea.model.db import RepoGroup, Repository, Setting, Ui, User, UserGroup, UserLog

log = logging.getLogger(__name__)

REMOVED_REPO_PAT = re.compile(r'rm__\d{8}_\d{6}_\d{6}_.*')

#==============================================================================

# PERM DECORATOR HELPERS FOR EXTRACTING NAMES FOR PERM CHECKS

#==============================================================================

def get_repo_slug(request):

def map_groups(path):

    """

    Given a full path to a repository, create all nested groups that this

    repo is inside. This function creates parent-child relationships between

    groups and creates default perms for all new groups.

    :param paths: full path to repository

    """

    from kallithea.model.repo_group import RepoGroupModel

    sa = meta.Session()

    parent = None

    group = None

    # last element is repo in nested groups structure

    groups = groups[:-1]

    rgm = RepoGroupModel()

    owner = User.get_first_admin()

    for lvl, group_name in enumerate(groups):

        group_name = '/'.join(groups[:lvl] + [group_name])

        group = RepoGroup.get_by_group_name(group_name)

        desc = '%s group' % group_name

        """Add Repository-specific helpers for common query constructs.

        sorted: if True, apply the default ordering (name, case insensitive).

        """

        q = super(Repository, cls).query()

        if sorted:

            q = q.order_by(sqlalchemy.func.lower(Repository.repo_name))

        return q

    @classmethod

    def normalize_repo_name(cls, repo_name):

        """

        Normalizes os specific repo_name to the format internally stored inside

        database using URL_SEP

        :param cls:

        :param repo_name:

        """

    @classmethod

    def guess_instance(cls, value):

        return super(Repository, cls).guess_instance(value, Repository.get_by_repo_name)

    @classmethod

    def get_by_repo_name(cls, repo_name, case_insensitive=False):

        """Get the repo, defaulting to database case sensitivity.

        case_insensitive will be slower and should only be specified if necessary."""

        if case_insensitive:

            q = Session().query(cls).filter(sqlalchemy.func.lower(cls.repo_name) == sqlalchemy.func.lower(repo_name))

        else:

    @classmethod

    def get_repo_forks(cls, repo_id):

        return cls.query().filter(Repository.fork_id == repo_id)

    @classmethod

    def base_path(cls):

        """

        Returns base path where all repos are stored

        :param cls:

        """

        q = Session().query(Ui) \

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

    @property

    def forks(self):

        """

        Return forks of this repo

        """

        return Repository.get_repo_forks(self.repo_id)

    @property

    def parent(self):

        """

        Returns fork parent

        """

        return self.fork

    @property

    def just_name(self):

    @property

    def groups_with_parents(self):

        groups = []

        group = self.group

        while group is not None:

            groups.append(group)

            group = group.parent_group

            assert group not in groups, group # avoid recursion on bad db content

        groups.reverse()

        return groups

    @LazyProperty

    def repo_path(self):

        """

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

    @property

    def repo_full_path(self):

        p = [self.repo_path]

        # we need to split the name by / since this is how we store the

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

        # into a valid system path

        return os.path.join(*p)

    @property

    def cache_keys(self):

        """

        Returns associated cache keys for that repo

        """

        return CacheInvalidation.query() \

            .filter(CacheInvalidation.cache_args == self.repo_name) \

            .order_by(CacheInvalidation.cache_key) \

            .all()

    def get_new_name(self, repo_name):

        """

        returns new full repository name based on assigned group and new new

        :param group_name:

        """

        path_prefix = self.group.full_path_splitted if self.group else []

    @property

    def _ui(self):

        """

        Creates an db based ui object for this repository

        """

        from kallithea.lib.utils import make_ui

        return make_ui()

    @classmethod

    def is_valid(cls, repo_name):

        """

        from webhelpers2.html import literal

        if repo_group is None:

            return (-1, '-- %s --' % _('top level'))

        return repo_group.group_id, literal(cls.SEP.join(repo_group.full_path_splitted))

    @classmethod

    def groups_choices(cls, groups):

        """Return tuples with group_id and name as html literal."""

        return sorted((cls._generate_choice(g) for g in groups),

                      key=lambda c: c[1].split(cls.SEP))

    @classmethod

    def guess_instance(cls, value):

        return super(RepoGroup, cls).guess_instance(value, RepoGroup.get_by_group_name)

    @classmethod

    def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):

        group_name = group_name.rstrip('/')

        if case_insensitive:

            gr = cls.query() \

                .filter(sqlalchemy.func.lower(cls.group_name) == sqlalchemy.func.lower(group_name))

        else:

            gr = cls.query() \

                .filter(cls.group_name == group_name)

            groups.append(group)

            group = group.parent_group

            assert group not in groups, group # avoid recursion on bad db content

        groups.reverse()

        return groups

    @property

    def children(self):

        return RepoGroup.query().filter(RepoGroup.parent_group == self)

    @property

    def name(self):

    @property

    def full_path(self):

        return self.group_name

    @property

    def full_path_splitted(self):

    @property

    def repositories(self):

        return Repository.query(sorted=True).filter_by(group=self)

    @property

    def repositories_recursive_count(self):

        cnt = self.repositories.count()

        def children_count(group):

            cnt = 0

            for child in group.children:

        Returns all children groups for this group including children of children

        """

        return self._recursive_objects(include_repos=False)

    def get_new_name(self, group_name):

        """

        returns new full group name based on parent and new name

        :param group_name:

        """

        path_prefix = (self.parent_group.full_path_splitted if

                       self.parent_group else [])

    def get_api_data(self):

        """

        Common function for generating api data

        """

        group = self

        data = dict(

            group_id=group.group_id,

            group_name=group.group_name,

            group_description=group.group_description,

            parent_group=group.parent_group.group_name if group.parent_group else None,

import shutil

import traceback

from datetime import datetime

import kallithea.lib.utils2

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevel, HasUserGroupPermissionLevel

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.utils2 import LazyProperty, get_current_authuser, obfuscate_url_pw, remove_prefix

from kallithea.lib.vcs.backends import get_backend

                                UserGroupRepoToPerm, UserRepoGroupToPerm, UserRepoToPerm)

log = logging.getLogger(__name__)

class RepoModel(object):

    def _create_default_perms(self, repository, private):

        # create default permission

        default = 'repository.read'

        def_user = User.get_default_user()

        for p in def_user.user_perms:

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

                default = p.permission.permission_name

                break

        default_perm = 'repository.none' if private else default

        from kallithea.model.scm import ScmModel

        owner = User.guess_instance(owner)

        fork_of = Repository.guess_instance(fork_of)

        repo_group = RepoGroup.guess_instance(repo_group)

        try:

            repo_name = repo_name

            description = description

            # 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

            repo_name_full = repo_name

            if kallithea.lib.utils2.repo_name_slug(repo_name) != repo_name:

                raise Exception('invalid repo name %s' % repo_name)

            new_repo = Repository()

            new_repo.repo_state = state

            new_repo.enable_statistics = False

            new_repo.repo_name = repo_name_full

            new_repo.repo_type = repo_type

            new_repo.owner = owner

            new_repo.group = repo_group

            new_repo.description = description or repo_name

            new_repo.private = private

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

"""

import datetime

import logging

import os

import shutil

import traceback

import kallithea.lib.utils2

from kallithea.lib.utils2 import LazyProperty

from kallithea.model.db import Permission, RepoGroup, Repository, Session, Ui, User, UserGroup, UserGroupRepoGroupToPerm, UserRepoGroupToPerm

log = logging.getLogger(__name__)

class RepoGroupModel(object):

    @LazyProperty

    def repos_path(self):

        """

        Gets the repositories root path from database

        if os.path.isdir(new_path):

            raise Exception('Was trying to rename to already '

                            'existing dir %s' % new_path)

        shutil.move(old_path, new_path)

    def _delete_group(self, group, force_delete=False):

        """

        Deletes a group from a filesystem

        :param group: instance of group from database

        :param force_delete: use shutil rmtree to remove all objects

        """

        paths = os.sep.join(paths)

        rm_path = os.path.join(self.repos_path, paths)

        log.info("Removing group %s", rm_path)

        # delete only if that path really exists

        if os.path.isdir(rm_path):

            if force_delete:

                shutil.rmtree(rm_path)

            else:

                # archive that group

                _now = datetime.datetime.now()

                _ms = str(_now.microsecond).rjust(6, '0')

import ipaddr

import sqlalchemy

from formencode.validators import CIDR, Bool, Email, FancyValidator, Int, IPAddress, NotEmpty, Number, OneOf, Regex, Set, String, StringBoolean, UnicodeString

from sqlalchemy import func

from tg.i18n import ugettext as _

from kallithea.config.routing import ADMIN_PREFIX

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel

from kallithea.lib.compat import OrderedSet

from kallithea.lib.exceptions import InvalidCloneUriException, LdapImportError

from kallithea.lib.utils import is_valid_repo_uri

from kallithea.lib.utils2 import aslist, repo_name_slug, str2bool

from kallithea.model.db import RepoGroup, Repository, User, UserGroup

# silence warnings and pylint

UnicodeString, OneOf, Int, Number, Regex, Email, Bool, StringBoolean, Set, \

    NotEmpty, IPAddress, CIDR, String, FancyValidator

log = logging.getLogger(__name__)

def UniqueListFromString():

    class _UniqueListFromString(formencode.FancyValidator):

        }

        def _convert_to_python(self, value, state):

            repo_name = repo_name_slug(value.get('repo_name', ''))

            repo_group = value.get('repo_group')

            if repo_group:

                gr = RepoGroup.get(repo_group)

                group_path = gr.full_path

                group_name = gr.group_name

                # value needs to be aware of group name in order to check

                # db key This is an actual just the name to store in the

                # database

            else:

                group_name = group_path = ''

                repo_name_full = repo_name

            value['repo_name'] = repo_name

            value['repo_name_full'] = repo_name_full

            value['group_path'] = group_path

            value['group_name'] = group_name

            return value

        def _validate_python(self, value, state):

            repo_name = value.get('repo_name')

# -*- coding: utf-8 -*-

import os

import urllib.parse

import mock

import pytest

from kallithea.lib import vcs

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.user import UserModel

from kallithea.tests import base

from kallithea.tests.fixture import Fixture, error_function

fixture = Fixture()

def _get_permission_for_user(user, repo):

    def test_create_in_group(self):

        self.log_user()

        ## create GROUP

        group_name = 'sometest_%s' % self.REPO_TYPE

        gr = RepoGroupModel().create(group_name=group_name,

                                     group_description='test',

                                     owner=base.TEST_USER_ADMIN_LOGIN)

        Session().commit()

        repo_name = 'ingroup'

        description = 'description for newly created repo'

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                repo_group=gr.group_id,

                                                _session_csrf_secret_token=self.session_csrf_secret_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(base.url('repo_check_home', repo_name=repo_name_full))

        assert response.json == {'result': True}

        self.checkSessionFlash(response,

        gr = RepoGroupModel().create(group_name=group_name,

                                     group_description='test',

                                     owner=base.TEST_USER_ADMIN_LOGIN)

        Session().commit()

        group_name_allowed = 'reg_sometest_allowed_%s' % self.REPO_TYPE

        gr_allowed = RepoGroupModel().create(group_name=group_name_allowed,

                                     group_description='test',

                                     owner=base.TEST_USER_REGULAR_LOGIN)

        Session().commit()

        repo_name = 'ingroup'

        description = 'description for newly created repo'

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                repo_group=gr.group_id,

                                                _session_csrf_secret_token=session_csrf_secret_token))

        response.mustcontain('Invalid value')

        # user is allowed to create in this group

        repo_name = 'ingroup'

        description = 'description for newly created repo'

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                repo_group=gr_allowed.group_id,

                                                _session_csrf_secret_token=session_csrf_secret_token))

        ## run the check page that triggers the flash message

        response = self.app.get(base.url('repo_check_home', repo_name=repo_name_full))

        assert response.json == {'result': True}

        ## create GROUP

        group_name = 'sometest_%s' % self.REPO_TYPE

        gr = RepoGroupModel().create(group_name=group_name,

                                     group_description='test',

                                     owner=base.TEST_USER_ADMIN_LOGIN)

        perm = Permission.get_by_key('repository.write')

        RepoGroupModel().grant_user_permission(gr, base.TEST_USER_REGULAR_LOGIN, perm)

        ## add repo permissions

        Session().commit()

        repo_name = 'ingroup_inherited_%s' % self.REPO_TYPE

        description = 'description for newly created repo'

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                repo_group=gr.group_id,

                                                repo_copy_permissions=True,

                                                _session_csrf_secret_token=self.session_csrf_secret_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(base.url('repo_check_home', repo_name=repo_name_full))

from kallithea.lib.auth import AuthUser

from kallithea.model.meta import Session

from kallithea.model.permission import PermissionModel

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.user import UserModel

from kallithea.model.user_group import UserGroupModel

from kallithea.tests import base

from kallithea.tests.fixture import Fixture

fixture = Fixture()

                                               perm='group.none')

        RepoGroupModel().grant_user_permission(repo_group=self.g2,

                                               user=self.anon,

                                               perm='group.none')

        u1_auth = AuthUser(user_id=self.u1.user_id)

        assert u1_auth.permissions['repositories_groups'] == {'group1': 'group.none', 'group2': 'group.none'}

        a1_auth = AuthUser(user_id=self.anon.user_id)

        assert a1_auth.permissions['repositories_groups'] == {'group1': 'group.none', 'group2': 'group.none'}

        # add repo to group

        self.test_repo = fixture.create_repo(name=name,

                                             repo_type='hg',

                                             repo_group=self.g1,

                                             cur_user=self.u1,)

        u1_auth = AuthUser(user_id=self.u1.user_id)

        assert u1_auth.permissions['repositories_groups'] == {'group1': 'group.none', 'group2': 'group.none'}

        a1_auth = AuthUser(user_id=self.anon.user_id)

        assert a1_auth.permissions['repositories_groups'] == {'group1': 'group.none', 'group2': 'group.none'}

        # grant permission for u2 !

import os

import pytest

from sqlalchemy.exc import IntegrityError

from kallithea.model.db import RepoGroup

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.tests import base

from kallithea.tests.fixture import Fixture

fixture = Fixture()

def _update_repo_group(id_, group_name, desc='desc', parent_id=None):

        r = fixture.create_repo('john')

        assert r.repo_name == 'john'

        # put repo into group

        r = _update_repo('john', repo_group=g1.group_id)

        Session().commit()

        assert r.repo_name == 'g1/john'

        _update_repo_group(g1.group_id, 'g1', parent_id=g2.group_id)

        assert self.__check_path('g2', 'g1')

        # test repo

    def test_move_to_root(self):

        g1 = fixture.create_repo_group('t11')

        g2 = fixture.create_repo_group('t22', parent_group_id=g1.group_id)

        assert g2.full_path == 't11/t22'

        assert self.__check_path('t11', 't22')

        g2 = _update_repo_group(g2.group_id, 'g22', parent_id=None)

        Session().commit()

        assert g2.group_name == 'g22'