'use strict';
var restify = require('restify'),
bunyan = require('bunyan'),
log = bunyan.createLogger({name: "sellstuff"});
var server = restify.createServer({
log: log,
version: '0.1.0'
});
server.use(restify.bodyParser());
function send(req, res, next) {
res.send('hello ' + req.params.name);
return next();
}
server.post('/hello', function (req, res, next) {
res.send(201, Math.random().toString(36).substr(3, 8));
return next();
});
server.put('/hello', send);
server.get('/hello/:name', send);
server.head('/hello/:name', send);
server.del('/hello/:name', function rm(req, res, next) {
res.send(204);
return next();
});
var restify = require("restify");
var server = restify.createServer({
name: "newstoday",
version: "0.0.1"
});
server.get("/", function(rq, res) {
res.send({
data: "welcome newstday"
});
});
server.get("/hello/:name", function (req, res, next) {
res.send("Hello, ", req.params.name);
});
server.listen(8081, function () {
console.log("%s listening at %s", server.name, server.url);
});
var restify = require('restify');
var widget = require('save')('widget');
var server = restify.createServer({name: 'Examples'});
server.use(restify.fullResponse());
server.use(restify.bodyParser());
// GET
server.get('/api/:widget', function retrieve(req, res, next) {
widget.findOne({_id: req.params.widget}, function (err, obj) {
if (err) {
return next (
new restify.InvalidArgumentError(JSON.stringify(error.errors)));
}
if (obj) {
res.send(200,obj);
} else {
res.send(404);
}
return next();
});
});
// POST
server.post('/api/create', function create(req, res, next) {
widget.create(req.params, function (err,widget) {
console.log(widget);
res.send(201, widget._id);
});
return next();
});
var config = require('./config').config,
restify = require('restify');
// if(process.env.NODE_ENV != 'development') {
// process.addListener('uncaughtException', function (err) {
// console.log(JSON.stringify(err));
// });
// }
// Create server
var app = restify.createServer();
app.use(restify.queryParser());
app.use(restify.bodyParser());
app.listen(config.server_port, function() {
console.log('%s listening at %s', app.name, config.server_port);
});
// Wire up routes
module.exports.app = app;
routes = require('./routes/routes');
audience: g_config.audience
};
// --------------------------------------------
// REST Specifc modules
var restify = require('restify');
// Setup some configuration
var serverPort = process.env.PORT || 8888;
/**
*
* APIs for our REST Task server
*/
var server = restify.createServer({
name: "Authenticated API Server",
version: "1.0.0"
});
// Ensure we don't drop data on uploads
server.pre(restify.pre.pause());
// Clean up sloppy paths like //todo//////1//
server.pre(restify.pre.sanitizePath());
// Handles annoying user agents (curl)
server.pre(restify.pre.userAgentConnection());
// Set a per request bunyan logger (with requestid filled in)
server.use(restify.requestLogger());
// Allow 5 requests/second by IP, and burst to 10
var MODELS_PATH = './models'
var restify = require('restify'),
fs = require('fs'),
mongoose = require('mongoose/');
var server = restify.createServer({
name: 'AgileWarlock',
version: '0.1.0'
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.get(/\/public\/?.*/, restify.serveStatic({
directory: './client/app/'
}));
// connects to MongoDB
//db = mongoose.connect(config.creds.mongoose_auth),
db = mongoose.connect('mongodb://localhost/agilewarlockdb'),
Schema = mongoose.Schema;
// Load models
fs.readdirSync(MODELS_PATH).forEach(function (file) {
console.log("Loading model " + file);
require(MODELS_PATH + '/' +file);
});
'use strict';
// Module dependencies
var restify = require('restify');
var Config = require('./config/index.js');
var log = require('./utils/logger');
var routes = require('./routes');
var config = new Config();
var server = restify.createServer({
name: 'restify-seed',
version: '0.0.1'
});
// Initializes the server once configuration loads
config.load().then(function () {
log.info('Configurations loaded... initializing the server');
// Retrieve the configuration object
var cfg = config.get();
// ## Middleware
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
// ## Initialize Routes
routes.api(server, cfg);
var env = require('./env');
var pkgjson = require('./package.json');
var restify = require('restify');
var server = exports.server =
restify.createServer({
name: pkgjson.name,
level: 'info',
stream: process.stdout,
serializers: restify.bunyan.serializers,
});
exports.init = init;
function init(cb) {
env.init(server, function() {
/// Listen
var port = process.env.PORT || 3000;
server.listen(port, function() {
var startLog = {
port: port,
version: pkgjson.version,
log_level: server.log.level()
};
startLog[pkgjson.name] = 'OK';
server.log.info(startLog, 'API Server has started');
var restify = require("restify");
//var db = require("db");
var restServer = restify.createServer();
//Get user
restServer.get("/user", function(request, response, next) {
});
//Create a new project
restServer.post("/projects", function(request, response, next) {
});
//Retrieve all projects
restServer.get("/projects", function(request, response, next) {
});
//Retrieve a project
restServer.get("/projects/:id", function(request, response, next) {
});
//Update a project
restServer.put("/projects/:id", function(request, response, next) {
});
//Delete a project
// Create a schema for our data
var ArticleSchema = new Schema({
title: String,
url: String,
image: String,
username: String,
date: Date
});
// Use the schema to register a model
mongoose.model('Article', ArticleSchema);
var Article = mongoose.model('Article');
var server = restify.createServer({
name: 'restify-lab',
version: '0.0.0'
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.get('/articles', function (req, res, next) {
res.header("Access-Control-Allow-Origin", "*");
res.header("Access-Control-Allow-Headers", "X-Requested-With");
console.log("mongodbServer getArticles");
Article.find({}, null, {sort: {date: -1}}, function (err,data) {
res.json(data);
});
return next();
const restify = require('restify');
const server = restify.createServer({
name: 'Manual Service',
version: '1.0.0'
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.get('/echo/:name', (req, res, next) => {
res.send(req.params);
return next();
});
server.post('/api/push', (req, res, next) => {
});
server.listen(8080, function () {
console.log('%s listening at %s', server.name, server.url);
});
});
};
function getShoeById(req, res, next) {
findGuestById(db, req.params.id, function(err, data) {
if (!err) {
res.send(data);
} else {
res.send(err);
}
next();
db.close();
});
};
function getVersion(req, res, next) {
res.send("1.0.0");
}
var server = restify.createServer({
name: 'inquiryService',
});
server.use(restify.bodyParser());
server.get('/version', getVersion);
server.get('/shoes', listShoes);
server.get('/shoe/:id', getShoeById);
server.listen(8080, function() {
console.log('%s listening at %s', server.name, server.url);
});
function createServer(options) {
var server = restify.createServer({
name: 'mp-location',
version: '1.0.0'
});
// Clean up sloppy paths like
server.pre(restify.pre.sanitizePath());
// Handles annoying user agents (curl)
server.pre(restify.pre.userAgentConnection());
restify.CORS.ALLOW_HEADERS.push('Access-Control-Allow-Origin');
server.use(restify.CORS());
// Allow 5 requests/second by IP, and burst to 10
server.use(restify.throttle({
burst: 100,
rate: 50,
ip: true
}));
restify.CORS.ALLOW_HEADERS.push('auth-token');
restify.CORS.ALLOW_HEADERS.push('client-id');
restify.CORS.ALLOW_HEADERS.push("Access-Control-Allow-Origin");
restify.CORS.ALLOW_HEADERS.push("Access-Control-Allow-Credentials");
restify.CORS.ALLOW_HEADERS.push("Access-Control-Allow-Methods", "GET");
restify.CORS.ALLOW_HEADERS.push("Access-Control-Allow-Methods", "POST");
restify.CORS.ALLOW_HEADERS.push("Access-Control-Allow-Methods", "PUT");
restify.CORS.ALLOW_HEADERS.push("Access-Control-Allow-Methods", "DELETE");
restify.CORS.ALLOW_HEADERS.push("Access-Control-Allow-Headers", "accept,api-version, content-length, content-md5,x-requested-with,content-type, date, request-id, response-time");
server.use(restify.CORS({headers: ['auth-token'], origins: ['*']}));
server.use(restify.acceptParser(server.acceptable));
server.use(restify.dateParser());
server.use(restify.authorizationParser());
server.use(restify.queryParser());
server.use(restify.gzipResponse());
server.use(restify.fullResponse());
server.use(restify.bodyParser({uploadDir: __dirname + '/uploads/'}));
server.get(/\/apidoc\/?.*/, restify.serveStatic({
directory: './public'
}));
server.get('/', function (req, res, next) {
res.send(200, {success: true, project: "MP Common Location Module"});
return next();
});
var orderOpArr = [2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 99];//订单操作
server.post({
path: '/api/location',
contentType: 'application/json'
},
// roleBase.checkUserToken([8]),
location.addLocation);
server.get('/api/user/:userNo/location',
// roleBase.checkUserToken(orderOpArr),
location.getLocation);
server.get('/api/user/:userNo/route',
// roleBase.checkUserToken(orderOpArr),
location.getRouteLocation);
server.post({path: '/api/zhiyunTrack', contentType: 'application/json'}, track.addTrack);
server.get('/api/zhiyunTrack', track.getTrack);
server.on('NotFound', function (req, res, next) {
logger.warn(req.url + " not found");
res.send(404);
next();
});
return (server);
}
var restify = require('restify');
var request = require('superagent');
var jsdom = require('jsdom');
var eachSeries = require('async/eachSeries');
var server = restify.createServer({
name: 'sempre geo lookup',
version: '1.0.0'
});
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.get('/health', function (req, res, next) {
res.json({ ok: true});
next();
});
server.get('/test', function (req, res, next) {
res.send('ok');
var ip = '192.77.239.202';
getGeoLocation(ip, function (err, data) {
if (err) {
console.log('Err parsing geo location: ' + err);
return next(err);
}
var message = 'orig message';
postToSlack(data, message, function (err) {
if (err) {
var restify = require('restify'),
taskSave = require('save')('task'),
server = restify.createServer({ name: 'my-api' })
server.listen(3000, function () {
console.log('%s listening at %s', server.name, server.url)
})
server
.use(restify.fullResponse())
.use(restify.bodyParser())
server.get('/task', function (req, res, next) {
taskSave.find({}, function (error, tasks) {
res.send(tasks)
})
})
server.get('/task/:id', function (req, res, next) {
taskSave.findOne({ _id: req.params.id }, function (error, task) {
if (error) return next(new restify.InvalidArgumentError(JSON.stringify(error.errors)))
if (task) {
res.send(task)
} else {
res.send(404)
}
})
})
server.post('/task', function (req, res, next) {
var restify = require('restify'),
userSave = require('save')('user'),
statSave = require('save')('stat'),
fs = require('fs'),
path = require('path');
var server = restify.createServer({name:'stats-api'});
server.use(restify.fullResponse());
server.use(restify.bodyParser());
server.listen(3000, function(){
console.log('%s listening at %s', server.name, server.url);
});
var handleError = function(error){
if(error){
return next(new restify.InvalidArgumentError(JSON.stringify(error.errors)));
}else{
return undefined;
}
};
//Stats endpoints
server.get('/stat/:name', function(req, res, next){
statSave.findOne({name:req.params.name}, function(err, stat){
var error = handleError(err);
if(error) return error;
if(stat){
res.send(stat);
new Error().stack;
var restify = require('restify');
var fs = require('fs');
var d = require('dtrace-provider');
var dtp = d.createDTraceProvider('echofile');
dtp.addProbe('fs-read-start', 'char *');
dtp.addProbe('fs-read-done', 'char *', 'char *', 'int');
console.log(dtp);
var server = restify.createServer({
name: 'myapp',
version: '1.0.0'
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.get(/^\/(.*)/, function (req, res, next) {
dtp.fire('fs-read-start', function() {
return [req.params[0]];
});
fs.readFile(req.params[0], 'utf8', function(e, data) {
var payload;
dtp.fire('fs-read-done', function() {
return [req.params[0], e && e.code ? e.code : null, data ? data.length : 0];
});
var restify = require('restify');
var db_server = require('./nedb-server.js');
var port = process.env.PORT || 3000;
var server = restify.createServer({ name: 'sample-node-server' });
server.listen(port, function () {
console.log('%s listening at %s', server.name, server.url)
});
server
.use(restify.fullResponse())
.use(restify.bodyParser());
// Define Routes
server.post('/init/:account', createEventStoreIfNotExists);
server.post('/store/:account', storeEvent);
server.get('/events/:account', readAllAccountEvents);
server.get('/events/:account/:entityId', readAllEntityEvents);
server.del('/remove/:account', removeEventStoreForAnAccount);
// Define actions
function createEventStoreIfNotExists(req, res, next) {
// Check for existing Account Parameter
var restify = require('restify');
var sprintf = require("sprintf-js").sprintf;
var server = restify.createServer({
name: 'recogniser',
version: '1.0.0'
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.get('/', function (req, res, next) {
res.send('Recognise');
return next();
});
var convnetjs = require('convnetjs');
var PNG = require('pngjs').PNG;
var fs = require('fs');
var str = fs.readFileSync(__dirname + "/neuralnet/nnew.json");
var json = JSON.parse(str);
var net = new convnetjs.Net();
net.fromJSON(json);
trainer = new convnetjs.SGDTrainer(net, {method:'adadelta', batch_size:20, l2_decay:0.001});
server.post('/upload', function(req, res) {
res.header("Access-Control-Allow-Origin", "*");
res.header("Access-Control-Allow-Headers", "X-Requested-With");
var fs = require('fs');
var newPath = __dirname + "/uploads/x.png";
console.log(req);
var _ = require('lodash');
var crautos = require('./lib/crautos.js');
var restify = require('restify');
var server = restify.createServer({
name: 'crautos.js'
});
server.use(restify.fullResponse())
.use(restify.bodyParser())
.use(restify.queryParser());
server.get('/search', function (req, res, next) {
crautos.search({
modelstr: req.query.model
}).then(function(results) {
res.send(results);
});
});
var port = process.env.PORT || 5000;
server.listen(port, function () {
console.log('%s listening at %s', server.name, server.url)
});
var restify = require('restify');
var restifySwagger = require('node-restify-swagger');
var restifyValidation = require('node-restify-validation');
var server = restify.createServer({
name: 'fastHAR-api',
version: '0.0.1'
});
server.use(restify.bodyParser());
server.use(restify.CORS());
server.use(restify.gzipResponse());
server.use(restify.queryParser());
server.use(restifyValidation.validationPlugin({errorsAsArray: false}));
restifySwagger.configure(server);
restifySwagger.loadRestifyRoutes();
module.exports = server;
return next();
}
function TestTranscribe(req, res, next) {
var ring = "Ash nazg durbatulûk, ash nazg gimbatul, Ash nazg thrakatulûk agh burzum-ishi krimpatul.";
console.log(tengwarjs.transcribe(ring));
}
/* Define the nodejs restify server and routes
*/
var server = restify.createServer(
{ name: SERVER_TITLE, path: ROUTE, version: CURRENT_VERSION},
ShowTitle );
server.use(restify.acceptParser(server.acceptable));
server.use(restify.bodyParser()); // enable bundled plug in for POST body parsing
server.use(restify.queryParser());
server.get('/api', ShowTitle);
server.get('/api/transcribe/:input', Transcribe);
server.get('/api/transcribe/', Transcribe);
server.post('/api/transcribe/', Transcribe);
server.get('/api/test', TestTranscribe);
server.listen(8095, function() {
console.log('%s listening at %s', server.name, server.url);
});
process.exit(1);
}
var logger = bunyan.createLogger({
name: pkgjson.name + '_log',
level: opts.loglevel,
stream: process.stdout,
serializers: restify.bunyan.serializers,
src: (process.env.NODE_ENV !== 'production')
});
opts.logger = logger;
var restifyServer = restify.createServer({
name: pkgjson.name,
version: pkgjson.version,
log: logger
});
server.restifyServer = restifyServer;
restifyServer.log.level('info');
/* eslint-disable new-cap */
if (opts.cors) {
restifyServer.pre(restify.CORS());
}
/* eslint-enable new-cap */
var restify = require('restify');
var request = require('request');
var util = require('./util');
var server = restify.createServer({
name: 'escnproxy',
version: '1.0.0'
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.get('/topics', function (req, res, next) {
var page = 1;
if (req.params.page) page = req.params.page;
var base = 'http://proxy.elasticsearch.thnuclub.com/topic/page-'+page;
request(base, function(err, response, body) {
if(err) {
return next(err);
}
try {
data = util.parseTopic(body);
res.send(200, data);
return next();
} catch(e) {
return next("parse error");
}
})
});
server.get('/users', function (req, res, next) {
const restify = require('restify')
const bunyan = require('bunyan')
const config = require('./config')
const logger = require('./utils/logger')
const store = require('./src/store')()
let server = restify.createServer({
name: config.name,
version: '1.0.0',
log: logger.child({
component: 'server',
level: bunyan.INFO,
streams: [{
level: bunyan.DEBUG,
type: 'raw',
stream: new restify.bunyan.RequestCaptureStream({
level: bunyan.WARN,
maxRecords: 100,
maxRequestIds: 1000,
stream: process.stderr
})
}],
serializers: bunyan.stdSerializers
})
})
// Setup server dont switch ordering
require('./src/transport')(store)
require('./config/restify')(server)
require('./routes')(server, store)
function startServer(db) {
function reply(fn) {
return function (req, res, next) {
fn.call(db, req.params.id, req.body)
.then(
function (result) {
log.info(
{
op: 'request.summary',
code: 200,
route: req.route.name,
method: req.method,
path: req.url,
t: Date.now() - req.time()
}
)
if (Array.isArray(result)) {
res.send(result.map(bufferize.unbuffer))
}
else {
res.send(bufferize.unbuffer(result || {}))
}
},
function (err) {
if (typeof err !== 'object') {
err = { message: err || 'none' }
}
var statusCode = err.code || 500
var msg = {
op: 'request.summary',
code: statusCode,
route: req.route.name,
method: req.method,
path: req.url,
err: err,
t: Date.now() - req.time()
}
if (statusCode >= 500) {
log.error(msg)
}
else {
log.warn(msg)
}
res.send(statusCode, err)
}
)
.done(next, next)
}
}
var api = restify.createServer()
api.use(restify.bodyParser())
api.use(bufferize.bufferizeRequest)
api.get('/account/:id', reply(db.account))
api.del('/account/:id', reply(db.deleteAccount))
api.put('/account/:id', reply(db.createAccount))
api.get('/account/:id/devices', reply(db.accountDevices))
api.post('/account/:id/reset', reply(db.resetAccount))
api.post('/account/:id/verifyEmail', reply(db.verifyEmail))
api.post('/account/:id/locale', reply(db.updateLocale))
api.get('/sessionToken/:id', reply(db.sessionToken))
api.del('/sessionToken/:id', reply(db.deleteSessionToken))
api.put('/sessionToken/:id', reply(db.createSessionToken))
api.get('/keyFetchToken/:id', reply(db.keyFetchToken))
api.del('/keyFetchToken/:id', reply(db.deleteKeyFetchToken))
api.put('/keyFetchToken/:id', reply(db.createKeyFetchToken))
api.get('/accountResetToken/:id', reply(db.accountResetToken))
api.del('/accountResetToken/:id', reply(db.deleteAccountResetToken))
api.put('/accountResetToken/:id', reply(db.createAccountResetToken))
api.get('/passwordChangeToken/:id', reply(db.passwordChangeToken))
api.del('/passwordChangeToken/:id', reply(db.deletePasswordChangeToken))
api.put('/passwordChangeToken/:id', reply(db.createPasswordChangeToken))
api.get('/passwordForgotToken/:id', reply(db.passwordForgotToken))
api.del('/passwordForgotToken/:id', reply(db.deletePasswordForgotToken))
api.put('/passwordForgotToken/:id', reply(db.createPasswordForgotToken))
api.post('/passwordForgotToken/:id/update', reply(db.updatePasswordForgotToken))
api.post('/passwordForgotToken/:id/verified', reply(db.forgotPasswordVerified))
api.get('/emailRecord/:id', reply(db.emailRecord))
api.head('/emailRecord/:id', reply(db.accountExists))
api.get('/__heartbeat__', reply(db.ping))
api.get(
'/',
function (req, res, next) {
res.send({ version: pkg.version, patchLevel: db.patchLevel })
next()
}
)
api.listen(
config.port,
config.hostname,
function () {
log.info({ op: 'listening', port: config.port, host: config.hostname })
}
)
}
var restify = require('restify');
var server = restify.createServer({
name: 'chrome-stt-server'
});
server.use(restify.queryParser());
server.use(restify.bodyParser());
var xal = require('../../xal-javascript');
server.post('/', function(req, res, next) {
console.log(req.params);
var message = req.params.stt;
console.log(message);
res.send("STT Okay");
message = message.replace(/\bp m\b/ig, 'pm');
message = message.replace(/\ba m\b/ig, 'am');
message = message.replace(/\bbm\b/ig, 'pm');
message = message.replace(/\b(\d\d)(\d\d) (am|pm)\b/, "$1:$2 $3");
xal.log.info("Received STT:", message);
xal.createEvent('xi.event.input.text', function(state, done) {
state.put('xi.event.input.text', message);
done(state);
});
next();
});
xal.start({name: 'chrome-stt'}, function() {
server.listen(9876, function() {
xal.log.info('Chrome-STT Server: Listening on port 9876');
});
var restify = require('restify');
var fs = require('fs');
var rest = require('restler');
var host = 'http://rekognition.com/func/api/';
var path = '/fc/faces/detect.json';
var apiKey = '4Aq04rNPc9ab4N6H';
var apiSecret = '9o8vaNRHNIRq4v7W';
var server = restify.createServer({
name: 'detectface-proxy',
version: '1.0.0'
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.pre(function(req, res, next) {
res.header('Access-Control-Allow-Origin', '*');
res.header('Access-Control-Allow-Methods', 'POST, GET, PUT, DELETE, OPTIONS');
res.header('Access-Control-Allow-Headers', 'Origin, Authorization, X-Requested-With, X-File-Name, Content-Type, Cache-Control');
res.header('Cache-Control', 'no-cache');
if ('OPTIONS' == req.method) {
res.send(203, 'OK');
}
next();
});
server.get('/', function(req, res, next) {
var Kali = require('kali').Local;
var kali = new Kali({
server: "restify"
}, global);
var fs = require('fs');
var restify = require('restify');
var server = restify.createServer();
server.use(restify.queryParser());
var host = process.env.HOST || 'localhost';
var port = process.env.PORT || 3000;
var filepath = '/usr/share/dict/words';
server.get('/', function (req, res) {
fs.readFile(filepath, function (err, data) {
if (err) {
throw err;
}
res.send(data.toString());
kali.send({action: 'request', data: req.query.id});
});
})
server.listen(port, function(){
kali.send({action: 'started', data: 1});
});
var throttle = require("tokenthrottle")({rate: config.rateLimit});
// create mqtt connection
try {
// var mqttclient = mqtt.createClient(1883, 'mqtt.skynet.im', mqttsettings);
var mqttclient = mqtt.createClient(1883, 'localhost', mqttsettings);
// var mqttclient = mqtt.createClient(1883, '127.0.0.1', mqttsettings);
console.log('Skynet connected to MQTT broker');
} catch(err){
console.log('No MQTT server found.');
}
// Instantiate our two servers (http & https)
var server = restify.createServer();
server.pre(restify.pre.sanitizePath());
if(config.tls){
// Setup some https server options
if(app.environment == 'development'){
var https_options = {
certificate: fs.readFileSync("../skynet_certs/server.crt"),
key: fs.readFileSync("../skynet_certs/server.key")
};
} else {
var https_options = {
certificate: fs.readFileSync(config.tls.cert),
key: fs.readFileSync(config.tls.key),
};