How to use the express-validator/check.query function in express-validator

Revision,
  Wikitext,
} = require('../../../models');
const middlewares = require('../../../middlewares');
const Response = require('../../../responses');

const router = express.Router({ mergeParams: true });

router.get(
  '/',
  [
    query('limit')
      .optional()
      .trim()
      .isInt({ min: 1, max: 100 }),
    query('offset')
      .optional()
      .trim()
      .isInt({ min: 0 }),
    query('random')
      .optional(),
    query('order')
      .optional()
      .trim()
      .isIn(['updatedAt']),
  ],
  [
    sanitizeQuery('limit').trim().toInt(),
    sanitizeQuery('offset').trim().toInt(),
    sanitizeQuery('random').trim().toBoolean(), // Everything except for '0', 'false' and '' returns true
    sanitizeQuery('order').trim(),
  ],

const Response = require('../../../responses');

const router = express.Router({ mergeParams: true });

router.get(
  '/',
  [
    query('limit')
      .optional()
      .trim()
      .isInt({ min: 1, max: 100 }),
    query('offset')
      .optional()
      .trim()
      .isInt({ min: 0 }),
    query('random')
      .optional(),
    query('order')
      .optional()
      .trim()
      .isIn(['updatedAt']),
  ],
  [
    sanitizeQuery('limit').trim().toInt(),
    sanitizeQuery('offset').trim().toInt(),
    sanitizeQuery('random').trim().toBoolean(), // Everything except for '0', 'false' and '' returns true
    sanitizeQuery('order').trim(),
  ],
  middlewares.validate(),
  async (req, res, next) => {
    const limit = req.query.limit || 10;
    const offset = req.query.offset || 0;

});

router.get('/init', (req, res) => {
	res.status(200).json({
		tokenName: conf.tokenName
	});
});

const checkCurrencyData = checkQuery('filter_currency').optional().isIn(['all', 'GBYTE', 'BTC', 'ETH', 'USDT']);

router.get('/transactions', [
	checkQuery('page').optional().isInt({min:1}),
	checkQuery('limit').optional().isInt({min:1, max:100}),
	checkQuery('sort').optional().isIn(['currency_amount', 'creation_date']),
	checkQuery('filter_bb_address').optional().trim(),
	checkQuery('filter_receiving_address').optional().trim(),
	checkQuery('filter_txid').optional().trim(),
	checkQuery('filter_stable').optional().trim(),
	checkCurrencyData,
], (req, res) => {
	const objErrors = validationResult(req);
	if (!objErrors.isEmpty()) {
		return res.status(422).json({ errors: objErrors.mapped() });
	}

	const data = matchedData(req);
	// set default data values
	if (!data.page) data.page = 1;
	if (!data.limit) data.limit = 10;
	// prepare income data values
	data.page = Number(data.page);
	data.limit = Number(data.limit);

const express = require('express');

const router = express.Router({ mergeParams: true });

const {
  param, query, validationResult,
} = require('express-validator/check');
const { sanitizeParam, sanitizeQuery } = require('express-validator/filter');

const { Revision } = require('../../models');
const Response = require('../../responses');

router.get(
  '/',
  [
    query('limit')
      .optional()
      .trim()
      .isInt({ min: 1, max: 50 }),
    query('offset')
      .optional()
      .trim()
      .isInt({ min: 0 }),
    query('distinct')
      .optional(),
  ],
  [
    sanitizeQuery('limit').trim().toInt(),
    sanitizeQuery('offset').trim().toInt(),
    sanitizeQuery('distinct').trim().toBoolean(), // Everything except for '0', 'false' and '' returns true
  ],
  async (req, res, next) => {

try {
      const userGroupName = crowi.xss.process(name);
      const userGroup = await UserGroup.createGroupByName(userGroupName);

      return res.apiv3({ userGroup });
    }
    catch (err) {
      const msg = 'Error occurred in creating a user group';
      logger.error(msg, err);
      return res.apiv3Err(new ErrorV3(msg, 'user-group-create-failed'));
    }
  });

  validator.delete = [
    param('id').trim().exists({ checkFalsy: true }),
    query('actionName').trim().exists({ checkFalsy: true }),
    query('transferToUserGroupId').trim(),
  ];

  /**
   * @swagger
   *
   *  paths:
   *    /user-groups/{id}:
   *      delete:
   *        tags: [UserGroup]
   *        description: Deletes userGroup
   *        parameters:
   *          - name: id
   *            in: path
   *            required: true
   *            description: id of userGroup

conf.database.bReadOnly = true;

router.get('/', (req, res) => {
	res.status(200).json({
		version: process.env.npm_package_version,
		current_time: new Date()
	});
});

router.get('/init', (req, res) => {
	res.status(200).json({
		tokenName: conf.tokenName
	});
});

const checkCurrencyData = checkQuery('filter_currency').optional().isIn(['all', 'GBYTE', 'BTC', 'ETH', 'USDT']);

router.get('/transactions', [
	checkQuery('page').optional().isInt({min:1}),
	checkQuery('limit').optional().isInt({min:1, max:100}),
	checkQuery('sort').optional().isIn(['currency_amount', 'creation_date']),
	checkQuery('filter_bb_address').optional().trim(),
	checkQuery('filter_receiving_address').optional().trim(),
	checkQuery('filter_txid').optional().trim(),
	checkQuery('filter_stable').optional().trim(),
	checkCurrencyData,
], (req, res) => {
	const objErrors = validationResult(req);
	if (!objErrors.isEmpty()) {
		return res.status(422).json({ errors: objErrors.mapped() });
	}

const { query } = require('express-validator/check');
const { sanitizeQuery } = require('express-validator/filter');
const {
  DiscussionTopic,
  DiscussionComment,
} = require('../../models');
const Response = require('../../responses');
const middlewares = require('../../middlewares');

const router = express.Router({ mergeParams: true });


router.get(
  '/',
  [
    query('limit')
      .optional()
      .trim()
      .isInt({ min: 1, max: 30 }),
    query('order')
      .optional()
      .trim()
      .isIn(['updatedAt']),
  ],
  [
    sanitizeQuery('limit').toInt(),
    sanitizeQuery('order').trim(),
  ],
  middlewares.validate(),
  async (req, res, next) => {
    try {
      const limit = req.query.limit || 10;

ipEnd,
          reason,
          expiration,
        });
      }
      return new Response.Success().send(res);
    } catch (err) {
      return next(err);
    }
  },
);

router.get(
  '/',
  [
    query('containing')
      .optional()
      .trim()
      .isIP(),
    query('userId')
      .optional()
      .trim()
      .isInt(),
  ],
  [
    sanitizeQuery('containing').trim(),
    sanitizeQuery('userId').trim().toInt(),
  ],
  middlewares.validate(),
  async ({ query: { containing, userId } }, res, next) => {
    try {
      const scopes = ['valid'];

const express = require('express');
const { Op } = require('sequelize');
const { query, body, param } = require('express-validator/check');
const { sanitizeQuery, sanitizeBody, sanitizeParam } = require('express-validator/filter');
const { User, Namespace } = require('../../../models');
const Response = require('../../../responses');
const middlewares = require('../../../middlewares');
const { GET_USER_LIST } = require('../../../SpecialPermissions');

const router = express.Router({ mergeParams: true });

router.get(
  '/',
  [
    query('startingWith')
      .optional()
      .trim()
      .custom(v => User.validateUsername(v)),
    query('username')
      .optional()
      .trim()
      .custom(v => User.validateUsername(v)),
    query('limit')
      .optional()
      .trim()
      .isInt({ min: 1, max: 100 }),
  ],
  [
    sanitizeQuery('startingWith').trim(),
    sanitizeQuery('username').trim(),
    sanitizeQuery('limit').trim().toInt(),

.withMessage('Category does not exist.'),
  query('limit')
    .optional()
    .custom(value => Number(value) < 50)
    .withMessage('Limit should be a number less than 20.'),
  query('sort')
    .optional()
    .custom(value => value === 'hot' || value === 'new' || value === 'top')
    .withMessage('Sort should be one of top, hot or new.'),
  query('status')
    .optional()
    .custom(
      value => value === 'active' || value === 'pending' || value === 'rejected'
    )
    .withMessage('Status should be one of active, pending or rejected.'),
  query('type')
    .optional()
    .custom(
      value => value === 'channel' || value === 'bot' || value === 'supergroup'
    )
    .withMessage('Type should be one of channel, bot or supergroup.'),
];

export const reviewValidator = [
  body('disliked')
    .optional()
    .custom(value => typeof value === 'boolean')
    .withMessage('Disliekd must be boolean.')
    .custom((_v, { req }) => (req.body.disliked ? !req.body.liked : true))
    .withMessage('Can not both like and dislike an entry.'),
  body('liked')
    .optional()