this.postGroup = function (grpHostId, dishes, metId, addr, gorTime, grpAmountLimit, callback) {
let lastGroup = _.maxBy(db.GROUP, 'grpId');
let grpId = lastGroup ? lastGroup.grpId + 1 : 1;
db.pushToJsonDb('GROUP', {
grpId,
grpHostId: grpHostId,
metId: metId,
grpAddr: addr,
grpTime: gorTime,
grpStatus: 0,
grpCreateTime: new Date().getTime(),
grpAmount: 0,
grpAmountLimit: grpAmountLimit || 0
//minAmount: minAmount
});
for (let dihId of dishes) {
let lastDish = _.maxBy(db.GROUP_DISHES, 'gdeId');
let gdh = {
gdeId: lastDish ? lastDish.gdeId + 1 : 1,
dihId: Number(dihId),
grpId
};
db.pushToJsonDb("GROUP_DISHES", gdh);
}
callback({success: 1});
};
/**
* @description processes the Buffer result of an image file
* @param {Object} options
* @returns {Object} dimensions
*/
function fetchDimensionsFromBuffer(options) {
var buffer = options.buffer,
imagePath = options.imagePath,
imageObject = {},
dimensions;
imageObject.url = imagePath;
try {
// Using the Buffer rather than an URL requires to use sizeOf synchronously.
// See https://github.com/image-size/image-size#asynchronous
dimensions = sizeOf(buffer);
// CASE: `.ico` files might have multiple images and therefore multiple sizes.
// We return the largest size found (image-size default is the first size found)
if (dimensions.images) {
dimensions.width = _.maxBy(dimensions.images, function (w) {return w.width;}).width;
dimensions.height = _.maxBy(dimensions.images, function (h) {return h.height;}).height;
}
imageObject.width = dimensions.width;
imageObject.height = dimensions.height;
return Promise.resolve(imageObject);
} catch (err) {
return Promise.reject(new errors.InternalServerError({
code: 'IMAGE_SIZE',
err: err,
context: imagePath
}));
}
}
return new Promise(function getIconSize(resolve, reject) {
var dimensions;
try {
dimensions = sizeOf(path);
if (dimensions.images) {
dimensions.width = _.maxBy(dimensions.images, function (w) {
return w.width;
}).width;
dimensions.height = _.maxBy(dimensions.images, function (h) {
return h.height;
}).height;
}
return resolve({
width: dimensions.width,
height: dimensions.height
});
} catch (err) {
return reject(new common.errors.ValidationError({
message: common.i18n.t('errors.utils.blogIcon.error', {
file: path,
error: err.message
})
}));
}
});
query.getSalesTotals(req.params.mfc_id).then(function(data){
var total = 0;
var count = 0;
console.log(data);
var returnData = data.reduce(function(prev, curr){
if (!prev[curr.name]){
prev[curr.name] = {};
prev[curr.name].product_id = curr.product_id;
prev[curr.name].name = curr.name;
prev[curr.name].total = curr.price * curr.quantity;
prev[curr.name].quantity = curr.quantity;
return prev;
} else {
prev[curr.name].total += curr.price * curr.quantity;
prev[curr.name].quantity += curr.quantity;
return prev;
}
}, {})
var keys = Object.keys(returnData);
var finalVal = keys.map(function(key){
total += returnData[key].total;
count += returnData[key].quantity;
return returnData[key];
});
var returner = {
total: total,
count: count,
top: _.maxBy(finalVal, function(obj){ return obj.total }),
data: finalVal
}
res.json(returner);
})
.then((sets) => {
let net = getNet();
let trainer = getTrainer(net);
//console.log(sets.training.length, sets.testing.length);
let trainingsSet = helper.slice(sets.training, count);
let filter = (row) => { return row[0]>0 && row[1]>0 && row[2]>0 };
//let filter = (row) => { return true; };
trainingsSet = _.filter(trainingsSet, filter);
sets.testing = _.filter(sets.testing, filter);
var stats = [];
var maxSearches = _.maxBy(_.concat(trainingsSet, sets.testing), function(o) { return o[0]; })[0];
//console.log(trainingsSet[0].length, maxSearches);
var rightCount = 0;
let iterations = 1;
for(var i=0; i<iterations; i+=1) {
_.forEach(trainingsSet, (meta, index) => {
let options = prepare(meta);
//console.log(options.input, options.output, options.input.length);
var x = new convnetjs.Vol(options.input);
stats.push(trainer.train(x, options.output));
//console.log(`training ${i*trainingsSet.length + index} :`, helper.getAverageLoss(stats), rightCount/(i*trainingsSet.length + index));
var probability_volume = net.forward(x);
if(competition(probability_volume, options)) {
rightCount += 1;
}
//console.log(_.last(stats));
});
}
console.log('average loss:', helper.getAverageLoss(stats));
console.log('training accurancy:', rightCount/(iterations*trainingsSet.length));
rightCount = 0;
_.forEach(sets.testing, (meta) => {
let options = prepare(meta);
var x = new convnetjs.Vol(options.input);
var probability_volume = net.forward(x);
//console.log(probability_volume, options.output);
//console.log(Math.abs(probability_volume.w[0] - options.output[0])/options.output[0]);
if(competition(probability_volume, options)) {
rightCount += 1;
}
/*if(Math.abs(probability_volume.w[0]-options.output[0])/options.output[0] < 0.2) {
rightCount += 1;
}*/
});
console.log('validation accurancy', rightCount/sets.testing.length);
return {
net: net,
trainer: trainer
};
})
render() {
const { graph, filter } = this.props;
let maxVolume = 0;
if (graph.allEdges().length > 0) {
const maxVolumeEdge = _.maxBy(
graph.allEdges(), edge => edge.metrics.normal + edge.metrics.danger,
);
maxVolume = maxVolumeEdge.metrics.normal + maxVolumeEdge.metrics.danger;
}
return (
<div className="dependencies__graph">
<VizceralExt
allowDraggingOfNodes
targetFramerate={15}
traffic={{
renderer: 'region',
layout: 'ltrTree',
name: 'dependencies-graph',
updated: new Date().getTime(),
maxVolume: maxVolume * 2000,
nodes: graph.allNodes(),
connections: graph.allEdges(),
}}
objectHighlighted={this.handleObjectHighlighted}
match={filter}
styles={style}
/>
</div>
);
}
{datasets.map((d, i) => {
let bestTime = minBy(results[i], r => r ? r.time : null)
let bestMax = maxBy(results[i], r=> r ? r.max : null)
return (
<tr>
<td>{d.title}</td>
{range(0, configurations.length).map(j => {
let r = (results && results[i]) ? results[i][j] : null
let isMinTime = (r === bestTime)
let isMax = (r === bestMax)
if(!r) {
return (<td className={"warning"}>No results</td>)
}
return(
<td>
<Panel>
<Label bsStyle={isMinTime ? "success" : "default"}>
<small>{humanizer(r.time, {language: "fr"})}</small>
</Label>
<br/>
<Label bsStyle={isMax ? "success": "default"}>{r.max}</Label>
<br /><br/>
<Button bsSize="xsmall">
<Glyphicon glyph="eye-open"/> output
</Button>
</Panel>
</td>
)
})}
</tr>
)
})}
_.forIn(prop.seenDevices, function seenDevice (device) {
var deviceInfo = [device.name];
if (_.includes(selectedFields, 'status-symbol')) {
deviceInfo.push(device.status.symbol);
}
if (_.includes(selectedFields, 'status-label')) {
deviceInfo.push(device.status.label);
}
if (device.mmtune) {
var best = _.maxBy(device.mmtune.scanDetails, function (d) {
return d[2];
});
if (_.includes(selectedFields, 'freq')) {
deviceInfo.push(device.mmtune.setFreq + 'MHz');
}
if (best && best.length > 2 && _.includes(selectedFields, 'rssi')) {
deviceInfo.push('@ ' + best[2] + 'dB');
}
}
events.push({
time: device.status.when
, value: deviceInfo.join(' ')
});
});
return new Promise((resolve, reject)=> {
for (let dish of dishes) {
dish.dihId = _.maxBy(db.DISH, "dihId").dihId + 1;
db.pushToJsonDb('DISH', dish);
}
resolve(dishes);
});
return new Promise(function (resolve, reject) {
var id = _.maxBy(self.datasource, 'id')['id'] + 1;
record.id = id;
self.datasource.push(record);
self.data[record.id.toString()] = record;
resolve(record);
});
N.wire.on(apiPath, function* apply_penalty(infraction) {
let penalties = _.get(N.config, 'users.infractions.penalties', []);
// Rules sorted by `points` in desc order
let rules = penalties.sort((a, b) => b.points - a.points);
let infractions = yield N.models.users.Infraction.find()
.where('for').equals(infraction.for)
.where('exists').equals(true)
.or([ { expire: null }, { expire: { $gt: Date.now() } } ])
.select('points')
.lean(true);
let total_points = _.sumBy(infractions, 'points');
let apply_rule;
// Find rule with maximum points
apply_rule = _.maxBy(rules.filter(rule => rule.points <= total_points), rule => rule.points);
if (!apply_rule) return;
return N.wire.emit(`internal:users.infraction.${apply_rule.action}.add`, {
infraction,
action_data: apply_rule.action_data
});
});
return async (dispatch, getState) => {
dispatch({type: FETCH_ACTIVE_BOOKINGS_REQUEST});
const state = getState();
const {myBookings} = getCalendarFilters(state);
const {data: {roomIds}, activeBookings: {data}} = state.calendar;
let newRoomIds = roomIds;
if (fetchRooms) {
newRoomIds = await fetchCalendarRooms(dispatch, state);
if (!newRoomIds.length) {
dispatch({type: FETCH_ACTIVE_BOOKINGS_SUCCESS});
return;
}
}
const params = preProcessParameters({myBookings}, ajaxRules);
const body = {room_ids: newRoomIds, limit};
if (Object.keys(data).length) {
const lastDt = Object.keys(data).reverse()[0];
body.start_dt = _.maxBy(data[lastDt], (rv) => moment(rv.startDt, 'YYYY-MM-DD HH:mm').unix()).startDt;
body.last_reservation_id = data[lastDt][data[lastDt].length - 1].reservation.id;
}
return await ajaxAction(
() => indicoAxios.post(fetchActiveBookingsURL(), body, {params}),
null,
[ACTIVE_BOOKINGS_RECEIVED, FETCH_ACTIVE_BOOKINGS_SUCCESS],
[FETCH_ACTIVE_BOOKINGS_ERROR]
)(dispatch);
};
.reduce(function(accumulator, coloredSideStringsForItem) {
var sideStringDataSets = [
coloredSideStringsForItem.lhs,
coloredSideStringsForItem.rhs
]
.map(function(sideString) {
return sideString.split('\n');
})
.map(function(sideStringLines) {
return {
lines: sideStringLines,
lineCount: sideStringLines.length
};
});
var maxSideLineCount = _.maxBy(sideStringDataSets, 'lineCount').lineCount;
var coloredStrings = _.map(sideStringDataSets, function(sideStringData) {
var sideStringLineCount = sideStringData.lineCount;
var sideStringLines = sideStringData.lines;
if (sideStringLineCount < maxSideLineCount) {
var linesToAddCount = maxSideLineCount - sideStringLineCount;
sideStringLines = sideStringLines.concat(_.fill(new Array(linesToAddCount), ''));
}
return sideStringLines.join('\n');
});
accumulator.lhs += '\n\n' + coloredStrings[0];
accumulator.rhs += '\n\n' + coloredStrings[1];
return accumulator;
}, {lhs: '', rhs: ''});
function prettyPrintCommitHistory(commitArr) {
var commit = _.maxBy(commitArr, 'seq');
var line = '';
_.each(commitArr, function(c) {
if (c == commit) {
line += '\t*'
} else {
line +='\t|'
}
});
var label = [line, commit.id, commit.seq];
_.each(branches, function(v,k){
if (v == commit.id) label.push(k);
});
log.debug(label.join(' '));
if (Array.isArray(commit.parent)) {
//console.log("here", commit.parent);
var newCommit = commits[commit.parent[0]];
upsert(commitArr, commit, newCommit);
commitArr.push(commits[commit.parent[1]]);
//console.log("shoudl have 2", commitArr);
} else if(commit.parent == null){
return;
} else {
var nextCommit = commits[commit.parent];
upsert(commitArr, commit, nextCommit);
}
commitArr = _.uniqBy(commitArr, 'id');
prettyPrintCommitHistory(commitArr);
}
function prettyPrintCommitHistory (commitArr) {
var commit = _.maxBy(commitArr, 'seq')
var line = ''
commitArr.forEach(function (c) {
if (c === commit) {
line += '\t*'
} else {
line += '\t|'
}
})
var label = [line, commit.id, commit.seq]
_.each(branches, function (value, key) {
if (value === commit.id) label.push(key)
})
log.debug(label.join(' '))
if (Array.isArray(commit.parent)) {
var newCommit = commits[commit.parent[0]]
upsert(commitArr, commit, newCommit)
commitArr.push(commits[commit.parent[1]])
} else if (commit.parent == null) {
return
} else {
var nextCommit = commits[commit.parent]
upsert(commitArr, commit, nextCommit)
}
commitArr = _.uniqBy(commitArr, 'id')
prettyPrintCommitHistory(commitArr)
}
collection.find({'status': 'new'}, {}, function(e, docs) {
status.numMeetings = docs.length;
var byDiary = _.countBy(docs, 'diary');
status.numDiaries = _.values(byDiary).length;
status.maxMeetingsByDiary = _.max(_.values(byDiary));
status.avgMeetingsByDiary = _.mean(_.values(byDiary));
status.maxMeeting = (docs.length > 0) ? _.maxBy(docs, function(m) { return m.meeting.getTime(); }).meeting : 0;
var inconsistencies = helper.detectInconsistencies(docs);
for (var i in inconsistencies) {
// console.log("inconsistencies[" + i + "][meeting1]: " + JSON.stringify(inconsistencies[i]['meeting1']));
collection.remove({_id: inconsistencies[i]['meeting1']['_id']}, { justOne: true });
}
var inconsistencies2;
collection.find({'status': 'new'}, {}, function(e, docs) {
inconsistencies2 = helper.detectInconsistencies(docs);
// status.numInconsistenciesBefore = inconsistencies.length;
// status.numInconsistenciesAfter = inconsistencies2.length;
console.log("numB: " + inconsistencies.length);
console.log("numA: " + inconsistencies2.length);
res.send(status);
});
});
extractTaskProgress = skill => {
let { project } = this.props;
let tasks = project.needs(skill);
if (tasks === Number.POSITIVE_INFINITY) {
tasks = 0;
}
let bugs = project.bugs[skill];
let done = project.done[skill];
let max_skill = _.maxBy(_.keys(project.estimate), function(skill) {
return (
Math.max(
project.needs(skill) !== Number.POSITIVE_INFINITY ? project.needs(skill) : 0,
project.estimate[skill],
project.done[skill]
) + project.bugs[skill]
);
});
let max =
Math.max(
project.needs(max_skill) !== Number.POSITIVE_INFINITY ? project.needs(max_skill) : 0,
project.estimate[max_skill] !== Number.POSITIVE_INFINITY ? project.estimate[max_skill] : 0,
project.done[max_skill]
) + project.bugs[max_skill]; //, project.needs(max_skill)) + project.bugs[max_skill];
if (max === 0) max = 1;
let tasks_percent = (tasks / max) * 100;
let bugs_percent = (bugs / max) * 100;
let done_percent = (done / max) * 100;
return { tasks, bugs, done, tasks_percent, bugs_percent, done_percent };
};
function imageMove(deltaX, deltaY) {
const selected = SelectedEntry.selectedThing();
if (!selected) return;
const images = selected.entry.querySelectorAll('.res-media-movable');
const mostVisible = _.maxBy(images, media => getPercentageVisibleYAxis(media));
if (mostVisible) ShowImages.moveMedia(mostVisible, deltaX, deltaY);
}
var sliderData = d3.select("#slider").on("input", (value) => {
document.getElementById("slider-value").innerHTML = Math.round(d3.select("#slider")[0][0].value*100);
var filteredData = _.filter(data, d => d.Group == Math.round(d3.select("#slider")[0][0].value*100));
this.max = _.maxBy(filteredData, 'Amount').Amount;
this.x.domain(d3.extent(filteredData, d => d.PositionX)).nice();
this.y.domain(d3.extent(filteredData, d => d.PositionY)).nice();
this.draw(filteredData)
});
return new Promise((resolve, reject) => {
const range = {
max: _.maxBy(db, a => a.age).age,
min: _.minBy(db, a => a.age).age,
};
resolve(range);
});
async deviceTypeAndNewestRuntimeFor(name) {
const result = await this._execSimctl({ cmd: `list -j` });
const stdout = _.get(result, 'stdout');
const output = JSON.parse(stdout);
const deviceType = _.filter(output.devicetypes, { 'name': name})[0];
const newestRuntime = _.maxBy(output.runtimes, r => Number(r.version));
return { deviceType, newestRuntime };
}
return new Promise((resolve, reject)=> {
merchant.metId = _.maxBy(db.MERCHANT, 'metId').metId + 1;
db.pushToJsonDb('MERCHANT', merchant);
resolve(merchant);
});
render() {
let threshold = this.state.threshold,
max = _.maxBy(this.props.scores, (item) => {
return item.final_score;
}).final_score;
return _.isEmpty(this.props.effects) ? null : (
<Slider max={max} threshold={threshold} handleChange={this.handleChange} />
);
}
function create() {
levels = Level.parseText(game.cache.getText('levels'));
const width = _.maxBy(levels, (level) => {
return level.width;
});
const height = _.maxBy(levels, (level) => {
return level.height;
});
tileMap = game.add.tilemap();
tileMap.addTilesetImage('spritesheet', 'spritesheet', Constants.TILE_WIDTH, Constants.TILE_HEIGHT);
var l = tileMap.create('default', width, height, Constants.TILE_WIDTH, Constants.TILE_HEIGHT);
l.resizeWorld();
goToLevel(levelIndex);
}
const getSourceAndDestination = torrent => {
const destination = _.maxBy(torrent.files, 'length');
const source = torrent.fileStats[torrent.files.indexOf(destination)];
return {
source: path.join(torrent.folder, source.name),
destination: path.join(DESTINATION_FOLDER, path.basename(destination.path))
};
};
function transformStage(stage) {
var stages = flattenAndFilter(stage);
if (!stages.length) {
return;
}
if (stage.masterStage) {
var lastStage = stages[stages.length - 1];
setMasterStageStartTime(stages, stage);
var lastNotStartedStage = _.findLast(stages,
function (childStage) {
return childStage.hasNotStarted;
}
);
var lastFailedStage = _.findLast(stages,
function (childStage) {
return childStage.isFailed;
}
);
var lastRunningStage = _.findLast(stages,
function (childStage) {
return childStage.isRunning;
}
);
var lastCanceledStage = _.findLast(stages,
function (childStage) {
return childStage.isCanceled;
}
);
var lastStoppedStage = _.findLast(stages,
function (childStage) {
return childStage.isStopped;
}
);
var currentStage = lastRunningStage || lastFailedStage || lastStoppedStage || lastCanceledStage || lastNotStartedStage || lastStage;
stage.status = currentStage.status;
// if a stage is running, ignore the endTime of the parent stage
if (!currentStage.endTime) {
delete stage.endTime;
}
let lastEndingStage = _.maxBy(stages, 'endTime');
// if the current stage has an end time (i.e. it failed or completed), use the maximum end time
// of all the child stages as the end time for the parent - we do this because the parent might
// have been an initialization stage, which ends within a few milliseconds
if (currentStage.endTime && lastEndingStage.endTime) {
stage.endTime = Math.max(currentStage.endTime, lastEndingStage.endTime, stage.endTime);
}
}
stage.stages = stages;
}
fattestPath() {
let g = this;
if (_.isEmpty(g.vertices)) {
return 0;
}
if (null === g.source) {
throw new Error('Graph must have a source');
}
if (null === g.sink) {
throw new Error('Graph must have a sink');
}
if (_.isEmpty(g.edges)) {
return 0;
}
let queue = [];
// set fatness of all vertices to 0
g.vertices.map(function (vertex) {
vertex.fat = 0;
queue.push(vertex);
});
// set fatness to source as very large
g.source.fat = Number.MAX_VALUE;
while (queue.length > 0) {
// get fattest vertex and remove from queue
let fattest = _.maxBy(queue, 'fat');
_.pull(queue, fattest);
// if the fattest value is 0, we are finished
if (0 === fattest.fat) {
break;
}
// update fat value for neighbours of fattest vertex
g.edges.map(function (edge) {
if (edge.source === fattest && edge.capacity > 0) {
if (edge.target.fat < Math.min(fattest.fat, edge.capacity)) {
edge.target.fat = Math.min(fattest.fat, edge.capacity);
edge.target.pre = fattest;
}
}
});
}
// if the sink could not be reached by any vertex, flow is 0
if (null === g.sink.pre) {
return 0;
}
return this._buildFlowPath();
}
response.issues.forEach(function(incident) {
cli.log();
cli.styledHeader(`${incident.title} ${cli.color.yellow(moment(incident.created_at).format('LT'))} ${cli.color.cyan(incident.full_url)}`);
let padding = _.maxBy(incident.updates, 'update_type.length').update_type.length+1;
incident.updates.forEach(u => {
cli.log(`${cli.color.yellow(_.padEnd(u.update_type, padding))} ${moment(u.updated_at).format('LT')} (${moment(u.updated_at).fromNow()})`);
cli.log(`${u.contents}\n`);
});
});
flow.nodes = flow.nodes.map(node => {
const position = _.get(_.find(uiEq.nodes, { id: node.id }), 'position')
unplacedIndex = position ? unplacedIndex : unplacedIndex + 1
return {
...node,
x: position ? position.x : 50 + unplacedIndex * PLACING_STEP,
y: position ? position.y : (_.maxBy(flow.nodes, 'y') || { y: 0 }).y + PLACING_STEP
}
})
ICO.parse(arrayBuffer).then(function (result, error) {
if (error) {
return reject(new errors.ValidationError({message: i18n.t('errors.api.icons.couldNotGetSize', {file: icon.name, error: error.message})}));
}
// CASE: ico file contains only one size
if (result.length === 1) {
return resolve({
width: result[0].width,
height: result[0].height
});
} else {
// CASE: ico file contains multiple sizes, return only the max size
return resolve({
width: _.maxBy(result, function (w) {return w.width;}).width,
height: _.maxBy(result, function (h) {return h.height;}).height
});
}
});