value: function setupRoutes(router) {
router.get('/presets', this.getAllPresets.bind(this));
router.post('/preset', validate(PresetsModule.addPresetSchema()), this.addPreset.bind(this));
router.get('/preset/:id', validate(PresetsModule.getPresetSchema()), this.getPreset.bind(this));
router.put('/preset/:id', validate(PresetsModule.updatePresetSchema()), this.updatePreset.bind(this));
router.delete('/preset/:id', validate(PresetsModule.deletePresetSchema()), this.deletePreset.bind(this));
router.post('/preset/:id/activate', validate(PresetsModule.activatePresetSchema()), this.activatePreset.bind(this));
}
module.exports = function(router, core) {
router
.route('/-/generator')
.post(bodyParser.json()) // for this.$http.post (vue-resource)
.post(bodyParser.urlencoded({ extended: true})) // for $.ajax (jquery)
.post(validate({
body : {
size: Joi.number().integer().required(),
range: Joi.string().required()
}
}))
.post(function(req, res, next) {
debug('debug', req.body);
var body = {
naan : core.config.get('NAAN'),
subpub: req.body.range.toLocaleLowerCase(),
size: req.body.size,
bundle : shortid.generate()
}
var opt = {
query : {
typ: 'form',
filename : String(body.bundle).concat('.ark')
},
body : body,
json : true
};
core.agent.post('/' + body.subpub, opt)
.then(function(response) {
res.send(body);
})
.catch(next);
})
}
module.exports.setRoutes = function(app, sessionVerificationFunc) {
app.all('/app-deploy-pipeline/*', sessionVerificationFunc);
app.get('/app-deploy-pipeline/project/:projectId',validate(appDeployValidator.get),getProject);
function getProject(req, res, next) {
async.waterfall(
[
function (next) {
appDeployPipelineService.getProjectByProjectId(req.params.projectId, next);
}
],
function (err, results) {
if (err) {
return res.status(500).send({code: 500, errMessage: err});
} else {
return res.status(200).send(results);
}
}
);
}
app.post('/app-deploy-pipeline/save/appConfigPipeLineData',validate(appDeployValidator.post),saveAndUpdatePipeLineConfiguration);
app.put('/app-deploy-pipeline/update/appConfigPipeLineData',validate(appDeployValidator.post), saveAndUpdatePipeLineConfiguration);
function saveAndUpdatePipeLineConfiguration(req, res, next) {
var loggedInUser = req.session.user.cn;
var jsonReqData = req.body;
jsonReqData['loggedInUser']=loggedInUser;
async.waterfall(
[
function (next) {
appDeployPipelineService.saveAndUpdatePipeLineConfiguration(jsonReqData, next);
}
],
function (err, results) {
if (err) {
return res.status(500).send({code: 500, errMessage: err});
} else {
return res.status(200).send(results);
}
});
};
};
module.exports = function(router) {
var Model = require('../models/tag'),
rules = require('../validation'),
validate = require('express-validation');
router.get('/tags', function(req, res, next) {
Model.findAsync(req.query.name)
.then(function(tag) {
res.json(tag);
})
.catch(next);
});
router.get('/tags/:id', validate(rules.id), function(req, res, next) {
Model.findByIdAsync(req.params.id)
.then(function(tag) {
res.json(tag);
})
.catch(next);
});
router.post('/tags', validate(rules.tag), function(req, res, next) {
Model.getByNameOrDefineAsync(req.body.name)
.then(function(result) {
res.status(result.created ? 201 : 200).json(result.model);
})
.catch(next);
});
router.put('/tags/:id', validate(rules.tag), function(req, res, next) {
Model.renameAsync(req.params.id, req.body.name)
.then(function(tag) { res.json(tag); })
.catch(next);
});
router.delete('/tags/:id', validate(rules.id), function(req, res, next) {
Model.deleteAsync(req.params.id)
.then(function() {
res.sendStatus(204);
})
.catch(next);
});
};
module.exports.setRoutes = function(app, sessionVerification) {
app.post('/client-app-access', validate(clientAppAccessValidator.create), sessionVerification, createApplicationAccess);
function createApplicationAccess(req, res, next) {
logger.debug('Calling createApplicationAccess', req.body);
var bodyData = req.body;
bodyData.sessionData = req.session.user;
clientAppAccessService.createTransaction(bodyData, function(err, data) {
if (err) {
logger.error('Error occured while creating transaction ', err);
return next(err);
}
res.status(200).send(data);
});
}
app.get('/client-app-access/:transactionId', validate(clientAppAccessValidator.get), getTransaction);
function getTransaction(req, res, next) {
clientAppAccessService.getTransaction(req.params.transactionId, function(err, data) {
if (err) {
logger.error('Error occured getting bot transaction ', err);
return next(err);
}
tempAuthToken.createNew(data.sessionData, function(err, tokenData) {
if (err) {
logger.error('Error occured getting temporary auth token ', err);
return next(err);
}
//var base64 = new Buffer(JSON.stringify(data.params)).toString('base64');
res.redirect(data.catalystUrl + '?Token=' + tokenData.token + '&BotName=id:'+data.params.botId+'&redirectUrl='+data.clientRedirectUrl);
});
});
}
}
return new Promise(async function(accept, reject) {
const app = express();
if (NODE_ENV === 'production') {
app.use(sslify.HTTPS({trustProtoHeader: true}));
}
app.use(morganDebug('cors-proxy:server', 'combined'));
app.use(bodyParser.json());
app.post('/request', validate(RequestSchema), requestHandler);
// preflight request
app.options('/request', validate(PreflightSchema), function(req, res) {
setupCORS(req, res);
res.status(200).end();
});
const server = http.createServer(app);
server.listen(port, () => {
debug('Cors proxy running');
accept(server);
});
});
import { Router } from 'express';
import validate from 'express-validation';
import * as userController from './user.controllers';
import userValidation from './user.validations';
import { authLocal } from '../../services/auth.services';
const routes = new Router();
routes.post('/signup', validate(userValidation.signup), userController.signUp);
routes.post('/login', authLocal, userController.login);
export default routes;
const express = require('express');
const validate = require('express-validation');
const paramValidation = require('../config/param-validation');
const permissions = require('./permissions');
const pluginsCtrl = require('../controllers/plugins.controller');
const router = express.Router(); // eslint-disable-line new-cap
router.route('/')
/** GET /api/plugins - Get list of plugins */
.get(permissions.requireLogin, pluginsCtrl.list)
/** POST /api/plugins - Create new plugin */
.post(permissions.requireLogin, validate(paramValidation.createPlugin), pluginsCtrl.create);
router.route('/:pluginId')
/** GET /api/plugins/:pluginId - Get plugin */
.get(permissions.requireLogin, pluginsCtrl.get)
/** PUT /api/plugins/:pluginId - Update plugin */
.put(permissions.requireLogin, validate(paramValidation.updatePlugin), pluginsCtrl.update)
/** DELETE /api/plugins/:pluginId - Delete plugin */
.delete(permissions.requireLogin, pluginsCtrl.remove);
/** Load plugin when API with pluginId route parameter is hit */
router.param('pluginId', pluginsCtrl.load);
module.exports = router;
'use strict';
const express = require('express');
// eslint-disable-next-line new-cap
const router = express.Router();
const ev = require('express-validation');
const validations = require('../validations/joiartists_events');
const genEventsQuery = require('../modules/utils').genEventsQuery;
const rp = require('request-promise');
// Req.body should contain: a property called artists which is an array of
// artist names; optionally city, state, and radius all at once or not at all.
router.post('/artists/events', ev(validations.get), (req, res, next) => {
const { artists, city, state, radius } = req.body;
const eventsURL = 'http://api.bandsintown.com/events/search?api_version=2.0';
const appId = 'CHADTEST';
if (!artists) {
const err = new Error();
err.status = 400;
return next(err);
}
const options = {
uri: genEventsQuery(eventsURL, artists, appId, city, state, radius),
json: true
};
import express from 'express';
import validate from 'express-validation';
import taskCtrl from '../controllers/tasks';
import validations from './validation/tasks';
const router = express.Router();
router.route('/')
/** GET /api/tasks - Get list of tasks */
.get(taskCtrl.list)
/** POST /api/tasks - Create new task */
.post(validate(validations.createTask),
taskCtrl.create);
router.route('/:taskId')
/** GET /api/tasks/:taskId - Get task */
.get(taskCtrl.get)
/** PUT /api/tasks/:taskId - Update task */
.put(validate(validations.updateTask),
taskCtrl.update)
/** DELETE /api/tasks/:taskId - Delete task */
.delete(taskCtrl.remove);
/** Load task when API with taskId route parameter is hit */
router.param('taskId', validate(validations.getTask));
router.param('taskId', taskCtrl.load);
export default router;
* "title": "gay",
* "type": "gay",
* "skip": 10
* }
* @apiSuccessExample {json} Success
* [{
* "title": "fishGay is gay",
* "description": "fishGay is very gay",
* "type": "gay",
* "startTime": Date,
* "allDay": false,
* "endTime": Date,
* "venue": {
* "coordinates": {
* "lat": Number,
* "lon": Number
* },
* name: "Home"
* },
* "isPublic": true
* }]
*/
.get(validate(paramValidation.showEvents), eventCtrl.showEvents);
/** Load user when API with userId route parameter is hit */
router.param('eventId', eventCtrl.load);
module.exports = router;
'use strict';
const express = require('express');
const validate = require('express-validation');
const controller = require('./user.controller');
const auth = require('../../core/auth/auth.service.js');
const userValidation = require('../../validations/users');
var router = express.Router();
router
.get('/me', auth.isAuthenticated(), controller.me)
.put('/:id/password', auth.isAuthenticated(), controller.changePassword)
.put('/profile', auth.isAuthenticated(), controller.updateProfile)
.get('/:id', controller.show)
.post('/', validate(userValidation.create), controller.create);
router.post('/avatar', auth.isAuthenticated(), controller.uploadPicture);
module.exports = router;
import express from 'express';
import validate from 'express-validation';
import paramValidation from '../../config/param-validation';
import messageCtrl from '../controllers/message';
import auth from '../helpers/auth';
const router = express.Router();
router.route('/')
/** GET /api/messages - Get list of messages */
.get(auth.ensureAuth, messageCtrl.list)
/** POST /api/messages - Create new message */
.post(auth.ensureAuth, validate(paramValidation.createMessage), messageCtrl.create);
router.route('/:messageId')
/** GET /api/messages/:messageId - Get message */
.get(auth.ensureAuth,messageCtrl.get)
/** Load message when API with messageId route parameter is hit */
router.param('messageId', messageCtrl.load);
export default router;
import express from 'express';
import validate from 'express-validation';
import paramValidation from '../../config/param-validation';
import userCtrl from '../controllers/user.controller';
const router = express.Router(); // eslint-disable-line new-cap
router.route('/')
/** GET /api/users - Get list of users */
.get(userCtrl.list)
/** POST /api/users - Create new user */
.post(validate(paramValidation.createUser), userCtrl.create);
router.route('/:userId')
/** GET /api/users/:userId - Get user */
.get(userCtrl.get)
/** PUT /api/users/:userId - Update user */
.put(validate(paramValidation.updateUser), userCtrl.update)
/** DELETE /api/users/:userId - Delete user */
.delete(userCtrl.remove);
/** Load user when API with userId route parameter is hit */
router.param('userId', userCtrl.load);
export default router;
module.exports.setRoutes = function(app, sessionVerificationFunc) {
app.all('/scripts*', sessionVerificationFunc);
app.get('/scripts', function(req, res) {
var loggedUser = req.session.user.cn;
if(req.query.filterBy && req.query.paginationCheck && (req.query.paginationCheck === 'false' || req.query.paginationCheck === false)){
scriptService.getScriptList(req.query.filterBy,loggedUser,function(err, scripts) {
if (err) {
res.send(errorResponses.db.error);
return;
}else{
res.send(scripts);
return;
}
});
}else {
scriptService.getScriptListWithPagination(req.query,loggedUser, function (err, scripts) {
if (err) {
res.send(errorResponses.db.error);
return;
} else {
res.send(scripts);
return;
}
});
}
});
app.post('/scripts/save/scriptData',validate(scriptValidator.create),saveAndUpdateScript);
app.put('/scripts/update/scriptData',validate(scriptValidator.create),saveAndUpdateScript);
function saveAndUpdateScript(req,res,next) {
scriptService.saveAndUpdateScript(req.body, function (err, scripts) {
if (err) {
res.send(errorResponses.db.error);
return;
} else {
settingWizard.getSettingWizardByOrgId(req.body.orgDetails.id,function(err,settingWizards){
if(err){
logger.error('Hit getting setting wizard error', err);
res.send(500);
return;
}
var settingWizardSteps = appConfig.settingWizardSteps;
if(settingWizards.currentStep.name === 'Gallery Setup') {
settingWizards.currentStep.nestedSteps[2].isCompleted = true;
settingWizards.currentStep.isCompleted = true;
settingWizards.previousStep = settingWizards.currentStep;
settingWizards.currentStep = settingWizards.nextStep;
settingWizards.nextStep = {name:'Wizard Status',isCompleted:true};
settingWizard.updateSettingWizard(settingWizards, function (err, data) {
if (err) {
logger.error('Hit updating setting wizard error', err);
res.send(500);
return;
}
logger.debug("Exit post() for /script Gallery");
res.send(scripts);
return;
});
}else{
logger.debug("Exit post() for /script Gallery");
res.send(scripts);
return;
}
})
}
});
}
app.get('/scripts/:scriptId',validate(scriptValidator.get), function(req, res) {
scriptService.getScriptById(req.params.scriptId, function(err, scripts) {
if (err) {
res.status(500).send(errorResponses.db.error);
return;
}else if (scripts.length > 0) {
res.send(scripts);
return;
}else {
res.send("Script not found!");
return;
}
});
});
app.delete('/scripts/:scriptId',validate(scriptValidator.get), function(req, res) {
scriptService.getScriptById(req.params.scriptId, function(err, scripts) {
logger.debug(JSON.stringify(scripts));
if (err) {
res.status(500).send(errorResponses.db.error);
return;
}
scriptService.removeScriptById(req.params.scriptId, function (err, script) {
if (err) {
if (err.code === 403) {
res.send(err.code, err.message);
return;
} else {
res.send("Error while removing script:");
return;
}
} else {
settingsService.trackSettingWizard('scriptGallery', scripts.orgDetails.id, function (err, data) {
if (err) {
logger.error("Failed to update setting wizard item (%s)", err);
res.status(500).send(err);
return;
}
res.send("Successfully Removed script From the Database");
return;
})
}
});
});
});
};
*/
const permissions = tcMiddleware.permissions;
const createProjectMemberValidations = {
body: {
param: Joi.object()
.keys({
role: Joi.any()
.valid(PROJECT_MEMBER_ROLE.MANAGER, PROJECT_MEMBER_ROLE.ACCOUNT_MANAGER, PROJECT_MEMBER_ROLE.COPILOT),
}),
},
};
module.exports = [
// handles request validations
validate(createProjectMemberValidations),
permissions('project.addMember'),
(req, res, next) => {
let targetRole;
if (_.get(req, 'body.param.role')) {
targetRole = _.get(req, 'body.param.role');
if (PROJECT_MEMBER_ROLE.MANAGER === targetRole &&
!util.hasRoles(req, [USER_ROLE.MANAGER])) {
const err = new Error(`Only manager is able to join as ${targetRole}`);
err.status = 401;
return next(err);
}
if (PROJECT_MEMBER_ROLE.ACCOUNT_MANAGER === targetRole &&
!util.hasRoles(req, [USER_ROLE.MANAGER, USER_ROLE.TOPCODER_ACCOUNT_MANAGER])) {
/**
* Created by Shahar on 18/06/2016.
*/
import express from 'express';
import validate from 'express-validation';
import paramValidation from './login.validation';
import loginCtrl from './login.controller';
const router = express.Router(); // eslint-disable-line new-cap
router.route('/')
.post(validate(paramValidation.loginUser), loginCtrl.login);
export default router;
import {
Router
} from 'express';
import validate from 'express-validation';
import schema from '../validators/user';
import middleware from '../config/middleware';
import userService from '../services/user';
var router = Router();
router.get('/', userService.testRoute);
router.post('/login', validate(schema.login), userService.login);
router.post('/signup', validate(schema.signUp), userService.signUp);
router.get('/:id/loops', validate(schema.loops), userService.getLoops);
router.get('/:id/surveys', validate(schema.surveys), userService.getSurveys);
router.get('/attributes', userService.getAttributes);
// Error handler for user route
router.use(userService.errorHandler);
export default router;
import express from 'express';
import validate from 'express-validation';
import paramValidation from '../config/donor-param-validation';
import donorCtrl from '../controllers/donor';
const router = express.Router(); // eslint-disable-line new-cap
router.route('/')
/** GET /api/donors - Get list of donors */
.get(donorCtrl.list)
/** POST /api/donors - Create new donor */
.post(validate(paramValidation.createDonor), donorCtrl.create);
router.route('/:donorId')
/** GET /api/donors/:donorId - Get donor */
.get(donorCtrl.get)
/** PUT /api/donors/:donorId - Update donor */
.put(validate(paramValidation.updateDonor), donorCtrl.update)
/** DELETE /api/donors/:donorId - Delete donor */
.delete(donorCtrl.remove);
/** Load donor when API with donorId route parameter is hit */
router.param('donorId', donorCtrl.load);
export default router;
'use strict';
const { camelizeKeys, decamelizeKeys } = require('humps');
const { checkAdmin } = require('../../modules/middleware');
const boom = require('boom');
const ev = require('express-validation');
const express = require('express');
const knex = require('../../knex');
const router = express.Router();// eslint-disable-line new-cap
const val = require('../../validations/orders');
// For admins to cancel an order
router.delete('/orders/:id', checkAdmin, ev(val.delete), (req, res, next) => {
const id = req.params.id;
knex('orders')
.where('id', id)
.first()
.then((orderExists) => {
if (!orderExists) {
throw boom.notFound('Invalid order ID');
}
orderExists = camelizeKeys(orderExists);
if (orderExists.shipDate) {
throw boom.conflict('Order has already been marked as shipped');
}
if (orderExists.cancelled) {
throw boom.conflict('Order has already been cancelled');
var express = require('express');
var router = express.Router();
var validate = require('express-validation');
var registerManager = require('./../services/registerManager');
var requestAJAXValidation = require('./../validation/requestAJAX');
router.route('/')
.get(validate(requestAJAXValidation), function(request, response){
try{
var registerResponse = registerManager.getRegisterDetails(request, response);
response.json(registerResponse);
} catch(error){
throw "Error in router.register.get " + error;
}
});
module.exports = router;
import express from 'express';
import validate from 'express-validation';
import paramValidation from './user.validation';
import userCtrl from './user.controller';
// import ensure from 'connect-ensure-login'
const debug = require('debug')('express-mongoose-es6-rest-api:index');
const router = express.Router(); // eslint-disable-line new-cap
const secret = {
secret: process.env.SECRET_KEY
};
debug(secret);
router.route('/')
/** GET /api/users - Get list of users */
.get(userCtrl.list)
/** POST /api/users - Create new user */
.post(validate(paramValidation.createUser), userCtrl.create);
router.route('/:userid')
/** GET /api/users/:token - Get user */
.get(validate(paramValidation.getUser), userCtrl.get)
/** DELETE /api/users/:token - Delete user */
.delete(validate(paramValidation.getUser), userCtrl.remove);
/** Load user when API with userId route parameter is hit , required a token*/
router.param('username', userCtrl.load);
export default router;
router.route('/self')
/**
* @api {get} /api/v1/users/self Get information about the owner of the access_token.
* @apiVersion 0.0.1
* @apiName GetSelf
* @apiGroup Users
*/
.get(userCtrl.self)
/**
* @api {put} /api/v1/users/self Update self.
* @apiVersion 0.0.1
* @apiName UdateSelf
* @apiGroup Users
*/
.put(validate(paramValidation.updateUser), userCtrl.update)
/**
* @api {delete} /api/v1/users/self Delete self.
* @apiVersion 1.0.0
* @apiName DeleteSelf
* @apiGroup Users
*/
.delete(validate(paramValidation.deleteUser), userCtrl.remove);
/**
* @api {get} /api/v1/users/self/follows Get the list of users this user follows.
* @apiVersion 0.0.1
* @apiName GetUserFollows
* @apiGroup Users
*/
router.get('/self/follows', userCtrl.follows);
}
return Promise.resolve(productTemplate);
}));
});
});
if (productPromises.length > 0) {
return Promise.all(productPromises).then(productTemplates => ({ projectTemplate, productTemplates }));
}
// if there is no phase or product in a phase is specified, return empty product templates
return Promise.resolve({ projectTemplate, productTemplates: [] });
});
}
module.exports = [
// handles request validations
validate(createProjectValdiations),
permissions('project.create'),
fieldLookupValidation(models.ProjectType, 'key', 'body.param.type', 'Project type'),
/**
* POST projects/
* Create a project if the user has access
*/
(req, res, next) => {
const project = req.body.param;
// by default connect admin and managers joins projects as manager
const userRole = util.hasRoles(req, MANAGER_ROLES)
? PROJECT_MEMBER_ROLE.MANAGER
: PROJECT_MEMBER_ROLE.CUSTOMER;
// set defaults
_.defaults(project, {
description: '',
import express from 'express'
import validate from 'express-validation'
import paramValidation from '../../../config/param-validation'
import authCtrl from '../../controllers/auth'
const router = express.Router() // eslint-disable-line new-cap
/** POST /api/auth/login - Returns token if correct username and password is provided */
router.route('/login')
.post(validate(paramValidation.apiAuth.login), authCtrl.login)
export default router
const validations = require('../validations/joiusers');
const checkAuth = function(req, res, next) {
if (!Number.parseInt(req.session.userId)) {
const err = new Error();
err.status = 401;
return next(err);
}
next();
};
// Req.body must contain user_name, password, city, state, and radius.
router.post('/users', ev(validations.post), (req, res, next) => {
const newUser = req.body;
knex('users')
.select(knex.raw('1=1'))
.where('user_name', newUser.user_name)
.first()
.then((exists) => {
if (exists) {
throw boom.create(401, 'Username already exists');
}
return bcrypt.hash(newUser.password, 12);
})
/*eslint-disable */
import {
Router
} from 'express';
import validate from 'express-validation';
import middleware from '../config/middleware';
import schema from '../validators/survey';
import surveyService from '../services/survey';
var router = Router();
// GET SURVEYS
router.get('/', surveyService.getAll);
// GET A SURVEY
router.get('/:surveyId', validate(schema.getSurvey), surveyService.getSurvey);
// GET A SURVEY'S QUESTIONS
router.get('/:surveyId/questions', validate(schema.getSurvey), surveyService.getQuestions);
// POST SURVEY (CREATE)
router.post('/', middleware.verifyToken, validate(schema.survey), surveyService.postSurvey);
// Send the answer
router.post('/:surveyId/answer', middleware.verifyToken, surveyService.answerSurvey);
// Error handler for survey route
router.use(surveyService.errorHandler);
export default router;
router.get('/tasks', function(req, res) {
// returns all the tasks from the Database
Task.find({}).lean().exec(function(err, results) {
if (err) {
return res.json({ success: false, error: err });
}
return res.json({ success: true, results: results });
});
});
router.put('/tasks/:id', validate(validation.putTask), function(req, res) {
Task.findByIdAndUpdate(req.params.id, req.body, {}, function(err) {
if (err) {
return res.json({ success: false, error: err });
}
return res.json({ success: true, results: true });
})
});
router.post('/tasks', validate(validation.postTask), function(req, res) {
const task = new Task();
task.title = req.body.title;
task.priority = req.body.priority;
planConfig: Joi.object().optional().allow(null),
priceConfig: Joi.object().optional().allow(null),
disabled: Joi.boolean().optional(),
hidden: Joi.boolean().optional(),
createdAt: Joi.any().strip(),
updatedAt: Joi.any().strip(),
deletedAt: Joi.any().strip(),
createdBy: Joi.any().strip(),
updatedBy: Joi.any().strip(),
deletedBy: Joi.any().strip(),
}).required(),
},
};
module.exports = [
validate(schema),
permissions('projectTemplate.edit'),
fieldLookupValidation(models.ProjectType, 'key', 'body.param.category', 'Category'),
(req, res, next) => {
const param = req.body.param;
const { form, priceConfig, planConfig } = param;
const checkModel = (keyInfo, modelName, model) => {
let errorMessage = '';
if (keyInfo == null) {
return Promise.resolve(null);
}
if ((keyInfo.version != null) && (keyInfo.key != null)) {
errorMessage = `${modelName} with key ${keyInfo.key} and version ${keyInfo.version}`
+ ' referred in the project template is not found';
return (model.findOne({
'use strict'
const router = require('express').Router();
const validate = require('express-validation');
const controller = require('./poll.controller.js');
const pollValidation = require('../../validations/polls.js');
const auth = require('../../core/auth/auth.service.js');
router
.get('/', auth.isAuthenticated(), controller.getAll)
.get('/:id', controller.get)
.post('/', auth.isAuthenticated(), validate(pollValidation.create), controller.create)
.put('/:id', auth.isAuthenticated(), validate(pollValidation.update), controller.update)
.delete('/:id', auth.isAuthenticated(), controller.delete);
module.exports = router;