all

Securite/Linkwarden/lib/api/controllers/collections/collectionId/deleteCollectionById.ts

@@ -0,0 +1,129 @@
+import { prisma } from "@/lib/api/db";
+import getPermission from "@/lib/api/getPermission";
+import { Collection, UsersAndCollections } from "@prisma/client";
+import removeFolder from "@/lib/api/storage/removeFolder";
+
+export default async function deleteCollection(
+  userId: number,
+  collectionId: number
+) {
+  if (!collectionId)
+    return { response: "Please choose a valid collection.", status: 401 };
+
+  const collectionIsAccessible = await getPermission({
+    userId,
+    collectionId,
+  });
+
+  const memberHasAccess = collectionIsAccessible?.members.some(
+    (e: UsersAndCollections) => e.userId === userId
+  );
+
+  if (collectionIsAccessible?.ownerId !== userId && memberHasAccess) {
+    // Remove relation/Leave collection
+    const deletedUsersAndCollectionsRelation =
+      await prisma.usersAndCollections.delete({
+        where: {
+          userId_collectionId: {
+            userId: userId,
+            collectionId: collectionId,
+          },
+        },
+      });
+
+    await removeFromOrders(userId, collectionId);
+
+    return { response: deletedUsersAndCollectionsRelation, status: 200 };
+  } else if (collectionIsAccessible?.ownerId !== userId) {
+    return { response: "Collection is not accessible.", status: 401 };
+  }
+
+  const deletedCollection = await prisma.$transaction(async () => {
+    await deleteSubCollections(collectionId);
+
+    await prisma.usersAndCollections.deleteMany({
+      where: {
+        collection: {
+          id: collectionId,
+        },
+      },
+    });
+
+    await prisma.link.deleteMany({
+      where: {
+        collection: {
+          id: collectionId,
+        },
+      },
+    });
+
+    await removeFolder({ filePath: `archives/${collectionId}` });
+
+    await removeFromOrders(userId, collectionId);
+
+    return await prisma.collection.delete({
+      where: {
+        id: collectionId,
+      },
+    });
+  });
+
+  return { response: deletedCollection, status: 200 };
+}
+
+async function deleteSubCollections(collectionId: number) {
+  const subCollections = await prisma.collection.findMany({
+    where: { parentId: collectionId },
+  });
+
+  for (const subCollection of subCollections) {
+    await deleteSubCollections(subCollection.id);
+
+    await prisma.usersAndCollections.deleteMany({
+      where: {
+        collection: {
+          id: subCollection.id,
+        },
+      },
+    });
+
+    await prisma.link.deleteMany({
+      where: {
+        collection: {
+          id: subCollection.id,
+        },
+      },
+    });
+
+    await prisma.collection.delete({
+      where: { id: subCollection.id },
+    });
+
+    await removeFolder({ filePath: `archives/${subCollection.id}` });
+  }
+}
+
+async function removeFromOrders(userId: number, collectionId: number) {
+  const userCollectionOrder = await prisma.user.findUnique({
+    where: {
+      id: userId,
+    },
+    select: {
+      collectionOrder: true,
+    },
+  });
+
+  if (userCollectionOrder)
+    await prisma.user.update({
+      where: {
+        id: userId,
+      },
+      data: {
+        collectionOrder: {
+          set: userCollectionOrder.collectionOrder.filter(
+            (e: number) => e !== collectionId
+          ),
+        },
+      },
+    });
+}

Securite/Linkwarden/lib/api/controllers/collections/collectionId/getCollectionById.ts

@@ -0,0 +1,34 @@
+import { prisma } from "@/lib/api/db";
+
+export default async function getCollectionById(
+  userId: number,
+  collectionId: number
+) {
+  const collections = await prisma.collection.findFirst({
+    where: {
+      id: collectionId,
+      OR: [
+        { ownerId: userId },
+        { members: { some: { user: { id: userId } } } },
+      ],
+    },
+    include: {
+      _count: {
+        select: { links: true },
+      },
+      members: {
+        include: {
+          user: {
+            select: {
+              username: true,
+              name: true,
+              image: true,
+            },
+          },
+        },
+      },
+    },
+  });
+
+  return { response: collections, status: 200 };
+}

Securite/Linkwarden/lib/api/controllers/collections/collectionId/updateCollectionById.ts

@@ -0,0 +1,107 @@
+import { prisma } from "@/lib/api/db";
+import { CollectionIncludingMembersAndLinkCount } from "@/types/global";
+import getPermission from "@/lib/api/getPermission";
+
+export default async function updateCollection(
+  userId: number,
+  collectionId: number,
+  data: CollectionIncludingMembersAndLinkCount
+) {
+  if (!collectionId)
+    return { response: "Please choose a valid collection.", status: 401 };
+
+  const collectionIsAccessible = await getPermission({
+    userId,
+    collectionId,
+  });
+
+  if (!(collectionIsAccessible?.ownerId === userId))
+    return { response: "Collection is not accessible.", status: 401 };
+
+  console.log(data);
+
+  if (data.parentId) {
+    if (data.parentId !== ("root" as any)) {
+      const findParentCollection = await prisma.collection.findUnique({
+        where: {
+          id: data.parentId,
+        },
+        select: {
+          ownerId: true,
+          parentId: true,
+        },
+      });
+
+      if (
+        findParentCollection?.ownerId !== userId ||
+        typeof data.parentId !== "number" ||
+        findParentCollection?.parentId === data.parentId
+      )
+        return {
+          response: "You are not authorized to create a sub-collection here.",
+          status: 403,
+        };
+    }
+  }
+
+  const updatedCollection = await prisma.$transaction(async () => {
+    await prisma.usersAndCollections.deleteMany({
+      where: {
+        collection: {
+          id: collectionId,
+        },
+      },
+    });
+
+    return await prisma.collection.update({
+      where: {
+        id: collectionId,
+      },
+      data: {
+        name: data.name.trim(),
+        description: data.description,
+        color: data.color,
+        isPublic: data.isPublic,
+        parent:
+          data.parentId && data.parentId !== ("root" as any)
+            ? {
+                connect: {
+                  id: data.parentId,
+                },
+              }
+            : data.parentId === ("root" as any)
+              ? {
+                  disconnect: true,
+                }
+              : undefined,
+        members: {
+          create: data.members.map((e) => ({
+            user: { connect: { id: e.user.id || e.userId } },
+            canCreate: e.canCreate,
+            canUpdate: e.canUpdate,
+            canDelete: e.canDelete,
+          })),
+        },
+      },
+      include: {
+        _count: {
+          select: { links: true },
+        },
+        members: {
+          include: {
+            user: {
+              select: {
+                image: true,
+                username: true,
+                name: true,
+                id: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  });
+
+  return { response: updatedCollection, status: 200 };
+}