makeUrn: function (uri, params){
var urn = '', inner_params = {}, temp;
if (uri.indexOf ('?') != -1) {
urn = uri.split ('?') [0];
temp = uri.split ('?') [1];
if (temp.indexOf ('&') != -1) {
temp = temp.split ('&');
_.each (temp, function (item){
inner_params [item.split ('=') [0]] = decodeURIComponent (item.split('=') [1]);
});
} else {
inner_params [temp.split('=') [0]] = decodeURIComponent (temp.split('=') [1]);
}
} else {
urn = uri;
}
_.extend (inner_params, params);
var tail = _.compact (
_.map (inner_params, function (value, name) {
if (value) {
return name + "=" + encodeURIComponent (value);
}
})
).join ("&");
return tail ? (urn + '?' + tail) : urn;
},
it('should not change protocol between patch versions', async () => {
var shasum = crypto.createHash('sha1');
for (let [url, urlMapping] of _.toPairs(METHOD_MAP)) {
shasum.update(url);
for (let [method, methodMapping] of _.toPairs(urlMapping)) {
shasum.update(method);
if (methodMapping.command) shasum.update(methodMapping.command);
if (methodMapping.payloadParams) {
let allParams = _.flatten(methodMapping.payloadParams.required);
if (methodMapping.payloadParams.optional) {
allParams = allParams.concat(_.flatten(methodMapping.payloadParams.optional));
}
for (let param of allParams) {
shasum.update(param);
}
if (methodMapping.payloadParams.wrap) {
shasum.update('skip');
shasum.update(methodMapping.payloadParams.wrap);
}
}
}
}
var hash = shasum.digest('hex').substring(0, 8);
// Modify the hash whenever the protocol has intentionally been modified.
hash.should.equal('8c54fd6e');
});
attachments: function (doc) {
if (!doc) return [];
if (!doc._attachments) return [];
return _.map (_.keys (doc._attachments), function (file) {
var origin = doc.meta.last_updated_origin || doc.meta.origin;
return '/' + _.map ([origin, doc._id, file], encodeURIComponent).join ('/');
});
},
allModules = (function(){
var fixSlashes = function(p){ return p.replace(new RegExp('\\\\','g'),'/');},
modules =
_.flatten([scannedModules.js, options.extraModules || [], dynamicModules, scannedModules.text])
.map(fixSlashes)
.filter(options.moduleFilter);
return _.unique(modules);
})(),
insertRequireModules = (function(){
if(typeof(options.require) === 'string' || _.isArray(options.require)){
return _.flatten([options.require]);
}
else if(options.require === true || (options.almond && options.require !== false)){
return [allModules[0]];
}
return undefined;
})(),
allModules = (function(){
var fixSlashes = function(p){ return p.replace(new RegExp('\\\\','g'),'/');},
modules =
_.flatten([scannedModules.js, options.extraModules || [], dynamicModules, scannedModules.plugged])
.map(fixSlashes),
include = _.filter(modules, options.moduleFilter),
exclude = _.reject(modules, options.moduleFilter);
return { include:_.unique(include), exclude:_.unique(exclude) };
})(),
_.each(input, (param) => {
const decoded = decodeParams(param);
if (_.isUndefined(decoded) === false) {
if (_.has(obj, decoded.param)) {
_.merge(obj[decoded.param], decoded.value);
} else {
obj[decoded.param] = decoded.value;
}
}
});
uploadAttachments: function (model, eventFiles) {
var meta = model.get ('meta'),
origin = (meta.origin || meta.last_updated_origin),
e = encodeURIComponent,
baseUrl = '/' + _.map ([origin, model.id], e).join ('/');
var files = _.map (eventFiles, function (file) {
return file;
});
var _iterate = function () {
var file;
if (file = files.pop ()) {
_uploadFile (file);
} else {
model.off ('change:_attachments', _iterate);
}
};
var _contentType = function (file) {
return file.type;
};
var _uploadFile = function (file) {
var url = baseUrl + '/' + e (file.name) + '?rev=' + model.get ('_rev');
var xhr = new XMLHttpRequest ();
xhr.open ('PUT', url);
// TODO: Add better content-type detection
xhr.setRequestHeader ('Content-Type', _contentType (file));
xhr.setRequestHeader ('Cookie', document.cookie);
xhr.onreadystatechange = function (event) {
console.log ('upload attachments result');
};
xhr.onerror = function () {
console.error ('Failed to upload attachment', arguments);
};
xhr.onabort = function () {
console.log ('Attachment upload aborted', arguments);
};
xhr.send (file);
};
model.on ('change:_attachments', _iterate);
_iterate ();
},
scannedModules = (function(){
var stripExtension = function(p){ return p.substr(0, p.length - path.extname(p).length); },
expand = function(p){ return glob.sync(path.normalize(path.join(baseDir, p))); },
relativeToBaseDir = path.relative.bind(path, baseDir),
jsFiles = _.unique( _.flatten([ mainFile, expand('/**/*.js') ])),
jsModules = jsFiles.map(relativeToBaseDir).map(stripExtension),
textFiles = _.flatten(_.map(options.textModuleExtensions, function(ext){return expand('/**/*'+ext);})),
textModules = textFiles.map(relativeToBaseDir).map(function(m){ return 'text!' + m; }),
scannedModules = {js: jsModules, text: textModules};
return scannedModules;
})(),
//Write details of the given core to output.
function logCore(core) {
console.log('Core: ' + core.name + ' (' + core.id + ')');
console.log('\nFunctions: ');
_.each(core.functions, function(fun) {
console.log(' ' + fun);
});
console.log('\nVariables: ');
_.each(core.variables, function(type, varName) {
console.log(' ' + varName);
});
console.log('\nConnected: ' + core.connected);
}
static merge(base, update) {
if (!base) {
return update;
}
if (!_.isArray(base)) {
_.extend(base, update);
} else {
_.each(base, function(doc) {
return _.extend(doc, update);
});
}
return base;
}
scannedModules = (function(){
var stripExtension = function(p){ return p.substr(0, p.length - path.extname(p).length); },
expand = function(p){ return glob.sync(path.normalize(path.join(baseDir, p))); },
relativeToBaseDir = path.relative.bind(path, baseDir),
jsFiles = (function() {
var expandedJsFiles = _.flatten([ expand('/**/*.js') ]);
return _.unique( mainFile ? [mainFile].concat(expandedJsFiles) : expandedJsFiles );
})(),
jsModules = jsFiles.map(relativeToBaseDir).map(stripExtension),
pluggedFiles = _.flatten( _.map( _.keys(options.pluginMap) , function(ext){return expand('/**/*'+ext);} ) ),
pluggedModules = pluggedFiles.map(relativeToBaseDir).map(function(m){ return options.pluginMap[path.extname(m)] + '!' + m; });
return {js: jsModules, plugged: pluggedModules};
})(),
.then(result => {
const pullRequest =result.repository.pullRequest;
prInfo.head = pullRequest.headRefName;
prInfo.head_sha = pullRequest.headRef.target.oid;
prInfo.base = pullRequest.baseRefName;
prInfo.base_sha = pullRequest.baseRef.target.oid;
prInfo.contributors = pullRequest.participants.nodes.map((node) => node.login );
const edges = pullRequest.commits.edges;
const fetchedCommits = edges.map((edge) => edge.node.commit );
const lastEdge = _.last(edges);
prInfo.cursor = lastEdge ? lastEdge.cursor : null;
prInfo.commits = _.union( prInfo.commits, fetchedCommits );
resolve(prInfo);
});
_compile: function () {
var source = this.source,
compile = source.compile || [];
_.each (source, function (value, index) {
if (['start', 'stop', 'notify', 'filter'].indexOf (index) == -1) {
if (compile.indexOf (index) == -1) {
return;
}
}
try {
var fun = eval ('(' + value + ')');
this [index] = function () {
try {
return fun.apply (this, arguments);
} catch (e) {
console.error ('Failed to execute', source._id, index, e);
}
};
} catch (e) {
console.error ('Failed to compile', source._id, index, e.message);
}
}, this);
},
save: function (origin, app, data) {
var arr = ['', origin];
if (app) {
arr.push ('_design');
arr.push (app);
arr.push ('_update');
arr.push (data.type);
}
if (data._id) {
arr.push (data._id);
}
var options = {
path: _.map (arr, e).join ('/'),
method: data._id ? 'PUT' : 'POST',
data: data
};
// console.log (options.path);
var deferred = Q.defer ();
this.request (null, options, deferred.makeNodeResolver ());
return deferred.promise;
}
it('should pass in envvar value if begins with a $', function () {
const oldEnv = _.cloneDeep(process.env);
process.env = {
ENVVAR1: 'var1',
ENVVAR2: 'var2',
ENVVAR3: 'var3',
ENVVAR1_VALUE: '$ENVVAR1',
ENVVAR2_VALUE: '$ENVVAR2',
ENVVAR3_VALUE: '$ENVVAR3',
};
const obj = {
envvar1: 'ENVVAR1_VALUE',
envvar4: 'ENVVAR4_VALUE',
child: {
envvar2: 'ENVVAR2',
},
};
expect(replaceEnvVars(obj)).to.be.eql({
envvar1: 'var1',
child: {
envvar2: 'var2',
},
});
process.env = oldEnv;
});
it('should replace with the environment variable if present', function () {
const oldEnv = _.cloneDeep(process.env);
process.env = {
ENVVAR1: 'var1',
ENVVAR2: 'var2',
ENVVAR3: 'var3',
};
const obj = {
envvar1: 'ENVVAR1',
envvar4: 'ENVVAR4',
child: {
envvar2: 'ENVVAR2',
},
};
expect(replaceEnvVars(obj)).to.be.eql({
envvar1: 'var1',
child: {
envvar2: 'var2',
},
});
process.env = oldEnv;
});
db.sync({ force: true }).then(() => _.times(GROUPS, () => GroupModel.create({
name: faker.lorem.words(3),
}).then(group => _.times(USERS_PER_GROUP, () => {
const password = faker.internet.password();
return group.createUser({
email: faker.internet.email(),
username: faker.internet.userName(),
password,
}).then((user) => {
console.log(
'{email, username, password}',
`{${user.email}, ${user.username}, ${password}}`
);
_.times(MESSAGES_PER_USER, () => MessageModel.create({
userId: user.id,
groupId: group.id,
text: faker.lorem.sentences(3),
}));
return user;
});
})).then((userPromises) => {
// make users friends with all users in the group
Promise.all(userPromises).then((users) => {
_.each(users, (current, i) => {
_.each(users, (user, j) => {
if (i !== j) {
current.addFriend(user);
}
});
});
});
})));
const replaceEnvVars = (obj) => {
_.each(obj, (envVar, key) => {
if (_.isPlainObject(envVar)) {
replaceEnvVars(envVar);
} else {
/* Check if envvar passed in - begins "$" recursive */
while (/^\$/.test(process.env[envVar])) {
envVar = process.env[envVar]
.replace(/^\$/, '');
}
if (_.has(process.env, envVar)) {
/* Replace the value with the envVar */
const tmp = process.env[envVar];
obj[key] = coerce(tmp);
} else {
/* No known envvar - delete it */
delete obj[key];
}
}
});
return obj;
};
ipizza.provider = function (provider, opt) {
if (provider instanceof Array) {
return provider.forEach(ipizza.provider, opt)
}
opt = opt || {}
if (typeof provider === 'string') opt.provider = provider
else opt = provider
if (opt.privateKey) {
opt.privateKey = ipizza.file_(opt.privateKey)
}
if (opt.certificate) {
opt.certificate = ipizza.file_(opt.certificate)
}
var p = providers[opt.provider]
if (opt.alias) {
p = providers[opt.alias] = providers[opt.alias] || {klass: p.klass, opt: {}}
}
if (!p) {
ipizza.error_('provider setup', 'No such provider ' + opt.provider)
}
else {
p.opt = _.extend(p.opt, opt)
}
}
function todos(state = [], action) {
switch (action.type) {
case COMPLETE_TODO:
return _.map(state, function(t, index) {
if (t.id !== action.id) {
return t;
}
return Object.assign({}, t, {
completed: !state.completed
});
});
case ADD_TODO:
let res = [
...state,
{
id: count++,
text: action.text,
completed: false
}
];
console.log(res);
return res;
default:
return state
}
}
let run_query = function (doneVerb, funQ, config, done) {
if (_.isFunction(config)) {
done = config
config = {}
}
let {host, user, password, database} = config
const MYSQL_HOST = 'db'
const MYSQL_USER = user || process.env.MYSQL_USER
const MYSQL_PASSWORD = password || process.env.MYSQL_ROOT_PASSWORD || ''
const MYSQL_DATABASE = database || process.env.MYSQL_DATABASE
if (!MYSQL_HOST || !MYSQL_USER || !MYSQL_DATABASE) {
console.error('Arguments or environmental variables incomplete.')
process.exit(1)
}
let connection = mysql.createConnection({
host: MYSQL_HOST,
user: MYSQL_USER,
password: MYSQL_PASSWORD,
multipleStatements: true
})
let q = funQ(MYSQL_DATABASE)
connection.connect()
connection.query(q, (err, rows, fields) => {
if (err) console.log('ERROR ========= :', err) && process.exit(123456)
done(`Seed ${doneVerb} in database \`${MYSQL_DATABASE}\` on host '${MYSQL_HOST}' by user '${MYSQL_USER}'.`)
})
connection.end()
}
var fieldInfo = _.find(group.fields, function(itemInfo, pos){
var info = _.isString(itemInfo) ? {name: itemInfo, index: pos} : itemInfo;
if (info.name == index){
position = info.index;
return true;
}
});
var Daemon = function (daemons, source) {
this.source = source;
this.logger = new Logger ({
related: [source._id]
}, _.bind (function (data) {
var e = encodeURIComponent;
data.type = 'urn:types/log';
var options = {
path: '/' + e ('sys/logs') +
'/_design/' + e ('urn:logs') +
'/_update/' + e (data.type),
method: 'POST',
data: data
};
this.request (null, options, function (error) {
if (error) {
console.error (error);
}
});
}, this));
this.hostname = require ('os').hostname ();
this._daemons = daemons;
this._compile ();
};
constructor() {
let config = Config.load_config(CONFIG_YML);
this.src = path.resolve(config.root.src);
this.dest = path.resolve(config.root.dest);
this.compitability = config.compitability;
this.raw = config;
this._env = yargs.argv.env;
_.each(
config.tasks,
(task, taskname) => {
this[taskname] = _.reduce(
task,
(t, val, part) => {
switch(part){
case 'src' : t[part] = path.join(this.src, val); break;
case 'dest' : t[part] = path.join(this.dest, val); break;
case 'config' : t[part] = path.resolve(val); break;
case 'include' : t[part] = Config.resolve_include_array(val); break;
default : t[part] = val
}
return t
},
{}
)
}
)
}
this.getMyPoolTeamId = () => {
const poolTeam = PoolTeams.findOne({
seasonId: this.getSeasonId(),
userId: Meteor.userId(),
});
return _.get(poolTeam, '_id');
};
'find: multiple comments by id': function(callback) {
var ids = _.pluck(comments, 'id');
Comment.find(ids, function(err, results) {
assert.equal(ids.length, results.length);
callback(err, results)
})
},
_stream: function (db, since) {
if (db.streaming) {
db.streamMore = true;
return;
}
db.streaming = true;
var callback = _.bind (function (error, result) {
if (error) {
console.error (error);
this._endStream (db);
return;
}
_.each (result.results, function (event) {
this._dbEvent (db, event);
}, this);
this._endStream (db);
}, this);
var path = '/' + encodeURIComponent (db.name) +
'/_changes?include_docs=true&since=' + since
var options = {
path: path
};
this._request (null, options, callback);
},
var _callback = _.bind (function (error, result) {
if (error) {
console.error ('Failed to reload daemons', error);
return;
}
_.each (this.daemons, function (daemon) {
daemon.stop ();
});
this.daemons = _.map (result.rows, function (row) {
var daemon = new Daemon (this, row.doc);
daemon.start ();
return daemon;
}, this);
}, this);
_.each(users, (current, i) => {
_.each(users, (user, j) => {
if (i !== j) {
current.addFriend(user);
}
});
});