async.each(cards, function(card, done) {
var id = slugs(asciify(card.name));
Oracle.findById(id, function(err, oracle) {
if(!oracle) {
oracle = new Oracle();
oracle._id = id;
oracle.name = card.name;
oracle.slug = id;
oracle.rarity = card.rarity;
oracle.manaCost = card.manaCost;
oracle.cmc = card.cmc;
oracle.type = card.type;
oracle.types = card.types;
oracle.text = card.text;
oracle.power = card.power;
oracle.toughness = card.toughness;
oracle.loyalty = card.loyalty;
oracle.colors = card.colors;
oracle.rulings = card.rulings;
}
if(!oracle.printings.some(function(printing) { return printing._id == card.multiverseid; })) {
oracle.printings.push({
_id: card.multiverseid,
expansion: set.name,
expansionNumber: card.number });
}
oracle.save();
processed++;
process.stdout.write(util.format('processing set %s %s/%s\r', set.name, processed, set.cards.length));
done();
});
}, function(err) {
app.post("/docs/:doc/new-endpoint", authorized, checkDoc, function (req, rsp) {
var group = req.doc.groups[req.body.group];
if (typeof group === "undefined") {
req.flash("error", "Invalid group: %s", req.body.group);
rsp.redirect("/docs/" + req.params.doc + "/new-group");
} else {
var id = slugs(req.body.name);
if (typeof group.endpoints === "undefined") group.endpoints = {};
group.endpoints[id] = {
method: req.body.method,
path: req.body.path,
name: req.body.name,
description: req.body.description,
params: req.body.params,
curl: req.body.curl,
response: req.body.response
};
Doc.set(req.doc.id, req.doc, function (err, doc) {
if (err) {
req.flash("error", err.messages);
rsp.redirect("/docs/" + req.params.doc + "/endpoints/");
} else {
rsp.redirect("/docs/" + req.params.doc + "/endpoints/" + req.body.group);
}
});
}
});
.post(logged, getUser, function (req, res) {
var question = new Question({
user : req.user,
title : req.body.title,
content : req.body.content,
slug : slugs(req.body.title)
});
question.save(function(err) {
if (err) {
console.log("Error al Grabar Pregunta");
return;
}
io.to('home').emit('preguntando', {
username : req.user.username,
url_foto : req.user.url_foto,
title : question.title,
content : req.body.content,
created : question.created
});
});
res.redirect('/');
});
/**
* Get the font family name for the given font resource.
* The font won't be loaded.
* @returns The font-family to be used to render a text with the font.
*/
static getFontFamily(project: gdProject, resourceName: string) {
if (loadedFontFamilies[resourceName]) {
return loadedFontFamilies[resourceName];
}
const fontFamily = slugs(resourceName);
return fontFamily;
}
function Project(name, unlisted) {
this.name = name;
this.createdDate = new Date();
this.slug = slugify(name);
this.url = '/project/' + this.slug;
this.closed = false; // TODO: if closed, project is read only
this.deleted = false;
this.unlisted = unlisted;
}
function savePost(res,contributor,defaultData){
var postData = preparePostForSaving(defaultData,contributor);
var titleSlug = slugs(postData.title);
var url = queries.postType()+titleSlug.toLowerCase();
var headers = helpers.setHeaders(url,postData);
request(headers,function(error,response,body){
if(error) return res.send(500);
return res.send({id:body._id},200);
});
}
function savePost(postData,res){
var titleSlug = slugs(postData.title);
var url = queries.postType()+titleSlug.toLowerCase();
var headers = helpers.setHeaders(url,postData);
request(headers,function(error,response,body){
if(error) return res.send(500);
return res.send({id:body._id},200);
});
}
importer.getSet(code, function(err, info) {
delete info.cards;
info.slug = slugs(info.name);
Set.findByIdAndUpdate(info.code, info, { upsert: true }, function(err, doc) {
if(err) {
console.log(err, doc);
return done();
}
console.log('done with ', info.code);
return done();
});
});
router.post('/',auth,profile(cons.ST_PROFILE_GESTOR),function(req, res) {
var b = req.body;
if (!b.name || !b.budget || !b.type_rate){
res.status(400).json({
message: "Bad parameters"
});
return;
}
var data = {
slug: slugs(b.name),
name: b.name,
members : b.members ? b.members : [],
type_rate: b.type_rate,
hourly_rate: b.hourly_rate ? b.hourly_rate : null,
creator : req.user._id,
date_creation: new Date(),
date_start: b.date_start ? b.date_start : null,
date_finish: b.date_finish ? b.date_finish : null,
color: b.color ? b.color : "#ccc",
budgets : [{
id: uuid.v1(),
amount: parseFloat(b.budget),
desc: null,
date: new Date(),
id_user: req.user._id
}],
total_budget: parseFloat(b.budget)
};
ProjectModel.create(data,function(err,items){
if (err || !items.length){
res.status(400).json({
message: "Internal error",
error: err
});
}
else{
res.json({
id: items[0]._id,
slug: items[0].slug
});
}
});
});
storeSchema.pre('save', async function(next) {
if (!this.isModified('name')) {
next(); // skip it
return; // stop this function from running
}
this.slug = slug(this.name);
// find other stores that have a slug of wes, wes-1, wes-2
const slugRegEx = new RegExp(`^(${this.slug})((-[0-9]*$)?)$`, 'i');
const storesWithSlug = await this.constructor.find({ slug: slugRegEx });
if(storesWithSlug.length) {
this.slug = `${this.slug}-${storesWithSlug.length + 1}`;
}
next();
// TODO make more resiliant so slugs are unique
});
function checkSlugHelper(name, index, done) {
var slug = makeSlug(name);
if (index > 0) {
slug = slug + '-' + index;
}
mongoose.model('Survey').findOne({ slug: slug }, function (error, doc) {
if (error) {
return done(error);
}
if (doc === null) {
return done(null, slug);
}
checkSlugHelper(name, index + 1, done);
});
}
storeSchema.pre('save', async function(next) {
if (!this.isModified('name')) {
return next();
}
this.slug = slug(this.name);
const slugRegEx = new RegExp(`^(${this.slug})((-[0-9]*$)?)$`, 'i');
const storesWithSlug = await this.constructor.find({ slug: slugRegEx });
if (storesWithSlug.length) {
this.slug = `${this.slug}-${storesWithSlug.length + 1}`;
}
next();
});
schema.methods.makeSlug = function(suffix) {
var self = this;
var slug = [];
options.fields.forEach(function(field) {
if (self[field] !== undefined) {
slug.push(self[field]);
}
});
if (suffix !== undefined) {
slug.push(suffix);
}
return slugs(slug.join(' '));
};
// Make sure an item has a unique slug
function checkSlug(name, index, done) {
var slug = makeSlug(name);
if (index > 0) {
slug = slug + '-' + index;
}
// See if we've already used this slug.
// If we have, try another slug.
Survey.count({ slug: slug }, function (err, count) {
if (err) { return done(err); }
if (count > 0) {
checkSlug(name, index + 1, done);
} else {
done(null, slug);
}
});
}
app.post("/docs/:doc/new-group", authorized, checkDoc, function (req, rsp) {
var id = slugs(req.body.name);
if (!req.doc.groups) req.doc.groups = {};
req.doc.groups[id] = {
name: req.body.name,
title: req.body.title,
intro: req.body.intro
};
Doc.set(req.doc.id, req.doc, function (err, doc) {
if (err) {
req.flash("error", "Fail: ", err.messages);
rsp.redirect("/docs/" + req.params.doc + "/endpoints");
} else {
req.flash('success', "Group successfully created!", req.params.group);
rsp.status(201);
rsp.redirect("/docs/" + req.params.doc + "/endpoints/" + id);
}
});
});
router.put('/:slug',auth,profile(cons.ST_PROFILE_GESTOR),function(req, res) {
var b = req.body;
if (!b.name || !b.type_rate){
res.status(400).json({
message: "Bad parameters"
});
return;
}
var data = {
slug: slugs(b.name),
name: b.name,
members : b.members ? b.members : [],
manager: b.manager ? b.manager : null,
type_rate: b.type_rate,
hourly_rate: b.hourly_rate ? b.hourly_rate : null,
last_date_mod: new Date(),
last_user_mod: req.user._id,
date_start: b.date_start ? b.date_start : null,
date_finish: b.date_finish ? b.date_finish : null,
color: b.color ? b.color : "#ccc",
status: parseInt(b.status)
};
ProjectModel.edit(b._id,data,function(err,item){
if (err ){
res.status(400).json({
message: "Internal error",
error: err
});
}
else{
res.json({
id: b._id,
slug: data.slug
});
}
});
});
storeSchema.pre("save", async function(next) {
if(!this.isModified('name')){
next();
return;
}
/**
* Todo: make slugs unique
*/
this.slug = slug(this.name);
const slugRegEx = new RegExp(`^(${this.slug})((-[0-9]*$)?)$`, 'i')
const storesWithSlug = await this.constructor.find({ slug: slugRegEx });
if(storesWithSlug.length) {
this.slug = `${this.slug}-${storesWithSlug.length + 1}`;
}
next();
});
/**
* Load the given font from its url/filename.
* @returns a Promise that resolves with the font-family to be used
* to render a text with the font.
*/
static loadFontFamily(
project: gdProject,
resourceName: string
): Promise<string> {
// Avoid reloading a font if it's already cached
if (loadedFontFamilies[resourceName]) {
return Promise.resolve(loadedFontFamilies[resourceName]);
}
const fontFamily = slugs(resourceName);
let fullFilename = null;
if (project.getResourcesManager().hasResource(resourceName)) {
const resource = project.getResourcesManager().getResource(resourceName);
if (resource.getKind() === 'font') {
fullFilename = ResourcesLoader.getResourceFullUrl(
project,
resourceName
);
}
} else {
// Compatibility with GD <= 5.0-beta56
// Assume resourceName is just the filename to the font
fullFilename = ResourcesLoader.getFullUrl(project, resourceName);
// end of compatibility code
}
if (!fullFilename) {
// If no resource is found/resource is not a font, default to Arial,
// as done by the game engine too.
return Promise.resolve('Arial');
}
return loadFontFace(fontFamily, `url("${fullFilename}")`, {}).then(
loadedFace => {
loadedFontFamilies[resourceName] = fontFamily;
return fontFamily;
}
);
}
schema.pre("save",function (next) {
this.name = sanitizer.escape(this.name);
//this.description = sanitizer.escape(this.description||"");
this.slug = slugs(this.name);
next();
});
Producer.methods.getSlugName = function slug(){
return slugs(this.name);
}
generate: function (name) {
dbc([name], "Name is required");
return slug(name);
}
const mangleName = (name: string) => {
return slugs(name, '_', []);
};
function slugify(model, options) {
var slugParts = _.map(options.source, function(path) {
return _.get(model, path);
});
return slugs(slugParts.join(' '));
}
const getPathFor = (functionName: string) => {
return `${outputDir}/${slugs(functionName)}.js`;
};
const getPathFor = (functionName: string) => {
return `${prefix}/${slugs(functionName)}.js`;
};
/**
* Generate a filename for an uploaded image.
* @param {String} orig name of the uploaded file
* @param {String} surveyId id of the survey
* @param {String} objectName human-readable name of the base object
* @param {Function} done callback with parameter 'name'
* @param {Integer} suffix (optional) name suffix
*/
function makeFilename(orig, surveyId, objectName, done, suffix) {
if (!orig || !surveyId || !objectName) {
var message;
if (!orig) {
message = 'Original filename required when generating a remote filename';
} else if (!surveyId) {
message = 'Survey ID required when generative a remote filename';
} else {
message = 'Human-readable base object name required when generative a remote filename';
}
return done({
name: 'FileNamingError',
message: message
});
}
console.log('Received file named ' + orig);
// Get the date
// TODO: the naming could get wonky around midnight if we need to use a
// suffix. The date will change, so we'll have a "-1" suffix even if there is
// no suffix-less file with that date.
var today = new Date();
var date = today.getDate();
var month = today.getMonth() + 1; //Months are zero based
var year = today.getFullYear();
// Construct the name
var name = uploadDir + '/';
name = name + surveyId + '/';
name = name + year + '-' + month + '-' + date + '-';
name = name + makeSlug(objectName);
if (suffix) {
name = name + '-' + suffix.toString();
}
// Add the file extension
var split = orig.split('.');
var extension = split.slice(-1)[0];
name = name + '.' + extension;
// Check if the name works
// If it doesn't, try to add suffixes until it does!
checkIfFileNameExists(name, function(exists) {
if (exists) {
if (suffix === undefined) {
suffix = 1;
} else {
suffix += 1;
}
makeFilename(orig, surveyId, objectName, done, suffix);
} else {
done(null, name);
}
});
}
function slugify(model, options){
var slugParts = _.values(_.pick(model, options.source));
return slugs(slugParts.join(' '));
}