avatarciao 1.0.0

package/FS/basics.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+
+const baseDir = __dirname;
+const filePath = path.join(baseDir, 'sample.txt');
+const renamedFilePath = path.join(baseDir, 'renamed.txt');
+const folderPath = path.join(baseDir, 'demoFolder');
+const copyFolder = path.join(baseDir, 'backups');
+const copiedFilePath = path.join(copyFolder, 'copied.txt');
+
+fs.writeFile(filePath, 'Hello FS Module', () => {
+  fs.appendFile(filePath, '\nAppending new data', () => {
+    fs.readFile(filePath, 'utf8', (_, data) => {
+      console.log('\nREAD FILE:\n', data);
+
+      fs.rename(filePath, renamedFilePath, () => {
+        if (!fs.existsSync(folderPath)) {
+          fs.mkdirSync(folderPath);
+        }
+
+        fs.copyFile(renamedFilePath, path.join(folderPath, 'inside.txt'), () => {
+          if (!fs.existsSync(copyFolder)) {
+            fs.mkdirSync(copyFolder);
+          }
+
+          fs.copyFile(renamedFilePath, copiedFilePath, () => {
+            fs.stat(renamedFilePath, (_, stats) => {
+              console.log('\nFILE SIZE:', stats.size);
+
+              fs.readdir(baseDir, (_, files) => {
+                console.log('\nDIRECTORY FILES:', files);
+
+                const readStream = fs.createReadStream(renamedFilePath, 'utf8');
+                const writeStream = fs.createWriteStream(path.join(baseDir, 'stream.txt'));
+
+                readStream.pipe(writeStream);
+
+                setTimeout(() => {
+                  fs.unlink(renamedFilePath, () => {
+                    fs.rm(folderPath, { recursive: true, force: true }, () => {
+                      fs.rm(copyFolder, { recursive: true, force: true }, () => {
+                        console.log('\nALL FS OPERATIONS COMPLETED');
+                      });
+                    });
+                  });
+                }, 500);
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+});

package/FS/copyFile.js

@@ -0,0 +1,18 @@
+const fs = require('fs');
+const path = require('path');
+
+const sourceFile = path.join(__dirname, 'report.pdf');
+const backupDir = path.join(__dirname, 'backups');
+const destinationFile = path.join(backupDir, 'report.pdf');
+
+if (!fs.existsSync(backupDir)) {
+  fs.mkdirSync(backupDir);
+}
+
+fs.copyFile(sourceFile, destinationFile, (err) => {
+  if (err) {
+    console.error('Error copying file:', err.message);
+  } else {
+    console.log('File copied successfully to backups/report.pdf');
+  }
+});

package/FS/periodicLogger.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+
+const fileName = 'activity.log';
+
+function getFormattedTime() {
+  const now = new Date();
+
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  const seconds = String(now.getSeconds()).padStart(2, '0');
+
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+
+setInterval(() => {
+  const timeStamp = getFormattedTime();
+  const logEntry = `log entry at ${timeStamp}\n`;
+
+  fs.appendFile(fileName, logEntry, (err) => {
+    if (err) {
+      console.error('Error writing to file:', err);
+    } else {
+      console.log('Logged:', logEntry.trim());
+    }
+  });
+}, 10000);

package/Http/BasicsOfHttp.js

@@ -0,0 +1,73 @@
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+
+const options = {
+  key: fs.readFileSync(path.join(__dirname, "key.pem")),
+  cert: fs.readFileSync(path.join(__dirname, "cert.pem"))
+};
+
+function readFileData(filePath, callback) {
+  fs.readFile(filePath, "utf8", callback);
+}
+
+function writeFileData(filePath, data, callback) {
+  fs.writeFile(filePath, data, callback);
+}
+
+function appendFileData(filePath, data, callback) {
+  fs.appendFile(filePath, data, callback);
+}
+
+const server = https.createServer(options, (req, res) => {
+  if (req.method === "GET" && req.url === "/read") {
+    readFileData("data.txt", (err, data) => {
+      if (err) {
+        res.writeHead(500);
+        res.end("Error reading file");
+      } else {
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        res.end(data);
+      }
+    });
+  }
+
+  else if (req.method === "POST" && req.url === "/write") {
+    let body = "";
+    req.on("data", chunk => body += chunk);
+    req.on("end", () => {
+      writeFileData("data.txt", body, err => {
+        if (err) {
+          res.writeHead(500);
+          res.end("Error writing file");
+        } else {
+          res.writeHead(200);
+          res.end("File written");
+        }
+      });
+    });
+  }
+
+  else if (req.method === "POST" && req.url === "/append") {
+    let body = "";
+    req.on("data", chunk => body += chunk);
+    req.on("end", () => {
+      appendFileData("data.txt", body, err => {
+        if (err) {
+          res.writeHead(500);
+          res.end("Error appending file");
+        } else {
+          res.writeHead(200);
+          res.end("File appended");
+        }
+      });
+    });
+  }
+
+  else {
+    res.writeHead(404);
+    res.end("Not Found");
+  }
+});
+
+server.listen(3000);

package/Http/getPostHandling.js

@@ -0,0 +1,44 @@
+const http = require("http");
+const querystring = require("querystring");
+
+const server = http.createServer((req, res) => {
+  if (req.url === "/form" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(`
+      <h2>User Form</h2>
+      <form method="POST" action="/form">
+        <label>Name:</label><br/>
+        <input type="text" name="name" required /><br/><br/>
+        
+        <label>Email:</label><br/>
+        <input type="email" name="email" required /><br/><br/>
+        
+        <button type="submit">Submit</button>
+      </form>
+    `);
+  }
+
+  else if (req.url === "/form" && req.method === "POST") {
+    let body = "";
+    req.on("data", chunk => {
+      body += chunk.toString();
+    });
+
+    req.on("end", () => {
+      const parsedData = querystring.parse(body);
+      const { name, email } = parsedData;
+
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end(`Thank you, ${name}. Your email is ${email}.`);
+    });
+  }
+
+  else {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("404 Not Found");
+  }
+});
+
+server.listen(3000, () => {
+  console.log("Server running at http://localhost:3000/form");
+});

package/Http/serveFiles.js

@@ -0,0 +1,34 @@
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+
+const server = http.createServer((req, res) => {
+  if (req.url.startsWith("/public/")) {
+    const filePath = path.join(__dirname, req.url);
+
+    fs.readFile(filePath, (err, data) => {
+      if (err) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("404 Not Found");
+      } else {
+        const ext = path.extname(filePath);
+        const mimeTypes = {
+          ".css": "text/css",
+          ".js": "text/javascript",
+          ".png": "image/png",
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".gif": "image/gif",
+          ".html": "text/html"
+        };
+        res.writeHead(200, { "Content-Type": mimeTypes[ext] || "text/plain" });
+        res.end(data);
+      }
+    });
+  } else {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("404 Not Found");
+  }
+});
+
+server.listen(3000);

package/JWT/u1.js

@@ -0,0 +1,78 @@
+const express = require("express");
+const jwt = require("jsonwebtoken");
+const cookieParser = require("cookie-parser");
+const bodyParser = require("body-parser");
+const fs = require("fs");
+
+const app = express();
+const PORT = 3000;
+const SECRET_KEY = "mysecretkey";
+
+app.use(bodyParser.json());
+app.use(cookieParser());
+
+const users = JSON.parse(fs.readFileSync("./users.json", "utf-8"));
+
+app.post("/login", (req, res) => {
+  const { username, password } = req.body;
+
+  const user = users.find(
+    u => u.username === username && u.password === password
+  );
+
+  if (!user) {
+    return res.status(401).json({ message: "Invalid username or password" });
+  }
+
+  const token = jwt.sign(
+    {
+      username: user.username,
+      role: user.role,
+      loginTime: new Date().toISOString()
+    },
+    SECRET_KEY,
+    { expiresIn: "1h" }
+  );
+
+  res.cookie("token", token, { httpOnly: true });
+
+  res.json({
+    redirect: user.role === "admin" ? "/adminhome" : "/userhome"
+  });
+});
+
+function verifyJWT(req, res, next) {
+  const token = req.cookies.token;
+  if (!token) return res.status(403).json({ message: "No token" });
+
+  jwt.verify(token, SECRET_KEY, (err, decoded) => {
+    if (err) return res.status(401).json({ message: "Invalid token" });
+    req.user = decoded;
+    next();
+  });
+}
+
+function authorizeRole(role) {
+  return (req, res, next) => {
+    if (req.user.role !== role)
+      return res.status(403).json({ message: "Access denied" });
+    next();
+  };
+}
+
+app.get("/adminhome", verifyJWT, authorizeRole("admin"), (req, res) => {
+  res.send(`Welcome Admin ${req.user.username}`);
+});
+
+app.get("/userhome", verifyJWT, authorizeRole("user"), (req, res) => {
+  res.send(`Welcome User ${req.user.username}`);
+});
+
+app.get("/logout", (req, res) => {
+  res.clearCookie("token");
+  res.send("Logged out");
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/JWT/u2.js

@@ -0,0 +1,92 @@
+const express = require("express");
+const jwt = require("jsonwebtoken");
+const cookieParser = require("cookie-parser");
+const bodyParser = require("body-parser");
+const fs = require("fs");
+
+const app = express();
+const PORT = 3000;
+const SECRET_KEY = "mysecretkey";
+
+app.use(bodyParser.json());
+app.use(cookieParser());
+
+const users = JSON.parse(fs.readFileSync("./users.json", "utf-8"));
+
+app.post("/login", (req, res) => {
+  const { username, password } = req.body;
+
+  const user = users.find(
+    u => u.username === username && u.password === password
+  );
+
+  if (!user) {
+    return res.status(401).json({ message: "Invalid username or password" });
+  }
+
+  const token = jwt.sign(
+    {
+      username: user.username,
+      role: user.role,
+      loginTime: Date.now()
+    },
+    SECRET_KEY,
+    { expiresIn: "1h" }
+  );
+
+  res.cookie("token", token, { httpOnly: true });
+
+  res.json({
+    redirect: user.role === "admin" ? "/adminhome" : "/userhome"
+  });
+});
+
+function verifyJWT(req, res, next) {
+  const token = req.cookies.token;
+
+  if (!token) {
+    return res.redirect("/login");
+  }
+
+  jwt.verify(token, SECRET_KEY, (err, decoded) => {
+    if (err) {
+      return res.redirect("/login");
+    }
+    req.user = decoded;
+    req.token = token;
+    next();
+  });
+}
+
+app.get("/profile", verifyJWT, (req, res) => {
+  const timeSinceLogin = Math.floor(
+    (Date.now() - req.user.loginTime) / 1000
+  );
+
+  res.json({
+    username: req.user.username,
+    timeSinceLogin: `${timeSinceLogin} seconds`,
+    token: req.token
+  });
+});
+
+app.get("/adminhome", verifyJWT, (req, res) => {
+  res.send(`Welcome Admin ${req.user.username}`);
+});
+
+app.get("/userhome", verifyJWT, (req, res) => {
+  res.send(`Welcome User ${req.user.username}`);
+});
+
+app.get("/logout", (req, res) => {
+  res.clearCookie("token");
+  res.redirect("/login");
+});
+
+app.get("/login", (req, res) => {
+  res.send("Login Page");
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/JWT/u3.js

@@ -0,0 +1,97 @@
+const express = require("express");
+const jwt = require("jsonwebtoken");
+const cookieParser = require("cookie-parser");
+const bodyParser = require("body-parser");
+const fs = require("fs");
+
+const app = express();
+const PORT = 3000;
+const SECRET_KEY = "mysecretkey";
+
+app.use(bodyParser.json());
+app.use(cookieParser());
+
+const users = JSON.parse(fs.readFileSync("./users.json", "utf-8"));
+
+app.post("/login", (req, res) => {
+  const { username, password } = req.body;
+
+  const user = users.find(
+    u => u.username === username && u.password === password
+  );
+
+  if (!user) {
+    return res.status(401).json({ message: "Invalid username or password" });
+  }
+
+  const token = jwt.sign(
+    {
+      username: user.username,
+      role: user.role,
+      loginTime: Date.now()
+    },
+    SECRET_KEY,
+    { expiresIn: "30m" }
+  );
+
+  res.cookie("token", token, { httpOnly: true });
+
+  res.json({
+    redirect: user.role === "admin" ? "/adminhome" : "/userhome"
+  });
+});
+
+function verifyJWT(req, res, next) {
+  const token = req.cookies.token;
+
+  if (!token) {
+    return res.redirect("/login?expired=true");
+  }
+
+  jwt.verify(token, SECRET_KEY, (err, decoded) => {
+    if (err) {
+      res.clearCookie("token");
+      return res.redirect("/login?expired=true");
+    }
+
+    req.user = decoded;
+    req.token = token;
+    next();
+  });
+}
+
+app.get("/profile", verifyJWT, (req, res) => {
+  const timeSinceLogin = Math.floor(
+    (Date.now() - req.user.loginTime) / 1000
+  );
+
+  res.json({
+    username: req.user.username,
+    timeSinceLogin: `${timeSinceLogin} seconds`,
+    token: req.token
+  });
+});
+
+app.get("/adminhome", verifyJWT, (req, res) => {
+  res.send(`Welcome Admin ${req.user.username}`);
+});
+
+app.get("/userhome", verifyJWT, (req, res) => {
+  res.send(`Welcome User ${req.user.username}`);
+});
+
+app.get("/logout", (req, res) => {
+  res.clearCookie("token");
+  res.redirect("/login");
+});
+
+app.get("/login", (req, res) => {
+  if (req.query.expired) {
+    return res.send("Session expired. Please login again.");
+  }
+  res.send("Login Page");
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});

package/JWT/u4.js

@@ -0,0 +1,120 @@
+const express = require("express");
+const jwt = require("jsonwebtoken");
+const cookieParser = require("cookie-parser");
+const bodyParser = require("body-parser");
+const fs = require("fs");
+
+const app = express();
+const PORT = 3000;
+const SECRET_KEY = "mysecretkey";
+
+app.use(bodyParser.json());
+app.use(cookieParser());
+
+const users = JSON.parse(fs.readFileSync("./users.json", "utf-8"));
+const activeTokens = new Map();
+
+app.post("/login", (req, res) => {
+  const { username, password } = req.body;
+
+  const user = users.find(
+    u => u.username === username && u.password === password
+  );
+
+  if (!user) {
+    return res.status(401).json({ message: "Invalid username or password" });
+  }
+
+  const issuedAt = Date.now();
+  const expiresAt = issuedAt + 30 * 60 * 1000;
+
+  const token = jwt.sign(
+    {
+      username: user.username,
+      role: user.role,
+      loginTime: issuedAt
+    },
+    SECRET_KEY,
+    { expiresIn: "30m" }
+  );
+
+  activeTokens.set(token, {
+    username: user.username,
+    issuedAt,
+    expiresAt
+  });
+
+  res.cookie("token", token, { httpOnly: true });
+
+  res.json({
+    redirect: user.role === "admin" ? "/adminhome" : "/userhome"
+  });
+});
+
+function verifyJWT(req, res, next) {
+  const token = req.cookies.token;
+
+  if (!token) {
+    return res.redirect("/login?expired=true");
+  }
+
+  jwt.verify(token, SECRET_KEY, (err, decoded) => {
+    if (err) {
+      activeTokens.delete(token);
+      res.clearCookie("token");
+      return res.redirect("/login?expired=true");
+    }
+
+    req.user = decoded;
+    req.token = token;
+    next();
+  });
+}
+
+function authorizeRole(role) {
+  return (req, res, next) => {
+    if (req.user.role !== role) {
+      return res.status(403).json({ message: "Access denied" });
+    }
+    next();
+  };
+}
+
+app.get("/admin/panel", verifyJWT, authorizeRole("admin"), (req, res) => {
+  const data = [];
+
+  for (const [token, info] of activeTokens.entries()) {
+    data.push({
+      username: info.username,
+      issuedAt: new Date(info.issuedAt).toISOString(),
+      expiresAt: new Date(info.expiresAt).toISOString()
+    });
+  }
+
+  res.json(data);
+});
+
+app.get("/adminhome", verifyJWT, authorizeRole("admin"), (req, res) => {
+  res.send("Admin Home");
+});
+
+app.get("/userhome", verifyJWT, authorizeRole("user"), (req, res) => {
+  res.send("User Home");
+});
+
+app.get("/logout", verifyJWT, (req, res) => {
+  activeTokens.delete(req.token);
+  res.clearCookie("token");
+  res.redirect("/login");
+});
+
+app.get("/login", (req, res) => {
+  if (req.query.expired) {
+    return res.send("Session expired. Please login again.");
+  }
+  res.send("Login Page");
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on http://localhost:${PORT}`);
+});