working-on

services/zine/reactions.py

@@ -0,0 +1,159 @@
+import asyncio
+from sqlalchemy import and_, desc, func
+from sqlalchemy.orm import joinedload
+from base.orm import local_session
+from orm.reaction import Reaction, ReactionKind
+from orm.topic import ShoutTopic
+
+
+def kind_to_rate(kind) -> int:
+	if kind in [
+		ReactionKind.AGREE,
+		ReactionKind.LIKE,
+		ReactionKind.PROOF,
+		ReactionKind.ACCEPT
+	]: return 1
+	elif kind in [
+		ReactionKind.DISAGREE,
+		ReactionKind.DISLIKE,
+		ReactionKind.DISPROOF,
+		ReactionKind.REJECT
+	]: return -1
+	else: return 0
+
+class ReactionsStorage:
+	limit = 200
+	reactions = []
+	rating_by_shout = {}
+	reactions_by_shout = {}
+	reactions_by_topic = {}  # TODO: get sum reactions for all shouts in topic
+	reactions_by_author = {}
+	lock = asyncio.Lock()
+	period = 3*60  # 3 mins
+
+	@staticmethod
+	async def prepare_all(session):
+		stmt = session.query(Reaction).\
+			filter(Reaction.deletedAt == None).\
+			order_by(desc("createdAt")).\
+			limit(ReactionsStorage.limit)
+		reactions = []
+		for row in session.execute(stmt):
+			reaction = row.Reaction
+			reactions.append(reaction)
+		reactions.sort(key=lambda x: x.createdAt, reverse=True)
+		async with ReactionsStorage.lock:
+			print("[service.reactions] %d recently published reactions " % len(reactions))
+			ReactionsStorage.reactions = reactions
+
+	@staticmethod
+	async def prepare_by_author(session):
+		try:
+			by_authors = session.query(Reaction.createdBy, func.count('*').label("count")).\
+				where(and_(Reaction.deletedAt == None)).\
+				group_by(Reaction.createdBy).all()
+		except Exception as e:
+			print(e)
+			by_authors = {}
+		async with ReactionsStorage.lock:
+			ReactionsStorage.reactions_by_author = dict([stat for stat in by_authors])
+			print("[service.reactions] %d reacted users" % len(by_authors))
+
+	@staticmethod
+	async def prepare_by_shout(session):
+		try:
+			by_shouts = session.query(Reaction.shout, func.count('*').label("count")).\
+				where(and_(Reaction.deletedAt == None)).\
+				group_by(Reaction.shout).all()
+		except Exception as e:
+			print(e)
+			by_shouts = {}
+		async with ReactionsStorage.lock:
+			ReactionsStorage.reactions_by_shout = dict([stat for stat in by_shouts])
+			print("[service.reactions] %d reacted shouts" % len(by_shouts))
+
+	@staticmethod
+	async def calc_ratings(session):
+		rating_by_shout = {}
+		for shout in ReactionsStorage.reactions_by_shout.keys():
+			rating_by_shout[shout] = 0
+			shout_reactions_by_kinds = session.query(Reaction).\
+				where(and_(Reaction.deletedAt == None, Reaction.shout == shout)).\
+				group_by(Reaction.kind, Reaction.id).all()
+			for reaction in shout_reactions_by_kinds:
+				rating_by_shout[shout] +=  kind_to_rate(reaction.kind)
+		async with ReactionsStorage.lock:
+			ReactionsStorage.rating_by_shout = rating_by_shout
+
+	@staticmethod
+	async def prepare_by_topic(session):
+		# TODO: optimize
+		by_topics = session.query(Reaction, func.count('*').label("count")).\
+			options(
+				joinedload(ShoutTopic),
+				joinedload(Reaction.shout)
+			).\
+			join(ShoutTopic, ShoutTopic.shout == Reaction.shout).\
+			filter(Reaction.deletedAt == None).\
+			group_by(ShoutTopic.topic).all()
+		reactions_by_topic = {}
+		for t, reactions in by_topics:
+			if not reactions_by_topic.get(t):
+				reactions_by_topic[t] = 0
+			for r in reactions:
+				reactions_by_topic[t] += r.count
+		async with ReactionsStorage.lock:
+			ReactionsStorage.reactions_by_topic = reactions_by_topic
+
+	@staticmethod
+	async def recent():
+		async with ReactionsStorage.lock:
+			return ReactionsStorage.reactions
+
+	@staticmethod
+	async def total():
+		async with ReactionsStorage.lock:
+			return len(ReactionsStorage.reactions)
+
+	@staticmethod
+	async def by_shout(shout):
+		async with ReactionsStorage.lock:
+			stat = ReactionsStorage.reactions_by_shout.get(shout)
+			stat = stat if stat else 0
+			return stat
+	
+	@staticmethod
+	async def shout_rating(shout):
+		async with ReactionsStorage.lock:
+			return ReactionsStorage.rating_by_shout.get(shout)
+
+	@staticmethod
+	async def by_author(slug):
+		async with ReactionsStorage.lock:
+			stat = ReactionsStorage.reactions_by_author.get(slug)
+			stat = stat if stat else 0
+			return stat
+
+	@staticmethod
+	async def by_topic(topic):
+		async with ReactionsStorage.lock:
+			stat = ReactionsStorage.reactions_by_topic.get(topic)
+			stat = stat if stat else 0
+			return stat
+
+	@staticmethod
+	async def worker():
+		while True:
+			try:
+				with local_session() as session:
+					await ReactionsStorage.prepare_all(session)
+					print("[service.reactions] all reactions prepared")
+					await ReactionsStorage.prepare_by_shout(session)
+					print("[service.reactions] reactions by shouts prepared")
+					await ReactionsStorage.calc_ratings(session)
+					print("[service.reactions] reactions ratings prepared")
+					await ReactionsStorage.prepare_by_topic(session)
+					print("[service.reactions] reactions topics prepared")
+			except Exception as err:
+				print("[service.reactions] errror: %s" % (err))
+			await asyncio.sleep(ReactionsStorage.period)