disabled api key for anonymous users, and added api_key to rss/atom links for other users

rhodecode/lib/auth.py

@@ -1,591 +1,591 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.auth
     ~~~~~~~~~~~~~~~~~~
     
     authentication and permission libraries
     
     :created_on: Apr 4, 2010
     :copyright: (c) 2010 by marcink.
     :license: LICENSE_NAME, see LICENSE_FILE for more details.
 """
 # 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; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # 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, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 
 import random
 import logging
 import traceback
 import hashlib
 
 from tempfile import _RandomNameSequence
 from decorator import decorator
 
 from pylons import config, session, url, request
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 
 from rhodecode import __platform__
 
 if __platform__ == 'Windows':
     from hashlib import sha256
 if __platform__ in ('Linux', 'Darwin'):
     import bcrypt
 
 
 from rhodecode.lib.exceptions import LdapPasswordError, LdapUsernameError
 from rhodecode.lib.utils import get_repo_slug
 from rhodecode.lib.auth_ldap import AuthLdap
 
 from rhodecode.model import meta
 from rhodecode.model.user import UserModel
 from rhodecode.model.db import Permission
 
 
 log = logging.getLogger(__name__)
 
 class PasswordGenerator(object):
     """This is a simple class for generating password from
         different sets of characters
         usage:
         passwd_gen = PasswordGenerator()
         #print 8-letter password containing only big and small letters of alphabet
         print passwd_gen.gen_password(8, passwd_gen.ALPHABETS_BIG_SMALL)        
     """
     ALPHABETS_NUM = r'''1234567890'''#[0]
     ALPHABETS_SMALL = r'''qwertyuiopasdfghjklzxcvbnm'''#[1]
     ALPHABETS_BIG = r'''QWERTYUIOPASDFGHJKLZXCVBNM'''#[2]
     ALPHABETS_SPECIAL = r'''`-=[]\;',./~!@#$%^&*()_+{}|:"<>?'''    #[3]
     ALPHABETS_FULL = ALPHABETS_BIG + ALPHABETS_SMALL + ALPHABETS_NUM + ALPHABETS_SPECIAL#[4]
     ALPHABETS_ALPHANUM = ALPHABETS_BIG + ALPHABETS_SMALL + ALPHABETS_NUM#[5]
     ALPHABETS_BIG_SMALL = ALPHABETS_BIG + ALPHABETS_SMALL
     ALPHABETS_ALPHANUM_BIG = ALPHABETS_BIG + ALPHABETS_NUM#[6]
     ALPHABETS_ALPHANUM_SMALL = ALPHABETS_SMALL + ALPHABETS_NUM#[7]
 
     def __init__(self, passwd=''):
         self.passwd = passwd
 
     def gen_password(self, len, type):
         self.passwd = ''.join([random.choice(type) for _ in xrange(len)])
         return self.passwd
 
 class RhodeCodeCrypto(object):
 
     @classmethod
     def hash_string(cls, str_):
         """
         Cryptographic function used for password hashing based on pybcrypt
         or pycrypto in windows
         
         :param password: password to hash
         """
         if __platform__ == 'Windows':
             return sha256(str_).hexdigest()
         elif __platform__ in ('Linux', 'Darwin'):
             return bcrypt.hashpw(str_, bcrypt.gensalt(10))
         else:
             raise Exception('Unknown or unsupoprted platform %s' % __platform__)
 
     @classmethod
     def hash_check(cls, password, hashed):
         """
         Checks matching password with it's hashed value, runs different
         implementation based on platform it runs on
         
         :param password: password
         :param hashed: password in hashed form
         """
 
         if __platform__ == 'Windows':
             return sha256(password).hexdigest() == hashed
         elif __platform__ in ('Linux', 'Darwin'):
             return bcrypt.hashpw(password, hashed) == hashed
         else:
             raise Exception('Unknown or unsupoprted platform %s' % __platform__)
 
 
 
 
 
 def get_crypt_password(password):
     return RhodeCodeCrypto.hash_string(password)
 
 def check_password(password, hashed):
     return RhodeCodeCrypto.hash_check(password, hashed)
 
 def generate_api_key(username, salt=None):
     if salt is None:
         salt = _RandomNameSequence().next()
 
     return hashlib.sha1(username + salt).hexdigest()
 
 def authfunc(environ, username, password):
     """Dummy authentication function used in Mercurial/Git/ and access control,
     
     :param environ: needed only for using in Basic auth
     """
     return authenticate(username, password)
 
 
 def authenticate(username, password):
     """Authentication function used for access control,
     firstly checks for db authentication then if ldap is enabled for ldap
     authentication, also creates ldap user if not in database
     
     :param username: username
     :param password: password
     """
     user_model = UserModel()
     user = user_model.get_by_username(username, cache=False)
 
     log.debug('Authenticating user using RhodeCode account')
     if user is not None and not user.ldap_dn:
         if user.active:
 
             if user.username == 'default' and user.active:
                 log.info('user %s authenticated correctly as anonymous user',
                          username)
                 return True
 
             elif user.username == username and check_password(password, user.password):
                 log.info('user %s authenticated correctly', username)
                 return True
         else:
             log.warning('user %s is disabled', username)
 
     else:
         log.debug('Regular authentication failed')
         user_obj = user_model.get_by_username(username, cache=False,
                                             case_insensitive=True)
 
         if user_obj is not None and not user_obj.ldap_dn:
             log.debug('this user already exists as non ldap')
             return False
 
         from rhodecode.model.settings import SettingsModel
         ldap_settings = SettingsModel().get_ldap_settings()
 
         #======================================================================
         # FALLBACK TO LDAP AUTH IF ENABLE                
         #======================================================================
         if ldap_settings.get('ldap_active', False):
             log.debug("Authenticating user using ldap")
             kwargs = {
                   'server':ldap_settings.get('ldap_host', ''),
                   'base_dn':ldap_settings.get('ldap_base_dn', ''),
                   'port':ldap_settings.get('ldap_port'),
                   'bind_dn':ldap_settings.get('ldap_dn_user'),
                   'bind_pass':ldap_settings.get('ldap_dn_pass'),
                   'use_ldaps':ldap_settings.get('ldap_ldaps'),
                   'tls_reqcert':ldap_settings.get('ldap_tls_reqcert'),
                   'ldap_filter':ldap_settings.get('ldap_filter'),
                   'search_scope':ldap_settings.get('ldap_search_scope'),
                   'attr_login':ldap_settings.get('ldap_attr_login'),
                   'ldap_version':3,
                   }
             log.debug('Checking for ldap authentication')
             try:
                 aldap = AuthLdap(**kwargs)
                 (user_dn, ldap_attrs) = aldap.authenticate_ldap(username, password)
                 log.debug('Got ldap DN response %s', user_dn)
 
                 user_attrs = {
                     'name'     : ldap_attrs[ldap_settings.get('ldap_attr_firstname')][0],
                     'lastname' : ldap_attrs[ldap_settings.get('ldap_attr_lastname')][0],
                     'email'    : ldap_attrs[ldap_settings.get('ldap_attr_email')][0],
                     }
 
                 if user_model.create_ldap(username, password, user_dn, user_attrs):
                     log.info('created new ldap user %s', username)
 
                 return True
             except (LdapUsernameError, LdapPasswordError,):
                 pass
             except (Exception,):
                 log.error(traceback.format_exc())
                 pass
     return False
 
 class  AuthUser(object):
     """
     A simple object that handles all attributes of user in RhodeCode
     
     It does lookup based on API key,given user, or user present in session
     Then it fills all required information for such user. It also checks if 
     anonymous access is enabled and if so, it returns default user as logged
     in
     """
 
     def __init__(self, user_id=None, api_key=None):
 
         self.user_id = user_id
         self.api_key = None
 
         self.username = 'None'
         self.name = ''
         self.lastname = ''
         self.email = ''
         self.is_authenticated = False
         self.admin = False
         self.permissions = {}
         self._api_key = api_key
         self.propagate_data()
 
 
     def propagate_data(self):
         user_model = UserModel()
         self.anonymous_user = user_model.get_by_username('default', cache=True)
-        if self._api_key:
+        if self._api_key and self._api_key != self.anonymous_user.api_key:
             #try go get user by api key
             log.debug('Auth User lookup by API KEY %s', self._api_key)
             user_model.fill_data(self, api_key=self._api_key)
         else:
             log.debug('Auth User lookup by USER ID %s', self.user_id)
             if self.user_id is not None and self.user_id != self.anonymous_user.user_id:
                 user_model.fill_data(self, user_id=self.user_id)
             else:
                 if self.anonymous_user.active is True:
                     user_model.fill_data(self, user_id=self.anonymous_user.user_id)
                     #then we set this user is logged in
                     self.is_authenticated = True
                 else:
                     self.is_authenticated = False
 
         log.debug('Auth User is now %s', self)
         user_model.fill_perms(self)
 
     @property
     def is_admin(self):
         return self.admin
 
     def __repr__(self):
         return "<AuthUser('id:%s:%s|%s')>" % (self.user_id, self.username,
                                               self.is_authenticated)
 
     def set_authenticated(self, authenticated=True):
 
         if self.user_id != self.anonymous_user.user_id:
             self.is_authenticated = authenticated
 
 
 def set_available_permissions(config):
     """This function will propagate pylons globals with all available defined
     permission given in db. We don't want to check each time from db for new 
     permissions since adding a new permission also requires application restart
     ie. to decorate new views with the newly created permission
     
     :param config: current pylons config instance
     
     """
     log.info('getting information about all available permissions')
     try:
         sa = meta.Session()
         all_perms = sa.query(Permission).all()
     except:
         pass
     finally:
         meta.Session.remove()
 
     config['available_permissions'] = [x.permission_name for x in all_perms]
 
 #===============================================================================
 # CHECK DECORATORS
 #===============================================================================
 class LoginRequired(object):
     """
     Must be logged in to execute this function else 
     redirect to login page
     
     :param api_access: if enabled this checks only for valid auth token
         and grants access based on valid token
     """
 
     def __init__(self, api_access=False):
         self.api_access = api_access
 
     def __call__(self, func):
         return decorator(self.__wrapper, func)
 
     def __wrapper(self, func, *fargs, **fkwargs):
         cls = fargs[0]
         user = cls.rhodecode_user
 
         api_access_ok = False
         if self.api_access:
             log.debug('Checking API KEY access for %s', cls)
             if user.api_key == request.GET.get('api_key'):
                 api_access_ok = True
             else:
                 log.debug("API KEY token not valid")
 
         log.debug('Checking if %s is authenticated @ %s', user.username, cls)
         if user.is_authenticated or api_access_ok:
             log.debug('user %s is authenticated', user.username)
             return func(*fargs, **fkwargs)
         else:
             log.warn('user %s NOT authenticated', user.username)
 
             p = ''
             if request.environ.get('SCRIPT_NAME') != '/':
                 p += request.environ.get('SCRIPT_NAME')
 
             p += request.environ.get('PATH_INFO')
             if request.environ.get('QUERY_STRING'):
                 p += '?' + request.environ.get('QUERY_STRING')
 
             log.debug('redirecting to login page with %s', p)
             return redirect(url('login_home', came_from=p))
 
 class NotAnonymous(object):
     """Must be logged in to execute this function else 
     redirect to login page"""
 
     def __call__(self, func):
         return decorator(self.__wrapper, func)
 
     def __wrapper(self, func, *fargs, **fkwargs):
         cls = fargs[0]
         self.user = cls.rhodecode_user
 
         log.debug('Checking if user is not anonymous @%s', cls)
 
         anonymous = self.user.username == 'default'
 
         if anonymous:
             p = ''
             if request.environ.get('SCRIPT_NAME') != '/':
                 p += request.environ.get('SCRIPT_NAME')
 
             p += request.environ.get('PATH_INFO')
             if request.environ.get('QUERY_STRING'):
                 p += '?' + request.environ.get('QUERY_STRING')
 
             import rhodecode.lib.helpers as h
             h.flash(_('You need to be a registered user to perform this action'),
                     category='warning')
             return redirect(url('login_home', came_from=p))
         else:
             return func(*fargs, **fkwargs)
 
 class PermsDecorator(object):
     """Base class for controller decorators"""
 
     def __init__(self, *required_perms):
         available_perms = config['available_permissions']
         for perm in required_perms:
             if perm not in available_perms:
                 raise Exception("'%s' permission is not defined" % perm)
         self.required_perms = set(required_perms)
         self.user_perms = None
 
     def __call__(self, func):
         return decorator(self.__wrapper, func)
 
 
     def __wrapper(self, func, *fargs, **fkwargs):
         cls = fargs[0]
         self.user = cls.rhodecode_user
         self.user_perms = self.user.permissions
         log.debug('checking %s permissions %s for %s %s',
            self.__class__.__name__, self.required_perms, cls,
                self.user)
 
         if self.check_permissions():
             log.debug('Permission granted for %s %s', cls, self.user)
             return func(*fargs, **fkwargs)
 
         else:
             log.warning('Permission denied for %s %s', cls, self.user)
             #redirect with forbidden ret code
             return abort(403)
 
 
 
     def check_permissions(self):
         """Dummy function for overriding"""
         raise Exception('You have to write this function in child class')
 
 class HasPermissionAllDecorator(PermsDecorator):
     """Checks for access permission for all given predicates. All of them 
     have to be meet in order to fulfill the request
     """
 
     def check_permissions(self):
         if self.required_perms.issubset(self.user_perms.get('global')):
             return True
         return False
 
 
 class HasPermissionAnyDecorator(PermsDecorator):
     """Checks for access permission for any of given predicates. In order to 
     fulfill the request any of predicates must be meet
     """
 
     def check_permissions(self):
         if self.required_perms.intersection(self.user_perms.get('global')):
             return True
         return False
 
 class HasRepoPermissionAllDecorator(PermsDecorator):
     """Checks for access permission for all given predicates for specific 
     repository. All of them have to be meet in order to fulfill the request
     """
 
     def check_permissions(self):
         repo_name = get_repo_slug(request)
         try:
             user_perms = set([self.user_perms['repositories'][repo_name]])
         except KeyError:
             return False
         if self.required_perms.issubset(user_perms):
             return True
         return False
 
 
 class HasRepoPermissionAnyDecorator(PermsDecorator):
     """Checks for access permission for any of given predicates for specific 
     repository. In order to fulfill the request any of predicates must be meet
     """
 
     def check_permissions(self):
         repo_name = get_repo_slug(request)
 
         try:
             user_perms = set([self.user_perms['repositories'][repo_name]])
         except KeyError:
             return False
         if self.required_perms.intersection(user_perms):
             return True
         return False
 #===============================================================================
 # CHECK FUNCTIONS
 #===============================================================================
 
 class PermsFunction(object):
     """Base function for other check functions"""
 
     def __init__(self, *perms):
         available_perms = config['available_permissions']
 
         for perm in perms:
             if perm not in available_perms:
                 raise Exception("'%s' permission in not defined" % perm)
         self.required_perms = set(perms)
         self.user_perms = None
         self.granted_for = ''
         self.repo_name = None
 
     def __call__(self, check_Location=''):
         user = session.get('rhodecode_user', False)
         if not user:
             return False
         self.user_perms = user.permissions
         self.granted_for = user
         log.debug('checking %s %s %s', self.__class__.__name__,
                   self.required_perms, user)
 
         if self.check_permissions():
             log.debug('Permission granted %s @ %s', self.granted_for,
                       check_Location or 'unspecified location')
             return True
 
         else:
             log.warning('Permission denied for %s @ %s', self.granted_for,
                         check_Location or 'unspecified location')
             return False
 
     def check_permissions(self):
         """Dummy function for overriding"""
         raise Exception('You have to write this function in child class')
 
 class HasPermissionAll(PermsFunction):
     def check_permissions(self):
         if self.required_perms.issubset(self.user_perms.get('global')):
             return True
         return False
 
 class HasPermissionAny(PermsFunction):
     def check_permissions(self):
         if self.required_perms.intersection(self.user_perms.get('global')):
             return True
         return False
 
 class HasRepoPermissionAll(PermsFunction):
 
     def __call__(self, repo_name=None, check_Location=''):
         self.repo_name = repo_name
         return super(HasRepoPermissionAll, self).__call__(check_Location)
 
     def check_permissions(self):
         if not self.repo_name:
             self.repo_name = get_repo_slug(request)
 
         try:
             self.user_perms = set([self.user_perms['repositories']\
                                    [self.repo_name]])
         except KeyError:
             return False
         self.granted_for = self.repo_name
         if self.required_perms.issubset(self.user_perms):
             return True
         return False
 
 class HasRepoPermissionAny(PermsFunction):
 
     def __call__(self, repo_name=None, check_Location=''):
         self.repo_name = repo_name
         return super(HasRepoPermissionAny, self).__call__(check_Location)
 
     def check_permissions(self):
         if not self.repo_name:
             self.repo_name = get_repo_slug(request)
 
         try:
             self.user_perms = set([self.user_perms['repositories']\
                                    [self.repo_name]])
         except KeyError:
             return False
         self.granted_for = self.repo_name
         if self.required_perms.intersection(self.user_perms):
             return True
         return False
 
 #===============================================================================
 # SPECIAL VERSION TO HANDLE MIDDLEWARE AUTH
 #===============================================================================
 
 class HasPermissionAnyMiddleware(object):
     def __init__(self, *perms):
         self.required_perms = set(perms)
 
     def __call__(self, user, repo_name):
         usr = AuthUser(user.user_id)
         try:
             self.user_perms = set([usr.permissions['repositories'][repo_name]])
         except:
             self.user_perms = set()
         self.granted_for = ''
         self.username = user.username
         self.repo_name = repo_name
         return self.check_permissions()
 
     def check_permissions(self):
         log.debug('checking mercurial protocol '
                   'permissions %s for user:%s repository:%s', self.user_perms,
                                                 self.username, self.repo_name)
         if self.required_perms.intersection(self.user_perms):
             log.debug('permission granted')
             return True
         log.debug('permission denied')
         return False

rhodecode/templates/index.html

@@ -1,168 +1,176 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="base/base.html"/>
 <%def name="title()">
     ${_('Dashboard')} - ${c.rhodecode_name}
 </%def>
 <%def name="breadcrumbs()">
 	${c.rhodecode_name}
 </%def>
 <%def name="page_nav()">
 	${self.menu('home')}
 </%def>
 <%def name="main()">
 	<%def name="get_sort(name)">
 		<%name_slug = name.lower().replace(' ','_') %>
 		
 		%if name_slug == c.sort_slug:
 		  %if c.sort_by.startswith('-'):
 		    <a href="?sort=${name_slug}">${name}&uarr;</a>
 		  %else:
 		    <a href="?sort=-${name_slug}">${name}&darr;</a>
 		  %endif:
 		%else:
 		    <a href="?sort=${name_slug}">${name}</a>
 		%endif
 	</%def>
 	
     <div class="box">
 	    <!-- box / title -->
 	    <div class="title">
 	        <h5>${_('Dashboard')}
 	        <input class="top-right-rounded-corner top-left-rounded-corner bottom-left-rounded-corner bottom-right-rounded-corner" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/>
 	        </h5>
 	        %if c.rhodecode_user.username != 'default':
 		        %if h.HasPermissionAny('hg.admin','hg.create.repository')():
 		        <ul class="links">
 		          <li>
 		            <span>${h.link_to(_('ADD NEW REPOSITORY'),h.url('admin_settings_create_repository'))}</span>
 		          </li>          
 		        </ul>  	        
 		        %endif
 		    %endif
 	    </div>
 	    <!-- end box / title -->
         <div class="table">
             <table>
             <thead>
 	            <tr>
 			        <th class="left">${get_sort(_('Name'))}</th>
 			        <th class="left">${get_sort(_('Description'))}</th>
 			        <th class="left">${get_sort(_('Last change'))}</th>
 			        <th class="left">${get_sort(_('Tip'))}</th>
 			        <th class="left">${get_sort(_('Owner'))}</th>
 			        <th class="left">${_('RSS')}</th>
 			        <th class="left">${_('Atom')}</th>
 	            </tr>
             </thead>
             <tbody>
 		    %for cnt,repo in enumerate(c.repos_list):
 		        <tr class="parity${cnt%2}">
 		            <td>
 		            <div style="white-space: nowrap">
 		             ## TYPE OF REPO
 		             %if repo['dbrepo']['repo_type'] =='hg':
 		               <img class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="${h.url("/images/icons/hgicon.png")}"/>
 		             %elif repo['dbrepo']['repo_type'] =='git':
 		               <img class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="${h.url("/images/icons/giticon.png")}"/>
 		             %else:
 		               
 		             %endif 
 		            
 		             ##PRIVATE/PUBLIC
 		             %if repo['dbrepo']['private']:
 		                <img class="icon" title="${_('private repository')}" alt="${_('private repository')}" src="${h.url("/images/icons/lock.png")}"/>
 		             %else:
 		                <img class="icon" title="${_('public repository')}" alt="${_('public repository')}" src="${h.url("/images/icons/lock_open.png")}"/>
 		             %endif
 		            
 		            ##NAME   
 		            ${h.link_to(repo['name'],
 		                h.url('summary_home',repo_name=repo['name']),class_="repo_name")}
 		            %if repo['dbrepo_fork']:
 		            	<a href="${h.url('summary_home',repo_name=repo['dbrepo_fork']['repo_name'])}">
 		            	<img class="icon" alt="${_('fork')}"
 		            	title="${_('Fork of')} ${repo['dbrepo_fork']['repo_name']}" 
 		            	src="${h.url("/images/icons/arrow_divide.png")}"/></a>
 		            %endif
 		            </div>
 		            </td>
 		            ##DESCRIPTION
 		            <td><span class="tooltip" title="${h.tooltip(repo['description'])}">
 		               ${h.truncate(repo['description'],60)}</span>
 		            </td>
 		            ##LAST CHANGE
 		            <td>
 		              <span class="tooltip" title="${repo['last_change']}">
 		              ${h.age(repo['last_change'])}</span>
 		            </td>
 		            <td>
 		            	%if repo['rev']>=0:
 		            	${h.link_to('r%s:%s' % (repo['rev'],h.short_id(repo['tip'])),
 		                h.url('changeset_home',repo_name=repo['name'],revision=repo['tip']),
 		                class_="tooltip",
 		                title=h.tooltip(repo['last_msg']))}
 		            	%else:
 		            		${_('No changesets yet')}
 		            	%endif    
 		            </td>
 		            <td title="${repo['contact']}">${h.person(repo['contact'])}</td>
 		            <td>
+		              %if c.rhodecode_user.username != 'default':
+		                <a title="${_('Subscribe to %s rss feed')%repo['name']}" class="rss_icon"  href="${h.url('rss_feed_home',repo_name=repo['name'],api_key=c.rhodecode_user.api_key)}"></a>
+                      %else:
 		                <a title="${_('Subscribe to %s rss feed')%repo['name']}" class="rss_icon"  href="${h.url('rss_feed_home',repo_name=repo['name'])}"></a>
+                      %endif:		                
 		            </td>        
 		            <td>
+		              %if c.rhodecode_user.username != 'default':
+		                <a title="${_('Subscribe to %s atom feed')%repo['name']}"  class="atom_icon" href="${h.url('atom_feed_home',repo_name=repo['name'],api_key=c.rhodecode_user.api_key)}"></a>
+		              %else:
 		                <a title="${_('Subscribe to %s atom feed')%repo['name']}"  class="atom_icon" href="${h.url('atom_feed_home',repo_name=repo['name'])}"></a>
+		              %endif:
 		            </td>
 		        </tr>
 		    %endfor
             </tbody>
             </table>
             </div>
     </div>
     
     
     <script type="text/javascript">
      var D = YAHOO.util.Dom;
      var E = YAHOO.util.Event;
      var S = YAHOO.util.Selector;
      
      var q_filter = D.get('q_filter');
      var F = YAHOO.namespace('q_filter'); 
      
      E.on(q_filter,'click',function(){
     	q_filter.value = '';
      });
 
      F.filterTimeout = null;
      
      F.updateFilter  = function() { 
     	// Reset timeout 
         F.filterTimeout = null;
     	
         var obsolete = [];
         var nodes = S.query('div.table tr td div a.repo_name');
         var req = D.get('q_filter').value;
         for (n in nodes){
             D.setStyle(nodes[n].parentNode.parentNode.parentNode,'display','')
         }
         if (req){
 	        for (n in nodes){
 	        	if (nodes[n].innerHTML.toLowerCase().indexOf(req) == -1) {
 	        		obsolete.push(nodes[n]); 
 	        	}
 	    	}
 	        if(obsolete){
 		        for (n in obsolete){
 		        	D.setStyle(obsolete[n].parentNode.parentNode.parentNode,'display','none');
 		        }
 	        }
         }
      }
      
      E.on(q_filter,'keyup',function(e){
     	 clearTimeout(F.filterTimeout); 
     	 setTimeout(F.updateFilter,600); 
      });
      
     </script>
     	
 </%def>    

rhodecode/templates/summary/summary.html

@@ -1,684 +1,689 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('Summary')} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(u'Home',h.url('/'))}
     &raquo; 
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('summary')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('summary')}    
 </%def>
 
 <%def name="main()">
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
 	<div class="form">
 	  <div class="fields">
 		 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Name')}:</label>
 			  </div>
 			  <div class="input-short">
 		         %if c.dbrepo.repo_type =='hg':
 		           <img style="margin-bottom:2px" class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="${h.url("/images/icons/hgicon.png")}"/>
 		         %endif
 		         %if c.dbrepo.repo_type =='git':
 		           <img style="margin-bottom:2px" class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="${h.url("/images/icons/giticon.png")}"/>
 		         %endif 
                                  			  
 	             %if c.dbrepo.private:
 	                <img style="margin-bottom:2px" class="icon" title="${_('private repository')}" alt="${_('private repository')}" src="${h.url("/images/icons/lock.png")}"/>
 	             %else:
 	                <img style="margin-bottom:2px" class="icon" title="${_('public repository')}" alt="${_('public repository')}" src="${h.url("/images/icons/lock_open.png")}"/>
 	             %endif
 			      <span style="font-size: 1.6em;font-weight: bold;vertical-align: baseline;">${c.repo.name}</span>
 			      %if c.rhodecode_user.username != 'default':
 				      %if c.following:
 	                  <span id="follow_toggle" class="following" title="${_('Stop following this repository')}"
 	                        onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">
 	                  </span>			      
 				      %else:
 				      <span id="follow_toggle" class="follow" title="${_('Start following this repository')}"
 				            onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">
 				      </span>
 				      %endif
 				  %endif:
 			      <br/>
 		            %if c.dbrepo.fork:
 		            	<span style="margin-top:5px">
 		            	<a href="${h.url('summary_home',repo_name=c.dbrepo.fork.repo_name)}">
 		            	<img class="icon" alt="${_('public')}"
 		            	title="${_('Fork of')} ${c.dbrepo.fork.repo_name}" 
 		            	src="${h.url("/images/icons/arrow_divide.png")}"/>
 		            	${_('Fork of')} ${c.dbrepo.fork.repo_name}
 		            	</a>
 		            	</span>
 		            %endif
 					%if c.dbrepo.clone_uri:
                         <span style="margin-top:5px">
                         <a href="${h.url(str(c.dbrepo.clone_uri))}">
                         <img class="icon" alt="${_('remote clone')}"
                         title="${_('Clone from')} ${c.dbrepo.clone_uri}" 
                         src="${h.url("/images/icons/connect.png")}"/>
                         ${_('Clone from')} ${c.dbrepo.clone_uri}
                         </a>
                         </span>					
 					%endif		            		      
 			  </div>
 			 </div>
 			
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Description')}:</label>
 			  </div>
 			  <div class="input-short">
 			      ${c.dbrepo.description}
 			  </div>
 			 </div>
 			
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Contact')}:</label>
 			  </div>
 			  <div class="input-short">
 			  	<div class="gravatar">
 			  		<img alt="gravatar" src="${h.gravatar_url(c.dbrepo.user.email)}"/>
 			  	</div>
 			  		${_('Username')}: ${c.dbrepo.user.username}<br/>
 			  		${_('Name')}: ${c.dbrepo.user.name} ${c.dbrepo.user.lastname}<br/>
 			  		${_('Email')}: <a href="mailto:${c.dbrepo.user.email}">${c.dbrepo.user.email}</a>
 			  </div>
 			 </div>
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Last change')}:</label>
 			  </div>
 			  <div class="input-short">
 			      ${h.age(c.repo.last_change)} - ${c.repo.last_change} 
 			      ${_('by')} ${h.get_changeset_safe(c.repo,'tip').author} 
 			      
 			  </div>
 			 </div>
 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Clone url')}:</label>
 			  </div>
 			  <div class="input-short">
 			      <input type="text" id="clone_url" readonly="readonly" value="hg clone ${c.clone_repo_url}" size="70"/>
 			  </div>
 			 </div>
 			 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Trending source files')}:</label>
 			  </div>
 			  <div class="input-short">
 			    <div id="lang_stats"></div> 			   
 			  </div>
 			 </div>
 			 			
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Download')}:</label>
 			  </div>
 			  <div class="input-short">
 		        %if len(c.repo.revisions) == 0:
 		          ${_('There are no downloads yet')}
 		        %elif c.enable_downloads is False:
 		          ${_('Downloads are disabled for this repository')}
                     %if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
                         [${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name))}]
                     %endif  		          
 		        %else:
 			        ${h.select('download_options',c.repo.get_changeset().raw_id,c.download_options)}
 			        %for cnt,archive in enumerate(c.repo._get_archives()):
 			             %if cnt >=1:
 			             |
 			             %endif
 			             <span class="tooltip" title="${_('Download %s as %s') %('tip',archive['type'])}" 
 			                  id="${archive['type']+'_link'}">${h.link_to(archive['type'],
 			                h.url('files_archive_home',repo_name=c.repo.name,
 			                fname='tip'+archive['extension']),class_="archive_icon")}</span>
 			        %endfor
 			    %endif
 			  </div>
 			 </div>
 			 
 			 <div class="field">
 			  <div class="label">
 			      <label>${_('Feeds')}:</label>
 			  </div>
 			  <div class="input-short">
-	            ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.repo.name),class_='rss_icon')}
+			   %if c.rhodecode_user.username != 'default':
+	            ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.repo.name,api_key=c.rhodecode_user.api_key),class_='rss_icon')}
+	            ${h.link_to(_('Atom'),h.url('atom_feed_home',repo_name=c.repo.name,api_key=c.rhodecode_user.api_key),class_='atom_icon')}
+	           %else:
+                ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.repo.name,class_='rss_icon')}
 	            ${h.link_to(_('Atom'),h.url('atom_feed_home',repo_name=c.repo.name),class_='atom_icon')}
+	           %endif 
 			  </div>
 			 </div>				 			 			 
 	  </div>		 
 	</div>
   	<script type="text/javascript">
 	  	YUE.onDOMReady(function(e){
 	  	    id = 'clone_url';
 	  	    YUE.on(id,'click',function(e){
 	  	        YUD.get('clone_url').select();
 	  	    })
 	  	})
   		var data = ${c.trending_languages|n};
   		var total = 0;
   		var no_data = true;
   		for (k in data){
   		    total += data[k];
   		    no_data = false;
   		} 
 		var tbl = document.createElement('table');
 		tbl.setAttribute('class','trending_language_tbl');
 		var cnt =0;
   		for (k in data){
   			cnt+=1;
   			var hide = cnt>2;
 	  		var tr = document.createElement('tr');
 	  		if (hide){
 	  			tr.setAttribute('style','display:none');
 	  			tr.setAttribute('class','stats_hidden');
 	  		}
 	  		var percentage = Math.round((data[k]/total*100),2);
 			var value = data[k];
 	  		var td1 = document.createElement('td');
 	  		td1.width=150;
 	  		var trending_language_label = document.createElement('div');
 	  		trending_language_label.innerHTML = k;
 	  		td1.appendChild(trending_language_label);
 
 	  		var td2 = document.createElement('td');
 	  		td2.setAttribute('style','padding-right:14px !important');
   		    var trending_language = document.createElement('div');
   		    var nr_files = value+" ${_('files')}";
   		    
   		    trending_language.title = k+" "+nr_files;
   		    
   		    if (percentage>20){
   		    	trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"% "+nr_files+ "</b>";	
   		    }
   		    else{
   		    	trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"%</b>";
   		    }
   		    
   		    trending_language.setAttribute("class", 'trending_language top-right-rounded-corner bottom-right-rounded-corner');
   		    trending_language.style.width=percentage+"%";
 			td2.appendChild(trending_language);
 			
 			tr.appendChild(td1);
 			tr.appendChild(td2);
   		    tbl.appendChild(tr);
   		    if(cnt == 2){
   		    	var show_more = document.createElement('tr');
   		    	var td=document.createElement('td');
   		    	lnk = document.createElement('a');
   		    	lnk.href='#';
   		    	lnk.innerHTML = "${_("show more")}";
   		    	lnk.id='code_stats_show_more';
   		        td.appendChild(lnk);
   		    	show_more.appendChild(td);
   		    	show_more.appendChild(document.createElement('td'));
   		    	tbl.appendChild(show_more);
   		    }
   		    
   		}
   		if(no_data){
   			var tr = document.createElement('tr');
   			var td1 = document.createElement('td');
   			td1.innerHTML = "${c.no_data_msg}";
   			tr.appendChild(td1);
   			tbl.appendChild(tr);
 		}
   		YUD.get('lang_stats').appendChild(tbl);
   		YUE.on('code_stats_show_more','click',function(){
   			l = YUD.getElementsByClassName('stats_hidden')
   			for (e in l){
   			    YUD.setStyle(l[e],'display','');
   			};
   			YUD.setStyle(YUD.get('code_stats_show_more'),
   					'display','none');
   		})
   	
              
              YUE.on('download_options','change',function(e){
                  var new_cs = e.target.options[e.target.selectedIndex];
                  var tmpl_links = {}
                  %for cnt,archive in enumerate(c.repo._get_archives()):
                 	 tmpl_links['${archive['type']}'] = '${h.link_to(archive['type'],
                         h.url('files_archive_home',repo_name=c.repo.name,
                         fname='__CS__'+archive['extension']),class_="archive_icon")}';
                  %endfor
                 
                  
                  for(k in tmpl_links){
                 	 var s = YUD.get(k+'_link')
                 	 title_tmpl = "${_('Download %s as %s') % ('__CS_NAME__',archive['type'])}";
                 	 s.title = title_tmpl.replace('__CS_NAME__',new_cs.text)
                 	 s.innerHTML = tmpl_links[k].replace('__CS__',new_cs.value);
                  }
                  
              })
              	
   	</script>    				
 </div>
         
 <div class="box box-right"  style="min-height:455px">
     <!-- box / title -->
     <div class="title">
         <h5>${_('Commit activity by day / author')}</h5>
     </div>
     
     <div class="table">
          %if c.no_data:
            <div style="padding:0 10px 10px 15px;font-size: 1.2em;">${c.no_data_msg}
            %if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
                 [${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name))}]
            %endif         
            </div>
         %endif:  
         <div id="commit_history" style="width:460px;height:300px;float:left"></div>
         <div style="clear: both;height: 10px"></div>
         <div id="overview" style="width:460px;height:100px;float:left"></div>
         
     	<div id="legend_data" style="clear:both;margin-top:10px;">
 	    	<div id="legend_container"></div>
 	    	<div id="legend_choices">
 				<table id="legend_choices_tables" style="font-size:smaller;color:#545454"></table>
 	    	</div>
     	</div>
 		<script type="text/javascript">
 		/**
 		 * Plots summary graph
 		 *
 		 * @class SummaryPlot
 		 * @param {from} initial from for detailed graph
 		 * @param {to} initial to for detailed graph
 		 * @param {dataset}
 		 * @param {overview_dataset}
 		 */
 		function SummaryPlot(from,to,dataset,overview_dataset) {
 			var initial_ranges = {
 			    "xaxis":{
 				    "from":from,
 				   	"to":to,
 				},
 			};
 		    var dataset = dataset;
 		    var overview_dataset = [overview_dataset];
 		    var choiceContainer = YUD.get("legend_choices");
 		    var choiceContainerTable = YUD.get("legend_choices_tables");
 		    var plotContainer = YUD.get('commit_history');
 		    var overviewContainer = YUD.get('overview');
 		    
 		    var plot_options = {
 				bars: {show:true,align:'center',lineWidth:4},
 				legend: {show:true, container:"legend_container"},
 				points: {show:true,radius:0,fill:false},
 				yaxis: {tickDecimals:0,},
 				xaxis: {
 					mode: "time", 
 					timeformat: "%d/%m",
 				    min:from,
 				    max:to,	
 				}, 
 				grid: {
 					hoverable: true, 
 				    clickable: true,
 				    autoHighlight:true,
 				    color: "#999"
 				},
 				//selection: {mode: "x"}
 		    };
 		    var overview_options = {
 				legend:{show:false},
 			    bars: {show:true,barWidth: 2,},
 			    shadowSize: 0,
 			    xaxis: {mode: "time", timeformat: "%d/%m/%y",},
 			    yaxis: {ticks: 3, min: 0,tickDecimals:0,},
 			    grid: {color: "#999",},
 			    selection: {mode: "x"}
 			};
 
 			/**
 			*get dummy data needed in few places
 			*/
 		    function getDummyData(label){
 		    	return {"label":label,
                	 "data":[{"time":0,
                		 "commits":0,
 	                     "added":0,
 	                     "changed":0,
 	                     "removed":0,
                     }],
                     "schema":["commits"],
                     "color":'#ffffff',
            		}
 			}
 			
 		    /**
 		     * generate checkboxes accordindly to data
 		     * @param keys
 		     * @returns
 		     */
 		    function generateCheckboxes(data) {
 			    //append checkboxes
 			    var i = 0;
 			    choiceContainerTable.innerHTML = '';
 			    for(var pos in data) {
 			    	
 			    	data[pos].color = i;
 			        i++;
 			        if(data[pos].label != ''){
 				        choiceContainerTable.innerHTML += '<tr><td>'+
 				        '<input type="checkbox" name="' + data[pos].label +'" checked="checked" />'
 				        +data[pos].label+
 				        '</td></tr>';
 			        }
 			    }	
 		    }
 		    
 		    /**
 		     * ToolTip show
 		     */
 		    function showTooltip(x, y, contents) {
 		        var div=document.getElementById('tooltip');
 		        if(!div) {
 		            div = document.createElement('div');
 		            div.id="tooltip";
 		            div.style.position="absolute";
 		            div.style.border='1px solid #fdd';
 		            div.style.padding='2px';
 		            div.style.backgroundColor='#fee';
 		            document.body.appendChild(div);
 		        }
 		        YUD.setStyle(div, 'opacity', 0);
 		        div.innerHTML = contents;
 		        div.style.top=(y + 5) + "px";
 		        div.style.left=(x + 5) + "px";
 
 		        var anim = new YAHOO.util.Anim(div, {opacity: {to: 0.8}}, 0.2);
 		        anim.animate();
 		    }
 		    
 			/**
 			 * This function will detect if selected period has some changesets 
 			   for this user if it does this data is then pushed for displaying
 			   Additionally it will only display users that are selected by the checkbox
 			*/
 		    function getDataAccordingToRanges(ranges) {
 		    	
 		        var data = [];
 		        var keys = [];
 				for(var key in dataset){
 					var push = false;
 					
 					//method1 slow !!
 		            //*
 		            for(var ds in dataset[key].data){
 			            commit_data = dataset[key].data[ds];
 			            if (commit_data.time >= ranges.xaxis.from && commit_data.time <= ranges.xaxis.to){
 			            	push = true;
 			            	break;
 					    }
 				    }
 					//*/
 				    
 				    /*//method2 sorted commit data !!!
 				    
 				    var first_commit = dataset[key].data[0].time;
 				    var last_commit = dataset[key].data[dataset[key].data.length-1].time;
 				    
 				    if (first_commit >= ranges.xaxis.from && last_commit <= ranges.xaxis.to){
 						push = true;
 					}
 				    //*/
 				    
 				    if(push){			
 				    	data.push(dataset[key]);
 				    }
 				}
 				if(data.length >= 1){
 					return data;
 				} 
 				else{
 					//just return dummy data for graph to plot itself
 					return [getDummyData('')];	
 				}
 				
 		    }
 		    
 			/**
 			* redraw using new checkbox data
 			*/
 		    function plotchoiced(e,args){
 			    var cur_data = args[0];
 			    var cur_ranges = args[1];
 		    	
 				var new_data = [];
 		    	var inputs = choiceContainer.getElementsByTagName("input");
 
 		    	//show only checked labels
 		        for(var i=0; i<inputs.length; i++) {
 		            var checkbox_key = inputs[i].name;
 		            
 	                if(inputs[i].checked){
 						for(var d in cur_data){
 							if(cur_data[d].label == checkbox_key){
 								new_data.push(cur_data[d]);
 							}
 						}			                
 	    	        }
 	                else{
 		                //push dummy data to not hide the label
 						new_data.push(getDummyData(checkbox_key));
 			        }
 		        }
 					        
 		    	var new_options = YAHOO.lang.merge(plot_options, {
 		            xaxis: { 
 		  	      		min: cur_ranges.xaxis.from, 
 		  	      		max: cur_ranges.xaxis.to,
 		  	      		mode:"time",
 		  	      		timeformat: "%d/%m",
 		        	},
 		    	});
 		    	if (!new_data){
 					new_data = [[0,1]];
 				}
 		    	// do the zooming
 		       plot = YAHOO.widget.Flot(plotContainer, new_data, new_options);
 		       
 		       plot.subscribe("plotselected", plotselected);
 	
 		       //resubscribe plothover
 		       plot.subscribe("plothover", plothover);
 		        
 		       // don't fire event on the overview to prevent eternal loop
 		       overview.setSelection(cur_ranges, true);
 	
 		    }
 		    
 			/**
 		     * plot only selected items from overview
 		     * @param ranges
 		     * @returns
 		     */
 		    function plotselected(ranges,cur_data) {
 			    //updates the data for new plot
 	    		data = getDataAccordingToRanges(ranges);
 	    		generateCheckboxes(data);
 	    		
 		    	var new_options = YAHOO.lang.merge(plot_options, {
 		            xaxis: { 
 		  	      		min: ranges.xaxis.from, 
 		  	      		max: ranges.xaxis.to,
 		  	      		mode:"time",
 		  	      		timeformat: "%d/%m",
 		        	},
 		        	yaxis: { 
                         min: ranges.yaxis.from, 
                         max: ranges.yaxis.to,
                     },
                     		        	
 		    	});
 		    	// do the zooming
 		        plot = YAHOO.widget.Flot(plotContainer, data, new_options);
 
 		        plot.subscribe("plotselected", plotselected);
 
 		        //resubscribe plothover
 		        plot.subscribe("plothover", plothover);
 		        
 		        // don't fire event on the overview to prevent eternal loop
 		        overview.setSelection(ranges, true);
 
 		        //resubscribe choiced
 		        YUE.on(choiceContainer.getElementsByTagName("input"), "click", plotchoiced, [data, ranges]);
 		    }
 		    
 		    var previousPoint = null;
 
 			function plothover(o) {
 		        var pos = o.pos;
 		        var item = o.item;
 		        
 		        //YUD.get("x").innerHTML = pos.x.toFixed(2);
 		        //YUD.get("y").innerHTML = pos.y.toFixed(2);
 		        if (item) {
 		            if (previousPoint != item.datapoint) {
 		                previousPoint = item.datapoint;
 		                
 		                var tooltip = YUD.get("tooltip");
 		                if(tooltip) {
 		                	  tooltip.parentNode.removeChild(tooltip);
 		                }
 		                var x = item.datapoint.x.toFixed(2);
 		                var y = item.datapoint.y.toFixed(2);
 						
 		                if (!item.series.label){
 		                    item.series.label = 'commits';
 		                }
 		                var d = new Date(x*1000);
 		                var fd = d.toDateString()
 		                var nr_commits = parseInt(y);
 		                
 		                var cur_data = dataset[item.series.label].data[item.dataIndex];
 		                var added = cur_data.added;
 		                var changed = cur_data.changed;
 		                var removed = cur_data.removed;
 		                
 		                var nr_commits_suffix = " ${_('commits')} ";
 		                var added_suffix = " ${_('files added')} ";
 		                var changed_suffix = " ${_('files changed')} ";
 		                var removed_suffix = " ${_('files removed')} ";
 
 		                
 		                if(nr_commits == 1){nr_commits_suffix = " ${_('commit')} ";}
 						if(added==1){added_suffix=" ${_('file added')} ";}
 						if(changed==1){changed_suffix=" ${_('file changed')} ";}
 						if(removed==1){removed_suffix=" ${_('file removed')} ";}
 										                
 		                showTooltip(item.pageX, item.pageY, item.series.label + " on " + fd
 								 +'<br/>'+
 		                         nr_commits + nr_commits_suffix+'<br/>'+
 		                         added + added_suffix +'<br/>'+
 		                         changed + changed_suffix + '<br/>'+
 		                         removed + removed_suffix + '<br/>');
 		            }
 		        }
 		        else {
 		        	  var tooltip = YUD.get("tooltip");
 		        	  
 			          if(tooltip) {
 			                tooltip.parentNode.removeChild(tooltip);
 			          }
 		            previousPoint = null;
 		        }
 		    }
 			
 		    /**
 		     * MAIN EXECUTION
 		     */
 			
 			var data = getDataAccordingToRanges(initial_ranges);
 			generateCheckboxes(data);
 			
 		    //main plot
 		    var plot = YAHOO.widget.Flot(plotContainer,data,plot_options);
 		    
 			//overview
 			var overview = YAHOO.widget.Flot(overviewContainer, overview_dataset, overview_options);
 			
 			//show initial selection on overview
 			overview.setSelection(initial_ranges);    
 			
 		    plot.subscribe("plotselected", plotselected);
 		    
 		    overview.subscribe("plotselected", function (ranges) {
 		        plot.setSelection(ranges);
 		    });		
 				
 		    plot.subscribe("plothover", plothover);
 
 		    YUE.on(choiceContainer.getElementsByTagName("input"), "click", plotchoiced, [data, initial_ranges]);
 		}
 			SummaryPlot(${c.ts_min},${c.ts_max},${c.commit_data|n},${c.overview_data|n});		
 		</script>
 
     </div>
 </div>    
 
 <div class="box">    
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Shortlog'),h.url('shortlog_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <div id="shortlog_data">
             <%include file='../shortlog/shortlog_data.html'/>
         </div>
         ##%if c.repo_changesets:
         ##	${h.link_to(_('show more'),h.url('changelog_home',repo_name=c.repo_name))}
         ##%endif
     </div>
 </div>
 <div class="box">    
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Tags'),h.url('tags_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <%include file='../tags/tags_data.html'/>
         %if c.repo_changesets:
         	${h.link_to(_('show more'),h.url('tags_home',repo_name=c.repo_name))}
         %endif
     </div>
 </div>
 <div class="box">
     <div class="title">
         <div class="breadcrumbs">${h.link_to(_('Branches'),h.url('branches_home',repo_name=c.repo_name))}</div>
     </div>    
     <div class="table">
         <%include file='../branches/branches_data.html'/>
         %if c.repo_changesets:
         	${h.link_to(_('show more'),h.url('branches_home',repo_name=c.repo_name))}
         %endif
     </div>      
 </div> 
 
 </%def>