def _search_pages(session, search_query, title_only, next_rank, page_size,
user_id, include_places, include_guides):
rank, snippet, do_search_query = _gen_search_elements(
search_query,
title_only,
next_rank,
page_size,
[PageVersion.title],
[PageVersion.address],
[],
[PageVersion.content],
)
if not include_places and not include_guides:
return []
latest_pages = (session.query(func.max(PageVersion.id).label("id")).join(
Page, Page.id == PageVersion.page_id).filter(
or_(
(Page.type == PageType.place) if include_places else False,
(Page.type == PageType.guide) if include_guides else False,
)).group_by(PageVersion.page_id).subquery())
pages = do_search_query(
session.query(Page, rank,
snippet).join(PageVersion,
PageVersion.page_id == Page.id).join(
latest_pages,
latest_pages.c.id == PageVersion.id))
return [
search_pb2.Result(
rank=rank,
place=page_to_pb(page, user_id)
if page.type == PageType.place else None,
guide=page_to_pb(page, user_id)
if page.type == PageType.guide else None,
snippet=snippet,
) for page, rank, snippet in pages
]
def group_to_pb(cluster: Cluster, context):
with session_scope() as session:
can_moderate = can_moderate_node(session, context.user_id, cluster.parent_node_id)
member_count = session.execute(
select(func.count())
.select_from(ClusterSubscription)
.where_users_column_visible(context, ClusterSubscription.user_id)
.where(ClusterSubscription.cluster_id == cluster.id)
).scalar_one()
is_member = (
session.execute(
select(ClusterSubscription)
.where(ClusterSubscription.user_id == context.user_id)
.where(ClusterSubscription.cluster_id == cluster.id)
).scalar_one_or_none()
is not None
)
admin_count = session.execute(
select(func.count())
.select_from(ClusterSubscription)
.where_users_column_visible(context, ClusterSubscription.user_id)
.where(ClusterSubscription.cluster_id == cluster.id)
.where(ClusterSubscription.role == ClusterRole.admin)
).scalar_one()
is_admin = (
session.execute(
select(ClusterSubscription)
.where(ClusterSubscription.user_id == context.user_id)
.where(ClusterSubscription.cluster_id == cluster.id)
.where(ClusterSubscription.role == ClusterRole.admin)
).scalar_one_or_none()
is not None
)
return groups_pb2.Group(
group_id=cluster.id,
name=cluster.name,
slug=cluster.slug,
description=cluster.description,
created=Timestamp_from_datetime(cluster.created),
parents=_parents_to_pb(cluster),
main_page=page_to_pb(cluster.main_page, context),
member=is_member,
admin=is_admin,
member_count=member_count,
admin_count=admin_count,
can_moderate=can_moderate,
)
def community_to_pb(node: Node, context):
with session_scope() as session:
can_moderate = can_moderate_node(session, context.user_id, node.id)
member_count = session.execute(
select(func.count())
.select_from(ClusterSubscription)
.where_users_column_visible(context, ClusterSubscription.user_id)
.where(ClusterSubscription.cluster_id == node.official_cluster.id)
).scalar_one()
is_member = (
session.execute(
select(ClusterSubscription)
.where(ClusterSubscription.user_id == context.user_id)
.where(ClusterSubscription.cluster_id == node.official_cluster.id)
).scalar_one_or_none()
is not None
)
admin_count = session.execute(
select(func.count())
.select_from(ClusterSubscription)
.where_users_column_visible(context, ClusterSubscription.user_id)
.where(ClusterSubscription.cluster_id == node.official_cluster.id)
.where(ClusterSubscription.role == ClusterRole.admin)
).scalar_one()
is_admin = (
session.execute(
select(ClusterSubscription)
.where(ClusterSubscription.user_id == context.user_id)
.where(ClusterSubscription.cluster_id == node.official_cluster.id)
.where(ClusterSubscription.role == ClusterRole.admin)
).scalar_one_or_none()
is not None
)
return communities_pb2.Community(
community_id=node.id,
name=node.official_cluster.name,
slug=node.official_cluster.slug,
description=node.official_cluster.description,
created=Timestamp_from_datetime(node.created),
parents=_parents_to_pb(node.id),
member=is_member,
admin=is_admin,
member_count=member_count,
admin_count=admin_count,
main_page=page_to_pb(node.official_cluster.main_page, context),
can_moderate=can_moderate,
)
def ListGuides(self, request, context):
with session_scope() as session:
page_size = min(MAX_PAGINATION_LENGTH, request.page_size or MAX_PAGINATION_LENGTH)
next_page_id = int(request.page_token) if request.page_token else 0
node = session.execute(select(Node).where(Node.id == request.community_id)).scalar_one_or_none()
if not node:
context.abort(grpc.StatusCode.NOT_FOUND, errors.COMMUNITY_NOT_FOUND)
guides = (
node.official_cluster.owned_pages.where(Page.type == PageType.guide)
.where(Page.id >= next_page_id)
.order_by(Page.id)
.limit(page_size + 1)
.all()
)
return communities_pb2.ListGuidesRes(
guides=[page_to_pb(page, context) for page in guides[:page_size]],
next_page_token=str(guides[-1].id) if len(guides) > page_size else None,
)
def community_to_pb(node: Node, user_id):
with session_scope() as session:
can_moderate = can_moderate_node(session, user_id, node.id)
return communities_pb2.Community(
community_id=node.id,
name=node.official_cluster.name,
slug=node.official_cluster.slug,
description=node.official_cluster.description,
created=Timestamp_from_datetime(node.created),
parents=_parents_to_pb(node.id, user_id),
main_page=page_to_pb(node.official_cluster.main_page, user_id),
member=node.official_cluster.members.filter(
User.id == user_id).one_or_none() is not None,
admin=node.official_cluster.admins.filter(
User.id == user_id).one_or_none() is not None,
member_count=node.official_cluster.members.count(),
admin_count=node.official_cluster.admins.count(),
can_moderate=can_moderate,
)
def ListPlaces(self, request, context):
with session_scope() as session:
page_size = min(MAX_PAGINATION_LENGTH, request.page_size or MAX_PAGINATION_LENGTH)
next_page_id = int(request.page_token) if request.page_token else 0
cluster = session.execute(
select(Cluster).where(~Cluster.is_official_cluster).where(Cluster.id == request.group_id)
).scalar_one_or_none()
if not cluster:
context.abort(grpc.StatusCode.NOT_FOUND, errors.GROUP_NOT_FOUND)
places = (
cluster.owned_pages.where(Page.type == PageType.place)
.where(Page.id >= next_page_id)
.order_by(Page.id)
.limit(page_size + 1)
.all()
)
return groups_pb2.ListPlacesRes(
places=[page_to_pb(page, context) for page in places[:page_size]],
next_page_token=str(places[-1].id) if len(places) > page_size else None,
)
def group_to_pb(cluster: Cluster, user_id):
with session_scope() as session:
can_moderate = can_moderate_node(session, user_id,
cluster.parent_node_id)
return groups_pb2.Group(
group_id=cluster.id,
name=cluster.name,
slug=cluster.slug,
description=cluster.description,
created=Timestamp_from_datetime(cluster.created),
parents=_parents_to_pb(cluster, user_id),
main_page=page_to_pb(cluster.main_page, user_id),
member=cluster.members.filter(User.id == user_id).one_or_none()
is not None,
admin=cluster.admins.filter(User.id == user_id).one_or_none()
is not None,
member_count=cluster.members.count(),
admin_count=cluster.admins.count(),
can_moderate=can_moderate,
)
def ListGuides(self, request, context):
with session_scope() as session:
page_size = min(MAX_PAGINATION_LENGTH, request.page_size
or MAX_PAGINATION_LENGTH)
next_page_id = int(request.page_token) if request.page_token else 0
cluster = (session.query(Cluster).filter(
~Cluster.is_official_cluster).filter(
Cluster.id == request.group_id).one_or_none())
if not cluster:
context.abort(grpc.StatusCode.NOT_FOUND,
errors.GROUP_NOT_FOUND)
guides = (cluster.owned_pages.filter(
Page.type == PageType.guide).filter(
Page.id >= next_page_id).order_by(
Page.id).limit(page_size + 1).all())
return groups_pb2.ListGuidesRes(
guides=[
page_to_pb(page, context.user_id)
for page in guides[:page_size]
],
next_page_token=str(guides[-1].id)
if len(guides) > page_size else None,
)
