Files
core/resolvers/reader.py

296 lines
9.8 KiB
Python
Raw Normal View History

2023-12-03 01:14:36 +03:00
from sqlalchemy.orm import aliased, joinedload
from sqlalchemy.sql.expression import and_, asc, case, desc, func, nulls_last, select
from starlette.exceptions import HTTPException
2023-10-23 17:47:11 +03:00
from services.auth import login_required
2023-10-10 00:34:51 +03:00
from services.db import local_session
2023-11-24 02:00:28 +03:00
from services.schema import query
2023-12-09 20:12:04 +03:00
from orm.topic import TopicFollower, Topic
2023-01-17 22:07:44 +01:00
from orm.reaction import Reaction, ReactionKind
2023-11-28 14:17:21 +03:00
from orm.shout import Shout, ShoutAuthor, ShoutTopic, ShoutVisibility
2023-12-03 01:14:36 +03:00
from orm.author import AuthorFollower, Author
2023-12-03 01:22:16 +03:00
from services.search import SearchService
2023-11-22 19:38:39 +03:00
from services.viewed import ViewedStorage
2022-11-15 05:36:30 +03:00
2022-11-28 21:29:02 +01:00
def add_stat_columns(q):
2023-01-17 22:07:44 +01:00
aliased_reaction = aliased(Reaction)
2023-12-03 01:14:36 +03:00
2023-01-17 22:07:44 +01:00
q = q.outerjoin(aliased_reaction).add_columns(
2023-10-05 21:46:18 +03:00
func.sum(aliased_reaction.id).label("reacted_stat"),
2023-12-02 23:38:28 +03:00
func.sum(case((aliased_reaction.kind == ReactionKind.COMMENT.value, 1), else_=0)).label("commented_stat"),
2023-01-17 22:07:44 +01:00
func.sum(
case(
2023-11-30 10:38:41 +03:00
(aliased_reaction.kind == ReactionKind.AGREE.value, 1),
(aliased_reaction.kind == ReactionKind.DISAGREE.value, -1),
(aliased_reaction.kind == ReactionKind.PROOF.value, 1),
(aliased_reaction.kind == ReactionKind.DISPROOF.value, -1),
(aliased_reaction.kind == ReactionKind.ACCEPT.value, 1),
(aliased_reaction.kind == ReactionKind.REJECT.value, -1),
(aliased_reaction.kind == ReactionKind.LIKE.value, 1),
(aliased_reaction.kind == ReactionKind.DISLIKE.value, -1),
2023-12-03 01:14:36 +03:00
(aliased_reaction.reply_to.is_not(None), 0),
2023-10-05 21:46:18 +03:00
else_=0,
2023-01-17 22:07:44 +01:00
)
2023-10-05 21:46:18 +03:00
).label("rating_stat"),
func.max(
case(
2023-12-03 01:14:36 +03:00
(aliased_reaction.kind != ReactionKind.COMMENT.value, None),
2023-11-03 13:10:22 +03:00
else_=aliased_reaction.created_at,
2023-10-05 21:46:18 +03:00
)
).label("last_comment"),
)
2022-11-25 19:31:53 +01:00
2023-01-17 22:07:44 +01:00
return q
2023-12-03 01:14:36 +03:00
def apply_filters(q, filters, author_id=None): # noqa: C901
2023-10-23 17:47:11 +03:00
if filters.get("reacted") and author_id:
2023-11-03 13:10:22 +03:00
q.join(Reaction, Reaction.created_by == author_id)
2022-11-28 21:29:02 +01:00
2023-11-29 15:11:05 +03:00
by_published = filters.get("published")
if by_published:
2023-11-30 10:38:41 +03:00
q = q.filter(Shout.visibility == ShoutVisibility.PUBLIC.value)
2023-11-29 12:29:09 +03:00
by_layouts = filters.get("layouts")
if by_layouts:
q = q.filter(Shout.layout.in_(by_layouts))
by_author = filters.get("author")
if by_author:
q = q.filter(Shout.authors.any(slug=by_author))
by_topic = filters.get("topic")
if by_topic:
q = q.filter(Shout.topics.any(slug=by_topic))
by_after = filters.get("after")
if by_after:
ts = int(by_after)
2023-11-29 10:23:41 +03:00
q = q.filter(Shout.created_at > ts)
2022-11-21 11:13:57 +03:00
2022-11-25 19:31:53 +01:00
return q
2023-05-08 19:06:01 +02:00
2023-11-28 10:53:48 +03:00
@query.field("get_shout")
async def get_shout(_, _info, slug=None, shout_id=None):
2022-11-18 03:19:10 +01:00
with local_session() as session:
q = select(Shout).options(
2022-11-23 22:53:53 +01:00
joinedload(Shout.authors),
joinedload(Shout.topics),
)
2023-12-03 01:14:36 +03:00
2022-11-25 19:31:53 +01:00
q = add_stat_columns(q)
2023-05-08 19:06:01 +02:00
if slug is not None:
2023-10-05 21:46:18 +03:00
q = q.filter(Shout.slug == slug)
2023-05-08 19:06:01 +02:00
if shout_id is not None:
2023-10-05 21:46:18 +03:00
q = q.filter(Shout.id == shout_id)
2023-05-08 19:06:01 +02:00
2023-11-03 13:10:22 +03:00
q = q.filter(Shout.deleted_at.is_(None)).group_by(Shout.id)
2023-01-17 22:07:44 +01:00
2023-10-23 17:47:11 +03:00
try:
2023-12-03 01:14:36 +03:00
[shout, reacted_stat, commented_stat, rating_stat, _last_comment] = session.execute(q).first()
2023-11-27 20:35:26 +03:00
2023-12-03 01:14:36 +03:00
shout.stat = {
2023-12-03 01:42:16 +03:00
"viewed": await ViewedStorage.get_shout(shout.slug),
2023-12-03 01:14:36 +03:00
"reacted": reacted_stat,
"commented": commented_stat,
"rating": rating_stat,
}
2023-11-29 14:24:59 +03:00
2023-12-03 01:14:36 +03:00
for author_caption in session.query(ShoutAuthor).join(Shout).where(Shout.slug == slug):
for author in shout.authors:
2023-12-03 01:42:16 +03:00
if author.id == author_caption.author:
2023-12-03 01:14:36 +03:00
author.caption = author_caption.caption
2023-12-09 21:15:30 +03:00
main_topic = (
2023-12-09 21:21:38 +03:00
session.query(Topic.slug)
.join(ShoutTopic, and_(ShoutTopic.topic == Topic.id, ShoutTopic.shout == shout.id, ShoutTopic.main == True))
2023-12-09 21:15:30 +03:00
.first()
)
if main_topic:
shout.main_topic = main_topic[0]
2023-12-03 01:14:36 +03:00
return shout
except Exception:
2023-12-03 01:42:16 +03:00
raise HTTPException(status_code=404, detail=f"shout {slug or shout_id} not found")
2022-11-23 22:53:53 +01:00
2023-11-28 10:53:48 +03:00
@query.field("load_shouts_by")
2023-12-03 01:14:36 +03:00
async def load_shouts_by(_, _info, options):
2022-11-15 05:36:30 +03:00
"""
:param options: {
filters: {
2023-11-28 14:17:21 +03:00
layouts: ['audio', 'video', ..],
2023-11-29 12:33:33 +03:00
reacted: True,
2023-11-29 15:11:05 +03:00
published: True, // filter published-only
author: 'discours',
topic: 'culture',
2023-11-29 10:23:41 +03:00
after: 1234567 // unixtime
}
offset: 0
limit: 50
2023-11-03 13:10:22 +03:00
order_by: 'created_at' | 'commented' | 'reacted' | 'rating'
2022-11-21 11:13:57 +03:00
order_by_desc: true
2022-11-15 05:36:30 +03:00
}
:return: Shout[]
"""
2023-12-09 19:22:47 +03:00
2023-12-03 01:14:36 +03:00
# base
2023-10-05 21:46:18 +03:00
q = (
2023-12-03 01:14:36 +03:00
select(Shout)
2023-10-05 21:46:18 +03:00
.options(
2023-12-03 01:14:36 +03:00
joinedload(Shout.authors),
2023-10-05 21:46:18 +03:00
joinedload(Shout.topics),
2023-10-01 19:27:08 +02:00
)
2023-12-03 01:14:36 +03:00
.where(and_(Shout.deleted_at.is_(None), Shout.layout.is_not(None)))
2022-11-15 05:36:30 +03:00
)
2022-11-25 19:31:53 +01:00
2023-12-03 01:14:36 +03:00
# stats
2022-11-25 19:31:53 +01:00
q = add_stat_columns(q)
2023-12-02 09:25:08 +03:00
# filters
2023-11-29 12:29:09 +03:00
q = apply_filters(q, options.get("filters", {}))
2022-11-25 19:31:53 +01:00
2023-12-02 09:25:08 +03:00
# group
2023-12-03 01:14:36 +03:00
q = q.group_by(Shout.id)
2023-12-02 09:25:08 +03:00
# order
2023-11-03 13:10:22 +03:00
order_by = options.get("order_by", Shout.published_at)
2023-11-23 23:30:00 +03:00
query_order_by = desc(order_by) if options.get("order_by_desc", True) else asc(order_by)
2023-12-02 09:25:08 +03:00
q = q.order_by(nulls_last(query_order_by))
# limit offset
2022-11-21 07:47:59 +03:00
offset = options.get("offset", 0)
limit = options.get("limit", 10)
2023-12-02 09:25:08 +03:00
q = q.limit(limit).offset(offset)
2023-07-05 16:08:17 +02:00
shouts = []
with local_session() as session:
2023-12-02 23:38:28 +03:00
for [shout, reacted_stat, commented_stat, rating_stat, _last_comment] in session.execute(q).unique():
2023-12-09 21:15:30 +03:00
main_topic = (
2023-12-09 21:21:38 +03:00
session.query(Topic.slug)
.join(ShoutTopic, and_(ShoutTopic.topic == Topic.id, ShoutTopic.shout == shout.id, ShoutTopic.main == True))
2023-12-09 21:15:30 +03:00
.first()
)
if main_topic:
shout.main_topic = main_topic[0]
2022-11-25 19:31:53 +01:00
shout.stat = {
2023-12-03 01:42:16 +03:00
"viewed": await ViewedStorage.get_shout(shout.slug),
2022-11-25 19:31:53 +01:00
"reacted": reacted_stat,
"commented": commented_stat,
2023-10-05 21:46:18 +03:00
"rating": rating_stat,
2022-11-25 19:31:53 +01:00
}
2023-12-02 23:17:26 +03:00
shouts.append(shout)
2023-01-17 22:07:44 +01:00
return shouts
2023-02-06 15:27:23 +01:00
2023-05-08 19:06:01 +02:00
2023-12-03 01:14:36 +03:00
@query.field("load_shouts_drafts")
2023-02-06 15:27:23 +01:00
@login_required
2023-12-03 01:14:36 +03:00
async def load_shouts_drafts(_, info):
user_id = info.context["user_id"]
q = (
select(Shout)
.options(
joinedload(Shout.authors),
joinedload(Shout.topics),
)
.filter(Shout.deleted_at.is_(None))
2023-12-03 01:22:16 +03:00
.filter(Shout.visibility == ShoutVisibility.AUTHORS.value)
2023-12-03 01:14:36 +03:00
)
shouts = []
with local_session() as session:
reader = session.query(Author).filter(Author.user == user_id).first()
if reader:
q = q.filter(Shout.created_by == reader.id)
q = q.group_by(Shout.id)
for [shout] in session.execute(q).unique():
2023-12-09 21:15:30 +03:00
main_topic = (
2023-12-09 21:21:38 +03:00
session.query(Topic.slug)
.join(ShoutTopic, and_(ShoutTopic.topic == Topic.id, ShoutTopic.shout == shout.id, ShoutTopic.main == True))
2023-12-09 21:15:30 +03:00
.first()
)
if main_topic:
shout.main_topic = main_topic[0]
2023-12-03 01:14:36 +03:00
shouts.append(shout)
return shouts
2023-11-28 10:53:48 +03:00
@query.field("load_shouts_feed")
2023-12-03 01:14:36 +03:00
@login_required
2023-11-28 10:53:48 +03:00
async def load_shouts_feed(_, info, options):
2023-11-24 02:00:28 +03:00
user_id = info.context["user_id"]
2023-12-03 01:14:36 +03:00
2023-10-23 17:47:11 +03:00
with local_session() as session:
2023-12-03 01:14:36 +03:00
reader = session.query(Author).filter(Author.user == user_id).first()
if reader:
reader_followed_authors = select(AuthorFollower.author).where(AuthorFollower.follower == reader.id)
reader_followed_topics = select(TopicFollower.topic).where(TopicFollower.follower == reader.id)
2023-11-27 21:18:52 +03:00
subquery = (
select(Shout.id)
.where(Shout.id == ShoutAuthor.shout)
.where(Shout.id == ShoutTopic.shout)
2023-11-28 10:53:48 +03:00
.where(
2023-12-03 01:14:36 +03:00
(ShoutAuthor.user.in_(reader_followed_authors))
| (ShoutTopic.topic.in_(reader_followed_topics))
2023-11-28 10:53:48 +03:00
)
2023-10-23 17:47:11 +03:00
)
2023-11-27 21:18:52 +03:00
q = (
select(Shout)
.options(
joinedload(Shout.authors),
joinedload(Shout.topics),
)
.where(
2023-12-03 01:14:36 +03:00
and_(Shout.published_at.is_not(None), Shout.deleted_at.is_(None), Shout.id.in_(subquery))
2023-10-23 17:47:11 +03:00
)
2023-10-05 21:46:18 +03:00
)
2023-02-06 15:27:23 +01:00
2023-11-27 21:18:52 +03:00
q = add_stat_columns(q)
2023-12-03 01:14:36 +03:00
q = apply_filters(q, options.get("filters", {}), reader.id)
2023-02-16 13:08:55 +03:00
2023-11-27 21:18:52 +03:00
order_by = options.get("order_by", Shout.published_at)
2023-02-16 13:08:55 +03:00
2023-11-27 21:18:52 +03:00
query_order_by = desc(order_by) if options.get("order_by_desc", True) else asc(order_by)
offset = options.get("offset", 0)
limit = options.get("limit", 10)
2023-10-23 17:47:11 +03:00
2023-11-27 21:18:52 +03:00
q = q.group_by(Shout.id).order_by(nulls_last(query_order_by)).limit(limit).offset(offset)
2023-02-16 13:08:55 +03:00
2023-12-03 01:14:36 +03:00
# print(q.compile(compile_kwargs={"literal_binds": True}))
2023-11-27 21:18:52 +03:00
shouts = []
2023-12-02 23:44:36 +03:00
for [shout, reacted_stat, commented_stat, rating_stat, _last_comment] in session.execute(q).unique():
2023-12-09 21:15:30 +03:00
main_topic = (
2023-12-09 21:21:38 +03:00
session.query(Topic.slug)
.join(ShoutTopic, and_(ShoutTopic.topic == Topic.id, ShoutTopic.shout == shout.id, ShoutTopic.main == True))
2023-12-09 21:15:30 +03:00
.first()
)
if main_topic:
shout.main_topic = main_topic[0]
2023-11-27 21:18:52 +03:00
shout.stat = {
2023-12-03 01:42:16 +03:00
"viewed": await ViewedStorage.get_shout(shout.slug),
2023-11-27 21:18:52 +03:00
"reacted": reacted_stat,
"commented": commented_stat,
"rating": rating_stat,
}
shouts.append(shout)
2023-12-02 23:44:36 +03:00
2023-12-03 01:14:36 +03:00
return shouts
2023-12-03 01:22:16 +03:00
@query.field("load_shouts_search")
async def load_shouts_search(_, _info, text, limit=50, offset=0):
if text and len(text) > 2:
return SearchService.search(text, limit, offset)
else:
return []