def test_returns_parse_results(self, parse, pyramid_request): parse.return_value = {"foo": "bar"} pyramid_request.GET["q"] = "giraffe" result = extract(pyramid_request, parse=parse) assert result == {"foo": "bar"}
def test_returns_parse_results(self, parse, pyramid_request): parse.return_value = {'foo': 'bar'} pyramid_request.GET['q'] = 'giraffe' result = extract(pyramid_request, parse=parse) assert result == {'foo': 'bar'}
def search(self): check_slug(self.group, self.request) result = super(GroupSearchController, self).search() result["opts"] = {"search_groupname": self.group.name} if self.request.authenticated_user not in self.group.members: return result def user_annotation_count(aggregation, userid): for user in aggregation: if user["user"] == userid: return user["count"] return 0 q = query.extract(self.request) users_aggregation = result["search_results"].aggregations.get("users", []) members = [ { "username": u.username, "userid": u.userid, "count": user_annotation_count(users_aggregation, u.userid), "faceted_by": _faceted_by_user(self.request, u.username, q), } for u in self.group.members ] members = sorted(members, key=lambda k: k["username"].lower()) group_annotation_count = None if self.request.feature("total_shared_annotations"): group_annotation_count = self.request.find_service(name="annotation_stats").group_annotation_count( self.group.pubid ) result["stats"] = {"annotation_count": group_annotation_count} result["group"] = { "created": self.group.created.strftime("%B, %Y"), "description": self.group.description, "name": self.group.name, "pubid": self.group.pubid, "url": self.request.route_url("group_read", pubid=self.group.pubid, slug=self.group.slug), "members": members, } if self.request.has_permission("admin", self.group): result["group_edit_url"] = self.request.route_url("group_edit", pubid=self.group.pubid) result["more_info"] = "more_info" in self.request.params if not result.get("q"): result["zero_message"] = Markup( _("The group “{name}” has not made any annotations yet.").format(name=Markup.escape(self.group.name)) ) return result
def search(request): if not request.feature('search_page'): raise httpexceptions.HTTPNotFound() q = query.extract(request) # Check whether a redirect is required query.check_url(request, q) page_size = request.params.get('page_size', PAGE_SIZE) try: page_size = int(page_size) except ValueError: page_size = PAGE_SIZE # Fetch results result = query.execute(request, q, page_size=page_size) groups_suggestions = [] if request.authenticated_user: for group in request.authenticated_user.groups: groups_suggestions.append({ 'name': group.name, 'pubid': group.pubid }) def tag_link(tag): q = parser.unparse({'tag': tag}) return request.route_url('activity.search', _query=[('q', q)]) def username_from_id(userid): parts = split_user(userid) return parts['username'] def user_link(userid): username=username_from_id(userid) return request.route_url('activity.user_search', username=username) return { 'aggregations': result.aggregations, 'groups_suggestions': groups_suggestions, 'page': paginate(request, result.total, page_size=page_size), 'pretty_link': pretty_link, 'q': request.params.get('q', ''), 'tag_link': tag_link, 'timeframes': result.timeframes, 'total': result.total, 'user_link': user_link, 'username_from_id': username_from_id, }
def group_search(request): if not request.feature('search_page'): raise httpexceptions.HTTPNotFound() result = search(request) pubid = request.matchdict['pubid'] result['opts'] = {'search_groupname': pubid} try: group = request.db.query(models.Group).filter_by(pubid=pubid).one() except exc.NoResultFound: return result result['opts']['search_groupname'] = group.name if request.authenticated_user not in group.members: return result def user_annotation_count(aggregation, userid): for user in aggregation: if user['user'] == userid: return user['count'] return 0 q = query.extract(request) users_aggregation = result.get('aggregations', {}).get('users', []) members = [{'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(request, u.username, q)} for u in group.members] members = sorted(members, key=lambda k: k['username'].lower()) result['group'] = { 'created': group.created.strftime('%B, %Y'), 'description': group.description, 'name': group.name, 'pubid': group.pubid, 'url': request.route_url('group_read', pubid=group.pubid, slug=group.slug), 'members': members, } if request.has_permission('admin', group): result['group_edit_url'] = request.route_url('group_edit', pubid=pubid) result['more_info'] = 'more_info' in request.params return result
def test_overrides_user_term_for_user_search_requests(self, parse, pyramid_request): """ If the query sent to a user search page includes a user, we override it, because otherwise we'll display the union of the results for those two users, which makes no sense. """ parse.return_value = MultiDict({"foo": "bar", "user": "******"}) pyramid_request.matched_route.name = "activity.user_search" pyramid_request.matchdict["username"] = "******" pyramid_request.GET["q"] = "giraffe" result = extract(pyramid_request, parse=parse) assert result.dict_of_lists() == {"foo": ["bar"], "user": ["josiah"]}
def search(self): q = query.extract(self.request) # Check whether a redirect is required. query.check_url(self.request, q) page_size = self.request.params.get('page_size', PAGE_SIZE) try: page_size = int(page_size) except ValueError: page_size = PAGE_SIZE # Fetch results. results = query.execute(self.request, q, page_size=page_size) groups_suggestions = [] if self.request.user: for group in self.request.user.groups: groups_suggestions.append({ 'name': group.name, 'pubid': group.pubid }) def tag_link(tag): q = parser.unparse({'tag': tag}) return self.request.route_url('activity.search', _query=[('q', q)]) def username_from_id(userid): parts = split_user(userid) return parts['username'] def user_link(userid): username = username_from_id(userid) return self.request.route_url('activity.user_search', username=username) return { 'search_results': results, 'groups_suggestions': groups_suggestions, 'page': paginate(self.request, results.total, page_size=page_size), 'pretty_link': pretty_link, 'q': self.request.params.get('q', ''), 'tag_link': tag_link, 'user_link': user_link, 'username_from_id': username_from_id, # The message that is shown (only) if there's no search results. 'zero_message': _('No annotations matched your search.'), }
def test_overrides_user_term_for_user_search_requests(self, parse, pyramid_request): """ If the query sent to a user search page includes a user, we override it, because otherwise we'll display the union of the results for those two users, which makes no sense. """ parse.return_value = MultiDict({'foo': 'bar', 'user': '******'}) pyramid_request.matched_route.name = 'activity.user_search' pyramid_request.matchdict['username'] = '******' pyramid_request.GET['q'] = 'giraffe' result = extract(pyramid_request, parse=parse) assert result.dict_of_lists() == {'foo': ['bar'], 'user': ['josiah']}
def test_overrides_group_term_for_group_search_requests( self, parse, pyramid_request ): """ If the query sent to a group search page includes a group, we override it, because otherwise we'll display the union of the results for those two groups, which makes no sense. """ parse.return_value = MultiDict({"foo": "bar", "group": "whattheusersent"}) pyramid_request.matched_route.name = "group_read" pyramid_request.matchdict["pubid"] = "abcd1234" pyramid_request.GET["q"] = "giraffe" result = extract(pyramid_request, parse=parse) assert result.dict_of_lists() == {"foo": ["bar"], "group": ["abcd1234"]}
def test_overrides_group_term_for_group_search_requests(self, parse, pyramid_request): """ If the query sent to a group search page includes a group, we override it, because otherwise we'll display the union of the results for those two groups, which makes no sense. """ parse.return_value = MultiDict({'foo': 'bar', 'group': 'whattheusersent'}) pyramid_request.matched_route.name = 'group_read' pyramid_request.matchdict['pubid'] = 'abcd1234' pyramid_request.GET['q'] = 'giraffe' result = extract(pyramid_request, parse=parse) assert result.dict_of_lists() == {'foo': ['bar'], 'group': ['abcd1234']}
def search(self): q = query.extract(self.request) # Check whether a redirect is required. query.check_url(self.request, q) page_size = self.request.params.get("page_size", PAGE_SIZE) try: page_size = int(page_size) except ValueError: page_size = PAGE_SIZE # Fetch results. results = query.execute(self.request, q, page_size=page_size) groups_suggestions = [] if self.request.authenticated_user: for group in self.request.authenticated_user.groups: groups_suggestions.append({"name": group.name, "pubid": group.pubid}) def tag_link(tag): q = parser.unparse({"tag": tag}) return self.request.route_url("activity.search", _query=[("q", q)]) def username_from_id(userid): parts = split_user(userid) return parts["username"] def user_link(userid): username = username_from_id(userid) return self.request.route_url("activity.user_search", username=username) return { "search_results": results, "groups_suggestions": groups_suggestions, "page": paginate(self.request, results.total, page_size=page_size), "pretty_link": pretty_link, "q": self.request.params.get("q", ""), "tag_link": tag_link, "user_link": user_link, "username_from_id": username_from_id, # The message that is shown (only) if there's no search results. "zero_message": _("No annotations matched your search."), }
def search(request): if not request.feature('search_page'): raise httpexceptions.HTTPNotFound() q = query.extract(request) # Check whether a redirect is required query.check_url(request, q) # Fetch results result = query.execute(request, q, page_size=PAGE_SIZE) return { 'total': result.total, 'aggregations': result.aggregations, 'timeframes': result.timeframes, 'page': paginate(request, result.total, page_size=PAGE_SIZE), }
def search(request): if not request.feature('search_page'): raise httpexceptions.HTTPNotFound() q = query.extract(request) if q is None: return {} # Check whether a redirect is required query.check_url(request, q) # Fetch results result = query.execute(request, q) return { 'q': request.params['q'], 'total': result.total, 'aggregations': result.aggregations, 'timeframes': result.timeframes, 'page': paginate(request, result.total), }
def search(request): if not request.feature('search_page'): raise httpexceptions.HTTPNotFound() q = query.extract(request) # Check whether a redirect is required query.check_url(request, q) page_size = request.params.get('page_size', PAGE_SIZE) try: page_size = int(page_size) except ValueError: page_size = PAGE_SIZE # Fetch results result = query.execute(request, q, page_size=page_size) for user in result.aggregations.get('users', []): user['username'] = util.user.split_user(user['user'])['username'] user['userid'] = user['user'] user['faceted_by'] = _faceted_by_user(request, user['username'], q) del user['user'] groups_suggestions = [] if request.authenticated_user: for group in request.authenticated_user.groups: groups_suggestions.append({ 'name': group.name, 'pubid': group.pubid }) return { 'total': result.total, 'aggregations': result.aggregations, 'groups_suggestions': groups_suggestions, 'timeframes': result.timeframes, 'page': paginate(request, result.total, page_size=page_size), }
def search(request): if not request.feature('search_page'): raise httpexceptions.HTTPNotFound() q = query.extract(request) # Check whether a redirect is required query.check_url(request, q) page_size = request.params.get('page_size', PAGE_SIZE) try: page_size = int(page_size) except ValueError: page_size = PAGE_SIZE # Fetch results result = query.execute(request, q, page_size=page_size) return { 'total': result.total, 'aggregations': result.aggregations, 'timeframes': result.timeframes, 'page': paginate(request, result.total, page_size=page_size), }
def search(self): # If the user is just logged-in in 10 seconds, create JWT grant tokens # for each JWT clients. user = self.request.user grant_tokens = [] if user is not None and \ datetime.utcnow() < user.last_login_date + timedelta(seconds=10): clients = self.request.db.query(AuthClient) \ .order_by(AuthClient.name.asc()) \ .all() for client in clients: if client.secret is not None: grant_tokens.append( self._create_grant_token(user.username, client)) q = query.extract(self.request) # Check whether a redirect is required. query.check_url(self.request, q) page_size = self.request.params.get('page_size', PAGE_SIZE) try: page_size = int(page_size) except ValueError: page_size = PAGE_SIZE # Fetch results. results = query.execute(self.request, q, page_size=page_size) groups_suggestions = [] if self.request.user: for group in self.request.user.groups: groups_suggestions.append({ 'name': group.name, 'pubid': group.pubid }) def tag_link(tag): q = parser.unparse({'tag': tag}) return self.request.route_url('activity.search', _query=[('q', q)]) def username_from_id(userid): parts = split_user(userid) return parts['username'] def user_link(userid): username = username_from_id(userid) return self.request.route_url('activity.user_search', username=username) return { 'search_results': results, 'groups_suggestions': groups_suggestions, 'page': paginate(self.request, results.total, page_size=page_size), 'pretty_link': pretty_link, 'q': self.request.params.get('q', ''), 'tag_link': tag_link, 'user_link': user_link, 'username_from_id': username_from_id, # The message that is shown (only) if there's no search results. 'zero_message': _('No annotations matched your search.'), 'grant_tokens': enumerate(grant_tokens), }
def __init__(self, request): self.request = request # Cache a copy of the extracted query params for the child controllers to use if needed. self.parsed_query_params = query.extract(self.request)
def test_returns_none_if_q_not_in_params(self, parse, pyramid_request): result = extract(pyramid_request, parse=parse) assert result is None
def search(self): result = self._check_access_permissions() if result is not None: return result check_slug(self.group, self.request) result = super(GroupSearchController, self).search() result['opts'] = {'search_groupname': self.group.name} # If the group has read access only for members and the user is not in that list # return without extra info. if self.group.readable_by == ReadableBy.members and ( self.request.user not in self.group.members): return result def user_annotation_count(aggregation, userid): for user in aggregation: if user['user'] == userid: return user['count'] return 0 q = query.extract(self.request) members = [] moderators = [] users_aggregation = result['search_results'].aggregations.get( 'users', []) # If the group has members provide a list of member info, # otherwise provide a list of moderator info instead. if self.group.members: members = [{ 'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(self.request, u.username, q) } for u in self.group.members] members = sorted(members, key=lambda k: k['username'].lower()) else: moderators = [] if self.group.creator: # Pass a list of moderators, anticipating that [self.group.creator] # will change to an actual list of moderators at some point. moderators = [{ 'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(self.request, u.username, q) } for u in [self.group.creator]] moderators = sorted(moderators, key=lambda k: k['username'].lower()) group_annotation_count = self.request.find_service( name='annotation_stats').group_annotation_count(self.group.pubid) result['stats'] = { 'annotation_count': group_annotation_count, } result['group'] = { 'created': utc_us_style_date(self.group.created), 'description': self.group.description, 'name': self.group.name, 'pubid': self.group.pubid, 'url': self.request.route_url('group_read', pubid=self.group.pubid, slug=self.group.slug), 'members': members, 'creator': self.group.creator.userid if self.group.creator else None, 'share_subtitle': _('Share group'), 'share_msg': _('Sharing the link lets people view this group:'), } if self.group.type == 'private': result['group']['share_subtitle'] = _('Invite new members') result['group']['share_msg'] = _( 'Sharing the link lets people join this group:') result['group_users_args'] = [ _('Members'), moderators if self.group.type == 'open' else members, result['group']['creator'], ] if self.request.has_permission('admin', self.group): result['group_edit_url'] = self.request.route_url( 'group_edit', pubid=self.group.pubid) result['more_info'] = 'more_info' in self.request.params if not result.get('q'): result['zero_message'] = Markup( _('The group “{name}” has not made any annotations yet.'). format(name=Markup.escape(self.group.name))) result['show_leave_button'] = self.request.user in self.group.members return result
def search(self): result = self._check_access_permissions() if result is not None: return result check_slug(self.group, self.request) result = super(GroupSearchController, self).search() result['opts'] = {'search_groupname': self.group.name} # If the group has read access only for members and the user is not in that list # return without extra info. if self.group.readable_by == ReadableBy.members and (self.request.user not in self.group.members): return result def user_annotation_count(aggregation, userid): for user in aggregation: if user['user'] == userid: return user['count'] return 0 q = query.extract(self.request) members = [] moderators = [] users_aggregation = result['search_results'].aggregations.get('users', []) # If the group has members provide a list of member info, # otherwise provide a list of moderator info instead. if self.group.members: members = [{'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(self.request, u.username, q)} for u in self.group.members] members = sorted(members, key=lambda k: k['username'].lower()) else: moderators = [] if self.group.creator: # Pass a list of moderators, anticipating that [self.group.creator] # will change to an actual list of moderators at some point. moderators = [{'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(self.request, u.username, q)} for u in [self.group.creator]] moderators = sorted(moderators, key=lambda k: k['username'].lower()) group_annotation_count = self.request.find_service(name='annotation_stats').group_annotation_count(self.group.pubid) result['stats'] = { 'annotation_count': group_annotation_count, } result['group'] = { 'created': utc_us_style_date(self.group.created), 'description': self.group.description, 'name': self.group.name, 'pubid': self.group.pubid, 'url': self.request.route_url('group_read', pubid=self.group.pubid, slug=self.group.slug), 'share_subtitle': _('Share group'), 'share_msg': _('Sharing the link lets people view this group:'), 'organization': {'name': self.group.organization.name, 'logo': self._organization_context.logo} } if self.group.type == 'private': result['group']['share_subtitle'] = _('Invite new members') result['group']['share_msg'] = _('Sharing the link lets people join this group:') result['group_users_args'] = [ _('Members'), moderators if self.group.type == 'open' else members, self.group.creator.userid if self.group.creator else None, ] if self.request.has_permission('admin', self.group): result['group_edit_url'] = self.request.route_url( 'group_edit', pubid=self.group.pubid) result['more_info'] = 'more_info' in self.request.params if not result.get('q'): result['zero_message'] = Markup(_( 'The group “{name}” has not made any annotations yet.').format( name=Markup.escape(self.group.name))) result['show_leave_button'] = self.request.user in self.group.members return result
def test_returns_empty_results_when_q_param_is_missing( self, parse, pyramid_request ): result = extract(pyramid_request, parse=parse) assert result == parse.return_value
def test_parses_param_value_with_parser(self, parse, pyramid_request): pyramid_request.GET["q"] = "giraffe" extract(pyramid_request, parse=parse) parse.assert_called_once_with("giraffe")
def search(self): result = self._check_access_permissions() if result is not None: return result check_slug(self.group, self.request) result = super(GroupSearchController, self).search() result['opts'] = {'search_groupname': self.group.name} # If the group has a concept of members (aka joinable_by is not None) # and the user is not in the list of members, return without extra info. if self.group.joinable_by and (self.request.user not in self.group.members): return result def user_annotation_count(aggregation, userid): for user in aggregation: if user['user'] == userid: return user['count'] return 0 q = query.extract(self.request) members = None moderators = None users_aggregation = result['search_results'].aggregations.get('users', []) # If the group has a concept of members provide a list of member info, # otherwise provide a list of moderator info instead. if self.group.joinable_by: members = [{'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(self.request, u.username, q)} for u in self.group.members] members = sorted(members, key=lambda k: k['username'].lower()) else: moderators = [] if self.group.creator: # Pass a list of moderators, anticipating that [self.group.creator] # will change to an actual list of moderators at some point. moderators = [{'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(self.request, u.username, q)} for u in [self.group.creator]] moderators = sorted(moderators, key=lambda k: k['username'].lower()) group_annotation_count = self.request.find_service(name='annotation_stats').group_annotation_count(self.group.pubid) result['stats'] = { 'annotation_count': group_annotation_count, } result['group'] = { 'created': self.group.created.strftime('%B, %Y'), 'description': self.group.description, 'name': self.group.name, 'pubid': self.group.pubid, 'url': self.request.route_url('group_read', pubid=self.group.pubid, slug=self.group.slug), 'members': members, 'moderators': moderators, 'creator': self.group.creator.userid if self.group.creator else None, } if self.request.has_permission('admin', self.group): result['group_edit_url'] = self.request.route_url( 'group_edit', pubid=self.group.pubid) result['more_info'] = 'more_info' in self.request.params if not result.get('q'): result['zero_message'] = Markup(_( 'The group “{name}” has not made any annotations yet.').format( name=Markup.escape(self.group.name))) return result
def test_returns_empty_results_when_q_param_is_missing( self, parse, pyramid_request): result = extract(pyramid_request, parse=parse) assert result == parse.return_value
def test_parses_param_value_with_parser(self, parse, pyramid_request): pyramid_request.GET['q'] = 'giraffe' extract(pyramid_request, parse=parse) parse.assert_called_once_with('giraffe')
def search(self): result = self._check_access_permissions() if result is not None: return result check_slug(self.group, self.request) result = super(GroupSearchController, self).search() result['opts'] = {'search_groupname': self.group.name} if self.request.user not in self.group.members: return result def user_annotation_count(aggregation, userid): for user in aggregation: if user['user'] == userid: return user['count'] return 0 q = query.extract(self.request) users_aggregation = result['search_results'].aggregations.get('users', []) members = [{'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(self.request, u.username, q)} for u in self.group.members] members = sorted(members, key=lambda k: k['username'].lower()) group_annotation_count = self.request.find_service(name='annotation_stats').group_annotation_count(self.group.pubid) result['stats'] = { 'annotation_count': group_annotation_count, } result['group'] = { 'created': self.group.created.strftime('%B, %Y'), 'description': self.group.description, 'name': self.group.name, 'pubid': self.group.pubid, 'url': self.request.route_url('group_read', pubid=self.group.pubid, slug=self.group.slug), 'members': members, } if self.request.has_permission('admin', self.group): result['group_edit_url'] = self.request.route_url( 'group_edit', pubid=self.group.pubid) result['more_info'] = 'more_info' in self.request.params if not result.get('q'): result['zero_message'] = Markup(_( 'The group “{name}” has not made any annotations yet.').format( name=Markup.escape(self.group.name))) return result
def search(self): result = self._check_access_permissions() if result is not None: return result check_slug(self.group, self.request) result = super(GroupSearchController, self).search() result['opts'] = {'search_groupname': self.group.name} if self.request.user not in self.group.members: return result def user_annotation_count(aggregation, userid): for user in aggregation: if user['user'] == userid: return user['count'] return 0 q = query.extract(self.request) users_aggregation = result['search_results'].aggregations.get('users', []) members = [{'username': u.username, 'userid': u.userid, 'count': user_annotation_count(users_aggregation, u.userid), 'faceted_by': _faceted_by_user(self.request, u.username, q)} for u in self.group.members] members = sorted(members, key=lambda k: k['username'].lower()) group_annotation_count = None if self.request.feature('total_shared_annotations'): group_annotation_count = self.request.find_service(name='annotation_stats').group_annotation_count(self.group.pubid) result['stats'] = { 'annotation_count': group_annotation_count, } result['group'] = { 'created': self.group.created.strftime('%B, %Y'), 'description': self.group.description, 'name': self.group.name, 'pubid': self.group.pubid, 'url': self.request.route_url('group_read', pubid=self.group.pubid, slug=self.group.slug), 'members': members, } if self.request.has_permission('admin', self.group): result['group_edit_url'] = self.request.route_url( 'group_edit', pubid=self.group.pubid) result['more_info'] = 'more_info' in self.request.params if not result.get('q'): result['zero_message'] = Markup(_( 'The group “{name}” has not made any annotations yet.').format( name=Markup.escape(self.group.name))) return result