Feat/social media platforms (#196)

* chore: this part works now wooohooo

* chore: stash progress

* chore: stash progress

* chore: init message data models

* feat: different socials

* chore: blabsy ready for redesign

* chore: add other socials

Author: coodos

platforms/blabsy-api/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "piqtique-api",
+    "version": "1.0.0",
+    "description": "Piqtique Social Media Platform API",
+    "main": "src/index.ts",
+    "scripts": {
+        "start": "ts-node src/index.ts",
+        "dev": "nodemon --exec ts-node src/index.ts",
+        "build": "tsc",
+        "typeorm": "typeorm-ts-node-commonjs",
+        "migration:generate": "npm run typeorm migration:generate -- -d src/database/data-source.ts",
+        "migration:run": "npm run typeorm migration:run -- -d src/database/data-source.ts",
+        "migration:revert": "npm run typeorm migration:revert -- -d src/database/data-source.ts"
+    },
+    "dependencies": {
+        "axios": "^1.6.7",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.5",
+        "eventsource-polyfill": "^0.9.6",
+        "express": "^4.18.2",
+        "jsonwebtoken": "^9.0.2",
+        "pg": "^8.11.3",
+        "reflect-metadata": "^0.2.1",
+        "typeorm": "^0.3.20",
+        "uuid": "^9.0.1"
+    },
+    "devDependencies": {
+        "@types/cors": "^2.8.17",
+        "@types/express": "^4.17.21",
+        "@types/jsonwebtoken": "^9.0.5",
+        "@types/node": "^20.11.24",
+        "@types/pg": "^8.11.2",
+        "@types/uuid": "^9.0.8",
+        "@typescript-eslint/eslint-plugin": "^7.0.1",
+        "@typescript-eslint/parser": "^7.0.1",
+        "eslint": "^8.56.0",
+        "nodemon": "^3.0.3",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.3.3"
+    }
+}

platforms/blabsy-api/src/controllers/AuthController.ts

@@ -0,0 +1,81 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+import { UserService } from "../services/UserService";
+import { EventEmitter } from "events";
+export class AuthController {
+    private userService: UserService;
+    private eventEmitter: EventEmitter;
+
+    constructor() {
+        this.userService = new UserService();
+        this.eventEmitter = new EventEmitter();
+    }
+
+    sseStream = async (req: Request, res: Response) => {
+        const { id } = req.params;
+
+        // Set headers for SSE
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Access-Control-Allow-Origin": "*",
+        });
+
+        const handler = (data: any) => {
+            res.write(`data: ${JSON.stringify(data)}\n\n`);
+        };
+
+        this.eventEmitter.on(id, handler);
+
+        // Handle client disconnect
+        req.on("close", () => {
+            this.eventEmitter.off(id, handler);
+            res.end();
+        });
+
+        req.on("error", (error) => {
+            console.error("SSE Error:", error);
+            this.eventEmitter.off(id, handler);
+            res.end();
+        });
+    };
+
+    getOffer = async (req: Request, res: Response) => {
+        const url = new URL(
+            "/api/auth",
+            process.env.PUBLIC_BLABSY_BASE_URL,
+        ).toString();
+        const session = uuidv4();
+        const offer = `w3ds://auth?redirect=${url}&session=${session}&platform=blabsy`;
+        res.json({ uri: offer });
+    };
+
+    login = async (req: Request, res: Response) => {
+        try {
+            const { ename, session } = req.body;
+
+            if (!ename) {
+                return res.status(400).json({ error: "ename is required" });
+            }
+
+            const { user, token } =
+                await this.userService.findOrCreateUser(ename);
+
+            const data = {
+                user: {
+                    id: user.id,
+                    ename: user.ename,
+                    isVerified: user.isVerified,
+                    isPrivate: user.isPrivate,
+                },
+                token,
+            };
+            this.eventEmitter.emit(session, data);
+            res.status(200).send();
+        } catch (error) {
+            console.error("Error during login:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+}

platforms/blabsy-api/src/controllers/CommentController.ts

@@ -0,0 +1,93 @@
+import { Request, Response } from "express";
+import { CommentService } from "../services/CommentService";
+
+export class CommentController {
+    private commentService: CommentService;
+
+    constructor() {
+        this.commentService = new CommentService();
+    }
+
+    createComment = async (req: Request, res: Response) => {
+        try {
+            const { blabId, text } = req.body;
+            const userId = req.user?.id;
+
+            if (!userId) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+
+            const reply = await this.commentService.createComment(blabId, userId, text);
+            res.status(201).json(reply);
+        } catch (error) {
+            console.error("Error creating reply:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    getPostComments = async (req: Request, res: Response) => {
+        try {
+            const { blabId } = req.params;
+            const replies = await this.commentService.getPostComments(blabId);
+            res.json(replies);
+        } catch (error) {
+            console.error("Error fetching replies:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    updateComment = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const { text } = req.body;
+            const userId = req.user?.id;
+
+            if (!userId) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+
+            const reply = await this.commentService.getCommentById(id);
+
+            if (!reply) {
+                return res.status(404).json({ error: "Reply not found" });
+            }
+
+            if (reply.creator.id !== userId) {
+                return res.status(403).json({ error: "Forbidden" });
+            }
+
+            const updatedReply = await this.commentService.updateComment(id, text);
+            res.json(updatedReply);
+        } catch (error) {
+            console.error("Error updating reply:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    deleteComment = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const userId = req.user?.id;
+
+            if (!userId) {
+                return res.status(401).json({ error: "Unauthorized" });
+            }
+
+            const reply = await this.commentService.getCommentById(id);
+
+            if (!reply) {
+                return res.status(404).json({ error: "Reply not found" });
+            }
+
+            if (reply.creator.id !== userId) {
+                return res.status(403).json({ error: "Forbidden" });
+            }
+
+            await this.commentService.deleteComment(id);
+            res.status(204).send();
+        } catch (error) {
+            console.error("Error deleting reply:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+}