/**
* @private
*/
_initVogelsAutoscale() {
Vogels.AWS.config.maxRetries = 3;
Vogels.documentClient(
new AutoScaleDynamoDB(
Vogels.dynamoDriver(),
Vogels.documentClient()
).extend()
);
}
describe: function (connection, collectionName, cb) {
//sails.log.silly("adaptor::describe");
//console.log("::connection",connection);
//console.log("::collection",collectionName);
// If you need to access your private data for this collection:
var collection = _collectionReferences[collectionName];
//console.log("::collection.definition",collection.definition);
// Respond with the schema (attributes) for a collection or table in the data store
var attributes = {};
// extremly simple table names
var tableName = collectionName.toLowerCase() + 's'; // 's' is vogels spec
var Endpoint = collection.connections[connection]['config']['endPoint'];
if (DynamoDB === false) {
DynamoDB = new AWS.DynamoDB(
Endpoint ? {endpoint: new AWS.Endpoint(Endpoint)}
: null
);
if (Endpoint)
Vogels.dynamoDriver(DynamoDB);
}
DynamoDB.describeTable({TableName: tableName}, function (err, res) {
if (err) {
if ('code' in err && err['code'] === 'ResourceNotFoundException') {
cb();
}
else {
//sails.log.error('Error describe tables' + __filename, err);
cb(err);
}
// console.log(err); // an error occurred
}
else {
// console.log(data); // successful response
cb();
}
});
},
/**
* UserController
*
* @description :: Server-side logic for managing users
* @help :: See http://sailsjs.org/#!/documentation/concepts/Controllers
*/
var AWS = require('aws-sdk');
var vogels = require("vogels");
var Joi = require("joi");
vogels.AWS.config.loadFromPath("credentials.json");
var opts = { endpoint : 'http://localhost:8000'};
vogels.dynamoDriver(new AWS.DynamoDB(opts));
module.exports = {
index: (req, res) => {
console.log(Joi);
console.log(vogels);
res.json({
text: "This is from API."
});
}
};
app.use(bodyParser.json());
var AWS = require('aws-sdk');
AWS.config.update({
accessKeyId: process.env.AWSAcessKeyId,
secretAccessKey: process.env.AWSSecretkey,
region: "us-west-1"
});
//this does not look like my code
// Using dynamo local
dynam = new AWS.DynamoDB();
var vogels = require('vogels');
vogels.dynamoDriver(dynam);
//Checking to see if tables exist
dynam.listTables(function(err, data) {
console.log('listTables', err, data);
calls(err, data);
}, calls);
/**ALL MY MODELS**/
var catalog = vogels.define('catalog', function(schema) {
schema.String('name', {
hashKey: true
});
schema.String('description');
});
var Items = vogels.define('item', function(schema) {
internals.main = function () {
var options = {
views: {
engines: { jade: require('jade') },
path: './views',
compileOptions: {
pretty: true
}
}
};
AWS.config.update({region: 'us-east-1'});
AWS.config.update({accessKeyId: 'People', secretAccessKey: 'SECRET'});
var db = new AWS.DynamoDB({ endpoint: "http://localhost:8000" });
vogels.AWS.config.update({accessKeyId: 'People', secretAccessKey: 'SECRET'});
vogels.dynamoDriver(db);
var server = Hapi.createServer('localhost', 3000, options);
server.pack.register(halacious, function (err) {
if (err) console.log(err);
});
server.route({ method: 'GET', path: '/{path*}', handler: {
directory: {
path: './static',
listing: false,
index: true
}
}
});
server.route({ method: 'POST', path: '/people/{id}/photos', config: {
payload: {
output: 'file',
parse: true
},
handler: function (request, reply) {
var fileInfo = request.payload.userPhoto;
var extension = ".jpg";
var personId = request.params.id;
switch (fileInfo.headers['content-type']) {
case 'image/png':
extension = '.png';
break;
case "image/jpeg":
case 'image/jpg':
default:
extension = '.jpg';
break;
}
var gm = gma.subClass({ imageMagick: true });
gm(fileInfo.path).size(function (err, value) {
if (err || !value) {
console.log("Error getting image size", err, value);
return reply(err);
}
var width = Math.min(value.width, value.height);
var resizeAndSave = function (path, size, outPath, callback) {
gm(path)
.resize(size, size)
.stream(function (err, stdout, stderr) {
var writeStream = Fs.createWriteStream(outPath);
stdout.pipe(writeStream)
.on('close', function () {
callback();
});
});
}
gm(fileInfo.path).crop(width, width, (value.width - width) / 2, (value.height - width) / 2)
.stream(function (err, stdout, stderr) {
var cropName = uploadFolder + personId + "_crop" + extension;
var writeStream = Fs.createWriteStream(cropName);
stdout.pipe(writeStream)
.on('close', function () {
async.parallel([
function (cb) {
resizeAndSave(cropName, Math.min(600, width), uploadFolder + personId + '_large' + extension, cb);
},
function (cb) {
resizeAndSave(cropName, Math.min(300, width), uploadFolder + personId + '_medium' + extension, cb);
},
function (cb) {
resizeAndSave(cropName, Math.min(150, width), uploadFolder + personId + '_small' + extension, cb);
}
], function (err) {
Fs.unlink(cropName);
Fs.unlink(fileInfo.path);
People.update({id: personId, hasPhoto: true}, function (err, person) {
reply();
})
});
});
});
})
}
}
});
server.route({ method: 'GET', path: '/people', config: {
handler: function (request, reply) {
var mediaType, negotiator, availableMediaTypes;
negotiator = new Negotiator(request);
availableMediaTypes = ['text/html'];
mediaType = negotiator.mediaType(availableMediaTypes);
if (mediaType) {
return reply.view('addPerson', {});
}
return reply().code(404);
}
}
});
server.route({ method: 'GET', path: '/people/sex', config: {
plugins: {
hal: {
embedded: {
'people': {
path: 'people',
href: '/people/sex',
embedded: {
'male': Hoek.applyToDefaults(Entities.people, {path: 'male'}),
'female': Hoek.applyToDefaults(Entities.people, {path: 'female'})
}
}
}
}
},
handler: function (request, reply) {
People.scan().exec(function (err, response) {
if (err) {
console.log(err);
return reply(err);
}
var males = response.Items
.filter(function (i) {
return !i.get('sex');
})
.map(function (x) {
return x.toJSON()
});
var females = response.Items
.filter(function (i) {
return i.get('sex');
})
.map(function (x) {
return x.toJSON()
});
reply({people: {
male: males,
female: females
}});
});
}
}
})
server.route({ method: 'GET', path: '/people/all', config: {
plugins: {
hal: {
embedded: {
'people': Entities.people
}
}
},
handler: function (request, reply) {
People.scan().exec(function (err, response) {
if (err) {
console.log(err);
return reply(err);
}
var out = { people: response.Items.map(function (i) {
return i.toJSON();
}) }
reply(out);
});
}
}
});
server.route({ method: 'GET', path: '/people/{id}', config: {
plugins: {
hal: Entities.people
},
handler: function (request, reply) {
var mediaType, negotiator, availableMediaTypes;
negotiator = new Negotiator(request);
availableMediaTypes = ['text/html'];
mediaType = negotiator.mediaType(availableMediaTypes);
if (!mediaType) return reply().code(404);
People.get(request.params.id, function (err, people) {
if (err) {
console.log(err);
return reply(err);
}
if (!people) return reply(Hapi.error.notFound('Person Not Found'));
var env = {
id: people.get('id'),
lastName: people.get('name_last'),
firstName: people.get('name_first'),
sex: (people.get('sex')) ? 'Female' : 'Male',
fatherId: (people.get('father') ? people.get('father') : '---'),
motherId: (people.get('mother') ? people.get('mother') : '---'),
lastUpdate: Misc.getDateFromUnixTimestamp(people.get('update_ts'))
};
if (people.get('hasPhoto') == true) {
env.photoUrlLarge = "/uploads/" + people.get('id') + '_large.jpg';
env.photoUrlMedium = "/uploads/" + people.get('id') + '_medium.jpg';
env.photoUrlSmall = "/uploads/" + people.get('id') + '_small.jpg';
}
return reply.view('viewPerson', env);
})
}
}
});
server.route({ method: 'POST', path: '/people',
config: {
validate: {
payload: {
name_last: Joi.string(),
name_first: Joi.string(),
father: Joi.number().allow(null),
mother: Joi.number().allow(null),
sex: Joi.boolean()
}
},
plugins: {
hal: {
embedded: {
"person": Entities.people
}
}
},
handler: function (request, reply) {
var newPerson = request.payload;
newPerson.id = newPerson.id ? newPerson.id : Misc.createUnixTimestamp();
newPerson = new People(newPerson);
newPerson.save(function(err) {
if (err) {
console.log("Error saving person", err);
return reply(err);
}
return reply({people: newPerson.toJSON()});
});
}
}
});
server.route({ method: 'POST', path: '/people/{id}', handler: function (request, reply) {
People.get(request.params.id, function (err, people) {
if (err) {
console.log(err);
return reply(err);
}
if (!people) return reply(Hapi.error.notFound('Person Not Found'));
if (!request.payload.id) request.payload.id = request.params.id;
request.payload.update_ts = Misc.createUnixTimestamp();
people.set(request.payload);
people.update(function (err) {
if (err) {
console.log(err);
return reply(err);
}
reply().code(200);
})
})
}
});
server.route({ method: 'DELETE', path: '/people/{id}', handler: function (request, reply) {
People.destroy(request.params.id, function (err) {
if (err) {
console.log(err);
Fs.unlink(uploadFolder + request.payload.id + '_large.jpg');
Fs.unlink(uploadFolder + request.payload.id + '_medium.jpg');
Fs.unlink(uploadFolder + request.payload.id + '_small.jpg');
return reply(err);
}
reply().code(200);
})
}
});
server.on('request', function (request, event, tags) {
if (tags.error && !tags.auth) {
console.log(event);
}
});
server.start();
}
/**
* @param {Object} driver
* @returns {DB}
* @private
*/
_setVogelsDriver(driver) {
Vogels.dynamoDriver(driver);
return this;
}
var Hapi = require('hapi');
var AWS = require('aws-sdk');
var vogels = require('vogels');
var People = require('./lib/models/People');
var Entities = require('./lib/entities');
AWS.config.update({region: 'us-east-1'});
AWS.config.update({accessKeyId: 'People', secretAccessKey: 'SECRET'});
var db = new AWS.DynamoDB({ endpoint: "http://localhost:8000" });
vogels.AWS.config.update({accessKeyId: 'People', secretAccessKey: 'SECRET'});
vogels.dynamoDriver(db);
var halaciousOpts = {};
var server = Hapi.createServer('localhost', 3000);
server.pack.require('halacious', halaciousOpts, function(err){
if (err) console.log(err);
});
server.route({ method: 'GET', path: '/people', config: {
plugins: Entities.people,
handler: function (request, reply) {
People.scan().exec(function(err, response) {
if (err) {
console.log(err);
return reply(err);
}
var out = { people: response.Items.map(function(i) {return i.toJSON();}) }
reply(out);
});