async def feed_articles( current_user: schemas.UserDB = Depends(deps.get_current_user()), limit: int = 20, offset: int = 0, ) -> schemas.MultipleArticlesInResponse: article_dbs = await crud_article.feed(limit=limit, offset=offset, follow_by=current_user.id) articles = [] for article_db in article_dbs: profile = await crud_profile.get_profile_by_user_id( article_db.author_id, requested_user=current_user) tags = await crud_article.get_article_tags(article_db.id) favorited = await crud_article.is_article_favorited_by_user( article_db.id, current_user.id) favorites_count = await crud_article.count_article_favorites( article_db.id) article_for_reponse = schemas.ArticleForResponse( slug=article_db.slug, title=article_db.title, description=article_db.description, body=article_db.body, createdAt=article_db.created_at, updatedAt=article_db.updated_at, author=profile, # type: ignore tagList=tags, favorited=favorited, favoritesCount=favorites_count, ) articles.append(article_for_reponse) return schemas.MultipleArticlesInResponse(articles=articles, articlesCount=len(articles))
async def delete_comment_for_article( slug: str, comment_id: int, current_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> None: article_db = await crud_article.get_article_by_sluq(slug=slug) if article_db is None: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=SLUG_NOT_FOUND, ) comment_db = await crud_comment.get(comment_id) if comment_db is None: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="comment with this id not found", ) if comment_db.article_id != article_db.id: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="This comment is not belong to this article", ) if comment_db.author_id != current_user.id: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="You can not delete a comment is not belong to yourself", ) await crud_comment.delete(comment_id)
async def get_article( slug: str, current_user: schemas.UserDB = Depends( deps.get_current_user(required=False)), ) -> schemas.ArticleInResponse: return await get_article_response_by_slug(slug=slug, current_user=current_user)
async def create_article_comment( slug: str, comment_in: schemas.CommentInCreate = Body(..., embed=True, alias="comment"), current_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> schemas.CommentInResponse: article_db = await crud_article.get_article_by_sluq(slug=slug) if article_db is None: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=SLUG_NOT_FOUND, ) comment_id = await crud_comment.create(payload=comment_in, article_id=article_db.id, author_id=current_user.id) comment_db = await crud_comment.get(comment_id) # type: ignore profile = await crud_profile.get_profile_by_user_id( comment_db.author_id, requested_user=current_user # type: ignore ) return schemas.CommentInResponse(comment=schemas.CommentForResponse( id=comment_db.id, # type: ignore body=comment_db.body, # type: ignore createdAt=comment_db.created_at, # type: ignore updatedAt=comment_db.updated_at, # type: ignore author=profile, # type: ignore ))
async def get_comments_from_an_article( slug: str, current_user: schemas.UserDB = Depends( deps.get_current_user(required=False)), ) -> schemas.MultipleCommentsInResponse: article_db = await crud_article.get_article_by_sluq(slug=slug) if article_db is None: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="article with this slug not found", ) comment_dbs = await crud_comment.get_comments_from_an_article( article_id=article_db.id) comments = [] for comment_db in comment_dbs: profile = await crud_profile.get_profile_by_user_id( comment_db.author_id, requested_user=current_user) comments.append( schemas.CommentForResponse( id=comment_db.id, body=comment_db.body, createdAt=comment_db.created_at, updatedAt=comment_db.updated_at, author=profile, # type: ignore )) return schemas.MultipleCommentsInResponse(comments=comments)
async def update_current_user( user_update: schemas.UserUpdate = Body(..., embed=True, alias="user"), current_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> schemas.UserResponse: if user_update.username and user_update.username != current_user.username: user_db = await crud_user.get_user_by_username( username=user_update.username) if user_db: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="user with this username already exists", ) if user_update.email and user_update.email != current_user.email: user_db = await crud_user.get_user_by_email(email=user_update.email) if user_db: raise HTTPException( status_code=HTTP_400_BAD_REQUEST, detail="user with this email already exists", ) user_id = await crud_user.update(user_id=current_user.id, payload=user_update) user_db = await crud_user.get(user_id) token = security.create_access_token(current_user.id) return schemas.UserResponse(user=schemas.UserWithToken( username=user_db.username, # type: ignore email=user_db.email, # type: ignore bio=user_db.bio, # type: ignore image=user_db.image, # type: ignore token=token, ))
async def get_profile( username: str, requested_user: schemas.UserDB = Depends( deps.get_current_user(required=False)), ) -> schemas.ProfileResponse: return await get_profile_response(requested_user=requested_user, username=username)
async def retrieve_current_user( current_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> schemas.UserResponse: token = security.create_access_token(current_user.id) return schemas.UserResponse(user=schemas.UserWithToken( username=current_user.username, email=current_user.email, bio=current_user.bio, image=current_user.image, token=token, ))
async def favorite_article( slug: str, current_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> schemas.ArticleInResponse: article = await crud_article.get_article_by_sluq(slug=slug) if article is None: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=SLUG_NOT_FOUND, ) await crud_article.favorite(article_id=article.id, user_id=current_user.id) return await get_article_response_by_slug(slug=slug, current_user=current_user)
async def follow_user( username: str, requested_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> schemas.ProfileResponse: follower_user = await get_follow_user(requested_user=requested_user, username=username) if await crud_profile.is_following(follower_user, requested_user): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="you follow this user already", ) await crud_profile.follow(follower_user, requested_user) return await get_profile_response(requested_user=requested_user, username=username)
async def delete_article( slug: str, current_user: schemas.UserDB = Depends( deps.get_current_user(required=False)), ) -> None: article_db = await crud_article.get_article_by_sluq(slug=slug) if article_db is None: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=SLUG_NOT_FOUND, ) if article_db.author_id != current_user.id: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="can not delete an article owner by other user", ) await crud_article.delete(article_db)
async def update_article( slug: str, article_in: schemas.ArticleInUpdate = Body(..., embed=True, alias="article"), current_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> schemas.ArticleInResponse: article_db = await crud_article.get_article_by_sluq(slug) if article_db is None: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=SLUG_NOT_FOUND, ) await crud_article.update(article_db, payload=article_in) return await get_article_response_by_slug(slug=slug, current_user=current_user)
async def create_article( article_in: schemas.ArticleInCreate = Body(..., embed=True, alias="article"), current_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> schemas.ArticleInResponse: article_id = await crud_article.create(article_in, author_id=current_user.id) article = await crud_article.get(article_id) profile = await crud_profile.get_profile_by_user_id( article.author_id, requested_user=current_user # type: ignore ) tags = await crud_article.get_article_tags(article_id) favorited = await crud_article.is_article_favorited_by_user( article_id, current_user.id) favorites_count = await crud_article.count_article_favorites(article_id) return gen_article_in_response( article=article, # type: ignore favorited=favorited, favorites_count=favorites_count, profile=profile, # type: ignore tags=tags, )
async def unfollow_user( username: str, requested_user: schemas.UserDB = Depends(deps.get_current_user()), ) -> schemas.ProfileResponse: follower_user = await crud_user.get_user_by_username(username=username) if follower_user is None: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="user with this username is not existed", ) if follower_user.id == requested_user.id: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="cannot unfollow yourself", ) if not await crud_profile.is_following(follower_user, requested_user): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="you don't follow this user already", ) await crud_profile.unfollow(follower_user, requested_user) profile = await crud_profile.get_profile_by_username( username, requested_user) return schemas.ProfileResponse(profile=profile) # type: ignore