#47 implemented Adding of new repo_groups+forms+validators. Fixed sorting of repo groups by main names in multiple locations. Removed some unneeded calls to self.sa for exchange to .query() methods.

Added new db unique key for Group

rhodecode/model/repos_group.py

@@ -0,0 +1,133 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.model.user_group
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    users groups model for RhodeCode
+
+    :created_on: Jan 25, 2011
+    :author: marcink
+    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :license: GPLv3, see COPYING 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import os
+import logging
+import traceback
+
+from pylons.i18n.translation import _
+
+from vcs.utils.lazy import LazyProperty
+
+from rhodecode.model import BaseModel
+from rhodecode.model.caching_query import FromCache
+from rhodecode.model.db import Group, RhodeCodeUi
+
+log = logging.getLogger(__name__)
+
+
+class ReposGroupModel(BaseModel):
+
+    @LazyProperty
+    def repos_path(self):
+        """
+        Get's the repositories root path from database
+        """
+
+        q = RhodeCodeUi.get_by_key('/').one()
+        return q.ui_value
+
+    def __create_group(self, group_name, parent_id):
+        """
+        makes repositories group on filesystem
+
+        :param repo_name:
+        :param parent_id:
+        """
+
+        if parent_id:
+            parent_group_name = Group.get(parent_id).group_name
+        else:
+            parent_group_name = ''
+
+        create_path = os.path.join(self.repos_path, parent_group_name,
+                                   group_name)
+        log.debug('creating new group in %s', create_path)
+
+        if os.path.isdir(create_path):
+            raise Exception('That directory already exists !')
+
+
+        os.makedirs(create_path)
+
+
+    def __rename_group(self, group_name):
+        """
+        Renames a group on filesystem
+        
+        :param group_name:
+        """
+        pass
+
+    def __delete_group(self, group_name):
+        """
+        Deletes a group from a filesystem
+        
+        :param group_name:
+        """
+        pass
+
+    def create(self, form_data):
+        try:
+            new_repos_group = Group()
+            new_repos_group.group_name = form_data['repos_group_name']
+            new_repos_group.group_description = \
+                form_data['repos_group_description']
+            new_repos_group.group_parent_id = form_data['repos_group_parent']
+
+            self.sa.add(new_repos_group)
+
+            self.__create_group(form_data['repos_group_name'],
+                                form_data['repos_group_parent'])
+
+            self.sa.commit()
+        except:
+            log.error(traceback.format_exc())
+            self.sa.rollback()
+            raise
+
+    def update(self, repos_group_id, form_data):
+
+        try:
+            repos_group = Group.get(repos_group_id)
+
+
+
+            self.sa.add(repos_group)
+            self.sa.commit()
+        except:
+            log.error(traceback.format_exc())
+            self.sa.rollback()
+            raise
+
+    def delete(self, users_group_id):
+        try:
+            users_group = self.get(users_group_id, cache=False)
+            self.sa.delete(users_group)
+            self.sa.commit()
+        except:
+            log.error(traceback.format_exc())
+            self.sa.rollback()
+            raise

rhodecode/templates/admin/repos_groups/repos_groups_add.html

@@ -0,0 +1,64 b''
+## -*- coding: utf-8 -*-
+<%inherit file="/base/base.html"/>
+
+<%def name="title()">
+    ${_('Add repos group')} - ${c.rhodecode_name}
+</%def>
+<%def name="breadcrumbs_links()">
+    ${h.link_to(_('Admin'),h.url('admin_home'))} 
+    &raquo; 
+    ${h.link_to(_('Repos groups'),h.url('repos_groups'))} 
+    &raquo;
+    ${_('add new repos group')}
+</%def>
+
+<%def name="page_nav()">
+    ${self.menu('admin')}
+</%def>
+
+<%def name="main()">
+<div class="box">
+    <!-- box / title -->
+    <div class="title">
+        ${self.breadcrumbs()}       
+    </div>
+    <!-- end box / title -->
+    ${h.form(url('repos_groups'))}
+    <div class="form">
+        <!-- fields -->
+        <div class="fields">
+             <div class="field">
+                <div class="label">
+                    <label for="users_group_name">${_('Group name')}:</label>
+                </div>
+                <div class="input">
+                    ${h.text('repos_group_name',class_='medium')}
+                </div>
+             </div>
+             
+	        <div class="field">
+	            <div class="label label-textarea">
+	                <label for="description">${_('Description')}:</label>
+	            </div>
+	            <div class="textarea text-area editor">
+	                ${h.textarea('repos_group_description',cols=23,rows=5,class_="medium")}
+	            </div>
+	         </div>
+             
+	         <div class="field">
+	             <div class="label">
+	                 <label for="repo_group">${_('Group parent')}:</label>
+	             </div>
+	             <div class="input">
+	                 ${h.select('repos_group_parent','',c.repo_groups,class_="medium")}
+	             </div>
+	         </div>             
+                         
+            <div class="buttons">
+              ${h.submit('save','save',class_="ui-button")}
+            </div>             
+        </div>
+    </div>
+    ${h.end_form()}
+</div>    
+</%def>    
  No newline at end of file

rhodecode/templates/admin/repos_groups/repos_groups_show.html

@@ -0,0 +1,68 b''
+## -*- coding: utf-8 -*-
+<%inherit file="/base/base.html"/>
+
+<%def name="title()">
+    ${_('Repositories groups administration')} - ${c.rhodecode_name}
+</%def>
+
+
+<%def name="breadcrumbs_links()">
+    ${h.link_to(_('Admin'),h.url('admin_home'))} &raquo; ${_('Repositories')}
+</%def>
+<%def name="page_nav()">
+    ${self.menu('admin')}
+</%def>
+<%def name="main()">
+<div class="box">
+    <!-- box / title -->
+    <div class="title">
+        ${self.breadcrumbs()}
+        <ul class="links">
+          <li>
+            <span>${h.link_to(u'ADD NEW GROUP',h.url('new_repos_group'))}</span>
+          </li>          
+        </ul>        
+    </div>
+    <!-- end box / title -->
+    <div class="table">
+           % if c.groups:
+            <table class="table_disp">
+            
+                <thead>
+                    <tr>
+                        <th class="left"><a href="#">${_('Group name')}</a></th>
+                        <th class="left"><a href="#">${_('Description')}</a></th>
+                        <th class="left"><a href="#">${_('Number of repositories')}</a></th>
+                        <th class="left">${_('action')}</th>
+                    </tr>
+                </thead>
+                
+                ## REPO GROUPS
+                
+                % for gr in c.groups:
+                  <tr>
+                      <td>
+                          <div style="white-space: nowrap">
+                          <img class="icon" alt="${_('Repositories group')}" src="${h.url('/images/icons/database_link.png')}"/>
+                          ${h.link_to(h.literal(' &raquo; '.join([g.group_name for g in gr.parents+[gr]])),url('edit_repos_group',id=gr.group_id))}
+                          </div>
+                      </td>
+                      <td>${gr.group_description}</td>
+                      <td><b>${gr.repositories.count()}</b></td>
+		               <td>
+		                 ${h.form(url('repos_group', id=gr.group_id),method='delete')}
+		                   ${h.submit('remove_%s' % gr.group_name,'delete',class_="delete_icon action_button",onclick="return confirm('Confirm to delete this group');")}
+		                 ${h.end_form()}
+		               </td>                      
+                  </tr>
+                % endfor
+                
+            </table>
+            % else:
+                {_('There are no repositories groups yet')}
+            % endif
+         
+    </div>
+</div> 
+           
+</%def>    

rhodecode/controllers/admin/repos.py

@@ -1,418 +1,420 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.admin.repos
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Admin controller for RhodeCode
 
     :created_on: Apr 7, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING 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, either version 3 of the License, or
 # (at your option) any later version.
 #
 # 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, see <http://www.gnu.org/licenses/>.
 
 import logging
 import traceback
 import formencode
 from operator import itemgetter
 from formencode import htmlfill
 
 from paste.httpexceptions import HTTPInternalServerError
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \
     HasPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug
 from rhodecode.lib.helpers import get_token
 from rhodecode.model.db import User, Repository, UserFollowing, Group
 from rhodecode.model.forms import RepoForm
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.repo import RepoModel
 
 log = logging.getLogger(__name__)
 
 
 class ReposController(BaseController):
     """
     REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repo', 'repos')
 
     @LoginRequired()
     @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
     def __before__(self):
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
         super(ReposController, self).__before__()
 
     def __load_defaults(self):
         repo_model = RepoModel()
 
         c.repo_groups = [('', '')]
         parents_link = lambda k: h.literal('&raquo;'.join(
                                     map(lambda k: k.group_name,
                                         k.parents + [k])
                                     )
                                 )
 
         c.repo_groups.extend([(x.group_id, parents_link(x)) for \
                                             x in self.sa.query(Group).all()])
+        c.repo_groups = sorted(c.repo_groups,
+                               key=lambda t: t[1].split('&raquo;')[0])
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
 
     def __load_data(self, repo_name=None):
         """
         Load defaults settings for edit, and update
 
         :param repo_name:
         """
         self.__load_defaults()
 
         repo, dbrepo = ScmModel().get(repo_name, retval='repo')
 
         repo_model = RepoModel()
         c.repo_info = repo_model.get_by_repo_name(repo_name)
 
         if c.repo_info is None:
             h.flash(_('%s repository is not mapped to db perhaps'
                       ' it was created or renamed from the filesystem'
                       ' please run the application again'
                       ' in order to rescan repositories') % repo_name,
                       category='error')
 
             return redirect(url('repos'))
 
         c.default_user_id = User.by_username('default').user_id
         c.in_public_journal = self.sa.query(UserFollowing)\
             .filter(UserFollowing.user_id == c.default_user_id)\
             .filter(UserFollowing.follows_repository == c.repo_info).scalar()
 
         if c.repo_info.stats:
             last_rev = c.repo_info.stats.stat_on_revision
         else:
             last_rev = 0
         c.stats_revision = last_rev
 
         c.repo_last_rev = repo.count() - 1 if repo.revisions else 0
 
         if last_rev == 0 or c.repo_last_rev == 0:
             c.stats_percentage = 0
         else:
             c.stats_percentage = '%.2f' % ((float((last_rev)) /
                                             c.repo_last_rev) * 100)
 
         defaults = c.repo_info.get_dict()
         group, repo_name = c.repo_info.groups_and_repo
         defaults['repo_name'] = repo_name
         defaults['repo_group'] = getattr(group[-1] if group else None,
                                          'group_id', None)
 
         #fill owner
         if c.repo_info.user:
             defaults.update({'user': c.repo_info.user.username})
         else:
             replacement_user = self.sa.query(User)\
             .filter(User.admin == True).first().username
             defaults.update({'user': replacement_user})
 
         #fill repository users
         for p in c.repo_info.repo_to_perm:
             defaults.update({'u_perm_%s' % p.user.username:
                              p.permission.permission_name})
 
         #fill repository groups
         for p in c.repo_info.users_group_to_perm:
             defaults.update({'g_perm_%s' % p.users_group.users_group_name:
                              p.permission.permission_name})
 
         return defaults
 
     @HasPermissionAllDecorator('hg.admin')
     def index(self, format='html'):
         """GET /repos: All items in the collection"""
         # url('repos')
 
         all_repos = [r.repo_name for r in Repository.query().all()]
 
         cached_repo_list = ScmModel().get_repos(all_repos)
         c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))
         return render('admin/repos/repos.html')
 
     @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
     def create(self):
         """
         POST /repos: Create a new item"""
         # url('repos')
         repo_model = RepoModel()
         self.__load_defaults()
         form_result = {}
         try:
             form_result = RepoForm(repo_groups=c.repo_groups_choices)()\
                             .to_python(dict(request.POST))
             repo_model.create(form_result, self.rhodecode_user)
             if form_result['clone_uri']:
                 h.flash(_('created repository %s from %s') \
                     % (form_result['repo_name'], form_result['clone_uri']),
                     category='success')
             else:
                 h.flash(_('created repository %s') % form_result['repo_name'],
                     category='success')
 
             if request.POST.get('user_created'):
                 action_logger(self.rhodecode_user, 'user_created_repo',
                               form_result['repo_name'], '', self.sa)
             else:
                 action_logger(self.rhodecode_user, 'admin_created_repo',
                               form_result['repo_name'], '', self.sa)
 
         except formencode.Invalid, errors:
 
             c.new_repo = errors.value['repo_name']
 
             if request.POST.get('user_created'):
                 r = render('admin/repos/repo_add_create_repository.html')
             else:
                 r = render('admin/repos/repo_add.html')
 
             return htmlfill.render(
                 r,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8")
 
         except Exception:
             log.error(traceback.format_exc())
             msg = _('error occurred during creation of repository %s') \
                     % form_result.get('repo_name')
             h.flash(msg, category='error')
         if request.POST.get('user_created'):
             return redirect(url('home'))
         return redirect(url('repos'))
 
     @HasPermissionAllDecorator('hg.admin')
     def new(self, format='html'):
         """GET /repos/new: Form to create a new item"""
         new_repo = request.GET.get('repo', '')
         c.new_repo = repo_name_slug(new_repo)
         self.__load_defaults()
         return render('admin/repos/repo_add.html')
 
     @HasPermissionAllDecorator('hg.admin')
     def update(self, repo_name):
         """
         PUT /repos/repo_name: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('repo', repo_name=ID),
         #           method='put')
         # url('repo', repo_name=ID)
         self.__load_defaults()
         repo_model = RepoModel()
         changed_name = repo_name
         _form = RepoForm(edit=True, old_data={'repo_name': repo_name},
                          repo_groups=c.repo_groups_choices)()
         try:
             form_result = _form.to_python(dict(request.POST))
             repo_model.update(repo_name, form_result)
             invalidate_cache('get_repo_cached_%s' % repo_name)
             h.flash(_('Repository %s updated successfully' % repo_name),
                     category='success')
             changed_name = form_result['repo_name_full']
             action_logger(self.rhodecode_user, 'admin_updated_repo',
                               changed_name, '', self.sa)
 
         except formencode.Invalid, errors:
             defaults = self.__load_data(repo_name)
             defaults.update(errors.value)
             return htmlfill.render(
                 render('admin/repos/repo_edit.html'),
                 defaults=defaults,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8")
 
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('error occurred during update of repository %s') \
                     % repo_name, category='error')
         return redirect(url('edit_repo', repo_name=changed_name))
 
     @HasPermissionAllDecorator('hg.admin')
     def delete(self, repo_name):
         """
         DELETE /repos/repo_name: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('repo', repo_name=ID),
         #           method='delete')
         # url('repo', repo_name=ID)
 
         repo_model = RepoModel()
         repo = repo_model.get_by_repo_name(repo_name)
         if not repo:
             h.flash(_('%s repository is not mapped to db perhaps'
                       ' it was moved or renamed  from the filesystem'
                       ' please run the application again'
                       ' in order to rescan repositories') % repo_name,
                       category='error')
 
             return redirect(url('repos'))
         try:
             action_logger(self.rhodecode_user, 'admin_deleted_repo',
                               repo_name, '', self.sa)
             repo_model.delete(repo)
             invalidate_cache('get_repo_cached_%s' % repo_name)
             h.flash(_('deleted repository %s') % repo_name, category='success')
 
         except Exception, e:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of %s') % repo_name,
                     category='error')
 
         return redirect(url('repos'))
 
     @HasPermissionAllDecorator('hg.admin')
     def delete_perm_user(self, repo_name):
         """
         DELETE an existing repository permission user
 
         :param repo_name:
         """
 
         try:
             repo_model = RepoModel()
             repo_model.delete_perm_user(request.POST, repo_name)
         except Exception, e:
             h.flash(_('An error occurred during deletion of repository user'),
                     category='error')
             raise HTTPInternalServerError()
 
     @HasPermissionAllDecorator('hg.admin')
     def delete_perm_users_group(self, repo_name):
         """
         DELETE an existing repository permission users group
 
         :param repo_name:
         """
         try:
             repo_model = RepoModel()
             repo_model.delete_perm_users_group(request.POST, repo_name)
         except Exception, e:
             h.flash(_('An error occurred during deletion of repository'
                       ' users groups'),
                     category='error')
             raise HTTPInternalServerError()
 
     @HasPermissionAllDecorator('hg.admin')
     def repo_stats(self, repo_name):
         """
         DELETE an existing repository statistics
 
         :param repo_name:
         """
 
         try:
             repo_model = RepoModel()
             repo_model.delete_stats(repo_name)
         except Exception, e:
             h.flash(_('An error occurred during deletion of repository stats'),
                     category='error')
         return redirect(url('edit_repo', repo_name=repo_name))
 
     @HasPermissionAllDecorator('hg.admin')
     def repo_cache(self, repo_name):
         """
         INVALIDATE existing repository cache
 
         :param repo_name:
         """
 
         try:
             ScmModel().mark_for_invalidation(repo_name)
         except Exception, e:
             h.flash(_('An error occurred during cache invalidation'),
                     category='error')
         return redirect(url('edit_repo', repo_name=repo_name))
 
     @HasPermissionAllDecorator('hg.admin')
     def repo_public_journal(self, repo_name):
         """
         Set's this repository to be visible in public journal,
         in other words assing default user to follow this repo
 
         :param repo_name:
         """
 
         cur_token = request.POST.get('auth_token')
         token = get_token()
         if cur_token == token:
             try:
                 repo_id = Repository.by_repo_name(repo_name).repo_id
                 user_id = User.by_username('default').user_id
                 self.scm_model.toggle_following_repo(repo_id, user_id)
                 h.flash(_('Updated repository visibility in public journal'),
                         category='success')
             except:
                 h.flash(_('An error occurred during setting this'
                           ' repository in public journal'),
                         category='error')
 
         else:
             h.flash(_('Token mismatch'), category='error')
         return redirect(url('edit_repo', repo_name=repo_name))
 
     @HasPermissionAllDecorator('hg.admin')
     def repo_pull(self, repo_name):
         """
         Runs task to update given repository with remote changes,
         ie. make pull on remote location
 
         :param repo_name:
         """
         try:
             ScmModel().pull_changes(repo_name, self.rhodecode_user.username)
             h.flash(_('Pulled from remote location'), category='success')
         except Exception, e:
             h.flash(_('An error occurred during pull from remote location'),
                     category='error')
 
         return redirect(url('edit_repo', repo_name=repo_name))
 
     @HasPermissionAllDecorator('hg.admin')
     def show(self, repo_name, format='html'):
         """GET /repos/repo_name: Show a specific item"""
         # url('repo', repo_name=ID)
 
     @HasPermissionAllDecorator('hg.admin')
     def edit(self, repo_name, format='html'):
         """GET /repos/repo_name/edit: Form to edit an existing item"""
         # url('edit_repo', repo_name=ID)
         defaults = self.__load_data(repo_name)
 
         return htmlfill.render(
             render('admin/repos/repo_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )

rhodecode/controllers/admin/repos_groups.py

@@ -1,93 +1,160 b''
 import logging
+import traceback
+import formencode
+
+from formencode import htmlfill
 from operator import itemgetter
 
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
+from pylons.i18n.translation import _
 
+from rhodecode.lib import helpers as h
+from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \
+    HasPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.model.db import Group
+from rhodecode.model.repos_group import ReposGroupModel
+from rhodecode.model.forms import ReposGroupForm
 
 log = logging.getLogger(__name__)
 
 
 class ReposGroupsController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repos_group', 'repos_groups')
 
+    def __load_defaults(self):
+
+        c.repo_groups = [('', '')]
+        parents_link = lambda k: h.literal('»'.join(
+                                    map(lambda k: k.group_name,
+                                        k.parents + [k])
+                                    )
+                                )
+
+        c.repo_groups.extend([(x.group_id, parents_link(x)) for \
+                                            x in self.sa.query(Group).all()])
+
+        c.repo_groups = sorted(c.repo_groups,
+                               key=lambda t: t[1].split('»')[0])
+        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
+
+    @LoginRequired()
+    def __before__(self):
+        super(ReposGroupsController, self).__before__()
+
+    @HasPermissionAnyDecorator('hg.admin')
     def index(self, format='html'):
         """GET /repos_groups: All items in the collection"""
         # url('repos_groups')
 
+        sk = lambda g:g.parents[0].group_name if g.parents else g.group_name
+        c.groups = sorted(Group.query().all(), key=sk)
+        return render('admin/repos_groups/repos_groups_show.html')
+
+    @HasPermissionAnyDecorator('hg.admin')
     def create(self):
         """POST /repos_groups: Create a new item"""
         # url('repos_groups')
+        self.__load_defaults()
+        repos_group_model = ReposGroupModel()
+        repos_group_form = ReposGroupForm(available_groups=
+                                          c.repo_groups_choices)()
+        try:
+            form_result = repos_group_form.to_python(dict(request.POST))
+            repos_group_model.create(form_result)
+            h.flash(_('created repos group %s') \
+                    % form_result['repos_group_name'], category='success')
+            #TODO: in futureaction_logger(, '', '', '', self.sa)
+        except formencode.Invalid, errors:
 
+            return htmlfill.render(
+                render('admin/repos_groups/repos_groups_add.html'),
+                defaults=errors.value,
+                errors=errors.error_dict or {},
+                prefix_error=False,
+                encoding="UTF-8")
+        except Exception:
+            log.error(traceback.format_exc())
+            h.flash(_('error occurred during creation of repos group %s') \
+                    % request.POST.get('repos_group_name'), category='error')
+
+        return redirect(url('repos_groups'))
+
+
+    @HasPermissionAnyDecorator('hg.admin')
     def new(self, format='html'):
         """GET /repos_groups/new: Form to create a new item"""
         # url('new_repos_group')
+        self.__load_defaults()
+        return render('admin/repos_groups/repos_groups_add.html')
 
+    @HasPermissionAnyDecorator('hg.admin')
     def update(self, id):
         """PUT /repos_groups/id: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('repos_group', id=ID),
         #           method='put')
         # url('repos_group', id=ID)
 
+    @HasPermissionAnyDecorator('hg.admin')
     def delete(self, id):
         """DELETE /repos_groups/id: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('repos_group', id=ID),
         #           method='delete')
         # url('repos_group', id=ID)
 
     def show(self, id, format='html'):
         """GET /repos_groups/id: Show a specific item"""
         # url('repos_group', id=ID)
 
         c.group = Group.get(id)
         if c.group:
             c.group_repos = c.group.repositories.all()
         else:
             return redirect(url('repos_group'))
 
         sortables = ['name', 'description', 'last_change', 'tip', 'owner']
         current_sort = request.GET.get('sort', 'name')
         current_sort_slug = current_sort.replace('-', '')
 
         if current_sort_slug not in sortables:
             c.sort_by = 'name'
             current_sort_slug = c.sort_by
         else:
             c.sort_by = current_sort
         c.sort_slug = current_sort_slug
 
         sort_key = current_sort_slug + '_sort'
 
         #overwrite our cached list with current filter
         gr_filter = [r.repo_name for r in c.group_repos]
         c.cached_repo_list = self.scm_model.get_repos(all_repos=gr_filter)
 
         if c.sort_by.startswith('-'):
             c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key),
                                   reverse=True)
         else:
             c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key),
                                   reverse=False)
 
         c.repo_cnt = len(c.repos_list)
 
 
         c.groups = self.sa.query(Group).order_by(Group.group_name)\
             .filter(Group.group_parent_id == id).all()
 
         return render('admin/repos_groups/repos_groups.html')
 
+    @HasPermissionAnyDecorator('hg.admin')
     def edit(self, id, format='html'):
         """GET /repos_groups/id/edit: Form to edit an existing item"""
         # url('edit_repos_group', id=ID)

rhodecode/controllers/admin/settings.py

@@ -1,362 +1,364 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.admin.settings
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     settings controller for rhodecode admin
 
     :created_on: Jul 14, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING 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, either version 3 of the License, or
 # (at your option) any later version.
 #
 # 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, see <http://www.gnu.org/licenses/>.
 
 import logging
 import traceback
 import formencode
 
 from sqlalchemy import func
 from formencode import htmlfill
 from pylons import request, session, tmpl_context as c, url, config
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \
     HasPermissionAnyDecorator, NotAnonymous
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.celerylib import tasks, run_task
 from rhodecode.lib.utils import repo2db_mapper, invalidate_cache, \
     set_rhodecode_config, repo_name_slug
 from rhodecode.model.db import RhodeCodeUi, Repository, Group, \
     RhodeCodeSettings
 from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \
     ApplicationUiSettingsForm
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.user import UserModel
 
 log = logging.getLogger(__name__)
 
 
 class SettingsController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('setting', 'settings', controller='admin/settings',
     #         path_prefix='/admin', name_prefix='admin_')
 
     @LoginRequired()
     def __before__(self):
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
         super(SettingsController, self).__before__()
 
     @HasPermissionAllDecorator('hg.admin')
     def index(self, format='html'):
         """GET /admin/settings: All items in the collection"""
         # url('admin_settings')
 
         defaults = RhodeCodeSettings.get_app_settings()
         defaults.update(self.get_hg_ui_settings())
         return htmlfill.render(
             render('admin/settings/settings.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
 
     @HasPermissionAllDecorator('hg.admin')
     def create(self):
         """POST /admin/settings: Create a new item"""
         # url('admin_settings')
 
     @HasPermissionAllDecorator('hg.admin')
     def new(self, format='html'):
         """GET /admin/settings/new: Form to create a new item"""
         # url('admin_new_setting')
 
     @HasPermissionAllDecorator('hg.admin')
     def update(self, setting_id):
         """PUT /admin/settings/setting_id: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('admin_setting', setting_id=ID),
         #           method='put')
         # url('admin_setting', setting_id=ID)
         if setting_id == 'mapping':
             rm_obsolete = request.POST.get('destroy', False)
             log.debug('Rescanning directories with destroy=%s', rm_obsolete)
             initial = ScmModel().repo_scan()
             log.debug('invalidating all repositories')
             for repo_name in initial.keys():
                 invalidate_cache('get_repo_cached_%s' % repo_name)
 
             added, removed = repo2db_mapper(initial, rm_obsolete)
 
             h.flash(_('Repositories successfully'
                       ' rescanned added: %s,removed: %s') % (added, removed),
                     category='success')
 
         if setting_id == 'whoosh':
             repo_location = self.get_hg_ui_settings()['paths_root_path']
             full_index = request.POST.get('full_index', False)
             run_task(tasks.whoosh_index, repo_location, full_index)
 
             h.flash(_('Whoosh reindex task scheduled'), category='success')
         if setting_id == 'global':
 
             application_form = ApplicationSettingsForm()()
             try:
                 form_result = application_form.to_python(dict(request.POST))
 
                 try:
                     hgsettings1 = RhodeCodeSettings.get_by_name('title')
                     hgsettings1.app_settings_value = \
                         form_result['rhodecode_title']
 
                     hgsettings2 = RhodeCodeSettings.get_by_name('realm')
                     hgsettings2.app_settings_value = \
                         form_result['rhodecode_realm']
 
                     hgsettings3 = RhodeCodeSettings.get_by_name('ga_code')
                     hgsettings3.app_settings_value = \
                         form_result['rhodecode_ga_code']
 
                     self.sa.add(hgsettings1)
                     self.sa.add(hgsettings2)
                     self.sa.add(hgsettings3)
                     self.sa.commit()
                     set_rhodecode_config(config)
                     h.flash(_('Updated application settings'),
                             category='success')
 
                 except Exception:
                     log.error(traceback.format_exc())
                     h.flash(_('error occurred during updating '
                               'application settings'),
                             category='error')
 
                     self.sa.rollback()
 
             except formencode.Invalid, errors:
                 return htmlfill.render(
                      render('admin/settings/settings.html'),
                      defaults=errors.value,
                      errors=errors.error_dict or {},
                      prefix_error=False,
                      encoding="UTF-8")
 
         if setting_id == 'mercurial':
             application_form = ApplicationUiSettingsForm()()
             try:
                 form_result = application_form.to_python(dict(request.POST))
 
                 try:
 
                     hgsettings1 = self.sa.query(RhodeCodeUi)\
                     .filter(RhodeCodeUi.ui_key == 'push_ssl').one()
                     hgsettings1.ui_value = form_result['web_push_ssl']
 
                     hgsettings2 = self.sa.query(RhodeCodeUi)\
                     .filter(RhodeCodeUi.ui_key == '/').one()
                     hgsettings2.ui_value = form_result['paths_root_path']
 
                     #HOOKS
                     hgsettings3 = self.sa.query(RhodeCodeUi)\
                     .filter(RhodeCodeUi.ui_key == 'changegroup.update').one()
                     hgsettings3.ui_active = \
                         bool(form_result['hooks_changegroup_update'])
 
                     hgsettings4 = self.sa.query(RhodeCodeUi)\
                     .filter(RhodeCodeUi.ui_key ==
                             'changegroup.repo_size').one()
                     hgsettings4.ui_active = \
                         bool(form_result['hooks_changegroup_repo_size'])
 
                     hgsettings5 = self.sa.query(RhodeCodeUi)\
                     .filter(RhodeCodeUi.ui_key ==
                             'pretxnchangegroup.push_logger').one()
                     hgsettings5.ui_active = \
                         bool(form_result['hooks_pretxnchangegroup'
                                          '_push_logger'])
 
                     hgsettings6 = self.sa.query(RhodeCodeUi)\
                     .filter(RhodeCodeUi.ui_key ==
                             'preoutgoing.pull_logger').one()
                     hgsettings6.ui_active = \
                         bool(form_result['hooks_preoutgoing_pull_logger'])
 
                     self.sa.add(hgsettings1)
                     self.sa.add(hgsettings2)
                     self.sa.add(hgsettings3)
                     self.sa.add(hgsettings4)
                     self.sa.add(hgsettings5)
                     self.sa.add(hgsettings6)
                     self.sa.commit()
 
                     h.flash(_('Updated mercurial settings'),
                             category='success')
 
                 except:
                     log.error(traceback.format_exc())
                     h.flash(_('error occurred during updating '
                               'application settings'), category='error')
 
                     self.sa.rollback()
 
             except formencode.Invalid, errors:
                 return htmlfill.render(
                      render('admin/settings/settings.html'),
                      defaults=errors.value,
                      errors=errors.error_dict or {},
                      prefix_error=False,
                      encoding="UTF-8")
 
         return redirect(url('admin_settings'))
 
     @HasPermissionAllDecorator('hg.admin')
     def delete(self, setting_id):
         """DELETE /admin/settings/setting_id: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('admin_setting', setting_id=ID),
         #           method='delete')
         # url('admin_setting', setting_id=ID)
 
     @HasPermissionAllDecorator('hg.admin')
     def show(self, setting_id, format='html'):
         """
         GET /admin/settings/setting_id: Show a specific item"""
         # url('admin_setting', setting_id=ID)
 
     @HasPermissionAllDecorator('hg.admin')
     def edit(self, setting_id, format='html'):
         """
         GET /admin/settings/setting_id/edit: Form to
         edit an existing item"""
         # url('admin_edit_setting', setting_id=ID)
 
     @NotAnonymous()
     def my_account(self):
         """
         GET /_admin/my_account Displays info about my account
         """
         # url('admin_settings_my_account')
 
         c.user = UserModel().get(self.rhodecode_user.user_id, cache=False)
         all_repos = [r.repo_name for r in self.sa.query(Repository)\
                      .filter(Repository.user_id == c.user.user_id)\
                      .order_by(func.lower(Repository.repo_name)).all()]
         c.user_repos = ScmModel().get_repos(all_repos)
 
         if c.user.username == 'default':
             h.flash(_("You can't edit this user since it's"
               " crucial for entire application"), category='warning')
             return redirect(url('users'))
 
         defaults = c.user.get_dict()
         return htmlfill.render(
             render('admin/users/user_edit_my_account.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
 
     def my_account_update(self):
         """PUT /_admin/my_account_update: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('admin_settings_my_account_update'),
         #           method='put')
         # url('admin_settings_my_account_update', id=ID)
         user_model = UserModel()
         uid = self.rhodecode_user.user_id
         _form = UserForm(edit=True,
                          old_data={'user_id': uid,
                                    'email': self.rhodecode_user.email})()
         form_result = {}
         try:
             form_result = _form.to_python(dict(request.POST))
             user_model.update_my_account(uid, form_result)
             h.flash(_('Your account was updated successfully'),
                     category='success')
 
         except formencode.Invalid, errors:
             c.user = user_model.get(self.rhodecode_user.user_id, cache=False)
             c.user = UserModel().get(self.rhodecode_user.user_id, cache=False)
             all_repos = self.sa.query(Repository)\
                 .filter(Repository.user_id == c.user.user_id)\
                 .order_by(func.lower(Repository.repo_name))\
                 .all()
             c.user_repos = ScmModel().get_repos(all_repos)
 
             return htmlfill.render(
                 render('admin/users/user_edit_my_account.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8")
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('error occurred during update of user %s') \
                     % form_result.get('username'), category='error')
 
         return redirect(url('my_account'))
 
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
     def create_repository(self):
         """GET /_admin/create_repository: Form to create a new item"""
 
         c.repo_groups = [('', '')]
         parents_link = lambda k: h.literal('&raquo;'.join(
                                     map(lambda k: k.group_name,
                                         k.parents + [k])
                                     )
                                 )
 
         c.repo_groups.extend([(x.group_id, parents_link(x)) for \
                                             x in self.sa.query(Group).all()])
+        c.repo_groups = sorted(c.repo_groups,
+                               key=lambda t: t[1].split('&raquo;')[0])
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
 
         new_repo = request.GET.get('repo', '')
         c.new_repo = repo_name_slug(new_repo)
 
         return render('admin/repos/repo_add_create_repository.html')
 
     def get_hg_ui_settings(self):
         ret = self.sa.query(RhodeCodeUi).all()
 
         if not ret:
             raise Exception('Could not get application ui settings !')
         settings = {}
         for each in ret:
             k = each.ui_key
             v = each.ui_value
             if k == '/':
                 k = 'root_path'
 
             if k.find('.') != -1:
                 k = k.replace('.', '_')
 
             if each.ui_section == 'hooks':
                 v = each.ui_active
 
             settings[each.ui_section + '_' + k] = v
 
         return settings

rhodecode/controllers/home.py

@@ -1,81 +1,80 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.home
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Home controller for Rhodecode
 
     :created_on: Feb 18, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING 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, either version 3 of the License, or
 # (at your option) any later version.
 #
 # 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, see <http://www.gnu.org/licenses/>.
 
 import logging
 from operator import itemgetter
 
 from pylons import tmpl_context as c, request
 from paste.httpexceptions import HTTPBadRequest
 
 from rhodecode.lib.auth import LoginRequired
 from rhodecode.lib.base import BaseController, render
 from rhodecode.model.db import Group
 
 log = logging.getLogger(__name__)
 
 
 class HomeController(BaseController):
 
     @LoginRequired()
     def __before__(self):
         super(HomeController, self).__before__()
 
     def index(self):
         sortables = ['name', 'description', 'last_change', 'tip', 'owner']
         current_sort = request.GET.get('sort', 'name')
         current_sort_slug = current_sort.replace('-', '')
 
         if current_sort_slug not in sortables:
             c.sort_by = 'name'
             current_sort_slug = c.sort_by
         else:
             c.sort_by = current_sort
         c.sort_slug = current_sort_slug
 
         sort_key = current_sort_slug + '_sort'
 
         if c.sort_by.startswith('-'):
             c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key),
                                   reverse=True)
         else:
             c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key),
                                   reverse=False)
 
         c.repo_cnt = len(c.repos_list)
 
 
-        c.groups = self.sa.query(Group)\
-            .filter(Group.group_parent_id == None).all()
+        c.groups = Group.query().filter(Group.group_parent_id == None).all()
 
 
         return render('/index.html')
 
     def repo_switcher(self):
         if request.is_xhr:
             c.repos_list = sorted(c.cached_repo_list,
                                   key=itemgetter('name_sort'), reverse=False)
             return render('/repo_switcher_list.html')
         else:
             return HTTPBadRequest()

rhodecode/model/db.py

@@ -1,547 +1,552 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.db
     ~~~~~~~~~~~~~~~~~~
 
     Database Models for RhodeCode
 
     :created_on: Apr 08, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING 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, either version 3 of the License, or
 # (at your option) any later version.
 #
 # 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, see <http://www.gnu.org/licenses/>.
 
 import os
 import logging
 import datetime
 from datetime import date
 
 from sqlalchemy import *
 from sqlalchemy.exc import DatabaseError
 from sqlalchemy.orm import relationship, backref
 from sqlalchemy.orm.interfaces import MapperExtension
 
 from rhodecode.lib import str2bool
 from rhodecode.model.meta import Base, Session
 from rhodecode.model.caching_query import FromCache
 
 log = logging.getLogger(__name__)
 
 #==============================================================================
 # MAPPER EXTENSIONS
 #==============================================================================
 
 class RepositoryMapper(MapperExtension):
     def after_update(self, mapper, connection, instance):
         pass
 
 
 class RhodeCodeSettings(Base):
     __tablename__ = 'rhodecode_settings'
     __table_args__ = (UniqueConstraint('app_settings_name'), {'useexisting':True})
     app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     app_settings_name = Column("app_settings_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     app_settings_value = Column("app_settings_value", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
 
     def __init__(self, k='', v=''):
         self.app_settings_name = k
         self.app_settings_value = v
 
     def __repr__(self):
         return "<%s('%s:%s')>" % (self.__class__.__name__,
                                   self.app_settings_name, self.app_settings_value)
 
 
     @classmethod
     def get_by_name(cls, ldap_key):
         return Session.query(cls)\
             .filter(cls.app_settings_name == ldap_key).scalar()
 
     @classmethod
     def get_app_settings(cls, cache=False):
 
         ret = Session.query(cls)
 
         if cache:
             ret = ret.options(FromCache("sql_cache_short", "get_hg_settings"))
 
         if not ret:
             raise Exception('Could not get application settings !')
         settings = {}
         for each in ret:
             settings['rhodecode_' + each.app_settings_name] = \
                 each.app_settings_value
 
         return settings
 
     @classmethod
     def get_ldap_settings(cls, cache=False):
         ret = Session.query(cls)\
                 .filter(cls.app_settings_name.startswith('ldap_'))\
                 .all()
         fd = {}
         for row in ret:
             fd.update({row.app_settings_name:row.app_settings_value})
         return fd
 
 
 class RhodeCodeUi(Base):
     __tablename__ = 'rhodecode_ui'
     __table_args__ = {'useexisting':True}
     ui_id = Column("ui_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     ui_section = Column("ui_section", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     ui_key = Column("ui_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     ui_value = Column("ui_value", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     ui_active = Column("ui_active", Boolean(), nullable=True, unique=None, default=True)
 
 
+    @classmethod
+    def get_by_key(cls, key):
+        return Session.query(cls).filter(cls.ui_key == key)
+
+
 class User(Base):
     __tablename__ = 'users'
     __table_args__ = (UniqueConstraint('username'), UniqueConstraint('email'), {'useexisting':True})
     user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     username = Column("username", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     password = Column("password", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     active = Column("active", Boolean(), nullable=True, unique=None, default=None)
     admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
     name = Column("name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     lastname = Column("lastname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     email = Column("email", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
     ldap_dn = Column("ldap_dn", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     api_key = Column("api_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
 
     user_log = relationship('UserLog', cascade='all')
     user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
 
     repositories = relationship('Repository')
     user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
     repo_to_perm = relationship('RepoToPerm', primaryjoin='RepoToPerm.user_id==User.user_id', cascade='all')
 
     group_member = relationship('UsersGroupMember', cascade='all')
 
     @property
     def full_contact(self):
         return '%s %s <%s>' % (self.name, self.lastname, self.email)
 
     @property
     def short_contact(self):
         return '%s %s' % (self.name, self.lastname)
 
 
     @property
     def is_admin(self):
         return self.admin
 
     def __repr__(self):
         return "<%s('id:%s:%s')>" % (self.__class__.__name__,
                                      self.user_id, self.username)
 
     @classmethod
     def by_username(cls, username):
         return Session.query(cls).filter(cls.username == username).one()
 
 
     def update_lastlogin(self):
         """Update user lastlogin"""
 
         try:
             session = Session.object_session(self)
             self.last_login = datetime.datetime.now()
             session.add(self)
             session.commit()
             log.debug('updated user %s lastlogin', self.username)
         except (DatabaseError,):
             session.rollback()
 
 
 class UserLog(Base):
     __tablename__ = 'user_logs'
     __table_args__ = {'useexisting':True}
     user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(length=None, convert_unicode=False, assert_unicode=None), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
     repository_name = Column("repository_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     user_ip = Column("user_ip", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     action = Column("action", UnicodeText(length=1200000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
 
     @property
     def action_as_day(self):
         return date(*self.action_date.timetuple()[:3])
 
     user = relationship('User')
     repository = relationship('Repository')
 
 
 class UsersGroup(Base):
     __tablename__ = 'users_groups'
     __table_args__ = {'useexisting':True}
 
     users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_name = Column("users_group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
 
     members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
 
 
     @classmethod
     def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
         if case_insensitive:
             gr = Session.query(cls)\
             .filter(cls.users_group_name.ilike(group_name))
         else:
             gr = Session.query(UsersGroup)\
                 .filter(UsersGroup.users_group_name == group_name)
         if cache:
             gr = gr.options(FromCache("sql_cache_short",
                                           "get_user_%s" % group_name))
         return gr.scalar()
 
 class UsersGroupMember(Base):
     __tablename__ = 'users_groups_members'
     __table_args__ = {'useexisting':True}
 
     users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
     users_group = relationship('UsersGroup')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
         self.user_id = u_id
 
 class Repository(Base):
     __tablename__ = 'repositories'
     __table_args__ = (UniqueConstraint('repo_name'), {'useexisting':True},)
     __mapper_args__ = {'extension':RepositoryMapper()}
 
     repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     repo_name = Column("repo_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
     clone_uri = Column("clone_uri", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=False, default=None)
     repo_type = Column("repo_type", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=False, default='hg')
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
     private = Column("private", Boolean(), nullable=True, unique=None, default=None)
     enable_statistics = Column("statistics", Boolean(), nullable=True, unique=None, default=True)
     enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True)
     description = Column("description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     created_on = Column('created_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
 
     fork_id = Column("fork_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=False, default=None)
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None)
 
 
     user = relationship('User')
     fork = relationship('Repository', remote_side=repo_id)
     group = relationship('Group')
     repo_to_perm = relationship('RepoToPerm', cascade='all', order_by='RepoToPerm.repo_to_perm_id')
     users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')
 
     logs = relationship('UserLog', cascade='all')
 
     def __repr__(self):
         return "<%s('%s:%s')>" % (self.__class__.__name__,
                                   self.repo_id, self.repo_name)
 
     @classmethod
     def by_repo_name(cls, repo_name):
         return Session.query(cls).filter(cls.repo_name == repo_name).one()
 
 
     @classmethod
     def get_repo_forks(cls, repo_id):
         return Session.query(cls).filter(Repository.fork_id == repo_id)
 
     @property
     def just_name(self):
         return self.repo_name.split(os.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):
         return self.groups_with_parents, self.just_name
 
 
 class Group(Base):
     __tablename__ = 'groups'
-    __table_args__ = (UniqueConstraint('group_name'), {'useexisting':True},)
+    __table_args__ = (UniqueConstraint('group_name', 'group_parent_id'), {'useexisting':True},)
     __mapper_args__ = {'order_by':'group_name'}
 
     group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     group_name = Column("group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
     group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
     group_description = Column("group_description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
 
     parent_group = relationship('Group', remote_side=group_id)
 
 
     def __init__(self, group_name='', parent_group=None):
         self.group_name = group_name
         self.parent_group = parent_group
 
     def __repr__(self):
         return "<%s('%s:%s')>" % (self.__class__.__name__, self.group_id,
                                   self.group_name)
 
     @property
     def parents(self):
         groups = []
         if self.parent_group is None:
             return groups
         cur_gr = self.parent_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 full_path(self):
         return '/'.join([g.group_name for g in self.parents] +
                         [self.group_name])
 
     @property
     def repositories(self):
         return Session.query(Repository).filter(Repository.group == self)
 
 class Permission(Base):
     __tablename__ = 'permissions'
     __table_args__ = {'useexisting':True}
     permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     permission_name = Column("permission_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     permission_longname = Column("permission_longname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
 
     def __repr__(self):
         return "<%s('%s:%s')>" % (self.__class__.__name__,
                                   self.permission_id, self.permission_name)
 
     @classmethod
     def get_by_key(cls, key):
         return Session.query(cls).filter(cls.permission_name == key).scalar()
 
 class RepoToPerm(Base):
     __tablename__ = 'repo_to_perm'
     __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'useexisting':True})
     repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User')
     permission = relationship('Permission')
     repository = relationship('Repository')
 
 class UserToPerm(Base):
     __tablename__ = 'user_to_perm'
     __table_args__ = (UniqueConstraint('user_id', 'permission_id'), {'useexisting':True})
     user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User')
     permission = relationship('Permission')
 
     @classmethod
     def has_perm(cls, user_id, perm):
         if not isinstance(perm, Permission):
             raise Exception('perm needs to be an instance of Permission class')
 
         return Session.query(cls).filter(cls.user_id == user_id)\
             .filter(cls.permission == perm).scalar() is not None
 
     @classmethod
     def grant_perm(cls, user_id, perm):
         if not isinstance(perm, Permission):
             raise Exception('perm needs to be an instance of Permission class')
 
         new = cls()
         new.user_id = user_id
         new.permission = perm
         try:
             Session.add(new)
             Session.commit()
         except:
             Session.rollback()
 
 
     @classmethod
     def revoke_perm(cls, user_id, perm):
         if not isinstance(perm, Permission):
             raise Exception('perm needs to be an instance of Permission class')
 
         try:
             Session.query(cls).filter(cls.user_id == user_id)\
                 .filter(cls.permission == perm).delete()
             Session.commit()
         except:
             Session.rollback()
 
 class UsersGroupRepoToPerm(Base):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (UniqueConstraint('users_group_id', 'permission_id'), {'useexisting':True})
     users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
     users_group = relationship('UsersGroup')
     permission = relationship('Permission')
     repository = relationship('Repository')
 
 
 class UsersGroupToPerm(Base):
     __tablename__ = 'users_group_to_perm'
     users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     users_group = relationship('UsersGroup')
     permission = relationship('Permission')
 
 
     @classmethod
     def has_perm(cls, users_group_id, perm):
         if not isinstance(perm, Permission):
             raise Exception('perm needs to be an instance of Permission class')
 
         return Session.query(cls).filter(cls.users_group_id ==
                                          users_group_id)\
                                          .filter(cls.permission == perm)\
                                          .scalar() is not None
 
     @classmethod
     def grant_perm(cls, users_group_id, perm):
         if not isinstance(perm, Permission):
             raise Exception('perm needs to be an instance of Permission class')
 
         new = cls()
         new.users_group_id = users_group_id
         new.permission = perm
         try:
             Session.add(new)
             Session.commit()
         except:
             Session.rollback()
 
 
     @classmethod
     def revoke_perm(cls, users_group_id, perm):
         if not isinstance(perm, Permission):
             raise Exception('perm needs to be an instance of Permission class')
 
         try:
             Session.query(cls).filter(cls.users_group_id == users_group_id)\
                 .filter(cls.permission == perm).delete()
             Session.commit()
         except:
             Session.rollback()
 
 
 class GroupToPerm(Base):
     __tablename__ = 'group_to_perm'
     __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'useexisting':True})
 
     group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User')
     permission = relationship('Permission')
     group = relationship('Group')
 
 class Statistics(Base):
     __tablename__ = 'statistics'
     __table_args__ = (UniqueConstraint('repository_id'), {'useexisting':True})
     stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
     stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
     commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
     commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
     languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
 
     repository = relationship('Repository', single_parent=True)
 
 class UserFollowing(Base):
     __tablename__ = 'user_followings'
     __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'),
                       UniqueConstraint('user_id', 'follows_user_id')
                       , {'useexisting':True})
 
     user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
     follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
 
     user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
 
     follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
     follows_repository = relationship('Repository', order_by='Repository.repo_name')
 
 
 
     @classmethod
     def get_repo_followers(cls, repo_id):
         return Session.query(cls).filter(cls.follows_repo_id == repo_id)
 
 class CacheInvalidation(Base):
     __tablename__ = 'cache_invalidation'
     __table_args__ = (UniqueConstraint('cache_key'), {'useexisting':True})
     cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     cache_key = Column("cache_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     cache_args = Column("cache_args", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
 
 
     def __init__(self, cache_key, cache_args=''):
         self.cache_key = cache_key
         self.cache_args = cache_args
         self.cache_active = False
 
     def __repr__(self):
         return "<%s('%s:%s')>" % (self.__class__.__name__,
                                   self.cache_id, self.cache_key)
 
 class DbMigrateVersion(Base):
     __tablename__ = 'db_migrate_version'
     __table_args__ = {'useexisting':True}
     repository_id = Column('repository_id', String(250), primary_key=True)
     repository_path = Column('repository_path', Text)
     version = Column('version', Integer)

rhodecode/model/forms.py

@@ -1,619 +1,644 b''
 """ this is forms validation classes
 http://formencode.org/module-formencode.validators.html
 for list off all availible validators
 
 we can create our own validators
 
 The table below outlines the options which can be used in a schema in addition to the validators themselves
 pre_validators          []     These validators will be applied before the schema
 chained_validators      []     These validators will be applied after the schema
 allow_extra_fields      False     If True, then it is not an error when keys that aren't associated with a validator are present
 filter_extra_fields     False     If True, then keys that aren't associated with a validator are removed
 if_key_missing          NoDefault If this is given, then any keys that aren't available but are expected will be replaced with this value (and then validated). This does not override a present .if_missing attribute on validators. NoDefault is a special FormEncode class to mean that no default values has been specified and therefore missing keys shouldn't take a default value.
 ignore_key_missing      False     If True, then missing keys will be missing in the result, if the validator doesn't have .if_missing on it already
 
 
 <name> = formencode.validators.<name of validator>
 <name> must equal form name
 list=[1,2,3,4,5]
 for SELECT use formencode.All(OneOf(list), Int())
 
 """
 import os
 import re
 import logging
 import traceback
 
 import formencode
 from formencode import All
 from formencode.validators import UnicodeString, OneOf, Int, Number, Regex, \
     Email, Bool, StringBoolean, Set
 
 from pylons.i18n.translation import _
 from webhelpers.pylonslib.secure_form import authentication_token
 
 from rhodecode.lib.utils import repo_name_slug
 from rhodecode.lib.auth import authenticate, get_crypt_password
 from rhodecode.lib.exceptions import LdapImportError
-from rhodecode.model import meta
 from rhodecode.model.user import UserModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.db import User, UsersGroup, Group
 from rhodecode import BACKENDS
 
 log = logging.getLogger(__name__)
 
 #this is needed to translate the messages using _() in validators
 class State_obj(object):
     _ = staticmethod(_)
 
 #==============================================================================
 # VALIDATORS
 #==============================================================================
 class ValidAuthToken(formencode.validators.FancyValidator):
     messages = {'invalid_token':_('Token mismatch')}
 
     def validate_python(self, value, state):
 
         if value != authentication_token():
             raise formencode.Invalid(self.message('invalid_token', state,
                                             search_number=value), value, state)
 
 def ValidUsername(edit, old_data):
     class _ValidUsername(formencode.validators.FancyValidator):
 
         def validate_python(self, value, state):
             if value in ['default', 'new_user']:
                 raise formencode.Invalid(_('Invalid username'), value, state)
             #check if user is unique
             old_un = None
             if edit:
                 old_un = UserModel().get(old_data.get('user_id')).username
 
             if old_un != value or not edit:
                 if UserModel().get_by_username(value, cache=False,
                                                case_insensitive=True):
                     raise formencode.Invalid(_('This username already '
                                                'exists') , value, state)
 
             if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:
                 raise formencode.Invalid(_('Username may only contain '
                                            'alphanumeric characters '
                                            'underscores, periods or dashes '
                                            'and must begin with alphanumeric '
                                            'character'), value, state)
 
     return _ValidUsername
 
 
 def ValidUsersGroup(edit, old_data):
 
     class _ValidUsersGroup(formencode.validators.FancyValidator):
 
         def validate_python(self, value, state):
             if value in ['default']:
                 raise formencode.Invalid(_('Invalid group name'), value, state)
             #check if group is unique
             old_ugname = None
             if edit:
                 old_ugname = UsersGroup.get(
                             old_data.get('users_group_id')).users_group_name
 
             if old_ugname != value or not edit:
                 if UsersGroup.get_by_group_name(value, cache=False,
                                                case_insensitive=True):
                     raise formencode.Invalid(_('This users group '
                                                'already exists') , value,
                                              state)
 
 
             if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:
                 raise formencode.Invalid(_('Group name may only contain '
                                            'alphanumeric characters '
                                            'underscores, periods or dashes '
                                            'and must begin with alphanumeric '
                                            'character'), value, state)
 
     return _ValidUsersGroup
 
 
+def ValidReposGroup(edit, old_data):
+
+    class _ValidReposGroup(formencode.validators.FancyValidator):
+
+        def validate_python(self, value, state):
+            #TODO WRITE VALIDATIONS
+            group_name = value.get('repos_group_name')
+            parent_id = value.get('repos_group_parent')
+
+            # slugify repo group just in case :)
+            slug = repo_name_slug(group_name)
+
+            # check filesystem
+            gr = Group.query().filter(Group.group_name == slug)\
+                .filter(Group.group_parent_id == parent_id).scalar()
+
+            if gr:
+                e_dict = {'repos_group_name':_('This group already exists')}
+                raise formencode.Invalid('', value, state,
+                                         error_dict=e_dict)
+    return _ValidReposGroup
 
 class ValidPassword(formencode.validators.FancyValidator):
 
     def to_python(self, value, state):
 
         if value:
 
             if value.get('password'):
                 try:
                     value['password'] = get_crypt_password(value['password'])
                 except UnicodeEncodeError:
                     e_dict = {'password':_('Invalid characters in password')}
                     raise formencode.Invalid('', value, state, error_dict=e_dict)
 
             if value.get('password_confirmation'):
                 try:
                     value['password_confirmation'] = \
                         get_crypt_password(value['password_confirmation'])
                 except UnicodeEncodeError:
                     e_dict = {'password_confirmation':_('Invalid characters in password')}
                     raise formencode.Invalid('', value, state, error_dict=e_dict)
 
             if value.get('new_password'):
                 try:
                     value['new_password'] = \
                         get_crypt_password(value['new_password'])
                 except UnicodeEncodeError:
                     e_dict = {'new_password':_('Invalid characters in password')}
                     raise formencode.Invalid('', value, state, error_dict=e_dict)
 
             return value
 
 class ValidPasswordsMatch(formencode.validators.FancyValidator):
 
     def validate_python(self, value, state):
 
         if value['password'] != value['password_confirmation']:
             e_dict = {'password_confirmation':
                    _('Password do not match')}
             raise formencode.Invalid('', value, state, error_dict=e_dict)
 
 class ValidAuth(formencode.validators.FancyValidator):
     messages = {
             'invalid_password':_('invalid password'),
             'invalid_login':_('invalid user name'),
             'disabled_account':_('Your account is disabled')
 
             }
     #error mapping
     e_dict = {'username':messages['invalid_login'],
               'password':messages['invalid_password']}
     e_dict_disable = {'username':messages['disabled_account']}
 
     def validate_python(self, value, state):
         password = value['password']
         username = value['username']
         user = UserModel().get_by_username(username)
 
         if authenticate(username, password):
             return value
         else:
             if user and user.active is False:
                 log.warning('user %s is disabled', username)
                 raise formencode.Invalid(self.message('disabled_account',
                                          state=State_obj),
                                          value, state,
                                          error_dict=self.e_dict_disable)
             else:
                 log.warning('user %s not authenticated', username)
                 raise formencode.Invalid(self.message('invalid_password',
                                          state=State_obj), value, state,
                                          error_dict=self.e_dict)
 
 class ValidRepoUser(formencode.validators.FancyValidator):
 
     def to_python(self, value, state):
-        sa = meta.Session()
         try:
-            self.user_db = sa.query(User)\
+            self.user_db = User.query()\
                 .filter(User.active == True)\
                 .filter(User.username == value).one()
         except Exception:
             raise formencode.Invalid(_('This username is not valid'),
                                      value, state)
-        finally:
-            meta.Session.remove()
-
         return value
 
 def ValidRepoName(edit, old_data):
     class _ValidRepoName(formencode.validators.FancyValidator):
         def to_python(self, value, state):
 
             repo_name = value.get('repo_name')
 
             slug = repo_name_slug(repo_name)
             if slug in ['_admin', '']:
                 e_dict = {'repo_name': _('This repository name is disallowed')}
                 raise formencode.Invalid('', value, state, error_dict=e_dict)
 
 
             if value.get('repo_group'):
                 gr = Group.get(value.get('repo_group'))
                 group_path = gr.full_path
                 # value needs to be aware of group name
+                # it has to use '/'
                 repo_name_full = group_path + '/' + repo_name
             else:
                 group_path = ''
                 repo_name_full = repo_name
 
 
             value['repo_name_full'] = repo_name_full
             if old_data.get('repo_name') != repo_name_full or not edit:
 
                 if group_path != '':
                     if RepoModel().get_by_repo_name(repo_name_full,):
                         e_dict = {'repo_name':_('This repository already '
                                                 'exists in group "%s"') %
                                   gr.group_name}
                         raise formencode.Invalid('', value, state,
                                                  error_dict=e_dict)
 
                 else:
                     if RepoModel().get_by_repo_name(repo_name_full):
                         e_dict = {'repo_name':_('This repository '
                                                 'already exists')}
                         raise formencode.Invalid('', value, state,
                                                  error_dict=e_dict)
             return value
 
 
     return _ValidRepoName
 
-def SlugifyRepo():
-    class _SlugifyRepo(formencode.validators.FancyValidator):
+def SlugifyName():
+    class _SlugifyName(formencode.validators.FancyValidator):
 
         def to_python(self, value, state):
             return repo_name_slug(value)
 
-    return _SlugifyRepo
+    return _SlugifyName
 
 def ValidCloneUri():
     from mercurial.httprepo import httprepository, httpsrepository
     from rhodecode.lib.utils import make_ui
 
     class _ValidCloneUri(formencode.validators.FancyValidator):
 
         def to_python(self, value, state):
             if not value:
                 pass
             elif value.startswith('https'):
                 try:
                     httpsrepository(make_ui('db'), value).capabilities
                 except Exception, e:
                     log.error(traceback.format_exc())
                     raise formencode.Invalid(_('invalid clone url'), value,
                                              state)
             elif value.startswith('http'):
                 try:
                     httprepository(make_ui('db'), value).capabilities
                 except Exception, e:
                     log.error(traceback.format_exc())
                     raise formencode.Invalid(_('invalid clone url'), value,
                                              state)
             else:
                 raise formencode.Invalid(_('Invalid clone url, provide a '
                                            'valid clone http\s url'), value,
                                          state)
             return value
 
     return _ValidCloneUri
 
 def ValidForkType(old_data):
     class _ValidForkType(formencode.validators.FancyValidator):
 
         def to_python(self, value, state):
             if old_data['repo_type'] != value:
                 raise formencode.Invalid(_('Fork have to be the same '
                                            'type as original'), value, state)
             return value
     return _ValidForkType
 
 class ValidPerms(formencode.validators.FancyValidator):
     messages = {'perm_new_member_name':_('This username or users group name'
                                          ' is not valid')}
 
     def to_python(self, value, state):
         perms_update = []
         perms_new = []
         #build a list of permission to update and new permission to create
         for k, v in value.items():
             #means new added member to permissions
             if k.startswith('perm_new_member'):
                 new_perm = value.get('perm_new_member', False)
                 new_member = value.get('perm_new_member_name', False)
                 new_type = value.get('perm_new_member_type')
 
                 if new_member and new_perm:
                     if (new_member, new_perm, new_type) not in perms_new:
                         perms_new.append((new_member, new_perm, new_type))
             elif k.startswith('u_perm_') or k.startswith('g_perm_'):
                 member = k[7:]
                 t = {'u':'user',
                      'g':'users_group'}[k[0]]
                 if member == 'default':
                     if value['private']:
                         #set none for default when updating to private repo
                         v = 'repository.none'
                 perms_update.append((member, v, t))
 
         value['perms_updates'] = perms_update
         value['perms_new'] = perms_new
 
         #update permissions
-        sa = meta.Session
         for k, v, t in perms_new:
             try:
                 if t is 'user':
-                    self.user_db = sa.query(User)\
+                    self.user_db = User.query()\
                         .filter(User.active == True)\
                         .filter(User.username == k).one()
                 if t is 'users_group':
-                    self.user_db = sa.query(UsersGroup)\
+                    self.user_db = UsersGroup.query()\
                         .filter(UsersGroup.users_group_active == True)\
                         .filter(UsersGroup.users_group_name == k).one()
 
             except Exception:
                 msg = self.message('perm_new_member_name',
                                      state=State_obj)
                 raise formencode.Invalid(msg, value, state,
                                          error_dict={'perm_new_member_name':msg})
         return value
 
 class ValidSettings(formencode.validators.FancyValidator):
 
     def to_python(self, value, state):
         #settings  form can't edit user
         if value.has_key('user'):
             del['value']['user']
 
         return value
 
 class ValidPath(formencode.validators.FancyValidator):
     def to_python(self, value, state):
 
         if not os.path.isdir(value):
             msg = _('This is not a valid path')
             raise formencode.Invalid(msg, value, state,
                                      error_dict={'paths_root_path':msg})
         return value
 
 def UniqSystemEmail(old_data):
     class _UniqSystemEmail(formencode.validators.FancyValidator):
         def to_python(self, value, state):
             value = value.lower()
             if old_data.get('email') != value:
-                sa = meta.Session()
-                try:
-                    user = sa.query(User).filter(User.email == value).scalar()
+                user = User.query().filter(User.email == value).scalar()
                     if user:
-                        raise formencode.Invalid(_("This e-mail address is already taken") ,
+                    raise formencode.Invalid(
+                                    _("This e-mail address is already taken"),
                                                  value, state)
-                finally:
-                    meta.Session.remove()
-
             return value
 
     return _UniqSystemEmail
 
 class ValidSystemEmail(formencode.validators.FancyValidator):
     def to_python(self, value, state):
         value = value.lower()
-        sa = meta.Session
-        try:
-            user = sa.query(User).filter(User.email == value).scalar()
+        user = User.query().filter(User.email == value).scalar()
             if  user is None:
                 raise formencode.Invalid(_("This e-mail address doesn't exist.") ,
                                          value, state)
-        finally:
-            meta.Session.remove()
 
         return value
 
 class LdapLibValidator(formencode.validators.FancyValidator):
 
     def to_python(self, value, state):
 
         try:
             import ldap
         except ImportError:
             raise LdapImportError
         return value
 
 class AttrLoginValidator(formencode.validators.FancyValidator):
 
     def to_python(self, value, state):
 
         if not value or not isinstance(value, (str, unicode)):
             raise formencode.Invalid(_("The LDAP Login attribute of the CN "
                                        "must be specified - this is the name "
                                        "of the attribute that is equivalent "
                                        "to 'username'"),
                                      value, state)
 
         return value
 
 #===============================================================================
 # FORMS
 #===============================================================================
 class LoginForm(formencode.Schema):
     allow_extra_fields = True
     filter_extra_fields = True
     username = UnicodeString(
                              strip=True,
                              min=1,
                              not_empty=True,
                              messages={
                                        'empty':_('Please enter a login'),
                                        'tooShort':_('Enter a value %(min)i characters long or more')}
                             )
 
     password = UnicodeString(
                             strip=True,
                             min=6,
                             not_empty=True,
                             messages={
                                       'empty':_('Please enter a password'),
                                       'tooShort':_('Enter %(min)i characters or more')}
                                 )
 
 
     #chained validators have access to all data
     chained_validators = [ValidAuth]
 
 def UserForm(edit=False, old_data={}):
     class _UserForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         username = All(UnicodeString(strip=True, min=1, not_empty=True),
                        ValidUsername(edit, old_data))
         if edit:
             new_password = All(UnicodeString(strip=True, min=6, not_empty=False))
             admin = StringBoolean(if_missing=False)
         else:
             password = All(UnicodeString(strip=True, min=6, not_empty=True))
         active = StringBoolean(if_missing=False)
         name = UnicodeString(strip=True, min=1, not_empty=True)
         lastname = UnicodeString(strip=True, min=1, not_empty=True)
         email = All(Email(not_empty=True), UniqSystemEmail(old_data))
 
         chained_validators = [ValidPassword]
 
     return _UserForm
 
 
 def UsersGroupForm(edit=False, old_data={}, available_members=[]):
     class _UsersGroupForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         users_group_name = All(UnicodeString(strip=True, min=1, not_empty=True),
                        ValidUsersGroup(edit, old_data))
 
         users_group_active = StringBoolean(if_missing=False)
 
         if edit:
             users_group_members = OneOf(available_members, hideList=False,
                                         testValueList=True,
                                         if_missing=None, not_empty=False)
 
     return _UsersGroupForm
 
+def ReposGroupForm(edit=False, old_data={}, available_groups=[]):
+    class _ReposGroupForm(formencode.Schema):
+        allow_extra_fields = True
+        filter_extra_fields = True
+
+        repos_group_name = All(UnicodeString(strip=True, min=1, not_empty=True),
+                               SlugifyName())
+        repos_group_description = UnicodeString(strip=True, min=1,
+                                                not_empty=True)
+        repos_group_parent = OneOf(available_groups, hideList=False,
+                                        testValueList=True,
+                                        if_missing=None, not_empty=False)
+
+        chained_validators = [ValidReposGroup(edit, old_data)]
+
+    return _ReposGroupForm
+
 def RegisterForm(edit=False, old_data={}):
     class _RegisterForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         username = All(ValidUsername(edit, old_data),
                        UnicodeString(strip=True, min=1, not_empty=True))
         password = All(UnicodeString(strip=True, min=6, not_empty=True))
         password_confirmation = All(UnicodeString(strip=True, min=6, not_empty=True))
         active = StringBoolean(if_missing=False)
         name = UnicodeString(strip=True, min=1, not_empty=True)
         lastname = UnicodeString(strip=True, min=1, not_empty=True)
         email = All(Email(not_empty=True), UniqSystemEmail(old_data))
 
         chained_validators = [ValidPasswordsMatch, ValidPassword]
 
     return _RegisterForm
 
 def PasswordResetForm():
     class _PasswordResetForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         email = All(ValidSystemEmail(), Email(not_empty=True))
     return _PasswordResetForm
 
 def RepoForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),
              repo_groups=[]):
     class _RepoForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),
-                        SlugifyRepo())
+                        SlugifyName())
         clone_uri = All(UnicodeString(strip=True, min=1, not_empty=False),
                         ValidCloneUri()())
         repo_group = OneOf(repo_groups, hideList=True)
         repo_type = OneOf(supported_backends)
         description = UnicodeString(strip=True, min=1, not_empty=True)
         private = StringBoolean(if_missing=False)
         enable_statistics = StringBoolean(if_missing=False)
         enable_downloads = StringBoolean(if_missing=False)
 
         if edit:
             #this is repo owner
             user = All(UnicodeString(not_empty=True), ValidRepoUser)
 
         chained_validators = [ValidRepoName(edit, old_data), ValidPerms]
     return _RepoForm
 
 def RepoForkForm(edit=False, old_data={}, supported_backends=BACKENDS.keys()):
     class _RepoForkForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         fork_name = All(UnicodeString(strip=True, min=1, not_empty=True),
-                        SlugifyRepo())
+                        SlugifyName())
         description = UnicodeString(strip=True, min=1, not_empty=True)
         private = StringBoolean(if_missing=False)
         repo_type = All(ValidForkType(old_data), OneOf(supported_backends))
     return _RepoForkForm
 
 def RepoSettingsForm(edit=False, old_data={}):
     class _RepoForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),
-                        SlugifyRepo())
+                        SlugifyName())
         description = UnicodeString(strip=True, min=1, not_empty=True)
         private = StringBoolean(if_missing=False)
 
         chained_validators = [ValidRepoName(edit, old_data), ValidPerms, ValidSettings]
     return _RepoForm
 
 
 def ApplicationSettingsForm():
     class _ApplicationSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         rhodecode_title = UnicodeString(strip=True, min=1, not_empty=True)
         rhodecode_realm = UnicodeString(strip=True, min=1, not_empty=True)
         rhodecode_ga_code = UnicodeString(strip=True, min=1, not_empty=False)
 
     return _ApplicationSettingsForm
 
 def ApplicationUiSettingsForm():
     class _ApplicationUiSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         web_push_ssl = OneOf(['true', 'false'], if_missing='false')
         paths_root_path = All(ValidPath(), UnicodeString(strip=True, min=1, not_empty=True))
         hooks_changegroup_update = OneOf(['True', 'False'], if_missing=False)
         hooks_changegroup_repo_size = OneOf(['True', 'False'], if_missing=False)
         hooks_pretxnchangegroup_push_logger = OneOf(['True', 'False'], if_missing=False)
         hooks_preoutgoing_pull_logger = OneOf(['True', 'False'], if_missing=False)
 
     return _ApplicationUiSettingsForm
 
 def DefaultPermissionsForm(perms_choices, register_choices, create_choices):
     class _DefaultPermissionsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         overwrite_default = StringBoolean(if_missing=False)
         anonymous = OneOf(['True', 'False'], if_missing=False)
         default_perm = OneOf(perms_choices)
         default_register = OneOf(register_choices)
         default_create = OneOf(create_choices)
 
     return _DefaultPermissionsForm
 
 
 def LdapSettingsForm(tls_reqcert_choices, search_scope_choices, tls_kind_choices):
     class _LdapSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         pre_validators = [LdapLibValidator]
         ldap_active = StringBoolean(if_missing=False)
         ldap_host = UnicodeString(strip=True,)
         ldap_port = Number(strip=True,)
         ldap_tls_kind = OneOf(tls_kind_choices)
         ldap_tls_reqcert = OneOf(tls_reqcert_choices)
         ldap_dn_user = UnicodeString(strip=True,)
         ldap_dn_pass = UnicodeString(strip=True,)
         ldap_base_dn = UnicodeString(strip=True,)
         ldap_filter = UnicodeString(strip=True,)
         ldap_search_scope = OneOf(search_scope_choices)
         ldap_attr_login = All(AttrLoginValidator, UnicodeString(strip=True,))
         ldap_attr_firstname = UnicodeString(strip=True,)
         ldap_attr_lastname = UnicodeString(strip=True,)
         ldap_attr_email = UnicodeString(strip=True,)
 
     return _LdapSettingsForm

rhodecode/public/css/style.css

@@ -1,2658 +1,2665 b''
 html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,caption,tbody,tfoot,thead,tr,th,td {
 border:0;
 outline:0;
 font-size:100%;
 vertical-align:baseline;
 background:transparent;
 margin:0;
 padding:0;
 }
 
 body {
 line-height:1;
 height:100%;
 background:url("../images/background.png") repeat scroll 0 0 #B0B0B0;
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:12px;
 color:#000;
 margin:0;
 padding:0;
 }
 
 ol,ul {
 list-style:none;
 }
 
 blockquote,q {
 quotes:none;
 }
 
 blockquote:before,blockquote:after,q:before,q:after {
 content:none;
 }
 
 :focus {
 outline:0;
 }
 
 del {
 text-decoration:line-through;
 }
 
 table {
 border-collapse:collapse;
 border-spacing:0;
 }
 
 html {
 height:100%;
 }
 
 a {
 color:#003367;
 text-decoration:none;
 cursor:pointer;
 font-weight:700;
 }
 
 a:hover {
 color:#316293;
 text-decoration:underline;
 }
 
 h1,h2,h3,h4,h5,h6 {
 color:#292929;
 font-weight:700;
 }
 
 h1 {
 font-size:22px;
 }
 
 h2 {
 font-size:20px;
 }
 
 h3 {
 font-size:18px;
 }
 
 h4 {
 font-size:16px;
 }
 
 h5 {
 font-size:14px;
 }
 
 h6 {
 font-size:11px;
 }
 
 ul.circle {
 list-style-type:circle;
 }
 
 ul.disc {
 list-style-type:disc;
 }
 
 ul.square {
 list-style-type:square;
 }
 
 ol.lower-roman {
 list-style-type:lower-roman;
 }
 
 ol.upper-roman {
 list-style-type:upper-roman;
 }
 
 ol.lower-alpha {
 list-style-type:lower-alpha;
 }
 
 ol.upper-alpha {
 list-style-type:upper-alpha;
 }
 
 ol.decimal {
 list-style-type:decimal;
 }
 
 div.color {
 clear:both;
 overflow:hidden;
 position:absolute;
 background:#FFF;
 margin:7px 0 0 60px;
 padding:1px 1px 1px 0;
 }
 
 div.color a {
 width:15px;
 height:15px;
 display:block;
 float:left;
 margin:0 0 0 1px;
 padding:0;
 }
 
 div.options {
 clear:both;
 overflow:hidden;
 position:absolute;
 background:#FFF;
 margin:7px 0 0 162px;
 padding:0;
 }
 
 div.options a {
 height:1%;
 display:block;
 text-decoration:none;
 margin:0;
 padding:3px 8px;
 }
 
 .top-left-rounded-corner {
 -webkit-border-top-left-radius: 8px;
 -khtml-border-radius-topleft: 8px; 
 -moz-border-radius-topleft: 8px;
 border-top-left-radius: 8px;
 }
 
 .top-right-rounded-corner {
 -webkit-border-top-right-radius: 8px;
 -khtml-border-radius-topright: 8px;    
 -moz-border-radius-topright: 8px;
 border-top-right-radius: 8px;
 }
 
 .bottom-left-rounded-corner {
 -webkit-border-bottom-left-radius: 8px;
 -khtml-border-radius-bottomleft: 8px;  
 -moz-border-radius-bottomleft: 8px;
 border-bottom-left-radius: 8px;
 }
 
 .bottom-right-rounded-corner {
 -webkit-border-bottom-right-radius: 8px;
 -khtml-border-radius-bottomright: 8px; 
 -moz-border-radius-bottomright: 8px;
 border-bottom-right-radius: 8px;
 }
 
 
 #header {
 margin:0;
 padding:0 10px;
 }
 
 
 #header ul#logged-user{
 margin-bottom:5px !important;
 -webkit-border-radius: 0px 0px 8px 8px;
 -khtml-border-radius: 0px 0px 8px 8px; 
 -moz-border-radius: 0px 0px 8px 8px;
 border-radius: 0px 0px 8px 8px;
 height:37px;
 background:url("../images/header_inner.png") repeat-x scroll 0 0 #003367
 }
 
 #header ul#logged-user li {
 list-style:none;
 float:left;
 margin:8px 0 0;
 padding:4px 12px;
 border-left: 1px solid #316293;
 }
 
 #header ul#logged-user li.first {
 border-left:none;
 margin:4px;
 }
 
 #header ul#logged-user li.first div.gravatar {
 margin-top:-2px;
 }
 
 #header ul#logged-user li.first div.account {
 padding-top:4px;
 float:left;
 }
 
 #header ul#logged-user li.last {
 border-right:none;
 }
 
 #header ul#logged-user li a {
 color:#fff;
 font-weight:700;
 text-decoration:none;
 }
 
 #header ul#logged-user li a:hover {
 text-decoration:underline;
 }
 
 #header ul#logged-user li.highlight a {
 color:#fff;
 }
 
 #header ul#logged-user li.highlight a:hover {
 color:#FFF;
 }
 
 #header #header-inner {
 height:40px;
 clear:both;
 position:relative;
 background:#003367 url("../images/header_inner.png") repeat-x;
 border-bottom:2px solid #fff;
 margin:0;
 padding:0;
 }
 
 #header #header-inner #home a {
 height:40px;
 width:46px;
 display:block;
 background:url("../images/button_home.png");
 background-position:0 0;
 margin:0;
 padding:0;
 }
 
 #header #header-inner #home a:hover {
 background-position:0 -40px;
 }
 
 #header #header-inner #logo h1 {
 color:#FFF;
 font-size:18px;
 margin:10px 0 0 13px;
 padding:0;
 }
 
 #header #header-inner #logo a {
 color:#fff;
 text-decoration:none;
 }
 
 #header #header-inner #logo a:hover {
 color:#bfe3ff;
 }
 
 #header #header-inner #quick,#header #header-inner #quick ul {
 position:relative;
 float:right;
 list-style-type:none;
 list-style-position:outside;
 margin:10px 5px 0 0;
 padding:0;
 }
 
 #header #header-inner #quick li {
 position:relative;
 float:left;
 margin:0 5px 0 0;
 padding:0;
 }
 
 #header #header-inner #quick li a {
 top:0;
 left:0;
 height:1%;
 display:block;
 clear:both;
 overflow:hidden;
 color:#FFF;
 font-weight:700;
 text-decoration:none;
 background:#369 url("../images/quick_l.png") no-repeat top left;
 padding:0;
 }
 
 #header #header-inner #quick li span.short {
 padding:9px 6px 8px 6px;
 }
 
 #header #header-inner #quick li span {
 top:0;
 right:0;
 height:1%;
 display:block;
 float:left;
 background:url("../images/quick_r.png") no-repeat top right;
 border-left:1px solid #3f6f9f;
 margin:0;
 padding:10px 12px 8px 10px;
 }
 
 #header #header-inner #quick li span.normal {
 border:none;
 padding:10px 12px 8px;
 }
 
 #header #header-inner #quick li span.icon {
 top:0;
 left:0;
 border-left:none;
 background:url("../images/quick_l.png") no-repeat top left;
 border-right:1px solid #2e5c89;
 padding:8px 8px 4px;
 }
 
 #header #header-inner #quick li span.icon_short {
 top:0;
 left:0;
 border-left:none;
 background:url("../images/quick_l.png") no-repeat top left;
 border-right:1px solid #2e5c89;
 padding:9px 4px 4px;
 }
 
 #header #header-inner #quick li a:hover {
 background:#4e4e4e url("../images/quick_l_selected.png") no-repeat top left;
 }
 
 #header #header-inner #quick li a:hover span {
 border-left:1px solid #545454;
 background:url("../images/quick_r_selected.png") no-repeat top right;
 }
 
 #header #header-inner #quick li a:hover span.icon,#header #header-inner #quick li a:hover span.icon_short {
 border-left:none;
 border-right:1px solid #464646;
 background:url("../images/quick_l_selected.png") no-repeat top left;
 }
 
 
 #header #header-inner #quick ul {
 top:29px;
 right:0;
 min-width:200px;
 display:none;
 position:absolute;
 background:#FFF;
 border:1px solid #666;
 border-top:1px solid #003367;
 z-index:100;
 margin:0;
 padding:0;
 }
 
 #header #header-inner #quick ul.repo_switcher {
 max-height:275px;
 overflow-x:hidden;
 overflow-y:auto;
 }
 #header #header-inner #quick ul.repo_switcher li.qfilter_rs {
 float:none;
 margin:0;
 border-bottom:2px solid #003367;
 }
 
 
 #header #header-inner #quick .repo_switcher_type{
 position:absolute;
 left:0;
 top:9px; 
 
 }
 #header #header-inner #quick li ul li {
 border-bottom:1px solid #ddd;
 }
 
 #header #header-inner #quick li ul li a {
 width:182px;
 height:auto;
 display:block;
 float:left;
 background:#FFF;
 color:#003367;
 font-weight:400;
 margin:0;
 padding:7px 9px;
 }
 
 #header #header-inner #quick li ul li a:hover {
 color:#000;
 background:#FFF;
 }
 
 #header #header-inner #quick ul ul {
 top:auto;
 }
 
 #header #header-inner #quick li ul ul {
 right:200px;
 max-height:275px;
 overflow:auto;
 overflow-x:hidden;
 white-space:normal;
 }
 
 #header #header-inner #quick li ul li a.journal,#header #header-inner #quick li ul li a.journal:hover {
 background:url("../images/icons/book.png") no-repeat scroll 4px 9px #FFF;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.private_repo,#header #header-inner #quick li ul li a.private_repo:hover {
 background:url("../images/icons/lock.png") no-repeat scroll 4px 9px #FFF;
 min-width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.public_repo,#header #header-inner #quick li ul li a.public_repo:hover {
 background:url("../images/icons/lock_open.png") no-repeat scroll 4px 9px #FFF;
 min-width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.hg,#header #header-inner #quick li ul li a.hg:hover {
 background:url("../images/icons/hgicon.png") no-repeat scroll 4px 9px #FFF;
 min-width:167px;
 margin:0 0 0 14px;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.git,#header #header-inner #quick li ul li a.git:hover {
 background:url("../images/icons/giticon.png") no-repeat scroll 4px 9px #FFF;
 min-width:167px;
 margin:0 0 0 14px;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.repos,#header #header-inner #quick li ul li a.repos:hover {
 background:url("../images/icons/database_edit.png") no-repeat scroll 4px 9px #FFF;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
+#header #header-inner #quick li ul li a.repos_groups,#header #header-inner #quick li ul li a.repos_groups:hover {
+background:url("../images/icons/database_link.png") no-repeat scroll 4px 9px #FFF;
+width:167px;
+margin:0;
+padding:12px 9px 7px 24px;
+}
+
 #header #header-inner #quick li ul li a.users,#header #header-inner #quick li ul li a.users:hover {
 background:#FFF url("../images/icons/user_edit.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.groups,#header #header-inner #quick li ul li a.groups:hover {
 background:#FFF url("../images/icons/group_edit.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.settings,#header #header-inner #quick li ul li a.settings:hover {
 background:#FFF url("../images/icons/cog.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.permissions,#header #header-inner #quick li ul li a.permissions:hover {
 background:#FFF url("../images/icons/key.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.ldap,#header #header-inner #quick li ul li a.ldap:hover {
 background:#FFF url("../images/icons/server_key.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.fork,#header #header-inner #quick li ul li a.fork:hover {
 background:#FFF url("../images/icons/arrow_divide.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.search,#header #header-inner #quick li ul li a.search:hover {
 background:#FFF url("../images/icons/search_16.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.delete,#header #header-inner #quick li ul li a.delete:hover {
 background:#FFF url("../images/icons/delete.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.branches,#header #header-inner #quick li ul li a.branches:hover {
 background:#FFF url("../images/icons/arrow_branch.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.tags,#header #header-inner #quick li ul li a.tags:hover {
 background:#FFF url("../images/icons/tag_blue.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #header #header-inner #quick li ul li a.admin,#header #header-inner #quick li ul li a.admin:hover {
 background:#FFF url("../images/icons/cog_edit.png") no-repeat 4px 9px;
 width:167px;
 margin:0;
 padding:12px 9px 7px 24px;
 }
 
 #content #left {
 left:0;
 width:280px;
 position:absolute;
 }
 
 #content #right {
 margin:0 60px 10px 290px;
 }
 
 #content div.box {
 clear:both;
 overflow:hidden;
 background:#fff;
 margin:0 0 10px;
 padding:0 0 10px;
 }
 
 #content div.box-left {
 width:49%;
 clear:none;
 float:left;
 margin:0 0 10px;
 }
 
 #content div.box-right {
 width:49%;
 clear:none;
 float:right;
 margin:0 0 10px;
 }
 
 #content div.box div.title {
 clear:both;
 overflow:hidden;
 background:#369 url("../images/header_inner.png") repeat-x;
 margin:0 0 20px;
 padding:0;
 }
 
 #content div.box div.title h5 {
 float:left;
 border:none;
 color:#fff;
 text-transform:uppercase;
 margin:0;
 padding:11px 0 11px 10px;
 }
 
 #content div.box div.title ul.links li {
 list-style:none;
 float:left;
 margin:0;
 padding:0;
 }
 
 #content div.box div.title ul.links li a {
     border-left: 1px solid #316293;
     color: #FFFFFF;
     display: block;
     float: left;
     font-size: 13px;
     font-weight: 700;
     height: 1%;
     margin: 0;
     padding: 11px 22px 12px;
     text-decoration: none;
 }
 
 #content div.box h1,#content div.box h2,#content div.box h3,#content div.box h4,#content div.box h5,#content div.box h6 {
 clear:both;
 overflow:hidden;
 border-bottom:1px solid #DDD;
 margin:10px 20px;
 padding:0 0 15px;
 }
 
 #content div.box p {
 color:#5f5f5f;
 font-size:12px;
 line-height:150%;
 margin:0 24px 10px;
 padding:0;
 }
 
 #content div.box blockquote {
 border-left:4px solid #DDD;
 color:#5f5f5f;
 font-size:11px;
 line-height:150%;
 margin:0 34px;
 padding:0 0 0 14px;
 }
 
 #content div.box blockquote p {
 margin:10px 0;
 padding:0;
 }
 
 #content div.box dl {
 margin:10px 24px;
 }
 
 #content div.box dt {
 font-size:12px;
 margin:0;
 }
 
 #content div.box dd {
 font-size:12px;
 margin:0;
 padding:8px 0 8px 15px;
 }
 
 #content div.box li {
 font-size:12px;
 padding:4px 0;
 }
 
 #content div.box ul.disc,#content div.box ul.circle {
 margin:10px 24px 10px 38px;
 }
 
 #content div.box ul.square {
 margin:10px 24px 10px 40px;
 }
 
 #content div.box img.left {
 border:none;
 float:left;
 margin:10px 10px 10px 0;
 }
 
 #content div.box img.right {
 border:none;
 float:right;
 margin:10px 0 10px 10px;
 }
 
 #content div.box div.messages {
 clear:both;
 overflow:hidden;
 margin:0 20px;
 padding:0;
 }
 
 #content div.box div.message {
 clear:both;
 overflow:hidden;
 margin:0;
 padding:10px 0;
 }
 
 #content div.box div.message a {
 font-weight:400 !important;
 }
 
 #content div.box div.message div.image {
 float:left;
 margin:9px 0 0 5px;
 padding:6px;
 }
 
 #content div.box div.message div.image img {
 vertical-align:middle;
 margin:0;
 }
 
 #content div.box div.message div.text {
 float:left;
 margin:0;
 padding:9px 6px;
 }
 
 #content div.box div.message div.dismiss a {
 height:16px;
 width:16px;
 display:block;
 background:url("../images/icons/cross.png") no-repeat;
 margin:15px 14px 0 0;
 padding:0;
 }
 
 #content div.box div.message div.text h1,#content div.box div.message div.text h2,#content div.box div.message div.text h3,#content div.box div.message div.text h4,#content div.box div.message div.text h5,#content div.box div.message div.text h6 {
 border:none;
 margin:0;
 padding:0;
 }
 
 #content div.box div.message div.text span {
 height:1%;
 display:block;
 margin:0;
 padding:5px 0 0;
 }
 
 #content div.box div.message-error {
 height:1%;
 clear:both;
 overflow:hidden;
 background:#FBE3E4;
 border:1px solid #FBC2C4;
 color:#860006;
 }
 
 #content div.box div.message-error h6 {
 color:#860006;
 }
 
 #content div.box div.message-warning {
 height:1%;
 clear:both;
 overflow:hidden;
 background:#FFF6BF;
 border:1px solid #FFD324;
 color:#5f5200;
 }
 
 #content div.box div.message-warning h6 {
 color:#5f5200;
 }
 
 #content div.box div.message-notice {
 height:1%;
 clear:both;
 overflow:hidden;
 background:#8FBDE0;
 border:1px solid #6BACDE;
 color:#003863;
 }
 
 #content div.box div.message-notice h6 {
 color:#003863;
 }
 
 #content div.box div.message-success {
 height:1%;
 clear:both;
 overflow:hidden;
 background:#E6EFC2;
 border:1px solid #C6D880;
 color:#4e6100;
 }
 
 #content div.box div.message-success h6 {
 color:#4e6100;
 }
 
 #content div.box div.form div.fields div.field {
 height:1%;
 border-bottom:1px solid #DDD;
 clear:both;
 margin:0;
 padding:10px 0;
 }
 
 #content div.box div.form div.fields div.field-first {
 padding:0 0 10px;
 }
 
 #content div.box div.form div.fields div.field-noborder {
 border-bottom:0 !important;
 }
 
 #content div.box div.form div.fields div.field span.error-message {
 height:1%;
 display:inline-block;
 color:red;
 margin:8px 0 0 4px;
 padding:0;
 }
 
 #content div.box div.form div.fields div.field span.success {
 height:1%;
 display:block;
 color:#316309;
 margin:8px 0 0;
 padding:0;
 }
 
 #content div.box div.form div.fields div.field div.label {
 left:70px;
 width:auto;
 position:absolute;
 margin:0;
 padding:8px 0 0 5px;
 }
 
 #content div.box-left div.form div.fields div.field div.label,#content div.box-right div.form div.fields div.field div.label {
 clear:both;
 overflow:hidden;
 left:0;
 width:auto;
 position:relative;
 margin:0;
 padding:0 0 8px;
 }
 
 #content div.box div.form div.fields div.field div.label-select {
 padding:5px 0 0 5px;
 }
 
 #content div.box-left div.form div.fields div.field div.label-select,#content div.box-right div.form div.fields div.field div.label-select {
 padding:0 0 8px;
 }
 
 #content div.box-left div.form div.fields div.field div.label-textarea,#content div.box-right div.form div.fields div.field div.label-textarea {
 padding:0 0 8px !important;
 }
 
 #content div.box div.form div.fields div.field div.label label, div.label label{
 color:#393939;
 font-weight:700;
 }
 
 #content div.box div.form div.fields div.field div.input {
 margin:0 0 0 200px;
 }
 #content div.box-left div.form div.fields div.field div.input,#content div.box-right div.form div.fields div.field div.input {
 margin:0 0 0 0px;
 }
 
 #content div.box div.form div.fields div.field div.input input {
 background:#FFF;
 border-top:1px solid #b3b3b3;
 border-left:1px solid #b3b3b3;
 border-right:1px solid #eaeaea;
 border-bottom:1px solid #eaeaea;
 color:#000;
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:11px;
 margin:0;
 padding:7px 7px 6px;
 }
 
 
 
 #content div.box div.form div.fields div.field div.input input.small {
 width:30%;
 }
 
 #content div.box div.form div.fields div.field div.input input.medium {
 width:55%;
 }
 
 #content div.box div.form div.fields div.field div.input input.large {
 width:85%;
 }
 
 #content div.box div.form div.fields div.field div.input input.date {
 width:177px;
 }
 
 #content div.box div.form div.fields div.field div.input input.button {
 background:#D4D0C8;
 border-top:1px solid #FFF;
 border-left:1px solid #FFF;
 border-right:1px solid #404040;
 border-bottom:1px solid #404040;
 color:#000;
 margin:0;
 padding:4px 8px;
 }
 
 #content div.box div.form div.fields div.field div.textarea {
 border-top:1px solid #b3b3b3;
 border-left:1px solid #b3b3b3;
 border-right:1px solid #eaeaea;
 border-bottom:1px solid #eaeaea;
 margin:0 0 0 200px;
 padding:10px;
 }
 
 #content div.box div.form div.fields div.field div.textarea-editor {
 border:1px solid #ddd;
 padding:0;
 }
 
 #content div.box div.form div.fields div.field div.textarea textarea {
 width:100%;
 height:220px;
 overflow:hidden;
 background:#FFF;
 color:#000;
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:11px;
 outline:none;
 border-width:0;
 margin:0;
 padding:0;
 }
 
 #content div.box-left div.form div.fields div.field div.textarea textarea,#content div.box-right div.form div.fields div.field div.textarea textarea {
 width:100%;
 height:100px;
 }
 
 #content div.box div.form div.fields div.field div.textarea table {
 width:100%;
 border:none;
 margin:0;
 padding:0;
 }
 
 #content div.box div.form div.fields div.field div.textarea table td {
 background:#DDD;
 border:none;
 padding:0;
 }
 
 #content div.box div.form div.fields div.field div.textarea table td table {
 width:auto;
 border:none;
 margin:0;
 padding:0;
 }
 
 #content div.box div.form div.fields div.field div.textarea table td table td {
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:11px;
 padding:5px 5px 5px 0;
 }
 
 #content div.box div.form div.fields div.field input[type=text]:focus,#content div.box div.form div.fields div.field input[type=password]:focus,#content div.box div.form div.fields div.field input[type=file]:focus,#content div.box div.form div.fields div.field textarea:focus,#content div.box div.form div.fields div.field select:focus {
 background:#f6f6f6;
 border-color:#666;
 }
 
 div.form div.fields div.field div.button {
 margin:0;
 padding:0 0 0 8px;
 }
 
 div.form div.fields div.field div.highlight .ui-button {
 background:#4e85bb url("../images/button_highlight.png") repeat-x;
 border-top:1px solid #5c91a4;
 border-left:1px solid #2a6f89;
 border-right:1px solid #2b7089;
 border-bottom:1px solid #1a6480;
 color:#FFF;
 margin:0;
 padding:6px 12px;
 }
 
 div.form div.fields div.field div.highlight .ui-state-hover {
 background:#46a0c1 url("../images/button_highlight_selected.png") repeat-x;
 border-top:1px solid #78acbf;
 border-left:1px solid #34819e;
 border-right:1px solid #35829f;
 border-bottom:1px solid #257897;
 color:#FFF;
 margin:0;
 padding:6px 12px;
 }
 
 #content div.box div.form div.fields div.buttons div.highlight input.ui-button {
 background:#4e85bb url("../images/button_highlight.png") repeat-x;
 border-top:1px solid #5c91a4;
 border-left:1px solid #2a6f89;
 border-right:1px solid #2b7089;
 border-bottom:1px solid #1a6480;
 color:#fff;
 margin:0;
 padding:6px 12px;
 }
 
 #content div.box div.form div.fields div.buttons div.highlight input.ui-state-hover {
 background:#46a0c1 url("../images/button_highlight_selected.png") repeat-x;
 border-top:1px solid #78acbf;
 border-left:1px solid #34819e;
 border-right:1px solid #35829f;
 border-bottom:1px solid #257897;
 color:#fff;
 margin:0;
 padding:6px 12px;
 }
 
 #content div.box table {
 width:100%;
 border-collapse:collapse;
 margin:0;
 padding:0;
 }
 
 #content div.box table th {
 background:#eee;
 border-bottom:1px solid #ddd;
 padding:5px 0px 5px 5px;
 }
 
 #content div.box table th.left {
 text-align:left;
 }
 
 #content div.box table th.right {
 text-align:right;
 }
 
 #content div.box table th.center {
 text-align:center;
 }
 
 #content div.box table th.selected {
 vertical-align:middle;
 padding:0;
 }
 
 #content div.box table td {
 background:#fff;
 border-bottom:1px solid #cdcdcd;
 vertical-align:middle;
 padding:5px;
 }
 
 #content div.box table tr.selected td {
 background:#FFC;
 }
 
 #content div.box table td.selected {
 width:3%;
 text-align:center;
 vertical-align:middle;
 padding:0;
 }
 
 #content div.box table td.action {
 width:45%;
 text-align:left;
 }
 
 #content div.box table td.date {
 width:33%;
 text-align:center;
 }
 
 #content div.box div.action {
 float:right;
 background:#FFF;
 text-align:right;
 margin:10px 0 0;
 padding:0;
 }
 
 #content div.box div.action select {
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:11px;
 margin:0;
 }
 
 #content div.box div.action .ui-selectmenu {
 margin:0;
 padding:0;
 }
 
 #content div.box div.pagination {
 height:1%;
 clear:both;
 overflow:hidden;
 margin:10px 0 0;
 padding:0;
 }
 
 #content div.box div.pagination ul.pager {
 float:right;
 text-align:right;
 margin:0;
 padding:0;
 }
 
 #content div.box div.pagination ul.pager li {
 height:1%;
 float:left;
 list-style:none;
 background:#ebebeb url("../images/pager.png") repeat-x;
 border-top:1px solid #dedede;
 border-left:1px solid #cfcfcf;
 border-right:1px solid #c4c4c4;
 border-bottom:1px solid #c4c4c4;
 color:#4A4A4A;
 font-weight:700;
 margin:0 0 0 4px;
 padding:0;
 }
 
 #content div.box div.pagination ul.pager li.separator {
 padding:6px;
 }
 
 #content div.box div.pagination ul.pager li.current {
 background:#b4b4b4 url("../images/pager_selected.png") repeat-x;
 border-top:1px solid #ccc;
 border-left:1px solid #bebebe;
 border-right:1px solid #b1b1b1;
 border-bottom:1px solid #afafaf;
 color:#515151;
 padding:6px;
 }
 
 #content div.box div.pagination ul.pager li a {
 height:1%;
 display:block;
 float:left;
 color:#515151;
 text-decoration:none;
 margin:0;
 padding:6px;
 }
 
 #content div.box div.pagination ul.pager li a:hover,#content div.box div.pagination ul.pager li a:active {
 background:#b4b4b4 url("../images/pager_selected.png") repeat-x;
 border-top:1px solid #ccc;
 border-left:1px solid #bebebe;
 border-right:1px solid #b1b1b1;
 border-bottom:1px solid #afafaf;
 margin:-1px;
 }
 
 #content div.box div.pagination-wh {
 height:1%;
 clear:both;
 overflow:hidden;
 text-align:right;
 margin:10px 0 0;
 padding:0;
 }
 
 #content div.box div.pagination-right {
 float:right;
 }
 
 #content div.box div.pagination-wh a,#content div.box div.pagination-wh span.pager_dotdot {
 height:1%;
 float:left;
 background:#ebebeb url("../images/pager.png") repeat-x;
 border-top:1px solid #dedede;
 border-left:1px solid #cfcfcf;
 border-right:1px solid #c4c4c4;
 border-bottom:1px solid #c4c4c4;
 color:#4A4A4A;
 font-weight:700;
 margin:0 0 0 4px;
 padding:6px;
 }
 
 #content div.box div.pagination-wh span.pager_curpage {
 height:1%;
 float:left;
 background:#b4b4b4 url("../images/pager_selected.png") repeat-x;
 border-top:1px solid #ccc;
 border-left:1px solid #bebebe;
 border-right:1px solid #b1b1b1;
 border-bottom:1px solid #afafaf;
 color:#515151;
 font-weight:700;
 margin:0 0 0 4px;
 padding:6px;
 }
 
 #content div.box div.pagination-wh a:hover,#content div.box div.pagination-wh a:active {
 background:#b4b4b4 url("../images/pager_selected.png") repeat-x;
 border-top:1px solid #ccc;
 border-left:1px solid #bebebe;
 border-right:1px solid #b1b1b1;
 border-bottom:1px solid #afafaf;
 text-decoration:none;
 }
 
 #content div.box div.traffic div.legend {
 clear:both;
 overflow:hidden;
 border-bottom:1px solid #ddd;
 margin:0 0 10px;
 padding:0 0 10px;
 }
 
 #content div.box div.traffic div.legend h6 {
 float:left;
 border:none;
 margin:0;
 padding:0;
 }
 
 #content div.box div.traffic div.legend li {
 list-style:none;
 float:left;
 font-size:11px;
 margin:0;
 padding:0 8px 0 4px;
 }
 
 #content div.box div.traffic div.legend li.visits {
 border-left:12px solid #edc240;
 }
 
 #content div.box div.traffic div.legend li.pageviews {
 border-left:12px solid #afd8f8;
 }
 
 #content div.box div.traffic table {
 width:auto;
 }
 
 #content div.box div.traffic table td {
 background:transparent;
 border:none;
 padding:2px 3px 3px;
 }
 
 #content div.box div.traffic table td.legendLabel {
 padding:0 3px 2px;
 }
 
 #summary{
 
 }
 
 #summary .desc{
 white-space: pre;
 width: 100%;
 }
 
 #summary .repo_name{
 font-size: 1.6em;
 font-weight: bold;
 vertical-align: baseline;
 clear:right
 }
 
 
 #footer {
 clear:both;
 overflow:hidden;
 text-align:right;
 margin:0;
 padding:0 10px 4px;
 margin:-10px 0 0;
 }
 
 #footer div#footer-inner {
 background:url("../images/header_inner.png") repeat-x scroll 0 0 #003367;
 border-top:2px solid #FFFFFF;
 }
 
 #footer div#footer-inner p {
 padding:15px 25px 15px 0;
 color:#FFF;
 font-weight:700;
 }
 #footer div#footer-inner .footer-link {
 float:left;
 padding-left:10px;
 }
 #footer div#footer-inner .footer-link a,#footer div#footer-inner .footer-link-right a {
 color:#FFF; 
 }
 
 #login div.title {
 width:420px;
 clear:both;
 overflow:hidden;
 position:relative;
 background:#003367 url("../images/header_inner.png") repeat-x;
 margin:0 auto;
 padding:0;
 }
 
 #login div.inner {
 width:380px;
 background:#FFF url("../images/login.png") no-repeat top left;
 border-top:none;
 border-bottom:none;
 margin:0 auto;
 padding:20px;
 }
 
 #login div.form div.fields div.field div.label {
 width:173px;
 float:left;
 text-align:right;
 margin:2px 10px 0 0;
 padding:5px 0 0 5px;
 }
 
 #login div.form div.fields div.field div.input input {
 width:176px;
 background:#FFF;
 border-top:1px solid #b3b3b3;
 border-left:1px solid #b3b3b3;
 border-right:1px solid #eaeaea;
 border-bottom:1px solid #eaeaea;
 color:#000;
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:11px;
 margin:0;
 padding:7px 7px 6px;
 }
 
 #login div.form div.fields div.buttons {
 clear:both;
 overflow:hidden;
 border-top:1px solid #DDD;
 text-align:right;
 margin:0;
 padding:10px 0 0;
 }
 
 #login div.form div.links {
 clear:both;
 overflow:hidden;
 margin:10px 0 0;
 padding:0 0 2px;
 }
 
 #quick_login{
 top: 31px;
 background-color: rgb(0, 51, 103);
 z-index: 999; 
 height: 150px;
 position: absolute;
 margin-left: -16px;
 width: 281px;
 border-radius: 0 0 8px 8px;
 }
 
 #quick_login div.form div.fields{
 padding-top: 2px;
 padding-left:10px;
 }
 
 #quick_login div.form div.fields div.field{
  padding: 5px;
 }
 
 #quick_login div.form div.fields div.field div.label label{
 color:#fff;
 padding-bottom: 3px;
 }
 
 #quick_login div.form div.fields div.field div.input input {
 width:236px;
 background:#FFF;
 border-top:1px solid #b3b3b3;
 border-left:1px solid #b3b3b3;
 border-right:1px solid #eaeaea;
 border-bottom:1px solid #eaeaea;
 color:#000;
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:11px;
 margin:0;
 padding:5px 7px 4px;
 }
 
 #quick_login div.form div.fields div.buttons {
 clear:both;
 overflow:hidden;
 text-align:right;
 margin:0;
 padding:10px 14px 0;
 }
 
 #quick_login div.form div.fields div.buttons input.ui-button{
 background:#e5e3e3 url("../images/button.png") repeat-x;
 border-top:1px solid #DDD;
 border-left:1px solid #c6c6c6;
 border-right:1px solid #DDD;
 border-bottom:1px solid #c6c6c6;
 color:#515151;
 margin:0;
 padding:4px 10px;
 }
 
 #quick_login div.form div.links {
 clear:both;
 overflow:hidden;
 margin:10px 0 0;
 padding:0 0 2px;
 }
 
 #register div.title {
 clear:both;
 overflow:hidden;
 position:relative;
 background:#003367 url("../images/header_inner.png") repeat-x;
 margin:0 auto;
 padding:0;
 }
 
 #register div.inner {
 background:#FFF;
 border-top:none;
 border-bottom:none;
 margin:0 auto;
 padding:20px;
 }
 
 #register div.form div.fields div.field div.label {
 width:135px;
 float:left;
 text-align:right;
 margin:2px 10px 0 0;
 padding:5px 0 0 5px;
 }
 
 #register div.form div.fields div.field div.input input {
 width:300px;
 background:#FFF;
 border-top:1px solid #b3b3b3;
 border-left:1px solid #b3b3b3;
 border-right:1px solid #eaeaea;
 border-bottom:1px solid #eaeaea;
 color:#000;
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:11px;
 margin:0;
 padding:7px 7px 6px;
 }
 
 #register div.form div.fields div.buttons {
 clear:both;
 overflow:hidden;
 border-top:1px solid #DDD;
 text-align:left;
 margin:0;
 padding:10px 0 0 150px;
 }
 
 #register div.form div.fields div.buttons div.highlight input.ui-button {
 background:url("../images/button_highlight.png") repeat-x scroll 0 0 #4E85BB;
 color:#FFF;
 border-color:#5C91A4 #2B7089 #1A6480 #2A6F89;
 border-style:solid;
 border-width:1px;
 }
 
 #register div.form div.activation_msg {
 padding-top:4px;
 padding-bottom:4px;
 }
 
 #journal .journal_day{
 font-size:20px;
 padding:10px 0px;
 border-bottom:2px solid #DDD;
 margin-left:10px;
 margin-right:10px;
 }
 
 #journal .journal_container{
 padding:5px;
 clear:both;
 margin:0px 5px 0px 10px;
 }
 
 #journal .journal_action_container{
 padding-left:38px;
 }
 
 #journal .journal_user{
 color: #747474;
 font-size: 14px;
 font-weight: bold;
 height: 30px;
 }
 #journal .journal_icon{
 clear: both;
 float: left;
 padding-right: 4px;
 padding-top: 3px;
 }
 #journal .journal_action{
 padding-top:4px;
 min-height:2px;
 float:left
 }
 #journal .journal_action_params{
 clear: left;
 padding-left: 22px;
 }
 #journal .journal_repo{
 float: left;
 margin-left: 6px;
 padding-top: 3px;
 }
 #journal .date{
 clear: both;
 color: #777777;
 font-size: 11px;
 padding-left: 22px;
 }
 #journal .journal_repo .journal_repo_name{
 font-weight: bold;
 font-size: 1.1em;
 }
 #journal .compare_view{
 padding: 5px 0px 5px 0px;
 width: 95px;
 }
 .journal_highlight{
 font-weight: bold;
 padding: 0 2px;
 vertical-align: bottom;
 }
 .trending_language_tbl,.trending_language_tbl td {
 border:0 !important;
 margin:0 !important;
 padding:0 !important;
 }
 
 .trending_language {
 background-color:#003367;
 color:#FFF;
 display:block;
 min-width:20px;
 text-decoration:none;
 height:12px;
 margin-bottom:4px;
 margin-left:5px;
 white-space:pre;
 padding:3px;
 }
 
 h3.files_location {
 font-size:1.8em;
 font-weight:700;
 border-bottom:none !important;
 margin:10px 0 !important;
 }
 
 #files_data dl dt {
 float:left;
 width:115px;
 margin:0 !important;
 padding:5px;
 }
 
 #files_data dl dd {
 margin:0 !important;
 padding:5px !important;
 }
 
 #changeset_content {
 border:1px solid #CCC;
 padding:5px;
 }
 #changeset_compare_view_content{
 border:1px solid #CCC;
 padding:5px;
 }
 
 #changeset_content .container {
 min-height:120px;
 font-size:1.2em;
 overflow:hidden;
 }
 
 #changeset_compare_view_content .compare_view_commits{
 width: auto !important;
 }
 
 #changeset_compare_view_content .compare_view_commits td{
 padding:0px 0px 0px 12px !important;
 }
 
 #changeset_content .container .right {
 float:right;
 width:25%;
 text-align:right;
 }
 
 #changeset_content .container .left .message {
 font-style:italic;
 color:#556CB5;
 white-space:pre-wrap;
 }
 
 .cs_files .cur_cs{
 margin:10px 2px;
 font-weight: bold;
 }
 
 .cs_files .node{
 float: left;
 }
 .cs_files .changes{
 float: right;
 }
 .cs_files .changes .added{
 background-color: #BBFFBB;
 float: left;
 text-align: center;
 font-size: 90%; 
 }
 .cs_files .changes .deleted{
 background-color: #FF8888;
 float: left;
 text-align: center;
 font-size: 90%;
 }
 .cs_files .cs_added {
 background:url("../images/icons/page_white_add.png") no-repeat scroll 3px;
 height:16px;
 padding-left:20px;
 margin-top:7px;
 text-align:left;
 }
 
 .cs_files .cs_changed {
 background:url("../images/icons/page_white_edit.png") no-repeat scroll 3px;
 height:16px;
 padding-left:20px;
 margin-top:7px;
 text-align:left;
 }
 
 .cs_files .cs_removed {
 background:url("../images/icons/page_white_delete.png") no-repeat scroll 3px;
 height:16px;
 padding-left:20px;
 margin-top:7px;
 text-align:left;
 }
 
 #graph {
 overflow:hidden;
 }
 
 #graph_nodes {
 width:160px;
 float:left;
 margin-left:-50px;
 margin-top:5px;
 }
 
 #graph_content {
 width:800px;
 float:left;
 }
 
 #graph_content .container_header {
 border:1px solid #CCC;
 padding:10px;
 }
 #graph_content #rev_range_container{
 padding:10px 0px;
 }
 #graph_content .container {
 border-bottom:1px solid #CCC;
 border-left:1px solid #CCC;
 border-right:1px solid #CCC;
 min-height:80px;
 overflow:hidden;
 font-size:1.2em;
 }
 
 #graph_content .container .right {
 float:right;
 width:28%;
 text-align:right;
 padding-bottom:5px;
 }
 
 #graph_content .container .left .date {
 font-weight:700;
 padding-bottom:5px;
 }
 #graph_content .container .left .date span{
 vertical-align: text-top;    
 }
 
 #graph_content .container .left .message {
 font-size:100%;
 padding-top:3px;
 white-space:pre-wrap;
 }
 
 .right div {
 clear:both;
 }
 
 .right .changes .added,.changed,.removed {
 border:1px solid #DDD;
 display:block;
 float:right;
 text-align:center;
 min-width:15px;
 cursor: help;
 }
 .right .changes .large {
 border:1px solid #DDD;
 display:block;
 float:right;
 text-align:center;
 min-width:45px;
 cursor: help;
 background: #54A9F7;
 }
 
 .right .changes .added {
 background:#BFB;
 }
 
 .right .changes .changed {
 background:#FD8;
 }
 
 .right .changes .removed {
 background:#F88;
 }
 
 .right .merge {
 vertical-align:top;
 font-size:0.75em;
 font-weight:700;
 }
 
 .right .parent {
 font-size:90%;
 font-family:monospace;
 }
 
 .right .logtags .branchtag {
 background:#FFF url("../images/icons/arrow_branch.png") no-repeat right 6px;
 display:block;
 font-size:0.8em;
 padding:11px 16px 0 0;
 }
 
 .right .logtags .tagtag {
 background:#FFF url("../images/icons/tag_blue.png") no-repeat right 6px;
 display:block;
 font-size:0.8em;
 padding:11px 16px 0 0;
 }
 
 div.browserblock {
 overflow:hidden;
 border:1px solid #ccc;
 background:#f8f8f8;
 font-size:100%;
 line-height:125%;
 padding:0;
 }
 
 div.browserblock .browser-header {
 background:#FFF;
 padding:10px 0px 25px 0px;
 width: 100%;
 }
 div.browserblock .browser-nav {
 float:left
 }
 
 div.browserblock .browser-branch {
 float:left;
 }
 
 div.browserblock .browser-branch label {
 color:#4A4A4A;
 vertical-align:text-top;
 }
 
 div.browserblock .browser-header span {
 margin-left:5px;
 font-weight:700;
 }
 
 div.browserblock .browser-body {
 background:#EEE;
 border-top:1px solid #CCC;
 }
 
 table.code-browser {
 border-collapse:collapse;
 width:100%;
 }
 
 table.code-browser tr {
 margin:3px;
 }
 
 table.code-browser thead th {
 background-color:#EEE;
 height:20px;
 font-size:1.1em;
 font-weight:700;
 text-align:left;
 padding-left:10px;
 }
 
 table.code-browser tbody td {
 padding-left:10px;
 height:20px;
 }
 
 table.code-browser .browser-file {
 background:url("../images/icons/document_16.png") no-repeat scroll 3px;
 height:16px;
 padding-left:20px;
 text-align:left;
 }
 .diffblock .changeset_file{
 background:url("../images/icons/file.png") no-repeat scroll 3px;
 height:16px;
 padding-left:22px;
 text-align:left;
 font-size: 14px;
 }
 
 .diffblock .changeset_header{
 margin-left: 6px !important;
 }
 
 table.code-browser .browser-dir {
 background:url("../images/icons/folder_16.png") no-repeat scroll 3px;
 height:16px;
 padding-left:20px;
 text-align:left;
 }
 
 .box .search {
 clear:both;
 overflow:hidden;
 margin:0;
 padding:0 20px 10px;
 }
 
 .box .search div.search_path {
 background:none repeat scroll 0 0 #EEE;
 border:1px solid #CCC;
 color:blue;
 margin-bottom:10px;
 padding:10px 0;
 }
 
 .box .search div.search_path div.link {
 font-weight:700;
 margin-left:25px;
 }
 
 .box .search div.search_path div.link a {
 color:#003367;
 cursor:pointer;
 text-decoration:none;
 }
 
 #path_unlock {
 color:red;
 font-size:1.2em;
 padding-left:4px;
 }
 
 .info_box span {
 margin-left:3px;
 margin-right:3px;
 }
 
 .info_box .rev {
 color: #003367;
 font-size: 1.6em;
 font-weight: bold;
 vertical-align: sub;
 }
 
 
 .info_box input#at_rev,.info_box input#size {
 background:#FFF;
 border-top:1px solid #b3b3b3;
 border-left:1px solid #b3b3b3;
 border-right:1px solid #eaeaea;
 border-bottom:1px solid #eaeaea;
 color:#000;
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:12px;
 margin:0;
 padding:1px 5px 1px;
 }
 
 
 
 .info_box input#view {
 text-align:center;
 padding:4px 3px 2px 2px;
 }
 
 .yui-overlay,.yui-panel-container {
 visibility:hidden;
 position:absolute;
 z-index:2;
 }
 
 .yui-tt {
 visibility:hidden;
 position:absolute;
 color:#666;
 background-color:#FFF;
 font-family:arial, helvetica, verdana, sans-serif;
 border:2px solid #003367;
 font:100% sans-serif;
 width:auto;
 opacity:1px;
 padding:8px;
 white-space: pre;
 -webkit-border-radius: 8px 8px 8px 8px;
 -khtml-border-radius: 8px 8px 8px 8px; 
 -moz-border-radius: 8px 8px 8px 8px;
 border-radius: 8px 8px 8px 8px;
 }
 
 .ac {
 vertical-align:top;
 }
 
 .ac .yui-ac {
 position:relative;
 font-family:arial;
 font-size:100%;
 }
 
 .ac .perm_ac {
 width:15em;
 }
 
 .ac .yui-ac-input {
 width:100%;
 }
 
 .ac .yui-ac-container {
 position:absolute;
 top:1.6em;
 width:100%;
 }
 
 .ac .yui-ac-content {
 position:absolute;
 width:100%;
 border:1px solid gray;
 background:#fff;
 overflow:hidden;
 z-index:9050;
 }
 
 .ac .yui-ac-shadow {
 position:absolute;
 width:100%;
 background:#000;
 -moz-opacity:0.1px;
 opacity:.10;
 filter:alpha(opacity =   10);
 z-index:9049;
 margin:.3em;
 }
 
 .ac .yui-ac-content ul {
 width:100%;
 margin:0;
 padding:0;
 }
 
 .ac .yui-ac-content li {
 cursor:default;
 white-space:nowrap;
 margin:0;
 padding:2px 5px;
 }
 
 .ac .yui-ac-content li.yui-ac-prehighlight {
 background:#B3D4FF;
 }
 
 .ac .yui-ac-content li.yui-ac-highlight {
 background:#556CB5;
 color:#FFF;
 }
 
 
 .follow{
 background:url("../images/icons/heart_add.png") no-repeat scroll 3px;
 height: 16px;
 width: 20px;
 cursor: pointer;
 display: block;
 float: right;
 margin-top: 2px;
 }
 
 .following{
 background:url("../images/icons/heart_delete.png") no-repeat scroll 3px;
 height: 16px;
 width: 20px;
 cursor: pointer;
 display: block;
 float: right;
 margin-top: 2px;
 }
 
 .currently_following{
 padding-left: 10px;
 padding-bottom:5px;
 }
 
 .add_icon {
 background:url("../images/icons/add.png") no-repeat scroll 3px;
 padding-left:20px;
 padding-top:0px;
 text-align:left;
 }
 
 .edit_icon {
 background:url("../images/icons/folder_edit.png") no-repeat scroll 3px;
 padding-left:20px;
 padding-top:0px;
 text-align:left;
 }
 
 .delete_icon {
 background:url("../images/icons/delete.png") no-repeat scroll 3px;
 padding-left:20px;
 padding-top:0px;
 text-align:left;
 }
 
 .refresh_icon {
 background:url("../images/icons/arrow_refresh.png") no-repeat scroll 3px;
 padding-left:20px;
 padding-top:0px;
 text-align:left;
 }
 
 .pull_icon {
 background:url("../images/icons/connect.png") no-repeat scroll 3px;
 padding-left:20px;
 padding-top:0px;
 text-align:left;
 }
 
 .rss_icon {
 background:url("../images/icons/rss_16.png") no-repeat scroll 3px;
 padding-left:20px;
 padding-top:0px;
 text-align:left;
 }
 
 .atom_icon {
 background:url("../images/icons/atom.png") no-repeat scroll 3px;
 padding-left:20px;
 padding-top:0px;
 text-align:left;
 }
 
 .archive_icon {
 background:url("../images/icons/compress.png") no-repeat scroll 3px;
 padding-left:20px;
 text-align:left;
 padding-top:1px;
 }
 
 .start_following_icon {
 background:url("../images/icons/heart_add.png") no-repeat scroll 3px;
 padding-left:20px;
 text-align:left;
 padding-top:0px;
 }
 
 .stop_following_icon {
 background:url("../images/icons/heart_delete.png") no-repeat scroll 3px;
 padding-left:20px;
 text-align:left;
 padding-top:0px;
 }
 
 .action_button {
 border:0;
 display:inline;
 }
 
 .action_button:hover {
 border:0;
 text-decoration:underline;
 cursor:pointer;
 }
 
 #switch_repos {
 position:absolute;
 height:25px;
 z-index:1;
 }
 
 #switch_repos select {
 min-width:150px;
 max-height:250px;
 z-index:1;
 }
 
 .breadcrumbs {
 border:medium none;
 color:#FFF;
 float:left;
 text-transform:uppercase;
 font-weight:700;
 font-size:14px;
 margin:0;
 padding:11px 0 11px 10px;
 }
 
 .breadcrumbs a {
 color:#FFF;
 }
 
 .flash_msg ul {
 margin:0;
 padding:0 0 10px;
 }
 
 .error_msg {
 background-color:#FFCFCF;
 background-image:url("../images/icons/error_msg.png");
 border:1px solid #FF9595;
 color:#C30;
 }
 
 .warning_msg {
 background-color:#FFFBCC;
 background-image:url("../images/icons/warning_msg.png");
 border:1px solid #FFF35E;
 color:#C69E00;
 }
 
 .success_msg {
 background-color:#D5FFCF;
 background-image:url("../images/icons/success_msg.png");
 border:1px solid #97FF88;
 color:#090;
 }
 
 .notice_msg {
 background-color:#DCE3FF;
 background-image:url("../images/icons/notice_msg.png");
 border:1px solid #93A8FF;
 color:#556CB5;
 }
 
 .success_msg,.error_msg,.notice_msg,.warning_msg {
 background-position:10px center;
 background-repeat:no-repeat;
 font-size:12px;
 font-weight:700;
 min-height:14px;
 line-height:14px;
 margin-bottom:0;
 margin-top:0;
 display:block;
 overflow:auto;
 padding:6px 10px 6px 40px;
 }
 
 #msg_close {
 background:transparent url("../icons/cross_grey_small.png") no-repeat scroll 0 0;
 cursor:pointer;
 height:16px;
 position:absolute;
 right:5px;
 top:5px;
 width:16px;
 }
 
 div#legend_container table,div#legend_choices table {
 width:auto !important;
 }
 
 table#permissions_manage {
 width:0 !important;
 }
 
 table#permissions_manage span.private_repo_msg {
 font-size:0.8em;
 opacity:0.6px;
 }
 
 table#permissions_manage td.private_repo_msg {
 font-size:0.8em;
 }
 
 table#permissions_manage tr#add_perm_input td {
 vertical-align:middle;
 }
 
 div.gravatar {
 background-color:#FFF;
 border:1px solid #D0D0D0;
 float:left;
 margin-right:0.7em;
 padding:2px 2px 0;
 }
 
 #header,#content,#footer {
 min-width:978px;
 }
 
 #content {
 min-height:100%;
 clear:both;
 overflow:hidden;
 padding:14px 10px;
 }
 
 #content div.box div.title div.search {
 background:url("../images/title_link.png") no-repeat top left;
 border-left:1px solid #316293;
 }
 
 #content div.box div.title div.search div.input input {
 border:1px solid #316293;
 }
 
 #content div.box div.title div.search div.button input.ui-button {
 background:#4e85bb url("../images/button_highlight.png") repeat-x;
 border:1px solid #316293;
 border-left:none;
 color:#FFF;
 }
 
 #content div.box input.ui-button-small {
 background:#e5e3e3 url("../images/button.png") repeat-x;
 border-top:1px solid #DDD;
 border-left:1px solid #c6c6c6;
 border-right:1px solid #DDD;
 border-bottom:1px solid #c6c6c6;
 color:#515151;
 outline:none;
 margin:0;
 }
 
 #content div.box input.ui-button-small-blue {
 background:#4e85bb url("../images/button_highlight.png") repeat-x;
 border-top:1px solid #5c91a4;
 border-left:1px solid #2a6f89;
 border-right:1px solid #2b7089;
 border-bottom:1px solid #1a6480;
 color:#fff;
 }
 
 #content div.box input.ui-button-small submit,button{
 cursor: pointer;
 }
 
 #content div.box div.title div.search div.button input.ui-state-hover {
 background:#46a0c1 url("../images/button_highlight_selected.png") repeat-x;
 border:1px solid #316293;
 border-left:none;
 color:#FFF;
 }
 
 #content div.box div.form div.fields div.field div.highlight .ui-button {
 background:#4e85bb url("../images/button_highlight.png") repeat-x;
 border-top:1px solid #5c91a4;
 border-left:1px solid #2a6f89;
 border-right:1px solid #2b7089;
 border-bottom:1px solid #1a6480;
 color:#fff;
 }
 
 #content div.box div.form div.fields div.field div.highlight .ui-state-hover {
 background:#46a0c1 url("../images/button_highlight_selected.png") repeat-x;
 border-top:1px solid #78acbf;
 border-left:1px solid #34819e;
 border-right:1px solid #35829f;
 border-bottom:1px solid #257897;
 color:#fff;
 }
 
 ins,div.options a:hover {
 text-decoration:none;
 }
 
 img,#header #header-inner #quick li a:hover span.normal,#header #header-inner #quick li ul li.last,#content div.box div.form div.fields div.field div.textarea table td table td a,#clone_url {
 border:none;
 }
 
 img.icon,.right .merge img {
 vertical-align:bottom;
 }
 
 #header ul#logged-user,#content div.box div.title ul.links,#content div.box div.message div.dismiss,#content div.box div.traffic div.legend ul {
 float:right;
 margin:0;
 padding:0;
 }
 
 #header #header-inner #home,#header #header-inner #logo,#content div.box ul.left,#content div.box ol.left,#content div.box div.pagination-left,div#commit_history,div#legend_data,div#legend_container,div#legend_choices {
 float:left;
 }
 
 #header #header-inner #quick li:hover ul ul,#header #header-inner #quick li:hover ul ul ul,#header #header-inner #quick li:hover ul ul ul ul,#content #left #menu ul.closed,#content #left #menu li ul.collapsed,.yui-tt-shadow {
 display:none;
 }
 
 #header #header-inner #quick li:hover ul,#header #header-inner #quick li li:hover ul,#header #header-inner #quick li li li:hover ul,#header #header-inner #quick li li li li:hover ul,#content #left #menu ul.opened,#content #left #menu li ul.expanded {
 display:block;
 }
 
 #content div.graph{
 padding:0 10px 10px;
 }
 
 #content div.box div.title ul.links li a:hover,#content div.box div.title ul.links li.ui-tabs-selected a {
 color:#bfe3ff;
 }
 
 #content div.box ol.lower-roman,#content div.box ol.upper-roman,#content div.box ol.lower-alpha,#content div.box ol.upper-alpha,#content div.box ol.decimal {
 margin:10px 24px 10px 44px;
 }
 
 #content div.box div.form,#content div.box div.table,#content div.box div.traffic {
 clear:both;
 overflow:hidden;
 margin:0;
 padding:0 20px 10px;
 }
 
 #content div.box div.form div.fields,#login div.form,#login div.form div.fields,#register div.form,#register div.form div.fields {
 clear:both;
 overflow:hidden;
 margin:0;
 padding:0;
 }
 
 #content div.box div.form div.fields div.field div.label span,#login div.form div.fields div.field div.label span,#register div.form div.fields div.field div.label span {
 height:1%;
 display:block;
 color:#363636;
 margin:0;
 padding:2px 0 0;
 }
 
 #content div.box div.form div.fields div.field div.input input.error,#login div.form div.fields div.field div.input input.error,#register div.form div.fields div.field div.input input.error {
 background:#FBE3E4;
 border-top:1px solid #e1b2b3;
 border-left:1px solid #e1b2b3;
 border-right:1px solid #FBC2C4;
 border-bottom:1px solid #FBC2C4;
 }
 
 #content div.box div.form div.fields div.field div.input input.success,#login div.form div.fields div.field div.input input.success,#register div.form div.fields div.field div.input input.success {
 background:#E6EFC2;
 border-top:1px solid #cebb98;
 border-left:1px solid #cebb98;
 border-right:1px solid #c6d880;
 border-bottom:1px solid #c6d880;
 }
 
 #content div.box-left div.form div.fields div.field div.textarea,#content div.box-right div.form div.fields div.field div.textarea,#content div.box div.form div.fields div.field div.select select,#content div.box table th.selected input,#content div.box table td.selected input {
 margin:0;
 }
 
 #content div.box-left div.form div.fields div.field div.select,#content div.box-left div.form div.fields div.field div.checkboxes,#content div.box-left div.form div.fields div.field div.radios,#content div.box-right div.form div.fields div.field div.select,#content div.box-right div.form div.fields div.field div.checkboxes,#content div.box-right div.form div.fields div.field div.radios{
 margin:0 0 0 0px !important;
 padding:0;
 }
 
 #content div.box div.form div.fields div.field div.select,#content div.box div.form div.fields div.field div.checkboxes,#content div.box div.form div.fields div.field div.radios {
 margin:0 0 0 200px;
 padding:0;
 }
 
 
 #content div.box div.form div.fields div.field div.select a:hover,#content div.box div.form div.fields div.field div.select a.ui-selectmenu:hover,#content div.box div.action a:hover {
 color:#000;
 text-decoration:none;
 }
 
 #content div.box div.form div.fields div.field div.select a.ui-selectmenu-focus,#content div.box div.action a.ui-selectmenu-focus {
 border:1px solid #666;
 }
 
 #content div.box div.form div.fields div.field div.checkboxes div.checkbox,#content div.box div.form div.fields div.field div.radios div.radio {
 clear:both;
 overflow:hidden;
 margin:0;
 padding:8px 0 2px;
 }
 
 #content div.box div.form div.fields div.field div.checkboxes div.checkbox input,#content div.box div.form div.fields div.field div.radios div.radio input {
 float:left;
 margin:0;
 }
 
 #content div.box div.form div.fields div.field div.checkboxes div.checkbox label,#content div.box div.form div.fields div.field div.radios div.radio label {
 height:1%;
 display:block;
 float:left;
 margin:2px 0 0 4px;
 }
 
 div.form div.fields div.field div.button input,#content div.box div.form div.fields div.buttons input,div.form div.fields div.buttons input,#content div.box div.action div.button input {
 color:#000;
 font-family:Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;
 font-size:11px;
 font-weight:700;
 margin:0;
 }
 
 div.form div.fields div.field div.button .ui-button,#content div.box div.form div.fields div.buttons input.ui-button {
 background:#e5e3e3 url("../images/button.png") repeat-x;
 border-top:1px solid #DDD;
 border-left:1px solid #c6c6c6;
 border-right:1px solid #DDD;
 border-bottom:1px solid #c6c6c6;
 color:#515151;
 outline:none;
 margin:0;
 padding:6px 12px;
 }
 
 div.form div.fields div.field div.button .ui-state-hover,#content div.box div.form div.fields div.buttons input.ui-state-hover {
 background:#b4b4b4 url("../images/button_selected.png") repeat-x;
 border-top:1px solid #ccc;
 border-left:1px solid #bebebe;
 border-right:1px solid #b1b1b1;
 border-bottom:1px solid #afafaf;
 color:#515151;
 outline:none;
 margin:0;
 padding:6px 12px;
 }
 
 div.form div.fields div.field div.highlight,#content div.box div.form div.fields div.buttons div.highlight {
 display:inline;
 }
 
 #content div.box div.form div.fields div.buttons,div.form div.fields div.buttons {
 margin:10px 0 0 200px;
 padding:0;
 }
 
 #content div.box-left div.form div.fields div.buttons,#content div.box-right div.form div.fields div.buttons,div.box-left div.form div.fields div.buttons,div.box-right div.form div.fields div.buttons {
 margin:10px 0 0;
 }
 
 #content div.box table td.user,#content div.box table td.address {
 width:10%;
 text-align:center;
 }
 
 #content div.box div.action div.button,#login div.form div.fields div.field div.input div.link,#register div.form div.fields div.field div.input div.link {
 text-align:right;
 margin:6px 0 0;
 padding:0;
 }
 
 #content div.box div.action div.button input.ui-button,#login div.form div.fields div.buttons input.ui-button,#register div.form div.fields div.buttons input.ui-button {
 background:#e5e3e3 url("../images/button.png") repeat-x;
 border-top:1px solid #DDD;
 border-left:1px solid #c6c6c6;
 border-right:1px solid #DDD;
 border-bottom:1px solid #c6c6c6;
 color:#515151;
 margin:0;
 padding:6px 12px;
 }
 
 #content div.box div.action div.button input.ui-state-hover,#login div.form div.fields div.buttons input.ui-state-hover,#register div.form div.fields div.buttons input.ui-state-hover {
 background:#b4b4b4 url("../images/button_selected.png") repeat-x;
 border-top:1px solid #ccc;
 border-left:1px solid #bebebe;
 border-right:1px solid #b1b1b1;
 border-bottom:1px solid #afafaf;
 color:#515151;
 margin:0;
 padding:6px 12px;
 }
 
 #content div.box div.pagination div.results,#content div.box div.pagination-wh div.results {
 text-align:left;
 float:left;
 margin:0;
 padding:0;
 }
 
 #content div.box div.pagination div.results span,#content div.box div.pagination-wh div.results span {
 height:1%;
 display:block;
 float:left;
 background:#ebebeb url("../images/pager.png") repeat-x;
 border-top:1px solid #dedede;
 border-left:1px solid #cfcfcf;
 border-right:1px solid #c4c4c4;
 border-bottom:1px solid #c4c4c4;
 color:#4A4A4A;
 font-weight:700;
 margin:0;
 padding:6px 8px;
 }
 
 #content div.box div.pagination ul.pager li.disabled,#content div.box div.pagination-wh a.disabled {
 color:#B4B4B4;
 padding:6px;
 }
 
 #login,#register {
 width:520px;
 margin:10% auto 0;
 padding:0;
 }
 
 #login div.color,#register div.color {
 clear:both;
 overflow:hidden;
 background:#FFF;
 margin:10px auto 0;
 padding:3px 3px 3px 0;
 }
 
 #login div.color a,#register div.color a {
 width:20px;
 height:20px;
 display:block;
 float:left;
 margin:0 0 0 3px;
 padding:0;
 }
 
 #login div.title h5,#register div.title h5 {
 color:#fff;
 margin:10px;
 padding:0;
 }
 
 #login div.form div.fields div.field,#register div.form div.fields div.field {
 clear:both;
 overflow:hidden;
 margin:0;
 padding:0 0 10px;
 }
 
 #login div.form div.fields div.field span.error-message,#register div.form div.fields div.field span.error-message {
 height:1%;
 display:block;
 color:red;
 margin:8px 0 0;
 padding:0;
 max-width: 320px;
 }
 
 #login div.form div.fields div.field div.label label,#register div.form div.fields div.field div.label label {
 color:#000;
 font-weight:700;
 }
 
 #login div.form div.fields div.field div.input,#register div.form div.fields div.field div.input {
 float:left;
 margin:0;
 padding:0;
 }
 
 #login div.form div.fields div.field div.checkbox,#register div.form div.fields div.field div.checkbox {
 margin:0 0 0 184px;
 padding:0;
 }
 
 #login div.form div.fields div.field div.checkbox label,#register div.form div.fields div.field div.checkbox label {
 color:#565656;
 font-weight:700;
 }
 
 #login div.form div.fields div.buttons input,#register div.form div.fields div.buttons input {
 color:#000;
 font-size:1em;
 font-weight:700;
 font-family:Verdana, Helvetica, Sans-Serif;
 margin:0;
 }
 
 #changeset_content .container .wrapper,#graph_content .container .wrapper {
 width:600px;
 }
 
 #changeset_content .container .left,#graph_content .container .left {
 float:left;
 width:70%;
 padding-left:5px;
 }
 
 #changeset_content .container .left .date,.ac .match {
 font-weight:700;
 padding-top: 5px;
 padding-bottom:5px;
 }
 
 div#legend_container table td,div#legend_choices table td {
 border:none !important;
 height:20px !important;
 padding:0 !important;
 }
 
 #q_filter{
 border:0 none;
 color:#AAAAAA;
 margin-bottom:-4px;
 margin-top:-4px;
 padding-left:3px;
 }
 

rhodecode/templates/admin/repos/repo_add_base.html

@@ -1,61 +1,60 b''
 ## -*- coding: utf-8 -*-
 
 ${h.form(url('repos'))}
 <div class="form">
     <!-- fields -->
     <div class="fields">
         <div class="field">
             <div class="label">
                 <label for="repo_name">${_('Name')}:</label>
             </div>
             <div class="input">
                 ${h.text('repo_name',c.new_repo,class_="small")}
             </div>
          </div>
         <div class="field">
             <div class="label">
                 <label for="clone_uri">${_('Clone from')}:</label>
             </div>
             <div class="input">
                 ${h.text('clone_uri',class_="small")}
             </div>
          </div>             
          <div class="field">
              <div class="label">
                  <label for="repo_group">${_('Repository group')}:</label>
              </div>
              <div class="input">
                  ${h.select('repo_group','',c.repo_groups,class_="medium")}
-             <span>${h.link_to(_('add new group'),h.url(''))}</span>
              </div>
          </div>         
         <div class="field">
             <div class="label">
                 <label for="repo_type">${_('Type')}:</label>
             </div>
             <div class="input">
                 ${h.select('repo_type','hg',c.backends,class_="small")}
             </div>
          </div>             
         <div class="field">
             <div class="label label-textarea">
                 <label for="description">${_('Description')}:</label>
             </div>
             <div class="textarea text-area editor">
                 ${h.textarea('description',cols=23,rows=5)}
             </div>
          </div>
         <div class="field">
             <div class="label label-checkbox">
                 <label for="private">${_('Private')}:</label>
             </div>
             <div class="checkboxes">
                 ${h.checkbox('private',value="True")}
             </div>
          </div>
         <div class="buttons">
           ${h.submit('add','add',class_="ui-button")}
         </div>                                                          
     </div>
 </div>    
 ${h.end_form()}    

rhodecode/templates/admin/repos/repo_edit.html

@@ -1,383 +1,382 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('Edit repository')} ${c.repo_info.repo_name} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Admin'),h.url('admin_home'))} 
     &raquo; 
     ${h.link_to(_('Repositories'),h.url('repos'))} 
     &raquo;
     ${_('edit')} &raquo; ${h.link_to(c.repo_info.just_name,h.url('summary_home',repo_name=c.repo_name))}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('admin')}
 </%def>
 
 <%def name="main()">
 <div class="box box-left">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}      
     </div>
     ${h.form(url('repo', repo_name=c.repo_info.repo_name),method='put')}
     <div class="form">
         <!-- fields -->
         <div class="fields">
             <div class="field">
                 <div class="label">
                     <label for="repo_name">${_('Name')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('repo_name',class_="medium")}
                 </div>
            </div>
 	       <div class="field">
 	           <div class="label">
 	               <label for="clone_uri">${_('Clone uri')}:</label>
 	           </div>
 	           <div class="input">
 	               ${h.text('clone_uri',class_="medium")}
 	           </div>
 	        </div>             
 	        <div class="field">
 	            <div class="label">
 	                <label for="repo_group">${_('Repository group')}:</label>
 	            </div>
 	            <div class="input">
 	                ${h.select('repo_group','',c.repo_groups,class_="medium")}
-	            <span>${h.link_to(_('add new group'),h.url(''))}</span>
 	            </div>
 	        </div>         
             <div class="field">
                 <div class="label">
                     <label for="repo_type">${_('Type')}:</label>
                 </div>
                 <div class="input">
                     ${h.select('repo_type','hg',c.backends,class_="medium")}
                 </div>
             </div>             
             <div class="field">
                 <div class="label label-textarea">
                     <label for="description">${_('Description')}:</label>
                 </div>
                 <div class="textarea text-area editor">
                     ${h.textarea('description',cols=23,rows=5)}
                 </div>
             </div>
             
             <div class="field">
                 <div class="label label-checkbox">
                     <label for="private">${_('Private')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('private',value="True")}
                 </div>
             </div>
             <div class="field">
                 <div class="label label-checkbox">
                     <label for="enable_statistics">${_('Enable statistics')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('enable_statistics',value="True")}
                 </div>
             </div>     
             <div class="field">
                 <div class="label label-checkbox">
                     <label for="enable_downloads">${_('Enable downloads')}:</label>
                 </div>
                 <div class="checkboxes">
                     ${h.checkbox('enable_downloads',value="True")}
                 </div>
             </div>                      
             <div class="field">
                 <div class="label">
                     <label for="user">${_('Owner')}:</label>
                 </div>
                 <div class="input input-small ac">
                     <div class="perm_ac">
                        ${h.text('user',class_='yui-ac-input')}
                        <div id="owner_container"></div>
                     </div>
                 </div>
              </div>                
              
             <div class="field">
                 <div class="label">
                     <label for="input">${_('Permissions')}:</label>
                 </div>
                 <div class="input">
                     <%include file="repo_edit_perms.html"/>
                 </div>
              
             <div class="buttons">
               ${h.submit('save','Save',class_="ui-button")}
               ${h.reset('reset','Reset',class_="ui-button")}
             </div>                                                          
         </div>
     </div>
     </div>    
     ${h.end_form()}
         <script type="text/javascript">
             YAHOO.util.Event.onDOMReady(function(){
                 var D = YAHOO.util.Dom;
                 if(!D.hasClass('perm_new_member_name','error')){
                     D.setStyle('add_perm_input','display','none');
                 }
                 YAHOO.util.Event.addListener('add_perm','click',function(){
                     D.setStyle('add_perm_input','display','');
                     D.setStyle('add_perm','opacity','0.6');
                     D.setStyle('add_perm','cursor','default');
                 });
             });
         </script>
         <script type="text/javascript">    
         YAHOO.example.FnMultipleFields = function(){
         	var myUsers = ${c.users_array|n};
         	var myGroups = ${c.users_groups_array|n};
             
             // Define a custom search function for the DataSource of users
             var matchUsers = function(sQuery) {
                 // Case insensitive matching
                 var query = sQuery.toLowerCase();
                 var i=0;
                 var l=myUsers.length;
                 var matches = [];
                 
                 // Match against each name of each contact
                 for(; i<l; i++) {
                     contact = myUsers[i];
                     if((contact.fname.toLowerCase().indexOf(query) > -1) ||
                         (contact.lname.toLowerCase().indexOf(query) > -1) ||
                         (contact.nname && (contact.nname.toLowerCase().indexOf(query) > -1))) {
                         matches[matches.length] = contact;
                     }
                 }
                 return matches;
             };
 
             // Define a custom search function for the DataSource of usersGroups
             var matchGroups = function(sQuery) {
                 // Case insensitive matching
                 var query = sQuery.toLowerCase();
                 var i=0;
                 var l=myGroups.length;
                 var matches = [];
                 
                 // Match against each name of each contact
                 for(; i<l; i++) {
                     matched_group = myGroups[i];
                     if(matched_group.grname.toLowerCase().indexOf(query) > -1) {
                         matches[matches.length] = matched_group;
                     }
                 }
                 return matches;
             };         
             
             //match all
             var matchAll = function(sQuery){
             	u = matchUsers(sQuery);
             	g = matchGroups(sQuery);
             	return u.concat(g);
             };
             
             // DataScheme for members
             var memberDS = new YAHOO.util.FunctionDataSource(matchAll);
             memberDS.responseSchema = {
                 fields: ["id", "fname", "lname", "nname", "grname", "grmembers"]
             };
 
             // DataScheme for owner
             var ownerDS = new YAHOO.util.FunctionDataSource(matchUsers);
             ownerDS.responseSchema = {
                 fields: ["id", "fname", "lname", "nname"]
             };          
             
             // Instantiate AutoComplete for perms
             var membersAC = new YAHOO.widget.AutoComplete("perm_new_member_name", "perm_container", memberDS);
             membersAC.useShadow = false;
             membersAC.resultTypeList = false;
             
             // Instantiate AutoComplete for owner
             var ownerAC = new YAHOO.widget.AutoComplete("user", "owner_container", ownerDS);
             ownerAC.useShadow = false;
             ownerAC.resultTypeList = false;
             
 
             // Helper highlight function for the formatter
             var highlightMatch = function(full, snippet, matchindex) {
                 return full.substring(0, matchindex) + 
                         "<span class='match'>" + 
                         full.substr(matchindex, snippet.length) + 
                         "</span>" +
                         full.substring(matchindex + snippet.length);
             };
             
             // Custom formatter to highlight the matching letters
             var custom_formatter = function(oResultData, sQuery, sResultMatch) {
             	var query = sQuery.toLowerCase();
             	
             	if (oResultData.grname != undefined){
             		var grname = oResultData.grname;
             		var grmembers = oResultData.grmembers;
             		var grnameMatchIndex = grname.toLowerCase().indexOf(query);
             		var grprefix = "${_('Group')}: ";
             		var grsuffix = " ("+grmembers+"  ${_('members')})";
             		
             		if (grnameMatchIndex > -1){
             			return grprefix+highlightMatch(grname,query,grnameMatchIndex)+grsuffix;
             		}
             		
             		return grprefix+oResultData.grname+grsuffix;
             	}
             	else if(oResultData.fname != undefined){
 	                
 	                var fname = oResultData.fname,
 	                    lname = oResultData.lname,
 	                    nname = oResultData.nname || "", // Guard against null value
 	                    fnameMatchIndex = fname.toLowerCase().indexOf(query),
 	                    lnameMatchIndex = lname.toLowerCase().indexOf(query),
 	                    nnameMatchIndex = nname.toLowerCase().indexOf(query),
 	                    displayfname, displaylname, displaynname;
 	                    
 	                if(fnameMatchIndex > -1) {
 	                    displayfname = highlightMatch(fname, query, fnameMatchIndex);
 	                }
 	                else {
 	                    displayfname = fname;
 	                }
 	        
 	                if(lnameMatchIndex > -1) {
 	                    displaylname = highlightMatch(lname, query, lnameMatchIndex);
 	                }
 	                else {
 	                    displaylname = lname;
 	                }
 	        
 	                if(nnameMatchIndex > -1) {
 	                    displaynname = "(" + highlightMatch(nname, query, nnameMatchIndex) + ")";
 	                }
 	                else {
 	                    displaynname = nname ? "(" + nname + ")" : "";
 	                }
 	        
 	                return displayfname + " " + displaylname + " " + displaynname;
             	}
             	else{
             		return '';
             	}
             };
             membersAC.formatResult = custom_formatter; 
             ownerAC.formatResult = custom_formatter;
                             
             var myHandler = function(sType, aArgs) {
 
                 var myAC = aArgs[0];  // reference back to the AC instance
                 var elLI = aArgs[1];  // reference to the selected LI element
                 var oData = aArgs[2]; // object literal of selected item's result data
                 
                 //fill the autocomplete with value
                 if(oData.nname != undefined){
                 	//users
                 	myAC.getInputEl().value = oData.nname;
                 	YUD.get('perm_new_member_type').value = 'user';
                 }
                 else{
                 	//groups
                 	myAC.getInputEl().value = oData.grname;
                 	YUD.get('perm_new_member_type').value = 'users_group';
                 }
                 
             };
 
             membersAC.itemSelectEvent.subscribe(myHandler);
             ownerAC.itemSelectEvent.subscribe(myHandler);
             
             return {
                 memberDS: memberDS,
                 ownerDS:  ownerDS,
                 membersAC: membersAC,
                 ownerAC: ownerAC, 
             };
         }();
             
         </script>      
 
 </div>
 
 <div class="box box-right">
     <div class="title">
         <h5>${_('Administration')}</h5>    
     </div>
     
         <h3>${_('Statistics')}</h3>
         ${h.form(url('repo_stats', repo_name=c.repo_info.repo_name),method='delete')}
         <div class="form">
            <div class="fields">
                ${h.submit('reset_stats_%s' % c.repo_info.repo_name,_('Reset current statistics'),class_="refresh_icon action_button",onclick="return confirm('Confirm to remove current statistics');")}
                <div class="field" style="border:none">
                <ul>
                     <li>${_('Fetched to rev')}: ${c.stats_revision}/${c.repo_last_rev}</li>
                     <li>${_('Percentage of stats gathered')}: ${c.stats_percentage} %</li>
                </ul>
                </div>
                
            </div>
         </div>                    
         ${h.end_form()}
         
         %if c.repo_info.clone_uri:
         <h3>${_('Remote')}</h3>
         ${h.form(url('repo_pull', repo_name=c.repo_info.repo_name),method='put')}
         <div class="form">
            <div class="fields">
                ${h.submit('remote_pull_%s' % c.repo_info.repo_name,_('Pull changes from remote location'),class_="pull_icon action_button",onclick="return confirm('Confirm to pull changes from remote side');")}
                <div class="field" style="border:none">
                <ul>
                     <li><a href="${c.repo_info.clone_uri}">${c.repo_info.clone_uri}</a></li>
                </ul> 
                </div>              
            </div>
         </div>                    
         ${h.end_form()}
         %endif
         
         <h3>${_('Cache')}</h3>
         ${h.form(url('repo_cache', repo_name=c.repo_info.repo_name),method='delete')}
         <div class="form">
            <div class="fields">
                ${h.submit('reset_cache_%s' % c.repo_info.repo_name,_('Invalidate repository cache'),class_="refresh_icon action_button",onclick="return confirm('Confirm to invalidate repository cache');")}
            </div>
         </div>                    
         ${h.end_form()}
         
         <h3>${_('Public journal')}</h3>
         ${h.form(url('repo_public_journal', repo_name=c.repo_info.repo_name),method='put')}
         <div class="form">
             <div class="fields">
                 ${h.hidden('auth_token',str(h.get_token()))}
                 %if c.in_public_journal:
                     ${h.submit('set_public_%s' % c.repo_info.repo_name,_('Remove from public journal'),class_="stop_following_icon action_button")}
                 %else:
 		            ${h.submit('set_public_%s' % c.repo_info.repo_name,_('Add to public journal'),class_="start_following_icon action_button")}
 		        %endif
 	         </div>        
         </div>
         ${h.end_form()}
         
         <h3>${_('Delete')}</h3>
         ${h.form(url('repo', repo_name=c.repo_info.repo_name),method='delete')}
         <div class="form">
            <div class="fields">
                ${h.submit('remove_%s' % c.repo_info.repo_name,_('Remove this repository'),class_="delete_icon action_button",onclick="return confirm('Confirm to delete this repository');")}
            </div>
         </div>                    
         ${h.end_form()}
     
 </div>
 
 
 </%def> 
  No newline at end of file

rhodecode/templates/base/base.html

@@ -1,400 +1,401 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="root.html"/>
 
 <!-- HEADER -->
 <div id="header">
     <!-- user -->
     <ul id="logged-user">
          <li class="first">
          
 			<div id="quick_login" style="display:none">
 			${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">
 			            ${h.submit('sign_in','Sign In',class_="ui-button")}
 			        </div>
 			    </div>
 			</div>
 			${h.end_form()}
 			<script type="text/javascript">
 			YUE.on('quick_login_link','click',function(e){
 				
 				if(YUD.hasClass('quick_login_link','enabled')){
 					YUD.setStyle('quick_login','display','none');
 					YUD.removeClass('quick_login_link','enabled');
 				}
 				else{
 	                YUD.setStyle('quick_login','display','');
 	                YUD.addClass('quick_login_link','enabled');
 	                YUD.get('username').focus();
 				}
 			    //make sure we don't redirect
 				YUE.preventDefault(e);
 			});
 			
 			</script>			
 			</div>         
          
              <div class="gravatar">
                  <img alt="gravatar" src="${h.gravatar_url(c.rhodecode_user.email,20)}" />
              </div>
           <div class="account">
           %if c.rhodecode_user.username == 'default':
               <a href="${h.url('public_journal')}">${_('Public journal')}</a>   
           %else:                        		            
           	${h.link_to(c.rhodecode_user.username,h.url('admin_settings_my_account'),title='%s %s'%(c.rhodecode_user.name,c.rhodecode_user.lastname))}
           %endif
           </div>	
          </li>
          <li>
             <a href="${h.url('home')}">${_('Home')}</a>
          </li>
          %if c.rhodecode_user.username != 'default':
             <li>
                <a href="${h.url('journal')}">${_('Journal')}</a> 
                ##(${c.unread_journal}
             </li>
             %endif
             %if c.rhodecode_user.username == 'default':
                 <li class="last highlight">${h.link_to(u'Login',h.url('login_home'),id='quick_login_link')}</li>
             %else:
                 <li class="last highlight">${h.link_to(u'Log Out',h.url('logout_home'))}</li>
             %endif
     </ul>
     <!-- end user -->
     <div id="header-inner" class="title top-left-rounded-corner top-right-rounded-corner">
         <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 bottom-left-rounded-corner bottom-right-rounded-corner">
        <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} &copy; 2010-${h.datetime.today().year} by Marcin Kuzminski
 	       </p>
        </div>
    </div>
    <script type="text/javascript">
    function tooltip_activate(){
 	    ${h.tooltip.activate()}
    }
    tooltip_activate();
    </script>
 </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="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 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>
 					<script type="text/javascript">
 					   YUE.on('repo_switcher','mouseover',function(){
 						      function qfilter(){
 						         var S = YAHOO.util.Selector;
 						         
 						         var q_filter = YUD.get('q_filter_rs');
 						         var F = YAHOO.namespace('q_filter_rs'); 
 						         
 						         YUE.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('ul#repo_switcher_list li a.repo_name');
 						            var req = YUD.get('q_filter_rs').value;
 						            for (n in nodes){
 						                YUD.setStyle(nodes[n].parentNode,'display','')
 						            }
 						            if (req){
 						                for (n in nodes){
 						                    console.log(n);
 						                    if (nodes[n].innerHTML.toLowerCase().indexOf(req) == -1) {
 						                        obsolete.push(nodes[n]); 
 						                    }
 						                }
 						                if(obsolete){
 						                    for (n in obsolete){
 						                        YUD.setStyle(obsolete[n].parentNode,'display','none');
 						                    }
 						                }
 						            }
 						         }
 						         
 						         YUE.on(q_filter,'keyup',function(e){
 						             clearTimeout(F.filterTimeout); 
 						             setTimeout(F.updateFilter,600); 
 						         });
 						}
 						   var loaded = YUD.hasClass('repo_switcher','loaded');
 						   if(!loaded){
 							   YUD.addClass('repo_switcher','loaded');
 							   YAHOO.util.Connect.asyncRequest('GET',"${h.url('repo_switcher')}",{
 								   success:function(o){
 								      YUD.get('repo_switcher_list').innerHTML = o.responseText;
 								      qfilter();
 								   },
 								   failure:function(o){
 									   YUD.removeClass('repo_switcher','loaded');   
 								   }
 							   },null);
 						   }
 						   return false;
 					   });
 					</script>	
 				</li>
 				
 	            <li ${is_current('summary')}>
 	               <a 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('shortlog')}>
                 ##   <a title="${_('Shortlog')}" href="${h.url('shortlog_home',repo_name=c.repo_name)}">
                 ##   <span class="icon">
                 ##       <img src="${h.url("/images/icons/application_view_list.png")}" alt="${_('Shortlog')}" />
                 ##   </span>
                 ##   <span>${_('Shortlog')}</span>                 
                 ##   </a>             
                 ##</li>	            
                 <li ${is_current('changelog')}>
                    <a 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 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>
                         <li>
                             ${h.link_to('%s (%s)' % (_('branches'),len(c.rhodecode_repo.branches.values()),),h.url('branches_home',repo_name=c.repo_name),class_='branches childs')}
                             <ul>
                             %if c.rhodecode_repo.branches.values():
 						        %for cnt,branch in enumerate(c.rhodecode_repo.branches.items()):
 						            <li>${h.link_to('%s - %s' % (branch[0],h.short_id(branch[1])),h.url('files_home',repo_name=c.repo_name,revision=branch[1]))}</li>
 						        %endfor
 						    %else:
 						    	<li>${h.link_to(_('There are no branches yet'),'#')}</li>
 						    %endif
                             </ul>                        
                         </li>
                         <li>
                             ${h.link_to('%s (%s)' % (_('tags'),len(c.rhodecode_repo.tags.values()),),h.url('tags_home',repo_name=c.repo_name),class_='tags childs')}
                             <ul>
                             %if c.rhodecode_repo.tags.values():
                                 %for cnt,tag in enumerate(c.rhodecode_repo.tags.items()):
                                  <li>${h.link_to('%s - %s' % (tag[0],h.short_id(tag[1])),h.url('files_home',repo_name=c.repo_name,revision=tag[1]))}</li>
                                 %endfor
                             %else:
                             	<li>${h.link_to(_('There are no tags yet'),'#')}</li>
                             %endif
                             </ul>                        
                         </li>                        
                     </ul>
                 </li>
                 <li ${is_current('files')}>
                    <a 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 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>
                     <a title="${_('Followers')}" href="${h.url('repo_followers_home',repo_name=c.repo_name)}">
                     <span class="icon_short">
                         <img src="${h.url('/images/icons/heart.png')}" alt="${_('Followers')}" />
                     </span>
                     <span id="current_followers_count" class="short">${c.repository_followers}</span>
                     </a>
                 </li>
                 <li>
                     <a title="${_('Forks')}" href="${h.url('repo_forks_home',repo_name=c.repo_name)}">
                     <span class="icon_short">
                         <img src="${h.url('/images/icons/arrow_divide.png')}" alt="${_('Forks')}" />
                     </span>
                     <span class="short">${c.repository_forks}</span>
                     </a>
                 </li>                
                 
 	        </ul>
 		%else:
 		    ##ROOT MENU
             <ul id="quick">
                 <li>
                     <a title="${_('Home')}"  href="${h.url('home')}">
                     <span class="icon">
                         <img src="${h.url('/images/icons/home_16.png')}" alt="${_('Home')}" />
                     </span>
                     <span>${_('Home')}</span>                 
                     </a>        
                 </li>
                 % if c.rhodecode_user.username != 'default':
                  <li>
                     <a title="${_('Journal')}"  href="${h.url('journal')}">
                     <span class="icon">
                         <img src="${h.url('/images/icons/book.png')}" alt="${_('Journal')}" />
                     </span>
                     <span>${_('Journal')}</span>                 
                     </a>        
                  </li>
                 % endif
                 <li>
                     <a title="${_('Search')}"  href="${h.url('search')}">
                     <span class="icon">
                         <img src="${h.url('/images/icons/search_16.png')}" alt="${_('Search')}" />
                     </span>
                     <span>${_('Search')}</span>                 
                     </a>        
                 </li>
                 
 				%if h.HasPermissionAll('hg.admin')('access admin main page'):
                 <li ${is_current('admin')}>
                    <a title="${_('Admin')}" href="${h.url('admin_home')}">
                    <span class="icon">
                        <img src="${h.url('/images/icons/cog_edit.png')}" alt="${_('Admin')}" />
                    </span>
                    <span>${_('Admin')}</span>                 
                    </a>
                     ${admin_menu()}
                 </li>
 				%endif
 			</ul>
 		%endif    
 </%def>
  No newline at end of file