const express = require('express');

const mongoose = require('mongoose');

const cors = require('cors');

const helmet = require('helmet');

require('dotenv').config();

const authRoutes = require('./routes/authRoutes');

const flowerRoutes = require('./routes/flowerRoutes');

const app = express();

// Middleware

app.use(helmet());

app.use(cors());

app.use(express.json());

// Routes

app.use('/api/auth', authRoutes);

app.use('/api/flowers', flowerRoutes);

// Connect to MongoDB

mongoose.connect(process.env.MONGO_URI, { useNewUrlParser: true,

useUnifiedTopology: true })

.then(() => console.log('Connected to MongoDB'))

.catch(err => console.error(err));

// Start Server
const PORT = process.env.PORT || 5000;

app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

const mongoose = require('mongoose');

const UserSchema = new mongoose.Schema({

name: { type: String, required: true },

email: { type: String, required: true, unique: true },

password: { type: String },

role: { type: String, default: 'user' }, // 'user' or 'admin'

}, { timestamps: true });

module.exports = mongoose.model('User', UserSchema);

const mongoose = require('mongoose');

const FlowerSchema = new mongoose.Schema({

name: { type: String, required: true },

description: { type: String, required: true },

price: { type: Number, required: true },

image: { type: String }, // URL of the image

stock: { type: Number, required: true, default: 0 },

}, { timestamps: true });

module.exports = mongoose.model('Flower', FlowerSchema);

const express = require('express');

const { registerUser, loginUser, getUser } =

require('../controllers/authController');

const { verifyToken } = require('../middleware/authMiddleware');

const router = express.Router();

// Routes

router.post('/register', registerUser);

router.post('/login', loginUser);

router.get('/me', verifyToken, getUser);

module.exports = router;

const User = require('../models/User');

const bcrypt = require('bcryptjs');

const jwt = require('jsonwebtoken');

// Register User

exports.registerUser = async (req, res) => {

const { name, email, password } = req.body;

 try {

const existingUser = await User.findOne({ email });

if (existingUser) return res.status(400).json({ message: 'User already

exists' });

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

const newUser = new User({ name, email, password:

hashedPassword });

await newUser.save();

res.status(201).json({ message: 'User registered successfully' });

} catch (error) {

res.status(500).json({ message: error.message });

};

// Login User

exports.loginUser = async (req, res) => {

const { email, password } = req.body;

try {

const user = await User.findOne({ email });

if (!user) return res.status(404).json({ message: 'User not found' });

const isMatch = await bcrypt.compare(password, user.password);

if (!isMatch) return res.status(400).json({ message: 'Invalid

credentials' });
 const token = jwt.sign({ id: user._id, role: user.role },
process.env.JWT_SECRET, { expiresIn: '1h' });

res.status(200).json({ token });

} catch (error) {

res.status(500).json({ message: error.message });

};

// Get User Info

exports.getUser = async (req, res) => {

try {

const user = await User.findById(req.user.id).select('-password');

res.status(200).json(user);

} catch (error) {

res.status(500).json({ message: error.message });

};

const jwt = require('jsonwebtoken');

exports.verifyToken = (req, res, next) => {

const token = req.header('Authorization');

if (!token) return res.status(401).json({ message: 'Access denied' });

 try {

const verified = jwt.verify(token.split(" ")[1], process.env.JWT_SECRET);

req.user = verified;

next();

} catch (error) {

res.status(400).json({ message: 'Invalid token' });

};

const express = require('express');

const { getAllFlowers, createFlower, updateFlower, deleteFlower } =

require('../controllers/flowerController');

const { verifyToken } = require('../middleware/authMiddleware');

const router = express.Router();

// Routes

router.get('/', getAllFlowers);

router.post('/', verifyToken, createFlower); // Admin access only

router.put('/:id', verifyToken, updateFlower);

router.delete('/:id', verifyToken, deleteFlower);

module.exports = router;
const Flower = require('../models/Flower');

// Get All Flowers

exports.getAllFlowers = async (req, res) => {

try {

const flowers = await Flower.find();

res.status(200).json(flowers);

} catch (error) {

res.status(500).json({ message: error.message });

};

// Create Flower

exports.createFlower = async (req, res) => {

const { name, description, price, image, stock } = req.body;

try {

const flower = new Flower({ name, description, price, image, stock });

await flower.save();

res.status(201).json(flower);

} catch (error) {

res.status(500).json({ message: error.message });

};
// Update Flower

exports.updateFlower = async (req, res) => {

const { id } = req.params;

const { name, description, price, image, stock } = req.body;

try {

const updatedFlower = await Flower.findByIdAndUpdate(id, { name,

description, price, image, stock }, { new: true });

res.status(200).json(updatedFlower);

} catch (error) {

res.status(500).json({ message: error.message });

};

// Delete Flower

exports.deleteFlower = async (req, res) => {

const { id } = req.params;

try {

await Flower.findByIdAndDelete(id);

res.status(200).json({ message: 'Flower deleted successfully' });

} catch (error) {

res.status(500).json({ message: error.message });

};

FRONT END
import React from 'react';

import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';

import Home from './pages/Home';

import Login from './components/Auth/Login';

import Register from './components/Auth/Register';

import AdminPanel from './components/Admin/AdminPanel';

import NotFound from './pages/NotFound';

function App() {

return (

<Router>

<Routes>

<Route path="/" element={<Home />} />

<Route path="/login" element={<Login />} />

<Route path="/register" element={<Register />} />

<Route path="/admin" element={<AdminPanel />} />

<Route path="*" element={<NotFound />} />

</Routes>

</Router>

);

export default App;

import React, { useState, useEffect } from 'react';

import axios from 'axios';

import FlowerCard from '../components/Flowers/FlowerCard';

function Home() {

const [flowers, setFlowers] = useState([]);

useEffect(() => {

axios.get('http://localhost:5000/api/flowers')

.then(response => setFlowers(response.data))

.catch(error => console.error(error));

}, []);

return (

<div className="container mt-5">

<h1 className="text-center mb-4">Flower Garden</h1>

<div className="row">

{flowers.map(flower => (

<FlowerCard key={flower._id} flower={flower} />

))}

</div>

</div>

);

export default Home;

import React from 'react';

function FlowerCard({ flower }) {

return (

<div className="col-md-4 mb-4">

<div className="card">

<img src={flower.image} className="card-img-top"

alt={flower.name} />

<div className="card-body">

<h5 className="card-title">{flower.name}</h5>

<p className="card-text">{flower.description}</p>

<p className="card-text"><strong>Price: </strong>$

{flower.price}</p>

<button className="btn btn-primary">Buy Now</button>

</div>

</div>

</div>

);

export default FlowerCard;

import React, { useState } from 'react';

import axios from 'axios';

function Login() {

const [email, setEmail] = useState('');

const [password, setPassword] = useState('');

const handleLogin = async (e) => {

e.preventDefault();

try {

const response = await axios.post('http://localhost:5000/api/auth/login', {

email, password });

localStorage.setItem('token', response.data.token);

alert('Login successful');

window.location = '/';

} catch (error) {

alert('Login failed');

};

return (

<div className="container mt-5">

<h2>Login</h2>

<form onSubmit={handleLogin}>

<div className="mb-3">
 <label>Email</label>

<input type="email" className="form-control" value={email}

onChange={(e) => setEmail(e.target.value)} required />

</div>

<div className="mb-3">

<label>Password</label>

<input type="password" className="form-control"

value={password} onChange={(e) => setPassword(e.target.value)}
required />

</div>

<button type="submit" className="btn btn-primary">Login</button>

</form>

</div>

);

export default Login;

import React, { useState } from 'react';

import axios from 'axios';

function Register() {

const [name, setName] = useState('');

const [email, setEmail] = useState('');

const [password, setPassword] = useState('');

 const handleRegister = async (e) => {

e.preventDefault();

try {

await axios.post('http://localhost:5000/api/auth/register', { name, email,

password });

alert('Registration successful');

window.location = '/login';

} catch (error) {

alert('Registration failed');

};

return (

<div className="container mt-5">

<h2>Register</h2>

<form onSubmit={handleRegister}>

<div className="mb-3">

<label>Name</label>

<input type="text" className="form-control" value={name}

onChange={(e) => setName(e.target.value)} required />

</div>

<div className="mb-3">

<label>Email</label>

<input type="email" className="form-control" value={email}

onChange={(e) => setEmail(e.target.value)} required />

</div>

<div className="mb-3">

<label>Password</label>
 <input type="password" className="form-control"
value={password} onChange={(e) => setPassword(e.target.value)}
required />

</div>

<button type="submit" className="btn

btn-primary">Register</button>

</form>

</div>

);

export default Register;

import React from 'react';

function AdminPanel() {

return (

<div className="container mt-5">

<h1>Admin Panel</h1>

<p>Manage flowers, users, and the website here.</p>

{/* Add admin functionalities here */}

</div>

);

}
export default AdminPanel;

const path = require('path');

const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = {

entry: './src/index.js', // Entry point for the application

output: {

path: path.resolve(__dirname, 'dist'),

filename: 'bundle.js',

},

module: {

rules: [

test: /\.(js|jsx)$/, // Apply Babel to JavaScript and JSX files

exclude: /node_modules/,

use: 'babel-loader',

},

],

},

resolve: {

extensions: ['.js', '.jsx'], // Allow import without file extensions

},

devServer: {

contentBase: './dist',

port: 3000,
 },

plugins: [

new HtmlWebpackPlugin({

template: './public/index.html', // The HTML template for your app

}),

],

};