Feat/content backend

.gitignore

@@ -1,2 +1,3 @@
 /node_modules
 .DS_Store
+.env

client/.gitignore

@@ -22,5 +22,3 @@ dist-ssr
 *.njsproj
 *.sln
 *.sw?
-
-.env

client/src/pages/Faq.tsx

@@ -1,15 +1,47 @@
+import React, { useState, useEffect } from "react";
 import Collapsible from "../components/Collapsible";
+import api from "../api";
 
 import "../style/faq.css";
 import "../style/common.css";
-import faqs from "../placeholders/faqs.json";
+
+interface Faq {
+  question: string;
+  answer: string;
+}
+
+function parseFaq(content: string): Faq[] {
+  const lines = content.split("\n");
+  const faqs: Faq[] = [];
+  let current: Faq | null = null;
+
+  for (const line of lines) {
+    if (line.startsWith("#")) {
+      if (current) faqs.push(current);
+      current = { question: line.slice(1).trim(), answer: "" };
+    } else if (current) {
+      current.answer += (current.answer ? "\n" : "") + line;
+    }
+  }
+
+  if (current) faqs.push(current);
+  return faqs;
+}
 
 const Faq = () => {
+  const [faqs, setFaqs] = useState<Faq[]>([]);
+
+  useEffect(() => {
+    api
+      .get<{ content: string }[]>("/faqs")
+      .then((res) => setFaqs(res.data.flatMap((faq) => parseFaq(faq.content))))
+      .catch((err) => console.error("Failed to fetch faqs:", err));
+  }, []);
+
   return (
     <div className="faq-container bg-yellow-light">
       {/** title */}
       <section className="faq-title">F&nbsp;A&nbsp;Q&nbsp;s</section>
-
       {/** faq items */}
       <section className="faq-list">
         {faqs.map((item, index) => (

server/.gitignore

@@ -1,3 +1,2 @@
 node_modules
 build
-.env

server/src/controllers/contentController.ts

@@ -0,0 +1,88 @@
+import { RequestHandler } from "express";
+import { Content } from "../model/content";
+
+const CACHE_TTL_MS = 1000 * 60 * 60 * 24 * 7;
+
+let contentCache: { data: unknown[]; expiresAt: number } | null = null;
+let contentCacheStale = false;
+
+const markContentCacheStale = () => {
+  contentCacheStale = true;
+};
+
+export const getContents: RequestHandler = async (req, res) => {
+  try {
+    if (
+      contentCache &&
+      !contentCacheStale &&
+      Date.now() < contentCache.expiresAt
+    ) {
+      res.json(contentCache.data);
+      return;
+    }
+    const contents = await Content.find().lean();
+    contentCache = { data: contents, expiresAt: Date.now() + CACHE_TTL_MS };
+    contentCacheStale = false;
+    res.json(contents);
+  } catch (error) {
+    console.error("Error fetching contents:", error);
+    res.status(500).json({ message: "Failed to fetch contents" });
+  }
+};
+
+export const createContent: RequestHandler = async (req, res) => {
+  try {
+    const content = await Content.create(req.body);
+    markContentCacheStale();
+    res.status(201).json(content);
+  } catch (error) {
+    console.error("Error creating content:", error);
+    res.status(500).json({ message: "Failed to create content" });
+  }
+};
+
+export const updateContent: RequestHandler = async (req, res) => {
+  try {
+    const updated = await Content.findByIdAndUpdate(req.params.id, req.body, {
+      returnDocument: "after",
+    }).lean();
+    if (!updated) {
+      res.status(404).json({ message: "Content not found" });
+      return;
+    }
+    markContentCacheStale();
+    res.json(updated);
+  } catch (error) {
+    console.error("Error updating content: ", error);
+    res.status(500).json({ message: "Failed to update content" });
+  }
+};
+
+export const deleteContent: RequestHandler = async (req, res) => {
+  try {
+    const deleted = await Content.findByIdAndDelete(req.params.id);
+    if (!deleted) {
+      res.status(404).json({ message: "Content not found" });
+      return;
+    }
+    markContentCacheStale();
+    res.json({ message: "Content deleted successfully" });
+  } catch (error) {
+    console.error("Error deleting content: ", error);
+    res.status(500).json({ message: "Failed to delete content" });
+  }
+};
+
+export const deleteAllContents: RequestHandler = async (req, res) => {
+  try {
+    const result = await Content.deleteMany({});
+    markContentCacheStale();
+    res.json({
+      message: "All contents deleted successfully",
+      deletedCount: result.deletedCount,
+    });
+  } catch (error) {
+    console.error("Error deleting all contents: ", error);
+    res.status(500).json({ message: "Failed to delete all contents" });
+  }
+};

server/src/controllers/faqController.ts

@@ -0,0 +1,81 @@
+import { RequestHandler } from "express";
+import { Faq } from "../model/faq";
+
+const CACHE_TTL_MS = 1000 * 60 * 60 * 24 * 7;
+
+let faqCache: { data: unknown[]; expiresAt: number } | null = null;
+let faqCacheStale = false;
+
+const markFaqCacheStale = () => {
+  faqCacheStale = true;
+};
+
+export const getFaqs: RequestHandler = async (req, res) => {
+  try {
+    if (faqCache && !faqCacheStale && Date.now() < faqCache.expiresAt) {
+      res.json(faqCache.data);
+      return;
+    }
+    const faqs = await Faq.find().lean();
+    faqCache = { data: faqs, expiresAt: Date.now() + CACHE_TTL_MS };
+    faqCacheStale = false;
+    res.json(faqs);
+  } catch (error) {
+    console.error("Error fetching FAQs:", error);
+    res.status(500).json({ message: "Failed to fetch FAQs" });
+  }
+};
+
+export const createFaq: RequestHandler = async (req, res) => {
+  try {
+    const faq = await Faq.create(req.body);
+    markFaqCacheStale();
+    res.status(201).json(faq);
+  } catch (error) {
+    console.error("Error creating FAQ:", error);
+    res.status(500).json({ message: "Failed to create FAQ" });
+  }
+};
+
+export const updateFaq: RequestHandler = async (req, res) => {
+  try {
+    const updated = await Faq.findByIdAndUpdate(req.params.id, req.body, {
+      returnDocument: "after",
+    }).lean();
+    if (!updated) {
+      res.status(404).json({ message: "FAQ not found" });
+      return;
+    }
+    markFaqCacheStale();
+    res.json(updated);
+  } catch (error) {
+    console.error("Error updating FAQ: ", error);
+    res.status(500).json({ message: "Failed to update FAQ" });
+  }
+};
+
+export const deleteFaq: RequestHandler = async (req, res) => {
+  try {
+    const deleted = await Faq.findByIdAndDelete(req.params.id);
+    if (!deleted) {
+      res.status(404).json({ message: "FAQ not found" });
+      return;
+    }
+    markFaqCacheStale();
+    res.json({ message: "FAQ deleted successfully" });
+  } catch (error) {
+    console.error("Error deleting FAQ: ", error);
+    res.status(500).json({ message: "Failed to delete FAQ" });
+  }
+};
+
+export const deleteAllFaqs: RequestHandler = async(req, res) => {
+  try {
+    const result = await Faq.deleteMany({});
+    markFaqCacheStale();
+    res.json({message: "All FAQs deleted successfully", deletedCount: result.deletedCount });
+  } catch (error) {
+    console.error("Error deleting all FAQs: ", error);
+    res.status(500).json({message: "Failed to delete all FAQs"});
+  }
+};

server/src/index.ts

@@ -7,6 +7,8 @@ import { Strategy as GoogleStrategy } from "passport-google-oauth20";
 import authRoutes from "./routes/authRoutes";
 import imageRoutes from "./routes/imageRoutes";
 import executivesRoutes from "./routes/executivesRoutes";
+import faqRoutes from "./routes/faqRoutes";
+import contentRoutes from "./routes/contentRoutes";
 import paymentRoutes from "./routes/paymentRoutes";
 import webhookRoutes from "./routes/webhookRoutes";
 import sponsorRoutes from "./routes/sponsorRoutes";
@@ -68,6 +70,8 @@ app.use(express.json());
 app.use("/api/auth", authRoutes);
 app.use("/api/images", imageRoutes);
 app.use("/api/executives", executivesRoutes);
+app.use("/api/faqs", faqRoutes);
+app.use("/api/contents", contentRoutes);
 app.use("/api/payments", paymentRoutes);
 app.use("/api/sponsors", sponsorRoutes);
 app.use("/api/contacts", contactRoutes);

server/src/model/content.ts

@@ -0,0 +1,12 @@
+import mongoose from "mongoose";
+const { Schema, model } = mongoose;
+
+const contentSchema = new Schema(
+  {
+    _id: { type: String, required: true },
+    content: { type: String, required: true },
+  },
+  { versionKey: false, timestamps: true }
+);
+
+export const Content = model("Content", contentSchema);

server/src/model/faq.ts

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+const { Schema, model } = mongoose;
+
+const faqSchema = new Schema(
+  {
+    content: { type: String, required: true },
+  },
+  { versionKey: false, timestamps: true }
+);
+
+export const Faq = model("Faq", faqSchema);

server/src/routes/contentRoutes.ts

@@ -0,0 +1,17 @@
+import express from "express";
+import {
+  getContents,
+  createContent,
+  updateContent,
+  deleteContent,
+  deleteAllContents,
+} from "../controllers/contentController";
+
+const router = express.Router();
+router.get("/", getContents);
+router.post("/", createContent);
+router.put("/:id", updateContent);
+router.delete("/:id", deleteContent);
+router.delete("/", deleteAllContents);
+
+export default router;

server/src/routes/faqRoutes.ts

@@ -0,0 +1,17 @@
+import express from "express";
+import {
+  getFaqs,
+  createFaq,
+  updateFaq,
+  deleteFaq,
+  deleteAllFaqs,
+} from "../controllers/faqController";
+
+const router = express.Router();
+router.get("/", getFaqs);
+router.post("/", createFaq);
+router.put("/:id", updateFaq);
+router.delete("/:id", deleteFaq);
+router.delete("/", deleteAllFaqs);
+
+export default router;