def index(self):
limit = 100
default = 20
if request.GET.get('size'):
c.size = max(min(safe_int(request.GET.get('size')), limit), 1)
session['changelog_size'] = c.size
session.save()
else:
c.size = int(session.get('changelog_size', default))
# min size must be 1
c.size = max(c.size, 1)
p = safe_int(request.GET.get('page', 1), 1)
branch_name = request.GET.get('branch', None)
try:
if branch_name:
collection = [z for z in
c.rhodecode_repo.get_changesets(start=0,
branch_name=branch_name)]
c.total_cs = len(collection)
else:
collection = c.rhodecode_repo
c.total_cs = len(c.rhodecode_repo)
c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,
items_per_page=c.size, branch=branch_name)
collection = list(c.pagination)
page_revisions = [x.raw_id for x in collection]
c.comments = c.rhodecode_db_repo.get_comments(page_revisions)
c.statuses = c.rhodecode_db_repo.statuses(page_revisions)
except (EmptyRepositoryError), e:
h.flash(str(e), category='warning')
return redirect(url('summary_home', repo_name=c.repo_name))
def index(self, repo_name, revision=None, f_path=None):
p = safe_int(request.GET.get('page', 1), 1)
size = safe_int(request.GET.get('size', 20), 20)
collection = c.rhodecode_repo
c.file_history = f_path
def url_generator(**kw):
if f_path:
return url('shortlog_file_home',
repo_name=repo_name,
revision=revision,
f_path=f_path,
size=size,
**kw)
return url('shortlog_home', repo_name=repo_name, size=size, **kw)
if f_path:
log.debug('generating shortlog for path %s' % f_path)
# get the history for the file !
tip_cs = c.rhodecode_repo.get_changeset()
try:
collection = tip_cs.get_file_history(f_path)
except (NodeDoesNotExistError, ChangesetError):
#this node is not present at tip !
try:
cs = self.__get_cs_or_redirect(revision, repo_name)
collection = cs.get_file_history(f_path)
except RepositoryError, e:
h.flash(str(e), category='warning')
redirect(h.url('shortlog_home', repo_name=repo_name))
collection = list(reversed(collection))
def delete_repo_perm_member(self, repo_name):
"""
DELETE an existing repository permission user
:param repo_name:
"""
try:
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
)
#TODO: implement this
#action_logger(self.rhodecode_user, 'admin_revoked_repo_permissions',
# repo_name, self.ip_addr, self.sa)
Session().commit()
except Exception:
log.error(traceback.format_exc())
h.flash(_('An error occurred during revoking of permission'),
category='error')
raise HTTPInternalServerError()
def delete_user_group_perm_member(self, id):
"""
DELETE an existing repository group permission user
:param group_name:
"""
try:
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 not c.rhodecode_user.is_admin:
if obj_type == 'user' and c.rhodecode_user.user_id == obj_id:
msg = _('Cannot revoke permission for yourself as admin')
h.flash(msg, category='warning')
raise Exception('revoke admin permission on self')
if obj_type == 'user':
UserGroupModel().revoke_user_permission(user_group=id,
user=obj_id)
elif obj_type == 'user_group':
UserGroupModel().revoke_users_group_permission(
target_user_group=id, user_group=obj_id)
Session().commit()
except Exception:
log.error(traceback.format_exc())
h.flash(_('An error occurred during revoking of permission'),
category='error')
raise HTTPInternalServerError()
def delete_user_group_perm_member(self, id):
"""
DELETE an existing repository group permission user
:param group_name:
"""
try:
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 not c.rhodecode_user.is_admin:
if obj_type == 'user' and c.rhodecode_user.user_id == obj_id:
msg = _('Cannot revoke permission for yourself as admin')
h.flash(msg, category='warning')
raise Exception('revoke admin permission on self')
if obj_type == 'user':
UserGroupModel().revoke_user_permission(user_group=id,
user=obj_id)
elif obj_type == 'user_group':
UserGroupModel().revoke_users_group_permission(target_user_group=id,
user_group=obj_id)
Session().commit()
except Exception:
log.error(traceback.format_exc())
h.flash(_('An error occurred during revoking of permission'),
category='error')
raise HTTPInternalServerError()
def index(self, repo_name, revision=None, f_path=None):
p = safe_int(request.params.get('page', 1), 1)
size = safe_int(request.params.get('size', 20), 20)
collection = c.rhodecode_repo
c.file_history = f_path
def url_generator(**kw):
if f_path:
return url('shortlog_file_home', repo_name=repo_name,
revision=revision, f_path=f_path, size=size, **kw)
return url('shortlog_home', repo_name=repo_name, size=size, **kw)
if f_path:
log.debug('generating shortlog for path %s' % f_path)
# get the history for the file !
tip_cs = c.rhodecode_repo.get_changeset()
try:
collection = tip_cs.get_file_history(f_path)
except (NodeDoesNotExistError, ChangesetError):
#this node is not present at tip !
try:
cs = self.__get_cs_or_redirect(revision, repo_name)
collection = cs.get_file_history(f_path)
except RepositoryError, e:
h.flash(str(e), category='warning')
redirect(h.url('shortlog_home', repo_name=repo_name))
collection = list(reversed(collection))
def delete_repo_perm_member(self, repo_name):
"""
DELETE an existing repository permission user
:param repo_name:
"""
try:
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)
#TODO: implement this
#action_logger(self.rhodecode_user, 'admin_revoked_repo_permissions',
# repo_name, self.ip_addr, self.sa)
Session().commit()
except Exception:
log.error(traceback.format_exc())
h.flash(_('An error occurred during revoking of permission'),
category='error')
raise HTTPInternalServerError()
def __before__(self):
"""
__before__ is called before controller methods and after __call__
"""
# on each call propagate settings calls into global settings.
set_rhodecode_config(config)
attach_context_attributes(c)
# TODO: Remove this when fixed in attach_context_attributes()
c.repo_name = get_repo_slug(request) # can be empty
self.cut_off_limit_diff = safe_int(config.get('cut_off_limit_diff'))
self.cut_off_limit_file = safe_int(config.get('cut_off_limit_file'))
self.sa = meta.Session
self.scm_model = ScmModel(self.sa)
default_lang = c.language
user_lang = c.language
try:
user_obj = self._rhodecode_user.get_instance()
if user_obj:
user_lang = user_obj.user_data.get('language')
except Exception:
log.exception('Failed to fetch user language for user %s',
self._rhodecode_user)
if user_lang and user_lang != default_lang:
log.debug('set language to %s for user %s', user_lang,
self._rhodecode_user)
translation.set_lang(user_lang)
def add_auth_token(self, user_id):
user_id = safe_int(user_id)
c.user = User.get_or_404(user_id)
if c.user.username == User.DEFAULT_USER:
h.flash(_("You can't edit this user"), category='warning')
return redirect(url('users'))
lifetime = safe_int(request.POST.get('lifetime'), -1)
description = request.POST.get('description')
role = request.POST.get('role')
AuthTokenModel().create(c.user.user_id, description, lifetime, role)
Session().commit()
h.flash(_("Auth token successfully created"), category='success')
return redirect(url('edit_user_auth_tokens', user_id=c.user.user_id))
def __before__(self):
super(FeedController, self).__before__()
#common values for feeds
self.description = _('Changes on %s repository')
self.title = self.title = _('%s %s feed') % (c.rhodecode_name, '%s')
self.language = 'en-us'
self.ttl = "5"
import rhodecode
CONF = rhodecode.CONFIG
self.include_diff = str2bool(CONF.get('rss_include_diff', False))
self.feed_nr = safe_int(CONF.get('rss_items_per_page', 20))
# we need to protect from parsing huge diffs here other way
# we can kill the server
self.feed_diff_limit = safe_int(CONF.get('rss_cut_off_limit', 32 * 1024))
def __before__(self):
super(FeedController, self).__before__()
#common values for feeds
self.description = _('Changes on %s repository')
self.title = self.title = _('%s %s feed') % (c.rhodecode_name, '%s')
self.language = 'en-us'
self.ttl = "5"
import rhodecode
CONF = rhodecode.CONFIG
self.include_diff = str2bool(CONF.get('rss_include_diff', False))
self.feed_nr = safe_int(CONF.get('rss_items_per_page', 20))
# we need to protect from parsing huge diffs here other way
# we can kill the server
self.feed_diff_limit = safe_int(CONF.get('rss_cut_off_limit', 32 * 1024))
def __before__(self):
"""
__before__ is called before controller methods and after __call__
"""
c.rhodecode_version = __version__
c.rhodecode_instanceid = config.get('instance_id')
c.rhodecode_name = config.get('rhodecode_title')
c.rhodecode_bugtracker = config.get('bugtracker', 'http://bitbucket.org/marcinkuzminski/rhodecode/issues')
c.use_gravatar = str2bool(config.get('use_gravatar'))
c.ga_code = config.get('rhodecode_ga_code')
# Visual options
c.visual = AttributeDict({})
rc_config = RhodeCodeSetting.get_app_settings()
## DB stored
c.visual.show_public_icon = str2bool(rc_config.get('rhodecode_show_public_icon'))
c.visual.show_private_icon = str2bool(rc_config.get('rhodecode_show_private_icon'))
c.visual.stylify_metatags = str2bool(rc_config.get('rhodecode_stylify_metatags'))
c.visual.dashboard_items = safe_int(rc_config.get('rhodecode_dashboard_items', 100))
c.visual.repository_fields = str2bool(rc_config.get('rhodecode_repository_fields'))
c.visual.show_version = str2bool(rc_config.get('rhodecode_show_version'))
## INI stored
self.cut_off_limit = int(config.get('cut_off_limit'))
c.visual.allow_repo_location_change = str2bool(config.get('allow_repo_location_change', True))
c.visual.allow_custom_hooks_settings = str2bool(config.get('allow_custom_hooks_settings', True))
c.repo_name = get_repo_slug(request) # can be empty
c.backends = BACKENDS.keys()
c.unread_notifications = NotificationModel()\
.get_unread_cnt_for_user(c.rhodecode_user.user_id)
self.sa = meta.Session
self.scm_model = ScmModel(self.sa)
def get_locks(self, apiuser, userid=Optional(OAttr('apiuser'))):
"""
Get all locks for given userid, if
this command is runned by non-admin account userid is set to user
who is calling this method, thus returning locks for himself
:param apiuser:
:param userid:
"""
if not HasPermissionAnyApi('hg.admin')(user=apiuser):
#make sure normal user does not pass someone else userid,
#he is not allowed to do that
if not isinstance(userid, Optional) and userid != apiuser.user_id:
raise JSONRPCError('userid is not the same as your user')
ret = []
if isinstance(userid, Optional):
user = None
else:
user = get_user_or_error(userid)
#show all locks
for r in Repository.getAll():
userid, time_ = r.locked
if time_:
_api_data = r.get_api_data()
# if we use userfilter just show the locks for this user
if user:
if safe_int(userid) == user.user_id:
ret.append(_api_data)
else:
ret.append(_api_data)
return ret
def index(self):
users_log = UserLog.query()\
.options(joinedload(UserLog.user))\
.options(joinedload(UserLog.repository))
#FILTERING
c.search_term = request.GET.get('filter')
try:
users_log = _journal_filter(users_log, c.search_term)
except Exception:
# we want this to crash for now
raise
users_log = users_log.order_by(UserLog.action_date.desc())
p = safe_int(request.GET.get('page', 1), 1)
def url_generator(**kw):
return url.current(filter=c.search_term, **kw)
c.users_log = Page(users_log, page=p, items_per_page=10, url=url_generator)
c.log_data = render('admin/admin_log.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.log_data
return render('admin/admin.html')
def update_perms(self, user_group_id):
"""
grant permission for given usergroup
:param user_group_id:
"""
user_group_id = safe_int(user_group_id)
c.user_group = UserGroup.get_or_404(user_group_id)
form = UserGroupPermsForm()().to_python(request.POST)
if not c.rhodecode_user.is_admin:
if self._revoke_perms_on_yourself(form):
msg = _('Cannot change permission for yourself as admin')
h.flash(msg, category='warning')
return redirect(
url('edit_user_group_perms', user_group_id=user_group_id))
try:
UserGroupModel().update_permissions(user_group_id,
form['perm_additions'],
form['perm_updates'],
form['perm_deletions'])
except RepoGroupAssignmentError:
h.flash(_('Target group cannot be the same'), category='error')
return redirect(
url('edit_user_group_perms', user_group_id=user_group_id))
#TODO: implement this
#action_logger(c.rhodecode_user, 'admin_changed_repo_permissions',
# repo_name, self.ip_addr, self.sa)
Session().commit()
h.flash(_('User Group permissions updated'), category='success')
return redirect(
url('edit_user_group_perms', user_group_id=user_group_id))
def validate_python(self, value, state):
gr = RepoGroup.get(value)
gr_name = gr.group_name if gr else None # None means ROOT location
# create repositories with write permission on group is set to true
create_on_write = HasPermissionAny(
'hg.create.write_on_repogroup.true')()
group_admin = HasRepoGroupPermissionAny('group.admin')(
gr_name, 'can write into group validator')
group_write = HasRepoGroupPermissionAny('group.write')(
gr_name, 'can write into group validator')
forbidden = not (group_admin or (group_write and create_on_write))
can_create_repos = HasPermissionAny(
'hg.admin', 'hg.create.repository')
gid = (old_data['repo_group'].get('group_id')
if (old_data and 'repo_group' in old_data) else None)
value_changed = gid != safe_int(value)
new = not old_data
# do check if we changed the value, there's a case that someone got
# revoked write permissions to a repository, he still created, we
# don't need to check permission if he didn't change the value of
# groups in form box
if value_changed or new:
# parent group need to be existing
if gr and forbidden:
msg = M(self, 'permission_denied', state)
raise formencode.Invalid(
msg, value, state, error_dict={'repo_type': msg}
)
# check if we can write to root location !
elif gr is None and not can_create_repos():
msg = M(self, 'permission_denied_root', state)
raise formencode.Invalid(
msg, value, state, error_dict={'repo_type': msg}
)
def edit_perms_summary(self, user_group_id):
user_group_id = safe_int(user_group_id)
c.user_group = UserGroup.get_or_404(user_group_id)
c.active = 'perms_summary'
permissions = {
'repositories': {},
'repositories_groups': {},
}
ugroup_repo_perms = UserGroupRepoToPerm.query()\
.options(joinedload(UserGroupRepoToPerm.permission))\
.options(joinedload(UserGroupRepoToPerm.repository))\
.filter(UserGroupRepoToPerm.users_group_id == user_group_id)\
.all()
for gr in ugroup_repo_perms:
permissions['repositories'][gr.repository.repo_name] \
= gr.permission.permission_name
ugroup_group_perms = UserGroupRepoGroupToPerm.query()\
.options(joinedload(UserGroupRepoGroupToPerm.permission))\
.options(joinedload(UserGroupRepoGroupToPerm.group))\
.filter(UserGroupRepoGroupToPerm.users_group_id == user_group_id)\
.all()
for gr in ugroup_group_perms:
permissions['repositories_groups'][gr.group.group_name] \
= gr.permission.permission_name
c.permissions = permissions
return render('admin/user_groups/user_group_edit.html')
def __before__(self):
"""
__before__ is called before controller methods and after __call__
"""
c.rhodecode_version = __version__
c.rhodecode_instanceid = config.get('instance_id')
c.rhodecode_name = config.get('rhodecode_title')
c.use_gravatar = str2bool(config.get('use_gravatar'))
c.ga_code = config.get('rhodecode_ga_code')
# Visual options
c.visual = AttributeDict({})
rc_config = RhodeCodeSetting.get_app_settings()
## DB stored
c.visual.show_public_icon = str2bool(rc_config.get('rhodecode_show_public_icon'))
c.visual.show_private_icon = str2bool(rc_config.get('rhodecode_show_private_icon'))
c.visual.stylify_metatags = str2bool(rc_config.get('rhodecode_stylify_metatags'))
c.visual.dashboard_items = safe_int(rc_config.get('rhodecode_dashboard_items', 100))
c.visual.repository_fields = str2bool(rc_config.get('rhodecode_repository_fields'))
c.visual.show_version = str2bool(rc_config.get('rhodecode_show_version'))
## INI stored
self.cut_off_limit = int(config.get('cut_off_limit'))
c.visual.allow_repo_location_change = str2bool(config.get('allow_repo_location_change', True))
c.repo_name = get_repo_slug(request) # can be empty
c.backends = BACKENDS.keys()
c.unread_notifications = NotificationModel()\
.get_unread_cnt_for_user(c.rhodecode_user.user_id)
self.sa = meta.Session
self.scm_model = ScmModel(self.sa)
def merge(self, repo_name, pull_request_id):
"""
POST /{repo_name}/pull-request/{pull_request_id}
Merge will perform a server-side merge of the specified
pull request, if the pull request is approved and mergeable.
After succesfull merging, the pull request is automatically
closed, with a relevant comment.
"""
pull_request_id = safe_int(pull_request_id)
pull_request = PullRequest.get_or_404(pull_request_id)
user = c.rhodecode_user
if self._meets_merge_pre_conditions(pull_request, user):
log.debug("Pre-conditions checked, trying to merge.")
extras = vcs_operation_context(
request.environ,
repo_name=pull_request.target_repo.repo_name,
username=user.username,
action='push',
scm=pull_request.target_repo.repo_type)
self._merge_pull_request(pull_request, user, extras)
return redirect(
url('pullrequest_show',
repo_name=pull_request.target_repo.repo_name,
pull_request_id=pull_request.pull_request_id))
def index(self):
users_log = UserLog.query()\
.options(joinedload(UserLog.user))\
.options(joinedload(UserLog.repository))
#FILTERING
c.search_term = request.GET.get('filter')
try:
users_log = _journal_filter(users_log, c.search_term)
except:
# we want this to crash for now
raise
users_log = users_log.order_by(UserLog.action_date.desc())
p = safe_int(request.params.get('page', 1), 1)
def url_generator(**kw):
return url.current(filter=c.search_term, **kw)
c.users_log = Page(users_log, page=p, items_per_page=10, url=url_generator)
c.log_data = render('admin/admin_log.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.log_data
return render('admin/admin.html')
def create_personal_repo_group(self, user_id):
"""
Create personal repository group for this user
:param user_id:
"""
from rhodecode.model.repo_group import RepoGroupModel
user_id = safe_int(user_id)
c.user = User.get_or_404(user_id)
try:
desc = RepoGroupModel.PERSONAL_GROUP_DESC % {
'username': c.user.username
}
if not RepoGroup.get_by_group_name(c.user.username):
RepoGroupModel().create(group_name=c.user.username,
group_description=desc,
owner=c.user.username)
msg = _('Created repository group `%s`' % (c.user.username, ))
h.flash(msg, category='success')
except Exception:
log.exception("Exception during repository group creation")
msg = _(
'An error occurred during repository group creation for user')
h.flash(msg, category='error')
return redirect(url('edit_user_advanced', user_id=user_id))
def edit_advanced_fork(self, repo_name):
"""
Mark given repository as a fork of another
:param repo_name:
"""
new_fork_id = request.POST.get('id_fork_of')
try:
if new_fork_id and not new_fork_id.isdigit():
log.error('Given fork id %s is not an INT', new_fork_id)
fork_id = safe_int(new_fork_id)
repo = ScmModel().mark_as_fork(repo_name, fork_id,
c.rhodecode_user.username)
fork = repo.fork.repo_name if repo.fork else _('Nothing')
Session().commit()
h.flash(_('Marked repo %s as fork of %s') % (repo_name, fork),
category='success')
except RepositoryError as e:
log.exception("Repository Error occurred")
h.flash(str(e), category='error')
except Exception as e:
log.exception("Exception while editing fork")
h.flash(_('An error occurred during this operation'),
category='error')
return redirect(url('edit_repo_advanced', repo_name=repo_name))
def update_object_permissions(self, form_result):
if 'perm_user_id' in form_result:
perm_user = User.get(safe_int(form_result['perm_user_id']))
else:
# used mostly to do lookup for default user
perm_user = User.get_by_username(form_result['perm_user_name'])
try:
# stage 2 reset defaults and set them from form data
self._set_new_user_perms(
perm_user,
form_result,
preserve=[
'default_repo_group_create', 'default_user_group_create',
'default_repo_create_on_write', 'default_repo_create',
'default_fork_create',
'default_inherit_default_permissions', 'default_register',
'default_extern_activate'
])
# overwrite default repo permissions
if form_result['overwrite_default_repo']:
_def_name = form_result['default_repo_perm'].split(
'repository.')[-1]
_def = Permission.get_by_key('repository.' + _def_name)
for r2p in self.sa.query(UserRepoToPerm)\
.filter(UserRepoToPerm.user == perm_user)\
.all():
# don't reset PRIVATE repositories
if not r2p.repository.private:
r2p.permission = _def
self.sa.add(r2p)
# overwrite default repo group permissions
if form_result['overwrite_default_group']:
_def_name = form_result['default_group_perm'].split(
'group.')[-1]
_def = Permission.get_by_key('group.' + _def_name)
for g2p in self.sa.query(UserRepoGroupToPerm)\
.filter(UserRepoGroupToPerm.user == perm_user)\
.all():
g2p.permission = _def
self.sa.add(g2p)
# overwrite default user group permissions
if form_result['overwrite_default_user_group']:
_def_name = form_result['default_user_group_perm'].split(
'usergroup.')[-1]
# user groups
_def = Permission.get_by_key('usergroup.' + _def_name)
for g2p in self.sa.query(UserUserGroupToPerm)\
.filter(UserUserGroupToPerm.user == perm_user)\
.all():
g2p.permission = _def
self.sa.add(g2p)
self.sa.commit()
except (DatabaseError, ):
log.exception('Failed to set default object permissions')
self.sa.rollback()
raise
def index(self):
"""GET /_admin/notifications: All items in the collection"""
# url('notifications')
c.user = c.rhodecode_user
notif = NotificationModel().get_for_user(
c.rhodecode_user.user_id, filter_=request.GET.getall('type'))
p = safe_int(request.GET.get('page', 1), 1)
notifications_url = webhelpers.paginate.PageURL(
url('notifications'), request.GET)
c.notifications = Page(notif,
page=p,
items_per_page=10,
url=notifications_url)
c.pull_request_type = Notification.TYPE_PULL_REQUEST
c.comment_type = [
Notification.TYPE_CHANGESET_COMMENT,
Notification.TYPE_PULL_REQUEST_COMMENT
]
_current_filter = request.GET.getall('type')
c.current_filter = 'all'
if _current_filter == [c.pull_request_type]:
c.current_filter = 'pull_request'
elif _current_filter == c.comment_type:
c.current_filter = 'comment'
if request.is_xhr:
return render('admin/notifications/notifications_data.html')
return render('admin/notifications/notifications.html')
def get_file_history(self, path, limit=None):
"""
Returns history of file as reversed list of ``Changeset`` objects for
which file at given ``path`` has been modified.
TODO: This function now uses os underlying 'git' and 'grep' commands
which is generally not good. Should be replaced with algorithm
iterating commits.
"""
self._get_filectx(path)
cs_id = safe_str(self.id)
f_path = safe_str(path)
if limit:
cmd = 'log -n %s --pretty="format: %%H" -s -p %s -- "%s"' % (
safe_int(limit, 0), cs_id, f_path
)
else:
cmd = 'log --pretty="format: %%H" -s -p %s -- "%s"' % (
cs_id, f_path
)
so, se = self.repository.run_git_command(cmd)
ids = re.findall(r'[0-9a-fA-F]{40}', so)
return [self.repository.get_changeset(id) for id in ids]
def update_application_permissions(self, form_result):
if 'perm_user_id' in form_result:
perm_user = User.get(safe_int(form_result['perm_user_id']))
else:
# used mostly to do lookup for default user
perm_user = User.get_by_username(form_result['perm_user_name'])
try:
# stage 1 set anonymous access
if perm_user.username == User.DEFAULT_USER:
perm_user.active = str2bool(form_result['anonymous'])
self.sa.add(perm_user)
# stage 2 reset defaults and set them from form data
self._set_new_user_perms(perm_user,
form_result,
preserve=[
'default_repo_perm',
'default_group_perm',
'default_user_group_perm',
'default_repo_group_create',
'default_user_group_create',
'default_repo_create_on_write',
'default_repo_create',
'default_fork_create',
'default_inherit_default_permissions',
])
self.sa.commit()
except (DatabaseError, ):
log.error(traceback.format_exc())
self.sa.rollback()
raise
def edit_auth_tokens(self, user_id):
user_id = safe_int(user_id)
c.user = User.get_or_404(user_id)
if c.user.username == User.DEFAULT_USER:
h.flash(_("You can't edit this user"), category='warning')
return redirect(url('users'))
c.active = 'auth_tokens'
show_expired = True
c.lifetime_values = [
(str(-1), _('forever')),
(str(5), _('5 minutes')),
(str(60), _('1 hour')),
(str(60 * 24), _('1 day')),
(str(60 * 24 * 30), _('1 month')),
]
c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]
c.role_values = [(x, AuthTokenModel.cls._get_role_name(x))
for x in AuthTokenModel.cls.ROLES]
c.role_options = [(c.role_values, _("Role"))]
c.user_auth_tokens = AuthTokenModel().get_auth_tokens(
c.user.user_id, show_expired=show_expired)
defaults = c.user.get_dict()
return htmlfill.render(render('admin/users/user_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def index(self):
# Return a rendered template
p = safe_int(request.GET.get('page', 1), 1)
c.user = User.get(c.rhodecode_user.user_id)
following = self.sa.query(UserFollowing)\
.filter(UserFollowing.user_id == c.rhodecode_user.user_id)\
.options(joinedload(UserFollowing.follows_repository))\
.all()
journal = self._get_journal_data(following)
def url_generator(**kw):
return url.current(filter=c.search_term, **kw)
c.journal_pager = Page(journal,
page=p,
items_per_page=20,
url=url_generator)
c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)
c.journal_data = render('journal/journal_data.html')
if request.is_xhr:
return c.journal_data
return render('journal/journal.html')
def edit_advanced(self, user_id):
user_id = safe_int(user_id)
user = c.user = User.get_or_404(user_id)
if user.username == User.DEFAULT_USER:
h.flash(_("You can't edit this user"), category='warning')
return redirect(url('users'))
c.active = 'advanced'
c.perm_user = AuthUser(user_id=user_id, ip_addr=self.ip_addr)
c.personal_repo_group = RepoGroup.get_by_group_name(user.username)
c.first_admin = User.get_first_super_admin()
defaults = user.get_dict()
# Interim workaround if the user participated on any pull requests as a
# reviewer.
has_review = bool(PullRequestReviewers.query().filter(
PullRequestReviewers.user_id == user_id).first())
c.can_delete_user = not has_review
c.can_delete_user_message = _(
'The user participates as reviewer in pull requests and '
'cannot be deleted. You can set the user to '
'"inactive" instead of deleting it.') if has_review else ''
return htmlfill.render(render('admin/users/user_edit.html'),
defaults=defaults,
encoding="UTF-8",
force_defaults=False)
def index(self):
# Return a rendered template
p = safe_int(request.params.get('page', 1), 1)
c.user = User.get(self.rhodecode_user.user_id)
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)
c.following = self.sa.query(UserFollowing)\
.filter(UserFollowing.user_id == self.rhodecode_user.user_id)\
.options(joinedload(UserFollowing.follows_repository))\
.all()
journal = self._get_journal_data(c.following)
c.journal_pager = Page(journal, page=p, items_per_page=20)
c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)
c.journal_data = render('journal/journal_data.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.journal_data
return render('journal/journal.html')
def _load_changelog_summary():
p = safe_int(request.GET.get('page'), 1)
size = safe_int(request.GET.get('size'), 10)
def url_generator(**kw):
return url('changelog_summary_home',
repo_name=c.rhodecode_db_repo.repo_name, size=size, **kw)
collection = c.rhodecode_repo
c.repo_changesets = RepoPage(collection, page=p,
items_per_page=size,
url=url_generator)
page_revisions = [x.raw_id for x in list(c.repo_changesets)]
c.comments = c.rhodecode_db_repo.get_comments(page_revisions)
c.statuses = c.rhodecode_db_repo.statuses(page_revisions)
def __before__(self):
c.rhodecode_version = __version__
c.rhodecode_instanceid = config.get('instance_id')
c.rhodecode_name = config.get('rhodecode_title')
c.use_gravatar = str2bool(config.get('use_gravatar'))
c.ga_code = config.get('rhodecode_ga_code')
# Visual options
c.visual = AttributeDict({})
rc_config = RhodeCodeSetting.get_app_settings()
c.visual.show_public_icon = str2bool(rc_config.get('rhodecode_show_public_icon'))
c.visual.show_private_icon = str2bool(rc_config.get('rhodecode_show_private_icon'))
c.visual.stylify_metatags = str2bool(rc_config.get('rhodecode_stylify_metatags'))
c.visual.lightweight_dashboard = str2bool(rc_config.get('rhodecode_lightweight_dashboard'))
c.visual.lightweight_dashboard_items = safe_int(config.get('dashboard_items', 100))
c.repo_name = get_repo_slug(request)
c.backends = BACKENDS.keys()
c.unread_notifications = NotificationModel()\
.get_unread_cnt_for_user(c.rhodecode_user.user_id)
self.cut_off_limit = int(config.get('cut_off_limit'))
self.sa = meta.Session
self.scm_model = ScmModel(self.sa)
self.ip_addr = ''
def update(self, gist, description, owner, gist_mapping, gist_type,
lifetime, gist_acl_level):
gist = self._get_gist(gist)
gist_repo = gist.scm_instance()
lifetime = safe_int(lifetime, -1)
if lifetime == 0: # preserve old value
gist_expires = gist.gist_expires
else:
gist_expires = (
time.time() + (lifetime * 60) if lifetime != -1 else -1)
# calculate operation type based on given data
gist_mapping_op = {}
for k, v in gist_mapping.items():
# add, mod, del
if not v['org_filename'] and v['filename']:
op = 'add'
elif v['org_filename'] and not v['filename']:
op = 'del'
else:
op = 'mod'
v['op'] = op
gist_mapping_op[k] = v
gist.gist_description = description
gist.gist_expires = gist_expires
gist.owner = owner
gist.gist_type = gist_type
gist.acl_level = gist_acl_level
self.sa.add(gist)
self.sa.flush()
message = 'updated file'
message += 's: ' if len(gist_mapping) > 1 else ': '
message += ', '.join([x for x in gist_mapping])
# fake RhodeCode Repository object
fake_repo = AttributeDict({
'repo_name': gist_repo.path,
'scm_instance': lambda *args, **kwargs: gist_repo,
})
self._store_metadata(gist_repo, gist.gist_id, gist.gist_access_id,
owner.user_id, owner.username, gist.gist_type,
gist.gist_expires, gist_acl_level)
# this can throw NodeNotChangedError, if changes we're trying to commit
# are not actually changes...
ScmModel().update_nodes(
user=owner.user_id,
repo=fake_repo,
message=message,
nodes=gist_mapping_op,
trigger_push_hook=False
)
return gist
def __init__(self, reponame, username, *args, **kwargs):
from rhodecode import CONFIG
from rhodecode.lib.utils2 import safe_int
_code = CONFIG.get('lock_ret_code')
self.code = safe_int(_code, self.code)
self.title = self.explanation = ('Repository `%s` locked by '
'user `%s`' % (reponame, username))
super(HTTPLockedRC, self).__init__(*args, **kwargs)
def __init__(self, message, *args, **kwargs):
from rhodecode import CONFIG
from rhodecode.lib.utils2 import safe_int
_code = CONFIG.get('lock_ret_code')
self.code = safe_int(_code, self.code)
self.title = self.explanation = message
super(HTTPLockedRC, self).__init__(*args, **kwargs)
self.args = (message, )
def _get_config(self):
import rhodecode
config = rhodecode.CONFIG
return {
'language':
'en-us',
'feed_ttl':
'5', # TTL of feed,
'feed_include_diff':
str2bool(config.get('rss_include_diff', False)),
'feed_items_per_page':
safe_int(config.get('rss_items_per_page', 20)),
'feed_diff_limit':
# we need to protect from parsing huge diffs here other way
# we can kill the server
safe_int(config.get('rss_cut_off_limit', 32 * 1024)),
}
def my_account_auth_tokens_add(self):
lifetime = safe_int(request.POST.get('lifetime'), -1)
description = request.POST.get('description')
role = request.POST.get('role')
AuthTokenModel().create(c.rhodecode_user.user_id, description,
lifetime, role)
Session().commit()
h.flash(_("Auth token successfully created"), category='success')
return redirect(url('my_account_auth_tokens'))
def update(self, user_id):
"""PUT /users/user_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('update_user', user_id=ID),
# method='put')
# url('user', user_id=ID)
user_id = safe_int(user_id)
c.user = User.get_or_404(user_id)
c.active = 'profile'
c.extern_type = c.user.extern_type
c.extern_name = c.user.extern_name
c.perm_user = AuthUser(user_id=user_id, ip_addr=self.ip_addr)
available_languages = [x[0] for x in c.allowed_languages]
_form = UserForm(edit=True,
available_languages=available_languages,
old_data={
'user_id': user_id,
'email': c.user.email
})()
form_result = {}
try:
form_result = _form.to_python(dict(request.POST))
skip_attrs = ['extern_type', 'extern_name']
# TODO: plugin should define if username can be updated
if c.extern_type != "rhodecode":
# forbid updating username for external accounts
skip_attrs.append('username')
UserModel().update_user(user_id,
skip_attrs=skip_attrs,
**form_result)
usr = form_result['username']
action_logger(c.rhodecode_user, 'admin_updated_user:%s' % usr,
None, self.ip_addr, self.sa)
h.flash(_('User updated successfully'), category='success')
Session().commit()
except formencode.Invalid as errors:
defaults = errors.value
e = errors.error_dict or {}
return htmlfill.render(render('admin/users/user_edit.html'),
defaults=defaults,
errors=e,
prefix_error=False,
encoding="UTF-8",
force_defaults=False)
except UserCreationError as e:
h.flash(e, 'error')
except Exception:
log.exception("Exception updating user")
h.flash(_('Error occurred during update of user %s') %
form_result.get('username'),
category='error')
return redirect(url('edit_user', user_id=user_id))
def _load_changelog_summary():
p = safe_int(request.GET.get('page'), 1)
size = safe_int(request.GET.get('size'), 10)
def url_generator(**kw):
return url('changelog_summary_home',
repo_name=c.rhodecode_db_repo.repo_name,
size=size,
**kw)
collection = c.rhodecode_repo
c.repo_changesets = RepoPage(collection,
page=p,
items_per_page=size,
url=url_generator)
page_revisions = [x.raw_id for x in list(c.repo_changesets)]
c.comments = c.rhodecode_db_repo.get_comments(page_revisions)
c.statuses = c.rhodecode_db_repo.statuses(page_revisions)
def delete(self, repo_name, pull_request_id):
pull_request_id = safe_int(pull_request_id)
pull_request = PullRequest.get_or_404(pull_request_id)
# only owner can delete it !
if pull_request.author.user_id == c.rhodecode_user.user_id:
PullRequestModel().delete(pull_request)
Session().commit()
h.flash(_('Successfully deleted pull request'), category='success')
return redirect(url('my_account_pullrequests'))
raise HTTPForbidden()
def new(self):
"""GET /repo_groups/new: Form to create a new item"""
# url('new_repo_group')
# perm check for admin, create_group perm or admin of parent_group
parent_group_id = safe_int(request.GET.get('parent_group'))
if not self._can_create_repo_group(parent_group_id):
return abort(403)
self.__load_defaults()
return render('admin/repo_groups/repo_group_add.html')
def index(self, repo_name):
p = safe_int(request.params.get('page', 1), 1)
size = safe_int(request.params.get('size', 20), 20)
def url_generator(**kw):
return url('shortlog_home', repo_name=repo_name, size=size, **kw)
c.repo_changesets = RepoPage(c.rhodecode_repo, page=p,
items_per_page=size, url=url_generator)
page_revisions = [x.raw_id for x in list(c.repo_changesets)]
c.statuses = c.rhodecode_db_repo.statuses(page_revisions)
if not c.repo_changesets:
return redirect(url('summary_home', repo_name=repo_name))
c.shortlog_data = render('shortlog/shortlog_data.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.shortlog_data
r = render('shortlog/shortlog.html')
return r
def show_all(self, repo_name):
c.pull_requests = PullRequestModel().get_all(repo_name)
c.repo_name = repo_name
p = safe_int(request.GET.get('page', 1), 1)
c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=10)
c.pullrequest_data = render('/pullrequests/pullrequest_data.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.pullrequest_data
return render('/pullrequests/pullrequest_show_all.html')
def index(self, repo_name, revision=None, f_path=None):
limit = 100
default = 20
if request.GET.get('size'):
c.size = max(min(safe_int(request.GET.get('size')), limit), 1)
session['changelog_size'] = c.size
session.save()
else:
c.size = int(session.get('changelog_size', default))
# min size must be 1
c.size = max(c.size, 1)
p = safe_int(request.GET.get('page', 1), 1)
branch_name = request.GET.get('branch', None)
if (branch_name and
branch_name not in c.rhodecode_repo.branches and
branch_name not in c.rhodecode_repo.closed_branches and
not revision):
return redirect(url('changelog_file_home', repo_name=c.repo_name,
revision=branch_name, f_path=f_path or ''))
c.changelog_for_path = f_path
try:
if f_path:
log.debug('generating changelog for path %s' % f_path)
# get the history for the file !
tip_cs = c.rhodecode_repo.get_changeset()
try:
collection = tip_cs.get_file_history(f_path)
except (NodeDoesNotExistError, ChangesetError):
#this node is not present at tip !
try:
cs = self.__get_cs_or_redirect(revision, repo_name)
collection = cs.get_file_history(f_path)
except RepositoryError, e:
h.flash(safe_str(e), category='warning')
redirect(h.url('changelog_home', repo_name=repo_name))
collection = list(reversed(collection))
else:
def followers(self, repo_name):
p = safe_int(request.GET.get('page', 1), 1)
repo_id = c.rhodecode_db_repo.repo_id
d = UserFollowing.get_repo_followers(repo_id)\
.order_by(UserFollowing.follows_from)
c.followers_pager = Page(d, page=p, items_per_page=20)
c.followers_data = render('/followers/followers_data.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.followers_data
return render('/followers/followers.html')
def show_id(cs):
"""
Configurable function that shows ID
by default it's r123:fffeeefffeee
:param cs: changeset instance
"""
from rhodecode import CONFIG
def_len = safe_int(CONFIG.get('show_sha_length', 12))
show_rev = str2bool(CONFIG.get('show_revision_number', True))
raw_id = cs.raw_id[:def_len]
if show_rev:
return 'r%s:%s' % (cs.revision, raw_id)
else:
return '%s' % (raw_id)
def index(self):
users_log = (
UserLog.query()
.options(joinedload(UserLog.user))
.options(joinedload(UserLog.repository))
.order_by(UserLog.action_date.desc())
)
p = safe_int(request.params.get("page", 1), 1)
c.users_log = Page(users_log, page=p, items_per_page=10)
c.log_data = render("admin/admin_log.html")
if request.environ.get("HTTP_X_PARTIAL_XHR"):
return c.log_data
return render("admin/admin.html")
def forks(self, repo_name):
p = safe_int(request.params.get('page', 1), 1)
repo_id = c.rhodecode_db_repo.repo_id
d = []
for r in Repository.get_repo_forks(repo_id):
if not HasRepoPermissionAny(
'repository.read', 'repository.write', 'repository.admin'
)(r.repo_name, 'get forks check'):
continue
d.append(r)
c.forks_pager = Page(d, page=p, items_per_page=20)
c.forks_data = render('/forks/forks_data.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.forks_data
return render('/forks/forks.html')
def public_journal(self):
# Return a rendered template
p = safe_int(request.GET.get('page', 1), 1)
c.following = self.sa.query(UserFollowing)\
.filter(UserFollowing.user_id == self.rhodecode_user.user_id)\
.options(joinedload(UserFollowing.follows_repository))\
.all()
journal = self._get_journal_data(c.following)
c.journal_pager = Page(journal, page=p, items_per_page=20)
c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)
c.journal_data = render('journal/journal_data.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.journal_data
return render('journal/public_journal.html')
def new(self, format='html'):
"""GET /repos_groups/new: Form to create a new item"""
# url('new_repos_group')
if HasPermissionAll('hg.admin')('group create'):
#we're global admin, we're ok and we can create TOP level groups
pass
else:
# we pass in parent group into creation form, thus we know
# what would be the group, we can check perms here !
group_id = safe_int(request.GET.get('parent_group'))
group = RepoGroup.get(group_id) if group_id else None
group_name = group.group_name if group else None
if HasReposGroupPermissionAll('group.admin')(group_name, 'group create'):
pass
else:
return abort(403)
self.__load_defaults()
return render('admin/repos_groups/repos_groups_add.html')
def index(self, format='html'):
"""GET /admin/gists: All items in the collection"""
# url('gists')
c.show_private = request.GET.get('private') and c.rhodecode_user.username != 'default'
c.show_public = request.GET.get('public') and c.rhodecode_user.username != 'default'
gists = Gist().query()\
.filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time()))\
.order_by(Gist.created_on.desc())
if c.show_private:
c.gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE)\
.filter(Gist.gist_owner == c.rhodecode_user.user_id)
elif c.show_public:
c.gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)\
.filter(Gist.gist_owner == c.rhodecode_user.user_id)
else:
c.gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)
p = safe_int(request.GET.get('page', 1), 1)
c.gists_pager = Page(c.gists, page=p, items_per_page=10)
return render('admin/gists/index.html')
def index(self, format='html'):
"""GET /_admin/notifications: All items in the collection"""
# url('notifications')
c.user = self.rhodecode_user
notif = NotificationModel().get_for_user(self.rhodecode_user.user_id,
filter_=request.GET.getall('type'))
p = safe_int(request.GET.get('page', 1), 1)
c.notifications = Page(notif, page=p, items_per_page=10)
c.pull_request_type = Notification.TYPE_PULL_REQUEST
c.comment_type = [Notification.TYPE_CHANGESET_COMMENT,
Notification.TYPE_PULL_REQUEST_COMMENT]
_current_filter = request.GET.getall('type')
c.current_filter = 'all'
if _current_filter == [c.pull_request_type]:
c.current_filter = 'pull_request'
elif _current_filter == c.comment_type:
c.current_filter = 'comment'
return render('admin/notifications/notifications.html')
def delete_repos_group_user_perm(self, group_name):
"""
DELETE an existing repository group permission user
:param group_name:
"""
try:
if not c.rhodecode_user.is_admin:
if c.rhodecode_user.user_id == safe_int(request.POST['user_id']):
msg = _('Cannot revoke permission for yourself as admin')
h.flash(msg, category='warning')
raise Exception('revoke admin permission on self')
recursive = str2bool(request.POST.get('recursive', False))
ReposGroupModel().delete_permission(
repos_group=group_name, obj=request.POST['user_id'],
obj_type='user', recursive=recursive
)
Session().commit()
except Exception:
log.error(traceback.format_exc())
h.flash(_('An error occurred during deletion of group user'),
category='error')
raise HTTPInternalServerError()
def get_locks(self, apiuser, userid=Optional(OAttr('apiuser'))):
"""
Get all locks for given userid, if
this command is runned by non-admin account userid is set to user
who is calling this method, thus returning locks for himself
:param apiuser:
:param userid:
"""
if HasPermissionAnyApi('hg.admin')(user=apiuser):
pass
else:
#make sure normal user does not pass someone else userid,
#he is not allowed to do that
if not isinstance(userid, Optional) and userid != apiuser.user_id:
raise JSONRPCError(
'userid is not the same as your user'
)
ret = []
if isinstance(userid, Optional):
user = None
else:
user = get_user_or_error(userid)
#show all locks
for r in Repository.getAll():
userid, time_ = r.locked
if time_:
_api_data = r.get_api_data()
# if we use userfilter just show the locks for this user
if user:
if safe_int(userid) == user.user_id:
ret.append(_api_data)
else:
ret.append(_api_data)
return ret
def index(self):
limit = 100
default = 20
if request.params.get('size'):
try:
int_size = int(request.params.get('size'))
except ValueError:
int_size = default
c.size = max(min(int_size, limit), 1)
session['changelog_size'] = c.size
session.save()
else:
c.size = int(session.get('changelog_size', default))
# min size must be 1
c.size = max(c.size, 1)
p = safe_int(request.params.get('page', 1), 1)
branch_name = request.params.get('branch', None)
try:
if branch_name:
collection = [z for z in
c.rhodecode_repo.get_changesets(start=0,
branch_name=branch_name)]
c.total_cs = len(collection)
else:
collection = c.rhodecode_repo
c.total_cs = len(c.rhodecode_repo)
c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,
items_per_page=c.size, branch=branch_name)
collection = list(c.pagination)
page_revisions = [x.raw_id for x in collection]
c.comments = c.rhodecode_db_repo.get_comments(page_revisions)
c.statuses = c.rhodecode_db_repo.statuses(page_revisions)
except (RepositoryError, ChangesetDoesNotExistError, Exception), e:
log.error(traceback.format_exc())
h.flash(str(e), category='warning')
return redirect(url('home'))
def index(self):
# Return a rendered template
p = safe_int(request.GET.get('page', 1), 1)
c.user = User.get(self.rhodecode_user.user_id)
c.following = self.sa.query(UserFollowing)\
.filter(UserFollowing.user_id == self.rhodecode_user.user_id)\
.options(joinedload(UserFollowing.follows_repository))\
.all()
journal = self._get_journal_data(c.following)
def url_generator(**kw):
return url.current(filter=c.search_term, **kw)
c.journal_pager = Page(journal, page=p, items_per_page=20, url=url_generator)
c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)
c.journal_data = render('journal/journal_data.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.journal_data
repos_list = Session().query(Repository)\
.filter(Repository.user_id ==
self.rhodecode_user.user_id)\
.order_by(func.lower(Repository.repo_name)).all()
repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,
admin=True)
#json used to render the grid
c.data = json.dumps(repos_data)
watched_repos_data = []
## watched repos
_render = RepoModel._render_datatable
def quick_menu(repo_name):
return _render('quick_menu', repo_name)
def repo_lnk(name, rtype, private, fork_of):
return _render('repo_name', name, rtype, private, fork_of,
short_name=False, admin=False)
def last_rev(repo_name, cs_cache):
return _render('revision', repo_name, cs_cache.get('revision'),
cs_cache.get('raw_id'), cs_cache.get('author'),
cs_cache.get('message'))
def desc(desc):
from pylons import tmpl_context as c
if c.visual.stylify_metatags:
return h.urlify_text(h.desc_stylize(h.truncate(desc, 60)))
else:
return h.urlify_text(h.truncate(desc, 60))
def repo_actions(repo_name):
return _render('repo_actions', repo_name)
def owner_actions(user_id, username):
return _render('user_name', user_id, username)
def toogle_follow(repo_id):
return _render('toggle_follow', repo_id)
for entry in c.following:
repo = entry.follows_repository
cs_cache = repo.changeset_cache
row = {
"menu": quick_menu(repo.repo_name),
"raw_name": repo.repo_name.lower(),
"name": repo_lnk(repo.repo_name, repo.repo_type,
repo.private, repo.fork),
"last_changeset": last_rev(repo.repo_name, cs_cache),
"raw_tip": cs_cache.get('revision'),
"action": toogle_follow(repo.repo_id)
}
watched_repos_data.append(row)
c.watched_data = json.dumps({
"totalRecords": len(c.following),
"startIndex": 0,
"sort": "name",
"dir": "asc",
"records": watched_repos_data
})
return render('journal/journal.html')
def create(self, description, owner, gist_mapping,
gist_type=Gist.GIST_PUBLIC, lifetime=-1):
"""
:param description: description of the gist
:param owner: user who created this gist
:param gist_mapping: mapping {filename:{'content':content},...}
:param gist_type: type of gist private/public
:param lifetime: in minutes, -1 == forever
"""
gist_id = safe_unicode(unique_id(20))
lifetime = safe_int(lifetime, -1)
gist_expires = time.time() + (lifetime * 60) if lifetime != -1 else -1
log.debug('set GIST expiration date to: %s'
% (time_to_datetime(gist_expires)
if gist_expires != -1 else 'forever'))
#create the Database version
gist = Gist()
gist.gist_description = description
gist.gist_access_id = gist_id
gist.gist_owner = owner.user_id
gist.gist_expires = gist_expires
gist.gist_type = safe_unicode(gist_type)
self.sa.add(gist)
self.sa.flush()
if gist_type == Gist.GIST_PUBLIC:
# use DB ID for easy to use GIST ID
gist_id = safe_unicode(gist.gist_id)
gist.gist_access_id = gist_id
self.sa.add(gist)
gist_repo_path = os.path.join(GIST_STORE_LOC, gist_id)
log.debug('Creating new %s GIST repo in %s' % (gist_type, gist_repo_path))
repo = RepoModel()._create_repo(repo_name=gist_repo_path, alias='hg',
parent=None)
processed_mapping = {}
for filename in gist_mapping:
if filename != os.path.basename(filename):
raise Exception('Filename cannot be inside a directory')
content = gist_mapping[filename]['content']
#TODO: expand support for setting explicit lexers
# if lexer is None:
# try:
# lexer = pygments.lexers.guess_lexer_for_filename(filename,content)
# except pygments.util.ClassNotFound:
# lexer = 'text'
processed_mapping[filename] = {'content': content}
# now create single multifile commit
message = 'added file'
message += 's: ' if len(processed_mapping) > 1 else ': '
message += ', '.join([x for x in processed_mapping])
#fake RhodeCode Repository object
fake_repo = AttributeDict(dict(
repo_name=gist_repo_path,
scm_instance_no_cache=lambda: repo,
))
ScmModel().create_nodes(
user=owner.user_id, repo=fake_repo,
message=message,
nodes=processed_mapping,
trigger_push_hook=False
)
# store metadata inside the gist, this can be later used for imports
# or gist identification
metadata = {
'gist_db_id': gist.gist_id,
'gist_access_id': gist.gist_access_id,
'gist_owner_id': owner.user_id,
'gist_type': gist.gist_type,
'gist_exipres': gist.gist_expires
}
with open(os.path.join(repo.path, '.hg', GIST_METADATA_FILE), 'wb') as f:
f.write(json.dumps(metadata))
return gist
def index(self, search_repo=None):
c.repo_name = search_repo
c.formated_results = []
c.runtime = ''
c.cur_query = request.GET.get('q', None)
c.cur_type = request.GET.get('type', 'content')
c.cur_search = search_type = {'content': 'content',
'commit': 'message',
'path': 'path',
'repository': 'repository'
}.get(c.cur_type, 'content')
index_name = {
'content': IDX_NAME,
'commit': CHGSET_IDX_NAME,
'path': IDX_NAME
}.get(c.cur_type, IDX_NAME)
schema_defn = {
'content': SCHEMA,
'commit': CHGSETS_SCHEMA,
'path': SCHEMA
}.get(c.cur_type, SCHEMA)
log.debug('IDX: %s' % index_name)
log.debug('SCHEMA: %s' % schema_defn)
if c.cur_query:
cur_query = c.cur_query.lower()
log.debug(cur_query)
if c.cur_query:
p = safe_int(request.params.get('page', 1), 1)
highlight_items = set()
try:
idx = open_dir(config['app_conf']['index_dir'],
indexname=index_name)
searcher = idx.searcher()
qp = QueryParser(search_type, schema=schema_defn)
if c.repo_name:
cur_query = u'repository:%s %s' % (c.repo_name, cur_query)
try:
query = qp.parse(unicode(cur_query))
# extract words for highlight
if isinstance(query, Phrase):
highlight_items.update(query.words)
elif isinstance(query, Prefix):
highlight_items.add(query.text)
else:
for i in query.all_terms():
if i[0] in ['content', 'message']:
highlight_items.add(i[1])
matcher = query.matcher(searcher)
log.debug('query: %s' % query)
log.debug('hl terms: %s' % highlight_items)
results = searcher.search(query)
res_ln = len(results)
c.runtime = '%s results (%.3f seconds)' % (
res_ln, results.runtime
)
def url_generator(**kw):
return update_params("?q=%s&type=%s" \
% (safe_str(c.cur_query), safe_str(c.cur_type)), **kw)
repo_location = RepoModel().repos_path
c.formated_results = Page(
WhooshResultWrapper(search_type, searcher, matcher,
highlight_items, repo_location),
page=p,
item_count=res_ln,
items_per_page=10,
url=url_generator
)
except QueryParserError:
c.runtime = _('Invalid search query. Try quoting it.')
searcher.close()
except (EmptyIndexError, IOError):
log.error(traceback.format_exc())
log.error('Empty Index data')
c.runtime = _('There is no index to search in. '
'Please run whoosh indexer')
except (Exception):
log.error(traceback.format_exc())
c.runtime = _('An error occurred during this search operation')
# Return a rendered template
return render('/search/search.html')
def index(self, repo_name=None):
c.repo_name = repo_name
c.formated_results = []
c.runtime = ""
c.cur_query = request.GET.get("q", None)
c.cur_type = request.GET.get("type", "content")
c.cur_search = search_type = {
"content": "content",
"commit": "message",
"path": "path",
"repository": "repository",
}.get(c.cur_type, "content")
index_name = {"content": IDX_NAME, "commit": CHGSET_IDX_NAME, "path": IDX_NAME}.get(c.cur_type, IDX_NAME)
schema_defn = {"content": SCHEMA, "commit": CHGSETS_SCHEMA, "path": SCHEMA}.get(c.cur_type, SCHEMA)
log.debug("IDX: %s" % index_name)
log.debug("SCHEMA: %s" % schema_defn)
if c.cur_query:
cur_query = c.cur_query.lower()
log.debug(cur_query)
if c.cur_query:
p = safe_int(request.GET.get("page", 1), 1)
highlight_items = set()
try:
idx = open_dir(config["app_conf"]["index_dir"], indexname=index_name)
searcher = idx.searcher()
qp = QueryParser(search_type, schema=schema_defn)
if c.repo_name:
cur_query = u"repository:%s %s" % (c.repo_name, cur_query)
try:
query = qp.parse(unicode(cur_query))
# extract words for highlight
if isinstance(query, Phrase):
highlight_items.update(query.words)
elif isinstance(query, Prefix):
highlight_items.add(query.text)
else:
for i in query.all_terms():
if i[0] in ["content", "message"]:
highlight_items.add(i[1])
matcher = query.matcher(searcher)
log.debug("query: %s" % query)
log.debug("hl terms: %s" % highlight_items)
results = searcher.search(query)
res_ln = len(results)
c.runtime = "%s results (%.3f seconds)" % (res_ln, results.runtime)
def url_generator(**kw):
q = urllib.quote(safe_str(c.cur_query))
return update_params("?q=%s&type=%s" % (q, safe_str(c.cur_type)), **kw)
repo_location = RepoModel().repos_path
c.formated_results = Page(
WhooshResultWrapper(search_type, searcher, matcher, highlight_items, repo_location),
page=p,
item_count=res_ln,
items_per_page=10,
url=url_generator,
)
except QueryParserError:
c.runtime = _("Invalid search query. Try quoting it.")
searcher.close()
except (EmptyIndexError, IOError):
log.error(traceback.format_exc())
log.error("Empty Index data")
c.runtime = _("There is no index to search in. " "Please run whoosh indexer")
except (Exception):
log.error(traceback.format_exc())
c.runtime = _("An error occurred during this search operation")
# Return a rendered template
return render("/search/search.html")
