Merge pull request #6 from mibrito1/likes.dislikes

projeto finalizado

src/business/PostBusiness.ts

@@ -1,10 +1,12 @@
 import { PostDataBase } from "../dataBase/PostDataBase";
 import { CreatPostInputDTO, CreatPostOutputDTO } from "../dtos/posts/CreatPost.dto";
 import { DeletePostInputDTO, DeletePostOutputDTO } from "../dtos/posts/DeletePost.dto";
+import { EditPostInputDTO, EditPostOutputDTO } from "../dtos/posts/EditPost.dto";
 import { GetPostInputDTO, GetPostOutputDTO } from "../dtos/posts/GetPost.dto";
+import { LikeDislikePostInputDTO, LikeDislikePostOutputDTO } from "../dtos/posts/LikeDislikePost.dto";
 import { BadError } from "../erros/BadError";
 import { NonAuthorizedError } from "../erros/NonAuthorizedError";
-import { Post, PostWithCreatorName } from "../models/Posts";
+import { LIKEDISLIKEDB, POST_LIKE, Post, PostWithCreatorName } from "../models/Posts";
 import { userRole } from "../models/Users";
 import { userRouter } from "../router/userRouter";
 import { IdGenerator } from "../services/IdGenerator";
@@ -96,4 +98,99 @@ export class PostBusiness {
         const output = { message: "Post apagado com suesso!" }
         return output
     }
+    public editPost = async (input: EditPostInputDTO): Promise<EditPostOutputDTO> => {
+        const {
+            token, id, content
+        } = input
+        const tokenPayload: TokenPayload | null = this.tokenManager.getPayload(token)
+        if (
+            !tokenPayload
+        ) {
+            throw new NonAuthorizedError()
+        }
+        const post = await this.postDataBase.getPostId(id)
+        if (
+            !post
+        ) {
+            throw new BadError("Post não existe!")
+        }
+        if (
+            post.creator_id !== tokenPayload.id
+        ) {
+            throw new NonAuthorizedError()
+        }
+        const postEditado = new Post(post.id, post.creator_id, content, post.likes, post.dislikes, post.created_at, new Date().toISOString())
+        await this.postDataBase.editPost(postEditado.toPostDb(), id)
+        return {
+            message: "Post editado com sucesso!"
+        }
+
+
+    }
+
+    public likeDislikePost = async (input: LikeDislikePostInputDTO): Promise<LikeDislikePostOutputDTO> => {
+        const {
+            token, id, like
+        } = input
+        const tokenPayload: TokenPayload | null = this.tokenManager.getPayload(token)
+        if (
+            !tokenPayload
+        ) {
+            throw new NonAuthorizedError()
+        }
+        const post = await this.postDataBase.getPostId(id)
+        if (
+            !post
+        ) {
+            throw new BadError("Post não existe!")
+        }
+        if (
+            post.creator_id === tokenPayload.id
+        ) {
+            throw new NonAuthorizedError()
+        }
+        const postEditado = new Post(
+            post.id,
+            post.creator_id,
+            post.content,
+            post.likes,
+            post.dislikes,
+            post.created_at,
+            post.updated_at,
+        )
+        const likeDislikeDb: LIKEDISLIKEDB = {
+            user_id: tokenPayload.id,
+            post_id: id,
+            like: like ? 1 : 0          //? simboliza um ternario, antes dos : if, depois dos : else
+        }
+        const usuarioInteragiu = await this.postDataBase.findLikeDislikePost(likeDislikeDb)
+        if (usuarioInteragiu === POST_LIKE.ALREADY_LIKED) {
+            if (like) {
+                await this.postDataBase.removeLikeDislikePost(likeDislikeDb)
+                postEditado.removeLike()
+            } else {
+                await this.postDataBase.updateLikeDislikePost(likeDislikeDb)
+                postEditado.removeLike()
+                postEditado.addDislike()
+            }
+        } else if (usuarioInteragiu === POST_LIKE.ALREADY_DISLIKED) {
+            if (!like) {
+                await this.postDataBase.removeLikeDislikePost(likeDislikeDb)
+                postEditado.removeDislike()
+            } else {
+                await this.postDataBase.updateLikeDislikePost(likeDislikeDb)
+                postEditado.removeDislike()
+                postEditado.addLike()
+            }
+        } else {
+            await this.postDataBase.creatLikeDislikePost(likeDislikeDb)
+            like ? postEditado.addLike() : postEditado.addDislike()
+        }
+        await this.postDataBase.editPost(postEditado.toPostDb(), id)
+        const output: LikeDislikePostOutputDTO = {
+            message: "Interação feita com sucesso!"
+        }
+        return output
+    }
 }
+

src/controller/PostController.ts

@@ -5,6 +5,8 @@ import { CreatPostSchema } from "../dtos/posts/CreatPost.dto";
 import { PostBusiness } from "../business/PostBusiness";
 import { GetPostSchema } from "../dtos/posts/GetPost.dto";
 import { DeletePostSchema } from "../dtos/posts/DeletePost.dto";
+import { EditPostSchema } from "../dtos/posts/EditPost.dto";
+import { LikeDislikePostSchema } from "../dtos/posts/LikeDislikePost.dto";
 
 export class PostController {
     constructor(
@@ -73,5 +75,49 @@ export class PostController {
 
         }
     }
+    public editPost = async (req: Request, res: Response) => {
+        try {
+            const input = EditPostSchema.parse({
+                token: req.headers.authorization,
+                id: req.params.id,
+                content: req.body.content
+            }
+            )
+            const output = await this.postBusiness.editPost(input)
+            res.status(200).send(output.message)
+        } catch (error) {
+            console.log(error)
+            if (error instanceof ZodError) {
+                res.status(400).send(error.issues)
+            } else if (error instanceof BaseError) {
+                res.status(error.statusCode).send(error.message)
+            } else {
+                res.status(500).send("Erro inesperado")
+            }
+
+        }
+    }
+    public likeDislikePost = async (req: Request, res: Response) => {
+        try {
+            const input = LikeDislikePostSchema.parse({
+                token: req.headers.authorization,
+                id: req.params.id,
+                like: req.body.like
+            }
+            )
+            const output = await this.postBusiness.likeDislikePost(input)
+            res.status(200).send(output.message)
+        } catch (error) {
+            console.log(error)
+            if (error instanceof ZodError) {
+                res.status(400).send(error.issues)
+            } else if (error instanceof BaseError) {
+                res.status(error.statusCode).send(error.message)
+            } else {
+                res.status(500).send("Erro inesperado")
+            }
+
+        }
+    }
 
 }

src/dataBase/PostDataBase.ts

@@ -1,8 +1,10 @@
-import { PostDb, PostDbWithCreatorName } from "../models/Posts";
+import { LIKEDISLIKEDB, POST_LIKE, PostDb, PostDbWithCreatorName } from "../models/Posts";
 import { BaseDatabase } from "./BaseDataBase";
 
 export class PostDataBase extends BaseDatabase {
     public static POSTS_TABLE = "posts"
+    public static LIKE_TABLE = "like_dislike"
+
     public async creatPost(post: PostDb): Promise<void> {
         await BaseDatabase.connection(PostDataBase.POSTS_TABLE).insert(post)
     }
@@ -35,4 +37,47 @@ export class PostDataBase extends BaseDatabase {
     public async deletePost(id: string): Promise<void> {
         await BaseDatabase.connection(PostDataBase.POSTS_TABLE).delete().where({ id })
     }
+
+    public async editPost(post: PostDb, id: string): Promise<void> {
+        await BaseDatabase.connection(PostDataBase.POSTS_TABLE).update(post).where({
+            id
+        })
+    }
+    public async creatLikeDislikePost(likeDislike: LIKEDISLIKEDB): Promise<void> {
+        await BaseDatabase.connection(
+            PostDataBase.LIKE_TABLE
+        ).insert(likeDislike)
+    }
+    public async findLikeDislikePost(likeDislike: LIKEDISLIKEDB): Promise<POST_LIKE | undefined> {
+        const [response] = await BaseDatabase.connection(
+            PostDataBase.LIKE_TABLE
+        ).where({
+            post_id: likeDislike.post_id,
+            user_id: likeDislike.user_id
+        })
+        if (response === undefined) {
+            return undefined
+        } else if (response.like === 1) {
+            return POST_LIKE.ALREADY_LIKED
+        } else {
+            return POST_LIKE.ALREADY_DISLIKED
+        }
+    }
+    public async removeLikeDislikePost(likeDislike: LIKEDISLIKEDB): Promise<void> {
+        await BaseDatabase.connection(
+            PostDataBase.LIKE_TABLE
+        ).del().where({
+            post_id: likeDislike.post_id,
+            user_id: likeDislike.user_id
+        })
+    }
+    public async updateLikeDislikePost(likeDislike: LIKEDISLIKEDB): Promise<void> {
+        await BaseDatabase.connection(
+            PostDataBase.LIKE_TABLE
+        ).update(likeDislike).where({
+            post_id: likeDislike.post_id,
+            user_id: likeDislike.user_id
+        })
+    }
+
 }

src/dataBase/labook.sql

@@ -26,4 +26,13 @@ CREATE TABLE
         Foreign Key (creator_id) REFERENCES users(id) ON UPDATE CASCADE ON DELETE CASCADE
     );
 
-SELECT * FROM posts;
+SELECT * FROM posts;
+
+CREATE TABLE
+    like_dislike(
+        user_id TEXT NOT NULL,
+        post_id TEXT NOT NULL,
+        like INTEGER NOT NULL,
+        Foreign Key (user_id) REFERENCES users(id) ON UPDATE CASCADE ON DELETE CASCADE,
+        Foreign Key (post_id) REFERENCES posts(id) ON UPDATE CASCADE ON DELETE CASCADE
+    );

src/dtos/posts/EditPost.dto.ts

@@ -0,0 +1,15 @@
+import { z } from "zod"
+
+export interface EditPostInputDTO {
+    content: string,
+    token: string,
+    id: string
+}
+export interface EditPostOutputDTO {
+    message: string
+}
+export const EditPostSchema = z.object({
+    token: z.string(),
+    content: z.string(),
+    id: z.string()
+}).transform(data => data as EditPostInputDTO)

src/dtos/posts/LikeDislikePost.dto.ts

@@ -0,0 +1,15 @@
+import { z } from "zod"
+
+export interface LikeDislikePostInputDTO {
+    token: string,
+    id: string,
+    like: boolean
+}
+export interface LikeDislikePostOutputDTO {
+    message: "Interação feita com sucesso!"
+}
+export const LikeDislikePostSchema = z.object({
+    token: z.string(),
+    id: z.string(),
+    like: z.boolean()
+}).transform(data => data as LikeDislikePostInputDTO)

src/models/Posts.ts

@@ -1,4 +1,8 @@
-import { privateDecrypt } from "crypto"
+export interface LIKEDISLIKEDB {
+    user_id: string,
+    post_id: string,
+    like: number
+}
 
 export enum POST_LIKE {
     ALREADY_LIKED = "ALREADY_LIKED",

src/router/postRouter.ts

@@ -16,4 +16,11 @@ postRouter.post("/", postControler.creatPost)
 
 postRouter.get("/", postControler.getPost)
 
-postRouter.delete("/:id", postControler.deletePost)
+postRouter.delete("/:id", postControler.deletePost)
+
+postRouter.put("/:id", postControler.editPost)
+
+postRouter.put("/:id/like", postControler.likeDislikePost)
+
+
+