from tg.i18n import ugettext as _

from kallithea.lib import webutils

from kallithea.lib.utils import extract_mentioned_users

from kallithea.lib.utils2 import shorter

log = logging.getLogger(__name__)

def _list_changeset_commenters(revision):

        line = ''

        if line_no:

            line = _('on line %s') % line_no

        # changeset

        if revision:

            cs = repo.scm_instance.get_changeset(revision)

            desc = cs.short_id

            threading = ['%s-rev-%s@%s' % (repo.repo_name, revision, webutils.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-rev-%s-line-%s@%s' % (repo.repo_name, revision, line_no,

                'branch': cs.branch,

                'comment_username': author.username,

                'threading': threading,

            }

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

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

                                          pull_request.pull_request_id,

                                          webutils.canonical_hostname())]

                                revision=revision,

                                pull_request=pull_request,

                                status_change=status_change,

                                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,

            )

            mention_recipients = extract_mentioned_users(body).difference(recipients)

            if mention_recipients:

                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,

                    email_kwargs=email_kwargs

                )

import shutil

import time

import traceback

from kallithea.lib import ext_json

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

log = logging.getLogger(__name__)

def make_gist_access_id():

    def __delete_gist(self, gist):

        """

        removes gist from filesystem

        :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

        or gist identification

        """

        metadata = {

            'gist_access_id': gist_access_id,

            'gist_owner_id': user_id,

            'gist_type': gist_type,

            'gist_expires': gist_expires,

            'gist_updated': time.time(),

        }

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

    def get_gist(self, gist):

        return db.Gist.guess_instance(gist)

    def get_gist_files(self, gist_access_id, revision=None):

        """

        Get files for given gist

        :param gist_access_id:

        """

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

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

               gist_type=db.Gist.GIST_PUBLIC, lifetime=-1):

        """

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

        if gist_type == db.Gist.GIST_PUBLIC:

            # use DB ID for easy to use GIST ID

            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 = {}

        for filename in gist_mapping:

            if filename != os.path.basename(filename):

                raise Exception('Filename cannot be inside a directory')

        message += 's: ' if len(processed_mapping) > 1 else ': '

        message += ', '.join([x for x in 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,

            message=message,

            nodes=processed_mapping,

            trigger_push_hook=False

        )

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

        return gist

    def delete(self, gist, fs_remove=True):

        gist = db.Gist.guess_instance(gist)

        try:

            scm_instance_no_cache=lambda: gist_repo,

        ))

        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,

            message=message,

            nodes=gist_mapping_op,

            trigger_push_hook=False

from tg.i18n import ugettext as _

from kallithea.lib import auth, webutils

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

def _assert_valid_reviewers(seq):

            'pr_owner_username': pr.owner.username,

            'pr_username': user.username,

            'threading': threading,

            '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

    def mention_from_description(self, user, pr, old_description=''):

        mention_recipients = (extract_mentioned_users(pr.description) -

        if self.org_repo.scm_instance.alias == 'git':

            # create a ref under refs/pull/ so that commits don't get garbage-collected

            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,

            pull_request=pr,

            send_email=False,

            status_change=db.ChangesetStatus.STATUS_UNDER_REVIEW,

        )

            self.org_repo,

            db.ChangesetStatus.STATUS_UNDER_REVIEW,

            created_by,

            pull_request=pr,

        )

        mention_recipients = extract_mentioned_users(self.description)

        PullRequestModel().add_reviewers(created_by, pr, self.reviewers, mention_recipients)

            raise CreatePullRequestAction.Unauthorized(_('You are not authorized to create the pull request'))

    def execute(self):

        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,

            pull_request=self.old_pull_request.pull_request_id,

            closing_pr=True)

        PullRequestModel().close_pull_request(self.old_pull_request.pull_request_id)

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

log = logging.getLogger(__name__)

class RepoModel(object):

        """

        _render = self._render_datatable

        from tg import request

        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,

                           short_name=short_name)

        def following(repo_id, is_following):

                "raw_name": repo.repo_name,

                "just_name": repo.just_name,

                "name": repo_lnk(repo.repo_name, repo.repo_type,

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

                "last_changeset": last_rev(repo.repo_name, cs_cache),

                "last_rev_raw": cs_cache.get('revision'),

                "desc": desc(repo.description),

                     copy_group_permissions=False, state=db.Repository.STATE_PENDING):

        """

        Create repository inside database with PENDING state. This should only be

        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)

        try:

            repo_name = repo_name

            description = description

                    db.UserGroupRepoToPerm.create(perm.users_group, new_repo, perm_obj)

            else:

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

            return new_repo

        except Exception:

            log.error(traceback.format_exc())

        Makes repository on filesystem. Operation is group aware, meaning that it will create

        a repository within a group, and alter the paths accordingly to the group location.

        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)

        if isinstance(repo_group, db.RepoGroup):

            new_parent_path = os.sep.join(repo_group.full_path_splitted)

                baseui.setconfig('hooks', k, None)

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

        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)

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

                  repo_name, repo_type)

        return repo

import os

import shutil

import traceback

import kallithea.lib.utils2

from kallithea.lib.utils2 import LazyProperty

log = logging.getLogger(__name__)

class RepoGroupModel(object):

            raise

    def _update_permissions(self, repo_group, perms_new=None,

                            perms_updates=None, recursive=None,

                            check_perms=True):

        from kallithea.lib.auth import HasUserGroupPermissionLevel

        if not perms_new:

            perms_new = []

        if not perms_updates:

            perms_updates = []

                if obj.private and user.is_default_user:

                    return

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

                # permission

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

                    repo=obj, user=user, perm=perm

                )

        def _set_perm_group(obj, users_group, perm):

            if isinstance(obj, db.RepoGroup):

                self.grant_user_group_permission(repo_group=obj,

                                                  group_name=users_group,

                                                  perm=perm)

            elif isinstance(obj, db.Repository):

                # 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

                )

        # start updates

        updates = []

        log.debug('Now updating permissions for %s in recursive mode:%s',

            self._delete_group(repo_group, force_delete)

        except Exception:

            log.error('Error removing repo_group %s', repo_group)

            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 el in repo_group.recursive_groups_and_repos():

            # iterated obj is an instance of a repos group or repository in

            # that group, recursive option can be: none, repos, groups, all

                else:

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

            elif isinstance(el, db.Repository):

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

                raise Exception('el should be instance of Repository or '

                                'RepositoryGroup got %s instead' % type(el))

        :param repo_group:

        :param obj: user or user group id

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

            # iterated obj is an instance of a repos group or repository in

            # that group, recursive option can be: none, repos, groups, all

            if recursive == 'all':

                elif obj_type == 'user_group':

                    RepoGroupModel().revoke_user_group_permission(el, group_name=obj)

                else:

                    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 Exception('el should be instance of Repository or '

                                'RepositoryGroup got %s instead' % type(el))

            return new_user

        except (DatabaseError,):

            log.error(traceback.format_exc())

            raise

    def create_registration(self, form_data):

        form_data['admin'] = False

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

        form_data['extern_name'] = ''

        new_user = self.create(form_data)

        edit_url = webutils.canonical_url('edit_user', id=new_user.user_id)

        email_kwargs = {

            'registered_user_url': edit_url,

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

        from kallithea.lib.auth import get_crypt_password

        skip_attrs = skip_attrs or []

        user = self.get(user_id)

        reset confirmation page with all information (including the token)

        pre-filled. Also returns URL of that page, only without the token,

        allowing users to copy-paste or manually enter the token from the

        email.

        """

        from kallithea.lib.celerylib import tasks

        user_email = data['email']

        user = db.User.get_by_email(user_email)

        timestamp = int(time.time())

        if user is not None:

            if self.can_change_password(user):

                             email=user_email,

                             timestamp=timestamp,

                             token=token)

            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,

                reset_url=link)

            log.debug('sending email')

            tasks.send_email([user_email], _("Password reset link"), body, html_body)