Continued updating the code to work with entities better

This commit is contained in:
Tiago Ribeiro
2024-10-07 15:49:58 +01:00
parent b5200c88fc
commit 1ef4efcacf
36 changed files with 2489 additions and 3012 deletions

View File

@@ -1,132 +1,171 @@
import {app} from "@/firebase";
import {Assignment} from "@/interfaces/results";
import {CorporateUser, Group, GroupWithUsers, MasterCorporateUser, StudentUser, TeacherUser, Type, User} from "@/interfaces/user";
import { app } from "@/firebase";
import { WithEntity } from "@/interfaces/entity";
import { Assignment } from "@/interfaces/results";
import { CorporateUser, Group, GroupWithUsers, MasterCorporateUser, StudentUser, TeacherUser, Type, User } from "@/interfaces/user";
import client from "@/lib/mongodb";
import moment from "moment";
import {getLinkedUsers, getUser} from "./users.be";
import {getSpecificUsers} from "./users.be";
import { getLinkedUsers, getUser } from "./users.be";
import { getSpecificUsers } from "./users.be";
const db = client.db(process.env.MONGODB_DB);
const addEntityToGroupPipeline = [
{
$lookup: {
from: "entities",
localField: "entity",
foreignField: "id",
as: "entity"
}
},
{
$addFields: {
entity: { $arrayElemAt: ["$entity", 0] }
}
},
{
$addFields: {
entity: {
$cond: {
if: { $isArray: "$entity" },
then: undefined,
else: "$entity"
}
}
}
}
]
export const updateExpiryDateOnGroup = async (participantID: string, corporateID: string) => {
const corporate = await db.collection("users").findOne<User>({id: corporateID});
const participant = await db.collection("users").findOne<User>({id: participantID});
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 || !participant) return;
if (corporate.type !== "corporate" || (participant.type !== "student" && participant.type !== "teacher")) return;
if (!corporate.subscriptionExpirationDate || !participant.subscriptionExpirationDate)
return await db.collection("users").updateOne({id: participant.id}, {$set: {subscriptionExpirationDate: null}});
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);
const corporateDate = moment(corporate.subscriptionExpirationDate);
const participantDate = moment(participant.subscriptionExpirationDate);
if (corporateDate.isAfter(participantDate))
return await db.collection("users").updateOne({id: participant.id}, {$set: {subscriptionExpirationDate: corporateDate.toISOString()}});
if (corporateDate.isAfter(participantDate))
return await db.collection("users").updateOne({ id: participant.id }, { $set: { subscriptionExpirationDate: corporateDate.toISOString() } });
return;
return;
};
export const getUserCorporate = async (id: string) => {
const user = await getUser(id);
if (!user) return undefined;
const user = await getUser(id);
if (!user) return undefined;
if (["admin", "developer"].includes(user.type)) return undefined;
if (user.type === "mastercorporate") return user;
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"))
.filter((x) => !!x) as 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"))
.filter((x) => !!x) as User[];
if (corporates.length === 0) return undefined;
return corporates.shift() as CorporateUser | MasterCorporateUser;
if (corporates.length === 0) return undefined;
return corporates.shift() as CorporateUser | MasterCorporateUser;
};
export const getGroup = async (id: string) => {
return await db.collection("groups").findOne<Group>({id});
return await db.collection("groups").findOne<Group>({ id });
};
export const getGroups = async () => {
return await db.collection("groups").find<Group>({}).toArray();
export const getGroups = async (): Promise<WithEntity<Group>[]> => {
return await db.collection("groups")
.aggregate<WithEntity<Group>>(addEntityToGroupPipeline).toArray()
};
export const getParticipantGroups = async (id: string) => {
return await db.collection("groups").find<Group>({participants: id}).toArray();
return await db.collection("groups").find<Group>({ participants: id }).toArray();
};
export const getUserGroups = async (id: string): Promise<Group[]> => {
return await db.collection("groups").find<Group>({admin: id}).toArray();
return await db.collection("groups").find<Group>({ admin: id }).toArray();
};
export const getUserNamedGroup = async (id: string, name: string) => {
return await db.collection("groups").findOne<Group>({admin: id, name});
return await db.collection("groups").findOne<Group>({ admin: id, name });
};
export const removeParticipantFromGroup = async (id: string, user: string) => {
return await db.collection("groups").updateOne({id}, {
// @ts-expect-error
$pull: {
participants: user
}
})
}
export const getUsersGroups = async (ids: string[]) => {
return await db
.collection("groups")
.find<Group>({admin: {$in: ids}})
.toArray();
return await db
.collection("groups")
.find<Group>({ admin: { $in: ids } })
.toArray();
};
export const convertToUsers = (group: Group, users: User[]): GroupWithUsers =>
Object.assign(group, {
admin: users.find((u) => u.id === group.admin),
participants: group.participants.map((p) => users.find((u) => u.id === p)).filter((x) => !!x) as User[],
});
Object.assign(group, {
admin: users.find((u) => u.id === group.admin),
participants: group.participants.map((p) => users.find((u) => u.id === p)).filter((x) => !!x) as User[],
});
export const getAllAssignersByCorporate = async (corporateID: string, type: Type): Promise<string[]> => {
const linkedTeachers = await getLinkedUsers(corporateID, type, "teacher");
const linkedCorporates = await getLinkedUsers(corporateID, type, "corporate");
const linkedTeachers = await getLinkedUsers(corporateID, type, "teacher");
const linkedCorporates = await getLinkedUsers(corporateID, type, "corporate");
return [...linkedTeachers.users.map((x) => x.id), ...linkedCorporates.users.map((x) => x.id)];
return [...linkedTeachers.users.map((x) => x.id), ...linkedCorporates.users.map((x) => x.id)];
};
export const getGroupsForEntities = async (ids: string[]) =>
await db
.collection("groups")
.find<Group>({entity: {$in: ids}})
.toArray();
await db
.collection("groups")
.find<Group>({ entity: { $in: ids } })
.toArray();
export const getGroupsForUser = async (admin?: string, participant?: string) => {
if (admin && participant) return await db.collection("groups").find<Group>({admin, participant}).toArray();
if (admin && participant) return await db.collection("groups").find<Group>({ admin, participant }).toArray();
if (admin) return await getUserGroups(admin);
if (participant) return await getParticipantGroups(participant);
if (admin) return await getUserGroups(admin);
if (participant) return await getParticipantGroups(participant);
return await getGroups();
return await getGroups();
};
export const getStudentGroupsForUsersWithoutAdmin = async (admin: string, participants: string[]) => {
return await db
.collection("groups")
.find<Group>({...(admin ? {admin: {$ne: admin}} : {}), ...(participants ? {participants} : {})})
.toArray();
return await db
.collection("groups")
.find<Group>({ ...(admin ? { admin: { $ne: admin } } : {}), ...(participants ? { participants } : {}) })
.toArray();
};
export const getCorporateNameForStudent = async (studentID: string) => {
const groups = await getStudentGroupsForUsersWithoutAdmin("", [studentID]);
if (groups.length === 0) return "";
const groups = await getStudentGroupsForUsersWithoutAdmin("", [studentID]);
if (groups.length === 0) return "";
const adminUserIds = [...new Set(groups.map((g) => g.admin))];
const adminUsersData = (await getSpecificUsers(adminUserIds)).filter((x) => !!x) as User[];
const adminUserIds = [...new Set(groups.map((g) => g.admin))];
const adminUsersData = (await getSpecificUsers(adminUserIds)).filter((x) => !!x) as User[];
if (adminUsersData.length === 0) return "";
const admins = adminUsersData.filter((x) => x.type === "corporate");
if (adminUsersData.length === 0) return "";
const admins = adminUsersData.filter((x) => x.type === "corporate");
if (admins.length > 0) {
return (admins[0] as CorporateUser).corporateInformation.companyInformation.name;
}
if (admins.length > 0) {
return (admins[0] as CorporateUser).corporateInformation.companyInformation.name;
}
return "";
return "";
};
export const getGroupsByEntity = async (id: string) => await db.collection("groups").find<Group>({entity: id}).toArray();
export const getGroupsByEntity = async (id: string) => await db.collection("groups").find<Group>({ entity: id }).toArray();
export const getGroupsByEntities = async (ids: string[]) =>
await db
.collection("groups")
.find<Group>({entity: {$in: ids}})
.toArray();
export const getGroupsByEntities = async (ids: string[]): Promise<WithEntity<Group>[]> =>
await db.collection("groups")
.aggregate<WithEntity<Group>>([
{ $match: { entity: { $in: ids } } },
...addEntityToGroupPipeline
]).toArray()