Almost finish implementing client side

2025-11-06 20:22:16 +02:00
parent a847779582
commit a891a686fd
42 changed files with 6450 additions and 57 deletions
--- a/Client/app/api/api.ts
+++ b/Client/app/api/api.ts
@@ -0,0 +1,146 @@
+import type { User } from "~/context/AuthContext";
+import type { Comment } from "~/types/comment";
+import type { PaginatedResponse } from "~/types/PaginatedResponse";
+import type { Post } from "~/types/post";
+import type { Tag } from "~/types/tag";
+
+const ENDPOINT = 'http://localhost:5259/api';
+
+export class API {
+
+    private static async genericRequest(url: string, method: string, body: any = null, headers: Record<string, string> = {}): Promise<Response> {
+        const localHeaders = {
+            'Content-Type': 'application/json',
+            ...headers,
+        };
+        const options: RequestInit = {
+            method,
+            headers: localHeaders,
+        };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        return response;
+    }
+
+    private static async get(url: string, headers: Record<string, string> = {}) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return response.json();
+    }
+
+    public static async post(url: string, body: any, headers: Record<string, string> = {}): Promise<Response> {
+        return await API.genericRequest(url, 'POST', body, headers);
+    }
+
+    private static async patch(url: string, body: any, headers: Record<string, string> = {}): Promise<Response> {
+        return await API.genericRequest(url, 'PATCH', body, headers);
+    }
+
+    private static async delete(url: string, body: any, headers: Record<string, string> = {}): Promise<Response> {
+        return await API.genericRequest(url, 'DELETE', body, headers);
+    }
+
+    /* Tag APIs */
+    public static async fetchTags(page: number): Promise<PaginatedResponse<Tag>> {
+        const data = await API.get(`${ENDPOINT}/tags?page=${page}`);
+        return data
+    }
+
+    public static async createTag(name: string, tagType: string, user: User): Promise<Response> {
+        return await API.post(`${ENDPOINT}/tags`, { name, type: tagType }, { Authorization: `Bearer ${user.accessToken}`});
+    }
+
+    public static async updateTag(name: string, newType: string,  user: User): Promise<Response> {
+        return await API.patch(`${ENDPOINT}/tags/${encodeURIComponent(name)}`, { type: newType }, { Authorization: `Bearer ${user.accessToken}`});
+    }
+
+    public static async deleteTag(name: string, user: User): Promise<Response> {
+        return await API.delete(`${ENDPOINT}/tags/${encodeURIComponent(name)}`, {}, { Authorization: `Bearer ${user.accessToken}`});
+    }
+
+
+    /* Post APIs */
+    public static async fetchPostById(id: number): Promise<Post|null> {
+        const data = await API.get(`${ENDPOINT}/posts/${id}`);
+        return data;
+    }
+
+    public static async fetchPosts(page: number, filter: string = ""): Promise<PaginatedResponse<Post>> {
+        const data = await API.get(`${ENDPOINT}/posts?page=${page}&query=${encodeURIComponent(filter)}`);
+        return data
+    }
+
+    public static async createPostRequest(
+        title: string, description: string,
+        tags: string[], filename: string,
+        fileMimeType: string, fileSize: number,
+        user: User
+    ): Promise<Response> {
+        return await API.post(`${ENDPOINT}/posts`, {
+            title, description, tags, filename,
+            fileMimeType, fileSize
+      }, { Authorization: `Bearer ${user.accessToken}`})
+    }
+
+    public static async patchFileUploadUrl(uploadUrl: string, image: File, user: User): Promise<Response> {
+        return await fetch(uploadUrl, {
+            method: 'PATCH',
+            headers: {
+            'Content-Range': `bytes 0-${image.size - 1}/${image.size}`,
+            'Content-Type': 'application/octet-stream',
+            'Authorization': `Bearer ${user.accessToken}`,
+            },
+            body: image,
+        });
+    }
+
+    public static async updatePost(postId: number, title: string, description: string, tags: string[], user: User): Promise<Response> {
+        return await API.patch(`${ENDPOINT}/posts/${postId}`, { title, description, tags }, {Authorization: `Bearer ${user.accessToken}`});
+    }
+
+    public static async deletePost(postId: number, user: User): Promise<Response> {
+        return await API.delete(`${ENDPOINT}/posts/${postId}`, {}, {Authorization: `Bearer ${user.accessToken}`});
+    }
+
+    /* Comment APIs */
+    public static async fetchCommentsByPostId(postId: number, page: number): Promise<PaginatedResponse<Comment>> {
+        const data = await API.get(`${ENDPOINT}/posts/${postId}/comments?page=${page}`);
+        return data;
+    }
+
+    public static async postComment(postId: number, text: string, user: User): Promise<Response> {
+        return await API.post(`${ENDPOINT}/posts/${postId}/comments`, { text }, {Authorization: `Bearer ${user.accessToken}`});
+    }
+
+    public static async updateComment(postId: number, commentId: number, newText: string, user: User): Promise<Response> {
+        return await API.patch(`${ENDPOINT}/posts/${postId}/comments/${commentId}`, { text: newText }, {Authorization: `Bearer ${user.accessToken}`});
+    }
+
+    public static async deleteComment(postId: number, commentId: number, user: User): Promise<Response> {
+        return await API.delete(`${ENDPOINT}/posts/${postId}/comments/${commentId}`, {}, {Authorization: `Bearer ${user.accessToken}`});
+    }
+
+
+
+    /* Auth APIs */
+    public static async register(username: string, email: string, password: string): Promise<Response> {
+        return await API.post(`${ENDPOINT}/auth/register`, { username, email, password });
+    }
+
+    public static async login(email: string, password: string): Promise<Response> {
+        return await API.post(`${ENDPOINT}/auth/login`, { email, password });
+    }
+
+    public static async renewToken(refreshToken: string): Promise<Response> {
+        return await API.post(`${ENDPOINT}/auth/renew`, { refreshToken });
+    }
+
+    public static async revokeToken(refreshToken: string): Promise<Response> {
+        return await API.post(`${ENDPOINT}/auth/revoke`, { refreshToken });
+    }
+}
+