def get_prefix(self):

        """

        get prefix that might have been used in _get_cache_key to

        generate self.cache_key. Only used for informational purposes

        in repo_edit.html.

        """

        # prefix, repo_name, suffix

        return self._cache_key_partition()[0]

    def get_suffix(self):

        """

        get suffix that might have been used in _get_cache_key to

        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 rhodecode

        prefix = rhodecode.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()

        try:

            for inv_obj in inv_objs:

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

                          % (inv_obj, safe_str(repo_name)))

                inv_obj.cache_active = False

                Session().add(inv_obj)

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            Session().rollback()

    @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

        try:

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

            if not inv_obj:

                inv_obj = CacheInvalidation(cache_key, repo_name)

            was_valid = inv_obj.cache_active

            inv_obj.cache_active = True

            Session().add(inv_obj)

            Session().commit()

            return was_valid

        except Exception:

            log.error(traceback.format_exc())

            Session().rollback()

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

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

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

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

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

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

    hl_lines = Column('hl_lines', Unicode(512), nullable=True)

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

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

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

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

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

    author = relationship('User', lazy='joined')

    repo = relationship('Repository')

    status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")

    pull_request = relationship('PullRequest', lazy='joined')

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

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

        elif pull_request_id:

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

        return q.all()

class ChangesetStatus(Base, BaseModel):

    __tablename__ = 'changeset_statuses'

    __table_args__ = (

        Index('cs_revision_idx', 'revision'),

        Index('cs_version_idx', 'version'),

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

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'}

    )

    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

    STATUS_APPROVED = 'approved'

    STATUS_REJECTED = 'rejected'

    STATUS_UNDER_REVIEW = 'under_review'

    STATUSES = [

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

        (STATUS_APPROVED, _("Approved")),

        (STATUS_REJECTED, _("Rejected")),

        (STATUS_UNDER_REVIEW, _("Under Review")),

    ]

    changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)

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

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

    revision = Column('revision', String(40), nullable=False)

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

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

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

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

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

    author = relationship('User', lazy='joined')

    repo = relationship('Repository')

    comment = relationship('ChangesetComment', lazy='joined')

    pull_request = relationship('PullRequest', lazy='joined')

    def __unicode__(self):

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

            self.__class__.__name__,

            self.status, self.author

        )

    @classmethod

    def get_status_lbl(cls, value):

        return dict(cls.STATUSES).get(value)

    @property

    def status_lbl(self):

        return ChangesetStatus.get_status_lbl(self.status)

class PullRequest(Base, BaseModel):

    __tablename__ = 'pull_requests'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    STATUS_NEW = u'new'

    STATUS_OPEN = u'open'

    STATUS_CLOSED = u'closed'

    pull_request_id = Column('pull_request_id', Integer(), nullable=False, primary_key=True)

    title = Column('title', Unicode(256), nullable=True)

    description = Column('description', UnicodeText(10240), nullable=True)

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

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

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

    _revisions = Column('revisions', UnicodeText(20500))  # 500 revisions max

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

    org_ref = Column('org_ref', Unicode(256), nullable=False)

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

    other_ref = Column('other_ref', Unicode(256), nullable=False)

    @hybrid_property

    def revisions(self):

        return self._revisions.split(':')

    @revisions.setter

    def revisions(self, val):

        self._revisions = ':'.join(val)

    @property

    def org_ref_parts(self):

        return self.org_ref.split(':')

    @property

    def other_ref_parts(self):

        return self.other_ref.split(':')

    author = relationship('User', lazy='joined')

    reviewers = relationship('PullRequestReviewers',

                             cascade="all, delete, delete-orphan")

    org_repo = relationship('Repository', primaryjoin='PullRequest.org_repo_id==Repository.repo_id')

    other_repo = relationship('Repository', primaryjoin='PullRequest.other_repo_id==Repository.repo_id')

    statuses = relationship('ChangesetStatus')

    comments = relationship('ChangesetComment',

                             cascade="all, delete, delete-orphan")

    def is_closed(self):

        return self.status == self.STATUS_CLOSED

    @property

    def last_review_status(self):

        return self.statuses[-1].status if self.statuses else ''

    def __json__(self):

        return dict(

          revisions=self.revisions

        )

class PullRequestReviewers(Base, BaseModel):

    __tablename__ = 'pull_request_reviewers'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    def __init__(self, user=None, pull_request=None):

        self.user = user

        self.pull_request = pull_request

    pull_requests_reviewers_id = Column('pull_requests_reviewers_id', Integer(), nullable=False, primary_key=True)

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

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

    user = relationship('User')

    pull_request = relationship('PullRequest')

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

    __table_args__ = (

        Index('notification_type_idx', 'type'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention'

    TYPE_REGISTRATION = u'registration'

    TYPE_PULL_REQUEST = u'pull_request'

    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

    notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

    subject = Column('subject', Unicode(512), nullable=True)

    body = Column('body', UnicodeText(50000), nullable=True)

    created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

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

    type_ = Column('type', Unicode(256))

    created_by_user = relationship('User')

    notifications_to_users = relationship('UserNotification', lazy='joined',

                                          cascade="all, delete, delete-orphan")

    @property

    def recipients(self):

        return [x.user for x in UserNotification.query()\

                .filter(UserNotification.notification == self)\

                .order_by(UserNotification.user_id.asc()).all()]

    @classmethod

    def create(cls, created_by, subject, body, recipients, type_=None):

        if type_ is None:

            type_ = Notification.TYPE_MESSAGE

        notification = cls()

        notification.created_by_user = created_by

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        notification.created_on = datetime.datetime.now()

        for u in recipients:

            assoc = UserNotification()

            assoc.notification = notification

            u.notifications.append(assoc)

        Session().add(notification)

        return notification

    @property

    def description(self):

        from rhodecode.model.notification import NotificationModel

        return NotificationModel().make_description(self)

class UserNotification(Base, BaseModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (

        UniqueConstraint('user_id', 'notification_id'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'}

    )

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)

    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column('read', Boolean, default=False)

    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

    user = relationship('User', lazy="joined")

    notification = relationship('Notification', lazy="joined",

                                order_by=lambda: Notification.created_on.desc(),)

    def mark_as_read(self):

        self.read = True

        Session().add(self)

class Gist(Base, BaseModel):

    __tablename__ = 'gists'

    __table_args__ = (

        Index('g_gist_access_id_idx', 'gist_access_id'),

        Index('g_created_on_idx', 'created_on'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

    )

    GIST_PUBLIC = u'public'

    GIST_PRIVATE = u'private'

    gist_id = Column('gist_id', Integer(), primary_key=True)

    gist_access_id = Column('gist_access_id', Unicode(250))

    gist_description = Column('gist_description', UnicodeText(1024))

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

    gist_expires = Column('gist_expires', Float(53), nullable=False)

    gist_type = Column('gist_type', Unicode(128), nullable=False)

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

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

    owner = relationship('User')

    @classmethod

    def get_or_404(cls, id_):

        res = cls.query().filter(cls.gist_access_id == id_).scalar()

        if not res:

            raise HTTPNotFound

        return res

    @classmethod

    def get_by_access_id(cls, gist_access_id):

        return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()

    def gist_url(self):

        import rhodecode

        alias_url = rhodecode.CONFIG.get('gist_alias_url')

        if alias_url:

            return alias_url.replace('{gistid}', self.gist_access_id)

        from pylons import url

        return url('gist', gist_id=self.gist_access_id, qualified=True)

    @classmethod

    def base_path(cls):

        """

        Returns base path when all gists are stored

        :param cls:

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

## usage:

## <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>

## ${comment.comment_block(co)}

##

<%def name="comment_block(co)">

  <div class="comment" id="comment-${co.comment_id}" line="${co.line_no}">

    <div class="comment-wrapp">

      <div class="meta">

        <div style="float:left"> <img src="${h.gravatar_url(co.author.email, 20)}" /> </div>

          <div class="user">

              ${co.author.username}

          </div>

          <div class="date">

              ${h.age(co.modified_at)}

          </div>

       <div style="float:left;padding:4px 0px 0px 5px">

        <span class="">

         %if co.pull_request:

            <a href="${h.url('pullrequest_show',repo_name=co.pull_request.other_repo.repo_name,pull_request_id=co.pull_request.pull_request_id)}">

            %if co.status_change:

            %else:

              ${_('Comment on pull request #%s') % co.pull_request.pull_request_id}

            %endif

            </a>

         %endif

        </span>

       </div>

      <a class="permalink" href="#comment-${co.comment_id}">&para;</a>

      %if h.HasPermissionAny('hg.admin', 'repository.admin')() or co.author.user_id == c.rhodecode_user.user_id:

          <div onClick="deleteComment(${co.comment_id})" class="buttons delete-comment ui-btn small">${_('Delete')}</div>

      %endif

      </div>

      <div class="text">

          ${h.rst_w_mentions(co.text)|n}

      </div>

    </div>

  </div>

</%def>

<%def name="comment_inline_form()">

<div id='comment-inline-form-template' style="display:none">

  <div class="comment-inline-form ac">

  %if c.rhodecode_user.username != 'default':

    <div class="overlay"><div class="overlay-text">${_('Submitting...')}</div></div>

      ${h.form('#', class_='inline-form')}

      <div id="edit-container_{1}" class="clearfix">

          <div class="comment-help">${_('Commenting on line {1}.')}

          ${(_('Comments parsed using %s syntax with %s support.') % (

                 ('<a href="%s">RST</a>' % h.url('rst_help')),

                   ('<span style="color:#003367" class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to send notification to this RhodeCode user'))

               )

            )|n

           }

          <div id="preview-btn_{1}" class="preview-btn ui-btn small">${_('Preview')}</div>

          </div>

            <div class="mentions-container" id="mentions_container_{1}"></div>

            <textarea id="text_{1}" name="text" class="comment-block-ta yui-ac-input"></textarea>

      </div>

      <div id="preview-container_{1}" class="clearfix" style="display:none">

         <div class="comment-help">

              ${_('Comment preview')}

            <div id="edit-btn_{1}" class="edit-btn ui-btn small">${_('Edit')}</div>

          </div>

          <div id="preview-box_{1}" class="preview-box"></div>

      </div>

      <div class="comment-button">

      <input type="hidden" name="f_path" value="{0}">

      <input type="hidden" name="line" value="{1}">

      ${h.submit('save', _('Comment'), class_='ui-btn save-inline-form')}

      ${h.reset('hide-inline-form', _('Cancel'), class_='ui-btn hide-inline-form')}

      </div>

      ${h.end_form()}

  %else:

      ${h.form('')}

      <div class="clearfix">

          <div class="comment-help">

            ${_('You need to be logged in to comment.')} <a href="${h.url('login_home',came_from=h.url.current())}">${_('Login now')}</a>

          </div>

      </div>

      <div class="comment-button">

      ${h.reset('hide-inline-form', _('Hide'), class_='ui-btn hide-inline-form')}

      </div>

      ${h.end_form()}

  %endif

  </div>

</div>

</%def>

## generates inlines taken from c.comments var

<%def name="inlines()">

    <div class="comments-number">${ungettext("%d comment", "%d comments", len(c.comments)) % len(c.comments)} ${ungettext("(%d inline)", "(%d inline)", c.inline_cnt) % c.inline_cnt}</div>

    %for path, lines in c.inline_comments:

        % for line,comments in lines.iteritems():

            <div style="display:none" class="inline-comment-placeholder" path="${path}" target_id="${h.safeid(h.safe_unicode(path))}">

            %for co in comments:

                ${comment_block(co)}

            %endfor

            </div>

        %endfor

    %endfor

</%def>

## generate inline comments and the main ones

<%def name="generate_comments(include_pr=False)">

<div class="comments">

    <div id="inline-comments-container">

    ## generate inlines for this changeset

     ${inlines()}

    </div>

    %for co in c.comments:

        <div id="comment-tr-${co.comment_id}">

          ## only render comments that are not from pull request, or from

          ## pull request and a status change

          %if not co.pull_request or (co.pull_request and co.status_change) or include_pr:

          ${comment_block(co)}

          %endif

        </div>

    %endfor

</div>

</%def>

## MAIN COMMENT FORM

<%def name="comments(post_url, cur_status, close_btn=False, change_status=True)">

<div class="comments">

    %if c.rhodecode_user.username != 'default':

    <div class="comment-form ac">

        ${h.form(post_url)}

        <div id="edit-container" class="clearfix">

            <div class="comment-help">

                ${(_('Comments parsed using %s syntax with %s support.') % (('<a href="%s">RST</a>' % h.url('rst_help')),

                  '<span style="color:#003367" class="tooltip" title="%s">@mention</span>' %

                  _('Use @username inside this text to send notification to this RhodeCode user')))|n}

              %if change_status:

                | <a id="show_changeset_link" onClick="change_status_show();"> ${_('Change status')}</a>

                  <input id="show_changeset_status_box" type="checkbox" name="change_changeset_status" style="display: none;" />

              %endif

              <div id="preview-btn" class="preview-btn ui-btn small">${_('Preview')}</div>

            </div>

            %if change_status:

            <div id="status_block_container" class="status-block" style="display:none">

                %for status,lbl in c.changeset_statuses:

                    <div class="">

                        <img src="${h.url('/images/icons/flag_status_%s.png' % status)}" /> <input ${'checked="checked"' if status == cur_status else ''}" type="radio" class="status_change_radio" name="changeset_status" id="${status}" value="${status}">

                        <label for="${status}">${lbl}</label>

                    </div>

                %endfor

                %if close_btn and change_status:

                <input id="save_close" type="checkbox" name="save_close" disabled="${'1' if cur_status in ['not_reviewed','under_review'] else ''}">

                <label id="save_close_label" for="save_close" class="${'disabled' if cur_status in ['not_reviewed','under_review'] else ''}">${_("Close (when approved or rejected)")}</label>

                %endif

            </div>

            %endif

            <div class="mentions-container" id="mentions_container"></div>

             ${h.textarea('text', class_="comment-block-ta")}

        </div>

        <div id="preview-container" class="clearfix" style="display:none">

           <div class="comment-help">

                ${_('Comment preview')}

              <div id="edit-btn" class="edit-btn ui-btn small">${_('Edit')}</div>

            </div>

            <div id="preview-box" class="preview-box"></div>

        </div>

        <div class="comment-button">

        ${h.submit('save', _('Comment'), class_="ui-btn large")}

        </div>

        ${h.end_form()}

    </div>

    %endif

</div>

<script>

var change_status_show = function(){

    var show = ! YUD.get('show_changeset_status_box').checked;

    YUD.get('show_changeset_status_box').checked = show;

    YUD.setStyle('status_block_container', 'display', show?'':'none');

};

YUE.onDOMReady(function () {

   MentionsAutoComplete('text', 'mentions_container', _USERS_AC_DATA, _GROUPS_AC_DATA);

   YUE.on(YUQ('.status_change_radio'), 'change',function(e){

       var val = e.currentTarget.value;

       if (val == 'approved' || val == 'rejected') {

           YUD.removeClass('save_close_label', 'disabled');

           YUD.get('save_close').disabled = false;

       }else{

           YUD.addClass('save_close_label', 'disabled');

           YUD.get('save_close').disabled = true;

       }

   })

   YUE.on('preview-btn', 'click', function(e){

       var _text = YUD.get('text').value;

       if(!_text){

           return

       }

       var post_data = {'text': _text};

       YUD.addClass('preview-box', 'unloaded');

       YUD.get('preview-box').innerHTML = _TM['Loading ...'];

       YUD.setStyle('edit-container', 'display', 'none');

       YUD.setStyle('preview-container', 'display', '');

       var url = pyroutes.url('changeset_comment_preview', {'repo_name': '${c.repo_name}'});

       ajaxPOST(url,post_data,function(o){

           YUD.get('preview-box').innerHTML = o.responseText;

           YUD.removeClass('preview-box', 'unloaded');

       })

   })

   YUE.on('edit-btn', 'click', function(e){

       YUD.setStyle('edit-container', 'display', '');

       YUD.setStyle('preview-container', 'display', 'none');

   })

});