(data, next) => {
const itemId = data.item.itemId;
const playerId = data.player.playerId;
const itemValue = Math.min(65535, data.item.itemValue + 10);
const playerItems = _.without(data.player.playerItems, itemId);
const target = 'player' + data.item.itemEffectTarget;
let targetValue = data.player[target] + data.item.itemEffectValue;
targetValue = Math.max(0, targetValue);
if (target === 'playerExp') {
targetValue = Math.min(65535, targetValue);
} else {
targetValue = Math.min(255, targetValue);
}
async.parallel({
player: (done) => {
service.user.updatePlayer(playerId, {
playerItems: playerItems.join(','),
[target]: targetValue
}, done);
},
item: (done) => {
service.item.updateItem(itemId, {
itemValue: itemValue
}, done);
},
}, next);
},
mongo.find('post', {postId: postId}, {postId: true, postItemId: true, postUserId: true, postDateTime: true, postItemScore: true, postItemState: true, postLikeUsers: true}, undefined, function(result){
var r = result[0];
var d = new Date(r.postDateTime * 1000);
var date = d.getYear() + "年" + (d.getMonth() + 1) + '月' + d.getDate() + "日 "
+ d.getHours() + ":" + d.getMinutes() + ":" + d.getSeconds();
var parallels = [];
parallels.push(function (done){
mongo.find('item', {itemId: r.postItemId}, {itemId: true, itemImage: true, itemSupplier:true, itemSoldQuantity:true, itemSalePrice: true, itemTags: true}, undefined, function(itemResult){
done({item: itemResult[0]});
});
});
parallels.push(function (done){
mongo.find('user', {userId: r.postUserId}, {userImage: true}, undefined, function(userResult){
done(userResult[0].userImage);
});
});
async.parallel(parallels, function(pararesult){
var post = {
postId: r.postId,
postItem: pararesult.item,
postUserId: r.postUserId,
postUserImage: pararesult.userImage,
postDateTime: date,
postItemScore: r.postItemScore,
postItemState: r.postItemState,
postLikeUsers: r.postLikeUsers.split(',')
};
res.render('post', {post: post, item: pararesult.item, userImage: pararesult.userImage});
});
});
exports.getFacebook = function(req, res, next) {
graph = require('fbgraph');
var token = req.user.tokens.facebook;
graph.setAccessToken(token);
async.parallel({
getMe: function(done) {
graph.get(req.user.facebookId, function(err, me) {
done(err, me);
});
},
getMyFriends: function(done) {
graph.get(req.user.facebookId + '/friends', function(err, friends) {
done(err, friends.data);
});
}
},
function(err, results) {
if (err) return next(err);
res.render('api/facebook', {
title: 'Facebook API',
me: results.getMe,
friends: results.getMyFriends
});
});
};
export default function updateInspectQuery (rConn, opts, cb) {
let calls = [];
Object.keys(opts.matchups).forEach(uUuid => {
calls.push(rearrangeUpcoming(rConn, opts.tournamentUuid, uUuid, opts.matchups[uUuid]));
});
async.parallel(calls, cb);
}
function writeResult (name, content, fn) {
var funcs = [
async.apply(writeFile, name, content.css)
];
if (content.map && name) {
funcs.push(async.apply(writeFile, name + '.map', content.map.toString()));
}
async.parallel(funcs, fn);
}
(next) => {
async.parallel({
player: (done) => {
service.user.getAll(done);
},
item: (done) => {
service.item.getAll(done);
}
}, next);
},
module.exports = function upload(stream, idOrPath, tag, done) {
var queries = new Array(global.parallelQueries);
var tx = db.begin();
for( var i = 0, len = queries.length; i < len; ++i ) {
queries[i] = fileInsertFor(i, tx);
}
async.parallel(queries, function(err, callback) {
if (err) {
tx.rollback();
done(err);
}
else {
tx.commit();
done();
}
});
}
info(hostname, callback) {
const parts = hostname.split('.');
if (parts.length === 1) throw Error(`Invalid hostname ${hostname}`);
if (parts.length === 2) return callback();
const domain = _.slice(parts, -2).join('.');
const subdomain = _.slice(parts, 0, -2).join('.');
async.parallel({
ns: cb => dns.resolveNs(domain, cb),
ip: cb => publicIp.v4().then(ip => cb(null, ip)),
}, (err, { ns, ip }) => {
let api;
if (/yandex\.(ru|net)/.test(ns[0])) {
this.logger(`dns ${domain} nameservers: ${ns.join(' ')}`);
this.logger(`dns ${hostname} public IP: ${ip}`);
api = new YandexDns();
}
callback(err, { domain, subdomain, ns, ip, api });
});
}
exports.getSteam = function(req, res, next) {
var steamId = '76561198040657099';
var query = { l: 'english', steamid: steamId, key: secrets.steam.apiKey };
async.parallel({
playerAchievements: function(done) {
query.appid = '49520';
var qs = querystring.stringify(query);
request.get({ url: 'http://api.steampowered.com/ISteamUserStats/GetPlayerAchievements/v0001/?' + qs, json: true }, function(error, req1, body) {
if (req1.statusCode === 401) return done(new Error('Missing or Invalid Steam API Key'));
done(error, body);
});
},
playerSummaries: function(done) {
query.steamids = steamId;
var qs = querystring.stringify(query);
request.get({ url: 'http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?' + qs, json: true }, function(err, req1, body) {
if (req1.statusCode === 401) return done(new Error('Missing or Invalid Steam API Key'));
done(err, body);
});
},
ownedGames: function(done) {
query.include_appinfo = 1;
query.include_played_free_games = 1;
var qs = querystring.stringify(query);
request.get({ url: 'http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?' + qs, json: true }, function(err, req1, body) {
if (req1.statusCode === 401) return done(new Error('Missing or Invalid Steam API Key'));
done(err, body);
});
}
},
function(err, results) {
if (err) return next(err);
res.render('api/steam', {
title: 'Steam Web API',
ownedGames: results.ownedGames.response.games,
playerAchievemments: results.playerAchievements.playerstats,
playerSummary: results.playerSummaries.response.players[0]
});
});
};
var fetchNewFolderName = function (callback) {
async.parallel([
function (cb) {
r = Math.floor(Math.random() * count)
// Find random word from database
FolderWordsModel.find({}).limit(1).skip(r).exec(function (err, data) {
if (err) return cb(err)
word1 = data[0].word
cb()
})
},
function (cb) {
r = Math.floor(Math.random() * count)
// Find another random word from database
FolderWordsModel.find({}).limit(1).skip(r).exec(function (err, data) {
if (err) return cb(err)
// First letter to uppercase
word2 = data[0].word.charAt(0).toUpperCase() + data[0].word.slice(1)
cb()
})
}
], function (err) {
if (err) return callback(err)
// Check from FilesModel wether the randomized foldername already exists
FilesModel.find({folder: word1 + word2}).exec(function (err, data) {
if (err) return callback(err)
// If folder already exists, fetch folder name again recursively
if (data.length !== 0) {
return fetchNewFolderName(callback)
}
callback(null, word1 + word2)
})
})
}
exports.getVenmo = function(req, res, next) {
var token = req.user.tokens.venmo;
var query = querystring.stringify({ access_token: token.accessToken });
async.parallel({
getProfile: function(done) {
request.get({ url: 'https://api.venmo.com/v1/me?' + query, json: true }, function(err, req1, body) {
done(err, body);
});
},
getRecentPayments: function(done) {
request.get({ url: 'https://api.venmo.com/v1/payments?' + query, json: true }, function(err, req1, body) {
done(err, body);
});
}
},
function(err, results) {
if (err) return next(err);
res.render('api/venmo', {
title: 'Venmo API',
profile: results.getProfile.data,
recentPayments: results.getRecentPayments.data
});
});
};
'neo-async': function(callback) {
neo_async.parallel(tasks, callback);
}
exports.getLastfm = function(req, res, next) {
LastFmNode = require('lastfm').LastFmNode;
var lastfm = new LastFmNode(secrets.lastfm);
async.parallel({
artistInfo: function(done) {
lastfm.request('artist.getInfo', {
artist: 'The Pierces',
handlers: {
success: function(data) {
done(null, data);
},
error: function(err) {
done(err);
}
}
});
},
artistTopTracks: function(done) {
lastfm.request('artist.getTopTracks', {
artist: 'The Pierces',
handlers: {
success: function(data) {
var tracks = [];
_.each(data.toptracks.track, function(track) {
tracks.push(track);
});
done(null, tracks.slice(0,10));
},
error: function(err) {
done(err);
}
}
});
},
artistTopAlbums: function(done) {
lastfm.request('artist.getTopAlbums', {
artist: 'The Pierces',
handlers: {
success: function(data) {
var albums = [];
_.each(data.topalbums.album, function(album) {
albums.push(album.image.slice(-1)[0]['#text']);
});
done(null, albums.slice(0, 4));
},
error: function(err) {
done(err);
}
}
});
}
},
function(err, results) {
if (err) return next(err.error.message);
var artist = {
name: results.artistInfo.artist.name,
image: results.artistInfo.artist.image.slice(-1)[0]['#text'],
tags: results.artistInfo.artist.tags.tag,
bio: results.artistInfo.artist.bio.summary,
stats: results.artistInfo.artist.stats,
similar: results.artistInfo.artist.similar.artist,
topAlbums: results.artistTopAlbums,
topTracks: results.artistTopTracks
};
res.render('api/lastfm', {
title: 'Last.fm API',
artist: artist
});
});
};
function benchNeoParallel (done) {
neo.parallel([somethingA, somethingA, somethingA], done)
}
(err, results) => {
if (err) return callback(err);
let loaders = results[0];
const resourceResolveData = results[1].resourceResolveData;
resource = results[1].resource;
// translate option idents
try {
for (const item of loaders) {
if (typeof item.options === "string" && item.options[0] === "?") {
const ident = item.options.substr(1);
item.options = this.ruleSet.findOptionsByIdent(ident);
item.ident = ident;
}
}
} catch (e) {
return callback(e);
}
if (resource === false) {
// ignored
return callback(
null,
new RawModule(
"/* (ignored) */",
`ignored ${context} ${request}`,
`${request} (ignored)`
)
);
}
const userRequest = loaders
.map(loaderToIdent)
.concat([resource])
.join("!");
let resourcePath = resource;
let resourceQuery = "";
const queryIndex = resourcePath.indexOf("?");
if (queryIndex >= 0) {
resourceQuery = resourcePath.substr(queryIndex);
resourcePath = resourcePath.substr(0, queryIndex);
}
const result = this.ruleSet.exec({
resource: resourcePath,
resourceQuery,
issuer: contextInfo.issuer,
compiler: contextInfo.compiler
});
const settings = {};
const useLoadersPost = [];
const useLoaders = [];
const useLoadersPre = [];
for (const r of result) {
if (r.type === "use") {
if (r.enforce === "post" && !noPrePostAutoLoaders)
useLoadersPost.push(r.value);
else if (
r.enforce === "pre" &&
!noPreAutoLoaders &&
!noPrePostAutoLoaders
)
useLoadersPre.push(r.value);
else if (!r.enforce && !noAutoLoaders && !noPrePostAutoLoaders)
useLoaders.push(r.value);
} else if (
typeof r.value === "object" &&
r.value !== null &&
typeof settings[r.type] === "object" &&
settings[r.type] !== null
) {
settings[r.type] = cachedMerge(settings[r.type], r.value);
} else {
settings[r.type] = r.value;
}
}
asyncLib.parallel(
[
this.resolveRequestArray.bind(
this,
contextInfo,
this.context,
useLoadersPost,
loaderResolver
),
this.resolveRequestArray.bind(
this,
contextInfo,
this.context,
useLoaders,
loaderResolver
),
this.resolveRequestArray.bind(
this,
contextInfo,
this.context,
useLoadersPre,
loaderResolver
)
],
(err, results) => {
if (err) return callback(err);
loaders = results[0].concat(loaders, results[1], results[2]);
process.nextTick(() => {
const type = settings.type;
const resolveOptions = settings.resolve;
callback(null, {
context: context,
request: loaders
.map(loaderToIdent)
.concat([resource])
.join("!"),
dependencies: data.dependencies,
userRequest,
rawRequest: request,
loaders,
resource,
resourceResolveData,
settings,
type,
parser: this.getParser(type, settings.parser),
generator: this.getGenerator(type, settings.generator),
resolveOptions
});
});
}
);
}
function benchNeoParallel (done) {
neo.parallel(funcs, done)
}
(err, beforeResolveResult) => {
if (err) return callback(err);
// Ignored
if (!beforeResolveResult) return callback();
const context = beforeResolveResult.context;
const request = beforeResolveResult.request;
const resolveOptions = beforeResolveResult.resolveOptions;
let loaders,
resource,
loadersPrefix = "";
const idx = request.lastIndexOf("!");
if (idx >= 0) {
loaders = request.substr(0, idx + 1);
let i;
for (i = 0; i < loaders.length && loaders[i] === "!"; i++) {
loadersPrefix += "!";
}
loaders = loaders
.substr(i)
.replace(/!+$/, "")
.replace(/!!+/g, "!");
if (loaders === "") loaders = [];
else loaders = loaders.split("!");
resource = request.substr(idx + 1);
} else {
loaders = [];
resource = request;
}
const contextResolver = this.resolverFactory.get(
"context",
resolveOptions || EMPTY_RESOLVE_OPTIONS
);
const loaderResolver = this.resolverFactory.get(
"loader",
EMPTY_RESOLVE_OPTIONS
);
asyncLib.parallel(
[
callback => {
contextResolver.resolve(
{},
context,
resource,
{},
(err, result) => {
if (err) return callback(err);
callback(null, result);
}
);
},
callback => {
asyncLib.map(
loaders,
(loader, callback) => {
loaderResolver.resolve(
{},
context,
loader,
{},
(err, result) => {
if (err) return callback(err);
callback(null, result);
}
);
},
callback
);
}
],
(err, result) => {
if (err) return callback(err);
this.hooks.afterResolve.callAsync(
Object.assign(
{
addon:
loadersPrefix +
result[1].join("!") +
(result[1].length > 0 ? "!" : ""),
resource: result[0],
resolveDependencies: this.resolveDependencies.bind(this)
},
beforeResolveResult
),
(err, result) => {
if (err) return callback(err);
// Ignored
if (!result) return callback();
return callback(
null,
new ContextModule(result.resolveDependencies, result)
);
}
);
}
);
}
var TICK = function () {
async.parallel(tickers, function(err, tickData) {
sendTick(tickData);
});
};