repos.py
578 lines
| 22.7 KiB
| text/x-python
|
PythonLexer
r824 | # -*- coding: utf-8 -*- | |||
""" | ||||
rhodecode.controllers.admin.repos | ||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | ||||
r1203 | ||||
r1982 | Repositories controller for RhodeCode | |||
r1203 | ||||
r824 | :created_on: Apr 7, 2010 | |||
:author: marcink | ||||
r1824 | :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com> | |||
r824 | :license: GPLv3, see COPYING for more details. | |||
""" | ||||
r1206 | # 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. | ||||
r1203 | # | |||
r547 | # 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. | ||||
r1203 | # | |||
r547 | # You should have received a copy of the GNU General Public License | |||
r1206 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
r824 | ||||
import logging | ||||
import traceback | ||||
import formencode | ||||
r547 | from formencode import htmlfill | |||
r824 | ||||
r3333 | from webob.exc import HTTPInternalServerError, HTTPForbidden | |||
r1722 | from pylons import request, session, tmpl_context as c, url | |||
from pylons.controllers.util import redirect | ||||
r547 | from pylons.i18n.translation import _ | |||
r1722 | from sqlalchemy.exc import IntegrityError | |||
r824 | ||||
r2664 | import rhodecode | |||
r547 | from rhodecode.lib import helpers as h | |||
from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \ | ||||
r3333 | HasPermissionAnyDecorator, HasRepoPermissionAllDecorator, NotAnonymous,\ | |||
r3629 | HasPermissionAny, HasReposGroupPermissionAny, HasRepoPermissionAnyDecorator | |||
|
r3288 | from rhodecode.lib.base import BaseRepoController, render | ||
r3693 | from rhodecode.lib.utils import action_logger, repo_name_slug | |||
r1085 | from rhodecode.lib.helpers import get_token | |||
r1722 | from rhodecode.model.meta import Session | |||
r3056 | from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup,\ | |||
r3308 | RhodeCodeSetting, RepositoryField | |||
r3628 | from rhodecode.model.forms import RepoForm, RepoFieldForm, RepoPermsForm | |||
r3864 | from rhodecode.model.scm import ScmModel, RepoGroupList, RepoList | |||
r629 | from rhodecode.model.repo import RepoModel | |||
r2664 | from rhodecode.lib.compat import json | |||
r2935 | from sqlalchemy.sql.expression import func | |||
r3641 | from rhodecode.lib.exceptions import AttachedForksError | |||
r3715 | from rhodecode.lib.utils2 import safe_int | |||
r824 | ||||
r547 | log = logging.getLogger(__name__) | |||
r1245 | ||||
|
r3288 | class ReposController(BaseRepoController): | ||
r1085 | """ | |||
REST Controller styled on the Atom Publishing Protocol""" | ||||
r547 | # To properly map this controller, ensure your config/routing.py | |||
# file has a resource setup: | ||||
# map.resource('repo', 'repos') | ||||
r636 | ||||
r547 | @LoginRequired() | |||
def __before__(self): | ||||
super(ReposController, self).__before__() | ||||
r636 | ||||
r1159 | def __load_defaults(self): | |||
r3714 | acl_groups = RepoGroupList(RepoGroup.query().all(), | |||
r3239 | perm_set=['group.write', 'group.admin']) | |||
c.repo_groups = RepoGroup.groups_choices(groups=acl_groups) | ||||
r1547 | c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups) | |||
r1722 | ||||
r1159 | repo_model = RepoModel() | |||
c.users_array = repo_model.get_users_js() | ||||
c.users_groups_array = repo_model.get_users_groups_js() | ||||
r2460 | choices, c.landing_revs = ScmModel().get_repo_landing_revs() | |||
c.landing_revs_choices = choices | ||||
r1159 | ||||
def __load_data(self, repo_name=None): | ||||
r1112 | """ | |||
Load defaults settings for edit, and update | ||||
r1203 | ||||
r1112 | :param repo_name: | |||
""" | ||||
r1159 | self.__load_defaults() | |||
r1530 | c.repo_info = db_repo = Repository.get_by_repo_name(repo_name) | |||
r1561 | repo = db_repo.scm_instance | |||
r1112 | ||||
if c.repo_info is None: | ||||
r3110 | h.not_mapped_error(repo_name) | |||
r1112 | return redirect(url('repos')) | |||
r3089 | ##override defaults for exact repo info here git/hg etc | |||
r2460 | choices, c.landing_revs = ScmModel().get_repo_landing_revs(c.repo_info) | |||
c.landing_revs_choices = choices | ||||
r3734 | c.default_user_id = User.get_default_user().user_id | |||
r1594 | c.in_public_journal = UserFollowing.query()\ | |||
r1112 | .filter(UserFollowing.user_id == c.default_user_id)\ | |||
.filter(UserFollowing.follows_repository == c.repo_info).scalar() | ||||
if c.repo_info.stats: | ||||
r1807 | # this is on what revision we ended up so we add +1 for count | |||
last_rev = c.repo_info.stats.stat_on_revision + 1 | ||||
r1112 | else: | |||
last_rev = 0 | ||||
c.stats_revision = last_rev | ||||
r1807 | c.repo_last_rev = repo.count() if repo.revisions else 0 | |||
r1112 | ||||
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) | ||||
r3308 | c.repo_fields = RepositoryField.query()\ | |||
.filter(RepositoryField.repository == db_repo).all() | ||||
r1594 | defaults = RepoModel()._get_defaults(repo_name) | |||
r1818 | ||||
r3864 | _repos = Repository.query().order_by(Repository.repo_name).all() | |||
read_access_repos = RepoList(_repos) | ||||
r1755 | c.repos_list = [('', _('--REMOVE FORK--'))] | |||
r3864 | c.repos_list += [(x.repo_id, x.repo_name) | |||
for x in read_access_repos | ||||
if x.repo_id != c.repo_info.repo_id] | ||||
r2459 | ||||
r2629 | defaults['id_fork_of'] = db_repo.fork.repo_id if db_repo.fork else '' | |||
r1112 | return defaults | |||
r547 | def index(self, format='html'): | |||
"""GET /repos: All items in the collection""" | ||||
# url('repos') | ||||
r3865 | repo_list = Repository.query()\ | |||
.order_by(func.lower(Repository.repo_name))\ | ||||
.all() | ||||
r1344 | ||||
r3865 | c.repos_list = RepoList(repo_list, perm_set=['repository.admin']) | |||
r3154 | repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list, | |||
r3245 | admin=True, | |||
super_user_actions=True) | ||||
r3154 | #json used to render the grid | |||
c.data = json.dumps(repos_data) | ||||
r2664 | ||||
r547 | return render('admin/repos/repos.html') | |||
r636 | ||||
r3333 | @NotAnonymous() | |||
r547 | def create(self): | |||
r1085 | """ | |||
POST /repos: Create a new item""" | ||||
r547 | # url('repos') | |||
r1722 | ||||
r1159 | self.__load_defaults() | |||
r547 | form_result = {} | |||
try: | ||||
r2460 | form_result = RepoForm(repo_groups=c.repo_groups_choices, | |||
landing_revs=c.landing_revs_choices)()\ | ||||
r1159 | .to_python(dict(request.POST)) | |||
r3333 | ||||
r2660 | new_repo = RepoModel().create(form_result, | |||
self.rhodecode_user.user_id) | ||||
r1112 | if form_result['clone_uri']: | |||
|
r3565 | h.flash(_('Created repository %s from %s') \ | ||
r1112 | % (form_result['repo_name'], form_result['clone_uri']), | |||
category='success') | ||||
else: | ||||
r3547 | repo_url = h.link_to(form_result['repo_name'], | |||
r3668 | h.url('summary_home', repo_name=form_result['repo_name_full'])) | |||
|
r3565 | h.flash(h.literal(_('Created repository %s') % repo_url), | ||
r3547 | category='success') | |||
r547 | ||||
if request.POST.get('user_created'): | ||||
r1722 | # created by regular non admin user | |||
r564 | action_logger(self.rhodecode_user, 'user_created_repo', | |||
r2375 | form_result['repo_name_full'], self.ip_addr, | |||
self.sa) | ||||
r547 | else: | |||
r564 | action_logger(self.rhodecode_user, 'admin_created_repo', | |||
r2375 | form_result['repo_name_full'], self.ip_addr, | |||
self.sa) | ||||
r2662 | Session().commit() | |||
r564 | except formencode.Invalid, errors: | |||
r547 | return htmlfill.render( | |||
r3333 | render('admin/repos/repo_add.html'), | |||
r547 | defaults=errors.value, | |||
errors=errors.error_dict or {}, | ||||
prefix_error=False, | ||||
r636 | encoding="UTF-8") | |||
r547 | ||||
except Exception: | ||||
log.error(traceback.format_exc()) | ||||
|
r3654 | msg = _('Error creating repository %s') \ | ||
r547 | % form_result.get('repo_name') | |||
h.flash(msg, category='error') | ||||
r3333 | if c.rhodecode_user.is_admin: | |||
return redirect(url('repos')) | ||||
return redirect(url('home')) | ||||
r2660 | #redirect to our new repo ! | |||
return redirect(url('summary_home', repo_name=new_repo.repo_name)) | ||||
r636 | ||||
r3629 | @NotAnonymous() | |||
def create_repository(self): | ||||
"""GET /_admin/create_repository: Form to create a new item""" | ||||
new_repo = request.GET.get('repo', '') | ||||
parent_group = request.GET.get('parent_group') | ||||
if not HasPermissionAny('hg.admin', 'hg.create.repository')(): | ||||
#you're not super admin nor have global create permissions, | ||||
#but maybe you have at least write permission to a parent group ? | ||||
_gr = RepoGroup.get(parent_group) | ||||
gr_name = _gr.group_name if _gr else None | ||||
if not HasReposGroupPermissionAny('group.admin', 'group.write')(group_name=gr_name): | ||||
raise HTTPForbidden | ||||
r3233 | ||||
r3714 | acl_groups = RepoGroupList(RepoGroup.query().all(), | |||
r3629 | perm_set=['group.write', 'group.admin']) | |||
c.repo_groups = RepoGroup.groups_choices(groups=acl_groups) | ||||
c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups) | ||||
choices, c.landing_revs = ScmModel().get_repo_landing_revs() | ||||
r3233 | ||||
r3629 | c.new_repo = repo_name_slug(new_repo) | |||
r3089 | ## apply the defaults from defaults page | |||
defaults = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True) | ||||
r3233 | if parent_group: | |||
defaults.update({'repo_group': parent_group}) | ||||
r3089 | return htmlfill.render( | |||
render('admin/repos/repo_add.html'), | ||||
defaults=defaults, | ||||
errors={}, | ||||
prefix_error=False, | ||||
encoding="UTF-8" | ||||
) | ||||
r636 | ||||
r3629 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r547 | def update(self, repo_name): | |||
r1085 | """ | |||
PUT /repos/repo_name: Update an existing item""" | ||||
r547 | # 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) | ||||
r1159 | self.__load_defaults() | |||
r547 | repo_model = RepoModel() | |||
changed_name = repo_name | ||||
r2603 | #override the choices with extracted revisions ! | |||
choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo_name) | ||||
c.landing_revs_choices = choices | ||||
r3524 | repo = Repository.get_by_repo_name(repo_name) | |||
r3863 | old_data = { | |||
'repo_name': repo_name, | ||||
'repo_group': repo.group.get_dict() if repo.group else {}, | ||||
'repo_type': repo.repo_type, | ||||
} | ||||
_form = RepoForm(edit=True, old_data=old_data, | ||||
r2460 | repo_groups=c.repo_groups_choices, | |||
landing_revs=c.landing_revs_choices)() | ||||
r3863 | ||||
r547 | try: | |||
form_result = _form.to_python(dict(request.POST)) | ||||
r3089 | repo = repo_model.update(repo_name, **form_result) | |||
r3693 | ScmModel().mark_for_invalidation(repo_name) | |||
|
r2570 | h.flash(_('Repository %s updated successfully') % repo_name, | ||
r547 | category='success') | |||
r1539 | changed_name = repo.repo_name | |||
r660 | action_logger(self.rhodecode_user, 'admin_updated_repo', | |||
r2375 | changed_name, self.ip_addr, self.sa) | |||
r2662 | Session().commit() | |||
r564 | except formencode.Invalid, errors: | |||
r1112 | defaults = self.__load_data(repo_name) | |||
defaults.update(errors.value) | ||||
r547 | return htmlfill.render( | |||
render('admin/repos/repo_edit.html'), | ||||
r1112 | defaults=defaults, | |||
r547 | errors=errors.error_dict or {}, | |||
prefix_error=False, | ||||
encoding="UTF-8") | ||||
r636 | ||||
r547 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
|
r3565 | h.flash(_('Error occurred during update of repository %s') \ | ||
r547 | % repo_name, category='error') | |||
return redirect(url('edit_repo', repo_name=changed_name)) | ||||
r636 | ||||
r3629 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r547 | def delete(self, repo_name): | |||
r1085 | """ | |||
DELETE /repos/repo_name: Delete an existing item""" | ||||
r547 | # Forms posted to this method should contain a hidden field: | |||
# <input type="hidden" name="_method" value="DELETE" /> | ||||
# Or using helpers: | ||||
# h.form(url('repo', repo_name=ID), | ||||
# method='delete') | ||||
# url('repo', repo_name=ID) | ||||
r636 | ||||
r547 | repo_model = RepoModel() | |||
r735 | repo = repo_model.get_by_repo_name(repo_name) | |||
r547 | if not repo: | |||
r3110 | h.not_mapped_error(repo_name) | |||
r547 | return redirect(url('repos')) | |||
try: | ||||
r3391 | _forks = repo.forks.count() | |||
r3641 | handle_forks = None | |||
r3391 | if _forks and request.POST.get('forks'): | |||
do = request.POST['forks'] | ||||
if do == 'detach_forks': | ||||
r3641 | handle_forks = 'detach' | |||
|
r3565 | h.flash(_('Detached %s forks') % _forks, category='success') | ||
r3391 | elif do == 'delete_forks': | |||
r3641 | handle_forks = 'delete' | |||
|
r3565 | h.flash(_('Deleted %s forks') % _forks, category='success') | ||
r3641 | repo_model.delete(repo, forks=handle_forks) | |||
r564 | action_logger(self.rhodecode_user, 'admin_deleted_repo', | |||
r3641 | repo_name, self.ip_addr, self.sa) | |||
r3693 | ScmModel().mark_for_invalidation(repo_name) | |||
|
r3565 | h.flash(_('Deleted repository %s') % repo_name, category='success') | ||
r2662 | Session().commit() | |||
r3641 | except AttachedForksError: | |||
h.flash(_('Cannot delete %s it still contains attached forks') | ||||
% repo_name, category='warning') | ||||
r1361 | ||||
r3641 | except Exception: | |||
r547 | log.error(traceback.format_exc()) | |||
r860 | h.flash(_('An error occurred during deletion of %s') % repo_name, | |||
r547 | category='error') | |||
r636 | ||||
r547 | return redirect(url('repos')) | |||
r636 | ||||
r1869 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r3628 | def set_repo_perm_member(self, repo_name): | |||
form = RepoPermsForm()().to_python(request.POST) | ||||
r3714 | RepoModel()._update_permissions(repo_name, form['perms_new'], | |||
form['perms_updates']) | ||||
r3628 | #TODO: implement this | |||
#action_logger(self.rhodecode_user, 'admin_changed_repo_permissions', | ||||
# repo_name, self.ip_addr, self.sa) | ||||
Session().commit() | ||||
|
r3654 | h.flash(_('Repository permissions updated'), category='success') | ||
r3628 | return redirect(url('edit_repo', repo_name=repo_name)) | |||
@HasRepoPermissionAllDecorator('repository.admin') | ||||
r3715 | def delete_repo_perm_member(self, repo_name): | |||
r1085 | """ | |||
DELETE an existing repository permission user | ||||
r1203 | ||||
r604 | :param repo_name: | |||
r547 | """ | |||
try: | ||||
r3715 | obj_type = request.POST.get('obj_type') | |||
obj_id = None | ||||
if obj_type == 'user': | ||||
obj_id = safe_int(request.POST.get('user_id')) | ||||
elif obj_type == 'user_group': | ||||
obj_id = safe_int(request.POST.get('user_group_id')) | ||||
if obj_type == 'user': | ||||
RepoModel().revoke_user_permission(repo=repo_name, user=obj_id) | ||||
elif obj_type == 'user_group': | ||||
RepoModel().revoke_users_group_permission( | ||||
repo=repo_name, group_name=obj_id | ||||
) | ||||
r3628 | #TODO: implement this | |||
#action_logger(self.rhodecode_user, 'admin_revoked_repo_permissions', | ||||
# repo_name, self.ip_addr, self.sa) | ||||
r2662 | Session().commit() | |||
r1982 | except Exception: | |||
log.error(traceback.format_exc()) | ||||
r3715 | h.flash(_('An error occurred during revoking of permission'), | |||
r1015 | category='error') | |||
raise HTTPInternalServerError() | ||||
r3629 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r1015 | def repo_stats(self, repo_name): | |||
r1085 | """ | |||
DELETE an existing repository statistics | ||||
r1203 | ||||
r708 | :param repo_name: | |||
""" | ||||
try: | ||||
r1982 | RepoModel().delete_stats(repo_name) | |||
r2662 | Session().commit() | |||
r708 | except Exception, e: | |||
r2726 | log.error(traceback.format_exc()) | |||
r860 | h.flash(_('An error occurred during deletion of repository stats'), | |||
r708 | category='error') | |||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
r3629 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r708 | def repo_cache(self, repo_name): | |||
r1085 | """ | |||
INVALIDATE existing repository cache | ||||
r1203 | ||||
r708 | :param repo_name: | |||
""" | ||||
try: | ||||
ScmModel().mark_for_invalidation(repo_name) | ||||
r2662 | Session().commit() | |||
r708 | except Exception, e: | |||
r2726 | log.error(traceback.format_exc()) | |||
r711 | h.flash(_('An error occurred during cache invalidation'), | |||
r708 | category='error') | |||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
r3629 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r2726 | def repo_locking(self, repo_name): | |||
""" | ||||
Unlock repository when it is locked ! | ||||
:param repo_name: | ||||
""" | ||||
try: | ||||
repo = Repository.get_by_repo_name(repo_name) | ||||
if request.POST.get('set_lock'): | ||||
Repository.lock(repo, c.rhodecode_user.user_id) | ||||
elif request.POST.get('set_unlock'): | ||||
Repository.unlock(repo) | ||||
except Exception, e: | ||||
log.error(traceback.format_exc()) | ||||
h.flash(_('An error occurred during unlocking'), | ||||
category='error') | ||||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
r3629 | @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin') | |||
def toggle_locking(self, repo_name): | ||||
""" | ||||
Toggle locking of repository by simple GET call to url | ||||
:param repo_name: | ||||
""" | ||||
try: | ||||
repo = Repository.get_by_repo_name(repo_name) | ||||
if repo.enable_locking: | ||||
if repo.locked[0]: | ||||
Repository.unlock(repo) | ||||
|
r3654 | action = _('Unlocked') | ||
r3629 | else: | |||
Repository.lock(repo, c.rhodecode_user.user_id) | ||||
|
r3654 | action = _('Locked') | ||
r3629 | ||||
h.flash(_('Repository has been %s') % action, | ||||
category='success') | ||||
except Exception, e: | ||||
log.error(traceback.format_exc()) | ||||
h.flash(_('An error occurred during unlocking'), | ||||
category='error') | ||||
return redirect(url('summary_home', repo_name=repo_name)) | ||||
@HasRepoPermissionAllDecorator('repository.admin') | ||||
r1085 | def repo_public_journal(self, repo_name): | |||
""" | ||||
Set's this repository to be visible in public journal, | ||||
in other words assing default user to follow this repo | ||||
r1203 | ||||
r1085 | :param repo_name: | |||
""" | ||||
cur_token = request.POST.get('auth_token') | ||||
token = get_token() | ||||
if cur_token == token: | ||||
try: | ||||
r1530 | repo_id = Repository.get_by_repo_name(repo_name).repo_id | |||
r3734 | user_id = User.get_default_user().user_id | |||
r1085 | self.scm_model.toggle_following_repo(repo_id, user_id) | |||
h.flash(_('Updated repository visibility in public journal'), | ||||
category='success') | ||||
r2662 | Session().commit() | |||
r3631 | except Exception: | |||
r1085 | h.flash(_('An error occurred during setting this' | |||
' repository in public journal'), | ||||
category='error') | ||||
else: | ||||
h.flash(_('Token mismatch'), category='error') | ||||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
r3629 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r1114 | def repo_pull(self, repo_name): | |||
""" | ||||
Runs task to update given repository with remote changes, | ||||
ie. make pull on remote location | ||||
r1203 | ||||
r1114 | :param repo_name: | |||
""" | ||||
try: | ||||
r1121 | ScmModel().pull_changes(repo_name, self.rhodecode_user.username) | |||
r1114 | h.flash(_('Pulled from remote location'), category='success') | |||
except Exception, e: | ||||
r3826 | log.error(traceback.format_exc()) | |||
r1114 | h.flash(_('An error occurred during pull from remote location'), | |||
category='error') | ||||
r1085 | ||||
r1114 | return redirect(url('edit_repo', repo_name=repo_name)) | |||
r1085 | ||||
r3629 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r1755 | def repo_as_fork(self, repo_name): | |||
""" | ||||
Mark given repository as a fork of another | ||||
r1818 | ||||
r1755 | :param repo_name: | |||
""" | ||||
try: | ||||
fork_id = request.POST.get('id_fork_of') | ||||
repo = ScmModel().mark_as_fork(repo_name, fork_id, | ||||
self.rhodecode_user.username) | ||||
fork = repo.fork.repo_name if repo.fork else _('Nothing') | ||||
r2629 | Session().commit() | |||
h.flash(_('Marked repo %s as fork of %s') % (repo_name, fork), | ||||
r1755 | category='success') | |||
except Exception, e: | ||||
r2629 | log.error(traceback.format_exc()) | |||
r1755 | h.flash(_('An error occurred during this operation'), | |||
category='error') | ||||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
r547 | def show(self, repo_name, format='html'): | |||
"""GET /repos/repo_name: Show a specific item""" | ||||
# url('repo', repo_name=ID) | ||||
r636 | ||||
r3629 | @HasRepoPermissionAllDecorator('repository.admin') | |||
r547 | def edit(self, repo_name, format='html'): | |||
"""GET /repos/repo_name/edit: Form to edit an existing item""" | ||||
# url('edit_repo', repo_name=ID) | ||||
r1112 | defaults = self.__load_data(repo_name) | |||
r636 | ||||
r547 | return htmlfill.render( | |||
render('admin/repos/repo_edit.html'), | ||||
defaults=defaults, | ||||
encoding="UTF-8", | ||||
force_defaults=False | ||||
r636 | ) | |||
r3308 | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
def create_repo_field(self, repo_name): | ||||
try: | ||||
form_result = RepoFieldForm()().to_python(dict(request.POST)) | ||||
new_field = RepositoryField() | ||||
new_field.repository = Repository.get_by_repo_name(repo_name) | ||||
new_field.field_key = form_result['new_field_key'] | ||||
new_field.field_type = form_result['new_field_type'] # python type | ||||
new_field.field_value = form_result['new_field_value'] # set initial blank value | ||||
new_field.field_desc = form_result['new_field_desc'] | ||||
new_field.field_label = form_result['new_field_label'] | ||||
Session().add(new_field) | ||||
Session().commit() | ||||
except Exception, e: | ||||
log.error(traceback.format_exc()) | ||||
msg = _('An error occurred during creation of field') | ||||
if isinstance(e, formencode.Invalid): | ||||
msg += ". " + e.msg | ||||
h.flash(msg, category='error') | ||||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||
@HasPermissionAllDecorator('hg.admin') | ||||
def delete_repo_field(self, repo_name, field_id): | ||||
field = RepositoryField.get_or_404(field_id) | ||||
try: | ||||
Session().delete(field) | ||||
Session().commit() | ||||
except Exception, e: | ||||
log.error(traceback.format_exc()) | ||||
msg = _('An error occurred during removal of field') | ||||
h.flash(msg, category='error') | ||||
return redirect(url('edit_repo', repo_name=repo_name)) | ||||