create-sales 1.0.0

package/backend-project/routes/users.js

@@ -0,0 +1,86 @@
+const express = require('express');
+const router = express.Router();
+const bcrypt = require('bcryptjs');
+const pool = require('../db');
+const { requireAuth, requireAdmin } = require('../middleware/auth');
+
+// GET /api/users — Get all users (admin only)
+router.get('/', requireAdmin, async (req, res) => {
+  try {
+    const [rows] = await pool.execute('SELECT UserID, UserName, UserRole FROM yk_users ORDER BY UserID DESC');
+    res.json(rows);
+  } catch (err) {
+    res.status(500).json({ message: 'Server error', error: err.message });
+  }
+});
+
+// POST /api/users — Create user (admin only)
+router.post('/', requireAdmin, async (req, res) => {
+  const { UserName, Password, UserRole } = req.body;
+  if (!UserName || !Password || !UserRole) {
+    return res.status(400).json({ message: 'UserName, Password, and UserRole are required.' });
+  }
+  try {
+    const hashedPassword = await bcrypt.hash(Password, 10);
+    const [result] = await pool.execute(
+      'INSERT INTO yk_users (UserName, Password, UserRole) VALUES (?, ?, ?)',
+      [UserName, hashedPassword, UserRole]
+    );
+    const [newUser] = await pool.execute(
+      'SELECT UserID, UserName, UserRole FROM yk_users WHERE UserID = ?',
+      [result.insertId]
+    );
+    res.status(201).json(newUser[0]);
+  } catch (err) {
+    if (err.code === 'ER_DUP_ENTRY') {
+      return res.status(409).json({ message: 'A user with this username already exists.' });
+    }
+    res.status(500).json({ message: 'Server error', error: err.message });
+  }
+});
+
+// PUT /api/users/:id — Update user (admin only)
+router.put('/:id', requireAdmin, async (req, res) => {
+  const { UserName, Password, UserRole } = req.body;
+  try {
+    if (Password) {
+      const hashedPassword = await bcrypt.hash(Password, 10);
+      await pool.execute(
+        'UPDATE yk_users SET UserName = ?, Password = ?, UserRole = ? WHERE UserID = ?',
+        [UserName, hashedPassword, UserRole, req.params.id]
+      );
+    } else {
+      await pool.execute(
+        'UPDATE yk_users SET UserName = ?, UserRole = ? WHERE UserID = ?',
+        [UserName, UserRole, req.params.id]
+      );
+    }
+    const [updated] = await pool.execute(
+      'SELECT UserID, UserName, UserRole FROM yk_users WHERE UserID = ?',
+      [req.params.id]
+    );
+    if (updated.length === 0) return res.status(404).json({ message: 'User not found' });
+    res.json(updated[0]);
+  } catch (err) {
+    if (err.code === 'ER_DUP_ENTRY') {
+      return res.status(409).json({ message: 'A user with this username already exists.' });
+    }
+    res.status(500).json({ message: 'Server error', error: err.message });
+  }
+});
+
+// DELETE /api/users/:id — Delete user (admin only)
+router.delete('/:id', requireAdmin, async (req, res) => {
+  if (parseInt(req.params.id) === req.session.user.UserID) {
+    return res.status(400).json({ message: 'You cannot delete your own account.' });
+  }
+  try {
+    const [result] = await pool.execute('DELETE FROM yk_users WHERE UserID = ?', [req.params.id]);
+    if (result.affectedRows === 0) return res.status(404).json({ message: 'User not found' });
+    res.json({ message: 'User deleted successfully' });
+  } catch (err) {
+    res.status(500).json({ message: 'Server error', error: err.message });
+  }
+});
+
+module.exports = router;

package/backend-project/server.js

@@ -0,0 +1,54 @@
+const express = require('express');
+const session = require('express-session');
+const cors = require('cors');
+const path = require('path');
+
+const authRoutes = require('./routes/auth');
+const busRoutes = require('./routes/buses');
+const scheduleRoutes = require('./routes/schedules');
+const bookingRoutes = require('./routes/bookings');
+const userRoutes = require('./routes/users');
+
+const app = express();
+const PORT = process.env.PORT || 5000;
+
+// ─── Middleware ────────────────────────────────────────────────
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// CORS — allow frontend origin with credentials
+app.use(cors({
+  origin: ['http://localhost:5173', 'http://localhost:3000'],
+  credentials: true,
+}));
+
+// Session configuration (session-based auth)
+app.use(session({
+  secret: process.env.SESSION_SECRET || 'ybus_secret_key_2026',
+  resave: false,
+  saveUninitialized: false,
+  cookie: {
+    httpOnly: true,
+    secure: false,         // set to true in production with HTTPS
+    maxAge: 1000 * 60 * 60 * 8, // 8 hours
+    sameSite: 'lax',
+  },
+}));
+
+// ─── Routes ───────────────────────────────────────────────────
+app.use('/api/auth', authRoutes);
+app.use('/api/buses', busRoutes);
+app.use('/api/schedules', scheduleRoutes);
+app.use('/api/bookings', bookingRoutes);
+app.use('/api/users', userRoutes);
+
+// Health check
+app.get('/api/health', (req, res) => {
+  res.json({ status: 'OK', message: 'Y-Bus API is running', timestamp: new Date() });
+});
+
+// ─── Start Server ─────────────────────────────────────────────
+app.listen(PORT, () => {
+  console.log(`\n🚌 Y-Bus Reservation API running on http://localhost:${PORT}`);
+  console.log(`📋 Health check: http://localhost:${PORT}/api/health\n`);
+});

package/bin/create-sales.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const targetArg = process.argv[2];
+const targetDir = path.resolve(process.cwd(), targetArg ?? ".");
+const projectName = path.basename(targetDir);
+
+const ignoredNames = new Set([
+  "bin",
+  "node_modules",
+  "dist",
+  ".git",
+  ".npmignore",
+  "package-lock.json",
+]);
+
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function copyEntry(sourcePath, destinationPath) {
+  const stats = await fs.lstat(sourcePath);
+
+  if (stats.isDirectory()) {
+    await fs.mkdir(destinationPath, { recursive: true });
+    const entries = await fs.readdir(sourcePath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (ignoredNames.has(entry.name)) {
+        continue;
+      }
+
+      await copyEntry(
+        path.join(sourcePath, entry.name),
+        path.join(destinationPath, entry.name)
+      );
+    }
+
+    return;
+  }
+
+  await fs.copyFile(sourcePath, destinationPath);
+}
+
+async function main() {
+  if (await pathExists(targetDir)) {
+    const existingEntries = await fs.readdir(targetDir);
+    if (existingEntries.length > 0) {
+      console.error(`Target directory "${targetDir}" is not empty.`);
+      process.exit(1);
+    }
+  } else {
+    await fs.mkdir(targetDir, { recursive: true });
+  }
+
+  const destinationPackage = {
+    name: projectName,
+    private: true,
+    version: "0.0.0",
+    type: "module",
+    scripts: {
+      "dev:frontend": "npm run dev --workspace frontend-project",
+      "build:frontend": "npm run build --workspace frontend-project",
+      "dev:backend": "npm run dev --workspace backend-project",
+      "start:backend": "npm start --workspace backend-project",
+    },
+  };
+
+  const sourceEntries = await fs.readdir(packageRoot, { withFileTypes: true });
+
+  for (const entry of sourceEntries) {
+    if (ignoredNames.has(entry.name) || entry.name === "package.json") {
+      continue;
+    }
+
+    await copyEntry(
+      path.join(packageRoot, entry.name),
+      path.join(targetDir, entry.name)
+    );
+  }
+
+  await fs.writeFile(
+    path.join(targetDir, "package.json"),
+    `${JSON.stringify(destinationPackage, null, 2)}\n`
+  );
+
+  console.log(`Created ${projectName} in ${targetDir}`);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/frontend-project/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Y Bus Reservation System</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/frontend-project/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "react-vite-tailwind",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@types/react-router-dom": "^5.3.3",
+    "axios": "^1.16.1",
+    "clsx": "2.1.1",
+    "react": "19.2.6",
+    "react-dom": "19.2.6",
+    "react-router-dom": "^7.15.1",
+    "tailwind-merge": "3.4.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "4.1.17",
+    "@types/node": "22.19.17",
+    "@types/react": "19.2.7",
+    "@types/react-dom": "19.2.3",
+    "@vitejs/plugin-react": "5.1.1",
+    "tailwindcss": "4.1.17",
+    "typescript": "5.9.3",
+    "vite": "7.3.2",
+    "vite-plugin-singlefile": "2.3.0"
+  }
+}

package/frontend-project/src/App.tsx

@@ -0,0 +1,77 @@
+import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom';
+import { AuthProvider } from './context/AuthContext';
+import ProtectedRoute from './components/common/ProtectedRoute';
+import Layout from './components/common/Layout';
+import Login from './pages/Login';
+import Dashboard from './pages/Dashboard';
+import Buses from './pages/Buses';
+import Schedules from './pages/Schedules';
+import Bookings from './pages/Bookings';
+import Report from './pages/Report';
+import Users from './pages/Users';
+
+function App() {
+  return (
+    <BrowserRouter>
+      <AuthProvider>
+        <Routes>
+          <Route path="/login" element={<Login />} />
+          <Route path="/" element={<Navigate to="/dashboard" replace />} />
+
+          <Route
+            path="/dashboard"
+            element={
+              <ProtectedRoute>
+                <Layout><Dashboard /></Layout>
+              </ProtectedRoute>
+            }
+          />
+          <Route
+            path="/buses"
+            element={
+              <ProtectedRoute>
+                <Layout><Buses /></Layout>
+              </ProtectedRoute>
+            }
+          />
+          <Route
+            path="/schedules"
+            element={
+              <ProtectedRoute>
+                <Layout><Schedules /></Layout>
+              </ProtectedRoute>
+            }
+          />
+          <Route
+            path="/bookings"
+            element={
+              <ProtectedRoute>
+                <Layout><Bookings /></Layout>
+              </ProtectedRoute>
+            }
+          />
+          <Route
+            path="/report"
+            element={
+              <ProtectedRoute>
+                <Layout><Report /></Layout>
+              </ProtectedRoute>
+            }
+          />
+          <Route
+            path="/users"
+            element={
+              <ProtectedRoute adminOnly>
+                <Layout><Users /></Layout>
+              </ProtectedRoute>
+            }
+          />
+
+          <Route path="*" element={<Navigate to="/dashboard" replace />} />
+        </Routes>
+      </AuthProvider>
+    </BrowserRouter>
+  );
+}
+
+export default App;

package/frontend-project/src/api/auth.ts

@@ -0,0 +1,20 @@
+import api from './axios';
+import { User } from '../types';
+
+export const login = async (UserName: string, Password: string): Promise<User> => {
+  const res = await api.post('/auth/login', { UserName, Password });
+  return res.data.user;
+};
+
+export const logout = async (): Promise<void> => {
+  await api.post('/auth/logout');
+};
+
+export const getSession = async (): Promise<User | null> => {
+  try {
+    const res = await api.get('/auth/session');
+    return res.data.user;
+  } catch {
+    return null;
+  }
+};

package/frontend-project/src/api/axios.ts

@@ -0,0 +1,11 @@
+import axios from 'axios';
+
+const api = axios.create({
+  baseURL: 'http://localhost:5000/api',
+  withCredentials: true,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+export default api;

package/frontend-project/src/api/bookings.ts

@@ -0,0 +1,31 @@
+import api from './axios';
+import { Booking } from '../types';
+
+export const getBookings = async (): Promise<Booking[]> => {
+  const res = await api.get('/bookings');
+  return res.data;
+};
+
+export const getBooking = async (id: number): Promise<Booking> => {
+  const res = await api.get(`/bookings/${id}`);
+  return res.data;
+};
+
+export const createBooking = async (data: Omit<Booking, 'BookingID'>): Promise<Booking> => {
+  const res = await api.post('/bookings', data);
+  return res.data;
+};
+
+export const updateBooking = async (id: number, data: Partial<Booking>): Promise<Booking> => {
+  const res = await api.put(`/bookings/${id}`, data);
+  return res.data;
+};
+
+export const deleteBooking = async (id: number): Promise<void> => {
+  await api.delete(`/bookings/${id}`);
+};
+
+export const getPassengerReport = async () => {
+  const res = await api.get('/bookings/report/passengers');
+  return res.data;
+};

package/frontend-project/src/api/buses.ts

@@ -0,0 +1,26 @@
+import api from './axios';
+import { Bus } from '../types';
+
+export const getBuses = async (): Promise<Bus[]> => {
+  const res = await api.get('/buses');
+  return res.data;
+};
+
+export const getBus = async (id: number): Promise<Bus> => {
+  const res = await api.get(`/buses/${id}`);
+  return res.data;
+};
+
+export const createBus = async (data: Omit<Bus, 'BusID'>): Promise<Bus> => {
+  const res = await api.post('/buses', data);
+  return res.data;
+};
+
+export const updateBus = async (id: number, data: Omit<Bus, 'BusID'>): Promise<Bus> => {
+  const res = await api.put(`/buses/${id}`, data);
+  return res.data;
+};
+
+export const deleteBus = async (id: number): Promise<void> => {
+  await api.delete(`/buses/${id}`);
+};

package/frontend-project/src/api/schedules.ts

@@ -0,0 +1,26 @@
+import api from './axios';
+import { Schedule } from '../types';
+
+export const getSchedules = async (): Promise<Schedule[]> => {
+  const res = await api.get('/schedules');
+  return res.data;
+};
+
+export const getSchedule = async (id: number): Promise<Schedule> => {
+  const res = await api.get(`/schedules/${id}`);
+  return res.data;
+};
+
+export const createSchedule = async (data: Omit<Schedule, 'ScheduleID'>): Promise<Schedule> => {
+  const res = await api.post('/schedules', data);
+  return res.data;
+};
+
+export const updateSchedule = async (id: number, data: Omit<Schedule, 'ScheduleID'>): Promise<Schedule> => {
+  const res = await api.put(`/schedules/${id}`, data);
+  return res.data;
+};
+
+export const deleteSchedule = async (id: number): Promise<void> => {
+  await api.delete(`/schedules/${id}`);
+};

package/frontend-project/src/api/users.ts

@@ -0,0 +1,21 @@
+import api from './axios';
+import { User } from '../types';
+
+export const getUsers = async (): Promise<User[]> => {
+  const res = await api.get('/users');
+  return res.data;
+};
+
+export const createUser = async (data: { UserName: string; Password: string; UserRole: string }): Promise<User> => {
+  const res = await api.post('/users', data);
+  return res.data;
+};
+
+export const updateUser = async (id: number, data: { UserName?: string; Password?: string; UserRole?: string }): Promise<User> => {
+  const res = await api.put(`/users/${id}`, data);
+  return res.data;
+};
+
+export const deleteUser = async (id: number): Promise<void> => {
+  await api.delete(`/users/${id}`);
+};

package/frontend-project/src/components/common/Layout.tsx

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import Navbar from './Navbar';
+
+const Layout = ({ children }: { children: ReactNode }) => {
+  return (
+    <div className="min-h-screen bg-gray-50">
+      <Navbar />
+      <main className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6">
+        {children}
+      </main>
+    </div>
+  );
+};
+
+export default Layout;

package/frontend-project/src/components/common/Modal.tsx

@@ -0,0 +1,42 @@
+import { ReactNode } from 'react';
+
+interface ModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  title: string;
+  children: ReactNode;
+  size?: 'sm' | 'md' | 'lg' | 'xl';
+}
+
+const Modal = ({ isOpen, onClose, title, children, size = 'md' }: ModalProps) => {
+  if (!isOpen) return null;
+
+  const sizeClasses = {
+    sm: 'max-w-sm',
+    md: 'max-w-md',
+    lg: 'max-w-lg',
+    xl: 'max-w-2xl',
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center px-4">
+      <div className="absolute inset-0 bg-black/60 backdrop-blur-sm" onClick={onClose} />
+      <div className={`relative bg-white rounded-xl shadow-2xl w-full ${sizeClasses[size]} max-h-[90vh] overflow-y-auto`}>
+        <div className="flex items-center justify-between p-5 border-b border-gray-200 bg-gray-900 rounded-t-xl">
+          <h2 className="text-lg font-semibold text-yellow-400">{title}</h2>
+          <button
+            onClick={onClose}
+            className="text-gray-400 hover:text-white transition-colors"
+          >
+            <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+            </svg>
+          </button>
+        </div>
+        <div className="p-5">{children}</div>
+      </div>
+    </div>
+  );
+};
+
+export default Modal;