}catch(pErr){
console.log('Error while parsing token : ' + pErr);
pResponse.sendStatus(403);
}
}
}
// Sanitize all the parameter send with POST request
if(pRequest.method === 'POST') {
for(let param in pRequest.body) {
pRequest.body[param] = vValidator.escape(pRequest.body[param]);
}
}
pNext();
});
var vRouter = vExpress.Router();
vRouter.post('/login',vLoginCtrl.login);
vRouter.post('/login/MPIN', vLoginCtrl.submitMPIN);
vRouter.get('/logout', vLoginCtrl.logout);
vRouter.get('/retailer/alert',vRetailerCtrl.getAllRetailerAlert);
vRouter.post('/getSalesRoute',vRetailerCtrl.getSalesRoute);
vRouter.post('/getRetailerSummary',vRetailerCtrl.getRetailerSummary);
vRouter.get('/getRetailerAlert',vRetailerCtrl.getAllRetailerAlert);
// vRouter.post('/accountsReceivables',vAccCtrl.accountsReceivables);
// vRouter.post('/retailerSelf',vAccCtrl.retailerSelf);
vRouter.get('/testSync',vSchedCtrl.syncTableMaster);
//API BASED ON GUIDELINES
vRouter.get('/task',vRetailerCtrl.task);
vRouter.post('/retailerCallPreparation',vRetailerCtrl.retailerCallPreparation);
vRouter.post('/loadWallet',vRetailerCtrl.loadWallet);
constructor() {
this.router = express.Router();
this.router.get('/', this.index);
}
import {Request, Response, Router} from "express";
const router: Router = Router();
import {IRoute} from "express-serve-static-core";
import {entityModel} from "../models/models";
import {checkObjectIDValidity, checkIfDataIsArray} from "../helpers/validation";
import {errorIDValidationMessages, errorApiMessages} from "../helpers/errorMessages";
const api: IRoute = router.route("/api/entity/:id");
api.get(async (req: Request, res: Response) => {
let id: string = req.params.id;
if (!checkObjectIDValidity(id)) {
res.status(400).json(errorIDValidationMessages.getMessage);
}
let obj: Object = await entityModel
.find({_id: id})
.exec()
.catch((e: Error) => {
res.status(400).send({ error: errorApiMessages.postMessage + e });
});
res.json(obj);
});
api.post(async (req: Request, res: Response) => {
// check data before saving also could do validation within function
let obj: Array<Object> = checkIfDataIsArray(req.body);
let dataRes: Object = await entityModel.insertMany(obj);
res.status(200).json(dataRes);
import * as express from 'express'
import * as _ from 'lodash'
import { data } from '../data-import/data-storage'
import { IGroup } from '../data-import/data-import'
import * as path from 'path';
import * as request from 'request';
var shipNameToImageId = require('../public/ship-name-to-image-id.json');
export let router = express.Router({ mergeParams: true });
var result: Array<IGroup> = JSON.parse(data);
router.get('/', (req: express.Request, res: express.Response) => {
let race = findRace(result, req);
let response = _.map(race.ships, (ship) => {
return {
name: ship.name,
group: ship.group,
race: ship.race
};
});
res.json(response);
});
router.get('/:shipId', (req: express.Request, res: express.Response) => {
let race = findRace(result, req);
res.send(_.find(race.ships, { name: req.params.shipId }));
});
import * as express from 'express';
import {sendError, formatSend, getAuthorizationData} from '../core/web_util';
import {addressBookGroupService} from './address_book_group_service';
import {AddressBookGroup, ModelOptions} from '../../client/core/dto';
const router = express.Router();
router.post('/', (req, res) => {
const modelOptions: ModelOptions = {
authorization: getAuthorizationData(req),
copyAuthorizationData: 'createdBy'
};
addressBookGroupService.createOne(req.body, modelOptions)
.then((group: AddressBookGroup) => formatSend(res, group), (err) => sendError(res, err));
});
router.put('/:id', (req, res) => {
const modelOptions: ModelOptions = {
authorization: getAuthorizationData(req)
};
req.body._id = req.params.id;
addressBookGroupService.updateOne(req.body, modelOptions)
.then((group: AddressBookGroup) => formatSend(res, group), (err) => sendError(res, err));
});
router.delete('/:id', (req, res) => {
const modelOptions: ModelOptions = {
authorization: getAuthorizationData(req),
additionalData: {_id: req.params.id}
};
/// <reference path="../typings/tsd.d.ts"/>
import {Request, Response} from "express";
var express = require('express');
var router = express.Router();
/* GET home page. */
router.get('/', function(req: Request, res: Response, next: Function) {
res.render('index', { title: 'Express' })
});
module.exports = router;
import {Router} from 'express';
import {addPost,searchPost, searchPostArea, pushElasticSearch, getAll,
editPost,addView,getPostAllByUser}
from '../controller/postController';
import {addRate} from '../controller/rateController';
import {verifyToken} from '../libs/verifyToken';
const router: any = Router();
import { uploadPost as upload } from '../libs/uploads';
router.route('/post')
.post(upload, verifyToken, addPost)
.put(verifyToken, editPost)
.all((req: any, res: any, next: any) => {
res.sendStatus(404);
});
router.route('/elastichpush')
.get(pushElasticSearch)
.all((req: any, res: any, next: any) => {
res.sendStatus(404);
});
router.route('/search')
.get(searchPost)
.all((req: any, res: any, next: any) => {
res.sendStatus(404);
});
router.route('/limit/:limit/offset/:offset')
.get(getAll)
import * as express from 'express';
import * as bodyParser from 'body-parser';
var jwt = require('jsonwebtoken');
var passport = require('passport');
var LocalStrategy = require('passport-local').Strategy;
var localStrategyConfig = require('./strategies/local');
import * as User from './../../user/User';
var config = require('./config');
// CONFIG
localStrategyConfig();
const authRoutes: express.Router = express.Router();
// ROUTES
authRoutes.post('/', function(req: express.Request, res: express.Response, next) {
console.log(req.body)
if (req.body.type) {
switch (req.body.type) {
case 'password':
localAuthentication(req, res, next);
}
} else {
return res.status(401).send({
message: 'credentials not provided'
});
}
import * as express from 'express'
import * as _ from 'lodash'
import {data} from '../data-import/data-storage'
import * as races from './races'
import {IGroup} from '../data-import/data-import'
export var router = express.Router({mergeParams: true});
router.get('/', (req:express.Request, res:express.Response)=>{
var result:Array<IGroup> = JSON.parse(data);
_.each(result, (group:IGroup)=>{
delete group.races;
})
res.json(result);
});
router.get('/:groupId', (req:express.Request, res:express.Response)=>{
var groups:Array<IGroup> = JSON.parse(data);
var group = _.find(groups, {name: req.params.groupId});
delete group.races;
res.send(group);
});
router.use('/:groupId/races', races.router);
videosSortValidator,
videosUpdateValidator
} from '../../../middlewares'
import { TagModel } from '../../../models/video/tag'
import { VideoModel } from '../../../models/video/video'
import { VideoFileModel } from '../../../models/video/video-file'
import { abuseVideoRouter } from './abuse'
import { blacklistRouter } from './blacklist'
import { videoCommentRouter } from './comment'
import { rateVideoRouter } from './rate'
import { VideoFilter } from '../../../../shared/models/videos/video-query.type'
import { VideoSortField } from '../../../../client/src/app/shared/video/sort-field.type'
import { createReqFiles, isNSFWHidden } from '../../../helpers/express-utils'
import { ScheduleVideoUpdateModel } from '../../../models/video/schedule-video-update'
const videosRouter = express.Router()
const reqVideoFileAdd = createReqFiles(
[ 'videofile', 'thumbnailfile', 'previewfile' ],
Object.assign({}, VIDEO_MIMETYPE_EXT, IMAGE_MIMETYPE_EXT),
{
videofile: CONFIG.STORAGE.VIDEOS_DIR,
thumbnailfile: CONFIG.STORAGE.THUMBNAILS_DIR,
previewfile: CONFIG.STORAGE.PREVIEWS_DIR
}
)
const reqVideoFileUpdate = createReqFiles(
[ 'thumbnailfile', 'previewfile' ],
IMAGE_MIMETYPE_EXT,
{
thumbnailfile: CONFIG.STORAGE.THUMBNAILS_DIR,
