get_changeset_safe, datetime_to_time, time_to_datetime, AttributeDict,\

    safe_int

from kallithea.lib.markup_renderer import MarkupRenderer

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

from kallithea.lib.vcs.backends.base import BaseChangeset, EmptyChangeset

from kallithea.config.conf import DATE_FORMAT, DATETIME_FORMAT

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.db import URL_SEP, Permission

log = logging.getLogger(__name__)

def canonical_url(*args, **kargs):

    '''Like url(x, qualified=True), but returns url that not only is qualified

    but also canonical, as configured in canonical_url'''

    from kallithea import CONFIG

    try:

        parts = CONFIG.get('canonical_url', '').split('://', 1)

        kargs['host'] = parts[1].split('/', 1)[0]

        kargs['protocol'] = parts[0]

    except IndexError:

        kargs['qualified'] = True

    return url(*args, **kargs)

def html_escape(text, html_escape_table=None):

    """Produce entities within text."""

    if not html_escape_table:

        html_escape_table = {

            "&": "&",

            '"': """,

            "'": "'",

            ">": ">",

            "<": "&lt;",

        }

    return "".join(html_escape_table.get(c, c) for c in text)

def shorter(text, size=20):

    postfix = '...'

    if len(text) > size:

        return text[:size - len(postfix)] + postfix

    return text

def _reset(name, value=None, id=NotGiven, type="reset", **attrs):

    """

    Reset button

    """

        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)

            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,

            }

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

            comment_url = h.canonical_url('pullrequest_show',

                repo_name=pull_request.other_repo.repo_name,

                pull_request_id=pull_request.pull_request_id,

                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,

            }

        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:

            new.author,

            comment,

            pull_request=new

        )

        mention_recipients = set(User.get_by_username(username, case_insensitive=True)

                                 for username in extract_mentioned_users(new.description))

        self.__add_reviewers(new, reviewers, mention_recipients)

        return new

    def __add_reviewers(self, pr, reviewers, mention_recipients=None):

        #members

        for member in set(reviewers):

            _usr = self._get_user(member)

            reviewer = PullRequestReviewers(_usr, pr)

            Session().add(reviewer)

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

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

        #notification to reviewers

        pr_url = h.canonical_url('pullrequest_show', repo_name=pr.other_repo.repo_name,

                       pull_request_id=pr.pull_request_id)

        subject = safe_unicode(

            h.link_to(

              _('%(user)s wants you to review pull request #%(pr_id)s: %(pr_title)s') % \

                {'user': pr.author.username,

                 'pr_title': pr.title,

                 'pr_id': pr.pull_request_id},

                pr_url)

            )

        body = pr.description

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

        email_kwargs = {

            'pr_title': pr.title,

            'pr_user_created': h.person(pr.author),

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

            'pr_id': pr.pull_request_id,

            'ref': org_ref_name,

            'pr_username': pr.author.username,

            'is_mention': False,

            }

        if reviewers:

            NotificationModel().create(created_by=pr.author, subject=subject, body=body,

                                       recipients=reviewers,

                                       type_=Notification.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

        if mention_recipients:

            mention_recipients.discard(None)

            mention_recipients.difference_update(reviewers)

        if mention_recipients:

            email_kwargs['is_mention'] = True

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

            NotificationModel().create(created_by=pr.author, subject=subject, body=body,

                                       recipients=mention_recipients,

                                       type_=Notification.TYPE_PULL_REQUEST,

                                       email_kwargs=email_kwargs)

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

        mention_recipients = set(User.get_by_username(username, case_insensitive=True)

                                 for username in extract_mentioned_users(pr.description))

        mention_recipients.difference_update(User.get_by_username(username, case_insensitive=True)