from kallithea.lib import webutils

from kallithea.lib.utils import extract_mentioned_users

from kallithea.lib.utils2 import shorter

log = logging.getLogger(__name__)

        # changeset

        if revision:

            cs = repo.scm_instance.get_changeset(revision)

            desc = cs.short_id

            }

        # pull request

        elif pull_request:

            desc = comment.pull_request.title

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

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

                                closing_pr=closing_pr)

            email_kwargs['is_mention'] = False

            # create notification objects, and emails

                created_by=author, subject=subj, body=body,

                recipients=recipients, type_=notification_type,

                email_kwargs=email_kwargs,

                email_kwargs['is_mention'] = True

                subj = _('[Mention]') + ' ' + subj

                # FIXME: this subject is wrong and unused!

                    created_by=author, subject=subj, body=body,

                    recipients=mention_recipients,

                    type_=notification_type,

from kallithea.lib import ext_json

from kallithea.lib.utils2 import AttributeDict, ascii_bytes, safe_int, time_to_datetime

log = logging.getLogger(__name__)

        :param gist: gist object

        """

        rm_path = os.path.join(root_path, db.Gist.GIST_STORE_LOC, gist.gist_access_id)

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

        shutil.rmtree(rm_path)

                        gist_expires):

        """

        store metadata inside the gist, this can be later used for imports

            'gist_expires': gist_expires,

            'gist_updated': time.time(),

        }

            f.write(ascii_bytes(ext_json.dumps(metadata)))

    def get_gist(self, gist):

        :param gist_access_id:

        """

        return cs, [n for n in cs.get_node('/')]

    def create(self, description, owner, ip_addr, gist_mapping,

            gist.gist_access_id = str(gist.gist_id)

        log.debug('Creating new %s GIST repo %s', gist_type, gist.gist_access_id)

            repo_name=gist.gist_access_id, repo_type='hg', repo_group=db.Gist.GIST_STORE_LOC)

        processed_mapping = {}

        # fake Kallithea Repository object

        fake_repo = AttributeDict(dict(

            repo_name=os.path.join(db.Gist.GIST_STORE_LOC, gist.gist_access_id),

        ))

            user=owner.user_id,

            ip_addr=ip_addr,

            repo=fake_repo,

            trigger_push_hook=False

        )

                             owner.user_id, gist.gist_type, gist.gist_expires)

        return gist

        self._store_metadata(gist_repo, gist.gist_id, gist.gist_access_id,

                             owner.user_id, gist.gist_type, gist.gist_expires)

            user=owner.user_id,

            ip_addr=ip_addr,

            repo=fake_repo,

from kallithea.lib.hooks import log_create_pullrequest

from kallithea.lib.utils import extract_mentioned_users

from kallithea.lib.utils2 import ascii_bytes, short_ref_name, shorter

log = logging.getLogger(__name__)

            'is_mention': False,

            }

        if reviewers:

                                       recipients=reviewers,

                                       email_kwargs=email_kwargs)

        if mention_recipients:

            email_kwargs['is_mention'] = True

            subject = _('[Mention]') + ' ' + subject

            # FIXME: this subject is wrong and unused!

                                       recipients=mention_recipients,

                                       email_kwargs=email_kwargs)

        return reviewers, redundant_reviewers

            self.org_repo.scm_instance._repo[b"refs/pull/%d/head" % pr.pull_request_id] = ascii_bytes(self.org_rev)

        # reset state to under-review

            text='',

            repo=self.org_repo,

            author=created_by,

            send_email=False,

            status_change=db.ChangesetStatus.STATUS_UNDER_REVIEW,

        )

            self.org_repo,

            db.ChangesetStatus.STATUS_UNDER_REVIEW,

            created_by,

            pull_request=pr,

        )

        pull_request = self.create_action.execute()

        # Close old iteration

            text=_('Closed, next iteration: %s .') % pull_request.url(canonical=True),

            repo=self.old_pull_request.other_repo_id,

            author=request.authuser.user_id,

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

log = logging.getLogger(__name__)

        from tg import tmpl_context as c

        import kallithea.lib.helpers as h

        def repo_lnk(name, rtype, rstate, private, fork_of):

            return _render('repo_name', name, rtype, rstate, private, fork_of,

                                 repo.repo_state, repo.private, repo.fork),

                "following": following(

                    repo.repo_id,

                ),

                "last_change_iso": repo.last_db_change.isoformat(),

                "last_change": last_change(repo.last_db_change),

        executed by create() repo, with exception of importing existing repos.

        """

        owner = db.User.guess_instance(owner)

        fork_of = db.Repository.guess_instance(fork_of)

        repo_group = db.RepoGroup.guess_instance(repo_group)

                self._create_default_perms(new_repo, private)

            # now automatically start following this repository as owner

            # we need to flush here, in order to check if database won't

            # throw any exceptions, create filesystem dirs at the very end

            meta.Session().flush()

        Note: clone_uri is low level and not validated - it might be a file system path used for validated cloning

        """

        from kallithea.lib.utils import is_valid_repo, is_valid_repo_group

        if '/' in repo_name:

            raise ValueError('repo_name must not contain groups got `%s`' % repo_name)

        elif repo_type == 'git':

            repo = backend(repo_path, create=True, src_url=clone_uri, bare=True)

            # add kallithea hook into this repo

        else:

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

import kallithea.lib.utils2

from kallithea.lib.utils2 import LazyProperty

log = logging.getLogger(__name__)

                            perms_updates=None, recursive=None,

                            check_perms=True):

        from kallithea.lib.auth import HasUserGroupPermissionLevel

        if not perms_new:

            perms_new = []

                # we set group permission but we have to switch to repo

                # permission

                perm = perm.replace('group.', 'repository.')

                    repo=obj, user=user, perm=perm

                )

                # we set group permission but we have to switch to repo

                # permission

                perm = perm.replace('group.', 'repository.')

                    repo=obj, group_name=users_group, perm=perm

                )

            raise

    def add_permission(self, repo_group, obj, obj_type, perm, recursive):

        repo_group = db.RepoGroup.guess_instance(repo_group)

        perm = db.Permission.guess_instance(perm)

                # for repos we need to hotfix the name of permission

                _perm = perm.permission_name.replace('group.', 'repository.')

                if obj_type == 'user':

                elif obj_type == 'user_group':

                else:

                    raise Exception('undefined object type %s' % obj_type)

            else:

        :param obj_type: user or user group type

        :param recursive: recurse to all children of group

        """

        repo_group = db.RepoGroup.guess_instance(repo_group)

        for el in repo_group.recursive_groups_and_repos():

                    raise Exception('undefined object type %s' % obj_type)

            elif isinstance(el, db.Repository):

                if obj_type == 'user':

                elif obj_type == 'user_group':

                else:

                    raise Exception('undefined object type %s' % obj_type)

            else:

            raise

    def create_registration(self, form_data):

        form_data['admin'] = False

        form_data['extern_type'] = db.User.DEFAULT_AUTH_TYPE

            'new_username': new_user.username,

            'new_email': new_user.email,

            'new_full_name': new_user.full_name}

                                   body=body, recipients=None,

                                   email_kwargs=email_kwargs)

    def update(self, user_id, form_data, skip_attrs=None):

        email.

        """

        from kallithea.lib.celerylib import tasks

        user_email = data['email']

        user = db.User.get_by_email(user_email)

            else:

                log.debug('password reset user %s found but was managed', user)

                token = link = None

                reg_type, 'txt',

                user=user.short_contact,

                reset_token=token,

                reset_url=link)

                reg_type, 'html',

                user=user.short_contact,

                reset_token=token,