espresss 1.0.0

package/ete 2/mongo db/company-systsem.js

@@ -0,0 +1,127 @@
+//MongoDb - Company Management System using MongoDB
+
+
+
+const express = require("express");
+const { MongoClient } = require("mongodb");
+
+const app = express();
+const url = "mongodb://127.0.0.1:27017";
+const dbName = "CompanyDB";
+
+let db, emp, dept;
+
+MongoClient.connect(url).then((client) => {
+  db = client.db(dbName);
+  emp = db.collection("employees");
+  dept = db.collection("departments");
+});
+
+/* Employee Routes */
+
+// seed employees
+app.get("/seed-employees", async (req, res) => {
+  await emp.insertMany([
+    { empid: 1, name: "Amit", salary: 20000, deptid: 1 },
+    { empid: 2, name: "Ravi", salary: 25000, deptid: 1 },
+    { empid: 3, name: "Neha", salary: 30000, deptid: 2 },
+    { empid: 4, name: "Pooja", salary: 28000, deptid: 2 },
+    { empid: 5, name: "Rahul", salary: 35000, deptid: 3 },
+    { empid: 6, name: "Kiran", salary: 22000, deptid: 3 },
+  ]);
+  res.send("Employees Seeded");
+});
+
+// view employees
+app.get("/view-employees", async (req, res) => {
+  res.json(await emp.find().toArray());
+});
+
+// add employee
+app.get("/add-employee/:id/:name/:salary/:deptid", async (req, res) => {
+  await emp.insertOne({
+    empid: +req.params.id,
+    name: req.params.name,
+    salary: +req.params.salary,
+    deptid: +req.params.deptid,
+  });
+  res.send("Employee Added");
+});
+
+// delete employee
+app.get("/delete-employee/:id", async (req, res) => {
+  await emp.deleteOne({ empid: +req.params.id });
+  res.send("Deleted");
+});
+
+// delete empid < id
+app.get("/delete-employee-lt/:id", async (req, res) => {
+  await emp.deleteMany({ empid: { $lt: +req.params.id } });
+  res.send("Deleted");
+});
+
+// update salary
+app.get("/update-salary/:id/:amount", async (req, res) => {
+  await emp.updateOne(
+    { empid: +req.params.id },
+    { $set: { salary: +req.params.amount } }
+  );
+  res.send("Updated");
+});
+
+// update salary range
+app.get("/update-salary-range/:id/:amount", async (req, res) => {
+  await emp.updateMany(
+    { empid: { $gte: +req.params.id } },
+    { $inc: { salary: +req.params.amount } }
+  );
+  res.send("Updated");
+});
+
+// search employee
+app.get("/search-employee/:name", async (req, res) => {
+  res.json(await emp.find({ name: req.params.name }).toArray());
+});
+
+/* Department Routes */
+
+// seed departments
+app.get("/seed-departments", async (req, res) => {
+  await dept.insertMany([
+    { deptid: 1, deptname: "HR" },
+    { deptid: 2, deptname: "IT" },
+    { deptid: 3, deptname: "Sales" },
+  ]);
+  res.send("Departments Seeded");
+});
+
+// view departments
+app.get("/view-departments", async (req, res) => {
+  res.json(await dept.find().toArray());
+});
+
+// add department
+app.get("/add-department/:id/:name", async (req, res) => {
+  await dept.insertOne({
+    deptid: +req.params.id,
+    deptname: req.params.name,
+  });
+  res.send("Department Added");
+});
+
+// delete department
+app.get("/delete-department/:id", async (req, res) => {
+  await dept.deleteOne({ deptid: +req.params.id });
+  res.send("Deleted");
+});
+
+// update department
+app.get("/update-department/:id/:newname", async (req, res) => {
+  await dept.updateOne(
+    { deptid: +req.params.id },
+    { $set: { deptname: req.params.newname } }
+  );
+  res.send("Updated");
+});
+
+module.exports = app;

package/ete 2/mongo db/student-management.js

@@ -0,0 +1,65 @@
+//MongoDb & Ejs - Student Management System with Pagination
+// Code Name: Student Management System with Pagination
+
+const express = require("express");
+const { MongoClient, ObjectId } = require("mongodb");
+const app = express();
+
+app.use(express.urlencoded({ extended: true }));
+app.use(express.json());
+app.set("view engine", "ejs");
+
+let db, students;
+MongoClient.connect("mongodb://127.0.0.1:27017").then((c) => {
+  db = c.db("testingproject");
+  students = db.collection("students");
+});
+
+/* Dashboard + Pagination */
+app.get("/", async (req, res) => {
+  const page = +req.query.page || 1;
+  const limit = 5;
+  const data = await students.find().skip((page - 1) * limit).limit(limit).toArray();
+  res.render("dashboard", { students: data, page });
+});
+
+/* Add Student */
+app.post("/addStudent", async (req, res) => {
+  await students.insertOne(req.body);
+  res.redirect("/");
+});
+
+/* Filter */
+app.post("/filter", async (req, res) => {
+  const { type, marks } = req.body;
+  const q =
+    type === ">"
+      ? { marks: { $gt: marks } }
+      : type === "<"
+      ? { marks: { $lt: marks } }
+      : { marks };
+  const data = await students.find(q).toArray();
+  res.render("dashboard", { students: data, page: 1 });
+});
+
+/* Get student */
+app.get("/updateStudent/:id", async (req, res) => {
+  res.json(await students.findOne({ _id: new ObjectId(req.params.id) }));
+});
+
+/* Update */
+app.patch("/updateStudent/:id", async (req, res) => {
+  await students.updateOne(
+    { _id: new ObjectId(req.params.id) },
+    { $set: req.body }
+  );
+  res.send("Updated");
+});
+
+/* Delete */
+app.delete("/deleteStudent/:id", async (req, res) => {
+  await students.deleteOne({ _id: new ObjectId(req.params.id) });
+  res.send("Deleted");
+});
+
+app.listen(3000);

package/ete 2/mongoose/e-commerce.js

@@ -0,0 +1,217 @@
+//Aggregate - E-commerce Order Analytics
+const express = require("express");
+const mongoose = require("mongoose");
+
+const app = express();
+
+const orderSchema = new mongoose.Schema({
+  orderId: String,
+  userId: String,
+  city: String,
+  category: String,
+  product: String,
+  quantity: Number,
+  price: Number,
+  discount: Number,
+  status: String,
+  orderDate: Date,
+});
+
+const Order = mongoose.model("Order", orderSchema);
+
+// Common revenue field
+const revenueStage = {
+  $addFields: {
+    totalAmount: {
+      $subtract: [
+        { $multiply: ["$price", "$quantity"] },
+        {
+          $multiply: [
+            { $multiply: ["$price", "$quantity"] },
+            { $divide: ["$discount", 100] },
+          ],
+        },
+      ],
+    },
+  },
+};
+
+/* Task 1: Top 3 Cities by Revenue */
+app.get("/task1", async (req, res) => {
+  res.json(
+    await Order.aggregate([
+      { $match: { status: { $ne: "cancelled" } } },
+      revenueStage,
+      {
+        $group: {
+          _id: "$city",
+          totalRevenue: { $sum: "$totalAmount" },
+          avgOrderValue: { $avg: "$totalAmount" },
+        },
+      },
+      { $sort: { totalRevenue: -1 } },
+      { $limit: 3 },
+      { $project: { _id: 0, city: "$_id", totalRevenue: 1, avgOrderValue: 1 } },
+    ])
+  );
+});
+
+/* Task 2: Category Performance */
+app.get("/task2", async (req, res) => {
+  res.json(
+    await Order.aggregate([
+      { $match: { status: "delivered" } },
+      revenueStage,
+      {
+        $group: {
+          _id: "$category",
+          totalOrders: { $sum: 1 },
+          totalQuantity: { $sum: "$quantity" },
+          avgOrderValue: { $avg: "$totalAmount" },
+          maxOrderValue: { $max: "$totalAmount" },
+        },
+      },
+    ])
+  );
+});
+
+/* Task 3: User Spending Analysis */
+app.get("/task3", async (req, res) => {
+  res.json(
+    await Order.aggregate([
+      revenueStage,
+      {
+        $group: {
+          _id: "$userId",
+          totalSpent: { $sum: "$totalAmount" },
+          avgOrderValue: { $avg: "$totalAmount" },
+        },
+      },
+      { $match: { totalSpent: { $gt: 20000 } } },
+      { $sort: { totalSpent: -1 } },
+      {
+        $project: {
+          _id: 0,
+          userId: "$_id",
+          totalSpent: 1,
+          averageOrderValue: "$avgOrderValue",
+        },
+      },
+    ])
+  );
+});
+
+/* Task 4: Monthly Revenue Trends */
+app.get("/task4", async (req, res) => {
+  const year = new Date().getFullYear();
+  res.json(
+    await Order.aggregate([
+      {
+        $match: {
+          orderDate: {
+            $gte: new Date(`${year}-01-01`),
+            $lte: new Date(`${year}-12-31`),
+          },
+        },
+      },
+      revenueStage,
+      {
+        $group: {
+          _id: { $month: "$orderDate" },
+          totalRevenue: { $sum: "$totalAmount" },
+          avgOrderValue: { $avg: "$totalAmount" },
+          totalOrders: { $sum: 1 },
+        },
+      },
+    ])
+  );
+});
+
+/* Task 5: Expensive Orders */
+app.get("/task5", async (req, res) => {
+  res.json(
+    await Order.aggregate([
+      revenueStage,
+      {
+        $group: {
+          _id: null,
+          avgAmount: { $avg: "$totalAmount" },
+        },
+      },
+      {
+        $lookup: {
+          from: "orders",
+          pipeline: [
+            revenueStage,
+            {
+              $match: {
+                $expr: { $gt: ["$totalAmount", "$$AVG"] },
+              },
+            },
+            { $sort: { totalAmount: -1 } },
+            { $limit: 5 },
+          ],
+          as: "result",
+        },
+      },
+      { $project: { _id: 0, result: 1 } },
+    ])
+  );
+});
+
+/* Task 6: Daily Order Summary */
+app.get("/task6", async (req, res) => {
+  res.json(
+    await Order.aggregate([
+      revenueStage,
+      {
+        $group: {
+          _id: {
+            $dateToString: { format: "%Y-%m-%d", date: "$orderDate" },
+          },
+          totalOrders: { $sum: 1 },
+          totalQuantity: { $sum: "$quantity" },
+          totalRevenue: { $sum: "$totalAmount" },
+          minOrder: { $min: "$totalAmount" },
+          maxOrder: { $max: "$totalAmount" },
+        },
+      },
+    ])
+  );
+});
+
+/* Task 7: City-Wise Distribution */
+app.get("/task7", async (req, res) => {
+  res.json(
+    await Order.aggregate([
+      { $group: { _id: "$city", totalOrders: { $sum: 1 } } },
+      { $match: { totalOrders: { $gt: 10 } } },
+    ])
+  );
+});
+
+/* Task 8: Category Popularity Index */
+app.get("/task8", async (req, res) => {
+  res.json(
+    await Order.aggregate([
+      {
+        $group: {
+          _id: "$category",
+          totalQuantity: { $sum: "$quantity" },
+          avgPrice: { $avg: "$price" },
+        },
+      },
+      {
+        $addFields: {
+          popularityScore: {
+            $multiply: ["$totalQuantity", "$avgPrice"],
+          },
+        },
+      },
+      { $sort: { popularityScore: -1 } },
+      { $limit: 5 },
+    ])
+  );
+});
+
+module.exports = app;

package/ete 2/mongoose/employee.js

@@ -0,0 +1,99 @@
+//Mongoose - Employee Payroll System
+
+const express = require("express");
+const mongoose = require("mongoose");
+
+const app = express();
+app.use(express.json());
+
+// MongoDB connection
+mongoose.connect("mongodb://127.0.0.1:27017/payroll");
+
+// Schema
+const employeeSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+    minlength: 3,
+    maxlength: 50,
+  },
+  employeeId: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  departments: [String],
+  salary: {
+    type: Number,
+    min: 10000,
+    validate: {
+      validator: (v) => v % 1000 === 0,
+    },
+  },
+  joiningDate: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+// Hook
+employeeSchema.pre("save", function (next) {
+  this.name = this.name.toUpperCase();
+  next();
+});
+
+const Employee = mongoose.model("Employee", employeeSchema);
+
+// Routes
+
+// Add employee
+app.post("/employees", async (req, res) => {
+  try {
+    const emp = new Employee(req.body);
+    await emp.save();
+    res.json(emp);
+  } catch (e) {
+    res.status(400).json({ error: e.message });
+  }
+});
+
+// View all employees
+app.get("/employees", async (req, res) => {
+  const employees = await Employee.find();
+  res.json(employees);
+});
+
+// Get employee by ID
+app.get("/employees/:id", async (req, res) => {
+  const emp = await Employee.findOne({ employeeId: req.params.id });
+  if (!emp) return res.status(404).json({ error: "Not found" });
+  res.json(emp);
+});
+
+// Update salary or departments
+app.put("/employees/:id", async (req, res) => {
+  const emp = await Employee.findOneAndUpdate(
+    { employeeId: req.params.id },
+    req.body,
+    { new: true }
+  );
+  if (!emp) return res.status(404).json({ error: "Not found" });
+  res.json(emp);
+});
+
+// Delete employee
+app.delete("/employees/:id", async (req, res) => {
+  await Employee.findOneAndDelete({ employeeId: req.params.id });
+  res.json({ message: "Deleted" });
+});
+
+// Bonus: Average salary by department
+app.get("/average/:dept", async (req, res) => {
+  const result = await Employee.aggregate([
+    { $match: { departments: req.params.dept } },
+    { $group: { _id: null, avgSalary: { $avg: "$salary" } } },
+  ]);
+  res.json({ averageSalary: result[0]?.avgSalary || 0 });
+});
+
+module.exports = app;

package/ete 2/mongoose/event-management.js

@@ -0,0 +1,87 @@
+//mongoose - Event Management System
+
+const express = require("express");
+const mongoose = require("mongoose");
+
+const app = express();
+app.use(express.json());
+
+mongoose.connect("mongodb://127.0.0.1:27017/events");
+
+// Schema
+const eventSchema = new mongoose.Schema({
+  eventName: {
+    type: String,
+    required: true,
+    minlength: 3,
+    maxlength: 50,
+  },
+  date: {
+    type: Date,
+    validate: {
+      validator: (v) => v > new Date(),
+    },
+  },
+  venue: String,
+  participants: {
+    type: [String],
+    validate: (v) => v.length > 0,
+  },
+  ticketPrice: {
+    type: Number,
+    min: 1,
+    max: 9999,
+  },
+});
+
+// Hooks
+eventSchema.pre("save", function (next) {
+  this.eventName = this.eventName.replace(/\b\w/g, (c) => c.toUpperCase());
+  next();
+});
+
+eventSchema.post("save", function () {
+  console.log("Event added successfully.");
+});
+
+const Event = mongoose.model("Event", eventSchema);
+
+// Routes
+
+// Add event
+app.post("/events", async (req, res) => {
+  try {
+    const event = new Event(req.body);
+    await event.save();
+    res.json(event);
+  } catch (e) {
+    res.status(400).json({ error: e.message });
+  }
+});
+
+// View all events
+app.get("/events", async (req, res) => {
+  res.json(await Event.find());
+});
+
+// Update event
+app.put("/events/:id", async (req, res) => {
+  const event = await Event.findByIdAndUpdate(req.params.id, req.body, {
+    new: true,
+  });
+  if (!event) return res.status(404).json({ error: "Not found" });
+  res.json(event);
+});
+
+// Delete event
+app.delete("/events/:id", async (req, res) => {
+  await Event.findByIdAndDelete(req.params.id);
+  res.json({ message: "Deleted" });
+});
+
+// Bonus: Events by venue
+app.get("/events/venue/:venue", async (req, res) => {
+  res.json(await Event.find({ venue: req.params.venue }));
+});
+
+module.exports = app;

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "espresss",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs"
+}