app.put('/Contact/:id', function(req, res){
var editContact = _.find(contacts, function(c){
return req.body.id == c.id;
});
editContact.firstname = req.body.firstname;
editContact.lastname = req.body.lastname;
if(req.body.phonenumbers){
editContact.phonenumbers = req.body.phonenumbers;
_.each(editContact.phonenumbers, function(phonenumber){
if(!phonenumber.id){
phonenumber.id = uuid.v1();
}
});
}
console.log("Update " + JSON.stringify(editContact));
res.send(editContact);
});
_.each(arr, function (elem) {
if (elem.IsDeleted) {
skdUsers = _.reject(skdUsers, function (subElem) {
return subElem.Id == elem.Id;
});
} else {
if (_.find(skdUsers, function (subElem) {
return subElem.Id == elem.Id;
}) == null) {
skdUsers.push(elem);
} else {
skdUsers = _.reject(skdUsers, function (subElem) {
return subElem.Id == elem.Id;
});
skdUsers.push(elem);
}
}
});
function drawImageForHeroId(heroId, dx, dy, ctx, scale) {
// the 'heroes' object contains all we need for this. It's a list of hero
// objects with their heroIds and their x/y positions within the minimap
// sheet.
if(_.isUndefined(scale)) {
scale = 24;
}
var hero = _.find(heroes, function(hero) {
return hero.id == heroId;
});
if(_.isUndefined(hero)) {
return;
}
ctx.drawImage(heroSpriteSheet, hero.x, hero.y, 32, 32, dx, dy, scale, scale);
}
describeCache(table).then(function(sobject) {
logger.debug('table '+table+'has been described');
if (fpath.length > 1) {
var rname = fpath.shift();
var rfield = _.find(sobject.fields, function(f) {
return f.relationshipName &&
f.relationshipName.toUpperCase() === rname.toUpperCase();
});
if (rfield) {
var rtable = rfield.referenceTo.length === 1 ? rfield.referenceTo[0] : 'Name';
return expandAsteriskField(rtable, fpath.join('.')).then(function(fpaths) {
return _.map(fpaths, function(fpath) { return rname + '.' + fpath; });
});
} else {
return [];
}
} else {
return _.map(sobject.fields, function(f) { return f.name; });
}
}) :
statePool.on('add', function(langNode) {
logger.statepool("Adding:");
logger.statepool(JSON.stringify(_.extend({}, langNode)));
var currentComponent;
//Make sure the item is unique.
//TODO: I'm not sure what this does with regexs
var duplicate = _.find(chart[idx], function(item) {
return compareLangNodes(langNode, item);
});
if(duplicate) {
//Duplicates generate interpretations.
//I'm not sure if that's the right way to do it.
//When I rewrite this I think I will go back to using a separate
//step to generate the tree, however I will attempt to make that step streaming
//so it can happen as the parse chart is genrated.
console.log("Duplicate found:");
console.log(JSON.stringify(utils.deprototype(langNode), 2, 2));
//duplicate.interpretations = duplicate.interpretations.concat(langNode.interpretations);
mergeInterpretations(duplicate.interpretations, langNode.interpretations);
return;
}
statePool.counter++;
chart[idx].push(langNode);
if(langNode.parseData.atComponent < langNode.components.length) {
currentComponent = langNode.components[langNode.parseData.atComponent];
if('terminal' in currentComponent) {
terminalScanner(langNode, idx);
} else if('category' in currentComponent) { //categories are non-terminals
predictor(langNode, idx);
} else if('regex' in currentComponent) {
regexScanner(langNode, idx);
} else {
throw "Unknown component type:\n" + JSON.stringify(currentComponent);
}
} else {
completer(langNode, idx);
}
});
socket.on("joinServer", function(name) {
var exists = false;
var ownerRoomID = inRoomID = null;
//check if user name exist
underScore.find(people, function(key,value) {
if (key.name.toLowerCase() === name.toLowerCase())
return exists = true;
});
if (exists) {
socket.emit("userExists", {msg: "Username is all ready in use, please use another one."});
} else {
people[socket.id] = new User(name, ownerRoomID, inRoomID);
socket.emit("messageFromServer", "Welcome to chat server.");
io.sockets.emit("messageFromServer", people[socket.id].name + " is online.");
socket.emit("yourData", people[socket.id]);
io.sockets.emit("updatePeople", {people: people, count: underScore.size(people)});
socket.emit("rooms", {rooms: rooms, count: underScore.size(rooms)});
sockets.push(socket);
}
});
specHelper.defaultGateway.plan.all(function (err, response) {
assert.isNull(err);
assert.isTrue(response.success);
let plan = _.find(response.plans, plan => plan.id === attributes.id);
assert.equal(attributes.id, plan.id);
assert.equal(attributes.billingDayOfMonth, plan.billingDayOfMonth);
assert.equal(attributes.billingFrequency, plan.billingFrequency);
assert.equal(attributes.currencyIsoCode, plan.currencyIsoCode);
assert.equal(attributes.description, plan.description);
assert.equal(attributes.name, plan.name);
assert.equal(attributes.numberOfBillingCycles, plan.numberOfBillingCycles);
assert.equal(attributes.price, plan.price);
assert.equal(attributes.trialPeriod, plan.trialPeriod);
assert.isNotNull(plan.createdAt);
assert.isNotNull(plan.updatedAt);
assert.equal(addOnAttributes.name, plan.addOns[0].name);
assert.equal(discountAttributes.name, plan.discounts[0].name);
done();
})
function onCreateGame(name) {
var exists = false;
_.find(games, function(k, v) {
if (k.name.toLowerCase() === name.toLowerCase())
return exists = true;
});
if (exists) {
return;
}
var uniqueGameID = uuid.v4();
var game = new Game(name, uniqueGameID, socket.id);
players[socket.id].person = 'pacmen';
players[socket.id].owns = uniqueGameID;
players[socket.id].ingame = uniqueGameID;
players[socket.id].game = game;
players[socket.id].roomname = name;
game.addPlayer(players[socket.id]);
games[uniqueGameID] = game;
socket.room = name;
socket.join(socket.room);
socket.emit('joined:game', players[socket.id]);
io.sockets.emit('list:games', games);
}
socket.on('start', (name, device) => {
var ownerRoomID = null;
var inRoomID = null;
var exists = _.find(people, (person) => {
return person.name.toLowerCase() === name.toLowerCase();
});
if (exists) {
socket.emit('nameExists', 'The username already exists. Please pick another one.');
} else {
people[socket.id] = {
'name' : name,
'owns' : ownerRoomID,
'inroom': inRoomID,
'device': device
};
// connection msg
io.emit('update', people[socket.id].name + ' is online.');
// update people and rooms
peopleCount = _.size(people);
roomCount = _.size(rooms);
socket.emit('updateRoomCount', {
rooms: rooms,
count: roomCount
});
io.emit('updatePeopleCount', {
people: people,
count: peopleCount
});
// record socket
sockets.push(socket);
}
});
_.each(destinationTranslations, function(destinationTranslation) {
var sourceTranslation = _.find(sourceTranslations, function(sourceTranslation) {
return destinationTranslation.key === sourceTranslation.key
&& destinationTranslation.namespace === sourceTranslation.namespace;
}),
mergedTranslation;
if(sourceTranslation) {
_.each(argv.p, function(property) {
if(_.has(sourceTranslation, property)) {
if(!mergedTranslation) {
mergedTranslation = {
_id: destinationTranslation._id
};
}
mergedTranslation[property] = sourceTranslation[property];
}
});
}
if(mergedTranslation) {
mergedTranslations.push(mergedTranslation);
}
});
function findDiscovery (targetIP) {
return _.find(netDb.db, function (value) {
return value.ipv4 == targetIP;
});
}
getOpponent: function(playerID) {
'use strict';
return _.find(this.battleModel.getPlayers(), function(id) {
return id !== playerID;
});
},
_.each(["radiant", "dire"], function(team) {
// the game.teams listing is unreliable,
// check te last snapshot instead.
var name = game.lastSnapshot[team + "_team"].team_name;
var team_id = game.lastSnapshot[team + "_team"].team_id;
var winner = _.find(matchMetadata.teams, function(team) {
return team.team_id==team_id;
}).winner;
var coords = {};
// team logos are 250x150
// we'll shrink them down to 40 high, so 67 wide
// try to read the file for the team_id.
var teamLogo = false;
var logoImage = null;
var offset = 5;
try {
teamLogo = fs.readFileSync("assets/teams/" + team_id + ".png");
logoImage = new Image;
logoImage.src = teamLogo;
offset = 40;
} catch (e) {
winston.warn("Issue loading team logo: " + e);
}
var textOffset = 0;
if(team=="radiant") {
coords = {x:offset, y:23};
} else {
coords = {x:offset, y:200-7-10};
}
if(teamLogo) {
ctx.drawImage(logoImage, 5, coords.y-18, 30, (logoImage.width/logoImage.height)*30);
}
if(winner) {
var textDimensions = ctx.measureText(name);
ctx.fillStyle = GOLD_COLOR;
ctx.fillRect(coords.x-2, coords.y-18, textDimensions.width+5, 16);
ctx.fillStyle = BACKGROUND_COLOR;
} else {
ctx.fillStyle = "#fff";
}
ctx.fillText(name, coords.x, coords.y-6);
// Series data goes here
var seriesStatus = matchMetadata.seriesStatus;
winston.info("seriesStatus: " + JSON.stringify(seriesStatus));
if(seriesStatus && ("series_type" in seriesStatus)) {
var gamesToWin = seriesStatus.series_type+1;
var wins = seriesStatus.teams[game.lastSnapshot[team + "_team"].team_id];
// now we're gong to make as many empty blocks as there are games to win
// and set the backgrounds gold for the ones that are < wins.
var seriesCoords = {x:coords.x, y:coords.y+12};
ctx.strokeStyle = "#ccc";
ctx.lineWidth = 1;
for(var i=0; i<gamesToWin; i++) {
if(i<wins) {
ctx.fillStyle = GOLD_COLOR;
} else {
// paint it gold!
ctx.fillStyle = "rgba(0,0,0,0.7)";
}
ctx.strokeRect(seriesCoords.x+2, seriesCoords.y-10, 15, 8);
ctx.fillRect(seriesCoords.x+2, seriesCoords.y-10, 15, 8);
seriesCoords.x += 20;
}
}
_.each(game.lastSnapshot.scoreboard[team].players, function(player, index) {
util.drawImageForHeroId(player.hero_id, coords.x + 260 - offset + (index*28), coords.y-20, ctx);
});
});
this.getUnitVMByID = function(id) {
id = parseInt(id, 10);
return _.find(this.unitVMs, function(uVM) {
return uVM.m.id === id;
});
};
getItemByID: function(id) {
'use strict';
return _.find(this.built, function(b) {
return b.id === parseInt(id, 10);
});
},
byName: function(name) {
return _.find(this.images, function(image_json) {
return image_json.image.match(name)
})
},
pendingTasks = __.filter( data.data, function ( task ) {
var assigned =__.find( task.assigned, function ( assigned ) {
return assigned === Auth.user.username;
});
return task.status === 'Por hacer' && assigned === Auth.user.username;
});
var unknownSrcs = _.map(unknownNames, function (name){
return _.find(srcs, function (src){
return src.name == name;
});
});
], function(err, items) {
var prefix = options.appOptions.featherRoot,
featherFiles = items['feather-files'],
restProxyInfo = items['feather-restProxyInfo'];
var cssFiles = [];
// js -----------------------------------------------------------------
var jsFiles = [
{path: "/feather-client/lib/underscore-min.js", prefix: prefix},
options.appOptions["socket.io"].enabled ? {path: "/socket.io/socket.io.js", prefix: prefix, virtual: true} : null,
{path: "/feather-client/lib/json2.js", prefix: prefix, minifyAllowed: false},
{path: "/feather-client/lib/jquery-1.7.min.js", prefix: prefix},
// {path: "/feather-client/lib/jquery-1.9.migrate.min.js", prefix: prefix},
{path: "/feather-client/lib/jquery.tmpl.js", prefix: prefix},
{path: "/feather-client/lib/jquery.cookie.js", prefix: prefix},
{path: "/feather-client/lib/inherits.js", prefix: prefix},
{path: "/feather-client/feather.js", prefix: prefix},
{path: "/feather-client/base-class.js", prefix: prefix},
{path: "/feather-client/event-publisher.js", prefix: prefix},
{path: "/feather-client/dom-event-cache.js", prefix: prefix},
{path: "/feather-client/registry.js", prefix: prefix},
{path: "/feather-client/semaphore.js", prefix: prefix},
{path: "/feather-client/fsm.js", prefix: prefix},
{path: "/feather-client/util.js", prefix: prefix},
{path: "/feather-client/widget.js", prefix: prefix},
{path: "/feather-client/socket.js", prefix: prefix}
];
if (options.appOptions.rest && options.appOptions.rest.autoGenerateProxy && restProxyInfo) {
//add the restProxy files
jsFiles.push({path: "/feather-client/restProxy.js", prefix: prefix});
jsFiles.push({
path: restProxyInfo.path,
prefix: restProxyInfo.prefix
});
}
// Only add the auth scripts if this app has auth enabled.
if (options.appOptions.auth.enabled) {
//jsFiles.push({path: "feather-client/sha512.js", prefix: prefix});
jsFiles.push({path: "/feather-client/auth-client.js", prefix: prefix});
}
// Add datalinking if enabled
if (options.appOptions.data.datalinking.enabled) {
jsFiles.push({path: "/feather-client/lib/jquery.datalink.js", prefix: prefix});
}
// Add files for the ui provider if enabled
if (options.appOptions.ui.enabled) {
var uiJSPrefix = prefix,
uiCSSPrefix = prefix,
provider = options.appOptions.ui.provider,
providers = options.appOptions.ui.providers;
if (typeof provider === 'string') {
provider = _.find(providers, function(_provider) {
return _provider.name === provider;
});
}
//get the js files
var appFiles = _.keys(featherFiles.appFiles);
if (provider.jsRoot === "/") uiJSPrefix = options.appOptions.publicRoot;
_.each(provider.jsFiles, function(file) {
var _path = file,
_prefix = uiJSPrefix;
//detect automatic app overrides (via dropping in new files in the /public/_ui folder)
var fileName = path.basename(file);
var overrideFile = _.find(appFiles, function(_appFile) {
return _appFile.indexOf('/public/_ui/' + provider.name + '/js/' + fileName) > -1;
});
if (overrideFile) {
_prefix = options.appOptions.publicRoot;
_path = '/' + path.relative(options.appOptions.publicRoot, overrideFile);
}
jsFiles.push({path: _path, prefix: _prefix});
});
//get the css files
if (provider.cssRoot === "/") uiCSSPrefix = options.appOptions.publicRoot;
_.each(provider.cssFiles, function(file) {
var _path = file,
_prefix = uiCSSPrefix;
//detect automatic app overrides (via dropping in new files in the /public/_ui folder)
var fileName = path.basename(file);
var overrideFile = _.find(appFiles, function(_appFile) {
return _appFile.indexOf('/public/_ui/' + provider.name + '/css/' + fileName) > -1;
});
if (overrideFile) {
_prefix = options.appOptions.publicRoot;
_path = '/' + path.relative(options.appOptions.publicRoot, overrideFile);
}
cssFiles.push({path: _path, prefix: _prefix});
});
}
var jsOptions = _.extend(_.clone(options), {
template: '<clientscript type="text/javascript" src="${href}"></clientscript>',
cacheName: "feather-client-core.js",
hrefPrefix: "",
contentType: "text/javascript",
files: _.compact(jsFiles)
});
var frameworkPackaged = new Semaphore(callback);
frameworkPackaged.increment();
exports.packageResources(jsOptions, function(err) {
frameworkPackaged.execute(err);
});
if (cssFiles.length) {
var cssOptions = _.extend(_.clone(options), {
template: '<link rel="stylesheet" type="text/css" href="${href}" />',
cacheName: "feather-client-core.css",
contentType: "text/css",
files: cssFiles
});
frameworkPackaged.increment();
exports.packageResources(cssOptions, function(err) {
frameworkPackaged.execute(err);
});
}
});
socket.on('submitPin', function(data){
var pinValue = data.pinValue;
var code = data.code;
var userPin = _.find(skdUsers, function (subElem) {
return subElem.Pin == pinValue;
});
if(userPin == null){
console.log("Неверный пин");
socket.emit("pinFalse",123);
return;
}
else if(code==1){
currentUser = userPin.Id;
SetSignal(false);
var userFullName = "";
if (currentUser != null){
userFullName = userPin.LastName;
if (userPin.FirstName != ""){
userFullName += " " + userPin.FirstName[0] + ".";
}
if (userPin.FatherName != ""){
userFullName += " " + userPin.FatherName[0] + ".";
}
}
socket.emit("alarmDeactivated", userFullName);
socket.broadcast.emit("alarmDeactivated", null);
}
else if(code==2){
doorCloseTimeLeft = 60;
if (!startedAlarmOnInterval) {
startedAlarmOnInterval = true;
blinkLight();
waitingForDoorCloseInterval = setInterval(function () {
doorCloseTimeLeft--;
if (doorCloseTimeLeft < 0) doorCloseTimeLeft = 0;
if (doorCloseTimeLeft < 1) {
if (doorState == "0"){
socket.emit("alarmActivationFailed", 123);
socket.broadcast.emit("alarmActivationFailed", 123);
SetSignal(false);
}
else {
SetSignal(true);
socket.emit("alarmActivated", 123);
socket.broadcast.emit('alarmActivated', 123);
}
}
else{
socket.emit('alarmActivateAfter', doorCloseTimeLeft);
socket.broadcast.emit('alarmActivateAfter', doorCloseTimeLeft);
}
}, 1000);
}
}
else if(code==3){
socket.emit('facilityDetails', 123);
}
});
io.sockets.on('connection', function (socket) {
var session = socket.handshake.session; // the session variable for this connection/user;
var sessionIntervalId = setInterval(function () {
session.reload(function() {
session.touch().save();
});
}, 60 * 1000); // touch the session every 60 seconds;
socket.on('disconnect', function() {
clearInterval(sessionIntervalId);
});
// assign a ship by id to the session
// We can't just set the ship into the session as it can't persist
// objects with their member functions, so we just need to retrieve
// the ship by it's id
var ship = null; // called ship for now, for reference below
var newShip = false;
if (typeof session.shipId === 'undefined' || session.shipId === null) {
// TODO: This will occasionally error out if the client is still running while the node server get's restarted
// possible solution is to use the sessionID to identify the ship
// first time here? get yer'self a ship!
ship = new OpenSpace.Ship(
'ship',
Math.random() * 1000 - 500,
Math.random() * 1000 - 500,
Math.random() * 1000 - 500
);
ship.id = ++shipCounter;
session.shipId = ship.id;
session.save();
ships.push(ship);
newShip = true; // so we can tell the world about us
} else {
// otherwise find the ship in the ships array
ship = _.find(ships, function(ship) { return ship.id == session.shipId});
}
console.log(' [*] Client connection, sid: ' + session.id + ' shipId: ' + session.shipId)
socket.emit('openspace.welcome', {msg: 'Welcome to OpenSpace', ship: ship, world: game.getWorldState()});
socket.broadcast.emit('openspace.new.ship', {msg: 'Ship detected', ship: ship.getState()}); // tell everyone (but us) that we arrived
socket.on('ship.drive', function(data) {
ship.drive();
});
socket.on('ship.thrust', function(message) {
ship.thrust(message.type);
});
socket.on('torpedo.fire', function(data, fn) {
// TODO: it would be great if this were integrated into the ship object
var torpedo = new OpenSpace.Ship('torpedo');
torpedo.id = ++shipCounter;
torpedo.setState(ship.getState());
torpedo.ownerId = ship.id; // set a reference to the owning ship
torpedo.drive(0.1);
ship.torpedoes.push(torpedo);
if (_.isFunction(fn)) {
fn({status: 'success', msg: 'Torpedo fired', id: torpedo.id});
};
socket.broadcast.emit('openspace.new.torpedo', { msg: 'Torpedo detected', ship: ship.getState(), torpedo: torpedo.getState()}); // the everyone (but us) that we attack!
});
socket.on('ship.destruct', function(message, fn) {
socket.broadcast.emit('openspace.destruct.ship', {msg: 'Ship destruction detected', type: 'self', ship: ship.getState()});
ships = _.filter(ships, function(s) { return s.id != ship.id});
ship = null;
session.shipId = null;
session.save();
if (_.isFunction(fn)) {
fn({status: 'success', msg: 'Your ship has self-destructed'});
}
});
socket.on('ship.devReset', function() {
ship.reset();
});
});
var sendResponse = function(jDoc, myRes, ip, bid, callback, gzip) {
// Convert the string representation of date to a Date object
jDoc.expires = new Date(jDoc.expires);
jDoc.lastModified = new Date(jDoc.lastModified);
// If there is a valid expiration date for the bundle
if ( 'expires' in jDoc && _.isDate(jDoc.expires) ) {
jDoc.secleft = jDoc.expires.getSecondsBetween( new Date() ) * -1;
} else {
// This should never happen
jDoc.secleft = -1;
}
if (Number(jDoc.secleft) < 0 && !GLOBAL.bundles[bid].locked) {
// Prevent other requests for this bundle from refreshing cache for time being
GLOBAL.bundles[bid].locked = true;
// The bundle has expired. Force a refresh
exports.fulfill( myRes, ip, bid, callback, gzip, true );
} else {
//Respond with the cached data
var responseType = callback ? 'application/javascript' : 'application/json';
var responseHeaders = {'Content-Type': responseType, 'vary': 'Accept-Encoding', 'max-age': jDoc.secleft, 'cache-control': 'public, max-age='+jDoc.secleft+', no-transform', "Expires": jDoc.expires, "Last-Modified": jDoc.lastModified};
var ext = bid.match(/\.[\w]+$/);
if (ext && (ext = ext[0])) {
// When the bid has an extension, we only return the first api.
var first = _.find(jDoc, function(api, key) {
return api && api.cname;
});
doc = first.result;
switch (ext) {
case ".kml":
case ".xml":
// When expecting response is KML or XML, we set the correct Content-Type
// and wrap it with quotes if it's a JSONP request.
responseHeaders['Content-Type'] = 'text/xml';
callback && (doc = "'"+ doc+"'");
break;
case ".json":
// Content-Type for JSON is already set above.
doc = JSON.stringify(doc);
default:
break;
}
} else {
doc = JSON.stringify(jDoc);
}
if (callback) {
doc = callback + '(' + doc + ');';
}
if (gzip) {
responseHeaders['content-encoding'] = 'gzip';
zlib.gzip(doc, function(err, zbuf) {
if (!err) {
winston.event('Send gzipped response for ' + bid +', ' + zbuf.toString().length + ', ' + ip);
myRes.writeHead(200, responseHeaders);
myRes.end(zbuf);
}
});
} else {
// If a callback name was passed, use it. Otherwise, just output the object
var tbuf = new Buffer(doc);
myRes.writeHead(200, responseHeaders);
winston.event('Send response for ' + bid +', ' + doc.length + ', ' + ip);
myRes.end(tbuf);
}
}
}
getUnitByID: function(id) {
'use strict';
return _.find(this.units, function(u) {
return u.id === parseInt(id, 10);
});
},
find: function(iterator) {
return _.find(this.items, iterator);
},
socket.on('disconnect', function (data) {
user = _.find(users, function(u){ return u.id === socket.id});
var index = users.indexOf(user);
users.splice(index, 1);
socket.broadcast.emit('joined', users);
});
function getByUser(user) {
'use strict';
return _.find(battleServers, function(bs) {
return bs.isPlayerInIt(user.id);
});
}
revisionTasks = __.filter( data.data, function ( task ) {
var assigned =__.find( task.creator, function ( creator ) {
return creator === Auth.user.username;
});
return task.status === 'Por revisar' && assigned === Auth.user.username;
});
Grid.prototype.isScented = function (input) {
return _.find(this.scents, function (scent) {
return _.isEqual(scent, input);
})
};