devops/encoach_frontend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated the groups and users

Browse Source
This commit is contained in:
Tiago Ribeiro
2024-09-07 15:13:13 +01:00
parent c0b814081e
commit e33fa00fa3
4 changed files with 72 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
src/utils/groups.be.ts
View File

@@ -1,75 +1,73 @@
import {app} from "@/firebase";
import {CorporateUser, Group, MasterCorporateUser, StudentUser, TeacherUser} from "@/interfaces/user";
import {CorporateUser, Group, MasterCorporateUser, StudentUser, TeacherUser, User} from "@/interfaces/user";
import client from "@/lib/mongodb";
import {collection, doc, getDoc, getDocs, getFirestore, query, setDoc, where} from "firebase/firestore";
import moment from "moment";
import {getUser} from "./users.be";
import {getSpecificUsers} from "./users.be";
const db = getFirestore(app);
const db = client.db(process.env.MONGODB_DB);
export const updateExpiryDateOnGroup = async (participantID: string, corporateID: string) => {
const corporateRef = await getDoc(doc(db, "users", corporateID));
const participantRef = await getDoc(doc(db, "users", participantID));
if (!corporateRef.exists() || !participantRef.exists()) return;
const corporate = {
...corporateRef.data(),
id: corporateRef.id,
} as CorporateUser;
const participant = {...participantRef.data(), id: participantRef.id} as StudentUser | TeacherUser;
const corporate = await db.collection("users").findOne<User>({id: corporateID});
const participant = await db.collection("users").findOne<User>({id: participantID});
if (!corporate || !participant) return;
if (corporate.type !== "corporate" || (participant.type !== "student" && participant.type !== "teacher")) return;
if (!corporate.subscriptionExpirationDate || !participant.subscriptionExpirationDate) {
return await setDoc(doc(db, "users", participant.id), {subscriptionExpirationDate: null}, {merge: true});
}
if (!corporate.subscriptionExpirationDate || !participant.subscriptionExpirationDate)
return await db.collection("users").updateOne({id: participant.id}, {$set: {subscriptionExpirationDate: null}});
const corporateDate = moment(corporate.subscriptionExpirationDate);
const participantDate = moment(participant.subscriptionExpirationDate);
if (corporateDate.isAfter(participantDate))
return await setDoc(doc(db, "users", participant.id), {subscriptionExpirationDate: corporateDate.toISOString()}, {merge: true});
return await db.collection("users").updateOne({id: participant.id}, {$set: {subscriptionExpirationDate: corporateDate.toISOString()}});
return;
};
export const getUserCorporate = async (id: string) => {
const user = await getUser(id);
if (!user) return undefined;
if (["admin", "developer"].includes(user.type)) return undefined;
if (user.type === "mastercorporate") return user;
const groups = await getParticipantGroups(id);
const admins = await Promise.all(groups.map((x) => x.admin).map(getUser));
const corporates = admins.filter((x) => (user.type === "corporate" ? x.type === "mastercorporate" : x.type === "corporate"));
const corporates = admins
.filter((x) => (user.type === "corporate" ? x?.type === "mastercorporate" : x?.type === "corporate"))
.filter((x) => !!x) as User[];
if (corporates.length === 0) return undefined;
return corporates.shift() as CorporateUser | MasterCorporateUser;
};
export const getGroups = async () => {
const groupDocs = await getDocs(collection(db, "groups"));
return groupDocs.docs.map((x) => ({...x.data(), id: x.id})) as Group[];
return await db.collection("groups").find<Group>({}).toArray();
};
export const getParticipantGroups = async (id: string) => {
const snapshot = await getDocs(query(collection(db, "groups"), where("participants", "array-contains", id)));
const groups = snapshot.docs.map((doc) => ({
id: doc.id,
...doc.data(),
})) as Group[];
return groups;
return await db.collection("groups").find<Group>({participants: id}).toArray();
};
export const getUserGroups = async (id: string): Promise<Group[]> => {
const groupDocs = await getDocs(query(collection(db, "groups"), where("admin", "==", id)));
return groupDocs.docs.map((x) => ({...x.data(), id})) as Group[];
return await db.collection("groups").find<Group>({admin: id}).toArray();
};
export const getUsersGroups = async (ids: string[]) => {
return await db
.collection("groups")
.find<Group>({admin: {$in: ids}})
.toArray();
};
export const getAllAssignersByCorporate = async (corporateID: string): Promise<string[]> => {
const groups = await getUserGroups(corporateID);
const groupUsers = (await Promise.all(groups.map(async (g) => await Promise.all(g.participants.map(getUser))))).flat();
const groupUsers = (await Promise.all(groups.map(async (g) => await Promise.all(g.participants.map(getUser)))))
.flat()
.filter((x) => !!x) as User[];
const teacherPromises = await Promise.all(
groupUsers.map(async (u) =>
u.type === "teacher" ? u.id : u.type === "corporate" ? [...(await getAllAssignersByCorporate(u.id)), u.id] : undefined,
@@ -80,42 +78,19 @@ export const getAllAssignersByCorporate = async (corporateID: string): Promise<s
};
export const getGroupsForUser = async (admin?: string, participant?: string) => {
try {
const queryConstraints = [
...(admin ? [where("admin", "==", admin)] : []),
...(participant ? [where("participants", "array-contains", participant)] : []),
];
const snapshot = await getDocs(queryConstraints.length > 0 ? query(collection(db, "groups"), ...queryConstraints) : collection(db, "groups"));
const groups = snapshot.docs.map((doc) => ({
id: doc.id,
...doc.data(),
})) as Group[];
if (admin && participant) return await db.collection("groups").find<Group>({admin, participant}).toArray();
return groups;
} catch (e) {
console.error(e);
return [];
}
if (admin) return await getUserGroups(admin);
if (participant) return await getParticipantGroups(participant);
return await getGroups();
};
export const getStudentGroupsForUsersWithoutAdmin = async (admin: string, participants: string[]) => {
try {
const queryConstraints = [
...(admin ? [where("admin", "!=", admin)] : []),
...(participants ? [where("participants", "array-contains-any", participants)] : []),
where("name", "==", "Students"),
];
const snapshot = await getDocs(queryConstraints.length > 0 ? query(collection(db, "groups"), ...queryConstraints) : collection(db, "groups"));
const groups = snapshot.docs.map((doc) => ({
id: doc.id,
...doc.data(),
})) as Group[];
return groups;
} catch (e) {
console.error(e);
return [];
}
return await db
.collection("groups")
.find<Group>({...(admin ? {admin: {$ne: admin}} : {}), ...(participants ? {participants} : {})})
.toArray();
};
export const getCorporateNameForStudent = async (studentID: string) => {
@@ -123,7 +98,7 @@ export const getCorporateNameForStudent = async (studentID: string) => {
if (groups.length === 0) return "";
const adminUserIds = [...new Set(groups.map((g) => g.admin))];
const adminUsersData = await getSpecificUsers(adminUserIds);
const adminUsersData = (await getSpecificUsers(adminUserIds)).filter((x) => !!x) as User[];
if (adminUsersData.length === 0) return "";
const admins = adminUsersData.filter((x) => x.type === "corporate");