162 lines
4.8 KiB
Python
162 lines
4.8 KiB
Python
from orm.collection import ShoutCollection
|
|
from orm.shout import Shout, ShoutAuthor, ShoutTopic
|
|
from orm.topic import Topic
|
|
from base.orm import local_session
|
|
from base.resolvers import mutation, query
|
|
from services.zine.shoutscache import ShoutsCache
|
|
from services.stat.viewed import ViewedStorage
|
|
from resolvers.profile import author_follow, author_unfollow
|
|
from resolvers.topics import topic_follow, topic_unfollow
|
|
from resolvers.community import community_follow, community_unfollow
|
|
from resolvers.reactions import reactions_follow, reactions_unfollow
|
|
from auth.authenticate import login_required
|
|
from sqlalchemy import select, desc, and_
|
|
from sqlalchemy.orm import selectinload, joinedload
|
|
|
|
|
|
@query.field("topViewed")
|
|
async def top_viewed(_, info, page, size):
|
|
async with ShoutsCache.lock:
|
|
return ShoutsCache.top_viewed[(page - 1) * size : page * size]
|
|
|
|
@query.field("topMonth")
|
|
async def top_month(_, info, page, size):
|
|
async with ShoutsCache.lock:
|
|
return ShoutsCache.top_month[(page - 1) * size : page * size]
|
|
|
|
@query.field("topOverall")
|
|
async def top_overall(_, info, page, size):
|
|
async with ShoutsCache.lock:
|
|
return ShoutsCache.top_overall[(page - 1) * size : page * size]
|
|
|
|
@query.field("recentPublished")
|
|
async def recent_published(_, info, page, size):
|
|
async with ShoutsCache.lock:
|
|
return ShoutsCache.recent_published[(page - 1) * size : page * size]
|
|
|
|
@query.field("recentAll")
|
|
async def recent_all(_, info, page, size):
|
|
async with ShoutsCache.lock:
|
|
return ShoutsCache.recent_all[(page - 1) * size : page * size]
|
|
|
|
@query.field("recentReacted")
|
|
async def recent_reacted(_, info, page, size):
|
|
async with ShoutsCache.lock:
|
|
return ShoutsCache.recent_reacted[(page - 1) * size : page * size]
|
|
|
|
@mutation.field("viewShout")
|
|
async def view_shout(_, info, slug):
|
|
await ViewedStorage.inc_shout(slug)
|
|
return {"error" : ""}
|
|
|
|
@query.field("getShoutBySlug")
|
|
async def get_shout_by_slug(_, info, slug):
|
|
shout = None
|
|
# FIXME: append captions anyhow
|
|
with local_session() as session:
|
|
shout = session.query(Shout, ShoutAuthor.caption.label("author_caption")).\
|
|
options([
|
|
selectinload(Shout.topics),
|
|
selectinload(Shout.reactions),
|
|
joinedload(Shout.authors),
|
|
selectinload(ShoutAuthor.caption)
|
|
]).\
|
|
join(ShoutAuthor.shout == slug ).\
|
|
filter(Shout.slug == slug).first()
|
|
|
|
if not shout:
|
|
print(f"[resolvers.zine] error: shout with slug {slug} not exist")
|
|
return {"error" : "shout not found"}
|
|
|
|
return shout
|
|
|
|
@query.field("shoutsByTopics")
|
|
async def shouts_by_topics(_, info, slugs, page, size):
|
|
page = page - 1
|
|
with local_session() as session:
|
|
shouts = session.query(Shout).\
|
|
join(ShoutTopic).\
|
|
where(and_(ShoutTopic.topic.in_(slugs), Shout.publishedAt != None)).\
|
|
order_by(desc(Shout.publishedAt)).\
|
|
limit(size).\
|
|
offset(page * size)
|
|
return shouts
|
|
|
|
@query.field("shoutsByCollection")
|
|
async def shouts_by_topics(_, info, collection, page, size):
|
|
page = page - 1
|
|
with local_session() as session:
|
|
shouts = session.query(Shout).\
|
|
join(ShoutCollection, ShoutCollection.collection == collection).\
|
|
where(and_(ShoutCollection.shout == Shout.slug, Shout.publishedAt != None)).\
|
|
order_by(desc(Shout.publishedAt)).\
|
|
limit(size).\
|
|
offset(page * size)
|
|
return shouts
|
|
|
|
@query.field("shoutsByAuthors")
|
|
async def shouts_by_authors(_, info, slugs, page, size):
|
|
page = page - 1
|
|
with local_session() as session:
|
|
|
|
shouts = session.query(Shout).\
|
|
join(ShoutAuthor).\
|
|
where(and_(ShoutAuthor.user.in_(slugs), Shout.publishedAt != None)).\
|
|
order_by(desc(Shout.publishedAt)).\
|
|
limit(size).\
|
|
offset(page * size)
|
|
return shouts
|
|
|
|
@query.field("shoutsByCommunities")
|
|
async def shouts_by_communities(_, info, slugs, page, size):
|
|
page = page - 1
|
|
with local_session() as session:
|
|
#TODO fix postgres high load
|
|
shouts = session.query(Shout).distinct().\
|
|
join(ShoutTopic).\
|
|
where(and_(Shout.publishedAt != None,\
|
|
ShoutTopic.topic.in_(\
|
|
select(Topic.slug).where(Topic.community.in_(slugs))\
|
|
))).\
|
|
order_by(desc(Shout.publishedAt)).\
|
|
limit(size).\
|
|
offset(page * size)
|
|
return shouts
|
|
|
|
@mutation.field("follow")
|
|
@login_required
|
|
async def follow(_, info, what, slug):
|
|
user = info.context["request"].user
|
|
try:
|
|
if what == "AUTHOR":
|
|
author_follow(user, slug)
|
|
elif what == "TOPIC":
|
|
topic_follow(user, slug)
|
|
elif what == "COMMUNITY":
|
|
community_follow(user, slug)
|
|
elif what == "REACTIONS":
|
|
reactions_follow(user, slug)
|
|
except Exception as e:
|
|
return {"error" : str(e)}
|
|
|
|
return {}
|
|
|
|
@mutation.field("unfollow")
|
|
@login_required
|
|
async def unfollow(_, info, what, slug):
|
|
user = info.context["request"].user
|
|
|
|
try:
|
|
if what == "AUTHOR":
|
|
author_unfollow(user, slug)
|
|
elif what == "TOPIC":
|
|
topic_unfollow(user, slug)
|
|
elif what == "COMMUNITY":
|
|
community_unfollow(user, slug)
|
|
elif what == "REACTIONS":
|
|
reactions_unfollow(user, slug)
|
|
except Exception as e:
|
|
return {"error" : str(e)}
|
|
|
|
return {}
|