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

Continued migrating more and more files

Browse Source
This commit is contained in:
Tiago Ribeiro
2024-09-07 18:29:20 +01:00
parent bb8dca69cf
commit 6251f8f4db
16 changed files with 254 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/pages/api/grading/index.ts
View File

@@ -1,7 +1,6 @@
// Next.js API route support: https://nextjs.org/docs/api-routes/introduction // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
import type {NextApiRequest, NextApiResponse} from "next"; import type {NextApiRequest, NextApiResponse} from "next";
import {app} from "@/firebase"; import {app} from "@/firebase";
import {getFirestore, collection, getDocs, setDoc, doc, getDoc, deleteDoc, query} from "firebase/firestore";
import {withIronSessionApiRoute} from "iron-session/next"; import {withIronSessionApiRoute} from "iron-session/next";
import {sessionOptions} from "@/lib/session"; import {sessionOptions} from "@/lib/session";
import {CorporateUser, Group} from "@/interfaces/user"; import {CorporateUser, Group} from "@/interfaces/user";

1
src/pages/api/login.ts
View File

@@ -4,7 +4,6 @@ import {app} from "@/firebase";
import {sessionOptions} from "@/lib/session"; import {sessionOptions} from "@/lib/session";
import {withIronSessionApiRoute} from "iron-session/next"; import {withIronSessionApiRoute} from "iron-session/next";
import {User} from "@/interfaces/user"; import {User} from "@/interfaces/user";
import {getFirestore, getDoc, doc} from "firebase/firestore";
import client from "@/lib/mongodb"; import client from "@/lib/mongodb";
const auth = getAuth(app); const auth = getAuth(app);

1
src/pages/api/make_user.ts
View File

@@ -1,6 +1,5 @@
import type {NextApiRequest, NextApiResponse} from "next"; import type {NextApiRequest, NextApiResponse} from "next";
import {app} from "@/firebase"; import {app} from "@/firebase";
import {getFirestore, setDoc, doc, query, collection, where, getDocs, getDoc, deleteDoc, limit, updateDoc} from "firebase/firestore";
import {withIronSessionApiRoute} from "iron-session/next"; import {withIronSessionApiRoute} from "iron-session/next";
import {sessionOptions} from "@/lib/session"; import {sessionOptions} from "@/lib/session";
import {v4} from "uuid"; import {v4} from "uuid";

27
src/pages/api/payments/[id].ts
View File

@@ -7,8 +7,9 @@ import {sessionOptions} from "@/lib/session";
import {Group} from "@/interfaces/user"; import {Group} from "@/interfaces/user";
import {Payment} from "@/interfaces/paypal"; import {Payment} from "@/interfaces/paypal";
import {deleteObject, ref} from "firebase/storage"; import {deleteObject, ref} from "firebase/storage";
import client from "@/lib/mongodb";
const db = getFirestore(app); const db = client.db(process.env.MONGODB_DB);
export default withIronSessionApiRoute(handler, sessionOptions); export default withIronSessionApiRoute(handler, sessionOptions);
@@ -28,10 +29,10 @@ async function get(req: NextApiRequest, res: NextApiResponse) {
const {id} = req.query as {id: string}; const {id} = req.query as {id: string};
const snapshot = await getDoc(doc(db, "payments", id)); const payment = await db.collection("payments").findOne<Payment>({id});
if (snapshot.exists()) { if (!!payment) {
res.status(200).json({...snapshot.data(), id: snapshot.id}); res.status(200).json(payment);
} else { } else {
res.status(404).json(undefined); res.status(404).json(undefined);
} }
@@ -45,15 +46,15 @@ async function del(req: NextApiRequest, res: NextApiResponse) {
const {id} = req.query as {id: string}; const {id} = req.query as {id: string};
const snapshot = await getDoc(doc(db, "payments", id)); const payment = await db.collection("payments").findOne<Payment>({id});
const data = snapshot.data() as Payment; if (!payment) return res.status(404).json({ok: false});
const user = req.session.user; const user = req.session.user;
if (user.type === "admin" || user.type === "developer") { if (user.type === "admin" || user.type === "developer") {
if (data.commissionTransfer) await deleteObject(ref(storage, data.commissionTransfer)); if (payment.commissionTransfer) await deleteObject(ref(storage, payment.commissionTransfer));
if (data.corporateTransfer) await deleteObject(ref(storage, data.corporateTransfer)); if (payment.corporateTransfer) await deleteObject(ref(storage, payment.corporateTransfer));
await deleteDoc(snapshot.ref); await db.collection("payments").deleteOne({id: payment.id});
res.status(200).json({ok: true}); res.status(200).json({ok: true});
return; return;
} }
@@ -68,15 +69,17 @@ async function patch(req: NextApiRequest, res: NextApiResponse) {
} }
const {id} = req.query as {id: string}; const {id} = req.query as {id: string};
const snapshot = await getDoc(doc(db, "payments", id));
const payment = await db.collection("payments").findOne<Payment>({id});
if (!payment) return res.status(404).json({ok: false});
const user = req.session.user; const user = req.session.user;
if (user.type === "admin" || user.type === "developer") { if (user.type === "admin" || user.type === "developer") {
await setDoc(snapshot.ref, req.body, {merge: true}); await db.collection("payments").updateOne({id: payment.id}, {$set: req.body});
if (req.body.isPaid) { if (req.body.isPaid) {
const corporateID = req.body.corporate; const corporateID = req.body.corporate;
await setDoc(doc(db, "users", corporateID), {status: "active"}, {merge: true}); await db.collection("users").updateOne({id: corporateID}, {$set: {status: "active"}});
} }
return res.status(200).json({ok: true}); return res.status(200).json({ok: true});
} }

117
src/pages/api/payments/assigned.ts
View File

@@ -1,85 +1,64 @@
// Next.js API route support: https://nextjs.org/docs/api-routes/introduction // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
import type { NextApiRequest, NextApiResponse } from "next"; import type {NextApiRequest, NextApiResponse} from "next";
import { app } from "@/firebase"; import {app} from "@/firebase";
import { import {getFirestore, collection, getDocs, query, where} from "firebase/firestore";
getFirestore, import {withIronSessionApiRoute} from "iron-session/next";
collection, import {sessionOptions} from "@/lib/session";
getDocs, import {Payment} from "@/interfaces/paypal";
query, import {PaymentsStatus} from "@/interfaces/user.payments";
where, import client from "@/lib/mongodb";
} from "firebase/firestore";
import { withIronSessionApiRoute } from "iron-session/next";
import { sessionOptions } from "@/lib/session";
import { Payment } from "@/interfaces/paypal";
import { PaymentsStatus } from "@/interfaces/user.payments";
const db = getFirestore(app); const db = client.db(process.env.MONGODB_DB);
export default withIronSessionApiRoute(handler, sessionOptions); export default withIronSessionApiRoute(handler, sessionOptions);
async function handler(req: NextApiRequest, res: NextApiResponse) { async function handler(req: NextApiRequest, res: NextApiResponse) {
if (req.method === "GET") return await get(req, res); if (req.method === "GET") return await get(req, res);
res.status(404).json(undefined); res.status(404).json(undefined);
} }
// user can fetch payments assigned to him as an agent // user can fetch payments assigned to him as an agent
async function get(req: NextApiRequest, res: NextApiResponse) { async function get(req: NextApiRequest, res: NextApiResponse) {
if (!req.session.user) { if (!req.session.user) {
res.status(401).json({ ok: false }); res.status(401).json({ok: false});
return; return;
} }
// if it's an admin, don't apply query filters const payments = await db
const whereClauses = ["admin", "developer"].includes(req.session.user.type) .collection("payments")
? [] .find(["admin", "developer"].includes(req.session.user.type) ? {} : {[req.session.user.type]: req.session.user.id})
: [ .toArray();
// where("agent", "==", "xRMirufz6PPQqxKBgvPTWiWKBD63"),
where(req.session.user.type, "==", req.session.user.id),
// Based on the logic of query we should be able to do this:
// where("isPaid", "==", paid === "paid"),
// but for some reason it is ignoring all but the first clause
// I opted into only fetching relevant content for the user
// and then filter it with JS
];
const codeQuery = query(collection(db, "payments"), ...whereClauses); if (payments.length === 0) {
res.status(200).json({
pending: [],
done: [],
});
return;
}
const snapshot = await getDocs(codeQuery); const paidStatusEntries = payments.reduce(
if (snapshot.empty) { (acc: PaymentsStatus, doc) => {
res.status(200).json({ if (doc.isPaid) {
pending: [], return {
done: [], ...acc,
}); done: [...acc.done, doc.corporate],
return; };
} }
const docs = snapshot.docs.map((doc) => ({ return {
id: doc.id, ...acc,
...doc.data(), pending: [...acc.pending, doc.corporate],
})) as Payment[]; };
},
const paidStatusEntries = docs.reduce( {
(acc: PaymentsStatus, doc) => { pending: [],
if (doc.isPaid) { done: [],
return { },
...acc, );
done: [...acc.done, doc.corporate], res.status(200).json({
}; pending: [...new Set(paidStatusEntries.pending)],
} done: [...new Set(paidStatusEntries.done)],
});
return {
...acc,
pending: [...acc.pending, doc.corporate],
};
},
{
pending: [],
done: [],
}
);
res.status(200).json({
pending: [...new Set(paidStatusEntries.pending)],
done: [...new Set(paidStatusEntries.done)],
});
} }

14
src/pages/api/payments/index.ts
View File

@@ -8,8 +8,9 @@ import {Group} from "@/interfaces/user";
import {Payment} from "@/interfaces/paypal"; import {Payment} from "@/interfaces/paypal";
import {v4} from "uuid"; import {v4} from "uuid";
import ShortUniqueId from "short-unique-id"; import ShortUniqueId from "short-unique-id";
import client from "@/lib/mongodb";
const db = getFirestore(app); const db = client.db(process.env.MONGODB_DB);
export default withIronSessionApiRoute(handler, sessionOptions); export default withIronSessionApiRoute(handler, sessionOptions);
@@ -24,20 +25,15 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
} }
async function get(req: NextApiRequest, res: NextApiResponse) { async function get(req: NextApiRequest, res: NextApiResponse) {
const snapshot = await getDocs(collection(db, "payments")); const payments = await db.collection("payments").find({}).toArray();
res.status(200).json( res.status(200).json(payments);
snapshot.docs.map((doc) => ({
id: doc.id,
...doc.data(),
})),
);
} }
async function post(req: NextApiRequest, res: NextApiResponse) { async function post(req: NextApiRequest, res: NextApiResponse) {
const body = req.body as Payment; const body = req.body as Payment;
const shortUID = new ShortUniqueId(); const shortUID = new ShortUniqueId();
await setDoc(doc(db, "payments", shortUID.randomUUID(8)), body); await db.collection("payments").insertOne({...body, id: shortUID.randomUUID(8)});
res.status(200).json({ok: true}); res.status(200).json({ok: true});
} }

32
src/pages/api/payments/paypal.ts
View File

@@ -1,30 +1,26 @@
// Next.js API route support: https://nextjs.org/docs/api-routes/introduction // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
import type { NextApiRequest, NextApiResponse } from "next"; import type {NextApiRequest, NextApiResponse} from "next";
import { app } from "@/firebase"; import {app} from "@/firebase";
import { import {getFirestore, getDocs, collection} from "firebase/firestore";
getFirestore, import {withIronSessionApiRoute} from "iron-session/next";
getDocs, import {sessionOptions} from "@/lib/session";
collection, import client from "@/lib/mongodb";
} from "firebase/firestore";
import { withIronSessionApiRoute } from "iron-session/next";
import { sessionOptions } from "@/lib/session";
const db = getFirestore(app); const db = client.db(process.env.MONGODB_DB);
export default withIronSessionApiRoute(handler, sessionOptions); export default withIronSessionApiRoute(handler, sessionOptions);
async function get(req: NextApiRequest, res: NextApiResponse) { async function get(req: NextApiRequest, res: NextApiResponse) {
const payments = await getDocs(collection(db, "paypalpayments")); const payments = await db.collection("paypalpayments").find({}).toArray();
const data = payments.docs.map((doc) => doc.data()); res.status(200).json(payments);
res.status(200).json(data);
} }
async function handler(req: NextApiRequest, res: NextApiResponse) { async function handler(req: NextApiRequest, res: NextApiResponse) {
if (!req.session.user) { if (!req.session.user) {
res.status(401).json({ ok: false }); res.status(401).json({ok: false});
return; return;
} }
if (req.method === "GET") await get(req, res); if (req.method === "GET") await get(req, res);
} }

185
src/pages/api/paypal/index.ts
View File

@@ -1,110 +1,103 @@
// Next.js API route support: https://nextjs.org/docs/api-routes/introduction // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
import type { NextApiRequest, NextApiResponse } from "next"; import type {NextApiRequest, NextApiResponse} from "next";
import { app } from "@/firebase"; import {withIronSessionApiRoute} from "iron-session/next";
import { getFirestore, collection, getDocs } from "firebase/firestore"; import {sessionOptions} from "@/lib/session";
import { withIronSessionApiRoute } from "iron-session/next";
import { sessionOptions } from "@/lib/session";
import axios from "axios"; import axios from "axios";
import { v4 } from "uuid"; import {v4} from "uuid";
import { OrderResponseBody } from "@paypal/paypal-js"; import {OrderResponseBody} from "@paypal/paypal-js";
import { getAccessToken } from "@/utils/paypal"; import {getAccessToken} from "@/utils/paypal";
const db = getFirestore(app);
export default withIronSessionApiRoute(handler, sessionOptions); export default withIronSessionApiRoute(handler, sessionOptions);
async function handler(req: NextApiRequest, res: NextApiResponse) { async function handler(req: NextApiRequest, res: NextApiResponse) {
if (req.method !== "POST") if (req.method !== "POST") return res.status(404).json({ok: false, reason: "Method not supported!"});
return res.status(404).json({ ok: false, reason: "Method not supported!" }); if (!req.session.user) return res.status(401).json({ok: false});
if (!req.session.user) return res.status(401).json({ ok: false });
const accessToken = await getAccessToken(); const accessToken = await getAccessToken();
if (!accessToken) if (!accessToken) return res.status(401).json({ok: false, reason: "Authorization failed!"});
return res.status(401).json({ ok: false, reason: "Authorization failed!" });
const { currencyCode, price, trackingId } = req.body as { const {currencyCode, price, trackingId} = req.body as {
currencyCode: string; currencyCode: string;
price: number; price: number;
trackingId: string; trackingId: string;
}; };
if (!trackingId) if (!trackingId) return res.status(401).json({ok: false, reason: "Missing tracking id!"});
return res.status(401).json({ ok: false, reason: "Missing tracking id!" });
const url = `${process.env.PAYPAL_ACCESS_TOKEN_URL}/v2/checkout/orders`; const url = `${process.env.PAYPAL_ACCESS_TOKEN_URL}/v2/checkout/orders`;
const amount = { const amount = {
currency_code: currencyCode, currency_code: currencyCode,
value: price.toString(), value: price.toString(),
}; };
const data = { const data = {
purchase_units: [ purchase_units: [
{ {
invoice_id: `INV-${v4()}`, invoice_id: `INV-${v4()}`,
amount: { amount: {
...amount, ...amount,
breakdown: { breakdown: {
item_total: amount, item_total: amount,
}, },
}, },
items: [ items: [
{ {
name: "Encoach Subscription", name: "Encoach Subscription",
quantity: "1", quantity: "1",
category: "DIGITAL_GOODS", category: "DIGITAL_GOODS",
unit_amount: amount, unit_amount: amount,
}, },
], ],
}, },
], ],
payment_source: { payment_source: {
paypal: { paypal: {
email_address: req.session.user.email || "", email_address: req.session.user.email || "",
address: { address: {
address_line_1: "", address_line_1: "",
address_line_2: "", address_line_2: "",
admin_area_1: "", admin_area_1: "",
admin_area_2: "", admin_area_2: "",
// added default values as requsted by the client, using the default values recommended // added default values as requsted by the client, using the default values recommended
// the paypal engineer, otherwise we would have to create something that would detect the location // the paypal engineer, otherwise we would have to create something that would detect the location
// of the user and generate a valid postal code for that location... // of the user and generate a valid postal code for that location...
country_code: "US", country_code: "US",
postal_code: "94107", postal_code: "94107",
}, },
experience_context: { experience_context: {
payment_method_preference: "IMMEDIATE_PAYMENT_REQUIRED", payment_method_preference: "IMMEDIATE_PAYMENT_REQUIRED",
locale: "en-US", locale: "en-US",
landing_page: "LOGIN", landing_page: "LOGIN",
shipping_preference: "NO_SHIPPING", shipping_preference: "NO_SHIPPING",
user_action: "PAY_NOW", user_action: "PAY_NOW",
brand_name: "Encoach", brand_name: "Encoach",
}, },
}, },
}, },
intent: "CAPTURE", intent: "CAPTURE",
}; };
const headers = { const headers = {
headers: { headers: {
Authorization: `Bearer ${accessToken}`, Authorization: `Bearer ${accessToken}`,
"PayPal-Client-Metadata-Id": trackingId, "PayPal-Client-Metadata-Id": trackingId,
}, },
}; };
console.log( console.log(
JSON.stringify({ JSON.stringify({
url, url,
data, data,
headers, headers,
}) }),
); );
axios axios
.post<OrderResponseBody>(url, data, headers) .post<OrderResponseBody>(url, data, headers)
.then((request) => { .then((request) => {
res.status(request.status).json(request.data); res.status(request.status).json(request.data);
}) })
.catch((err) => { .catch((err) => {
console.error(err.response.status, err.response.data); console.error(err.response.status, err.response.data);
res.status(err.response.status).json(err.response.data); res.status(err.response.status).json(err.response.data);
}); });
} }

90
src/pages/api/paypal/raas.ts
View File

@@ -1,61 +1,55 @@
// Next.js API route support: https://nextjs.org/docs/api-routes/introduction // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
import type { NextApiRequest, NextApiResponse } from "next"; import type {NextApiRequest, NextApiResponse} from "next";
import { app } from "@/firebase"; import {withIronSessionApiRoute} from "iron-session/next";
import { getFirestore, collection, getDocs } from "firebase/firestore"; import {sessionOptions} from "@/lib/session";
import { withIronSessionApiRoute } from "iron-session/next";
import { sessionOptions } from "@/lib/session";
import axios from "axios"; import axios from "axios";
import { v4 } from "uuid"; import {v4} from "uuid";
import { OrderResponseBody } from "@paypal/paypal-js"; import {OrderResponseBody} from "@paypal/paypal-js";
import { getAccessToken } from "@/utils/paypal"; import {getAccessToken} from "@/utils/paypal";
const db = getFirestore(app);
export default withIronSessionApiRoute(handler, sessionOptions); export default withIronSessionApiRoute(handler, sessionOptions);
async function handler(req: NextApiRequest, res: NextApiResponse) { async function handler(req: NextApiRequest, res: NextApiResponse) {
if (req.method !== "PUT") if (req.method !== "PUT") return res.status(404).json({ok: false, reason: "Method not supported!"});
return res.status(404).json({ ok: false, reason: "Method not supported!" });
if (!req.session.user) return res.status(401).json({ ok: false }); if (!req.session.user) return res.status(401).json({ok: false});
const accessToken = await getAccessToken(); const accessToken = await getAccessToken();
if (!accessToken) if (!accessToken) return res.status(401).json({ok: false, reason: "Authorization failed!"});
return res.status(401).json({ ok: false, reason: "Authorization failed!" });
const trackingId = `${req.session.user.id}-${Date.now()}`; const trackingId = `${req.session.user.id}-${Date.now()}`;
const url = `${process.env.PAYPAL_ACCESS_TOKEN_URL}/v1/risk/transaction-contexts/${process.env.PAYPAL_MERCHANT_ID}/${trackingId}`; const url = `${process.env.PAYPAL_ACCESS_TOKEN_URL}/v1/risk/transaction-contexts/${process.env.PAYPAL_MERCHANT_ID}/${trackingId}`;
const data = { const data = {
additional_data: [ additional_data: [
{ {
key: "user_id", key: "user_id",
value: req.session.user.id, value: req.session.user.id,
}, },
], ],
}; };
const headers = { const headers = {
headers: { headers: {
Authorization: `Bearer ${accessToken}`, Authorization: `Bearer ${accessToken}`,
}, },
}; };
console.log(JSON.stringify({ console.log(
url, JSON.stringify({
data, url,
headers, data,
})); headers,
try { }),
const request = await axios.put(url, data, headers); );
try {
const request = await axios.put(url, data, headers);
return res.status(request.status).json({ return res.status(request.status).json({
ok: true, ok: true,
trackingId, trackingId,
}); });
} catch (err) { } catch (err) {
console.error(url, err); console.error(url, err);
return res return res.status(500).json({ok: false, reason: "Failed to create tracking ID"});
.status(500) }
.json({ ok: false, reason: "Failed to create tracking ID" });
}
} }

51
src/pages/api/permissions/bootstrap.ts
View File

@@ -1,43 +1,28 @@
// Next.js API route support: https://nextjs.org/docs/api-routes/introduction // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
import type { NextApiRequest, NextApiResponse } from "next"; import type {NextApiRequest, NextApiResponse} from "next";
import { app } from "@/firebase"; import {withIronSessionApiRoute} from "iron-session/next";
import { import {sessionOptions} from "@/lib/session";
getFirestore, import {Permission} from "@/interfaces/permissions";
collection, import {bootstrap} from "@/utils/permissions.be";
getDocs,
query,
where,
doc,
setDoc,
addDoc,
getDoc,
deleteDoc,
} from "firebase/firestore";
import { withIronSessionApiRoute } from "iron-session/next";
import { sessionOptions } from "@/lib/session";
import { Permission } from "@/interfaces/permissions";
import { bootstrap } from "@/utils/permissions.be";
const db = getFirestore(app);
export default withIronSessionApiRoute(handler, sessionOptions); export default withIronSessionApiRoute(handler, sessionOptions);
async function handler(req: NextApiRequest, res: NextApiResponse) { async function handler(req: NextApiRequest, res: NextApiResponse) {
if (req.method === "GET") return get(req, res); if (req.method === "GET") return get(req, res);
} }
async function get(req: NextApiRequest, res: NextApiResponse) { async function get(req: NextApiRequest, res: NextApiResponse) {
if (!req.session.user) { if (!req.session.user) {
res.status(401).json({ ok: false }); res.status(401).json({ok: false});
return; return;
} }
console.log("Boostrap"); console.log("Boostrap");
try { try {
await bootstrap(); await bootstrap();
return res.status(200).json({ ok: true }); return res.status(200).json({ok: true});
} catch (err) { } catch (err) {
console.error("Failed to update permissions", err); console.error("Failed to update permissions", err);
return res.status(500).json({ ok: false }); return res.status(500).json({ok: false});
} }
} }

1
src/pages/api/register.ts
View File

@@ -3,7 +3,6 @@ import {createUserWithEmailAndPassword, getAuth} from "firebase/auth";
import {app} from "@/firebase"; import {app} from "@/firebase";
import {sessionOptions} from "@/lib/session"; import {sessionOptions} from "@/lib/session";
import {withIronSessionApiRoute} from "iron-session/next"; import {withIronSessionApiRoute} from "iron-session/next";
import {getFirestore, doc, setDoc, query, collection, where, getDocs} from "firebase/firestore";
import {Code, CorporateInformation, DemographicInformation, Group, Type} from "@/interfaces/user"; import {Code, CorporateInformation, DemographicInformation, Group, Type} from "@/interfaces/user";
import {addUserToGroupOnCreation} from "@/utils/registration"; import {addUserToGroupOnCreation} from "@/utils/registration";
import moment from "moment"; import moment from "moment";

1
src/pages/api/storage/delete.ts
View File

@@ -1,7 +1,6 @@
// Next.js API route support: https://nextjs.org/docs/api-routes/introduction // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
import type {NextApiRequest, NextApiResponse} from "next"; import type {NextApiRequest, NextApiResponse} from "next";
import {app} from "@/firebase"; import {app} from "@/firebase";
import {getFirestore, doc, getDoc, deleteDoc} from "firebase/firestore";
import {withIronSessionApiRoute} from "iron-session/next"; import {withIronSessionApiRoute} from "iron-session/next";
import {sessionOptions} from "@/lib/session"; import {sessionOptions} from "@/lib/session";
import {Session} from "@/hooks/useSessions"; import {Session} from "@/hooks/useSessions";

4
src/pages/api/storage/insert.ts
View File

@@ -7,11 +7,7 @@ import formidable from "formidable-serverless";
import {getDownloadURL, ref, uploadBytes} from "firebase/storage"; import {getDownloadURL, ref, uploadBytes} from "firebase/storage";
import fs from "fs"; import fs from "fs";
import {app, storage} from "@/firebase"; import {app, storage} from "@/firebase";
import {doc, getDoc, getFirestore, setDoc} from "firebase/firestore";
import {Stat} from "@/interfaces/user";
import {speakingReverseMarking} from "@/utils/score";
const db = getFirestore(app);
export default withIronSessionApiRoute(handler, sessionOptions); export default withIronSessionApiRoute(handler, sessionOptions);
async function handler(req: NextApiRequest, res: NextApiResponse) { async function handler(req: NextApiRequest, res: NextApiResponse) {

65
src/pages/api/user.ts
View File

@@ -7,9 +7,11 @@ import {getAuth} from "firebase-admin/auth";
import {withIronSessionApiRoute} from "iron-session/next"; import {withIronSessionApiRoute} from "iron-session/next";
import {NextApiRequest, NextApiResponse} from "next"; import {NextApiRequest, NextApiResponse} from "next";
import {getPermissions, getPermissionDocs} from "@/utils/permissions.be"; import {getPermissions, getPermissionDocs} from "@/utils/permissions.be";
import client from "@/lib/mongodb";
import {getGroupsForUser, getParticipantGroups} from "@/utils/groups.be";
const db = getFirestore(app);
const auth = getAuth(adminApp); const auth = getAuth(adminApp);
const db = client.db(process.env.MONGODB_DB);
export default withIronSessionApiRoute(user, sessionOptions); export default withIronSessionApiRoute(user, sessionOptions);
@@ -28,36 +30,26 @@ async function del(req: NextApiRequest, res: NextApiResponse) {
const {id} = req.query as {id: string}; const {id} = req.query as {id: string};
const docUser = await getDoc(doc(db, "users", req.session.user.id)); const user = await db.collection("users").findOne<User>({id: req.session.user.id});
if (!docUser.exists()) { if (!user) {
res.status(401).json({ok: false}); res.status(401).json({ok: false});
return; return;
} }
const user = docUser.data() as User; const targetUser = await db.collection("users").findOne<User>({id});
if (!targetUser) {
const docTargetUser = await getDoc(doc(db, "users", id));
if (!docTargetUser.exists()) {
res.status(404).json({ok: false}); res.status(404).json({ok: false});
return; return;
} }
const targetUser = {...docTargetUser.data(), id: docTargetUser.id} as User;
if (user.type === "corporate" && (targetUser.type === "student" || targetUser.type === "teacher")) { if (user.type === "corporate" && (targetUser.type === "student" || targetUser.type === "teacher")) {
const userParticipantGroup = await getDocs(query(collection(db, "groups"), where("participants", "array-contains", id))); const groups = await getGroupsForUser(user.id, targetUser.id);
await Promise.all([ await Promise.all([
...userParticipantGroup.docs ...groups
.filter((x) => (x.data() as Group).admin === user.id) .filter((x) => x.admin === user.id)
.map( .map(
async (x) => async (x) =>
await setDoc( await db.collection("groups").updateOne({id: x.id}, {$set: {participants: x.participants.filter((y: string) => y !== id)}}),
x.ref,
{
participants: x.data().participants.filter((y: string) => y !== id),
},
{merge: true},
),
), ),
]); ]);
@@ -65,41 +57,30 @@ async function del(req: NextApiRequest, res: NextApiResponse) {
} }
await auth.deleteUser(id); await auth.deleteUser(id);
await deleteDoc(doc(db, "users", id)); await db.collection("users").deleteOne({id: targetUser.id});
const userCodeDocs = await getDocs(query(collection(db, "codes"), where("userId", "==", id))); await db.collection("codes").deleteMany({userId: targetUser.id});
const userParticipantGroup = await getDocs(query(collection(db, "groups"), where("participants", "array-contains", id))); await db.collection("groups").deleteMany({admin: targetUser.id});
const userGroupAdminDocs = await getDocs(query(collection(db, "groups"), where("admin", "==", id))); await db.collection("stats").deleteMany({user: targetUser.id});
const userStatsDocs = await getDocs(query(collection(db, "stats"), where("user", "==", id)));
await Promise.all([ const groups = await getParticipantGroups(targetUser.id);
...userCodeDocs.docs.map(async (x) => await deleteDoc(x.ref)), await Promise.all(
...userGroupAdminDocs.docs.map(async (x) => await deleteDoc(x.ref)), groups.map(
...userStatsDocs.docs.map(async (x) => await deleteDoc(x.ref)), async (x) => await db.collection("groups").updateOne({id: x.id}, {$set: {participants: x.participants.filter((y: string) => y !== id)}}),
...userParticipantGroup.docs.map(
async (x) =>
await setDoc(
x.ref,
{
participants: x.data().participants.filter((y: string) => y !== id),
},
{merge: true},
),
), ),
]); );
res.json({ok: true}); res.json({ok: true});
} }
async function get(req: NextApiRequest, res: NextApiResponse) { async function get(req: NextApiRequest, res: NextApiResponse) {
if (req.session.user) { if (req.session.user) {
const docUser = await getDoc(doc(db, "users", req.session.user.id)); const user = await db.collection("users").findOne<User>({id: req.session.user.id});
if (!docUser.exists()) { if (!user) {
res.status(401).json(undefined); res.status(401).json(undefined);
return; return;
} }
const user = docUser.data() as User; await db.collection("users").updateOne({id: user.id}, {$set: {lastLogin: new Date().toISOString()}});
await setDoc(docUser.ref, {lastLogin: new Date().toISOString()}, {merge: true});
req.session.user = { req.session.user = {
...user, ...user,

1
src/utils/registration.ts
View File

@@ -1,4 +1,3 @@
import {collection, doc, getDoc, getDocs, getFirestore, query, setDoc, where} from "firebase/firestore";
import {app} from "@/firebase"; import {app} from "@/firebase";
import {Group, Type, User} from "@/interfaces/user"; import {Group, Type, User} from "@/interfaces/user";
import {uuidv4} from "@firebase/util"; import {uuidv4} from "@firebase/util";

19
src/utils/users.be.ts
View File

@@ -1,22 +1,3 @@
import {app} from "@/firebase";
import {
collection,
doc,
documentId,
endAt,
endBefore,
getCountFromServer,
getDoc,
getDocs,
getFirestore,
limit,
orderBy,
query,
startAfter,
startAt,
where,
} from "firebase/firestore";
import {CorporateUser, Group, Type, User} from "@/interfaces/user"; import {CorporateUser, Group, Type, User} from "@/interfaces/user";
import {getGroupsForUser, getParticipantGroups, getUserGroups, getUsersGroups} from "./groups.be"; import {getGroupsForUser, getParticipantGroups, getUserGroups, getUsersGroups} from "./groups.be";
import {last, uniq, uniqBy} from "lodash"; import {last, uniq, uniqBy} from "lodash";