if self.dotdot_attr:

                text_ = HTML.span(c=text_, **self.dotdot_attr)

            nav_items.append(HTML.li(text_))

        # Create a link to the very last page (unless we are on the last

        # page or there would be no need to insert '..' spacers)

        if self.page != self.last_page and rightmost_page < self.last_page:

            nav_items.append(HTML.li(self._pagerlink(self.last_page, self.last_page)))

        #_page_link = url.current()

        #nav_items.append(literal('<link rel="prerender" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))

        #nav_items.append(literal('<link rel="prefetch" href="%s?page=%s">' % (_page_link, str(int(self.page)+1))))

        return self.separator.join(nav_items)

    def pager(self, format='<ul class="pagination">$link_previous ~2~ $link_next</ul>', page_param='page', partial_param='partial',

        show_if_single_page=False, separator=' ', onclick=None,

        symbol_first='<<', symbol_last='>>',

        symbol_previous='<', symbol_next='>',

        link_attr=None,

        curpage_attr=None,

        dotdot_attr=None, **kwargs):

        self.curpage_attr = curpage_attr or {'class': 'active'}

        self.separator = separator

        self.pager_kwargs = kwargs

        self.page_param = page_param

        self.partial_param = partial_param

        self.onclick = onclick

        self.link_attr = link_attr or {'class': 'pager_link', 'rel': 'prerender'}

        self.dotdot_attr = dotdot_attr or {'class': 'pager_dotdot'}

        # Don't show navigator if there is no more than one page

        if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):

            return ''

        from string import Template

        # Replace ~...~ in token format by range of pages

        result = re.sub(r'~(\d+)~', self._range, format)

        # Interpolate '%' variables

        result = Template(result).safe_substitute({

            'first_page': self.first_page,

            'last_page': self.last_page,

            'page': self.page,

            'page_count': self.page_count,

            'items_per_page': self.items_per_page,

            'first_item': self.first_item,

            'last_item': self.last_item,

            'item_count': self.item_count,

                    self._pagerlink(self.first_page, symbol_first) or '',

                    self._pagerlink(self.last_page, symbol_last) or '',

                    or HTML.a(symbol_previous)),

                    or HTML.a(symbol_next))

        })

        return literal(result)

class RepoPage(Page):

    def __init__(self, collection, page=1, items_per_page=20,

                 item_count=None, **kwargs):

        """Create a "RepoPage" instance. special pager for paging

        repository

        """

        # TODO: call baseclass __init__

        self._url_generator = kwargs.pop('url', url.current)

        # Safe the kwargs class-wide so they can be used in the pager() method

        self.kwargs = kwargs

        # Save a reference to the collection

        self.original_collection = collection

        self.collection = collection

        # The self.page is the number of the current page.

        # The first page has the number 1!

        try:

            self.page = int(page)  # make it int() if we get it as a string

        except (ValueError, TypeError):

            log.error("Invalid page value: %r", page)

            self.page = 1

        self.items_per_page = items_per_page

        # Unless the user tells us how many items the collections has

        # we calculate that ourselves.

        if item_count is not None:

            self.item_count = item_count

        else:

            self.item_count = len(self.collection)

        # Compute the number of the first and last available page

        if self.item_count > 0:

            self.first_page = 1

            self.page_count = int(math.ceil(float(self.item_count) /

                                            self.items_per_page))

            self.last_page = self.first_page + self.page_count - 1

from kallithea.model.notification import NotificationModel

log = logging.getLogger(__name__)

def _list_changeset_commenters(revision):

    return (Session().query(User)

        .join(ChangesetComment.author)

        .filter(ChangesetComment.revision == revision)

        .all())

def _list_pull_request_commenters(pull_request):

    return (Session().query(User)

        .join(ChangesetComment.author)

        .filter(ChangesetComment.pull_request_id == pull_request.pull_request_id)

        .all())

class ChangesetCommentsModel(object):

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

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

                               status_change=None, closing_pr=False):

        """

        :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 = NotificationModel.TYPE_CHANGESET_COMMENT

            cs = repo.scm_instance.get_changeset(revision)

            desc = 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(

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

                          comment_url)

            )

            # get the current participants of this changeset

            recipients = _list_changeset_commenters(revision)

            # add changeset author if it's known locally

            cs_author = User.get_from_cs_author(cs.author)

            if not cs_author:

                # use repo owner if we cannot extract the author correctly

                # FIXME: just use committer name even if not a user

                cs_author = repo.owner

            recipients.append(cs_author)

            email_kwargs = {

                'status_change': status_change,

                'cs_comment_user': author.full_name_and_username,

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

                'cs_comment_url': comment_url,

                'cs_url': h.canonical_url('changeset_home', repo_name=repo.repo_name, revision=revision),

                'raw_id': revision,

                'message': cs.message,

                'message_short': h.shorter(cs.message, 50, firstline=True),

                'cs_author': cs_author,

                'repo_name': repo.repo_name,

                'short_id': h.short_id(revision),

                'branch': cs.branch,

                'comment_username': author.username,

                'threading': threading,

            }

        # pull request

        elif pull_request:

            notification_type = NotificationModel.TYPE_PULL_REQUEST_COMMENT

            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,

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

            comment_url = pull_request.url(canonical=True,

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

            subj = safe_unicode(

                h.link_to('Re pull request %(pr_nice_id)s: %(desc)s %(line)s' %

                          {'desc': desc,

                           'pr_nice_id': comment.pull_request.nice_id(),

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

"""

import datetime

import logging

import re

from tg import request

from tg.i18n import ugettext as _

from kallithea.lib import helpers as h

from kallithea.lib.utils2 import extract_mentioned_users, safe_str, safe_unicode

from kallithea.model.db import ChangesetStatus, PullRequest, PullRequestReviewer, User

from kallithea.model.meta import Session

from kallithea.model.notification import NotificationModel

log = logging.getLogger(__name__)

def _assert_valid_reviewers(seq):

    """Sanity check: elements are actual User objects, and not the default user."""

    assert not any(user.is_default_user for user in seq)

class PullRequestModel(object):

    def add_reviewers(self, user, pr, reviewers, mention_recipients=None):

        """Add reviewer and send notification to them.

        """

        reviewers = set(reviewers)

        _assert_valid_reviewers(reviewers)

        if mention_recipients is not None:

            mention_recipients = set(mention_recipients) - reviewers

            _assert_valid_reviewers(mention_recipients)

        # members

        for reviewer in reviewers:

            prr = PullRequestReviewer(reviewer, pr)

            Session().add(prr)

        # notification to reviewers

        pr_url = pr.url(canonical=True)

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

                                      pr.pull_request_id,

                                      h.canonical_hostname())]

        subject = safe_unicode(

            h.link_to(

                {'user': user.username,

                 'pr_title': pr.title,

                 'pr_nice_id': pr.nice_id()},

                pr_url)

            )

        body = pr.description

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

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

        revision_data = [(x.raw_id, x.message)

                         for x in map(pr.org_repo.get_changeset, pr.revisions)]

        email_kwargs = {

            'pr_title': pr.title,

            'pr_title_short': h.shorter(pr.title, 50),

            'pr_user_created': user.full_name_and_username,

            'pr_repo_url': h.canonical_url('summary_home', repo_name=pr.other_repo.repo_name),

            'pr_url': pr_url,

            'pr_revisions': revision_data,

            'repo_name': pr.other_repo.repo_name,

            'org_repo_name': pr.org_repo.repo_name,

            'pr_nice_id': pr.nice_id(),

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

                               repo_name=pr.other_repo.repo_name),

            'pr_target_branch': other_ref_name,

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

                               repo_name=pr.org_repo.repo_name),

            'pr_source_branch': org_ref_name,

            'pr_owner': pr.owner,

            'pr_owner_username': pr.owner.username,

            'pr_username': user.username,

            'threading': threading,

            'is_mention': False,

            }

        if reviewers:

            NotificationModel().create(created_by=user, subject=subject, body=body,

                                       recipients=reviewers,

                                       type_=NotificationModel.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

        if mention_recipients:

            email_kwargs['is_mention'] = True

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

            # FIXME: this subject is wrong and unused!

            NotificationModel().create(created_by=user, subject=subject, body=body,

                                       recipients=mention_recipients,

                                       type_=NotificationModel.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

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

                        _set_perm_group(obj, users_group=member, perm=perm)

            # set new permissions

            for member, perm, member_type in perms_new:

                if member_type == 'user':

                    _set_perm_user(obj, user=member, perm=perm)

                else:

                    # check if we have permissions to alter this usergroup's access

                    if not check_perms or HasUserGroupPermissionLevel('read')(member):

                        _set_perm_group(obj, users_group=member, perm=perm)

            updates.append(obj)

            # if it's not recursive call for all,repos,groups

            # break the loop and don't proceed with other changes

            if recursive not in ['all', 'repos', 'groups']:

                break

        return updates

    def update(self, repo_group, repo_group_args):

        try:

            repo_group = RepoGroup.guess_instance(repo_group)

            old_path = repo_group.full_path

            # change properties

            if 'group_description' in repo_group_args:

                repo_group.group_description = repo_group_args['group_description']

            if 'parent_group_id' in repo_group_args:

                repo_group.parent_group_id = repo_group_args['parent_group_id']

            if 'parent_group_id' in repo_group_args:

                assert repo_group_args['parent_group_id'] != u'-1', repo_group_args  # RepoGroupForm should have converted to None

                repo_group.parent_group = RepoGroup.get(repo_group_args['parent_group_id'])

            if 'group_name' in repo_group_args:

                group_name = repo_group_args['group_name']

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

                    raise Exception('invalid repo group name %s' % group_name)

                repo_group.group_name = repo_group.get_new_name(group_name)

            new_path = repo_group.full_path

            Session().add(repo_group)

            # iterate over all members of this groups and do fixes

            # if obj is a repoGroup also fix the name of the group according

            # to the parent

            # if obj is a Repo fix it's name

            # this can be potentially heavy operation

            for obj in repo_group.recursive_groups_and_repos():

                # set the value from it's parent

                if isinstance(obj, RepoGroup):

                    new_name = obj.get_new_name(obj.name)

                                % (obj.group_name, new_name))

                    obj.group_name = new_name

                elif isinstance(obj, Repository):

                    # we need to get all repositories from this new group and

                    # rename them accordingly to new group path

                    new_name = obj.get_new_name(obj.just_name)

                                % (obj.repo_name, new_name))

                    obj.repo_name = new_name

            self._rename_group(old_path, new_path)

            return repo_group

        except Exception:

            log.error(traceback.format_exc())

            raise

    def delete(self, repo_group, force_delete=False):

        repo_group = RepoGroup.guess_instance(repo_group)

        try:

            Session().delete(repo_group)

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

        from kallithea.model.repo import RepoModel

        repo_group = RepoGroup.guess_instance(repo_group)

        perm = 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

            if recursive == 'all':

                pass

            elif recursive == 'repos':

                # skip groups, other than this one

                if isinstance(el, RepoGroup) and not el == repo_group:

                    continue

            elif recursive == 'groups':

                # skip repos

                if isinstance(el, Repository):

                    continue

            else:  # recursive == 'none': # DEFAULT don't apply to iterated objects

                el = repo_group

                # also we do a break at the end of this loop.

            if isinstance(el, RepoGroup):

                if obj_type == 'user':

                    RepoGroupModel().grant_user_permission(el, user=obj, perm=perm)

                elif obj_type == 'user_group':

                    RepoGroupModel().grant_user_group_permission(el, group_name=obj, perm=perm)

                else:

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