def search(self):
result = super(UserSearchController, self).search()
result['opts'] = {'search_username': self.user.username}
result['more_info'] = 'more_info' in self.request.params
def domain(user):
if not user.uri:
return None
return urlparse.urlparse(user.uri).netloc
user_annotation_counts = self.request.find_service(
name='annotation_stats').user_annotation_counts(self.user.userid)
annotation_count = user_annotation_counts['public']
if self.request.authenticated_userid == self.user.userid:
annotation_count = user_annotation_counts['total']
result['stats'] = {
'annotation_count': annotation_count,
}
result['user'] = {
'name': self.user.display_name or self.user.username,
'description': self.user.description,
'registered_date': utc_us_style_date(self.user.registered_date),
'location': self.user.location,
'uri': self.user.uri,
'domain': domain(self.user),
'orcid': self.user.orcid,
}
if self.request.user == self.user:
result['user']['edit_url'] = self.request.route_url(
'account_profile')
if not result.get('q'):
if self.request.user == self.user:
# Tell the template that it should show "How to get started".
result['zero_message'] = '__SHOW_GETTING_STARTED__'
else:
result['zero_message'] = _(
"{name} has not made any annotations yet.".format(
name=result['user']['name']))
return result
def search(self):
result = super(UserSearchController, self).search()
result['opts'] = {'search_username': self.user.username}
result['more_info'] = 'more_info' in self.request.params
def domain(user):
if not user.uri:
return None
return urlparse.urlparse(user.uri).netloc
user_annotation_counts = self.request.find_service(name='annotation_stats').user_annotation_counts(self.user.userid)
annotation_count = user_annotation_counts['public']
if self.request.authenticated_userid == self.user.userid:
annotation_count = user_annotation_counts['total']
result['stats'] = {
'annotation_count': annotation_count,
}
result['user'] = {
'name': self.user.display_name or self.user.username,
'description': self.user.description,
'registered_date': utc_us_style_date(self.user.registered_date),
'location': self.user.location,
'uri': self.user.uri,
'domain': domain(self.user),
'orcid': self.user.orcid,
}
if self.request.user == self.user:
result['user']['edit_url'] = self.request.route_url(
'account_profile')
if not result.get('q'):
if self.request.user == self.user:
# Tell the template that it should show "How to get started".
result['zero_message'] = '__SHOW_GETTING_STARTED__'
else:
result['zero_message'] = _(
"{name} has not made any annotations yet.".format(
name=result['user']['name']))
return result
def search(self):
result = super().search()
result["opts"] = {"search_username": self.user.username}
result["more_info"] = "more_info" in self.request.params
def domain(user):
if not user.uri:
return None
return urlparse(user.uri).netloc
annotation_count = self._get_total_user_annotations(
result, self.request)
result["stats"] = {"annotation_count": annotation_count}
result["user"] = {
"name": self.user.display_name or self.user.username,
"description": self.user.description,
"registered_date": utc_us_style_date(self.user.registered_date),
"location": self.user.location,
"uri": self.user.uri,
"domain": domain(self.user),
"orcid": self.user.orcid,
}
if self.request.user == self.user:
result["user"]["edit_url"] = self.request.route_url(
"account_profile")
if not result.get("q"):
if self.request.user == self.user:
# Tell the template that it should show "How to get started".
result["zero_message"] = "__SHOW_GETTING_STARTED__"
else:
result["zero_message"] = _(
f"{result['user']['name']} has not made any annotations yet."
)
return result
def search(self):
result = super(UserSearchController, self).search()
result["opts"] = {"search_username": self.user.username}
result["more_info"] = "more_info" in self.request.params
def domain(user):
if not user.uri:
return None
return urlparse.urlparse(user.uri).netloc
annotation_count = self._get_total_user_annotations(result, self.request)
result["stats"] = {"annotation_count": annotation_count}
result["user"] = {
"name": self.user.display_name or self.user.username,
"description": self.user.description,
"registered_date": utc_us_style_date(self.user.registered_date),
"location": self.user.location,
"uri": self.user.uri,
"domain": domain(self.user),
"orcid": self.user.orcid,
}
if self.request.user == self.user:
result["user"]["edit_url"] = self.request.route_url("account_profile")
if not result.get("q"):
if self.request.user == self.user:
# Tell the template that it should show "How to get started".
result["zero_message"] = "__SHOW_GETTING_STARTED__"
else:
result["zero_message"] = _(
"{name} has not made any annotations yet.".format(
name=result["user"]["name"]
)
)
return result
def test_utc_us_style_date():
t = datetime.datetime(2016, 2, 4)
assert utc_us_style_date(t) == "February 4, 2016"
def search(self): # pylint: disable=too-complex
result = self._check_access_permissions()
if result is not None:
return result
check_slug(self.group, self.request)
result = super().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
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,
self.parsed_query_params),
} 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,
self.parsed_query_params),
} for u in [self.group.creator]]
moderators = sorted(moderators,
key=lambda k: k["username"].lower())
group_annotation_count = self._get_total_annotations_in_group(
result, self.request)
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:"),
}
if self.group.organization:
result["group"]["organization"] = OrganizationJSONPresenter(
self.group.organization, self.request).asdict(summary=True)
else:
result["group"]["organization"] = None
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(Permission.Group.EDIT,
context=self.context):
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_utc_us_style_date():
t = datetime.datetime(2016, 2, 4)
assert utc_us_style_date(t) == "February 4, 2016"
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
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,
self.parsed_query_params)
} 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,
self.parsed_query_params)
} for u in [self.group.creator]]
moderators = sorted(moderators,
key=lambda k: k['username'].lower())
group_annotation_count = self._get_total_annotations_in_group(
result, self.request)
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:')
}
if self.group.organization:
result['group']['organization'] = {
'name': self.group.organization.name,
'logo': self._organization_context.logo
}
else:
result['group']['organization'] = None
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 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 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
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, self.parsed_query_params
),
}
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, self.parsed_query_params
),
}
for u in [self.group.creator]
]
moderators = sorted(moderators, key=lambda k: k["username"].lower())
group_annotation_count = self._get_total_annotations_in_group(
result, self.request
)
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:"),
}
if self.group.organization:
result["group"]["organization"] = {
"name": self.group.organization.name,
"logo": self._organization_context.logo,
}
else:
result["group"]["organization"] = None
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 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':
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,
'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
