core/resolvers/profile.py

198 lines
5.6 KiB
Python
Raw Normal View History

2022-08-12 08:13:18 +00:00
from datetime import datetime
from typing import List
from sqlalchemy import and_, desc
from sqlalchemy.orm import selectinload
from auth.authenticate import login_required
from auth.tokenstorage import TokenStorage
2022-08-11 05:53:14 +00:00
from base.orm import local_session
from base.resolvers import mutation, query
from orm.reaction import Reaction
from orm.shout import Shout
from orm.topic import Topic, TopicFollower
from orm.user import User, UserRole, Role, UserRating, AuthorFollower
from resolvers.community import get_followed_communities
2022-08-12 12:50:59 +00:00
from resolvers.inbox import get_unread_counter
from resolvers.reactions import get_shout_reactions
from services.auth.users import UserStorage
2022-04-13 12:11:06 +00:00
2022-09-03 10:50:14 +00:00
@query.field("userReactedShouts")
2022-09-14 09:45:31 +00:00
async def get_user_reacted_shouts(_, _info, slug, offset, limit) -> List[Shout]:
2022-09-03 10:50:14 +00:00
user = await UserStorage.get_user_by_slug(slug)
if not user:
return []
with local_session() as session:
shouts = (
session.query(Shout)
.join(Reaction)
.where(Reaction.createdBy == user.slug)
.order_by(desc(Reaction.createdAt))
2022-09-14 09:45:31 +00:00
.limit(limit)
.offset()
2022-09-03 10:50:14 +00:00
.all()
)
return shouts
2022-05-04 13:53:23 +00:00
@query.field("userFollowedTopics")
@login_required
2022-07-21 16:11:39 +00:00
def get_followed_topics(_, slug) -> List[Topic]:
2022-09-03 10:50:14 +00:00
rows = []
with local_session() as session:
rows = (
session.query(Topic)
.join(TopicFollower)
.where(TopicFollower.follower == slug)
.all()
)
return rows
@query.field("userFollowedAuthors")
2022-07-21 16:11:39 +00:00
def get_followed_authors(_, slug) -> List[User]:
2022-09-03 10:50:14 +00:00
authors = []
with local_session() as session:
authors = (
session.query(User)
.join(AuthorFollower, User.slug == AuthorFollower.author)
.where(AuthorFollower.follower == slug)
.all()
)
return authors
@query.field("userFollowers")
2022-07-21 16:11:39 +00:00
async def user_followers(_, slug) -> List[User]:
2022-09-03 10:50:14 +00:00
with local_session() as session:
users = (
session.query(User)
.join(AuthorFollower, User.slug == AuthorFollower.follower)
.where(AuthorFollower.author == slug)
.all()
)
return users
2022-08-12 08:13:18 +00:00
2022-08-12 12:50:59 +00:00
# for mutation.field("refreshSession")
2022-05-03 12:55:29 +00:00
async def get_user_info(slug):
2022-09-03 10:50:14 +00:00
return {
"unread": await get_unread_counter(slug),
"topics": [t.slug for t in get_followed_topics(0, slug)],
"authors": [a.slug for a in get_followed_authors(0, slug)],
"reactions": [r.shout for r in get_shout_reactions(0, slug)],
"communities": [c.slug for c in get_followed_communities(0, slug)],
}
2022-05-03 12:55:29 +00:00
2022-08-12 12:50:59 +00:00
@mutation.field("refreshSession")
2021-09-05 07:16:28 +00:00
@login_required
2021-09-05 08:56:15 +00:00
async def get_current_user(_, info):
2022-09-03 10:50:14 +00:00
user = info.context["request"].user
user.lastSeen = datetime.now()
2022-09-03 10:50:14 +00:00
with local_session() as session:
session.add(user)
2022-09-03 10:50:14 +00:00
session.commit()
token = await TokenStorage.create_session(user)
2022-09-03 10:50:14 +00:00
return {
"token": token,
2022-09-03 10:50:14 +00:00
"user": user,
"info": await get_user_info(user.slug),
}
2021-11-24 09:09:47 +00:00
@query.field("getUsersBySlugs")
2022-09-14 09:45:31 +00:00
async def get_users_by_slugs(_, _info, slugs):
2022-09-03 10:50:14 +00:00
with local_session() as session:
users = (
session.query(User)
.options(selectinload(User.ratings))
.filter(User.slug in slugs)
.all()
)
return users
2021-11-25 02:45:22 +00:00
2021-12-11 13:18:40 +00:00
@query.field("getUserRoles")
2022-09-14 09:45:31 +00:00
async def get_user_roles(_, _info, slug):
2022-09-03 10:50:14 +00:00
with local_session() as session:
user = session.query(User).where(User.slug == slug).first()
roles = (
session.query(Role)
.options(selectinload(Role.permissions))
.join(UserRole)
.where(UserRole.user_id == user.id)
.all()
)
return roles
2021-11-24 09:09:47 +00:00
@mutation.field("updateProfile")
@login_required
async def update_profile(_, info, profile):
2022-09-03 10:50:14 +00:00
auth = info.context["request"].auth
user_id = auth.user_id
with local_session() as session:
user = session.query(User).filter(User.id == user_id).first()
if user:
User.update(user, **profile)
session.add(user)
session.commit()
2022-09-03 10:50:14 +00:00
return {}
2022-02-22 09:55:02 +00:00
2022-02-16 12:38:05 +00:00
@mutation.field("rateUser")
@login_required
async def rate_user(_, info, slug, value):
2022-09-03 10:50:14 +00:00
user = info.context["request"].user
with local_session() as session:
rating = (
session.query(UserRating)
.filter(and_(UserRating.rater == user.slug, UserRating.user == slug))
.first()
)
if rating:
rating.value = value
session.commit()
return {}
try:
UserRating.create(rater=user.slug, user=slug, value=value)
except Exception as err:
return {"error": err}
return {}
# for mutation.field("follow")
def author_follow(user, slug):
2022-09-03 10:50:14 +00:00
AuthorFollower.create(follower=user.slug, author=slug)
# for mutation.field("unfollow")
def author_unfollow(user, slug):
2022-09-03 10:50:14 +00:00
with local_session() as session:
flw = (
session.query(AuthorFollower)
.filter(
and_(
AuthorFollower.follower == user.slug, AuthorFollower.author == slug
)
)
.first()
)
if not flw:
raise Exception("[resolvers.profile] follower not exist, cant unfollow")
else:
session.delete(flw)
session.commit()
2022-07-28 03:44:56 +00:00
@query.field("authorsAll")
2022-09-14 09:45:31 +00:00
def get_authors_all(_, _info, offset, limit):
return list(UserStorage.get_all_users())[offset : offset + limit] # type: ignore
2022-09-14 08:27:44 +00:00
@query.field("topAuthors")
2022-09-14 09:45:31 +00:00
def get_top_authors(_, _info, offset, limit):
return list(UserStorage.get_top_users())[offset : offset + limit] # type: ignore