Added new permission system

src/utils/permissions.be.ts

@@ -0,0 +1,83 @@
+import { app, adminApp } from "@/firebase";
+import { getAuth } from "firebase-admin/auth";
+
+import {
+  collection,
+  deleteDoc,
+  doc,
+  getDoc,
+  getDocs,
+  getFirestore,
+  query,
+  setDoc,
+  where,
+} from "firebase/firestore";
+import {
+  Permission,
+  PermissionType,
+  permissions,
+} from "@/interfaces/permissions";
+import {v4} from "uuid";
+
+const db = getFirestore(app);
+
+async function createPermission(type: string) {
+  const permData = doc(db, "permissions", v4());
+  const permDoc = await getDoc(permData);
+  if (permDoc.exists()) {
+    return true;
+  }
+
+  await setDoc(permData, {
+    type,
+    users: [],
+  });
+}
+export function getPermissions(userId: string | undefined, docs: Permission[]) {
+  if (!userId) {
+    return [];
+  }
+  // the concept is like a blacklist
+  // if the user exists in the list, he can't access this permission
+  // even if his profile allows
+  const permissions = docs.reduce((acc: PermissionType[], doc: Permission) => {
+    //  typescript was complaining even with the validation on the top
+    if (doc.users.includes(userId)) {
+      return acc;
+    }
+
+    return [...acc, doc.type];
+  }, []) as PermissionType[];
+  return permissions;
+}
+
+export async function bootstrap() {
+  await permissions.forEach(async (type) => {
+    await createPermission(type);
+  });
+}
+
+export async function getPermissionDoc(id: string) {
+  const docRef = doc(db, "permissions", id);
+  const docSnap = await getDoc(docRef);
+
+  if (docSnap.exists()) {
+    return docSnap.data() as Permission;
+  }
+
+  throw new Error("Permission not found");
+}
+
+export async function getPermissionDocs() {
+  const q = query(collection(db, "permissions"));
+  // firebase is missing something like array-not-contains
+
+  const snapshot = await getDocs(q);
+
+  const docs = snapshot.docs.map((doc) => ({
+    id: doc.id,
+    ...doc.data(),
+  })) as Permission[];
+
+  return docs;
+}

src/utils/permissions.ts

@@ -0,0 +1,45 @@
+import { PermissionType } from "@/interfaces/permissions";
+import { User, Type, userTypes } from "@/interfaces/user";
+
+export function checkAccess(
+  user: User,
+  types: Type[],
+  permission?: PermissionType
+) {
+  if (!user) {
+    return false;
+  }
+
+  // if(user.type === '') {
+  if (!user.type) {
+    console.warn("User type is empty");
+    return false;
+  }
+
+  if (types.length === 0) {
+    console.warn("No types provided");
+    return false;
+  }
+
+  if (!types.includes(user.type)) {
+    return false;
+  }
+
+  // we may not want a permission check as most screens dont even havr a specific permission
+  if (permission) {
+    // this works more like a blacklist
+    // therefore if we don't find the permission here, he can't do it
+    if (!(user.permissions || []).includes(permission)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function getTypesOfUser(types: Type[]) {
+    // basicly generate a list of all types except the excluded ones
+    return userTypes.filter((userType) => {
+        return !types.includes(userType);
+    })
+}

src/utils/users.be.ts

@@ -0,0 +1,14 @@
+import { app } from "@/firebase";
+
+import { collection, getDocs, getFirestore } from "firebase/firestore";
+import { User } from "@/interfaces/user";
+const db = getFirestore(app);
+
+export async function getUsers() {
+  const snapshot = await getDocs(collection(db, "users"));
+
+  return snapshot.docs.map((doc) => ({
+    id: doc.id,
+    ...doc.data(),
+  })) as User[];
+}