How to use body-parser - 10 common examples

beforeEach(function(done) {
        var app = express();
        app.use(bodyParser.urlencoded({ extended: false }));

        // Simple middleware to handle get/post
        app.use('/model.json', FalcorServer.dataSourceRoute(function(req, res) {
            return new FalcorRouter([
                {
                    // match a request for the key "greeting"
                    route: "greeting",
                    // respond with a PathValue with the value of "Hello World."
                    get: function() {
                        return {path:["greeting"], value: "Hello World"};
                    }
                }
            ]);
        }));

        server = app.listen(60001, done);

Logger.setLevel("Performance", LogLevel.Error);  // Change to Info to capture

if (TestbedConfig.cloudRpc) {
  if (TestbedConfig.useHttp2) {
    const http2Options = { key: fs.readFileSync(path.join(__dirname, "../../local_dev_server.key")), cert: fs.readFileSync(path.join(__dirname, "../../local_dev_server.crt")) };
    http2.createSecureServer(http2Options, (req2, res2) => {
      if (req2.method === "GET") {
        handleHttp2Get(req2, res2);
      } else if (req2.method === "POST") {
        handleHttp2Post(req2, res2); // tslint:disable-line:no-floating-promises
      }
    }).listen(TestbedConfig.serverPort);
  } else {
    const app = express();
    app.use(bodyParser.text());
    app.use(bodyParser.raw());
    app.use(express.static(__dirname + "/public"));
    app.get(TestbedConfig.swaggerURI, (req, res) => TestbedConfig.cloudRpc.protocol.handleOpenApiDescriptionRequest(req, res));

    app.post("*", (req, res) => {
      if (handlePending(req, res)) {
        return;
      }

      TestbedConfig.cloudRpc.protocol.handleOperationPostRequest(req, res); // tslint:disable-line:no-floating-promises
    });

    app.get(/\/imodel\//, (req, res) => {
      TestbedConfig.cloudRpc.protocol.handleOperationGetRequest(req, res); // tslint:disable-line:no-floating-promises
    });

    app.listen(TestbedConfig.serverPort);

async function serveFunctions(settings) {
  const app = express();
  const dir = settings.functionsDir;
  const port = await getPort({
    port: assignLoudly(settings.port, defaultPort)
  });

  app.use(
    bodyParser.text({
      limit: "6mb",
      type: ["text/*", "application/json", "multipart/form-data"]
    })
  );
  app.use(bodyParser.raw({ limit: "6mb", type: "*/*" }));
  app.use(
    expressLogging(console, {
      blacklist: ["/favicon.ico"]
    })
  );

  app.get("/favicon.ico", function(req, res) {
    res.status(204).end();
  });
  app.all("*", createHandler(dir));

  app.listen(port, function(err) {
    if (err) {
      console.error(`${NETLIFYDEVERR} Unable to start lambda server: `, err); // eslint-disable-line no-console
      process.exit(1);
    }

mongoose.model('Blog', BlogSchema);

var Blog = mongoose.model('Blog');

/*var blog = new Blog({
	author: 'Michael',
	title: 'Michael\'s Blog',
	url: 'http://michaelsblog.com'
});

blog.save();*/

var app = express();

app.use(bodyParser.json());
app.use(express.static(__dirname + '/public'));

// ROUTES

app.get('/api/blogs', function(req, res) {
	Blog.find(function(err, docs) {
		docs.forEach(function(item) {
			console.log("Received a GET request for _id: " + item._id);
		})
		res.send(docs);
	});
});

app.post('/api/blogs', function(req, res) {
	console.log('Received a POST request:')
	for (var key in req.body) {

const apiLimiter = new RateLimit({
  windowMs: 60 * 60 * 1000, // 60 minutes
  max: 5,
  delayMs: 0 // disabled
})
app.use('/api/v1', apiLimiter)

// view engine setup
// app.set('views', path.join(__dirname, 'views'))
// app.set('view engine', 'ejs')

// uncomment after placing your favicon in /public
// app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')))
app.use(logger('dev'))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: false }))
// app.use(cookieParser());
// app.use(express.static(path.join(__dirname, 'static')))

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

// catch 404 and forward to error handler
app.use((req, res, next) => {
  var err = new Error('Not Found')
  err.status = 404
  next(err)
})

// error handlers

// development error handler

var express = require('express');
var path = require('path');
var server = require('substance/util/server');
var bodyParser = require('body-parser');

var app = express();
var port = process.env.PORT || 5000;

// use body parser so we can get info from POST and/or URL parameters
app.use(bodyParser.json({limit: '3mb'}));
app.use(bodyParser.urlencoded({ extended: true }));

// use static server
app.use(express.static(__dirname));
app.use(express.static(path.join(__dirname, "app/assets")));
app.use(express.static(path.join(__dirname, "app/data")));
app.use('/i18n', express.static(path.join(__dirname, "app/i18n")));
app.use('/fonts', express.static(path.join(__dirname, 'node_modules/font-awesome/fonts')));

server.serveStyles(app, '/app.css', path.join(__dirname, 'app', 'app.scss'));
server.serveJS(app, '/app.js', path.join(__dirname, 'app', 'app.js'));

app.listen(port, function(){
  console.log("Lens running on port " + port);
  console.log("http://127.0.0.1:"+port+"/");
});

const express = require('express');
const http = require('http');
const bodyParser = require('body-parser');
const morgan = require('morgan');
const app = express();
const router = require('./server/router');

// App setup
app.use(morgan('combined'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
router(app);

// Server setup
const port = process.env.PORT || 3090;
const server = http.createServer(app);
server.listen(port);
console.log('Server listening on:', port);

null,
        null,
        true
    ).catch(err => {
        console.log(err);
        res.status(500).send(err);
    });
});

// Test route
router.route('/ping').get(async function(req, res) {
    res.send('Hello World');
});

app.use(
    bodyParser.text({
        limit: '50mb'
    })
);

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

// Start the server.
var port = 3000;
http.createServer(app).listen(port);
console.log('Server listening on port ' + port);

const express = require('express');
const router = express.Router();
const axios = require('axios');
const bodyParser = require('body-parser');
const fb_client_secret = require('../../config/fb_client_secrets.json');
var { findByEmail, createOAuthUser } = require('../../controllers/userController');
const app_id = fb_client_secret['web']['app_id'];
const app_secret = fb_client_secret['web']['app_secret'];

var rawParser = bodyParser.raw();

router.post('/', rawParser,function(req, res, next) {
    if (req.query.state !== req.session.STATE){
        console.log('Invalid state parameter.');
        res.set('Content-Type', 'application/json');
        res.status(401);
        res.json({"error":"Invalid state parameter."});
        return;
    }
    // Obtain authorization code
        let token = req.body.toString('utf8');
        let url1 = 'https://graph.facebook.com/oauth/access_token?' +
        'grant_type=fb_exchange_token&client_id='+app_id
        +'&client_secret='+app_secret
        +'&fb_exchange_token='+token;
        console.log(url1);

import config from "../webpack.config";

import dbUtils from "./db";
import searchUtils from "./search";

const port = 8000;
const app = express();
const compiler = webpack(config);
const illegalCharsFormat = /[!@#$%^&*()+\-=[\]{};':"\\|,.<>/?]/;
dotenv.config();

// gzip files
app.use(helmet());
app.use(compression());
app.use(bodyParser.json());
app.use(bodyParser({extended: true}));
app.use(cors());
app.use(express.static(__dirname + "/public"));
app.use("/videos", express.static(__dirname + "/../videos"));
app.use("/users", express.static(__dirname + "/../users"));

// Use Webpack middleware
app.use(require("webpack-dev-middleware")(compiler, {
    noInfo: true,
    publicPath: config.output.publicPath
}));

app.get("/api/trending", (req, res) => {
    res.writeHead(200, {"Content-Type": "application/json"});

    // Define trending as videos uploaded in the last 5 days, with maximum views.
    dbUtils.init();