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): """ __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 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")