Nodejs Shopping Cart – Express Framework & MongoDB & PayPal Payment

Introduction

Building an e-commerce application is a complex task that requires a good understanding of web development, databases, and payment gateways. In this tutorial, we will be building a simple shopping cart application using Node.js, Express Framework, MongoDB, and PayPal payment gateway. This tutorial is designed for beginners who want to learn how to build a full-fledged e-commerce application.

Prerequisites

Before starting this tutorial, you should have the following:

• Node.js installed on your computer
• MongoDB installed on your computer
• A PayPal account
• Basic understanding of HTML, CSS, and JavaScript
• Familiarity with Node.js and Express Framework

Step 1: Setting up the Project

To start, let's create a new project folder and navigate to it in the terminal. Then, let's create a new file called package.json and add the following code to it:

{
  "name": "shopping-cart",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.17.1",
    "mongodb": "^3.6.3",
    "body-parser": "^1.19.0",
    "paypal-rest-sdk": "^1.14.0"
  }
}

This file specifies the dependencies required for our project. Let's install these dependencies by running the following command:

npm install

Step 2: Setting up the Database

Next, let's set up our database using MongoDB. We will create a new database called shopping-cart and a collection called products. Let's create a new file called db.js and add the following code to it:

const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
const dbName = 'shopping-cart';

MongoClient.connect(url, function(err, client) {
  if (err) {
    console.log(err);
  } else {
    console.log('Connected to MongoDB');
    const db = client.db(dbName);
    // Create a collection
    db.collection('products', function(err, collection) {
      if (err) {
        console.log(err);
      } else {
        console.log('Collection created');
      }
    });
  }
});

This code connects to our MongoDB instance and creates a new database and collection.

Step 3: Creating the Product Model

Next, let's create a product model using Mongoose, a popular ODM (Object Data Modeling) library for MongoDB. Let's create a new file called product.js and add the following code to it:

const mongoose = require('mongoose');
const productSchema = new mongoose.Schema({
  name: String,
  price: Number,
  description: String
});
const Product = mongoose.model('Product', productSchema);
module.exports = Product;

This code defines a product schema with three fields: name, price, and description. We will use this schema to create and retrieve products from our database.

Step 4: Creating the Product Controller

Next, let's create a product controller that will handle CRUD (Create, Read, Update, Delete) operations for our products. Let's create a new file called productController.js and add the following code to it:

const Product = require('./product');
const db = require('./db');

// Create a new product
exports.createProduct = (req, res) => {
  const product = new Product(req.body);
  product.save((err, product) => {
    if (err) {
      res.status(500).send({ message: 'Error creating product' });
    } else {
      res.send({ message: 'Product created successfully' });
    }
  });
};

// Get all products
exports.getProducts = (req, res) => {
  Product.find().then(products => {
    res.send(products);
  }).catch(err => {
    res.status(500).send({ message: 'Error getting products' });
  });
};

// Get a single product
exports.getProduct = (req, res) => {
  Product.findById(req.params.id).then(product => {
    if (!product) {
      res.status(404).send({ message: 'Product not found' });
    } else {
      res.send(product);
    }
  }).catch(err => {
    res.status(500).send({ message: 'Error getting product' });
  });
};

// Update a product
exports.updateProduct = (req, res) => {
  Product.findByIdAndUpdate(req.params.id, req.body, { new: true }, (err, product) => {
    if (err) {
      res.status(500).send({ message: 'Error updating product' });
    } else {
      res.send({ message: 'Product updated successfully' });
    }
  });
};

// Delete a product
exports.deleteProduct = (req, res) => {
  Product.findByIdAndRemove(req.params.id, (err, product) => {
    if (err) {
      res.status(500).send({ message: 'Error deleting product' });
    } else {
      res.send({ message: 'Product deleted successfully' });
    }
  });
};

This code defines five methods for creating, reading, updating, and deleting products.

Step 5: Creating the Route

Next, let's create a route that will handle requests to our product controller. Let's create a new file called routes.js and add the following code to it:

const express = require('express');
const router = express.Router();
const productController = require('./productController');

router.get('/products', productController.getProducts);
router.get('/products/:id', productController.getProduct);
router.post('/products', productController.createProduct);
router.put('/products/:id', productController.updateProduct);
router.delete('/products/:id', productController.deleteProduct);

module.exports = router;

This code defines five routes that correspond to the methods in our product controller.

Step 6: Creating the Shopping Cart

Next, let's create a shopping cart that will store the products that the user has added to their cart. Let's create a new file called cart.js and add the following code to it:

const Product = require('./product');

class Cart {
  constructor() {
    this.products = [];
  }

  addProduct(productId) {
    Product.findById(productId, (err, product) => {
      if (err) {
        console.log(err);
      } else {
        this.products.push(product);
      }
    });
  }

  removeProduct(productId) {
    this.products = this.products.filter(product => product._id.toString()!== productId);
  }

  getProducts() {
    return this.products;
  }
}

module.exports = Cart;

This code defines a Cart class that has three methods: addProduct, removeProduct, and getProducts.

Step 7: Creating the Checkout Route

Next, let's create a checkout route that will handle the payment process. Let's create a new file called checkout.js and add the following code to it:

const express = require('express');
const router = express.Router();
const cart = require('./cart');
const paypal = require('paypal-rest-sdk');

paypal.configure({
  'mode': 'sandbox', // sandbox or live
  'client_id': 'YOUR_CLIENT_ID',
  'client_secret': 'YOUR_CLIENT_SECRET'
});

router.get('/checkout', (req, res) => {
  const cartProducts = cart.getProducts();
  const total = cartProducts.reduce((acc, product) => acc + product.price, 0);
  res.render('checkout', { products: cartProducts, total });
});

router.post('/checkout', (req, res) => {
  const cartProducts = cart.getProducts();
  const total = cartProducts.reduce((acc, product) => acc + product.price, 0);
  paypal.payment.create({
    'transactions': [{
      'amount': {
        'currency': 'USD',
        'total': total
      },
      'description': 'Payment for products'
    }]
  }, (err, payment) => {
    if (err) {
      console.log(err);
      res.status(500).send({ message: 'Error processing payment' });
    } else {
      res.send({ message: 'Payment processed successfully' });
    }
  });
});

module.exports = router;

This code defines two routes: one for the checkout page and one for processing the payment. The checkout page renders a template with the products and total price, and the payment processing route uses the PayPal API to create a payment.

Step 8: Creating the Checkout Template

Next, let's create a checkout template that will render the products and total price. Let's create a new file called checkout.ejs and add the following code to it:

<h1>Checkout</h1>
<ul>
  <% products.forEach(product => { %>
    <li>
      <%= product.name %> - <%= product.price %>
    </li>
  <% }); %>
</ul>
<p>Total: <%= total %></p>
<form action="/checkout" method="post">
  <input type="submit" value="Pay with PayPal">
</form>

This code defines a simple template that renders the products and total price, and includes a form that submits the payment to the PayPal API.

Step 9: Running the Application

Finally, let's run our application by starting the Node.js server. Let's create a new file called server.js and add the following code to it:

const express = require('express');
const app = express();
const routes = require('./routes');
const cart = require('./cart');

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.use('/api', routes);
app.use('/', routes);

app.listen(3000, () => {
  console.log('Server started on port 3000');
});

This code defines an Express.js application that listens on port 3000 and uses the routes and cart module.

That's it! You have now completed the tutorial on building a Node.js shopping cart application using Express Framework, MongoDB, and PayPal payment gateway. You can run the application by starting the Node.js server and accessing the checkout page in your web browser.