class UserFollowing(Base, BaseModel):

    __tablename__ = 'user_followings'

    __table_args__ = (

        UniqueConstraint('user_id', 'follows_repository_id'),

        UniqueConstraint('user_id', 'follows_user_id'),

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

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

    )

    user_following_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

    follows_user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

    follows_from = Column(DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

    follows_repository = relationship('Repository', order_by='Repository.repo_name')

    @classmethod

    def get_repo_followers(cls, repo_id):

        return cls.query().filter(cls.follows_repo_id == repo_id)

class CacheInvalidation(Base, BaseModel):

    __tablename__ = 'cache_invalidation'

    __table_args__ = (

        UniqueConstraint('cache_key'),

        Index('key_idx', 'cache_key'),

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

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

    )

    # cache_id, not used

    cache_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    # cache_key as created by _get_cache_key

    cache_key = Column(String(255, convert_unicode=False))

    # cache_args is a repo_name

    cache_args = Column(String(255, convert_unicode=False))

    # instance sets cache_active True when it is caching, other instances set

    # cache_active to False to indicate that this cache is invalid

    cache_active = Column(Boolean(), nullable=True, unique=None, default=False)

    def __init__(self, cache_key, repo_name=''):

        self.cache_key = cache_key

        self.cache_args = repo_name

        self.cache_active = False

    def __unicode__(self):

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

            self.__class__.__name__,

            self.cache_id, self.cache_key, self.cache_active)

    def _cache_key_partition(self):

        prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

        return prefix, repo_name, suffix

    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 kallithea

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

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

    @classmethod

    def set_invalidate(cls, repo_name, delete=False):

        """

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

            if delete:

                Session().delete(inv_obj)

            else:

                inv_obj.cache_active = False

                Session().add(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 not inv_obj:

            inv_obj = CacheInvalidation(cache_key, repo_name)

        if inv_obj.cache_active:

            return True

        inv_obj.cache_active = True

        Session().add(inv_obj)

        Session().commit()

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

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

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

    )

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

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

    revision = Column(String(40))

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

    line_no = Column(Unicode(10))

    hl_lines = Column(Unicode(512))

    f_path = Column(Unicode(1000))

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

    text = Column(UnicodeText(25000), 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()

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

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

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

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

    )

    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(Integer(), nullable=False, unique=True, primary_key=True)

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

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

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

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

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

    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

        )

    @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__ = (

        Index('pr_org_repo_id_idx', 'org_repo_id'),

        Index('pr_other_repo_id_idx', 'other_repo_id'),

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

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

    )

    # values for .status

    STATUS_NEW = u'new'

    STATUS_CLOSED = u'closed'

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

    title = Column(Unicode(255), nullable=True)

    description = Column(UnicodeText(10240))

    status = Column(Unicode(255), nullable=False, default=STATUS_NEW) # only for closedness, not approve/reject/etc

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

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

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

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

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

    org_ref = Column(Unicode(255), nullable=False)

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

    other_ref = Column(Unicode(255), nullable=False)

    @hybrid_property

    def revisions(self):

        return self._revisions.split(':')

    @revisions.setter

    def revisions(self, val):

        self._revisions = safe_unicode(':'.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')

    reviewers = relationship('PullRequestReviewers',

                             cascade="all, 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-orphan")

    def is_closed(self):

        return self.status == self.STATUS_CLOSED

    @property

    def last_review_status(self):

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

    def user_review_status(self, user_id):

        """Return the user's latest status votes on PR"""

        # note: no filtering on repo - that would be redundant

        status = ChangesetStatus.query()\

            .filter(ChangesetStatus.pull_request == self)\

            .filter(ChangesetStatus.user_id == user_id)\

            .order_by(ChangesetStatus.version)\

            .first()

        return str(status.status) if status else ''

    @classmethod

    def make_nice_id(cls, pull_request_id):

        '''Return pull request id nicely formatted for displaying'''

        return '#%s' % pull_request_id

    def nice_id(self):

        '''Return the id of this pull request, nicely formatted for displaying'''

        return self.make_nice_id(self.pull_request_id)

    def __json__(self):

        return dict(

            revisions=self.revisions

        )

    def url(self, **kwargs):

        canonical = kwargs.pop('canonical', None)

        import kallithea.lib.helpers as h

        b = self.org_ref_parts[1]

        if b != self.other_ref_parts[1]:

            s = '/_/' + b

        else:

            s = '/_/' + self.title

        kwargs['extra'] = urlreadable(s)

        if canonical:

            return h.canonical_url('pullrequest_show', repo_name=self.other_repo.repo_name,

                                   pull_request_id=self.pull_request_id, **kwargs)

        return h.url('pullrequest_show', repo_name=self.other_repo.repo_name,

                     pull_request_id=self.pull_request_id, **kwargs)

class PullRequestReviewers(Base, BaseModel):

    __tablename__ = 'pull_request_reviewers'

    __table_args__ = (

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

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

    )

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

        self.user = user

        self.pull_request = pull_request

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

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

    user_id = Column(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', 'sqlite_autoincrement': True},

    )

    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(Integer(), nullable=False, unique=True, primary_key=True)

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

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

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

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

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

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

<%inherit file="/base/base.html"/>

<%block name="title">

    ${_('%s Changelog') % c.repo_name}

    %if c.changelog_for_path:

      /${c.changelog_for_path}

    %endif

</%block>

<%def name="breadcrumbs_links()">

    <% size = c.size if c.size <= c.total_cs else c.total_cs %>

    ${_('Changelog')}

    %if c.changelog_for_path:

     - /${c.changelog_for_path}

    %endif

    %if c.revision:

    @ ${h.short_id(c.first_revision.raw_id)}

    %endif

    - ${ungettext('showing %d out of %d revision', 'showing %d out of %d revisions', size) % (size, c.total_cs)}

</%def>

<%block name="header_menu">

    ${self.menu('repositories')}

</%block>

<%def name="main()">

${self.repo_context_bar('changelog', c.first_revision.raw_id if c.first_revision else None)}

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <div class="table">

        % if c.pagination:

            <div>

                <div style="overflow:auto; display:${'none' if c.changelog_for_path else ''}">

                    <div class="container_header">

                        <div style="float:left; margin-left:20px;">

                        ${h.form(h.url.current(),method='get')}

                            ${h.submit('set',_('Show'),class_="btn btn-small")}

                            ${h.text('size',size=3,value=c.size)}

                            ${_('revisions')}

                            %if c.branch_name:

                            ${h.hidden('branch', c.branch_name)}

                            %endif

                        ${h.end_form()}

                        </div>

                        <div style="float: right; margin: 0px 0px 0px 4px">

                            <a href="#" class="btn btn-small" id="rev_range_container" style="display:none"></a>

                            <a href="#" class="btn btn-small" id="rev_range_clear" style="display:none">${_('Clear selection')}</a>

                            %if c.revision:

                                <a class="btn btn-small" href="${h.url('changelog_home', repo_name=c.repo_name)}">

                                    ${_('Go to tip of repository')}

                                </a>

                            %endif

                            %if c.db_repo.fork:

                                <a id="compare_fork"

                                   title="${_('Compare fork with %s' % c.db_repo.fork.repo_name)}"

                                   href="${h.url('compare_url',repo_name=c.db_repo.fork.repo_name,org_ref_type=c.db_repo.landing_rev[0],org_ref_name=c.db_repo.landing_rev[1],other_repo=c.repo_name,other_ref_type='branch' if request.GET.get('branch') else c.db_repo.landing_rev[0],other_ref_name=request.GET.get('branch') or c.db_repo.landing_rev[1], merge=1)}"

                                   class="btn btn-small"><i class="icon-git-compare"></i> ${_('Compare fork with parent repo (%s)' % c.db_repo.fork.repo_name)}</a>

                            %endif

                            ## text and href of open_new_pr is controlled from javascript

                            <a id="open_new_pr" class="btn btn-small"></a>

                            ${_("Branch filter:")} ${h.select('branch_filter',c.branch_name,c.branch_filters)}

                        </div>

                    </div>

                </div>

                <div id="changelog" style="clear:both">

                <div id="graph_nodes">

                    <canvas id="graph_canvas"></canvas>

                </div>

                <div id="graph_content" style="${'margin: 0px' if c.changelog_for_path else ''}">

                <table id="changesets">

                <tbody>

                %for cnt,cs in enumerate(c.pagination):

                    <tr id="chg_${cnt+1}" class="container ${'tablerow%s' % (cnt%2)}">

                        <td class="checkbox">

                            %if c.changelog_for_path:

                                ${h.checkbox(cs.raw_id,class_="changeset_range", disabled="disabled")}

                            %else:

                                ${h.checkbox(cs.raw_id,class_="changeset_range")}

                            %endif

                        <td class="status">

                          %if c.statuses.get(cs.raw_id):

                            <div class="changeset-status-ico">

                            %if c.statuses.get(cs.raw_id)[2]:

                              <a class="tooltip" title="${_('Changeset status: %s\nClick to open associated pull request %s') % (c.statuses.get(cs.raw_id)[1], c.statuses.get(cs.raw_id)[4])}" href="${h.url('pullrequest_show',repo_name=c.statuses.get(cs.raw_id)[3],pull_request_id=c.statuses.get(cs.raw_id)[2])}">

                                <i class="icon-circle changeset-status-${c.statuses.get(cs.raw_id)[0]}"></i>

                              </a>

                            %else:

                                  <i class="icon-circle changeset-status-${c.statuses.get(cs.raw_id)[0]}"></i>

                              </a>

                            %endif

                            </div>

                          %endif

                        </td>

                        <td class="author">

                            ${h.gravatar(h.email_or_none(cs.author), size=16)}

                            <span title="${cs.author}" class="user">${h.shorter(h.person(cs.author),22)}</span>

                        </td>

                        <td class="hash" style="width:${len(h.show_id(cs))*6.5}px">

                            <a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}">

                                <span class="changeset_hash">${h.show_id(cs)}</span>

                            </a>

                        </td>

                        <td class="date">

                            <div class="date">${h.age(cs.date,True)}</div>

                        </td>

                        <td class="expand_commit" commit_id="${cs.raw_id}" title="${_('Expand commit message')}">

                            <i class="icon-align-left" style="color:#999"></i>

                        </td>

                        <td class="mid">

                            <div class="log-container">

                                <div class="message" id="C-${cs.raw_id}">${h.urlify_commit(cs.message, c.repo_name,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</div>

                                <div class="extra-container">

                                    %if c.comments.get(cs.raw_id):

                                        <div class="comments-container">

                                            <div class="comments-cnt" title="${_('Changeset has comments')}">

                                                    ${len(c.comments[cs.raw_id])}

                                                    <i class="icon-comment-discussion"></i>

                                                </a>

                                            </div>

                                        </div>

                                    %endif

                                    %if h.is_hg(c.db_repo_scm_instance):

                                        %for book in cs.bookmarks:

                                            <div class="booktag" title="${_('Bookmark %s') % book}">

                                                ${h.link_to(book,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}

                                            </div>

                                        %endfor

                                    %endif

                                    %for tag in cs.tags:

                                        <div class="tagtag" title="${_('Tag %s') % tag}">

                                            ${h.link_to(tag,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}

                                        </div>

                                    %endfor

                                    %if (not c.branch_name) and cs.branch:

                                        <div class="branchtag" title="${_('Branch %s' % cs.branch)}">

                                            ${h.link_to(cs.branch,h.url('changelog_home',repo_name=c.repo_name,branch=cs.branch))}

                                        </div>

                                    %endif

                                </div>

                            </div>

                        </td>

                    </tr>

                %endfor

                </tbody>

                </table>

                </div>

                <div class="pagination-wh pagination-left">

                    ${c.pagination.pager('$link_previous ~2~ $link_next')}

                </div>

            </div>

        </div>

        <script type="text/javascript" src="${h.url('/js/graph.js', ver=c.kallithea_version)}"></script>

        <script type="text/javascript">

            $(document).ready(function(){

                //Monitor range checkboxes and build a link to changesets ranges

                var checkboxes = YUD.getElementsByClassName('changeset_range');

                // register extra routes needed for this view

                pyroutes.register('changeset_home', "${h.url('changeset_home', repo_name='%(repo_name)s', revision='%(revision)s')}", ['repo_name', 'revision']);

                var checkbox_checker = function(e){

                    var checked_checkboxes = [];

                    for (pos in checkboxes){

                        if(checkboxes[pos].checked){

                            checked_checkboxes.push(checkboxes[pos]);

                        }

                    }

                    if(YUD.get('open_new_pr')){

                        if(checked_checkboxes.length>1){

                            YUD.setStyle('open_new_pr','display','none');

                        } else {

                            YUD.setStyle('open_new_pr','display','');

                            if(checked_checkboxes.length>0){

                                YUD.get('open_new_pr').innerHTML = _TM['Open New Pull Request for Selected Changesets'];

                            }else{

                                YUD.get('open_new_pr').innerHTML = _TM['Open New Pull Request'];

                            }

                        }

                    }

                    if(checked_checkboxes.length>0){

                        var rev_end = checked_checkboxes[0].name;

                        var rev_start = checked_checkboxes[checked_checkboxes.length-1].name;

                        var url = pyroutes.url('changeset_home', {'repo_name': '${c.repo_name}',

                                                                  'revision': rev_start+'...'+rev_end});

                        var link = (rev_start == rev_end)

                            ? _TM['Show Selected Changeset __S']

                            : _TM['Show Selected Changesets __S → __E'];

                        link = link.replace('__S',rev_start.substr(0,6));

                        link = link.replace('__E',rev_end.substr(0,6));

                        YUD.get('rev_range_container').href = url;

                        YUD.get('rev_range_container').innerHTML = link;

                        YUD.setStyle('rev_range_container','display','');

                        YUD.setStyle('rev_range_clear','display','');

                        YUD.get('open_new_pr').href = pyroutes.url('pullrequest_home',

                                                                   {'repo_name': '${c.repo_name}',

                                                                    'rev_start': rev_start,

                                                                    'rev_end': rev_end});

                        YUD.setStyle('compare_fork','display','none');

                    }else{

                        YUD.setStyle('rev_range_container','display','none');

                        YUD.setStyle('rev_range_clear','display','none');

                        %if c.revision:

                            YUD.get('open_new_pr').href = pyroutes.url('pullrequest_home',

                                                                       {'repo_name': '${c.repo_name}',

                                                                        'rev_end':'${c.first_revision.raw_id}'});

                        %else:

                            YUD.get('open_new_pr').href = pyroutes.url('pullrequest_home',

                                                                       {'repo_name': '${c.repo_name}',

                                                                        'branch':'${c.first_revision.branch}'});

                        %endif

                        YUD.setStyle('compare_fork','display','');

                    }

                };

                checkbox_checker();

                YUE.on(checkboxes,'click', checkbox_checker);

                YUE.on('rev_range_clear','click',function(e){

                    for (var i=0; i<checkboxes.length; i++){

                        var cb = checkboxes[i];

                        cb.checked = false;

                    }

                    checkbox_checker();

                    YUE.preventDefault(e);

                });

                var $msgs = $('.message');

                // get first element height

                var el = $('#graph_content .container')[0];

                var row_h = el.clientHeight;

                $msgs.each(function() {

                    var m = this;

                    var h = m.clientHeight;

                    if(h > row_h){

                        var offset = row_h - (h+12);

                        $(m.nextElementSibling).css('display', 'block');

                        $(m.nextElementSibling).css('margin-top', offset+'px');

                    }

                });

                $('.expand_commit').on('click',function(e){

                    var cid = $(this).attr('commit_id');

                    $('#C-'+cid).toggleClass('expanded');

                    //redraw the graph, r and jsdata are bound outside function

                    r.render(jsdata,100);

                });

                // change branch filter

                $("#branch_filter").select2({

                    dropdownAutoWidth: true,

                    minimumInputLength: 1

                    });

                $("#branch_filter").change(function(e){

                    var selected_branch = e.currentTarget.options[e.currentTarget.selectedIndex].value;

                    if(selected_branch != ''){

                        window.location = pyroutes.url('changelog_home', {'repo_name': '${c.repo_name}',

                                                                          'branch': selected_branch});

                    }else{

                        window.location = pyroutes.url('changelog_home', {'repo_name': '${c.repo_name}'});

                    }

                    $("#changelog").hide();

                });

                var jsdata = ${c.jsdata|n};

                var r = new BranchRenderer('graph_canvas', 'graph_content', 'chg_');

                r.render(jsdata,100);

            });

        </script>

        %else:

            ${_('There are no changes yet')}

        %endif

    </div>

</div>

</%def>

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

%if c.repo_changesets:

<table>

    <tr>

        <th class="left"></th>

        <th class="left"></th>

        <th class="left">${_('Revision')}</th>

        <th class="left">${_('Commit Message')}</th>

        <th class="left">${_('Age')}</th>

        <th class="left">${_('Author')}</th>

        <th class="left">${_('Refs')}</th>

    </tr>

%for cnt,cs in enumerate(c.repo_changesets):

    <tr class="parity${cnt%2}">

        <td class="compact">

            <div class="changeset-status-container">

              %if c.statuses.get(cs.raw_id):

                <span class="changeset-status-ico shortlog">

                %if c.statuses.get(cs.raw_id)[2]:

                  <a class="tooltip" title="${_('Changeset status: %s\nClick to open associated pull request %s') % (c.statuses.get(cs.raw_id)[1], c.statuses.get(cs.raw_id)[4])}" href="${h.url('pullrequest_show',repo_name=c.statuses.get(cs.raw_id)[3],pull_request_id=c.statuses.get(cs.raw_id)[2])}">

                    <i class="icon-circle changeset-status-${c.statuses.get(cs.raw_id)[0]}"></i>

                  </a>

                %else:

                  <i class="icon-circle changeset-status-${c.statuses.get(cs.raw_id)[0]}"></i>

                %endif

                </span>

              %endif

            </div>

        </td>

        <td class="compact">

              %if c.comments.get(cs.raw_id,[]):

               <div class="comments-container">

                   <div title="${('comments')}">

                          <i class="icon-comment"></i>${len(c.comments[cs.raw_id])}

                       </a>

                   </div>

               </div>

              %endif

        </td>

        <td>

            <a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}" class="revision-link">${h.show_id(cs)}</a>

        </td>

        <td>

            ${h.urlify_commit(h.chop_at(cs.message,'\n'),c.repo_name, h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}

        </td>

        <td><span class="tooltip" title="${h.tooltip(h.fmt_date(cs.date))}">

                      ${h.age(cs.date)}</span>

        </td>

        <td title="${cs.author}">${h.person(cs.author)}</td>

        <td>

            %if h.is_hg(c.db_repo_scm_instance):

                %for book in cs.bookmarks:

                    <div class="booktag" title="${_('Bookmark %s') % book}">

                        ${h.link_to(book,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}

                    </div>

                %endfor

            %endif

            %for tag in cs.tags:

             <div class="tagtag" title="${_('Tag %s') % tag}">

                 ${h.link_to(tag,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}

             </div>

            %endfor

            %if cs.branch:

             <div class="branchtag" title="${_('Branch %s' % cs.branch)}">

                 ${h.link_to(cs.branch,h.url('changelog_home',repo_name=c.repo_name,branch=cs.branch))}

             </div>

            %endif

        </td>

    </tr>

%endfor

</table>

<div class="pagination-wh pagination-left">

${c.repo_changesets.pager('$link_previous ~2~ $link_next')}

</div>

%else:

%if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):

<h4>${_('Add or upload files directly via Kallithea')}</h4>

<div style="margin: 20px 30px;">

  <div id="add_node_id" class="add_node">

      <a class="btn btn-mini" href="${h.url('files_add_home',repo_name=c.repo_name,revision=0,f_path='', anchor='edit')}">${_('Add New File')}</a>

  </div>

</div>

%endif

<h4>${_('Push new repo')}</h4>

<pre>

    ${c.db_repo_scm_instance.alias} clone ${c.clone_repo_url}

    ${c.db_repo_scm_instance.alias} add README # add first file

    ${c.db_repo_scm_instance.alias} commit -m "Initial" # commit with message

    ${c.db_repo_scm_instance.alias} push ${'origin master' if h.is_git(c.db_repo_scm_instance) else ''} # push changes back

</pre>

<h4>${_('Existing repository?')}</h4>

<pre>

%if h.is_git(c.db_repo_scm_instance):

    git remote add origin ${c.clone_repo_url}

    git push -u origin master

%else:

    hg push ${c.clone_repo_url}

%endif

</pre>

%endif

## -*- 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">

               ${h.gravatar(co.author.email, size=20)}

          </div>

          <div class="user">

              ${co.author.username_and_name}

          </div>

          <span>

              ${h.age(co.modified_at)}

              %if co.pull_request:

                ${_('on pull request')}

                <a href="${co.pull_request.url()}">"${co.pull_request.title or _("No title")}"</a>

              %else:

                ${_('on this changeset')}

              %endif

          </span>

          %if h.HasPermissionAny('hg.admin')() or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or co.author.user_id == c.authuser.user_id:

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

          %endif

      </div>

      <div class="text">

        %if co.status_change:

           <div class="rst-block automatic-comment">

             <p>

               <span title="${_('Changeset status')}" class="changeset-status-lbl">${_("Status change")}: ${co.status_change[0].status_lbl}</span>

               <span class="changeset-status-ico"><i class="icon-circle changeset-status-${co.status_change[0].status}"></i></span>

             </p>

           </div>

        %endif

        %if co.text:

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

        %endif

      </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.authuser.username != 'default':

    ${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:#577632" class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to notify another user'))

               )

            )|n

           }

        </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">