controller='admin/repos', action="edit_advanced_fork",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect("edit_repo_caches", "/{repo_name:.*?}/settings/caches",

                 controller='admin/repos', action="edit_caches",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_caches", "/{repo_name:.*?}/settings/caches",

                 controller='admin/repos', action="edit_caches",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect("edit_repo_statistics", "/{repo_name:.*?}/settings/statistics",

                 controller='admin/repos', action="edit_statistics",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_statistics", "/{repo_name:.*?}/settings/statistics",

                 controller='admin/repos', action="edit_statistics",

                 conditions=dict(method=["PUT"], function=check_repo))

    #still working url for backward compat.

    rmap.connect('raw_changeset_home_depraced',

                 '/{repo_name:.*?}/raw-changeset/{revision}',

                 controller='changeset', action='changeset_raw',

                 revision='tip', conditions=dict(function=check_repo))

    ## new URLs

    rmap.connect('changeset_raw_home',

                 '/{repo_name:.*?}/changeset-diff/{revision}',

                 controller='changeset', action='changeset_raw',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_patch_home',

                 '/{repo_name:.*?}/changeset-patch/{revision}',

                 controller='changeset', action='changeset_patch',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_download_home',

                 '/{repo_name:.*?}/changeset-download/{revision}',

                 controller='changeset', action='changeset_download',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_comment',

                 '/{repo_name:.*?}/changeset-comment/{revision}',

                controller='changeset', revision='tip', action='comment',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_comment_preview',

                 '/{repo_name:.*?}/changeset-comment-preview',

                controller='changeset', action='preview_comment',

                conditions=dict(function=check_repo, method=["POST"]))

    rmap.connect('changeset_comment_delete',

                 '/{repo_name:.*?}/changeset-comment-delete/{comment_id}',

                controller='changeset', action='delete_comment',

                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',

                 controller='changeset', action='changeset_info')

    rmap.connect('compare_home',

                 '/{repo_name:.*?}/compare',

                 controller='compare', action='index',

                 conditions=dict(function=check_repo))

    rmap.connect('compare_url',

                 '/{repo_name:.*?}/compare/{org_ref_type}@{org_ref_name:.*?}...{other_ref_type}@{other_ref_name:.*?}',

                 controller='compare', action='compare',

                 conditions=dict(function=check_repo),

                 requirements=dict(

                            org_ref_type='(branch|book|tag|rev|__other_ref_type__)',

                            other_ref_type='(branch|book|tag|rev|__org_ref_type__)')

                 )

    rmap.connect('pullrequest_home',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='index', conditions=dict(function=check_repo,

                                                 method=["GET"]))

    rmap.connect('pullrequest',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='create', conditions=dict(function=check_repo,

                                                  method=["POST"]))

    rmap.connect('pullrequest_copy_update',

                 '/{repo_name:.*?}/pull-request-update/{pull_request_id}', controller='pullrequests',

                 action='copy_update', conditions=dict(function=check_repo,

                                                       method=["POST"]))

    rmap.connect('pullrequest_show',

                 controller='pullrequests',

                 action='show', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('pullrequest_post',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='post', conditions=dict(function=check_repo,

                                                method=["POST"]))

    rmap.connect('pullrequest_update',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='update', conditions=dict(function=check_repo,

                                                method=["PUT"]))

    rmap.connect('pullrequest_delete',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='delete', conditions=dict(function=check_repo,

                                                method=["DELETE"]))

    rmap.connect('pullrequest_show_all',

                 '/{repo_name:.*?}/pull-request',

                 controller='pullrequests',

                 action='show_all', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('my_pullrequests',

                 '/my_pullrequests',

                 controller='pullrequests',

                 action='show_my', conditions=dict(method=["GET"]))

    rmap.connect('my_pullrequests_data',

                 '/my_pullrequests_data',

                 controller='pullrequests',

                 action='show_my_data', conditions=dict(method=["GET"]))

    rmap.connect('pullrequest_comment',

                 '/{repo_name:.*?}/pull-request-comment/{pull_request_id}',

                 controller='pullrequests',

                 action='comment', conditions=dict(function=check_repo,

                                                method=["POST"]))

    rmap.connect('pullrequest_comment_delete',

                 '/{repo_name:.*?}/pull-request-comment/{comment_id}/delete',

                controller='pullrequests', action='delete_comment',

                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('summary_home_summary', '/{repo_name:.*?}/summary',

                controller='summary', conditions=dict(function=check_repo))

    rmap.connect('branches_home', '/{repo_name:.*?}/branches',

                controller='branches', conditions=dict(function=check_repo))

    rmap.connect('tags_home', '/{repo_name:.*?}/tags',

                controller='tags', conditions=dict(function=check_repo))

    rmap.connect('bookmarks_home', '/{repo_name:.*?}/bookmarks',

                controller='bookmarks', conditions=dict(function=check_repo))

    rmap.connect('changelog_home', '/{repo_name:.*?}/changelog',

                controller='changelog', conditions=dict(function=check_repo))

    rmap.connect('changelog_summary_home', '/{repo_name:.*?}/changelog_summary',

                controller='changelog', action='changelog_summary',

                conditions=dict(function=check_repo))

    rmap.connect('changelog_file_home', '/{repo_name:.*?}/changelog/{revision}/{f_path:.*}',

                controller='changelog', f_path=None,

                conditions=dict(function=check_repo))

    rmap.connect('changelog_details', '/{repo_name:.*?}/changelog_details/{cs}',

                controller='changelog', action='changelog_details',

                conditions=dict(function=check_repo))

    rmap.connect('files_home', '/{repo_name:.*?}/files/{revision}/{f_path:.*}',

                controller='files', revision='tip', f_path='',

                conditions=dict(function=check_repo))

    rmap.connect('files_home_nopath', '/{repo_name:.*?}/files/{revision}',

                controller='files', revision='tip', f_path='',

                conditions=dict(function=check_repo))

    rmap.connect('files_history_home',

                 '/{repo_name:.*?}/history/{revision}/{f_path:.*}',

                 controller='files', action='history', revision='tip', f_path='',

                 conditions=dict(function=check_repo))

    rmap.connect('files_authors_home',

                 '/{repo_name:.*?}/authors/{revision}/{f_path:.*}',

                 controller='files', action='authors', revision='tip', f_path='',

                 conditions=dict(function=check_repo))

    rmap.connect('files_diff_home', '/{repo_name:.*?}/diff/{f_path:.*}',

                controller='files', action='diff', revision='tip', f_path='',

                conditions=dict(function=check_repo))

    rmap.connect('files_diff_2way_home', '/{repo_name:.*?}/diff-2way/{f_path:.*}',

                controller='files', action='diff_2way', revision='tip', f_path='',

        def add_other_repo(repo, branch_rev=None):

            if repo.repo_name in other_repos_info: # shouldn't happen

                return

            c.other_repos.append((repo.repo_name, repo.repo_name))

            other_refs, selected_other_ref = self._get_repo_refs(repo.scm_instance, branch_rev=branch_rev)

            other_repos_info[repo.repo_name] = {

                'user': dict(user_id=repo.user.user_id,

                             username=repo.user.username,

                             firstname=repo.user.firstname,

                             lastname=repo.user.lastname,

                             gravatar_link=h.gravatar_url(repo.user.email, 14)),

                'description': repo.description.split('\n', 1)[0],

                'revs': h.select('other_ref', selected_other_ref, other_refs, class_='refs')

            }

        # add org repo to other so we can open pull request against peer branches on itself

        add_other_repo(org_repo, branch_rev=org_rev)

        c.default_other_repo = org_repo.repo_name

        # gather forks and add to this list ... even though it is rare to

        # request forks to pull from their parent

        for fork in org_repo.forks:

            add_other_repo(fork)

        # add parents of this fork also, but only if it's not empty

        if org_repo.parent and org_repo.parent.scm_instance.revisions:

            add_other_repo(org_repo.parent)

            c.default_other_repo = org_repo.parent.repo_name

        c.default_other_repo_info = other_repos_info[c.default_other_repo]

        c.other_repos_info = json.dumps(other_repos_info)

        return render('/pullrequests/pullrequest.html')

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def create(self, repo_name):

        repo = RepoModel()._get_repo(repo_name)

        try:

            _form = PullRequestForm(repo.repo_id)().to_python(request.POST)

        except formencode.Invalid, errors:

            log.error(traceback.format_exc())

            log.error(str(errors))

            msg = _('Error creating pull request: %s') % errors.msg

            h.flash(msg, 'error')

            raise HTTPBadRequest

        # 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_repo = RepoModel()._get_repo(org_repo_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_repo = RepoModel()._get_repo(other_repo_name)

        (other_ref_type,

         other_ref_name,

         other_rev) = other_ref.split(':')

        cs_ranges, _cs_ranges_not, ancestor_rev = \

            CompareController._get_changesets(org_repo.scm_instance.alias,

                                              other_repo.scm_instance, other_rev, # org and other "swapped"

                                              org_repo.scm_instance, org_rev,

                                              )

        revisions = [cs.raw_id for cs in cs_ranges]

        # hack: ancestor_rev is not an other_rev but we want to show the

        # requested destination and have the exact ancestor

        other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, ancestor_rev)

        reviewers = _form['review_members']

        title = _form['pullrequest_title']

        if not title:

            title = '%s#%s to %s#%s' % (org_repo_name, h.short_ref(org_ref_type, org_ref_name),

                                        other_repo_name, h.short_ref(other_ref_type, other_ref_name))

        description = _form['pullrequest_desc'].strip() or _('No description')

        try:

            pull_request = PullRequestModel().create(

                self.authuser.user_id, org_repo_name, org_ref, other_repo_name,

                other_ref, revisions, reviewers, title, description

            )

            Session().commit()

            h.flash(_('Successfully opened new pull request'),

                    category='success')

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            return redirect(url('pullrequest_home', repo_name=repo_name))

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def copy_update(self, repo_name, pull_request_id):

        old_pull_request = PullRequest.get_or_404(pull_request_id)

        assert old_pull_request.other_repo.repo_name == repo_name

        if old_pull_request.is_closed():

            raise HTTPForbidden()

        org_repo = RepoModel()._get_repo(old_pull_request.org_repo.repo_name)

        org_ref_type, org_ref_name, org_rev = old_pull_request.org_ref.split(':')

        updaterev = request.POST.get('updaterev')

        if updaterev:

            new_org_rev = self._get_ref_rev(org_repo, 'rev', updaterev)

        else:

            # assert org_ref_type == 'branch', org_ref_type # TODO: what if not?

            new_org_rev = self._get_ref_rev(org_repo, org_ref_type, org_ref_name)

        other_repo = RepoModel()._get_repo(old_pull_request.other_repo.repo_name)

        other_ref_type, other_ref_name, other_rev = old_pull_request.other_ref.split(':') # other_rev is ancestor

        #assert other_ref_type == 'branch', other_ref_type # TODO: what if not?

        new_other_rev = self._get_ref_rev(other_repo, other_ref_type, other_ref_name)

        cs_ranges, _cs_ranges_not, ancestor_rev = CompareController._get_changesets(org_repo.scm_instance.alias,

            other_repo.scm_instance, new_other_rev, # org and other "swapped"

            org_repo.scm_instance, new_org_rev)

        old_revisions = set(old_pull_request.revisions)

        revisions = [cs.raw_id for cs in cs_ranges]

        new_revisions = [r for r in revisions if r not in old_revisions]

        lost = old_revisions.difference(revisions)

        infos = ['','', 'This is an update of %s "%s".' %

                 (h.canonical_url('pullrequest_show', repo_name=old_pull_request.other_repo.repo_name,

                      pull_request_id=pull_request_id),

                  old_pull_request.title)]

        if lost:

            infos.append(_('Missing changesets since the previous version:'))

            for r in old_pull_request.revisions:

                if r in lost:

                    desc = org_repo.get_changeset(r).message.split('\n')[0]

                    infos.append('  %s "%s"' % (h.short_id(r), desc))

        if new_revisions:

            infos.append(_('New changesets on %s %s since the previous version:') % (org_ref_type, org_ref_name))

            for r in reversed(revisions):

                if r in new_revisions:

                    desc = org_repo.get_changeset(r).message.split('\n')[0]

                    infos.append('  %s "%s"' % (h.short_id(r), desc))

            if ancestor_rev == other_rev:

                infos.append(_("Ancestor didn't change - show diff since previous version: %s .") %

                             h.canonical_url('compare_url',

                                 repo_name=org_repo.repo_name, # other_repo is always same as repo_name

                                 org_ref_type='rev', org_ref_name=h.short_id(org_rev), # use old org_rev as base

                                 other_ref_type='rev', other_ref_name=h.short_id(new_org_rev),

                                 )) # note: linear diff, merge or not doesn't matter

            else:

                infos.append(_('This pull request uses another merge ancestor than the previous version and they are not directly comparable.'))

        else:

           infos.append(_('No changes found on %s %s since previous version.') % (org_ref_type, org_ref_name))

           # TODO: fail?

        # hack: ancestor_rev is not an other_ref but we want to show the

        # requested destination and have the exact ancestor

        new_other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, ancestor_rev)

        new_org_ref = '%s:%s:%s' % (org_ref_type, org_ref_name, new_org_rev)

        reviewers = [r.user_id for r in old_pull_request.reviewers]

        try:

            old_title, old_v = re.match(r'(.*)\(v(\d+)\)\s*$', old_pull_request.title).groups()

            v = int(old_v) + 1

        except (AttributeError, ValueError):

            old_title = old_pull_request.title

            v = 2

        title = '%s (v%s)' % (old_title.strip(), v)

        description = (old_pull_request.description.rstrip() +

                       '\n'.join(infos))

        try:

            pull_request = PullRequestModel().create(

                self.authuser.user_id,

                old_pull_request.org_repo.repo_name, new_org_ref,

                old_pull_request.other_repo.repo_name, new_other_ref,

                revisions, reviewers, title, description

            )

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            return redirect(url('pullrequest_show', repo_name=repo_name,

                                pull_request_id=pull_request_id))

        ChangesetCommentsModel().create(

            text=_('Closed, replaced by %s .') % h.canonical_url('pullrequest_show',

                                                   repo_name=old_pull_request.other_repo.repo_name,

                                                   pull_request_id=pull_request.pull_request_id),

            repo=old_pull_request.other_repo.repo_id,

            user=c.authuser.user_id,

            pull_request=pull_request_id,

            closing_pr=True)

        PullRequestModel().close_pull_request(pull_request_id)

        Session().commit()

        h.flash(_('Pull request update created'),

                category='success')

        return redirect(url('pullrequest_show', repo_name=old_pull_request.other_repo.repo_name,

                            pull_request_id=pull_request.pull_request_id))

    # pullrequest_post for PR editing

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def post(self, repo_name, pull_request_id):

        repo = RepoModel()._get_repo(repo_name)

        pull_request = PullRequest.get_or_404(pull_request_id)

        old_description = pull_request.description

        _form = PullRequestPostForm()().to_python(request.POST)

        pull_request.title = _form['pullrequest_title']

        pull_request.description = _form['pullrequest_desc'].strip() or _('No description')

        PullRequestModel().mention_from_description(pull_request, old_description)

        Session().commit()

        h.flash(_('Pull request updated'), category='success')

        return redirect(url('pullrequest_show', repo_name=repo.repo_name,

                            pull_request_id=pull_request_id))

    # pullrequest_update for updating reviewer list

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def update(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        #only owner or admin can update it

        owner = pull_request.author.user_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if h.HasPermissionAny('hg.admin') or repo_admin or owner:

            reviewers_ids = map(int, filter(lambda v: v not in [None, ''],

                request.POST.get('reviewers_ids', '').split(',')))

            PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)

            Session().commit()

            return True

        raise HTTPForbidden()

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

        if pull_request.author.user_id == c.authuser.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request'),

                    category='success')

            return redirect(url('my_account_pullrequests'))

        raise HTTPForbidden()

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        # pull_requests repo_name we opened it against

        # ie. other_repo must match

        if repo_name != c.pull_request.other_repo.repo_name:

            raise HTTPNotFound

        # load compare data into template context

        self._load_compare_data(c.pull_request, enable_comments=True)

        # inline comments

        c.inline_cnt = 0

        c.inline_comments = cc_model.get_inline_comments(

                                c.db_repo.repo_id,

                                pull_request=pull_request_id)

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        # comments

        c.comments = cc_model.get_comments(c.db_repo.repo_id,

                                           pull_request=pull_request_id)

        # (badly named) pull-request status calculation based on reviewer votes

        (c.pull_request_reviewers,

         c.pull_request_pending_reviewers,

         c.current_voting_result,

         ) = cs_model.calculate_pull_request_result(c.pull_request)

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.as_form = False

        c.ancestor = None # there is one - but right here we don't know which

        return render('/pullrequests/pullrequest_show.html')

    @LoginRequired()

    @NotAnonymous()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def comment(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        status = request.POST.get('changeset_status')

        text = request.POST.get('text')

        close_pr = request.POST.get('save_close')

        allowed_to_change_status = self._get_is_allowed_change_status(pull_request)

        if status and allowed_to_change_status:

            _def = (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

            if close_pr:

                _def = _('Closing with') + ' ' + _def

            text = text or _def

        comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.db_repo.repo_id,

            user=c.authuser.user_id,

            pull_request=pull_request_id,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

                           if status and allowed_to_change_status else None),

            closing_pr=close_pr

        )

        action_logger(self.authuser,

                      'user_commented_pull_request:%s' % pull_request_id,

                      c.db_repo, self.ip_addr, self.sa)

        if allowed_to_change_status:

            # get status if set !

            if status:

                ChangesetStatusModel().set_status(

                    c.db_repo.repo_id,

                    status,

                    c.authuser.user_id,

                    comm,

                    pull_request=pull_request_id

                )

            if close_pr:

                PullRequestModel().close_pull_request(pull_request_id)

                action_logger(self.authuser,

                              'user_closed_pull_request:%s' % pull_request_id,

                              c.db_repo, self.ip_addr, self.sa)

        Session().commit()

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            return redirect(h.url('pullrequest_show', repo_name=repo_name,

    # Define our alphabet.

    _ALPHABET = alphabet or "23456789ABCDEFGHJKLMNPQRSTUVWXYZ"

    # If no URL is given, generate a random UUID.

    if url is None:

        unique_id = uuid.uuid4().int

    else:

        unique_id = uuid.uuid3(uuid.NAMESPACE_URL, url).int

    alphabet_length = len(_ALPHABET)

    output = []

    while unique_id > 0:

        digit = unique_id % alphabet_length

        output.append(_ALPHABET[digit])

        unique_id = int(unique_id / alphabet_length)

    return "".join(output)[:truncate_to]

def get_current_authuser():

    """

    Gets kallithea user from threadlocal tmpl_context variable if it's

    defined, else returns None.

    """

    from pylons import tmpl_context

    if hasattr(tmpl_context, 'authuser'):

        return tmpl_context.authuser

    return None

class OptionalAttr(object):

    """

    Special Optional Option that defines other attribute. Example::

        def test(apiuser, userid=Optional(OAttr('apiuser')):

            user = Optional.extract(userid)

            # calls

    """

    def __init__(self, attr_name):

        self.attr_name = attr_name

    def __repr__(self):

        return '<OptionalAttr:%s>' % self.attr_name

    def __call__(self):

        return self

#alias

OAttr = OptionalAttr

class Optional(object):

    """

    Defines an optional parameter::

        param = param.getval() if isinstance(param, Optional) else param

        param = param() if isinstance(param, Optional) else param

    is equivalent of::

        param = Optional.extract(param)

    """

    def __init__(self, type_):

        self.type_ = type_

    def __repr__(self):

        return '<Optional:%s>' % self.type_.__repr__()

    def __call__(self):

        return self.getval()

    def getval(self):

        """

        returns value from this Optional instance

        """

        if isinstance(self.type_, OAttr):

            # use params name

            return self.type_.attr_name

        return self.type_

    @classmethod

    def extract(cls, val):

        """

        Extracts value from Optional() instance

        :param val:

        :return: original value if it's not Optional instance else

            value of instance

        """

        if isinstance(val, cls):

            return val.getval()

        return val

from kallithea.lib import helpers as h

from kallithea.model import BaseModel

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

    Notification, PullRequest

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class ChangesetCommentsModel(BaseModel):

    cls = ChangesetComment

    def __get_changeset_comment(self, changeset_comment):

        return self._get_instance(ChangesetComment, changeset_comment)

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

    def _extract_mentions(self, s):

        user_objects = []

        for username in extract_mentioned_users(s):

            user_obj = User.get_by_username(username, case_insensitive=True)

            if user_obj:

                user_objects.append(user_obj)

        return user_objects

    def _get_notification_data(self, repo, comment, user, comment_text,

                               line_no=None, revision=None, pull_request=None,

                               status_change=None, closing_pr=False):

        """

        Get notification data

        :param comment_text:

        :param line:

        :returns: tuple (subj,body,recipients,notification_type,email_kwargs)

        """

        # make notification

        body = comment_text  # text of the comment

        line = ''

        if line_no:

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

        #changeset

        if revision:

            notification_type = Notification.TYPE_CHANGESET_COMMENT

            cs = repo.scm_instance.get_changeset(revision)

            desc = "%s" % (cs.short_id)

            threading = ['%s-rev-%s@%s' % (repo.repo_name, revision, h.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,

                                                           h.canonical_hostname()))

            comment_url = h.canonical_url('changeset_home',

                repo_name=repo.repo_name,

                revision=revision,

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

            subj = safe_unicode(

                h.link_to('Re changeset: %(desc)s %(line)s' % \

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

                          comment_url)

            )

            # get the current participants of this changeset

            recipients = ChangesetComment.get_users(revision=revision)

            # add changeset author if it's in kallithea system

            cs_author = User.get_from_cs_author(cs.author)

            if not cs_author:

                #use repo owner if we cannot extract the author correctly

                cs_author = repo.user

            recipients += [cs_author]

            email_kwargs = {

                'status_change': status_change,

                'cs_comment_user': h.person(user),

                'cs_target_repo': h.canonical_url('summary_home', repo_name=repo.repo_name),

                'cs_comment_url': comment_url,

                'raw_id': revision,

                'message': cs.message,

                'repo_name': repo.repo_name,

                'short_id': h.short_id(revision),

                'branch': cs.branch,

                'comment_username': user.username,

                'threading': threading,

            }

        #pull request

        elif pull_request:

            notification_type = Notification.TYPE_PULL_REQUEST_COMMENT

            desc = comment.pull_request.title

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

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

                                          pull_request.pull_request_id,

                                          h.canonical_hostname())]

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

                threading.append('%s-pr-%s-line-%s@%s' % (pull_request.other_repo.repo_name,

                                                          pull_request.pull_request_id, line_no,

                                                          h.canonical_hostname()))

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

            subj = safe_unicode(

                h.link_to('Re pull request #%(pr_id)s: %(desc)s %(line)s' % \

                          {'desc': desc,

                           'pr_id': comment.pull_request.pull_request_id,

                           'line': line},

                          comment_url)

            )

            # get the current participants of this pull request

            recipients = ChangesetComment.get_users(pull_request_id=

                                                pull_request.pull_request_id)

            # add pull request author

            recipients += [pull_request.author]

            # add the reviewers to notification

            recipients += [x.user for x in pull_request.reviewers]

            #set some variables for email notification

            email_kwargs = {

                'pr_title': pull_request.title,

                'pr_id': pull_request.pull_request_id,

                'status_change': status_change,

                'closing_pr': closing_pr,

                'pr_comment_url': comment_url,

                'pr_comment_user': h.person(user),

                'pr_target_repo': h.canonical_url('summary_home',

                                   repo_name=pull_request.other_repo.repo_name),

                'repo_name': pull_request.other_repo.repo_name,

                'ref': org_ref_name,

                'comment_username': user.username,

                'threading': threading,

            }

        return subj, body, recipients, notification_type, email_kwargs

    def create(self, text, repo, user, revision=None, pull_request=None,

               f_path=None, line_no=None, status_change=None, closing_pr=False,

               send_email=True):

        """

        Creates new comment for changeset or pull request.

        If status_change is not None this comment is associated with a

        status change of changeset or changesets associated with pull request

        :param text:

        :param repo:

        :param user:

        :param revision:

        :param pull_request: (for emails, not for comments)

        :param f_path:

        :param line_no:

        :param status_change: (for emails, not for comments)

        :param closing_pr: (for emails, not for comments)

        :param send_email: also send email

        """

        if not text:

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

            return

        repo = self._get_repo(repo)

        user = self._get_user(user)

        comment = ChangesetComment()

        comment.repo = repo

        comment.author = user

        comment.text = text

        comment.f_path = f_path

        comment.line_no = line_no

        if revision:

            comment.revision = revision

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

            comment.pull_request = pull_request

        else:

            raise Exception('Please specify revision or pull_request_id')

        Session().add(comment)

        Session().flush()

        if send_email:

            (subj, body, recipients, notification_type,

             email_kwargs) = self._get_notification_data(

                                repo, comment, user,

                                comment_text=text,

                                line_no=line_no,

                                revision=revision,

                                pull_request=pull_request,

                                status_change=status_change,

                                closing_pr=closing_pr)

            email_kwargs['is_mention'] = False

            # create notification objects, and emails

            NotificationModel().create(

                created_by=user, subject=subj, body=body,