(self.page - 1))

            self.items = list(self.collection[self.first_item:self.last_item + 1])

            # Links to previous and next page

            if self.page > self.first_page:

                self.previous_page = self.page - 1

            else:

                self.previous_page = None

            if self.page < self.last_page:

                self.next_page = self.page + 1

            else:

                self.next_page = None

        # No items available

        else:

            self.first_page = None

            self.page_count = 0

            self.last_page = None

            self.first_item = None

            self.last_item = None

            self.previous_page = None

            self.next_page = None

            self.items = []

        # This is a subclass of the 'list' type. Initialise the list now.

        list.__init__(self, reversed(self.items))

def changed_tooltip(nodes):

    """

    Generates a html string for changed nodes in changeset page.

    It limits the output to 30 entries

    :param nodes: LazyNodesGenerator

    """

    if nodes:

        pref = ': <br/> '

        suf = ''

        if len(nodes) > 30:

            suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)

        return literal(pref + '<br/> '.join([safe_unicode(x.path)

                                             for x in nodes[:30]]) + suf)

    else:

        return ': ' + _('No Files')

    """

    Makes a breadcrumbs link to repo within a group

    joins » on each group to create a fancy link

    ex::

        group >> subgroup >> repo

    :param groups_and_repos:

    :param last_url:

    """

        def make_link(group):

            return link_to(group.name,

                           url('repos_group_home', group_name=group.group_name))

def fancy_file_stats(stats):

    """

    Displays a fancy two colored bar for number of added/deleted

    lines of code on file

    :param stats: two element list of added/deleted lines of code

    """

    def cgen(l_type, a_v, d_v):

        mapping = {'tr': 'top-right-rounded-corner-mid',

                   'tl': 'top-left-rounded-corner-mid',

                   'br': 'bottom-right-rounded-corner-mid',

                   'bl': 'bottom-left-rounded-corner-mid'}

        map_getter = lambda x: mapping[x]

        if l_type == 'a' and d_v:

            #case when added and deleted are present

            return ' '.join(map(map_getter, ['tl', 'bl']))

        if l_type == 'a' and not d_v:

            return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))

        if l_type == 'd' and a_v:

            return ' '.join(map(map_getter, ['tr', 'br']))

        if l_type == 'd' and not a_v:

            return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))

    a, d = stats[0], stats[1]

    width = 100

    if a == 'b':

        #binary mode

        b_d = '<div class="bin%s %s" style="width:100%%">%s</div>' % (d, cgen('a', a_v='', d_v=0), 'bin')

        b_a = '<div class="bin1" style="width:0%%">%s</div>' % ('bin')

        return literal('<div style="width:%spx">%s%s</div>' % (width, b_a, b_d))

    t = stats[0] + stats[1]

    unit = float(width) / (t or 1)

    # needs > 9% of width to be visible or 0 to be hidden

    a_p = max(9, unit * a) if a > 0 else 0

    d_p = max(9, unit * d) if d > 0 else 0

    p_sum = a_p + d_p

    if p_sum > width:

        #adjust the percentage to be == 100% since we adjusted to 9

    def base_path(cls):

        """

        Returns base path when all repos are stored

        :param cls:

        """

        q = Session().query(RhodeCodeUi)\

            .filter(RhodeCodeUi.ui_key == cls.url_sep())

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

    @property

    def forks(self):

        """

        Return forks of this repo

        """

        return Repository.get_repo_forks(self.repo_id)

    @property

    def parent(self):

        """

        Returns fork parent

        """

        return self.fork

    @property

    def just_name(self):

        return self.repo_name.split(Repository.url_sep())[-1]

    @property

    def groups_with_parents(self):

        groups = []

        if self.group is None:

            return groups

        cur_gr = self.group

        groups.insert(0, cur_gr)

        while 1:

            gr = getattr(cur_gr, 'parent_group', None)

            cur_gr = cur_gr.parent_group

            if gr is None:

                break

            groups.insert(0, gr)

        return groups

    @property

    def groups_and_repo(self):

    @LazyProperty

    def repo_path(self):

        """

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

        q = Session().query(RhodeCodeUi).filter(RhodeCodeUi.ui_key ==

                                              Repository.url_sep())

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

    @property

    def repo_full_path(self):

        p = [self.repo_path]

        # we need to split the name by / since this is how we store the

        # names in the database, but that eventually needs to be converted

        # into a valid system path

        p += self.repo_name.split(Repository.url_sep())

        return os.path.join(*p)

    @property

    def cache_keys(self):

        """

        Returns associated cache keys for that repo

        """

        return CacheInvalidation.query()\

            .filter(CacheInvalidation.cache_args == self.repo_name)\

            .order_by(CacheInvalidation.cache_key)\

            .all()

    def get_new_name(self, repo_name):

        """

        returns new full repository name based on assigned group and new new

        :param group_name:

        """

        path_prefix = self.group.full_path_splitted if self.group else []

        return Repository.url_sep().join(path_prefix + [repo_name])

    @property

    def _ui(self):

        """

        Creates an db based ui object for this repository

        """

        from rhodecode.lib.utils import make_ui

        return make_ui('db', clear_session=False)

                    'repository.read', 'repository.write', 'repository.admin'

                )(repo.repo_name, 'get_repos_as_dict check'):

                    continue

            cs_cache = repo.changeset_cache

            row = {

                "menu": quick_menu(repo.repo_name),

                "raw_name": repo.repo_name.lower(),

                "name": repo_lnk(repo.repo_name, repo.repo_type,

                                 repo.private, repo.fork),

                "last_change": last_change(repo.last_db_change),

                "last_changeset": last_rev(repo.repo_name, cs_cache),

                "raw_tip": cs_cache.get('revision'),

                "desc": desc(repo.description),

                "owner": h.person(repo.user.username),

                "rss": rss_lnk(repo.repo_name),

                "atom": atom_lnk(repo.repo_name),

            }

            if admin:

                row.update({

                    "action": repo_actions(repo.repo_name),

                    "owner": owner_actions(repo.user.user_id,

                                           h.person(repo.user.username))

                })

            repos_data.append(row)

        return {

            "totalRecords": len(repos_list),

            "startIndex": 0,

            "sort": "name",

            "dir": "asc",

            "records": repos_data

        }

    def _get_defaults(self, repo_name):

        """

        Get's information about repository, and returns a dict for

        usage in forms

        :param repo_name:

        """

        repo_info = Repository.get_by_repo_name(repo_name)

        if repo_info is None:

            return None

        defaults = repo_info.get_dict()

        defaults['repo_name'] = repo_name

        defaults['repo_group'] = getattr(group[-1] if group else None,

                                         'group_id', None)

        for strip, k in [(0, 'repo_type'), (1, 'repo_enable_downloads'),

                  (1, 'repo_description'), (1, 'repo_enable_locking'),

                  (1, 'repo_landing_rev'), (0, 'clone_uri'),

                  (1, 'repo_private'), (1, 'repo_enable_statistics')]:

            attr = k

            if strip:

                attr = remove_prefix(k, 'repo_')

            defaults[k] = defaults[attr]

        # fill owner

        if repo_info.user:

            defaults.update({'user': repo_info.user.username})

        else:

            replacement_user = User.query().filter(User.admin ==

                                                   True).first().username

            defaults.update({'user': replacement_user})

        # fill repository users

        for p in repo_info.repo_to_perm:

            defaults.update({'u_perm_%s' % p.user.username:

                             p.permission.permission_name})

        # fill repository groups

        for p in repo_info.users_group_to_perm:

            defaults.update({'g_perm_%s' % p.users_group.users_group_name:

                             p.permission.permission_name})

        return defaults

    def update(self, org_repo_name, **kwargs):

        try:

            cur_repo = self.get_by_repo_name(org_repo_name, cache=False)

            # update permissions

            for member, perm, member_type in kwargs['perms_updates']:

                if member_type == 'user':

                    # this updates existing one

                    RepoModel().grant_user_permission(

                        repo=cur_repo, user=member, perm=perm

                    )

                else:

                    RepoModel().grant_users_group_permission(

                        repo=cur_repo, group_name=member, perm=perm

    </div>

</%def>

<%def name="context_bar(current=None)">

   %if c.repo_name:

    ${repo_context_bar(current)}

   %endif

</%def>

<%def name="admin_menu()">

  <ul class="admin_menu">

      <li>${h.link_to(_('admin journal'),h.url('admin_home'),class_='journal ')}</li>

      <li>${h.link_to(_('repositories'),h.url('repos'),class_='repos')}</li>

      <li>${h.link_to(_('repository groups'),h.url('repos_groups'),class_='repos_groups')}</li>

      <li>${h.link_to(_('users'),h.url('users'),class_='users')}</li>

      <li>${h.link_to(_('user groups'),h.url('users_groups'),class_='groups')}</li>

      <li>${h.link_to(_('permissions'),h.url('edit_permission',id='default'),class_='permissions')}</li>

      <li>${h.link_to(_('ldap'),h.url('ldap_home'),class_='ldap')}</li>

      <li>${h.link_to(_('defaults'),h.url('defaults'),class_='defaults')}</li>

      <li class="last">${h.link_to(_('settings'),h.url('admin_settings'),class_='settings')}</li>

  </ul>

</%def>

<%def name="admin_menu_simple()">

  <ul>

      <li>${h.link_to(_('repository groups'),h.url('repos_groups'),class_='repos_groups')}</li>

  </ul>

</%def>

<%def name="repo_context_bar(current=None)">

  <%

      def follow_class():

          if c.repository_following:

              return h.literal('following')

          else:

            return h.literal('follow')

  %>

  <%

    def is_current(selected):

        if selected == current:

            return h.literal('class="current"')

    %>

  <!--- CONTEXT BAR -->

  <div id="context-bar" class="box">

    <div id="context-top">

      <div id="breadcrumbs">

        ${h.link_to(_(u'Repositories'),h.url('home'))}

        ${h.repo_link(c.rhodecode_db_repo.groups_and_repo)}

      </div>

      ## TODO: this check feels wrong, it would be better to have a check for permissions

      ## also it feels like a job for the controller

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

        <ul id="context-actions" class="horizontal-list">

          <li>

           <button class="${follow_class()}" onclick="javascript:toggleFollowingRepo(this,${c.rhodecode_db_repo.repo_id},'${str(h.get_token())}');">

            <!--span class="icon show-follow follow"></span>

            <span class="icon show-following following"></span-->

            <span class="show-follow">${_('Follow')}</span>

            <span class="show-following">${_('Unfollow')}</span>

          </button>

          </li>

          <li><a href="${h.url('repo_fork_home',repo_name=c.repo_name)}" class="fork">${_('Fork')}</a></li>

          %if h.is_hg(c.rhodecode_repo):

          <li><a href="${h.url('pullrequest_home',repo_name=c.repo_name)}" class="pull-request">${_('Create Pull Request')}</a></li>

          %endif

        </ul>

      %endif

    </div>

    <div id="context-state">

      <ul id="context-pages" class="horizontal-list">

        <li ${is_current('summary')}><a href="${h.url('summary_home', repo_name=c.repo_name)}" class="summary">${_('Summary')}</a></li>

        <li ${is_current('changelog')}><a href="${h.url('changelog_home', repo_name=c.repo_name)}" class="changelogs">${_('Changelog')}</a></li>

        <li ${is_current('files')}><a href="${h.url('files_home', repo_name=c.repo_name)}" class="files"></span>${_('Files')}</a></li>

        <li ${is_current('switch-to')}>

          <a href="#" id="branch_tag_switcher_2" class="dropdown switch-to"></span>${_('Switch To')}</a>

          <ul id="switch_to_list_2" class="switch_to submenu">

            <li><a href="#">${_('loading...')}</a></li>

          </ul>

        </li>

        <li ${is_current('options')}>

          <a href="#" class="dropdown options"></span>${_('Options')}</a>

          <ul>

             %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):

               %if h.HasPermissionAll('hg.admin')('access settings on repository'):

                   <li>${h.link_to(_('Settings'),h.url('edit_repo',repo_name=c.repo_name),class_='settings')}</li>

               %else:

                   <li>${h.link_to(_('Settings'),h.url('repo_settings_home',repo_name=c.repo_name),class_='settings')}</li>

               %endif

             %endif

              %if c.rhodecode_db_repo.fork:

               <li>${h.link_to(_('Compare fork'),h.url('compare_url',repo_name=c.rhodecode_db_repo.fork.repo_name,org_ref_type='branch',org_ref='default',other_repo=c.repo_name,other_ref_type='branch',other_ref=request.GET.get('branch') or 'default'),class_='compare_request')}</li>

              %endif

              <li>${h.link_to(_('Lightweight changelog'),h.url('shortlog_home',repo_name=c.repo_name),class_='shortlog')}</li>

              <li>${h.link_to(_('Search'),h.url('search_repo',repo_name=c.repo_name),class_='search')}</li>