.map((o, k) => {
let date = new Date(k);
return {
time: Math.floor(date.getTime() / 1000),
data: {
h: Math.floor(_.meanBy(o, oo => oo.data.h) * 100) / 100,
t: Math.floor(_.meanBy(o, oo => oo.data.t) * 100) / 100
}
};
})
function averageCurrentEvents(events) {
return _.assign(events[0], {
current: _.meanBy(events, 'current'),
vcc: _.meanBy(events, 'vcc'),
rawMeasurement: _.meanBy(events, 'rawMeasurement'),
shuntVoltageMilliVolts: _.meanBy(events, 'shuntVoltageMilliVolts'),
previousSampleTimeMicros: _.meanBy(events, 'previousSampleTimeMicros'),
ts: new Date()
})
}
const convertActivityMetrics = (activityMetrics) => {
const meanPace = meanBy(activityMetrics, (metrics) => {
if (metrics[METRICS.SPEED]) {
return speedToPace(metrics[METRICS.SPEED]);
}
});
return activityMetrics.reduce((converted, metrics, idx, metricsArr) => {
const lat = metrics[METRICS.LATITUDE];
const lng = metrics[METRICS.LONGITUDE];
if (lat && lng) {
// Normalize & compress outlying data.
// TODO: Don't modify the data, change the bounds of the chart.
/* eslint-disable-next-line no-restricted-properties */
const paceThreshold = Math.pow(meanPace, 2) / 400;
const pace = speedToPace(metrics[METRICS.SPEED]);
converted.push({
distance: metersToMiles(metrics[METRICS.SUM_DISTANCE]),
elevation: metersToFeet(metrics[METRICS.ELEVATION]),
hr: metrics[METRICS.HEART_RATE] || 0,
lat,
lng,
pace: !pace || pace > paceThreshold ? paceThreshold : pace,
});
}
return converted;
}, []);
};
.map(({ matches, ...rest }) => {
const sortedMatches = _.sortBy(matches, [
invertNumber('duration'),
'text',
])
const result = { matches: sortedMatches, ...rest }
const meanDuration = _.meanBy(matches, 'duration')
if (isFinite(meanDuration)) {
result.meanDuration = meanDuration
}
return result
})
function worker(freelancers){
var average = _.meanBy(freelancers, 'income')
var result = {average: average};
var underperforming = _.filter(freelancers, function(person){
return person.income <= average;
})
console.log(underperforming);
underperforming = _.sortBy(underperforming, incomeSort);
result['underperform'] = underperforming;
var overperforming = _.filter(freelancers, function(person){
return person.income > average;
});
overperforming = _.sortBy(overperforming, incomeSort)
result['overperform'] = overperforming;
console.log(result);
return result;
};
_.each(definitionService.getDefinitions().resByEra, era => {
if (generatedOffer) {
return false;
}
//writeLog(`Przeglądam zasoby dla ery ${era.eraName}`);
var resInfoArray = _.map(era.goods, g => getTradeResInfo(g));
var depoArray = _.filter(resInfoArray, r => r.isDeposit);
var depoLength = depoArray.length;
if (depoLength === 0) {
return false;
}
var noDepoArray = _.filter(resInfoArray, r => !r.isDeposit);
_.each(resInfoArray, d => {
d.amountWithOffers = d.amount + getAmountInTradeOffers(d.res.id);
});
var medAmount = _.meanBy(resInfoArray, 'amountWithOffers');
_.each(depoArray, d => {
if (generatedOffer) {
return false;
}
var amountToSell = Math.round(d.amount - medAmount);
if (amountToSell >= 10) {
//writeLog(`Jest potencjał do sprzedaży ${d.res.name}`);
_.each(noDepoArray, nd => {
if (generatedOffer) {
return false;
}
var needAmount = getAmountInTradeOffersNeed(d.res.id, nd.res.id);
var amountToBuy = medAmount - nd.amount - needAmount;
var uniqTradeOffers = _(myOffers).filter(t => t.offer.good_id === d.res.id && t.need.good_id === nd.res.id).map(t => t.offer.value).map(a => Math.round(a / 10) * 10).uniq().sort().value();
amountToBuy = _(amountTemplateTable).difference(uniqTradeOffers).filter(a => a <= amountToBuy).first();
if (amountToBuy !== undefined) {
wls.writeLog(`Przygotowuję ofertę zakupu ${amountToBuy} x ${nd.res.name} oferując ${d.res.name} w stosunku 1:1`);
generatedOffer = createTradeOfferObj(d.res.id, amountToBuy, nd.res.id, amountToBuy);
return false;
}
});
}
});
});
showMetrics(metrics) {
let message = '';
if (this.options.function) {
message += `${chalk.yellow.underline(this.options.function)}\n`;
} else {
message += `${chalk.yellow.underline('Service wide metrics')}\n`;
}
const formattedStartTime = moment(this.options.startTime).format('LLL');
const formattedEndTime = moment(this.options.endTime).format('LLL');
message += `${formattedStartTime} - ${formattedEndTime}\n\n`;
if (metrics && metrics.length > 0) {
const getDatapointsByLabel = (Label) =>
_.chain(metrics)
.flatten()
.filter({ Label })
.map('Datapoints')
.flatten()
.value();
const invocationsCount = _.sumBy(getDatapointsByLabel('Invocations'), 'Sum');
const throttlesCount = _.sumBy(getDatapointsByLabel('Throttles'), 'Sum');
const errorsCount = _.sumBy(getDatapointsByLabel('Errors'), 'Sum');
const durationAverage = _.meanBy(getDatapointsByLabel('Duration'), 'Average') || 0;
// display the data
message += `${chalk.yellow('Invocations:', invocationsCount, '\n')}`;
message += `${chalk.yellow('Throttles:', throttlesCount, '\n')}`;
message += `${chalk.yellow('Errors:', errorsCount, '\n')}`;
message += `${chalk.yellow('Duration (avg.):', `${Number((durationAverage).toFixed(2))}ms`)}`;
} else {
message += `${chalk.yellow('There are no metrics to show for these options')}`;
}
this.serverless.cli.consoleLog(message);
return BbPromise.resolve(message);
}
prepareData: function (rawData) {
var data = null;
if (rawData) {
data = [];
rawData[0].value = +rawData[0].value;
let bucket = [rawData[0]];
for (var i = 1; i < rawData.length; i++) {
rawData[i].value = +rawData[i].value;
let prevTime = getTime(rawData[i - 1].createdAt);
let currTime = getTime(rawData[i].createdAt);
// Having measurements every minute is too much. Group them.
// To make sure that the grouped measurements are all around the same
// time there can't be more than X seconds difference between them.
if (currTime - prevTime > this._mTimeThreshold || bucket.length === this._mGroupSize) {
let f = {
createdAt: _.last(bucket).createdAt,
value: +round(_.meanBy(bucket, 'value'))
};
data.push(f);
bucket = [];
}
bucket.push(rawData[i]);
}
// After the loop finished there may still be data to process.
// if bucket.length < this._mGroupSize for example.
let f = {
createdAt: _.last(bucket).createdAt,
value: +round(_.meanBy(bucket, 'value'))
};
data.push(f);
}
let startToday = new Date();
startToday.setHours(0);
startToday.setMinutes(0);
startToday.setSeconds(0);
startToday = Math.floor(startToday.getTime() / 1000);
let startYesterday = startToday - (60 * 60 * 24);
let dataAll = [];
let dataToday = [];
let dataYesterday = [];
_.forEach(data, o => {
let date = new Date(o.createdAt);
let time = Math.floor(date.getTime() / 1000);
dataAll.push({
timestep: date,
value: +o.value
});
if (time >= startToday) {
dataToday.push({
timestep: date,
value: +o.value
});
}
if (time < startToday && time >= startYesterday) {
dataYesterday.push({
timestep: date,
value: +o.value
});
}
});
let avgs = {
today: _.meanBy(dataToday, 'value'),
yesterday: _.meanBy(dataYesterday, 'value')
};
let last = _.last(dataAll) || null;
return {
data: dataAll,
last,
avgs
};
},
value: function (d) {
return _.meanBy(d, (o) => o.o.data.P1)
}