create-myexam-app 1.0.24 → 1.0.26

package/index.js

@@ -10,19 +10,20 @@ const rl = readline.createInterface({
   output: process.stdout
 })
 console.log('\n[1] Car Repair Parking Managemnt System')
-console.log('[2]Employee Payroll Management System')
-console.log('[3]Employee Payroll Management System Elysee')
-console.log('[4]middleware')
-console.log('[5] Parking Management System')
-console.log('[6]Supply Chain Managemnt System')
-console.log('[7]Supply Chain Management System Elysee')
- console.log('[8] School fee Management System')
- console.log('[9]Stock Hub Management System')
- console.log('[10]Stock Invetory Management System')
- console.log('[11]Stock Management System')
- console.log('[12]Sales Record Management System')
- console.log('[13]Sales Record Management System Elysee')
- console.log('[14]userController.js')
+console.log('[2]Elysee File Prompt')
+console.log('[3]Employee Payroll Management System')
+console.log('[4]Employee Payroll Management System Elysee')
+console.log('[5]middleware')
+console.log('[6] Parking Management System')
+console.log('[7]Supply Chain Managemnt System')
+console.log('[8]Supply Chain Management System Elysee')
+ console.log('[9] School fee Management System')
+ console.log('[10]Stock Hub Management System')
+ console.log('[11]Stock Invetory Management System')
+ console.log('[12]Stock Management System')
+ console.log('[13]Sales Record Management System')
+ console.log('[14]Sales Record Management System Elysee')
+ console.log('[15]userController.js')
  
 
 
@@ -31,19 +32,20 @@ rl.question('Pick (1-14): ', (answer) => {
 
   const projects = {
     '1':'crpms',
-    '2':'EPMS',
-    '3':'EPMS(Ely)',
-    '4':'middleware',
-    '5': 'parking managementt system',
-    
-    '7':'SCMS(Ely)',
-    '8': 'sfms-app',
-    '9':'SHMS(Ely)',
-    '10':'sims',
-    '11': 'SMS-',
-    '12':'SRMS',
-    '13':'SRMS(Ely)',
-    '14':'user',
+    '2':'Elysee File',
+    '3':'EPMS',
+    '4':'EPMS(Ely)',
+    '5':'middleware',
+    '6': 'parking managementt system',
+    '7':'SCMS',
+    '8':'SCMS(Ely)',
+    '9': 'sfms-app',
+    '10':'SHMS(Ely)',
+    '11':'sims',
+    '12': 'SMS-',
+    '13':'SRMS',
+    '14':'SRMS(Ely)',
+    '15':'user',
     
      
   }

package/package.json

@@ -2,7 +2,7 @@
   
   "name": "create-myexam-app",
   
-  "version": "1.0.24",
+  "version": "1.0.26",
   
   "description": "My exam projects",
   

package/projects/Elysee File/# Full-Stack [SUBJECT] Management S.txt

@@ -0,0 +1,200 @@
+# Full-Stack [SUBJECT] Management System
+
+## Project Overview
+A full-stack web application for managing **[SUBJECT]** records. The system provides CRUD operations, authentication, and reporting functionality through a RESTful API backend and a React-based single-page frontend.
+
+## Tech Stack
+- **Frontend:** React 18 + Vite + React Router v6 + Axios
+- **Backend:** Node.js + Express 4 + JWT authentication + bcrypt
+- **Database:** MongoDB + Mongoose ODM
+- **Styling:** Custom CSS (no framework)
+- **Build:** Vite (frontend), Nodemon (backend dev)
+
+## Architecture
+Full-stack MERN pattern:
+
+```
+Frontend (React/Vite)  --HTTP-->  Backend (Express API)  --Mongoose-->  MongoDB
+    localhost:5173                  localhost:5000                      localhost:27017
+```
+
+## Backend Structure
+
+### Entry Point: `server.js`
+- Express app setup with CORS (origins: localhost:5173, 5174)
+- Connects to MongoDB, starts listening on PORT (default 5000)
+- Mounts all route groups under `/api/`
+
+### Authentication (`middleware/authMiddleware.js`)
+- JWT-based bearer token verification
+- Extracts token from `Authorization: Bearer <token>` header
+- Attaches decoded user (`{ id, username }`) to `req.user`
+- Returns 401 on missing/invalid/expired token
+
+### Data Models (`models/`)
+| Model   | Key Fields                                                                 |
+|---------|---------------------------------------------------------------------------|
+| User    | username (unique), password (hashed with bcrypt)                          |
+| [A]     | code (unique), name, additional fields per subject                        |
+| [B]     | code (unique), name, quantity, unit price                                 |
+| [C]     | invoice number (unique), date, payment method, total amount, customer ref, line items |
+
+### API Routes
+| Method | Endpoint            | Auth | Description                     |
+|--------|---------------------|------|---------------------------------|
+| POST   | /api/auth/register  | No   | Register new user               |
+| POST   | /api/auth/login     | No   | Login, returns JWT token        |
+| GET    | /api/[A]            | JWT  | List all [A] records            |
+| POST   | /api/[A]            | JWT  | Create new [A] record           |
+| GET    | /api/[B]            | JWT  | List all [B] records            |
+| POST   | /api/[B]            | JWT  | Create new [B] record           |
+| GET    | /api/[C]            | JWT  | List all [C] records            |
+| GET    | /api/[C]/:id        | JWT  | Get single [C] record           |
+| POST   | /api/[C]            | JWT  | Create [C] record               |
+| PUT    | /api/[C]/:id        | JWT  | Update [C] record               |
+| DELETE | /api/[C]/:id        | JWT  | Delete [C] record               |
+| GET    | /api/reports/daily  | JWT  | Daily report (date filter)      |
+| GET    | /api/reports/weekly | JWT  | Weekly report (week filter)     |
+| GET    | /api/reports/monthly| JWT  | Monthly report (year/month)     |
+
+### Controllers (`controllers/`)
+Each controller handles request validation, database interaction, and response formatting:
+- **authController** — register (hash password, create user, return JWT), login (verify credentials, return JWT)
+- **[A]Controller** — list (all sorted by newest), create (validate fields, check duplicate code)
+- **[B]Controller** — list (all sorted by newest), create (validate fields, check duplicate code)
+- **[C]Controller** — full CRUD: list, getById, create, update, delete; populates related [A] reference
+- **reportController** — daily/weekly/monthly aggregation with date range filtering, totals calculation
+
+## Frontend Structure
+
+### Entry: `index.html` → `main.jsx` → `App.jsx`
+- React StrictMode wrapping root App component
+- Global CSS import
+
+### App Component (`App.jsx`)
+- **State:** session (localStorage-persisted token + user), notice (notification messages)
+- **Session management:** saveSession (localStorage + state), logout (clear both)
+- **Routing (React Router v6):**
+  - `/login` — Login page
+  - `/register` — Register page
+  - `/dashboard` — Protected dashboard with stats overview
+  - `/[A]` — Protected [A] list/create page
+  - `/[B]` — Protected [B] list/create page
+  - `/[C]` — Protected [C] full CRUD page
+  - `/reports` — Protected reports page (daily/weekly/monthly)
+  - `/` — Redirects to dashboard or login
+  - `*` — Catch-all redirect
+- **Protected wrapper:** Redirects to `/login` if no session
+- **TopNav:** Navigation bar with links, username, logout button (hidden on print via `.no-print`)
+- **Notice bar:** Dismissible notification messages
+- API base URL: `http://localhost:5000/api` (hardcoded)
+
+### Pages (`src/pages/`)
+
+#### Login (`Login.jsx`)
+- Username/password form
+- Validates non-empty fields
+- POSTs to `/api/auth/login`, stores session, redirects to dashboard
+- Link to register page
+
+#### Register (`Register.jsx`)
+- Username/password/confirm password form
+- Validates non-empty fields, password match, password >= 4 chars
+- POSTs to `/api/auth/register`, stores session, redirects to dashboard
+- Link back to login
+
+#### Dashboard (`Dashboard.jsx`)
+- Fetches counts from all 3 record types on mount (parallel GET requests)
+- Displays 4 stat cards: Total [A], Total [B], Total [C], Total Revenue in [CURRENCY]
+- Quick action links to add new records
+
+#### [A] Records (`[A].jsx`)
+- Form with fields per [A] schema + submit button
+- Validates all fields, POSTs to create endpoint
+- Table listing all records with their fields
+- Currency formatting where applicable
+
+#### [B] Records (`[B].jsx`)
+- Form with fields per [B] schema + submit button
+- Validates fields (including numeric), POSTs to create endpoint
+- Table listing all records with computed totals
+- Currency formatting in [CURRENCY]
+
+#### [C] Records (`[C].jsx`)
+- Form with fields per [C] schema + [A] dropdown selector + submit/update/cancel buttons
+- Full CRUD: create (POST), edit (PUT with populated form), delete (DELETE with confirmation)
+- Fetches both [C] records and [A] list on mount
+- Table with all [C] fields and action buttons (Edit/Delete)
+
+#### Reports (`Reports.jsx`)
+- Daily / Weekly / Monthly toggle buttons
+- Date picker (daily/weekly) or month picker (monthly)
+- "Generate Report" button triggers filtered API call
+- "Print" button uses `window.print()`, nav hidden via CSS `@media print`
+- Report summary: Total Transactions, Total Revenue, Average per [C]
+- Report table with [C] details
+
+### Styling (`index.css`)
+- Global reset, blue primary color `#1E3A8A`
+- Responsive layout with max-width 1100px
+- 4-column stat card grid
+- Form grids (5-column, variants for 3/4 fields)
+- Scrollable tables with striped headers and hover rows
+- Centered auth card layout
+- Report filters and summary sections
+- Print media query hiding navigation
+- Responsive breakpoints at 950px and 620px
+
+## Configuration
+
+### Backend (`.env`)
+```
+PORT=5000
+MONGO_URI=mongodb://127.0.0.1:27017/[DB_NAME]
+JWT_SECRET=[JWT_SECRET_KEY]
+```
+
+### Frontend (`package.json`)
+- Scripts: `dev` (vite), `build` (vite build), `preview` (vite preview)
+- Port: 5173 (Vite dev server)
+
+## Authentication Flow
+1. User registers or logs in → backend returns JWT (expires 1 day, payload: `{ id, username }`)
+2. Frontend stores token + user in `localStorage` under key `[SESSION_KEY]`
+3. All API calls include `Authorization: Bearer <token>` header
+4. Backend `authMiddleware` verifies JWT on every protected route
+5. 401 response → frontend redirects to login
+
+## Key Design Decisions
+- No JSX in App.jsx (uses `React.createElement`); page components use JSX
+- No state management library (plain React state + localStorage)
+- No form validation library (manual validation)
+- No pagination (all records fetched at once)
+- No testing framework
+- Currency displayed in [CURRENCY]
+- Print support via CSS `@media print` and `window.print()`
+- Passwords hashed with bcrypt (10 salt rounds)
+- CORS restricted to localhost:5173/5174
+- No input sanitization library
+
+## Setup Instructions
+
+### Backend
+```bash
+cd backend-project
+npm install
+# Configure .env with your MongoDB URI and JWT secret
+npm run dev    # or npm start
+```
+
+### Frontend
+```bash
+cd frontend-project
+npm install
+npm run dev
+```
+
+### First Use
+1. Open `http://localhost:5173`
+2. Register a new account
+3. Start managing [SUBJECT] records

package/projects/SRMS/backend/config/db.js

@@ -0,0 +1,12 @@
+const mongoose = require('mongoose');
+
+const connectDB = async () => {
+  try {
+    await mongoose.connect('mongodb://localhost:27017/SRMS');
+    console.log('MongoDB connected');
+  } catch (error) {
+    console.error('MongoDB connection error:', error);
+  }
+};
+
+module.exports = connectDB;

package/projects/SRMS/backend/controllers/authController.js

@@ -0,0 +1,90 @@
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+const User = require('../models/User');
+const JWT_SECRET = 'change_this_to_a_long_random_secret';
+
+
+
+function createToken(userId) {
+  return jwt.sign({ userId },JWT_SECRET, { expiresIn: '7d' });
+}
+
+function formatUser(user) {
+  return {
+    id: user._id,
+    name: user.name,
+    email: user.email,
+  };
+}
+
+exports.register = async (req, res) => {
+  try {
+    const { name, email, password } = req.body;
+
+    if (!name || !email || !password) {
+      return res.status(400).json({ message: 'Name, email, and password are required' });
+    }
+
+    if (password.length < 6) {
+      return res.status(400).json({ message: 'Password must be at least 6 characters' });
+    }
+
+    const existing = await User.findOne({ email: email.toLowerCase() });
+    if (existing) {
+      return res.status(409).json({ message: 'Email already registered' });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const user = await User.create({
+      name,
+      email: email.toLowerCase(),//to ensure the email is always lowercase
+      password: hashedPassword,
+    });
+
+    const token = createToken(user._id);
+
+    res.status(201).json({
+      token,
+      user: formatUser(user),
+    });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+}
+
+exports.login = async (req, res) => {
+  try {
+    const { email, password } = req.body;
+
+    if (!email || !password) {
+      return res.status(400).json({ message: 'Email and password are required' });
+    }
+
+    const user = await User.findOne({ email: email.toLowerCase() });
+    if (!user) {
+      return res.status(401).json({ message: 'Invalid email or password' });
+    }
+
+    const match = await bcrypt.compare(password, user.password);
+    if (!match) {
+      return res.status(401).json({ message: 'Invalid email or password' });
+    }
+
+    const token = createToken(user._id);
+
+    res.json({
+      token,
+      user: formatUser(user),
+    });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+}
+
+exports.getMe = async (req, res) => {
+  try {
+    res.json({ user: formatUser(req.user) });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/projects/SRMS/backend/controllers/customerController.js

@@ -0,0 +1,45 @@
+const Customer = require('../models/customer');
+
+exports.addcustomer = async (req, res) => {
+  try {
+    const { customerNumber, firstName, lastName, telephone, address } = req.body;
+
+    const existingCustomer = await Customer.findOne({ customerNumber });
+    if (existingCustomer) {
+      return res.status(409).json({ message: 'Customer number already exists' });
+    }
+
+    const customer = await Customer.create({
+      customerNumber,
+      firstName,
+      lastName,
+      telephone,
+      address,
+    });
+
+    res.status(201).json(customer);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getcustomers = async (req, res) => {
+  try {
+    const customers = await Customer.find().sort({ createdAt: -1 });
+    res.json(customers);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getcustomerbyid = async (req, res) => {
+  try {
+    const customer = await Customer.findById(req.params.id);
+    if (!customer) {
+      return res.status(404).json({ message: 'Customer not found' });
+    }
+    res.json(customer);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/projects/SRMS/backend/controllers/productController.js

@@ -0,0 +1,44 @@
+const Product = require('../models/product');
+
+exports.getproduct = async (req, res) => {
+  try {
+    const products = await Product.find().sort({ createdAt: -1 });
+    res.json(products);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getproductbyid = async (req, res) => {
+  try {
+    const product = await Product.findById(req.params.id);
+    if (!product) {
+      return res.status(404).json({ message: 'Product not found' });
+    }
+    res.json(product);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.addproduct = async (req, res) => {
+  try {
+    const { productCode, productName, quantitySold, unitPrice } = req.body;
+
+    const existing = await Product.findOne({ productCode });
+    if (existing) {
+      return res.status(409).json({ message: 'Product code already exists' });
+    }
+
+    const newproduct = await Product.create({
+      productCode,
+      productName,
+      quantitySold,
+      unitPrice,
+    });
+
+    res.status(201).json(newproduct);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/projects/SRMS/backend/controllers/reportsController.js

@@ -0,0 +1,44 @@
+const Sales = require('../models/sales');
+const Product = require('../models/product');
+const Customer = require('../models/customer');
+
+const sumTotal = (items, field) => items.reduce((total, item) => total + (item[field] || 0), 0);
+
+exports.summary = async (req, res) => {
+  try {
+    const now = new Date();
+    const startOfDay = new Date(now);
+    startOfDay.setHours(0, 0, 0, 0);
+
+    const startOfWeek = new Date(startOfDay);
+    startOfWeek.setDate(startOfWeek.getDate() - startOfWeek.getDay());
+
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+
+    const [productCount, customerCount, salesCount] = await Promise.all([
+      Product.countDocuments(),
+      Customer.countDocuments(),
+      Sales.countDocuments(),
+    ]);
+
+    const [dailySales, weeklySales, monthlySales] = await Promise.all([
+      Sales.find({ salesDate: { $gte: startOfDay } }),
+      Sales.find({ salesDate: { $gte: startOfWeek } }),
+      Sales.find({ salesDate: { $gte: startOfMonth } }),
+    ]);
+
+    res.json({
+      productCount,
+      customerCount,
+      salesCount,
+      dailySalesTotal: sumTotal(dailySales, 'totalAmountPaid'),
+      weeklySalesTotal: sumTotal(weeklySales, 'totalAmountPaid'),
+      monthlySalesTotal: sumTotal(monthlySales, 'totalAmountPaid'),
+      dailySalesCount: dailySales.length,
+      weeklySalesCount: weeklySales.length,
+      monthlySalesCount: monthlySales.length,
+    });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/projects/SRMS/backend/controllers/salesController.js

@@ -0,0 +1,88 @@
+const Sales = require('../models/sales');
+const Product = require('../models/product');
+const Customer = require('../models/customer');
+
+exports.addsales = async (req, res) => {
+  try {
+    const { invoiceNumber, salesDate, paymentMethod, totalAmountPaid, quantitySold, productId, customerId } = req.body;
+
+    const product = await Product.findById(productId);
+    const customer = await Customer.findById(customerId);
+
+    if (!product) return res.status(400).json({ message: 'Product selection is required' });
+    if (!customer) return res.status(400).json({ message: 'Customer selection is required' });
+
+    const existing = await Sales.findOne({ invoiceNumber });
+    if (existing) {
+      return res.status(409).json({ message: 'Invoice number already exists' });
+    }
+
+    const sales = await Sales.create({
+      invoiceNumber,
+      salesDate,
+      paymentMethod,
+      totalAmountPaid,
+      quantitySold,
+      product_FK: productId,
+      customer_FK: customerId,
+    });
+
+    res.status(201).json(sales);
+  } catch (error) {
+    res.status(500).json({ message: error.message });
+  }
+};
+
+exports.getsales = async (req, res) => {
+  try {
+    const sales = await Sales.find().populate('product_FK').populate('customer_FK').sort({ salesDate: -1 });
+    res.status(200).json(sales);
+  } catch (error) {
+    res.status(404).json({ message: 'Sales not found' });
+  }
+};
+
+exports.getsalesbyid = async (req, res) => {
+  try {
+    const sale = await Sales.findById(req.params.id).populate('product_FK').populate('customer_FK');
+    if (!sale) {
+      return res.status(404).json({ message: 'Sale not found' });
+    }
+    res.status(200).json(sale);
+  } catch (error) {
+    res.status(404).json({ message: 'Failed to fetch sale' });
+  }
+};
+
+exports.updatesales = async (req, res) => {
+  try {
+    const { invoiceNumber, salesDate, paymentMethod, totalAmountPaid, quantitySold, productId, customerId } = req.body;
+    const sale = await Sales.findById(req.params.id);
+    if (!sale) return res.status(404).json({ message: 'Sale not found' });
+
+    sale.invoiceNumber = invoiceNumber;
+    sale.salesDate = salesDate;
+    sale.paymentMethod = paymentMethod;
+    sale.totalAmountPaid = totalAmountPaid;
+    sale.quantitySold = quantitySold;
+    sale.product_FK = productId;
+    sale.customer_FK = customerId;
+
+    await sale.save();
+
+    const updatedSale = await Sales.findById(req.params.id).populate('product_FK').populate('customer_FK');
+    res.status(200).json(updatedSale);
+  } catch (error) {
+    res.status(500).json({ message: error.message });
+  }
+};
+
+exports.deletesales = async (req, res) => {
+  try {
+    const deleted = await Sales.findByIdAndDelete(req.params.id);
+    if (!deleted) return res.status(404).json({ message: 'Sale not found' });
+    res.status(200).json({ message: 'Sale deleted successfully' });
+  } catch (error) {
+    res.status(500).json({ message: error.message });
+  }
+};

package/projects/SRMS/backend/middleware/auth.js

@@ -1,17 +1,32 @@
+// this middleware is helping us to protect our routes so that only authenticated users can access the routes
+//it is checking if the user is authenticated by checking the token in the header(the header is the part of the request that contains the token)
+//if the user is not authenticated, it will return a 401 status code and a message that the user is not authorized
+//if the user is authenticated, it will return the user object
+//and the user object is the user that is authenticated
 
-import jwt from 'jsonwebtoken'
+const jwt = require('jsonwebtoken');
+const User = require('../models/User');
+const JWT_SECRET = 'change_this_to_a_long_random_secret';
 
-const protect = (req, res, next) => {
-    const token = req.headers.authorization?.split(" ")[1];
-    if (!token) return res.status(401).json({ message: "Not authorized" });
-    
-    try {
-        const decoded = jwt.verify(token, process.env.JWT_SECRET);
-        req.user = decoded;
-        next(); 
-    } catch {
-        res.status(401).json({ message: "Invalid token" });
+exports.protect = async (req, res, next) => {
+  try {
+    const header = req.headers.authorization;
+
+    if (!header || !header.startsWith('Bearer ')) {
+      return res.status(401).json({ message: 'Not authorized' });
+    }
+
+    const token = header.split(' ')[1];
+    const decoded = jwt.verify(token, JWT_SECRET);
+    const user = await User.findById(decoded.userId).select('-password');
+
+    if (!user) {
+      return res.status(401).json({ message: 'Not authorized' });
     }
-}
 
-export default protect;
+    req.user = user;
+    next();
+  } catch (err) {
+    return res.status(401).json({ message: 'Not authorized' });
+  }
+};

package/projects/SRMS/backend/models/User.js

@@ -1,8 +1,28 @@
-import mongoose from 'mongoose'
+const mongoose = require('mongoose');
 
-const userSchema = new mongoose.Schema({
-    username:{type:String, required:true},
-    password:{type:String, required:true}
-});
+const userSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true,
+    },
+    password: {
+      type: String,
+      required: true,
+      minlength: 6,
+    },
+  },
+  { timestamps: true }
+);
 
-export default mongoose.model("User", userSchema);
+const User = mongoose.model('User', userSchema);
+
+module.exports = User;