Bong Flavours - Bengali Restaurant E-Commerce Platform

A comprehensive Next.js-based e-commerce platform for a Bengali restaurant featuring advanced order management, automated PDF bill generation, and dual-delivery email system.

� Features

Core Functionality

Interactive Menu System: Browse authentic Bengali dishes with detailed descriptions
User Authentication: Secure login/signup with JWT tokens and dual authentication support
Order Management: Complete order lifecycle from cart to delivery
Automated Bill Generation: PDF invoices generated using Puppeteer with professional formatting
Dual Email Delivery: Bills automatically sent to both customer and admin
Profile Management: User profile updates with address management
Admin Dashboard: Order management and system administration

Technical Highlights

Next.js 15.5.0 with App Router and TypeScript
MongoDB Atlas for data persistence with comprehensive models
Dual Authentication System: Cookie-based and Bearer token support for browser compatibility
Puppeteer PDF Generation with Chrome path detection and fallback support
Nodemailer Integration for reliable email delivery
Responsive Design with Tailwind CSS
Server-Side Validation using Zod schemas

🚀 Quick Start

Prerequisites

Node.js 18+ and npm
MongoDB Atlas account or local MongoDB instance
SMTP email service (Gmail recommended)

Installation

Clone the repository

git clone https://github.com/DebdootManna/bong-flavours
cd bong-flavours

Install dependencies
```
npm install
```

Environment Configuration Create a .env.local file in the root directory:

# MongoDB Configuration
MONGODB_URI=your_mongodb_connection_string

# JWT Configuration
JWT_SECRET=your_super_secure_jwt_secret_key_here

# Email Configuration (SMTP)
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=your_email@gmail.com
SMTP_PASS=your_app_specific_password
ADMIN_EMAIL=admin@bongflavours.com

# Application Configuration
NEXT_PUBLIC_APP_URL=http://localhost:3000

Start the development server
```
npm run dev
```
Access the application Open http://localhost:3000 in your browser

🗄️ MongoDB Database Setup

Automated Database Setup

The application includes comprehensive MongoDB models with automatic validation and schema enforcement.

Required Collections

The following collections will be automatically created:

1. Users Collection

{
  _id: ObjectId,
  name: String (required),
  email: String (required, unique, indexed),
  phone: String (required, unique, indexed),
  password: String (required, hashed),
  role: String (enum: ['customer', 'admin'], default: 'customer'),
  address: String (optional),
  city: String (optional),
  zipCode: String (optional),
  createdAt: Date,
  updatedAt: Date
}

2. Orders Collection

{
  _id: ObjectId,
  orderNumber: String (required, unique, auto-generated),
  userId: ObjectId (required, references Users),
  items: [{
    menuItemId: String (required),
    name: String (required),
    price: Number (required),
    quantity: Number (required),
    variant: String (optional),
    specialInstructions: String (optional)
  }],
  customerInfo: {
    name: String (required),
    email: String (required),
    phone: String (required),
    address: String (required)
  },
  deliveryInfo: {
    address: String (required),
    phone: String (required),
    deliveryNotes: String (optional)
  },
  total: Number (required),
  status: String (enum: ['pending', 'confirmed', 'preparing', 'ready', 'delivered', 'cancelled'], default: 'pending'),
  paymentMethod: String (enum: ['cod', 'online'], default: 'cod'),
  notes: String (optional),
  createdAt: Date,
  updatedAt: Date
}

Database Seeding Instructions for Local Development

Method 1: Using MongoDB Compass (Recommended for Beginners)

Install MongoDB Compass Download from MongoDB Compass
Connect to your MongoDB instance
- Local: mongodb://localhost:27017
- Atlas: Use your connection string from MongoDB Atlas
Create Database
- Database name: bongflavours

Import Sample Data Create the following collections and import sample documents:

Users Collection Sample:

[
  {
    "name": "Admin User",
    "email": "admin@bongflavours.com",
    "phone": "9876543210",
    "password": "$2b$10$hashedPasswordHere",
    "role": "admin",
    "createdAt": new Date(),
    "updatedAt": new Date()
  },
  {
    "name": "John Customer",
    "email": "customer@example.com",
    "phone": "9876543211",
    "password": "$2b$10$hashedPasswordHere",
    "role": "customer",
    "address": "123 Main Street",
    "city": "Kolkata",
    "zipCode": "700001",
    "createdAt": new Date(),
    "updatedAt": new Date()
  }
]

Method 2: Using MongoDB Shell

Connect to MongoDB

mongosh "your_mongodb_connection_string"

Switch to database
```
use bongflavours
```

Create admin user

db.users.insertOne({
  name: "Admin User",
  email: "admin@bongflavours.com",
  phone: "9876543210",
  password: "$2b$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi", // "password"
  role: "admin",
  createdAt: new Date(),
  updatedAt: new Date(),
});

Create sample customer

db.users.insertOne({
  name: "Test Customer",
  email: "customer@example.com",
  phone: "9876543211",
  password: "$2b$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi", // "password"
  role: "customer",
  address: "123 Main Street",
  city: "Kolkata",
  zipCode: "700001",
  createdAt: new Date(),
  updatedAt: new Date(),
});

Create indexes for performance

db.users.createIndex({ email: 1 }, { unique: true });
db.users.createIndex({ phone: 1 }, { unique: true });
db.orders.createIndex({ userId: 1 });
db.orders.createIndex({ orderNumber: 1 }, { unique: true });
db.orders.createIndex({ createdAt: -1 });

Method 3: Using Node.js Seeding Script

Create a seeding script scripts/seed.js:

const { MongoClient } = require("mongodb");
const bcrypt = require("bcryptjs");

const MONGODB_URI = "your_mongodb_connection_string";

async function seedDatabase() {
  const client = new MongoClient(MONGODB_URI);

  try {
    await client.connect();
    const db = client.db("bongflavours");

    // Hash password
    const hashedPassword = await bcrypt.hash("password", 10);

    // Insert admin user
    await db.collection("users").insertOne({
      name: "Admin User",
      email: "admin@bongflavours.com",
      phone: "9876543210",
      password: hashedPassword,
      role: "admin",
      createdAt: new Date(),
      updatedAt: new Date(),
    });

    // Insert sample customer
    await db.collection("users").insertOne({
      name: "Test Customer",
      email: "customer@example.com",
      phone: "9876543211",
      password: hashedPassword,
      role: "customer",
      address: "123 Main Street",
      city: "Kolkata",
      zipCode: "700001",
      createdAt: new Date(),
      updatedAt: new Date(),
    });

    console.log("Database seeded successfully!");
  } catch (error) {
    console.error("Seeding failed:", error);
  } finally {
    await client.close();
  }
}

seedDatabase();

Run the seeding script:

node scripts/seed.js

Environment-Specific Database Configuration

For Local Development

MONGODB_URI=mongodb://localhost:27017/bongflavours

For MongoDB Atlas (Production)

MONGODB_URI=mongodb+srv://username:password@cluster.mongodb.net/bongflavours?retryWrites=true&w=majority

🔧 Configuration Guide

Email Configuration (Gmail)

Enable 2-Factor Authentication on your Gmail account
Generate App Password:
- Go to Google Account settings
- Security → 2-Step Verification → App passwords
- Generate password for "Mail"

Update Environment Variables:

SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=your_email@gmail.com
SMTP_PASS=your_16_character_app_password

MongoDB Atlas Setup

Create MongoDB Atlas Account at mongodb.com
Create a New Cluster
Configure Network Access:
- Add your IP address (or 0.0.0.0/0 for development)
Create Database User:
- Username/password for database access
Get Connection String:
- Replace <password> with your database user password
- Update MONGODB_URI in .env.local

JWT Configuration

Generate a secure JWT secret:

node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

Add to .env.local:

JWT_SECRET=your_generated_secret_here

🏗️ Project Structure

bong-flavours/
├── src/
│   ├── app/
│   │   ├── api/                 # API routes
│   │   │   ├── auth/           # Authentication endpoints
│   │   │   ├── orders/         # Order management
│   │   │   └── menu/           # Menu system
│   │   ├── app/                # Protected application routes
│   │   │   ├── menu/           # Menu browsing
│   │   │   ├── checkout/       # Order checkout
│   │   │   └── profile/        # User profile
│   │   ├── admin/              # Admin dashboard
│   │   ├── login/              # Authentication pages
│   │   └── signup/
│   ├── components/             # Reusable UI components
│   ├── contexts/               # React contexts (Auth, Cart)
│   ├── lib/                    # Utility libraries
│   │   ├── mongodb.ts          # Database connection
│   │   ├── auth.ts             # Authentication utilities
│   │   ├── invoice.ts          # PDF generation
│   │   └── mailer.ts           # Email utilities
│   ├── models/                 # MongoDB models
│   └── data/                   # Static data (menu items)
├── public/                     # Static assets
└── package.json

🔒 Authentication System

Dual Authentication Support

The application supports both cookie-based and Bearer token authentication for maximum browser compatibility:

Cookie Authentication: Traditional httpOnly cookies (primary)
Bearer Token Authentication: localStorage-based tokens (fallback for VS Code Simple Browser)

Authentication Flow

User logs in via /api/auth/login-v2
JWT token stored in both httpOnly cookie and localStorage
API requests check Authorization header first, then cookie
Profile updates work seamlessly across all browser environments

📧 Email System

Bill Generation and Delivery

Order Creation: Triggers automatic PDF generation
PDF Generation: Professional invoice created using Puppeteer
Dual Delivery: Email sent to both customer and admin
Error Handling: Robust error handling with detailed logging

Email Templates

Customer email includes order details and PDF attachment
Admin email includes complete order information for processing
Professional HTML formatting with Bengali restaurant branding

🧪 Testing the Application

Complete Order Flow Test

Register/Login:

Email: customer@example.com
Password: password

Browse Menu: Navigate to /app/menu
Add Items to Cart: Select dishes and quantities
Proceed to Checkout: Fill in delivery information
Place Order: Complete the order process
Verify Email Delivery: Check both customer and admin emails for PDF bills

Authentication Testing

Login Flow: Test with VS Code Simple Browser and regular browsers
Profile Updates: Modify user profile information
Order History: View past orders in profile dashboard
Admin Access: Login as admin to manage orders

PDF Generation Testing

The system automatically generates professional PDF bills with:

Company branding and logo
Complete order details
Customer and delivery information
Itemized pricing and totals
Order number and timestamps

📊 Admin Features

Order Management

View all orders with filtering and pagination
Update order status (pending → confirmed → preparing → ready → delivered)
Customer information management
Revenue tracking and analytics

User Management

View customer accounts
Order history per customer
Communication tools

🚀 Deployment

Production Environment Variables

# Production MongoDB
MONGODB_URI=mongodb+srv://username:password@cluster.mongodb.net/bongflavours_prod

# Secure JWT Secret
JWT_SECRET=production_secure_secret_32_characters_minimum

# Production Email Configuration
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=production_email@bongflavours.com
SMTP_PASS=production_app_password
ADMIN_EMAIL=admin@bongflavours.com

# Production URL
NEXT_PUBLIC_APP_URL=https://your-domain.com

Build and Deploy

npm run build
npm start

🐛 Troubleshooting

Common Issues

Authentication Not Working:
- Verify JWT_SECRET is set
- Check MongoDB connection
- Clear browser localStorage and cookies
PDF Generation Fails:
- Ensure Chrome/Chromium is installed
- Check Puppeteer configuration
- Verify sufficient system memory
Emails Not Sending:
- Verify SMTP credentials
- Check Gmail app password configuration
- Ensure network connectivity
Database Connection Issues:
- Verify MongoDB URI format
- Check network access in MongoDB Atlas
- Ensure database user permissions

Debug Mode

Enable detailed logging by setting:

NODE_ENV=development

📱 Browser Compatibility

Chrome/Chromium: Full functionality
Firefox: Full functionality
Safari: Full functionality
VS Code Simple Browser: Full functionality with Bearer token authentication
Mobile browsers: Responsive design optimized

🔧 Development Tools

Recommended VS Code Extensions

ES7+ React/Redux/React-Native snippets
Tailwind CSS IntelliSense
MongoDB for VS Code
Thunder Client (API testing)

Testing APIs

Use the included Postman collection or Thunder Client to test API endpoints:

Authentication endpoints
Order creation and management
Profile updates
Admin functionality

📈 Performance Optimizations

Next.js App Router: Optimized routing and caching
MongoDB Indexing: Efficient database queries
Image Optimization: Next.js automatic image optimization
Lazy Loading: Components loaded on demand
PDF Caching: Generated PDFs cached for performance

🤝 Contributing

Fork the repository
Create a feature branch
Commit your changes
Push to the branch
Create a Pull Request

📄 License

This project is licensed under the MIT License.

🍛 About Bong Flavours

Bong Flavours is a tribute to authentic Bengali cuisine, bringing the rich flavors and traditions of Bengal to your table through modern e-commerce technology.

For technical support or questions, please contact the development team or create an issue in the repository.

🌟 Features

🔐 Authentication & User Management

Dual Authentication System: Separate login for customers and restaurant admin
JWT-based Security: Secure token-based authentication with HTTP-only cookies
Role-based Access Control: Different interfaces for customers and admin users
Profile Management: Customer dashboard with order history and profile editing

🛒 E-commerce Functionality

Smart Menu System: Public browsing menu and authenticated ordering menu
Shopping Cart: Persistent cart with real-time quantity updates
Checkout Process: Complete order flow with customer information validation
Order Management: Full order lifecycle from placement to delivery
Invoice Generation: Automated order confirmations and receipts

👨‍💼 Admin Dashboard

Order Management: View, update, and track all customer orders
Menu Management: Add, edit, and manage restaurant menu items
Customer Management: View customer profiles and order history
Analytics: Order statistics and business insights

🍽️ Menu Features

Categorized Menu: Organized by food categories (Shorbot, Rice, Curry, etc.)
Vegetarian Filtering: Clear VEG/NON-VEG labeling and filtering
Search Functionality: Text-based menu item search
Detailed Item Info: Prices, descriptions, and availability status

📱 Modern UI/UX

Responsive Design: Mobile-first responsive layout
Smooth Animations: Framer Motion powered transitions
Loading States: Skeleton loading and progress indicators
Error Handling: Comprehensive error states and user feedback

🛠️ Technology Stack

Frontend

Next.js 15.5.0: React framework with App Router
TypeScript: Type-safe development
Tailwind CSS: Utility-first CSS framework
Framer Motion: Animation library
React Context API: State management for cart and authentication

Backend

MongoDB Atlas: Cloud database with Mongoose ODM
JWT Authentication: Secure token-based auth
bcryptjs: Password hashing and security
Nodemailer: Email notifications
Zod: Runtime type validation

Development Tools

ESLint: Code linting and quality
Puppeteer: PDF processing
Sharp: Image optimization
Socket.io: Real-time communication (future feature)

📋 Prerequisites

Before setting up the project, ensure you have:

Node.js (v18 or higher)
npm (v9 or higher)
MongoDB Atlas account (free tier works)
Git for version control
Code editor (VS Code recommended)

🚀 Quick Start

1. Clone the Repository

git clone https://github.com/DebdootManna/bong-flavours.git
cd bong-flavours

2. Install Dependencies

npm install

3. Environment Setup

Copy the environment template and configure your settings:

cp .env.example .env.local

Edit .env.local with your actual values:

# Database Configuration
MONGODB_URI=mongodb+srv://username:password@cluster.mongodb.net/bong-flavours?retryWrites=true&w=majority

# Authentication
JWT_SECRET=your-super-secret-jwt-key-minimum-32-characters-long
NEXTAUTH_SECRET=your-nextauth-secret-key
NEXTAUTH_URL=http://localhost:3000

# Email Configuration (Gmail example)
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_SECURE=false
SMTP_USER=your-email@gmail.com
SMTP_PASS=your-app-password

# Site Configuration
NEXT_PUBLIC_SITE_URL=http://localhost:3000
NEXT_PUBLIC_RESTAURANT_EMAIL=mannadebdoot007@gmail.com
NEXT_PUBLIC_RESTAURANT_PHONE=8238018577

# Admin Credentials
ADMIN_EMAIL=admin@bongflavours.com
ADMIN_PASSWORD=admin123

4. Database Setup

The project includes automated scripts to seed your MongoDB database with menu items and demo users.

Seed Menu Items

npm run seed:menu

Seed Demo Users

npm run seed:users

Seed Everything at Once

npm run seed:all

5. Start Development Server

npm run dev

Your application will be available at http://localhost:3000

🗄️ MongoDB Database Setup Guide

Setting Up MongoDB Atlas

Create MongoDB Atlas Account
- Go to MongoDB Atlas
- Sign up for a free account
- Create a new project
Create a Cluster
- Click "Create Cluster"
- Choose "M0 Sandbox" (free tier)
- Select your preferred cloud provider and region
- Name your cluster (e.g., "bong-flavours-cluster")
Configure Database Access
- Go to "Database Access" in the left sidebar
- Click "Add New Database User"
- Create a user with "Read and write to any database" permissions
- Note down the username and password
Configure Network Access
- Go to "Network Access" in the left sidebar
- Click "Add IP Address"
- For development, add "0.0.0.0/0" (allows access from anywhere)
- For production, add only your server's IP addresses
Get Connection String
- Go to "Clusters" and click "Connect"
- Choose "Connect your application"
- Copy the connection string
- Replace <username>, <password>, and <dbname> with your values

Local MongoDB Setup (Alternative)

If you prefer running MongoDB locally:

macOS (using Homebrew)

# Install MongoDB
brew tap mongodb/brew
brew install mongodb-community

# Start MongoDB service
brew services start mongodb/brew/mongodb-community

# Create database directory
sudo mkdir -p /data/db
sudo chown -R `id -un` /data/db

Ubuntu/Debian

# Import MongoDB public GPG key
wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -

# Add MongoDB repository
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list

# Install MongoDB
sudo apt-get update
sudo apt-get install -y mongodb-org

# Start MongoDB service
sudo systemctl start mongod
sudo systemctl enable mongod

Windows

Download MongoDB Community Server from MongoDB Download Center
Run the installer with default settings
MongoDB will be installed as a Windows service

Local Connection String

For local MongoDB, use this connection string in your .env.local:

MONGODB_URI=mongodb://localhost:27017/bong-flavours

Database Collections

The application automatically creates these collections:

users - Customer and admin accounts
menuitems - Restaurant menu items
orders - Customer orders
sessions - User sessions (if using NextAuth)

Seeding Instructions for Local Machines

1. Menu Data Seeding

The scripts/seedMenu.js script will:

Read menu data from data/menu.json
Clear existing menu items
Insert 100+ Bengali food items
Create database indexes for performance
Display seeding statistics

Run the script:

npm run seed:menu

Expected output:

📖 Loaded 158 menu items from data/menu.json
🔌 Connecting to MongoDB...
🗑️  Clearing existing menu items...
📝 Inserting menu items...
✅ Successfully seeded 158 menu items
🔍 Creating database indexes...

📊 Seeding Statistics:
   Total items: 158
   Vegetarian: 89
   Non-vegetarian: 69
   Categories: 8
   Categories: Shorbot, Rice, Fish, Chicken, Mutton, Veg, Prawn, Egg

🎉 Menu seeding completed successfully!

2. User Account Seeding

The scripts/seedUsers.js script will:

Create admin and customer demo accounts
Hash all passwords securely
Create database indexes
Display account credentials

Run the script:

npm run seed:users

Expected output:

👥 Starting user seeding process...
📝 Preparing to create 6 demo accounts

🔌 Connecting to MongoDB...
🔐 Hashing passwords...
📝 Inserting demo users...
✅ Successfully created 6 demo accounts

📊 Demo Accounts Summary:
==================================================

👨‍💼 ADMIN ACCOUNT:
------------------------------
   Name: Restaurant Admin
   Email: admin@bongflavours.com
   Phone: 9876543210
   Password: admin123
   Role: admin

👥 CUSTOMER ACCOUNTS:
------------------------------
   1. Raj Kumar
      Email: raj.kumar@example.com
      Phone: 9876543211
      Password: customer123
      Address: 123 Salt Lake, Kolkata 700064

   2. Priya Sharma
      Email: priya.sharma@example.com
      Phone: 9876543212
      Password: customer123
      Address: 456 New Town, Kolkata 700156

   [... more customer accounts ...]

🎉 User seeding completed successfully!

3. Complete Database Setup

To set up everything at once:

npm run seed:all

This will run both menu and user seeding scripts sequentially.

4. Verify Database Setup

You can verify your database setup by:

Check collections in MongoDB Atlas:
- Log into MongoDB Atlas
- Navigate to your cluster
- Click "Browse Collections"
- Verify users and menuitems collections exist
Test login with demo accounts:
- Start your dev server: npm run dev
- Navigate to http://localhost:3000/login
- Use admin credentials: admin@bongflavours.com / admin123
- Or customer credentials: raj.kumar@example.com / customer123
Check menu display:
- Navigate to http://localhost:3000/menu
- Verify menu items are displaying correctly
- Test vegetarian filter functionality

5. Troubleshooting Database Issues

Connection Issues:

# Test database connection
node scripts/test-connection.js

Clear and Reseed:

# If you need to start fresh
npm run seed:all

Manual Database Inspection:

# Install MongoDB Compass (GUI tool)
# Connect using your MongoDB URI
# Browse collections and documents

Common Issues:

Authentication Failed:
- Verify username/password in connection string
- Check MongoDB Atlas database user permissions
Network Timeout:
- Verify IP address is whitelisted in MongoDB Atlas
- Check firewall settings
Database Not Found:
- MongoDB will automatically create the database on first write
- Ensure the database name in URI matches your configuration
Duplicate Key Errors:
- User emails must be unique
- Clear existing users before reseeding: db.users.deleteMany({})

🧪 Demo Accounts

After running the seeding scripts, you'll have these demo accounts:

Admin Account

Email: admin@bongflavours.com
Password: admin123
Access: Full admin dashboard, order management, menu management

Customer Accounts

Email: raj.kumar@example.com
Password: customer123
Email: priya.sharma@example.com
Password: customer123
Email: amit.das@example.com
Password: customer123

(And more customer accounts - see seeding output for complete list)

📁 Project Structure

bong-flavours/
├── src/
│   ├── app/                    # Next.js App Router
│   │   ├── api/               # API routes
│   │   │   ├── auth/          # Authentication endpoints
│   │   │   ├── menu/          # Menu data endpoints
│   │   │   └── orders/        # Order management
│   │   ├── app/               # Authenticated pages
│   │   │   ├── menu/          # Customer menu with cart
│   │   │   ├── checkout/      # Order checkout process
│   │   │   ├── profile/       # Customer dashboard
│   │   │   └── admin/         # Admin dashboard
│   │   ├── login/             # Authentication pages
│   │   ├── menu/              # Public menu (browse-only)
│   │   └── globals.css        # Global styles
│   ├── components/            # Reusable React components
│   │   ├── Header.tsx         # Navigation component
│   │   ├── Footer.tsx         # Footer component
│   │   └── [other components]
│   ├── contexts/              # React Context providers
│   │   ├── AuthContext.tsx    # Authentication state
│   │   └── CartContext.tsx    # Shopping cart state
│   ├── models/                # MongoDB/Mongoose models
│   │   ├── User.ts            # User schema
│   │   ├── Order.ts           # Order schema
│   │   └── MenuItem.ts        # Menu item schema
│   └── lib/                   # Utility functions
├── data/
│   └── menu.json             # Restaurant menu data
├── scripts/                   # Database seeding scripts
│   ├── seedMenu.js           # Menu data seeding
│   ├── seedUsers.js          # User account seeding
│   └── test-connection.js    # Database connection test
├── public/                    # Static assets
└── [config files]            # Next.js, TypeScript, Tailwind configs

🔗 API Endpoints

Authentication

POST /api/auth/login - User login
POST /api/auth/register - User registration
GET /api/auth/me - Get current user
POST /api/auth/logout - User logout

Orders

POST /api/orders - Create new order
GET /api/orders - Get user orders (or all orders for admin)
GET /api/orders/[id] - Get specific order
PUT /api/orders/[id] - Update order status (admin only)

Admin

GET /api/admin/orders - Get all orders (admin only)
GET /api/admin/users - Get all users (admin only)
PUT /api/admin/orders/[id] - Update order (admin only)

🎯 Usage Guide

Customer Workflow

Browse Menu - Visit /menu to browse available items
Register/Login - Create account or login at /login
Order Items - Navigate to /app/menu to add items to cart
Checkout - Complete order at /app/checkout
Track Orders - View order history at /app/profile

Admin Workflow

Admin Login - Login with admin credentials
Dashboard - Access admin dashboard at /app/admin
Manage Orders - View and update order statuses
Menu Management - Add/edit menu items
Customer Management - View customer accounts and orders

🔧 Development Scripts

# Development
npm run dev              # Start development server
npm run build           # Build for production
npm run start           # Start production server
npm run lint            # Run ESLint

# Database Management
npm run seed:menu       # Seed menu items
npm run seed:users      # Seed demo users
npm run seed:all        # Seed everything

# Utilities
npm run extract:pdf     # Extract menu from PDF
npm run build:menu      # Generate static menu HTML

🌐 Deployment

Vercel Deployment (Recommended)

Connect Repository
- Import your GitHub repository to Vercel
- Configure build settings (Next.js preset)
Environment Variables
- Add all environment variables from .env.local
- Use production MongoDB URI
- Set up production email service
Deploy
- Vercel will automatically deploy on push to main branch
- Run database seeding scripts after first deployment

Manual Deployment

Build Application
```
npm run build
```
Set Environment Variables
- Configure production environment variables
- Use production database and email services
Start Production Server
```
npm start
```

🔒 Security Considerations

Passwords: All passwords are hashed with bcryptjs (12 salt rounds)
JWT Tokens: Secure HTTP-only cookies with appropriate expiration
Environment Variables: Never commit sensitive data to version control
Database: Use MongoDB Atlas network restrictions in production
CORS: Configure appropriate CORS policies for production
Rate Limiting: Implement rate limiting for API endpoints in production

🤝 Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🐛 Troubleshooting

Common Issues

MongoDB Connection Failed
- Verify MONGODB_URI in .env.local
- Check MongoDB Atlas network access
- Ensure database user has correct permissions
Menu Items Not Loading
- Run menu seeding: npm run seed:menu
- Check API endpoint: http://localhost:3000/api/menu
- Verify MongoDB collection has data
Authentication Issues
- Check JWT_SECRET in environment variables
- Clear browser cookies and local storage
- Verify user accounts exist in database
Cart Not Persisting
- Check browser local storage permissions
- Verify CartContext is properly configured
- Test in incognito mode to rule out cache issues
Email Notifications Not Working
- Verify SMTP credentials in .env.local
- Check email provider settings (Gmail app passwords)
- Test with mail testing service like Mailtrap

Getting Help

GitHub Issues: Report bugs and request features
Documentation: Check inline code comments
Logs: Check browser console and server logs for errors

📞 Support

For support and questions:

Email: mannadebdoot007@gmail.com
GitHub: DebdootManna
Issues: GitHub Issues

Made with ❤️ for Bengali food lovers by Debdoot Manna

Name		Name	Last commit message	Last commit date
Latest commit History 50 Commits
data		data
docs		docs
public		public
scripts		scripts
src		src
.eslintrc.json		.eslintrc.json
.gitignore		.gitignore
ADMIN_USER_MANAGEMENT_SUMMARY.md		ADMIN_USER_MANAGEMENT_SUMMARY.md
Bong-Menu-new-v4.pdf		Bong-Menu-new-v4.pdf
CHECKOUT_AUTOFILL_SUMMARY.md		CHECKOUT_AUTOFILL_SUMMARY.md
CORRECT_VERCEL_ENV.md		CORRECT_VERCEL_ENV.md
DATABASE_DOCUMENTATION.md		DATABASE_DOCUMENTATION.md
DEMO_ACCOUNTS.md		DEMO_ACCOUNTS.md
DEMO_ACCOUNTS_SUMMARY.md		DEMO_ACCOUNTS_SUMMARY.md
DEPLOYMENT_FIXES.md		DEPLOYMENT_FIXES.md
FIXES_APPLIED.md		FIXES_APPLIED.md
FIXES_SUMMARY.md		FIXES_SUMMARY.md
IMPLEMENTATION_SUMMARY.md		IMPLEMENTATION_SUMMARY.md
LICENSE		LICENSE
README.md		README.md
SETUP_GUIDE.md		SETUP_GUIDE.md
VERCEL_DEPLOYMENT_GUIDE.md		VERCEL_DEPLOYMENT_GUIDE.md
check-env.js		check-env.js
cookies.txt		cookies.txt
debug-order.js		debug-order.js
diagnose-system.js		diagnose-system.js
eslint.config.mjs		eslint.config.mjs
middleware.ts		middleware.ts
next.config.ts		next.config.ts
package-lock.json		package-lock.json
package.json		package.json
playground-1.mongodb.js		playground-1.mongodb.js
postcss.config.js		postcss.config.js
postcss.config.mjs		postcss.config.mjs
quick-fix.sh		quick-fix.sh
server.log		server.log
system-diagnostic-report.json		system-diagnostic-report.json
tailwind.config.ts		tailwind.config.ts
test-accounts.js		test-accounts.js
test-api-order-final.js		test-api-order-final.js
test-api-order.js		test-api-order.js
test-chrome-simple.js		test-chrome-simple.js
test-complete-flow.js		test-complete-flow.js
test-customer-email-TEST1761369305322.html		test-customer-email-TEST1761369305322.html
test-database.js		test-database.js
test-db.js		test-db.js
test-email.js		test-email.js
test-full-flow.js		test-full-flow.js
test-gmail-smtp.js		test-gmail-smtp.js
test-invoice-CHROME_TEST_001.pdf		test-invoice-CHROME_TEST_001.pdf
test-invoice-TEST1761369305322.html		test-invoice-TEST1761369305322.html
test-invoice.pdf		test-invoice.pdf
test-login.js		test-login.js
test-order-gmail.js		test-order-gmail.js
test-order-no-pdf.js		test-order-no-pdf.js
test-order-simple.js		test-order-simple.js
test-puppeteer.js		test-puppeteer.js
test-restaurant-email-TEST1761369305322.html		test-restaurant-email-TEST1761369305322.html
test-system-complete.js		test-system-complete.js
test-system.js		test-system.js
tsconfig.build.json		tsconfig.build.json
tsconfig.json		tsconfig.json
vercel.json		vercel.json

Folders and files

Latest commit

History

Repository files navigation

Bong Flavours - Bengali Restaurant E-Commerce Platform

� Features

Core Functionality

Technical Highlights

🚀 Quick Start

Prerequisites

Installation

🗄️ MongoDB Database Setup

Automated Database Setup

Required Collections

1. Users Collection

2. Orders Collection

Database Seeding Instructions for Local Development

Method 1: Using MongoDB Compass (Recommended for Beginners)

Method 2: Using MongoDB Shell

Method 3: Using Node.js Seeding Script

Environment-Specific Database Configuration

For Local Development

For MongoDB Atlas (Production)

🔧 Configuration Guide

Email Configuration (Gmail)

MongoDB Atlas Setup

JWT Configuration

🏗️ Project Structure

🔒 Authentication System

Dual Authentication Support

Authentication Flow

📧 Email System

Bill Generation and Delivery

Email Templates

🧪 Testing the Application

Complete Order Flow Test

Authentication Testing

PDF Generation Testing

📊 Admin Features

Order Management

User Management

🚀 Deployment

Production Environment Variables

Build and Deploy

🐛 Troubleshooting

Common Issues

Debug Mode

📱 Browser Compatibility

🔧 Development Tools

Recommended VS Code Extensions

Testing APIs

📈 Performance Optimizations

🤝 Contributing

📄 License

🍛 About Bong Flavours

🌟 Features

🔐 Authentication & User Management

🛒 E-commerce Functionality

👨‍💼 Admin Dashboard

🍽️ Menu Features

📱 Modern UI/UX

🛠️ Technology Stack

Frontend

Backend

Development Tools

📋 Prerequisites

🚀 Quick Start

1. Clone the Repository

2. Install Dependencies

3. Environment Setup

4. Database Setup

Seed Menu Items

Seed Demo Users

Seed Everything at Once

5. Start Development Server

🗄️ MongoDB Database Setup Guide

Setting Up MongoDB Atlas

Local MongoDB Setup (Alternative)

macOS (using Homebrew)

Ubuntu/Debian

Packages