try:

            log = cls.get_logger()

        except:

            log = logging.getLogger(__name__)

    else:

        log = logging.getLogger(__name__)

    return log

@task(ignore_result=True)

@locked_task

@dbsession

def whoosh_index(repo_location, full_index):

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    log = whoosh_index.get_logger(whoosh_index)

    DBS = get_session()

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location, sa=DBS)\

                         .run(full_index=full_index)

@task(ignore_result=True)

@dbsession

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    log = get_logger(get_commits_stats)

    DBS = get_session()

    lockkey = __get_lockkey('get_commits_stats', repo_name, ts_min_y,

                            ts_max_y)

    lockkey_path = config['here']

    log.info('running task with lockkey %s', lockkey)

    try:

        lock = l = DaemonLock(file_=jn(lockkey_path, lockkey))

        # for js data compatibilty cleans the key for person from '

        akc = lambda k: person(k).replace('"', "")

        co_day_auth_aggr = {}

        commits_by_day_aggregate = {}

        repo = Repository.get_by_repo_name(repo_name)

        if repo is None:

            return True

        repo = repo.scm_instance

        repo_size = repo.count()

        # return if repo have no revisions

        if repo_size < 1:

            lock.release()

            return True

        skip_date_limit = True

        parse_limit = int(config['app_conf'].get('commit_parse_limit'))

        last_rev = None

        last_cs = None

        timegetter = itemgetter('time')

        dbrepo = DBS.query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        cur_stats = DBS.query(Statistics)\

            .filter(Statistics.repository == dbrepo).scalar()

        if cur_stats is not None:

            last_rev = cur_stats.stat_on_revision

        if last_rev == repo.get_changeset().revision and repo_size > 1:

            # pass silently without any work if we're not on first revision or

            # current state of parsing revision(from db marker) is the

            # last revision

            lock.release()

            return True

        if cur_stats:

            commits_by_day_aggregate = OrderedDict(json.loads(

                                        cur_stats.commit_activity_combined))

            co_day_auth_aggr = json.loads(cur_stats.commit_activity)

        log.debug('starting parsing %s', parse_limit)

        lmktime = mktime

        last_rev = last_rev + 1 if last_rev >= 0 else 0

        log.debug('Getting revisions from %s to %s' % (

             last_rev, last_rev + parse_limit)

        )

        for cs in repo[last_rev:last_rev + parse_limit]:

            last_cs = cs  # remember last parsed changeset

            k = lmktime([cs.date.timetuple()[0], cs.date.timetuple()[1],

                          cs.date.timetuple()[2], 0, 0, 0, 0, 0, 0])

            if akc(cs.author) in co_day_auth_aggr:

                try:

                    l = [timegetter(x) for x in

                         co_day_auth_aggr[akc(cs.author)]['data']]

                    time_pos = l.index(k)

                except ValueError:

                    time_pos = False

                if time_pos >= 0 and time_pos is not False:

                    datadict = \

                        co_day_auth_aggr[akc(cs.author)]['data'][time_pos]

                    datadict["commits"] += 1

                    datadict["added"] += len(cs.added)

                    datadict["changed"] += len(cs.changed)

                    datadict["removed"] += len(cs.removed)

                else:

                    if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                        datadict = {"time": k,

                                    "commits": 1,

                                    "added": len(cs.added),

                                    "changed": len(cs.changed),

                                    "removed": len(cs.removed),

                                   }

                        co_day_auth_aggr[akc(cs.author)]['data']\

                            .append(datadict)

            else:

                if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                    co_day_auth_aggr[akc(cs.author)] = {

                                        "label": akc(cs.author),

                                        "data": [{"time":k,

                                                 "commits":1,

                                                 "added":len(cs.added),

                                                 "changed":len(cs.changed),

                                                 "removed":len(cs.removed),

                                                 }],

                                        "schema": ["commits"],

                                        }

            #gather all data by day

            if k in commits_by_day_aggregate:

                commits_by_day_aggregate[k] += 1

            else:

                commits_by_day_aggregate[k] = 1

        overview_data = sorted(commits_by_day_aggregate.items(),

                               key=itemgetter(0))

        if not co_day_auth_aggr:

            co_day_auth_aggr[akc(repo.contact)] = {

                "label": akc(repo.contact),

                "data": [0, 1],

                "schema": ["commits"],

            }

        stats = cur_stats if cur_stats else Statistics()

        stats.commit_activity = json.dumps(co_day_auth_aggr)

        stats.commit_activity_combined = json.dumps(overview_data)

        log.debug('last revison %s', last_rev)

        leftovers = len(repo.revisions[last_rev:])

        log.debug('revisions to parse %s', leftovers)

        if last_rev == 0 or leftovers < parse_limit:

            log.debug('getting code trending stats')

            stats.languages = json.dumps(__get_codes_stats(repo_name))

        try:

            stats.repository = dbrepo

            stats.stat_on_revision = last_cs.revision if last_cs else 0

            DBS.add(stats)

            DBS.commit()

        except:

            log.error(traceback.format_exc())

            DBS.rollback()

            lock.release()

            return False

        #final release

        lock.release()

        #execute another task if celery is enabled

        if len(repo.revisions) > 1 and CELERY_ON:

            run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)

        return True

    except LockHeld:

        log.info('LockHeld')

        return 'Task with key %s already running' % lockkey

@task(ignore_result=True)

@dbsession

def send_password_link(user_email):

    from rhodecode.model.notification import EmailNotificationModel

    log = get_logger(send_password_link)

    DBS = get_session()

    try:

        user = User.get_by_email(user_email)

        if user:

            log.debug('password reset user found %s' % user)

            link = url('reset_password_confirmation', key=user.api_key,

                       qualified=True)

            reg_type = EmailNotificationModel.TYPE_PASSWORD_RESET

            body = EmailNotificationModel().get_email_tmpl(reg_type,

                                                **{'user':user.short_contact,

                                                   'reset_url':link})

            log.debug('sending email')

            run_task(send_email, user_email,

                     _("password reset link"), body)

            log.info('send new password mail to %s', user_email)

        else:

            log.debug("password reset email %s not found" % user_email)

    except:

        log.error(traceback.format_exc())

        return False

    return True

@task(ignore_result=True)

@dbsession

def reset_user_password(user_email):

    from rhodecode.lib import auth

    log = get_logger(reset_user_password)

    DBS = get_session()

    try:

        try:

            user = User.get_by_email(user_email)

            new_passwd = auth.PasswordGenerator().gen_password(8,

                             auth.PasswordGenerator.ALPHABETS_BIG_SMALL)

            if user:

                user.password = auth.get_crypt_password(new_passwd)

                user.api_key = auth.generate_api_key(user.username)

                DBS.add(user)

                DBS.commit()

                log.info('change password for %s', user_email)

            if new_passwd is None:

                raise Exception('unable to generate new password')

        except:

            log.error(traceback.format_exc())

            DBS.rollback()

        run_task(send_email, user_email,

                 'Your new password',

                 'Your new RhodeCode password:%s' % (new_passwd))

        log.info('send new password mail to %s', user_email)

    except:

        log.error('Failed to update user password')

        log.error(traceback.format_exc())

    return True

@task(ignore_result=True)

@dbsession

def send_email(recipients, subject, body, html_body=''):

    """

    Sends an email with defined parameters from the .ini files.

    :param recipients: list of recipients, it this is empty the defined email

        address from field 'email_to' is used instead

    :param subject: subject of the mail

    :param body: body of the mail

    :param html_body: html version of body

    """

    log = get_logger(send_email)

    DBS = get_session()

    email_config = config

    subject = "%s %s" % (email_config.get('email_prefix'), subject)

    if not recipients:

        # if recipients are not defined we send to email_config + all admins

        admins = [u.email for u in User.query()

                  .filter(User.admin == True).all()]

        recipients = [email_config.get('email_to')] + admins

    mail_from = email_config.get('app_email_from', 'RhodeCode')

    user = email_config.get('smtp_username')

    passwd = email_config.get('smtp_password')

    mail_server = email_config.get('smtp_server')

    mail_port = email_config.get('smtp_port')

    tls = str2bool(email_config.get('smtp_use_tls'))

    ssl = str2bool(email_config.get('smtp_use_ssl'))

    debug = str2bool(config.get('debug'))

    smtp_auth = email_config.get('smtp_auth')

    try:

        m = SmtpMailer(mail_from, user, passwd, mail_server, smtp_auth,

                       mail_port, ssl, tls, debug=debug)

        m.send(recipients, subject, body, html_body)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@task(ignore_result=True)

@dbsession

def create_repo_fork(form_data, cur_user):

    """

    Creates a fork of repository using interval VCS methods

    :param form_data:

    :param cur_user:

    """

    from rhodecode.model.repo import RepoModel

    log = get_logger(create_repo_fork)

    DBS = get_session()

    base_path = Repository.base_path()

    RepoModel(DBS).create(form_data, cur_user, just_db=True, fork=True)

    alias = form_data['repo_type']

    org_repo_name = form_data['org_path']

    fork_name = form_data['repo_name_full']

    update_after_clone = form_data['update_after_clone']

    source_repo_path = os.path.join(base_path, org_repo_name)

    destination_fork_path = os.path.join(base_path, fork_name)

    log.info('creating fork of %s as %s', source_repo_path,

             destination_fork_path)

    backend = get_backend(alias)

    backend(safe_str(destination_fork_path), create=True,

            src_url=safe_str(source_repo_path),

            update_after_clone=update_after_clone)

    action_logger(cur_user, 'user_forked_repo:%s' % fork_name,

                   org_repo_name, '', DBS)

    action_logger(cur_user, 'user_created_fork:%s' % fork_name,

                   fork_name, '', DBS)

    # finally commit at latest possible stage

    DBS.commit()

def __get_codes_stats(repo_name):

    repo = Repository.get_by_repo_name(repo_name).scm_instance

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

        for f in cs[2]:

            ext = lower(f.extension)

            if ext in LANGUAGES_EXTENSIONS_MAP.keys() and not f.is_binary:

                if ext in code_stats:

                    code_stats[ext] += 1

                else:

                    code_stats[ext] = 1

    map(aggregate, tip.walk('/'))

    return code_stats or {}

        else:

            self.item_count = len(self.collection)

        # Compute the number of the first and last available page

        if self.item_count > 0:

            self.first_page = 1

            self.page_count = int(math.ceil(float(self.item_count) /

                                            self.items_per_page))

            self.last_page = self.first_page + self.page_count - 1

            # Make sure that the requested page number is the range of

            # valid pages

            if self.page > self.last_page:

                self.page = self.last_page

            elif self.page < self.first_page:

                self.page = self.first_page

            # Note: the number of items on this page can be less than

            #       items_per_page if the last page is not full

            self.first_item = max(0, (self.item_count) - (self.page *

                                                          items_per_page))

            self.last_item = ((self.item_count - 1) - items_per_page *

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

def repo_link(groups_and_repos):

    """

    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:

    """

    groups, repo_name = groups_and_repos

    if not groups:

        return repo_name

    else:

        def make_link(group):

            return link_to(group.name, url('repos_group_home',

                                           group_name=group.group_name))

        return literal(' » '.join(map(make_link, groups)) + \

                       " » " + repo_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

    """

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

    width = 100

    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

        if a_p > d_p:

            a_p = a_p - (p_sum - width)

        else:

            d_p = d_p - (p_sum - width)

    a_v = a if a > 0 else ''

    d_v = d if d > 0 else ''

    def cgen(l_type):

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

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

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

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

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

    d_a = '<div class="added %s" style="width:%s%%">%s</div>' % (cgen('a'),

                                                                 a_p, a_v)

    d_d = '<div class="deleted %s" style="width:%s%%">%s</div>' % (cgen('d'),

                                                                   d_p, d_v)

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

def urlify_text(text_):

    import re

    url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]'''

                         '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')

    def url_func(match_obj):

        url_full = match_obj.groups()[0]

        return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})

    return literal(url_pat.sub(url_func, text_))

def urlify_changesets(text_, repository):

    import re

    URL_PAT = re.compile(r'([0-9a-fA-F]{12,})')

    def url_func(match_obj):

        rev = match_obj.groups()[0]

        pref = ''

        if match_obj.group().startswith(' '):

            pref = ' '

        tmpl = (

        '%(pref)s<a class="%(cls)s" href="%(url)s">'

        '%(rev)s'

        '</a>'

        )

        return tmpl % {

         'pref': pref,

         'cls': 'revision-link',

         'url': url('changeset_home', repo_name=repository, revision=rev),

         'rev': rev,

        }

    newtext = URL_PAT.sub(url_func, text_)

    return newtext

def urlify_commit(text_, repository=None, link_=None):

    import re

    import traceback

    # urlify changesets

    text_ = urlify_changesets(text_, repository)

    def linkify_others(t,l):

        urls = re.compile(r'(\<a.*?\<\/a\>)',)

        links = []

        for e in urls.split(t):

            if not urls.match(e):

                links.append('<a class="message-link" href="%s">%s</a>' % (l,e))

            else:

        return ''.join(links)

    try:

        conf = config['app_conf']

        URL_PAT = re.compile(r'%s' % conf.get('issue_pat'))

        if URL_PAT:

            ISSUE_SERVER_LNK = conf.get('issue_server_link')

            ISSUE_PREFIX = conf.get('issue_prefix')

            def url_func(match_obj):

                pref = ''

                if match_obj.group().startswith(' '):

                    pref = ' '

                issue_id = ''.join(match_obj.groups())

                tmpl = (

                '%(pref)s<a class="%(cls)s" href="%(url)s">'

                '%(issue-prefix)s%(id-repr)s'

                '</a>'

                )

                url = ISSUE_SERVER_LNK.replace('{id}', issue_id)

                if repository:

                    url = url.replace('{repo}', repository)

                return tmpl % {

                     'pref': pref,

                     'cls': 'issue-tracker-link',

                     'url': url,

                     'id-repr': issue_id,

                     'issue-prefix': ISSUE_PREFIX,

                     'serv': ISSUE_SERVER_LNK,

                }

            newtext = URL_PAT.sub(url_func, text_)

            # wrap not links into final link => link_

            newtext = linkify_others(newtext, link_)

            return literal(newtext)

    except:

        log.error(traceback.format_exc())

        pass

    return text_

def rst(source):

    return literal('<div class="rst-block">%s</div>' %

                   MarkupRenderer.rst(source))

def rst_w_mentions(source):

    """

    Wrapped rst renderer with @mention highlighting

    :param source:

    """

    return literal('<div class="rst-block">%s</div>' %

                   MarkupRenderer.rst_with_mentions(source))

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

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

<!-- HEADER -->

<div id="header">

    <div id="header-inner" class="title">

        <div id="logo">

            <h1><a href="${h.url('home')}">${c.rhodecode_name}</a></h1>

        </div>

        <!-- MENU -->

        ${self.page_nav()}

        <!-- END MENU -->

        ${self.body()}

    </div>

</div>

<!-- END HEADER -->

<!-- CONTENT -->

<div id="content">

    <div class="flash_msg">

        <% messages = h.flash.pop_messages() %>

        % if messages:

        <ul id="flash-messages">

            % for message in messages:

            <li class="${message.category}_msg">${message}</li>

            % endfor

        </ul>

        % endif

    </div>

    <div id="main">

        ${next.main()}

    </div>

</div>

<!-- END CONTENT -->

<!-- FOOTER -->

<div id="footer">

   <div id="footer-inner" class="title">

       <div>

           <p class="footer-link">

                <a href="${h.url('bugtracker')}">${_('Submit a bug')}</a>

           </p>

	       <p class="footer-link-right">

	           <a href="${h.url('rhodecode_official')}">RhodeCode</a>

	           ${c.rhodecode_version} © 2010-${h.datetime.today().year} by Marcin Kuzminski

	       </p>

       </div>

   </div>

</div>

<!-- END FOOTER -->

### MAKO DEFS ###

<%def name="page_nav()">

    ${self.menu()}

</%def>

<%def name="breadcrumbs()">

    <div class="breadcrumbs">

    ${self.breadcrumbs_links()}

    </div>

</%def>

<%def name="usermenu()">

  <div class="user-menu">

      <div class="container">

       <div class="gravatar" id="quick_login_link">

           <img alt="gravatar" src="${h.gravatar_url(c.rhodecode_user.email,24)}" />

       </div>

       %if c.rhodecode_user.username != 'default' and c.unread_notifications != 0:

        <div class="notifications">

          <a id="notification_counter" href="${h.url('notifications')}">${c.unread_notifications}</a>

        </div>

       %endif

      </div>

      <div id="quick_login" style="display:none">

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

            <h4>${_('Login to your account')}</h4>

            ${h.form(h.url('login_home',came_from=h.url.current()))}

            <div class="form">

                <div class="fields">

                    <div class="field">

                        <div class="label">

                            <label for="username">${_('Username')}:</label>

                        </div>

                        <div class="input">

                            ${h.text('username',class_='focus',size=40)}

                        </div>

                    </div>

                    <div class="field">

                        <div class="label">

                            <label for="password">${_('Password')}:</label>

                        </div>

                        <div class="input">

                            ${h.password('password',class_='focus',size=40)}

                        </div>

                    </div>

                    <div class="buttons">

                        <div class="password_forgoten">${h.link_to(_('Forgot password ?'),h.url('reset_password'))}</div>

                        <div class="register">

                        %if h.HasPermissionAny('hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')():

                         ${h.link_to(_("Don't have an account ?"),h.url('register'))}

                        %endif

                        </div>

                        <div class="submit">

                            ${h.submit('sign_in',_('Log In'),class_="ui-btn xsmall")}

                        </div>

                    </div>

                </div>

            </div>

            ${h.end_form()}

        %else:

            <div class="links_left">

                <div class="full_name">${c.rhodecode_user.full_name}</div>

                <div class="email">${c.rhodecode_user.email}</div>

                <div class="big_gravatar"><img alt="gravatar" src="${h.gravatar_url(c.rhodecode_user.email,48)}" /></div>

            </div>

            <div class="links_right">

            <ol class="links">

              <li>${h.link_to(_(u'Home'),h.url('home'))}</li>

              <li>${h.link_to(_(u'My account'),h.url('admin_settings_my_account'))}</li>

              <li class="logout">${h.link_to(_(u'Log Out'),h.url('logout_home'))}</li>

            </ol>

            </div>

        %endif

 </div>

</%def>

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

		<%

		def is_current(selected):

			if selected == current:

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

		%>

		%if current not in ['home','admin']:

		   ##REGULAR MENU

	        <ul id="quick">

				<!-- repo switcher -->

				<li>

					<a class="menu_link" id="repo_switcher" title="${_('Switch repository')}" href="#">

                    <span class="icon">

                        <img src="${h.url('/images/icons/database.png')}" alt="${_('Products')}" />

                    </span>

                    <span>&darr;</span>

					</a>

					<ul id="repo_switcher_list" class="repo_switcher">

                        <li>

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

                        </li>

					</ul>

				</li>

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

	               <a class="menu_link" title="${_('Summary')}" href="${h.url('summary_home',repo_name=c.repo_name)}">

	               <span class="icon">

	                   <img src="${h.url('/images/icons/clipboard_16.png')}" alt="${_('Summary')}" />

	               </span>

	               <span>${_('Summary')}</span>

	               </a>

	            </li>

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

                   <a class="menu_link" title="${_('Changelog')}" href="${h.url('changelog_home',repo_name=c.repo_name)}">

                   <span class="icon">

                       <img src="${h.url('/images/icons/time.png')}" alt="${_('Changelog')}" />

                   </span>

                   <span>${_('Changelog')}</span>

                   </a>

                </li>

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

                   <a class="menu_link" id="branch_tag_switcher" title="${_('Switch to')}" href="#">

                   <span class="icon">

                       <img src="${h.url('/images/icons/arrow_switch.png')}" alt="${_('Switch to')}" />

                   </span>

                   <span>${_('Switch to')}</span>

                   </a>

                    <ul id="switch_to_list" class="switch_to">

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

                    </ul>

                </li>

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

                   <a class="menu_link" title="${_('Files')}" href="${h.url('files_home',repo_name=c.repo_name)}">

                   <span class="icon">

                       <img src="${h.url('/images/icons/file.png')}" alt="${_('Files')}" />

                   </span>

                   <span>${_('Files')}</span>

                   </a>

                </li>

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

                   <a class="menu_link" title="${_('Options')}" href="#">

                   <span class="icon">

                       <img src="${h.url('/images/icons/table_gear.png')}" alt="${_('Admin')}" />

                   </span>

                   <span>${_('Options')}</span>

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

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

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

                    % if h.HasPermissionAll('hg.admin')('access admin main page'):

                     <li>

                       ${h.link_to(_('admin'),h.url('admin_home'),class_='admin')}

                        <%def name="admin_menu()">

                        <ul>

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

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

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

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

                            <li>${h.link_to(_('users 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 class="last">${h.link_to(_('settings'),h.url('admin_settings'),class_='settings')}</li>

                        </ul>

                        </%def>

                        ${admin_menu()}

                     </li>

                    % endif

                   </ul>

                </li>

                <li>