espresss 1.0.0

package/ETe/JWT/token based.js

@@ -0,0 +1,68 @@
+//JWT - Token-based Authentication and Role-based Redirection User Story 1
+// Language: JavaScript (Node.js + Express + JWT)
+// Code Name: JWT Token-based Authentication with Role-based Redirection
+
+const express = require("express");
+const jwt = require("jsonwebtoken");
+const cookieParser = require("cookie-parser");
+
+const app = express();
+app.use(express.json());
+app.use(cookieParser());
+
+const SECRET = "secretkey";
+
+/*
+==================== user.json (as variable) ====================
+*/
+const users = [
+  {
+    username: "user@gmail.com",
+    password: "user@123",
+    role: "user",
+  },
+  {
+    username: "admin@gmail.com",
+    password: "admin@123",
+    role: "admin",
+  },
+];
+/*
+===============================================================
+*/
+
+// Login Route
+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).send("Invalid credentials");
+
+  const token = jwt.sign(
+    {
+      username: user.username,
+      role: user.role,
+      loginTime: Date.now(),
+    },
+    SECRET
+  );
+
+  res.cookie("token", token);
+
+  if (user.role === "admin") res.redirect("/adminhome");
+  else res.redirect("/userhome");
+});
+
+// Role-based Pages
+app.get("/adminhome", (req, res) => {
+  res.send("Admin Home");
+});
+
+app.get("/userhome", (req, res) => {
+  res.send("User Home");
+});
+
+app.listen(3000);

package/ETe/JWT/token expiration.js

@@ -0,0 +1,66 @@
+//JWT - Token Expiration and Auto Logout User Story 3
+// Language: JavaScript (Node.js + Express + JWT)
+// Code Name: JWT Token Expiration and Auto Logout
+
+const express = require("express");
+const jwt = require("jsonwebtoken");
+const cookieParser = require("cookie-parser");
+
+const app = express();
+app.use(express.json());
+app.use(cookieParser());
+
+const SECRET = "secretkey";
+
+/* ===== Users (mock data) ===== */
+const users = [
+  { username: "user@gmail.com", password: "user@123" },
+  { username: "admin@gmail.com", password: "admin@123" },
+];
+
+/* ===== Login ===== */
+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).send("Invalid credentials");
+
+  const token = jwt.sign(
+    { username: user.username },
+    SECRET,
+    { expiresIn: "30m" } // 30 minutes expiry
+  );
+
+  res.cookie("token", token);
+  res.send("Logged In");
+});
+
+/* ===== JWT Middleware ===== */
+const auth = (req, res, next) => {
+  const token = req.cookies.token;
+  if (!token) return res.redirect("/login");
+
+  jwt.verify(token, SECRET, (err, decoded) => {
+    if (err) {
+      res.clearCookie("token");
+      return res.redirect("/login?msg=Token expired");
+    }
+    req.user = decoded;
+    next();
+  });
+};
+
+/* ===== Protected Route ===== */
+app.get("/profile", auth, (req, res) => {
+  res.send("Welcome " + req.user.username);
+});
+
+/* ===== Login Page ===== */
+app.get("/login", (req, res) => {
+  res.send(req.query.msg || "Login Page");
+});
+
+app.listen(3000);

package/ETe/Multer/ImageUpload.js

@@ -0,0 +1,55 @@
+const express = require("express");
+const multer = require("multer");
+const path = require("path");
+const fs = require("fs");
+
+const app = express();
+const PORT = 3000;
+
+const uploadDir = path.join(__dirname, "uploads");
+if (!fs.existsSync(uploadDir)) {
+  fs.mkdirSync(uploadDir);
+}
+
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, "uploads/");
+  },
+  filename: (req, file, cb) => {
+    cb(null, Date.now() + path.extname(file.originalname));
+  },
+});
+
+const fileFilter = (req, file, cb) => {
+  const allowedTypes = [".jpg", ".jpeg", ".png"];
+  const ext = path.extname(file.originalname).toLowerCase();
+  if (allowedTypes.includes(ext)) {
+    cb(null, true);
+  } else {
+    cb(new Error("Invalid file type. Only .jpg and .png allowed!"), false);
+  }
+};
+
+const upload = multer({ storage: storage, fileFilter: fileFilter });
+
+app.post("/upload", upload.single("profilePic"), (req, res) => {
+  if (!req.file) {
+    return res.status(400).json({ error: "No file uploaded or invalid file type." });
+  }
+  res.json({
+    message: "File uploaded successfully!",
+    fileName: req.file.filename,
+    filePath: `/uploads/${req.file.filename}`,
+  });
+});
+
+app.use((err, req, res, next) => {
+  if (err instanceof multer.MulterError || err.message.includes("Invalid file type")) {
+    return res.status(400).json({ error: err.message });
+  }
+  next(err);
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});

package/ETe/Multer/file management api.js

@@ -0,0 +1,266 @@
+// app.js
+const express = require('express');
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+/**
+ * Configuration
+ */
+const UPLOAD_ROOT = path.join(__dirname, 'uploads');
+const ALLOWED_EXT = ['.jpg', '.jpeg', '.png', '.pdf', '.docx']; // allowed extensions
+const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5 MB per file (global limit)
+
+/**
+ * Helper: map fieldname to folder
+ */
+function folderForField(fieldname) {
+  switch (fieldname) {
+    case 'profilePic': return 'profile_pics';
+    case 'docs': return 'documents';
+    case 'others': return 'others';
+    default: return 'others';
+  }
+}
+
+/**
+ * Ensure base upload folders exist
+ */
+['profile_pics', 'documents', 'others'].forEach(sub => {
+  const p = path.join(UPLOAD_ROOT, sub);
+  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
+});
+
+/**
+ * Multer storage config: dynamic destination using userId param
+ */
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    // Expect userId in route parameter: /upload/:userId
+    const userId = req.params.userId;
+    if (!userId) return cb(new Error('Missing userId in params'));
+
+    const folder = folderForField(file.fieldname);
+    const dest = path.join(UPLOAD_ROOT, folder, String(userId));
+
+    // create directory if not exists
+    fs.mkdir(dest, { recursive: true }, (err) => {
+      cb(err, dest);
+    });
+  },
+
+  filename: (req, file, cb) => {
+    const userId = req.params.userId || 'unknown';
+    const timestamp = Date.now();
+    // sanitize originalname for safety (strip path)
+    const orig = path.basename(file.originalname);
+    const filename = `${file.fieldname}-${userId}-${timestamp}-${orig}`;
+    cb(null, filename);
+  }
+});
+
+/**
+ * File filter: allow only specific extensions/mimetypes.
+ * Reject with "Invalid file type".
+ */
+function fileFilter(req, file, cb) {
+  const ext = path.extname(file.originalname).toLowerCase();
+  if (!ALLOWED_EXT.includes(ext)) {
+    // Provide an error that will be handled by our multer error handler
+    return cb(new multer.MulterError('LIMIT_UNEXPECTED_FILE', 'Invalid file type'));
+  }
+
+  // optional: further mime-type checks (basic)
+  const allowedMimes = [
+    'image/jpeg', 'image/png',
+    'application/pdf',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document' // .docx
+  ];
+  if (file.mimetype && !allowedMimes.includes(file.mimetype)) {
+    // still allow if extension was allowed (some clients provide different mimetype)
+    // but for safety, we will allow based on extension mainly.
+    // If you want to strictly check mimetype uncomment below:
+    // return cb(new multer.MulterError('LIMIT_UNEXPECTED_FILE', 'Invalid file type'));
+  }
+
+  cb(null, true);
+}
+
+/**
+ * Multer instance
+ * - single global fileSize limit (per-file)
+ * - fields: profilePic (1), docs (5), others (10) <-- adjust as needed
+ */
+const upload = multer({
+  storage,
+  fileFilter,
+  limits: {
+    fileSize: MAX_FILE_SIZE
+  }
+});
+
+/**
+ * Middleware to catch multer errors and format responses
+ */
+function multerErrorHandler(err, req, res, next) {
+  if (!err) return next();
+
+  if (err instanceof multer.MulterError) {
+    // Known multer errors
+    let message = err.message;
+
+    // Provide friendly messages for common codes:
+    if (err.code === 'LIMIT_FILE_SIZE') {
+      message = `File too large. Max size is ${MAX_FILE_SIZE} bytes.`;
+    } else if (err.code === 'LIMIT_UNEXPECTED_FILE') {
+      // We used this code to signal invalid file types too
+      if (err.field) {
+        message = `Unexpected field: ${err.field}`;
+      } else {
+        message = 'Invalid file type';
+      }
+    }
+
+    return res.status(400).json({ error: message });
+  }
+
+  // Non-multer error
+  return res.status(500).json({ error: err.message || 'Server Error' });
+}
+
+/**
+ * Route: POST /upload/:userId
+ * Accepts fields:
+ *  - profilePic: single file
+ *  - docs: array of files
+ *  - others: array of files
+ *
+ * Responds with uploaded file paths grouped under uploaded.profilePic, docs, others
+ */
+app.post(
+  '/upload/:userId',
+  // multer fields handling
+  (req, res, next) => {
+    const uploader = upload.fields([
+      { name: 'profilePic', maxCount: 1 },
+      { name: 'docs', maxCount: 10 },
+      { name: 'others', maxCount: 20 }
+    ]);
+    uploader(req, res, function (err) {
+      if (err) return next(err);
+      next();
+    });
+  },
+  (req, res) => {
+    const userId = req.params.userId;
+    const files = req.files || {};
+
+    // Build response paths relative to project root (so they are browsable under /uploads/)
+    const uploaded = {
+      profilePic: null,
+      docs: [],
+      others: []
+    };
+
+    if (files.profilePic && files.profilePic.length > 0) {
+      uploaded.profilePic = path.join(
+        'uploads',
+        folderForField('profilePic'),
+        String(userId),
+        files.profilePic[0].filename
+      ).replace(/\\/g, '/');
+    }
+
+    if (files.docs && files.docs.length > 0) {
+      uploaded.docs = files.docs.map(f => path.join('uploads', folderForField('docs'), String(userId), f.filename).replace(/\\/g, '/'));
+    }
+
+    if (files.others && files.others.length > 0) {
+      uploaded.others = files.others.map(f => path.join('uploads', folderForField('others'), String(userId), f.filename).replace(/\\/g, '/'));
+    }
+
+    res.json({
+      message: 'Files uploaded successfully!',
+      uploaded
+    });
+  }
+);
+
+// Attach multer error handler (must be after the upload route)
+app.use(multerErrorHandler);
+
+/**
+ * Route: GET /files/:userId
+ * Lists all files for a userId across profile_pics, documents, others
+ */
+app.get('/files/:userId', (req, res) => {
+  const userId = String(req.params.userId);
+  const folders = ['profile_pics', 'documents', 'others'];
+  const files = [];
+
+  folders.forEach(folder => {
+    const userFolder = path.join(UPLOAD_ROOT, folder, userId);
+    if (fs.existsSync(userFolder)) {
+      const list = fs.readdirSync(userFolder);
+      list.forEach(filename => {
+        files.push(path.join('uploads', folder, userId, filename).replace(/\\/g, '/'));
+      });
+    }
+  });
+
+  res.json({
+    userId,
+    files
+  });
+});
+
+/**
+ * Route: DELETE /delete/:userId/:filename
+ * Deletes the named file in any of the three subfolders for that user
+ */
+app.delete('/delete/:userId/:filename', (req, res) => {
+  const { userId, filename } = req.params;
+  const folders = ['profile_pics', 'documents', 'others'];
+
+  let foundPath = null;
+  for (const folder of folders) {
+    const p = path.join(UPLOAD_ROOT, folder, String(userId), filename);
+    if (fs.existsSync(p)) {
+      foundPath = p;
+      break;
+    }
+  }
+
+  if (!foundPath) {
+    return res.status(404).json({ error: 'File not found' });
+  }
+
+  fs.unlink(foundPath, (err) => {
+    if (err) {
+      console.error('Error deleting file:', err);
+      return res.status(500).json({ error: 'Failed to delete file' });
+    }
+    return res.json({ message: 'File deleted successfully!' });
+  });
+});
+
+/**
+ * Serve uploaded files statically so they are accessible via browser:
+ * e.g. http://localhost:3000/uploads/profile_pics/102/profilePic-102-...png
+ */
+app.use('/uploads', express.static(UPLOAD_ROOT));
+
+/**
+ * Simple health route
+ */
+app.get('/', (req, res) => {
+  res.send('FileManager API is running. Use POST /upload/:userId, GET /files/:userId, DELETE /delete/:userId/:filename');
+});
+
+/**
+ * Start
+ */
+app.listen(PORT, () => console.log(`FileManager listening on http://localhost:${PORT}`));

package/ETe/Multer/file size and validation.js

@@ -0,0 +1,62 @@
+const express = require("express");
+const multer = require("multer");
+const path = require("path");
+const fs = require("fs");
+
+const app = express();
+const PORT = 3000;
+
+const uploadDir = path.join(__dirname, "uploads/products");
+if (!fs.existsSync(uploadDir)) {
+  fs.mkdirSync(uploadDir, { recursive: true });
+}
+
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, "uploads/products/");
+  },
+  filename: (req, file, cb) => {
+    cb(null, Date.now() + path.extname(file.originalname));
+  },
+});
+
+const fileFilter = (req, file, cb) => {
+  const allowedTypes = [".jpg", ".jpeg", ".png"];
+  const ext = path.extname(file.originalname).toLowerCase();
+  if (allowedTypes.includes(ext)) {
+    cb(null, true);
+  } else {
+    cb(new Error("Invalid file type. Only .jpg and .png allowed!"), false);
+  }
+};
+
+const upload = multer({
+  storage: storage,
+  fileFilter: fileFilter,
+  limits: { fileSize: 2 * 1024 * 1024 },
+});
+
+app.post("/upload-product", upload.single("productImage"), (req, res) => {
+  if (!req.file) {
+    return res.status(400).json({ error: "No file uploaded or invalid file type." });
+  }
+  res.json({
+    message: "File uploaded successfully!",
+    filePath: `/uploads/products/${req.file.filename}`,
+    fileSize: `${(req.file.size / 1024).toFixed(2)} KB`,
+  });
+});
+
+app.use((err, req, res, next) => {
+  if (err.code === "LIMIT_FILE_SIZE") {
+    return res.status(400).json({ error: "File too large. Max size is 2 MB." });
+  }
+  if (err instanceof multer.MulterError || err.message.includes("Invalid file type")) {
+    return res.status(400).json({ error: err.message });
+  }
+  next(err);
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});

package/ETe/Multer/from data.js

@@ -0,0 +1,70 @@
+const express = require("express");
+const multer = require("multer");
+const path = require("path");
+const fs = require("fs");
+
+const app = express();
+const PORT = 3000;
+
+app.use(express.urlencoded({ extended: true }));
+app.use(express.json());
+
+const uploadDir = path.join(__dirname, "uploads/resumes");
+if (!fs.existsSync(uploadDir)) {
+  fs.mkdirSync(uploadDir, { recursive: true });
+}
+
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, "uploads/resumes/");
+  },
+  filename: (req, file, cb) => {
+    cb(null, Date.now() + path.extname(file.originalname));
+  },
+});
+
+const fileFilter = (req, file, cb) => {
+  const ext = path.extname(file.originalname).toLowerCase();
+  if (ext === ".pdf") {
+    cb(null, true);
+  } else {
+    cb(new Error("Invalid file type. Only .pdf allowed!"), false);
+  }
+};
+
+const upload = multer({ storage: storage, fileFilter: fileFilter });
+
+app.post("/submit", upload.single("resume"), (req, res) => {
+  const { name, email, phone } = req.body;
+  if (!req.file) {
+    return res.status(400).json({ error: "No resume uploaded or invalid file type." });
+  }
+  const formData = {
+    name,
+    email,
+    phone,
+    resumePath: `/uploads/resumes/${req.file.filename}`,
+  };
+  const dbPath = path.join(__dirname, "formData.json");
+  let existingData = [];
+  if (fs.existsSync(dbPath)) {
+    existingData = JSON.parse(fs.readFileSync(dbPath));
+  }
+  existingData.push(formData);
+  fs.writeFileSync(dbPath, JSON.stringify(existingData, null, 2));
+  res.json({
+    message: "Form submitted successfully!",
+    data: formData,
+  });
+});
+
+app.use((err, req, res, next) => {
+  if (err instanceof multer.MulterError || err.message.includes("Invalid file type")) {
+    return res.status(400).json({ error: err.message });
+  }
+  next(err);
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});

package/ETe/Multer/multiple.js

@@ -0,0 +1,57 @@
+const express = require("express");
+const multer = require("multer");
+const path = require("path");
+const fs = require("fs");
+
+const app = express();
+const PORT = 3000;
+
+const uploadDir = path.join(__dirname, "uploads/gallery");
+if (!fs.existsSync(uploadDir)) {
+  fs.mkdirSync(uploadDir, { recursive: true });
+}
+
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, "uploads/gallery/");
+  },
+  filename: (req, file, cb) => {
+    cb(null, Date.now() + path.extname(file.originalname));
+  },
+});
+
+const fileFilter = (req, file, cb) => {
+  const allowedTypes = [".jpg", ".jpeg", ".png"];
+  const ext = path.extname(file.originalname).toLowerCase();
+  if (allowedTypes.includes(ext)) {
+    cb(null, true);
+  } else {
+    cb(new Error("Invalid file type. Only .jpg, .jpeg, and .png allowed!"), false);
+  }
+};
+
+const upload = multer({ storage: storage, fileFilter: fileFilter });
+
+app.post("/upload-multiple", upload.array("images", 5), (req, res) => {
+  if (!req.files || req.files.length === 0) {
+    return res.status(400).json({ error: "No files uploaded or invalid file type." });
+  }
+  if (req.files.length > 5) {
+    return res.status(400).json({ error: "You can upload a maximum of 5 files." });
+  }
+  res.json({
+    message: "Files uploaded successfully!",
+    fileNames: req.files.map((file) => file.filename),
+  });
+});
+
+app.use((err, req, res, next) => {
+  if (err instanceof multer.MulterError || err.message.includes("Invalid file type")) {
+    return res.status(400).json({ error: err.message });
+  }
+  next(err);
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});