it(str + ' should be parsed as moment reprsenting' + expectedMoment + "with the offset " + expectedOffset, () => {
let result = parseTimestamp(str);
expect(moment.isMoment(result)).toBe(true);
expect(result.utcOffset()).toBe(expectedOffset);
expect(result.unix()).toEqual(expectedMoment.unix());
});
() => {
let result = parseTimestamp(str);
expect(moment.isMoment(result)).toBe(true);
expect(result.utcOffset()).toBe(expectedOffset);
expect(result.unix()).toEqual(expectedMoment.unix());
},
export function formatValue(value, options = {}) {
let column = options.column;
options = {
jsx: false,
comma: column && column.special_type === "number",
...options
};
if (value == undefined) {
return null;
} else if (column && column.unit != null) {
return formatTimeWithUnit(value, column.unit, options);
} else if (isDate(column) || moment.isDate(value) || moment.isMoment(value) || moment(value, ["YYYY-MM-DD'T'HH:mm:ss.SSSZ"], true).isValid()) {
return parseTimestamp(value).format("LLLL");
} else if (typeof value === "string") {
return value;
} else if (typeof value === "number") {
if (column && (column.special_type === "latitude" || column.special_type === "longitude")) {
return DECIMAL_DEGREES_FORMATTER(value)
} else {
return formatNumber(value, options);
}
} else if (typeof value === "object") {
// no extra whitespace for table cells
return JSON.stringify(value);
} else {
return String(value);
}
}
let HACK_parseTimestamp = (value, unit, warn) => {
if (value == null) {
warn(NULL_DIMENSION_WARNING);
return null;
} else {
let m = parseTimestamp(value, unit);
m.toString = moment_fast_toString
return m;
}
}
function applyChartTimeseriesXAxis(chart, settings, series, xValues, xDomain, xInterval) {
// setup an x-axis where the dimension is a timeseries
let dimensionColumn = series[0].data.cols[0];
// get the data's timezone offset from the first row
let dataOffset = parseTimestamp(series[0].data.rows[0][0]).utcOffset() / 60;
// compute the data interval
let dataInterval = xInterval;
let tickInterval = dataInterval;
if (settings["graph.x_axis.labels_enabled"]) {
chart.xAxisLabel(settings["graph.x_axis.title_text"] || getFriendlyName(dimensionColumn));
}
if (settings["graph.x_axis.axis_enabled"]) {
chart.renderVerticalGridLines(settings["graph.x_axis.gridLine_enabled"]);
if (dimensionColumn.unit == null) {
dimensionColumn = { ...dimensionColumn, unit: dataInterval.interval };
}
chart.xAxis().tickFormat(timestamp => {
// timestamp is a plain Date object which discards the timezone,
// so add it back in so it's formatted correctly
const timestampFixed = moment(timestamp).utcOffset(dataOffset).format();
return formatValue(timestampFixed, { column: dimensionColumn })
});
// Compute a sane interval to display based on the data granularity, domain, and chart width
tickInterval = computeTimeseriesTicksInterval(xDomain, dataInterval, chart.width(), MIN_PIXELS_PER_TICK.x, );
chart.xAxis().ticks(d3.time[tickInterval.interval], tickInterval.count);
} else {
chart.xAxis().ticks(0);
}
// pad the domain slightly to prevent clipping
xDomain[0] = moment(xDomain[0]).subtract(dataInterval.count * 0.75, dataInterval.interval);
xDomain[1] = moment(xDomain[1]).add(dataInterval.count * 0.75, dataInterval.interval);
// set the x scale
chart.x(d3.time.scale.utc().domain(xDomain));//.nice(d3.time[dataInterval.interval]));
// set the x units (used to compute bar size)
chart.xUnits((start, stop) => Math.ceil(1 + moment(stop).diff(start, dataInterval.interval) / dataInterval.count));
}
export const drillFilter = (card, value, column) => {
let filter;
if (isDate(column)) {
filter = [
"=",
["datetime-field", getFieldRefFromColumn(column), "as", column.unit],
parseTimestamp(value, column.unit).format(),
];
} else {
const range = rangeForValue(value, column);
if (range) {
filter = ["BETWEEN", getFieldRefFromColumn(column), range[0], range[1]];
} else {
filter = ["=", getFieldRefFromColumn(column), value];
}
}
return addOrUpdateFilter(card, filter);
};
function formatTimeWithUnit(value, unit, options = {}) {
let m = parseTimestamp(value);
if (!m.isValid()) {
return String(value);
}
switch (unit) {
case "hour": // 12 AM - January 1, 2015
return formatMajorMinor(m.format("h A"), m.format("MMMM D, YYYY"), options);
case "day": // January 1, 2015
return m.format("MMMM D, YYYY");
case "week": // 1st - 2015
// force 'en' locale for now since our weeks currently always start on Sundays
m = m.locale("en");
return formatMajorMinor(m.format("wo"), m.format("gggg"), options);
case "month": // January 2015
return options.jsx ?
<div><span className="text-bold">{m.format("MMMM")}</span> {m.format("YYYY")}</div> :
m.format("MMMM") + " " + m.format("YYYY");
case "year": // 2015
return String(value);
case "quarter": // Q1 - 2015
return formatMajorMinor(m.format("[Q]Q"), m.format("YYYY"), { ...options, majorWidth: 0 });
case "hour-of-day": // 12 AM
return moment().hour(value).format("h A");
case "day-of-week": // Sunday
return moment().day(value - 1).format("dddd");
case "week-of-year": // 1st
return moment().week(value).format("wo");
case "month-of-year": // January
return moment().month(value - 1).format("MMMM");
case "quarter-of-year": // January
return moment().quarter(value).format("[Q]Q");
default:
return m.format("LLLL");
}
}
{ interval: "year", count: 100, testFn: (d) => parseTimestamp(d).year() % 100 } // (21) 100 year
{ interval: "hour", count: 12, testFn: (d) => parseTimestamp(d).hours() % 12 }, // (12) 12 hours
{ interval: "year", count: 10, testFn: (d) => parseTimestamp(d).year() % 10 }, // (19) 10 year
{ interval: "year", count: 50, testFn: (d) => parseTimestamp(d).year() % 50 }, // (20) 50 year
{ interval: "year", count: 1, testFn: (d) => parseTimestamp(d).month() }, // (17) 1 year
{ interval: "year", count: 5, testFn: (d) => parseTimestamp(d).year() % 5 }, // (18) 5 year
testFn: d => parseTimestamp(d).seconds(),
{ interval: "minute", count: 5, testFn: (d) => parseTimestamp(d).minutes() % 5 }, // (6) 5 minutes
testFn: d => parseTimestamp(d).date(),
testFn: d => parseTimestamp(d).year() % 100,
{ interval: "minute", count: 15, testFn: (d) => parseTimestamp(d).minutes() % 15 }, // (7) 15 minutes
{ interval: "hour", count: 6, testFn: (d) => parseTimestamp(d).hours() % 6 }, // (11) 6 hours
{ interval: "hour", count: 3, testFn: (d) => parseTimestamp(d).hours() % 3 }, // (10) 3 hours
{ interval: "hour", count: 1, testFn: (d) => parseTimestamp(d).minutes() }, // (9) 1 hour
{ interval: "minute", count: 30, testFn: (d) => parseTimestamp(d).minutes() % 30 }, // (8) 30 minutes
testFn: d => parseTimestamp(d).hours(),
{ interval: "day", count: 1, testFn: (d) => parseTimestamp(d).hours() }, // (13) 1 day
testFn: d => parseTimestamp(d).month(),
{ interval: "week", count: 1, testFn: (d) => parseTimestamp(d).date() % 7 }, // (14) 7 days / 1 week
testFn: d => parseTimestamp(d).milliseconds(),
{ interval: "month", count: 1, testFn: (d) => parseTimestamp(d).date() }, // (15) 1 months
testFn: d => parseTimestamp(d).minutes(),
{ interval: "month", count: 3, testFn: (d) => parseTimestamp(d).month() % 3 }, // (16) 3 months / 1 quarter