Wir untersuchen, wie ein bestehender Beitrag über die Route "UPDATE POST BY ID" in der Datei postsRoutes.js aktualisiert werden kann. Diese Route ermöglicht das Aktualisieren eines Beitrags anhand seiner eindeutigen ID.

Routen-Definition

Der folgende Code definiert die Route "UPDATE POST BY ID" mit router.put():

router.put("/post/:id", validatePostData, async (req, res, next) => { ... }

• Diese Route ist für HTTP PUT-Anfragen konfiguriert, speziell zum Aktualisieren von Beiträgen;
• Im Routenpfad ist ein parametrisierter :id-Wert enthalten, um den zu aktualisierenden Beitrag zu identifizieren;
• Die Middleware validatePostData wird hinzugefügt, um die Datenvalidierung vor der weiteren Verarbeitung sicherzustellen. Die Logik der Middleware validatePostData bleibt wie im vorherigen Schritt unverändert.

Daten aus der Anfrage extrahieren

Hier werden die erforderlichen Daten aus der Anfrage extrahiert, einschließlich der Post-ID und des aktualisierten Beitragsinhalts:

const postId = req.params.id;
const updatedData = {
  username: req.body.username,
  postTitle: req.body.postTitle,
  postContent: req.body.postContent,
};

• Die Post-ID wird aus den Anfrageparametern extrahiert und steht für die weitere Verarbeitung zur Verfügung. Der :id-Parameter aus der Routen-URL wird mit req.params.id abgefragt;
• Die Werte für username, postTitle und postContent werden aus dem Anfrage-Body extrahiert.

Beitrag in der Datenbank aktualisieren

Das Aktualisieren eines bestehenden Beitrags umfasst mehrere Schritte, wie unten dargestellt:

const data = await readData();

const postIndex = data.findIndex((post) => post.id === postId);

if (postIndex === -1) {
  return res.status(404).json({ error: "Post not found" });
}

data[postIndex] = {
  ...data[postIndex],
  ...updatedData,
};

await fs.writeFile("./database/posts.json", JSON.stringify(data));

• Die vorhandenen Daten werden mit der asynchronen Funktion readData aus der JSON-Datei gelesen, wie zuvor erläutert;
• Die Variable postIndex speichert den Index des zu aktualisierenden Beitrags im Array data durch Vergleich der Post-IDs;
• Wird der Beitrag nicht gefunden (d.h. postIndex === -1), wird eine 404-Fehlermeldung (Nicht gefunden) an den Client zurückgegeben;
• Zur Aktualisierung der Beitragsdaten werden die bestehenden Daten (...data[postIndex]) mit den aktualisierten Daten (...updatedData) zusammengeführt. Dadurch werden nur die angegebenen Felder aktualisiert und vorhandene Daten beibehalten;
• Abschließend wird das aktualisierte data-Array zurück in die JSON-Datei geschrieben, um die vorgenommenen Änderungen zu speichern.

Antwort senden

Nach erfolgreicher Aktualisierung des Beitrags wird eine JSON-Antwort an den Client gesendet. Die Antwort enthält den Statuscode 200 (OK), der eine erfolgreiche Aktualisierung und die aktualisierten Beitragsdaten signalisiert.

res.status(200).json(data[postIndex]);

Fehlerbehandlung

Der Routencode wird in einen try-catch-Block eingebettet, um potenzielle Fehler während der Datenabfrage oder der Anfrageverarbeitung abzufangen. Auftretende Fehler werden zur Fehlersuche in der Konsole protokolliert:

try {
  // ... (code for retrieving and processing data)
} catch (error) {
  console.error(error.message);
}

Vollständiger Code der Datei postsRoutes.js in diesem Schritt

const express = require("express");
const fs = require("fs/promises");
const validatePostData = require("../middlewares/validateData");

const router = express.Router();

// Function to read data from the JSON file
async function readData() {
  try {
    // Read the contents of the `posts.json` file
    const data = await fs.readFile("./database/posts.json");
    // Parse the JSON data into a JavaScript object
    return JSON.parse(data);
  } catch (error) {
    // If an error occurs during reading or parsing, throw the error
    throw error;
  }
}

// GET ALL POSTS
router.get("/", async (req, res, next) => {
  try {
    // Call the `readData` function to retrieve the list of posts
    const data = await readData();
    // Send the retrieved data as the response
    res.status(200).send(data);
  } catch (error) {
    // If an error occurs during data retrieval or sending the response
    console.error(error.message); // Log the error to the console for debugging
  }
});

// GET POST BY ID
router.get("/post/:id", async (req, res, next) => {
  try {
    // Extract the post ID from the request parameters
    const postId = req.params.id;
    // Read data from the JSON file
    const data = await readData();

    // Find the post with the matching ID
    const post = data.find((post) => post.id === postId);

    // If the post is not found, send a 404 response
    if (!post) {
      res.status(404).json({ error: "Post not found" });
    } else {
      // If the post is found, send it as the response
      res.status(200).send(post);
    }
  } catch (error) {
    // Handle errors by logging them and sending an error response
    console.error(error.message);
  }
});

// CREATE POST
router.post("/", validatePostData, async (req, res, next) => {
  try {
    const newPost = {
      id: Date.now().toString(), // Generate a unique ID for the new post
      username: req.body.username,
      postTitle: req.body.postTitle,
      postContent: req.body.postContent,
    };

    // Read the existing data
    const data = await readData();

    // Add the new post to the data
    data.push(newPost);

    // Write the updated data back to the JSON file
    await fs.writeFile("./database/posts.json", JSON.stringify(data));

    // Send a success response with the new post
    res.status(201).json(newPost);
  } catch (error) {
    // Handle errors by logging them to the console
    console.error(error.message);
  }
});

// UPDATE POST BY ID
router.put("/post/:id", validatePostData, async (req, res, next) => {
  try {
    // Extract the post ID from the request parameters
    const postId = req.params.id;
    // Extract the updated data from the request body
    const updatedData = {
      username: req.body.username,
      postTitle: req.body.postTitle,
      postContent: req.body.postContent,
    };

    // Read the existing data
    const data = await readData();

    // Find the index of the post with the specified ID in the data array
    const postIndex = data.findIndex((post) => post.id === postId);

    // If the post with the specified ID doesn't exist, return a 404 error
    if (postIndex === -1) {
      return res.status(404).json({ error: "Post not found" });
    }

    // Update the post data with the new data using spread syntax
    data[postIndex] = {
      ...data[postIndex], // Keep existing data
      ...updatedData, // Apply updated data
    };

    // Write the updated data back
    await fs.writeFile("./database/posts.json", JSON.stringify(data));

    // Send a success response with the updated post
    res.status(200).json(data[postIndex]);
  } catch (error) {
    console.error(error.message);
    next(error);
  }
});