kallithea Changeset - 3bce31f026b8

Changeset - 3bce31f026b8

Parent rev.

Child rev.

[Not reviewed]

beta

0 10 3

Marcin Kuzminski - 14 years ago 2011-05-23 02:22:00
marcin@python-works.com

#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

13 files changed with 403 insertions and 32 deletions:

rhodecode/controllers/admin/repos.py

rhodecode/controllers/admin/repos_groups.py

rhodecode/controllers/admin/settings.py

rhodecode/controllers/home.py

rhodecode/model/db.py

rhodecode/model/forms.py

rhodecode/model/repos_group.py

133

rhodecode/public/css/style.css

rhodecode/templates/admin/repos/repo_add_base.html

rhodecode/templates/admin/repos/repo_edit.html

rhodecode/templates/admin/repos_groups/repos_groups_add.html

rhodecode/templates/admin/repos_groups/repos_groups_show.html

rhodecode/templates/base/base.html

0 comments (0 inline, 0 general)

rhodecode/controllers/admin/repos.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.admin.repos
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     Admin controller for RhodeCode
     :created_on: Apr 7, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
     :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')

rhodecode/controllers/admin/repos_groups.py

➞

Show inline comments

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

➞

Show inline comments

@@ @@ -143,220 +143,222 @@ class SettingsController(BaseController) @@
                     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

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.home
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
     Home controller for Rhodecode
     :created_on: Feb 18, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
     :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

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.model.db
     ~~~~~~~~~~~~~~~~~~
     Database Models for RhodeCode
     :created_on: Apr 08, 2010
     :author: marcink
     :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>
     :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})

rhodecode/model/forms.py

➞

Show inline comments

 """ 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/model/repos_group.py

➞

Show inline comments

@@ new file 100644 @@
 # -*- 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 <marcin@python-works.com>
     :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/public/css/style.css

➞

Show inline comments

@@ @@ -288,384 +288,391 @@ 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 {

rhodecode/templates/admin/repos/repo_add_base.html

➞

Show inline comments

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

➞

Show inline comments

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

rhodecode/templates/admin/repos_groups/repos_groups_add.html

➞

Show inline comments

@@ new file 100644 @@
 ## -*- 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

➞

Show inline comments

@@ new file 100644 @@
 ## -*- 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/templates/base/base.html

➞

Show inline comments

@@ @@ -133,268 +133,269 @@ @@
 </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 @@

0 comments (0 inline, 0 general)