from kallithea.lib.vcs.utils import safe_str

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.model.db import PullRequest, ChangesetStatus, ChangesetComment, \

from kallithea.model.pull_request import PullRequestModel

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

        # heads up: org and other might seem backward here ...

        org_repo_name = _form['org_repo']

        org_ref = _form['org_ref'] # will have merge_rev as rev but symbolic name

        (org_ref_type,

         org_ref_name,

         org_rev) = org_ref.split(':')

        other_repo_name = _form['other_repo']

        other_ref = _form['other_ref'] # will have symbolic name and head revision

        (other_ref_type,

         other_ref_name,

         other_rev) = other_ref.split(':')

    copy_fork_permissions = form_data.get('copy_permissions')

    try:

        RepoModel(DBS)._create_repo(

            repo_name=repo_name_full,

        else:

            self.sa = meta.Session()

    def _get_perm(self, permission):

        """

        Helper method to get permission by ID, or permission name

from sqlalchemy.orm import joinedload

from kallithea.model.base import BaseModel

from kallithea.lib.exceptions import StatusChangeOnClosedPullRequestError

log = logging.getLogger(__name__)

    def _get_status_query(self, repo, revision, pull_request,

                          with_revisions=False):

        q = ChangesetStatus.query() \

            .filter(ChangesetStatus.repo == repo)

            if last status was for pull request and it's closed. We shouldn't

            mess around this manually

        """

        q = ChangesetStatus.query()

        if revision is not None:

            new_status = ChangesetStatus()

            new_status.version = 0 # default

            new_status.author = User.guess_instance(user)

            new_status.status = status

            new_status.comment = comment

            new_status.revision = rev

from kallithea.lib import helpers as h

from kallithea.model.base import BaseModel

from kallithea.model.db import ChangesetComment, User, \

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

            log.warning('Missing text for comment, skipping...')

            return None

        author = User.guess_instance(author)

        comment = ChangesetComment()

        comment.repo = repo

        return repo.scalar()

    def get_repo(self, repository):

    def get_by_repo_name(self, repo_name, cache=False):

        repo = self.sa.query(Repository) \

    def update(self, repo, **kwargs):

        try:

            org_repo_name = cur_repo.repo_name

            if 'owner' in kwargs:

                cur_repo.owner = User.get_by_username(kwargs['owner'])

        from kallithea.model.scm import ScmModel

        owner = User.guess_instance(owner)

        repo_group = self._get_repo_group(repo_group)

        try:

            repo_name = safe_unicode(repo_name)

        """

        if not cur_user:

            cur_user = getattr(get_current_authuser(), 'username', None)

        if repo is not None:

            if forks == 'detach':

                for r in repo.forks:

        :param perm: Instance of Permission, or permission_name

        """

        user = User.guess_instance(user)

        permission = self._get_perm(perm)

        # check if we have that permission already

        """

        user = User.guess_instance(user)

        obj = self.sa.query(UserRepoToPerm) \

            .filter(UserRepoToPerm.repository == repo) \

            or user group name

        :param perm: Instance of Permission, or permission_name

        """

        group_name = self._get_user_group(group_name)

        permission = self._get_perm(perm)

        :param group_name: Instance of UserGroup, users_group_id,

            or user group name

        """

        group_name = self._get_user_group(group_name)

        obj = self.sa.query(UserGroupRepoToPerm) \

        :param repo_name:

        """

        try:

            obj = self.sa.query(Statistics) \

                .filter(Statistics.repository == repo).scalar()

import logging

from kallithea.model.base import BaseModel

from kallithea.model.db import User, UserRepoToPerm, UserGroupRepoToPerm, \

log = logging.getLogger(__name__)

class RepositoryPermissionModel(BaseModel):

    def get_user_permission(self, repository, user):

        user = User.guess_instance(user)

        return UserRepoToPerm.query() \

        return f is not None

    def get_followers(self, repo):

        return self.sa.query(UserFollowing) \

                .filter(UserFollowing.follows_repository == repo).count()

    def get_forks(self, repo):

        return self.sa.query(Repository) \

                .filter(Repository.fork == repo).count()

    def get_pull_requests(self, repo):

        return self.sa.query(PullRequest) \

                .filter(PullRequest.other_repo == repo) \

                .filter(PullRequest.status != PullRequest.STATUS_CLOSED).count()