Merge branch 'main' into reports

backend/prisma/schema.prisma

@@ -26,8 +26,6 @@ model Post {
   authorId String @db.ObjectId
   // Request details
   requests Request[]
-  // Report details
-  reports Report[]
 }
 
 // User stores n number of posts and requests
@@ -70,9 +68,8 @@ model Report {
   reason String
   status String @default("open")
   // Reporter details
-  reporter User @relation(fields: [reporterEmail], references: [email])
   reporterEmail String
-  // Post details
-  post Post @relation(fields: [postId], references: [id])
-  postId String @db.ObjectId
+  // User details
+  userReported User @relation(fields: [userReportedEmail], references: [email])
+  userReportedEmail String 
 }

backend/src/routes/admin.route.ts

@@ -1,7 +1,7 @@
 import { Router } from "express";
 import { HttpCodes } from "../types/HttpCodes";
 import { CustomResponse } from "../types/CustomResponse";
-import { getAllUsers, promoteUser, demoteUser, banUser } from "../service/admin.service";
+import { getAllUsers, promoteUser, demoteUser, banUser, deltaKarma} from "../service/admin.service";
 import prisma from '../db'
 import { getAllPosts } from "../service/posts.service";
 export const adminRouter = Router();
@@ -160,6 +160,30 @@ adminRouter.put("/ban/:user", async (req, res) => {
             data: ban
         }
 
+        return res.status(HttpCodes.OK).json(response);
+    }
+})
+
+adminRouter.put("/deltaKarma/:user", async (req, res) => {
+    const userEmailId = req.params.user;
+    const amount=  req.body.amount as number;
+    const sign= req.body.sign as boolean;
+    const fruit = await deltaKarma(userEmailId,amount,sign);
+
+    if (fruit.error) {
+        const response: CustomResponse = {
+            error: true,
+            message: fruit.data as string,
+            data: null
+        }
+        return res.status(HttpCodes.INTERNAL_SERVER_ERROR).json(response);
+    } else {
+        const response: CustomResponse = {
+            error: false,
+            message: "Selected user's karma has been updated",
+            data: fruit
+        }
+
         return res.status(HttpCodes.OK).json(response);
     }
 })

backend/src/routes/gauth.route.ts

@@ -22,7 +22,7 @@ gauthRouter.get("/", async (req, res) => {
         if (appUser.data) {
             if (typeof appUser.data !== 'string' && appUser.data.role === "admin") {
                 logger.info("Admin login");
-                res.redirect(FRONTEND_URL + '/admin');
+                res.redirect(FRONTEND_URL + '/admin/');
                 return;
             }
         } else {

backend/src/service/admin.service.ts

@@ -121,4 +121,74 @@ export const banUser = async (userEmailId: string): Promise<CustomReturn<User>>
             data: "Some error occurred while banning user."
         }
     }
+}
+
+//changes Karma of a user
+//use sign=false to decrease   sign=true to increase
+export const deltaKarma =async (userEmailId: string, amount:number, sign:boolean): 
+Promise<CustomReturn<User>> => {
+    try {
+        let user = await prisma.user.findUnique({
+            where: {
+                email: userEmailId
+            }
+        });
+
+        if (!user) return {
+            error: true,
+            data: "User does not exist."
+        }
+
+        if (user.role == "admin") {
+            return {
+                error: true,
+                data: "Admin karma cannot be updated."
+            }
+        }
+
+        if (sign==false) {
+            if(user.karmaPoints<amount){
+                return{
+                    error:true,
+                    data:"Stop, Stop! he is already dead."
+                }
+            }
+            const punishedUser= await prisma.user.update({
+                where: { email: userEmailId },
+                data: {
+                    karmaPoints: {
+                        decrement: amount
+                    }
+                }
+            })
+            return {
+                error:false,
+                data:punishedUser
+            }
+        }
+        else {
+            const cherishedUser= await prisma.user.update({
+                where: { email: userEmailId },
+                data: {
+                    karmaPoints: {
+                        increment: amount
+                    }
+                }
+            })
+            return {
+                error:false,
+                data:cherishedUser
+            }
+        }
+    }
+    catch (err: any) {
+        logger.error(JSON.stringify({
+            location: "deltaKarma",
+            message: err.toString()
+        }));
+        return {
+            error: true,
+            data: "Some error occurred while changing karma."
+        }
+    }
 }

backend/src/service/posts.service.ts

@@ -317,7 +317,7 @@ export const completePost = async (postId: string, authorEmail: string): Promise
             error: true,
             data: "Post has already been completed."
         };
-        
+
         else if (post.status == "open") return {
             error: true,
             data: "Post has not been closed yet."
@@ -336,7 +336,7 @@ export const completePost = async (postId: string, authorEmail: string): Promise
             data: "Some error occurred while finding accepted requests."
         }
 
-        if (post.costInPoints>user.karmaPoints) return {
+        if (post.costInPoints > user.karmaPoints) return {
             error: true,
             data: "Not enough karma to complete this post."
         }

backend/tests/admin.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect } from "@jest/globals";
 import { prismaMock } from "./_mockdb";
 import { User } from ".prisma/client";
-import { getAllUsers, promoteUser, demoteUser, banUser } from "../src/service/admin.service";
+import { getAllUsers, promoteUser, demoteUser, banUser, deltaKarma} from "../src/service/admin.service";
 
 const user: User = {
     id: "1",
@@ -13,7 +13,7 @@ const user: User = {
     isPublic: true
 }
 
-const a: User = {
+const admin: User = {
     id: "2",
     name: "ben",
     email: "ben@hen.com",
@@ -23,7 +23,7 @@ const a: User = {
     isPublic: true
 }
 
-const na: User = {
+const notadmin: User = {
     id: "2",
     name: "ben",
     email: "ben@hen.com",
@@ -33,6 +33,16 @@ const na: User = {
     isPublic: true
 }
 
+const na2: User = {
+    id: "3",
+    name: "ben",
+    email: "hen@hen.com",
+    phoneNumber: "9898989898",
+    karmaPoints: 0,
+    role: "user",
+    isPublic: true
+}
+
 const bu: User= {
     id: "2",
     name: "ben",
@@ -43,6 +53,16 @@ const bu: User= {
     isPublic: true
 }
 
+const iku: User = {
+    id: "2",
+    name: "ben",
+    email: "ben@hen.com",
+    phoneNumber: "9898989898",
+    karmaPoints: 12,
+    role: "user",
+    isPublic: true
+}
+
 describe("Get all users", () => {
     it("should get all users", () => {
         prismaMock.user.findMany.mockResolvedValue([user]);
@@ -65,20 +85,20 @@ describe("Get all users", () => {
 
 describe("promote user to admin", () => {
     it("should promote user to admin role", () => {
-        prismaMock.user.findUnique.mockResolvedValue(na);
-        prismaMock.user.update.mockResolvedValue(a);
+        prismaMock.user.findUnique.mockResolvedValue(notadmin);
+        prismaMock.user.update.mockResolvedValue(admin);
 
-        expect(promoteUser(na.email)).resolves.toEqual({
+        expect(promoteUser(notadmin.email)).resolves.toEqual({
             error: false,
-            data: a
+            data: admin
         })
     })
 
     it("should return error if any error occured", () => {
-        prismaMock.user.findUnique.mockResolvedValue(na);
+        prismaMock.user.findUnique.mockResolvedValue(notadmin);
         prismaMock.user.update.mockRejectedValue(new Error("Some error occurred"));
 
-        expect(promoteUser(na.email)).resolves.toEqual({
+        expect(promoteUser(notadmin.email)).resolves.toEqual({
             error: true,
             data: "Some error occurred while promoting user to admin role"
         })
@@ -87,20 +107,22 @@ describe("promote user to admin", () => {
 
 describe("demote admin to user", () => {
     it("should demote admin to user", () => {
-        prismaMock.user.findUnique.mockResolvedValue(a);
-        prismaMock.user.update.mockResolvedValue(na);
+        prismaMock.user.findUnique.mockResolvedValue(admin);
+        prismaMock.user.update.mockResolvedValue(notadmin);
+
 
-        expect(demoteUser(a.email)).resolves.toEqual({
+        expect(demoteUser(user.email, admin.email)).resolves.toEqual({
             error: false,
-            data: na
+            data: notadmin
         })
     })
 
     it("should return error if any error occured", () => {
-        prismaMock.user.findUnique.mockResolvedValue(a);
+        prismaMock.user.findUnique.mockResolvedValue(admin);
         prismaMock.user.update.mockRejectedValue(new Error("Some error occurred"));
 
-        expect(demoteUser(a.email)).resolves.toEqual({
+
+        expect(demoteUser(user.email, admin.email)).resolves.toEqual({
             error: true,
             data: "Some error occurred while demoting admin to user role"
         })
@@ -109,10 +131,10 @@ describe("demote admin to user", () => {
 
 describe("ban user", () => {
     it("should ban user", () => {
-        prismaMock.user.findUnique.mockResolvedValue(na);
+        prismaMock.user.findUnique.mockResolvedValue(notadmin);
         prismaMock.user.update.mockResolvedValue(bu);
 
-        expect(banUser(na.email)).resolves.toEqual({
+        expect(banUser(notadmin.email)).resolves.toEqual({
             error: false,
             data: bu
         })
@@ -127,22 +149,80 @@ describe("ban user", () => {
     })
 
     it("should return error if user to be banned is an admin", () => {
-        prismaMock.user.findUnique.mockResolvedValue(a);
+        prismaMock.user.findUnique.mockResolvedValue(admin);
         prismaMock.user.update.mockResolvedValue(bu);
 
-        expect(banUser(a.email)).resolves.toEqual({
+        expect(banUser(admin.email)).resolves.toEqual({
             error: true,
             data: "An admin cannot be banned."
         })
     })
 
     it("should return error if any error occured", () => {
-        prismaMock.user.findUnique.mockResolvedValue(na);
+        prismaMock.user.findUnique.mockResolvedValue(notadmin);
         prismaMock.user.update.mockRejectedValue(new Error("Some error occurred"));
 
-        expect(banUser(na.email)).resolves.toEqual({
+        expect(banUser(notadmin.email)).resolves.toEqual({
             error: true,
             data: "Some error occurred while banning user."
         })
     })
+})
+
+describe("increase/decrease user karma", () => {
+    it("should increase karma", () => {
+        prismaMock.user.findUnique.mockResolvedValue(na);
+        prismaMock.user.update.mockResolvedValue(iku);
+
+        expect(deltaKarma(na.email,12,true)).resolves.toEqual({
+            error: false,
+            data: iku
+        })
+    })
+
+    it("should decrease karma", () => {
+        prismaMock.user.findUnique.mockResolvedValue(iku);
+        prismaMock.user.update.mockResolvedValue(na);
+
+        expect(deltaKarma(iku.email,12,false)).resolves.toEqual({
+            error: false,
+            data: na
+        })
+    })
+
+    it("should return error if target karma is negative", () => {
+        prismaMock.user.findUnique.mockResolvedValue(na);
+
+        expect(deltaKarma(na.email,12,false)).resolves.toEqual({
+            error: true,
+            data: "Stop, Stop! he is already dead."
+        })
+    })
+
+    it("should return an error if user does not exist", () => {
+
+        expect(banUser("random@random.com")).resolves.toEqual({
+            error: true,
+            data: "User does not exist."
+        })
+    })
+
+    it("should return error if user to be updated is an admin", () => {
+        prismaMock.user.findUnique.mockResolvedValue(a);
+
+        expect(deltaKarma(a.email,12,true)).resolves.toEqual({
+            error: true,
+            data: "Admin karma cannot be updated."
+        })
+    })
+
+    it("should return error if any error occured", () => {
+        prismaMock.user.findUnique.mockResolvedValue(na);
+        prismaMock.user.update.mockRejectedValue(new Error("Some error occurred"));
+
+        expect(deltaKarma(na.email,12,true)).resolves.toEqual({
+            error: true,
+            data: "Some error occurred while changing karma."
+        })
+    })
 })