lbl = _('Show whitespace')

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = get_line_ctx(fileid, GET)

    # global option

    if fileid is None:

        if ig_ws is None:

            params['ignorews'] += [1]

            lbl = _('Ignore whitespace')

        ctx_key = 'context'

        ctx_val = ln_ctx

    # per file options

    else:

        if ig_ws is None:

            params[fileid] += ['WS:1']

            lbl = _('Ignore whitespace')

        ctx_key = fileid

        ctx_val = 'C:%s' % ln_ctx

    # if we have passed in ln_ctx pass it along to our params

    if ln_ctx:

        params[ctx_key] += [ctx_val]

    params['anchor'] = fileid

    icon = h.literal('<i class="icon-strike"></i>')

    return h.link_to(icon, h.url.current(**params), title=lbl, class_='tooltip')

def get_line_ctx(fid, GET):

    ln_ctx_global = GET.get('context')

    if fid:

        ln_ctx = filter(lambda k: k.startswith('C'), GET.getall(fid))

    else:

        _ln_ctx = filter(lambda k: k.startswith('C'), GET)

        ln_ctx = GET.get(_ln_ctx[0]) if _ln_ctx  else ln_ctx_global

        if ln_ctx:

            ln_ctx = [ln_ctx]

    if ln_ctx:

        retval = ln_ctx[0].split(':')[-1]

    else:

        retval = ln_ctx_global

    try:

        return int(retval)

    except Exception:

        return 3

def _context_url(GET, fileid=None):

    """

    Generates url for context lines

    :param fileid:

    """

    fileid = str(fileid) if fileid else None

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2

    params = defaultdict(list)

    _update_with_GET(params, GET)

    # global option

    if fileid is None:

        if ln_ctx > 0:

            params['context'] += [ln_ctx]

        if ig_ws:

            ig_ws_key = 'ignorews'

            ig_ws_val = 1

    # per file option

    else:

        params[fileid] += ['C:%s' % ln_ctx]

        ig_ws_key = fileid

        ig_ws_val = 'WS:%s' % 1

    if ig_ws:

        params[ig_ws_key] += [ig_ws_val]

    lbl = _('Increase diff context to %(num)s lines') % {'num': ln_ctx}

    params['anchor'] = fileid

    icon = h.literal('<i class="icon-sort"></i>')

    return h.link_to(icon, h.url.current(**params), title=lbl, class_='tooltip')

# Could perhaps be nice to have in the model but is too high level ...

def create_comment(text, status, f_path, line_no, revision=None, pull_request_id=None, closing_pr=None):

    """Comment functionality shared between changesets and pullrequests"""

    f_path = f_path or None

    line_no = line_no or None

    comment = ChangesetCommentsModel().create(

        text=text,

        repo=c.db_repo.repo_id,

        revision=revision,

        pull_request=pull_request_id,

        f_path=f_path,

        line_no=line_no,

        status_change=ChangesetStatus.get_status_lbl(status) if status else None,

        closing_pr=closing_pr,

    )

    return comment

class ChangesetController(BaseRepoController):

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

    def __load_data(self):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

    def _index(self, revision, method):

        c.pull_request = None

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.fulldiff = fulldiff = request.GET.get('fulldiff')

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        enable_comments = True

        c.cs_repo = c.db_repo

        try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.db_repo_scm_instance.get_changesets(start=rev_start,

                                                             end=rev_end)

            else:

                rev_ranges = [c.db_repo_scm_instance.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

        except (ChangesetDoesNotExistError, EmptyRepositoryError):

            log.debug(traceback.format_exc())

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        c.changeset_statuses = ChangesetStatus.STATUSES

        comments = dict()

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            if method == 'show':

                c.statuses.extend([ChangesetStatusModel().get_status(

                            c.db_repo.repo_id, changeset.raw_id)])

                # Changeset comments

                comments.update((com.comment_id, com)

                                for com in ChangesetCommentsModel()

                                .get_comments(c.db_repo.repo_id,

                                              revision=changeset.raw_id))

                # Status change comments - mostly from pull requests

                comments.update((st.changeset_comment_id, st.comment)

                                for st in ChangesetStatusModel()

                                .get_statuses(c.db_repo.repo_id,

                                              changeset.raw_id, with_revisions=True)

                                if st.changeset_comment_id is not None)

                inlines = ChangesetCommentsModel() \

                            .get_inline_comments(c.db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

            cs2 = changeset.raw_id

            cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset().raw_id

            context_lcl = get_line_ctx('', request.GET)

            ign_whitespace_lcl = get_ignore_ws('', request.GET)

            _diff = c.db_repo_scm_instance.get_diff(cs1, cs2,

                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)

            diff_limit = self.cut_off_limit if not fulldiff else None

            diff_processor = diffs.DiffProcessor(_diff,

        except Exception:

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

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=url('pullrequest_home', repo_name=repo_name))

        raise HTTPFound(location=pull_request.url())

    def create_new_iteration(self, old_pull_request, new_rev, title, description, reviewers_ids):

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

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

        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 a new iteration of %s "%s".' %

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

                      pull_request_id=old_pull_request.pull_request_id),

                  old_pull_request.title)]

        if lost:

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

            for r in old_pull_request.revisions:

                if r in lost:

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

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

        if new_revisions:

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

            for r in reversed(revisions):

                if r in new_revisions:

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

                    infos.append('  %s %s' % (h.short_id(r), h.shorter(rev_desc, 80)))

            if ancestor_rev == other_rev:

                infos.append(_("Ancestor didn't change - diff since previous iteration:"))

                infos.append(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 iteration is based on another %s revision and there is no simple diff.') % other_ref_name)

        else:

           infos.append(_('No changes found on %s %s since previous iteration.') % (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)

        try:

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

            v = int(old_v) + 1

        except (AttributeError, ValueError):

            v = 2

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

        # using a mail-like separator, insert new iteration info in description with latest first

        descriptions = description.replace('\r\n', '\n').split('\n-- \n', 1)

        description = descriptions[0].strip() + '\n\n-- \n' + '\n'.join(infos)

        if len(descriptions) > 1:

            description += '\n\n' + descriptions[1].strip()

        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_ids, title, description

            )

        except UserInvalidException as u:

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        except Exception:

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

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=old_pull_request.url())

        ChangesetCommentsModel().create(

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

            repo=old_pull_request.other_repo.repo_id,

            pull_request=old_pull_request.pull_request_id,

            closing_pr=True)

        PullRequestModel().close_pull_request(old_pull_request.pull_request_id)

        Session().commit()

        h.flash(_('New pull request iteration created'),

                category='success')

        raise HTTPFound(location=pull_request.url())

    # pullrequest_post for PR editing

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    def post(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        assert pull_request.other_repo.repo_name == repo_name

        #only owner or admin can update it

        owner = pull_request.owner_id == c.authuser.user_id

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

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

            raise HTTPForbidden()

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

        reviewers_ids = [int(s) for s in _form['review_members']]

        if _form['updaterev']:

            return self.create_new_iteration(pull_request,

                                      _form['updaterev'],

                                      _form['pullrequest_title'],

                                      _form['pullrequest_desc'],

                                      reviewers_ids)

        old_description = pull_request.description

        pull_request.title = _form['pullrequest_title']

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

        pull_request.owner = User.get_by_username(_form['owner'])

        user = User.get(c.authuser.user_id)

        try:

            PullRequestModel().mention_from_description(user, pull_request, old_description)

            PullRequestModel().update_reviewers(user, pull_request_id, reviewers_ids)

        except UserInvalidException as u:

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        Session().commit()

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

        raise HTTPFound(location=pull_request.url())

    @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.owner.user_id == c.authuser.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

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

                    category='success')

            raise HTTPFound(location=url('my_pullrequests'))

        raise HTTPForbidden()

    @LoginRequired()

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

                                   'repository.admin')

    def show(self, repo_name, pull_request_id, extra=None):

        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

        c.cs_repo = c.pull_request.org_repo

        (c.cs_ref_type,

         c.cs_ref_name,

         c.cs_rev) = c.pull_request.org_ref.split(':')

        c.a_repo = c.pull_request.other_repo

        (c.a_ref_type,

         c.a_ref_name,

         c.a_rev) = c.pull_request.other_ref.split(':') # other_rev is ancestor

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.model.comment

~~~~~~~~~~~~~~~~~~~~~~~

comments model for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Nov 11, 2011

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

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

"""

import logging

from pylons.i18n.translation import _

from collections import defaultdict

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

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

                               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 = Notification.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(

                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 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 += [cs_author]

            email_kwargs = {

                'status_change': status_change,

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

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

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

                           '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.owner]

            # add the reviewers to notification

            recipients += pull_request.get_reviewer_users()

            #set some variables for email notification

            email_kwargs = {

                'pr_title': pull_request.title,

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

                'pr_nice_id': pull_request.nice_id(),

                'status_change': status_change,

                'closing_pr': closing_pr,

                'pr_comment_url': comment_url,

                'pr_url': pull_request.url(canonical=True),

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

                                   repo_name=pull_request.other_repo.repo_name),

                'pr_target_branch': other_ref_name,

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

                                   repo_name=pull_request.org_repo.repo_name),

                'pr_source_branch': org_ref_name,

                'pr_owner': pull_request.owner,

                'pr_owner_username': pull_request.owner.username,

                'repo_name': pull_request.other_repo.repo_name,

                'threading': threading,

            }

        return subj, body, recipients, notification_type, email_kwargs

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

               send_email=True):

        """

        Creates a new comment for either a changeset or a pull request.

        status_change and closing_pr is only for the optional email.

        Returns the created comment.

        """

        if not status_change and not text:

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

            return None

        repo = self._get_repo(repo)

        comment = ChangesetComment()

        comment.repo = repo

        comment.text = text

        comment.f_path = f_path

        comment.line_no = line_no

        if revision is not None:

            comment.revision = revision

        elif pull_request is not None:

            pull_request = PullRequest.guess_instance(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(

                                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(

                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!

                NotificationModel().create(

                    recipients=mention_recipients,

                    type_=notification_type,

                    email_kwargs=email_kwargs

                )

        return comment

    def delete(self, comment):

        comment = ChangesetComment.guess_instance(comment)

        Session().delete(comment)

        return comment

    def get_comments(self, repo_id, revision=None, pull_request=None):

        """

        Gets general comments for either revision or pull_request.

        Returns a list, ordered by creation date.

        """

        return self._get_comments(repo_id, revision=revision, pull_request=pull_request,

                                  inline=False)

    def get_inline_comments(self, repo_id, revision=None, pull_request=None):

        """

        Gets inline comments for either revision or pull_request.

        Returns a list of tuples with file path and list of comments per line number.

        """

        comments = self._get_comments(repo_id, revision=revision, pull_request=pull_request,

                                      inline=True)

        paths = defaultdict(lambda: defaultdict(list))

        for co in comments:

            paths[co.f_path][co.line_no].append(co)

        return paths.items()

    def _get_comments(self, repo_id, revision=None, pull_request=None, inline=False):

        """

        Gets comments for either revision or pull_request_id, either inline or general.

        """

        q = Session().query(ChangesetComment)

        if inline:

            q = q.filter(ChangesetComment.line_no != None) \

                .filter(ChangesetComment.f_path != None)

        else:

            q = q.filter(ChangesetComment.line_no == None) \

                .filter(ChangesetComment.f_path == None)

        if revision is not None:

            q = q.filter(ChangesetComment.revision == revision) \

                .filter(ChangesetComment.repo_id == repo_id)

        elif pull_request is not None:

            pull_request = PullRequest.guess_instance(pull_request)

            q = q.filter(ChangesetComment.pull_request == pull_request)

        else:

            raise Exception('Please specify either revision or pull_request')

        return q.order_by(ChangesetComment.created_on).all()

        generate self.cache_key. Only used for informational purposes

        in repo_edit.html.

        """

        # prefix, repo_name, suffix

        return self._cache_key_partition()[2]

    @classmethod

    def clear_cache(cls):

        """

        Delete all cache keys from database.

        Should only be run when all instances are down and all entries thus stale.

        """

        cls.query().delete()

        Session().commit()

    @classmethod

    def _get_cache_key(cls, key):

        """

        Wrapper for generating a unique cache key for this instance and "key".

        key must / will start with a repo_name which will be stored in .cache_args .

        """

        import kallithea

        prefix = kallithea.CONFIG.get('instance_id', '')

        return "%s%s" % (prefix, key)

    @classmethod

    def set_invalidate(cls, repo_name):

        """

        Mark all caches of a repo as invalid in the database.

        """

        inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        log.debug('for repo %s got %s invalidation objects',

                  safe_str(repo_name), inv_objs)

        for inv_obj in inv_objs:

            log.debug('marking %s key for invalidation based on repo_name=%s',

                      inv_obj, safe_str(repo_name))

            Session().delete(inv_obj)

        Session().commit()

    @classmethod

    def test_and_set_valid(cls, repo_name, kind, valid_cache_keys=None):

        """

        Mark this cache key as active and currently cached.

        Return True if the existing cache registration still was valid.

        Return False to indicate that it had been invalidated and caches should be refreshed.

        """

        key = (repo_name + '_' + kind) if kind else repo_name

        cache_key = cls._get_cache_key(key)

        if valid_cache_keys and cache_key in valid_cache_keys:

            return True

        inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

        if inv_obj is None:

            inv_obj = cls(cache_key, repo_name)

            Session().add(inv_obj)

        elif inv_obj.cache_active:

            return True

        inv_obj.cache_active = True

        try:

            Session().commit()

        except sqlalchemy.exc.IntegrityError:

            log.error('commit of CacheInvalidation failed - retrying')

            Session().rollback()

            inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

            if inv_obj is None:

                log.error('failed to create CacheInvalidation entry')

                # TODO: fail badly?

            # else: TOCTOU - another thread added the key at the same time; no further action required

        return False

    @classmethod

    def get_valid_cache_keys(cls):

        """

        Return opaque object with information of which caches still are valid

        and can be used without checking for invalidation.

        """

        return set(inv_obj.cache_key for inv_obj in cls.query().filter(cls.cache_active).all())

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        Index('cc_revision_idx', 'revision'),

        Index('cc_pull_request_id_idx', 'pull_request_id'),

        _table_args_default_dict,

    )

    comment_id = Column(Integer(), primary_key=True)

    repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    revision = Column(String(40), nullable=True)

    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

    line_no = Column(Unicode(10), nullable=True)

    f_path = Column(Unicode(1000), nullable=True)

    text = Column(UnicodeText(), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    modified_at = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    author = relationship('User')

    repo = relationship('Repository')

    # status_change is frequently used directly in templates - make it a lazy

    # join to avoid fetching each related ChangesetStatus on demand.

    # There will only be one ChangesetStatus referencing each comment so the join will not explode.

    status_change = relationship('ChangesetStatus',

                                 cascade="all, delete-orphan", lazy='joined')

    pull_request = relationship('PullRequest')

    @classmethod

    def get_users(cls, revision=None, pull_request_id=None):

        """

        Returns user associated with this ChangesetComment. ie those

        who actually commented

        :param cls:

        :param revision:

        """

        q = Session().query(User) \

                .join(ChangesetComment.author)

        if revision is not None:

            q = q.filter(cls.revision == revision)

        elif pull_request_id is not None:

            q = q.filter(cls.pull_request_id == pull_request_id)

        return q.all()

    def url(self):

        anchor = "comment-%s" % self.comment_id

        import kallithea.lib.helpers as h

        if self.revision:

            return h.url('changeset_home', repo_name=self.repo.repo_name, revision=self.revision, anchor=anchor)

        elif self.pull_request_id is not None:

            return self.pull_request.url(anchor=anchor)

    def deletable(self):

        return self.created_on > datetime.datetime.now() - datetime.timedelta(minutes=5)

class ChangesetStatus(Base, BaseModel):

    __tablename__ = 'changeset_statuses'

    __table_args__ = (

        Index('cs_revision_idx', 'revision'),

        Index('cs_version_idx', 'version'),

        Index('cs_pull_request_id_idx', 'pull_request_id'),

        Index('cs_changeset_comment_id_idx', 'changeset_comment_id'),

        Index('cs_pull_request_id_user_id_version_idx', 'pull_request_id', 'user_id', 'version'),

        Index('cs_repo_id_pull_request_id_idx', 'repo_id', 'pull_request_id'),

        UniqueConstraint('repo_id', 'revision', 'version'),

        _table_args_default_dict,

    )

    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

    STATUS_APPROVED = 'approved'

    STATUS_REJECTED = 'rejected' # is shown as "Not approved" - TODO: change database content / scheme

    STATUS_UNDER_REVIEW = 'under_review'

    STATUSES = [

        (STATUS_NOT_REVIEWED, _("Not reviewed")),  # (no icon) and default

        (STATUS_UNDER_REVIEW, _("Under review")),

        (STATUS_REJECTED, _("Not approved")),

        (STATUS_APPROVED, _("Approved")),

    ]

    STATUSES_DICT = dict(STATUSES)

    changeset_status_id = Column(Integer(), primary_key=True)

    repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    revision = Column(String(40), nullable=True)

    status = Column(String(128), nullable=False, default=DEFAULT)

    changeset_comment_id = Column(Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False)

    modified_at = Column(DateTime(), nullable=False, default=datetime.datetime.now)

    version = Column(Integer(), nullable=False, default=0)

    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

    author = relationship('User')

    repo = relationship('Repository')

    comment = relationship('ChangesetComment')

    pull_request = relationship('PullRequest')

    def __unicode__(self):

        return u"<%s('%s:%s')>" % (

            self.__class__.__name__,

            self.status, self.author

        )