mirror of
https://github.com/grafana/grafana.git
synced 2024-12-26 00:41:20 -06:00
Updated default notes, fixed alert z-index, added time correction options for histogram
This commit is contained in:
Rashid Khan
parent
1545e32b60
commit
1796323cb9
@ -17,7 +17,7 @@
|
||||
.panel-error {
|
||||
opacity: 0.9;
|
||||
position:absolute;
|
||||
z-index: 2000;
|
||||
z-index: 1000;
|
||||
}
|
||||
|
||||
.panel i.editlink {
|
||||
@ -44,20 +44,6 @@
|
||||
max-width: 500px;
|
||||
}
|
||||
|
||||
/*
|
||||
.row-header i.editlink {
|
||||
opacity: 0;
|
||||
}
|
||||
|
||||
.row-header:hover i.editlink {
|
||||
opacity: 0.3;
|
||||
}
|
||||
|
||||
.row-header i.editlink:hover {
|
||||
opacity: 1;
|
||||
}
|
||||
*/
|
||||
|
||||
.pointer {
|
||||
cursor: pointer;
|
||||
}
|
||||
|
||||
993
common/lib/panels/timezone.js
Normal file
993
common/lib/panels/timezone.js
Normal file
@ -0,0 +1,993 @@
|
||||
// -----
|
||||
// The `timezoneJS.Date` object gives you full-blown timezone support, independent from the timezone set on the end-user's machine running the browser. It uses the Olson zoneinfo files for its timezone data.
|
||||
//
|
||||
// The constructor function and setter methods use proxy JavaScript Date objects behind the scenes, so you can use strings like '10/22/2006' with the constructor. You also get the same sensible wraparound behavior with numeric parameters (like setting a value of 14 for the month wraps around to the next March).
|
||||
//
|
||||
// The other significant difference from the built-in JavaScript Date is that `timezoneJS.Date` also has named properties that store the values of year, month, date, etc., so it can be directly serialized to JSON and used for data transfer.
|
||||
|
||||
/*
|
||||
* Copyright 2010 Matthew Eernisse (mde@fleegix.org)
|
||||
* and Open Source Applications Foundation
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* Credits: Ideas included from incomplete JS implementation of Olson
|
||||
* parser, "XMLDAte" by Philippe Goetz (philippe.goetz@wanadoo.fr)
|
||||
*
|
||||
* Contributions:
|
||||
* Jan Niehusmann
|
||||
* Ricky Romero
|
||||
* Preston Hunt (prestonhunt@gmail.com)
|
||||
* Dov. B Katz (dov.katz@morganstanley.com)
|
||||
* Peter Bergström (pbergstr@mac.com)
|
||||
* Long Ho
|
||||
*/
|
||||
(function () {
|
||||
// Standard initialization stuff to make sure the library is
|
||||
// usable on both client and server (node) side.
|
||||
"use strict";
|
||||
var root = this;
|
||||
|
||||
var timezoneJS;
|
||||
if (typeof exports !== 'undefined') {
|
||||
timezoneJS = exports;
|
||||
} else {
|
||||
timezoneJS = root.timezoneJS = {};
|
||||
}
|
||||
|
||||
timezoneJS.VERSION = '0.4.4';
|
||||
|
||||
// Grab the ajax library from global context.
|
||||
// This can be jQuery, Zepto or fleegix.
|
||||
// You can also specify your own transport mechanism by declaring
|
||||
// `timezoneJS.timezone.transport` to a `function`. More details will follow
|
||||
var $ = root.$ || root.jQuery || root.Zepto
|
||||
, fleegix = root.fleegix
|
||||
, _arrIndexOf
|
||||
// Declare constant list of days and months. Unfortunately this doesn't leave room for i18n due to the Olson data being in English itself
|
||||
, DAYS = timezoneJS.Days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
|
||||
, MONTHS = timezoneJS.Months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
|
||||
, SHORT_MONTHS = {}
|
||||
, SHORT_DAYS = {}
|
||||
, EXACT_DATE_TIME = {}
|
||||
, TZ_REGEXP = new RegExp('^[a-zA-Z]+/');
|
||||
|
||||
//`{ "Jan": 0, "Feb": 1, "Mar": 2, "Apr": 3, "May": 4, "Jun": 5, "Jul": 6, "Aug": 7, "Sep": 8, "Oct": 9, "Nov": 10, "Dec": 11 }`
|
||||
for (var i = 0; i < MONTHS.length; i++) {
|
||||
SHORT_MONTHS[MONTHS[i].substr(0, 3)] = i;
|
||||
}
|
||||
|
||||
//`{ "Sun": 0, "Mon": 1, "Tue": 2, "Wed": 3, "Thu": 4, "Fri": 5, "Sat": 6 }`
|
||||
for (i = 0; i < DAYS.length; i++) {
|
||||
SHORT_DAYS[DAYS[i].substr(0, 3)] = i;
|
||||
}
|
||||
|
||||
|
||||
//Handle array indexOf in IE
|
||||
//From https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf
|
||||
//Extending Array prototype causes IE to iterate thru extra element
|
||||
_arrIndexOf = Array.prototype.indexOf || function (el) {
|
||||
if (this === null) {
|
||||
throw new TypeError();
|
||||
}
|
||||
var t = Object(this);
|
||||
var len = t.length >>> 0;
|
||||
if (len === 0) {
|
||||
return -1;
|
||||
}
|
||||
var n = 0;
|
||||
if (arguments.length > 1) {
|
||||
n = Number(arguments[1]);
|
||||
if (n != n) { // shortcut for verifying if it's NaN
|
||||
n = 0;
|
||||
} else if (n !== 0 && n !== Infinity && n !== -Infinity) {
|
||||
n = (n > 0 || -1) * Math.floor(Math.abs(n));
|
||||
}
|
||||
}
|
||||
if (n >= len) {
|
||||
return -1;
|
||||
}
|
||||
var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
|
||||
for (; k < len; k++) {
|
||||
if (k in t && t[k] === el) {
|
||||
return k;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
};
|
||||
|
||||
|
||||
// Format a number to the length = digits. For ex:
|
||||
//
|
||||
// `_fixWidth(2, 2) = '02'`
|
||||
//
|
||||
// `_fixWidth(1998, 2) = '98'`
|
||||
//
|
||||
// This is used to pad numbers in converting date to string in ISO standard.
|
||||
var _fixWidth = function (number, digits) {
|
||||
if (typeof number !== "number") { throw "not a number: " + number; }
|
||||
var s = number.toString();
|
||||
if (number.length > digits) {
|
||||
return number.substr(number.length - digits, number.length);
|
||||
}
|
||||
while (s.length < digits) {
|
||||
s = '0' + s;
|
||||
}
|
||||
return s;
|
||||
};
|
||||
|
||||
// Abstraction layer for different transport layers, including fleegix/jQuery/Zepto
|
||||
//
|
||||
// Object `opts` include
|
||||
//
|
||||
// - `url`: url to ajax query
|
||||
//
|
||||
// - `async`: true for asynchronous, false otherwise. If false, return value will be response from URL. This is true by default
|
||||
//
|
||||
// - `success`: success callback function
|
||||
//
|
||||
// - `error`: error callback function
|
||||
// Returns response from URL if async is false, otherwise the AJAX request object itself
|
||||
var _transport = function (opts) {
|
||||
if ((!fleegix || typeof fleegix.xhr === 'undefined') && (!$ || typeof $.ajax === 'undefined')) {
|
||||
throw new Error('Please use the Fleegix.js XHR module, jQuery ajax, Zepto ajax, or define your own transport mechanism for downloading zone files.');
|
||||
}
|
||||
if (!opts) return;
|
||||
if (!opts.url) throw new Error ('URL must be specified');
|
||||
if (!('async' in opts)) opts.async = true;
|
||||
if (!opts.async) {
|
||||
return fleegix && fleegix.xhr
|
||||
? fleegix.xhr.doReq({ url: opts.url, async: false })
|
||||
: $.ajax({ url : opts.url, async : false }).responseText;
|
||||
}
|
||||
return fleegix && fleegix.xhr
|
||||
? fleegix.xhr.send({
|
||||
url : opts.url,
|
||||
method : 'get',
|
||||
handleSuccess : opts.success,
|
||||
handleErr : opts.error
|
||||
})
|
||||
: $.ajax({
|
||||
url : opts.url,
|
||||
dataType: 'text',
|
||||
method : 'GET',
|
||||
error : opts.error,
|
||||
success : opts.success
|
||||
});
|
||||
};
|
||||
|
||||
// Constructor, which is similar to that of the native Date object itself
|
||||
timezoneJS.Date = function () {
|
||||
var args = Array.prototype.slice.apply(arguments)
|
||||
, dt = null
|
||||
, tz = null
|
||||
, arr = [];
|
||||
|
||||
|
||||
//We support several different constructors, including all the ones from `Date` object
|
||||
// with a timezone string at the end.
|
||||
//
|
||||
//- `[tz]`: Returns object with time in `tz` specified.
|
||||
//
|
||||
// - `utcMillis`, `[tz]`: Return object with UTC time = `utcMillis`, in `tz`.
|
||||
//
|
||||
// - `Date`, `[tz]`: Returns object with UTC time = `Date.getTime()`, in `tz`.
|
||||
//
|
||||
// - `year, month, [date,] [hours,] [minutes,] [seconds,] [millis,] [tz]: Same as `Date` object
|
||||
// with tz.
|
||||
//
|
||||
// - `Array`: Can be any combo of the above.
|
||||
//
|
||||
//If 1st argument is an array, we can use it as a list of arguments itself
|
||||
if (Object.prototype.toString.call(args[0]) === '[object Array]') {
|
||||
args = args[0];
|
||||
}
|
||||
if (typeof args[args.length - 1] === 'string' && TZ_REGEXP.test(args[args.length - 1])) {
|
||||
tz = args.pop();
|
||||
}
|
||||
switch (args.length) {
|
||||
case 0:
|
||||
dt = new Date();
|
||||
break;
|
||||
case 1:
|
||||
dt = new Date(args[0]);
|
||||
break;
|
||||
default:
|
||||
for (var i = 0; i < 7; i++) {
|
||||
arr[i] = args[i] || 0;
|
||||
}
|
||||
dt = new Date(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6]);
|
||||
break;
|
||||
}
|
||||
|
||||
this._useCache = false;
|
||||
this._tzInfo = {};
|
||||
this._day = 0;
|
||||
this.year = 0;
|
||||
this.month = 0;
|
||||
this.date = 0;
|
||||
this.hours = 0;
|
||||
this.minutes = 0;
|
||||
this.seconds = 0;
|
||||
this.milliseconds = 0;
|
||||
this.timezone = tz || null;
|
||||
//Tricky part:
|
||||
// For the cases where there are 1/2 arguments: `timezoneJS.Date(millis, [tz])` and `timezoneJS.Date(Date, [tz])`. The
|
||||
// Date `dt` created should be in UTC. Thus the way I detect such cases is to determine if `arr` is not populated & `tz`
|
||||
// is specified. Because if `tz` is not specified, `dt` can be in local time.
|
||||
if (arr.length) {
|
||||
this.setFromDateObjProxy(dt);
|
||||
} else {
|
||||
this.setFromTimeProxy(dt.getTime(), tz);
|
||||
}
|
||||
};
|
||||
|
||||
// Implements most of the native Date object
|
||||
timezoneJS.Date.prototype = {
|
||||
getDate: function () { return this.date; },
|
||||
getDay: function () { return this._day; },
|
||||
getFullYear: function () { return this.year; },
|
||||
getMonth: function () { return this.month; },
|
||||
getYear: function () { return this.year - 1900; },
|
||||
getHours: function () { return this.hours; },
|
||||
getMilliseconds: function () { return this.milliseconds; },
|
||||
getMinutes: function () { return this.minutes; },
|
||||
getSeconds: function () { return this.seconds; },
|
||||
getUTCDate: function () { return this.getUTCDateProxy().getUTCDate(); },
|
||||
getUTCDay: function () { return this.getUTCDateProxy().getUTCDay(); },
|
||||
getUTCFullYear: function () { return this.getUTCDateProxy().getUTCFullYear(); },
|
||||
getUTCHours: function () { return this.getUTCDateProxy().getUTCHours(); },
|
||||
getUTCMilliseconds: function () { return this.getUTCDateProxy().getUTCMilliseconds(); },
|
||||
getUTCMinutes: function () { return this.getUTCDateProxy().getUTCMinutes(); },
|
||||
getUTCMonth: function () { return this.getUTCDateProxy().getUTCMonth(); },
|
||||
getUTCSeconds: function () { return this.getUTCDateProxy().getUTCSeconds(); },
|
||||
// Time adjusted to user-specified timezone
|
||||
getTime: function () {
|
||||
return this._timeProxy + (this.getTimezoneOffset() * 60 * 1000);
|
||||
},
|
||||
getTimezone: function () { return this.timezone; },
|
||||
getTimezoneOffset: function () { return this.getTimezoneInfo().tzOffset; },
|
||||
getTimezoneAbbreviation: function () { return this.getTimezoneInfo().tzAbbr; },
|
||||
getTimezoneInfo: function () {
|
||||
if (this._useCache) return this._tzInfo;
|
||||
var res;
|
||||
// If timezone is specified, get the correct timezone info based on the Date given
|
||||
if (this.timezone) {
|
||||
res = this.timezone === 'Etc/UTC' || this.timezone === 'Etc/GMT'
|
||||
? { tzOffset: 0, tzAbbr: 'UTC' }
|
||||
: timezoneJS.timezone.getTzInfo(this._timeProxy, this.timezone);
|
||||
}
|
||||
// If no timezone was specified, use the local browser offset
|
||||
else {
|
||||
res = { tzOffset: this.getLocalOffset(), tzAbbr: null };
|
||||
}
|
||||
this._tzInfo = res;
|
||||
this._useCache = true;
|
||||
return res;
|
||||
},
|
||||
getUTCDateProxy: function () {
|
||||
var dt = new Date(this._timeProxy);
|
||||
dt.setUTCMinutes(dt.getUTCMinutes() + this.getTimezoneOffset());
|
||||
return dt;
|
||||
},
|
||||
setDate: function (date) {
|
||||
this.setAttribute('date', date);
|
||||
return this.getTime();
|
||||
},
|
||||
setFullYear: function (year, month, date) {
|
||||
if (date !== undefined) { this.setAttribute('date', 1); }
|
||||
this.setAttribute('year', year);
|
||||
if (month !== undefined) { this.setAttribute('month', month); }
|
||||
if (date !== undefined) { this.setAttribute('date', date); }
|
||||
return this.getTime();
|
||||
},
|
||||
setMonth: function (month, date) {
|
||||
this.setAttribute('month', month);
|
||||
if (date !== undefined) { this.setAttribute('date', date); }
|
||||
return this.getTime();
|
||||
},
|
||||
setYear: function (year) {
|
||||
year = Number(year);
|
||||
if (0 <= year && year <= 99) { year += 1900; }
|
||||
this.setUTCAttribute('year', year);
|
||||
return this.getTime();
|
||||
},
|
||||
setHours: function (hours, minutes, seconds, milliseconds) {
|
||||
this.setAttribute('hours', hours);
|
||||
if (minutes !== undefined) { this.setAttribute('minutes', minutes); }
|
||||
if (seconds !== undefined) { this.setAttribute('seconds', seconds); }
|
||||
if (milliseconds !== undefined) { this.setAttribute('milliseconds', milliseconds); }
|
||||
return this.getTime();
|
||||
},
|
||||
setMinutes: function (minutes, seconds, milliseconds) {
|
||||
this.setAttribute('minutes', minutes);
|
||||
if (seconds !== undefined) { this.setAttribute('seconds', seconds); }
|
||||
if (milliseconds !== undefined) { this.setAttribute('milliseconds', milliseconds); }
|
||||
return this.getTime();
|
||||
},
|
||||
setSeconds: function (seconds, milliseconds) {
|
||||
this.setAttribute('seconds', seconds);
|
||||
if (milliseconds !== undefined) { this.setAttribute('milliseconds', milliseconds); }
|
||||
return this.getTime();
|
||||
},
|
||||
setMilliseconds: function (milliseconds) {
|
||||
this.setAttribute('milliseconds', milliseconds);
|
||||
return this.getTime();
|
||||
},
|
||||
setTime: function (n) {
|
||||
if (isNaN(n)) { throw new Error('Units must be a number.'); }
|
||||
this.setFromTimeProxy(n, this.timezone);
|
||||
return this.getTime();
|
||||
},
|
||||
setUTCFullYear: function (year, month, date) {
|
||||
if (date !== undefined) { this.setUTCAttribute('date', 1); }
|
||||
this.setUTCAttribute('year', year);
|
||||
if (month !== undefined) { this.setUTCAttribute('month', month); }
|
||||
if (date !== undefined) { this.setUTCAttribute('date', date); }
|
||||
return this.getTime();
|
||||
},
|
||||
setUTCMonth: function (month, date) {
|
||||
this.setUTCAttribute('month', month);
|
||||
if (date !== undefined) { this.setUTCAttribute('date', date); }
|
||||
return this.getTime();
|
||||
},
|
||||
setUTCDate: function (date) {
|
||||
this.setUTCAttribute('date', date);
|
||||
return this.getTime();
|
||||
},
|
||||
setUTCHours: function (hours, minutes, seconds, milliseconds) {
|
||||
this.setUTCAttribute('hours', hours);
|
||||
if (minutes !== undefined) { this.setUTCAttribute('minutes', minutes); }
|
||||
if (seconds !== undefined) { this.setUTCAttribute('seconds', seconds); }
|
||||
if (milliseconds !== undefined) { this.setUTCAttribute('milliseconds', milliseconds); }
|
||||
return this.getTime();
|
||||
},
|
||||
setUTCMinutes: function (minutes, seconds, milliseconds) {
|
||||
this.setUTCAttribute('minutes', minutes);
|
||||
if (seconds !== undefined) { this.setUTCAttribute('seconds', seconds); }
|
||||
if (milliseconds !== undefined) { this.setUTCAttribute('milliseconds', milliseconds); }
|
||||
return this.getTime();
|
||||
},
|
||||
setUTCSeconds: function (seconds, milliseconds) {
|
||||
this.setUTCAttribute('seconds', seconds);
|
||||
if (milliseconds !== undefined) { this.setUTCAttribute('milliseconds', milliseconds); }
|
||||
return this.getTime();
|
||||
},
|
||||
setUTCMilliseconds: function (milliseconds) {
|
||||
this.setUTCAttribute('milliseconds', milliseconds);
|
||||
return this.getTime();
|
||||
},
|
||||
setFromDateObjProxy: function (dt) {
|
||||
this.year = dt.getFullYear();
|
||||
this.month = dt.getMonth();
|
||||
this.date = dt.getDate();
|
||||
this.hours = dt.getHours();
|
||||
this.minutes = dt.getMinutes();
|
||||
this.seconds = dt.getSeconds();
|
||||
this.milliseconds = dt.getMilliseconds();
|
||||
this._day = dt.getDay();
|
||||
this._dateProxy = dt;
|
||||
this._timeProxy = Date.UTC(this.year, this.month, this.date, this.hours, this.minutes, this.seconds, this.milliseconds);
|
||||
this._useCache = false;
|
||||
},
|
||||
setFromTimeProxy: function (utcMillis, tz) {
|
||||
var dt = new Date(utcMillis);
|
||||
var tzOffset;
|
||||
tzOffset = tz ? timezoneJS.timezone.getTzInfo(dt, tz).tzOffset : dt.getTimezoneOffset();
|
||||
dt.setTime(utcMillis + (dt.getTimezoneOffset() - tzOffset) * 60000);
|
||||
this.setFromDateObjProxy(dt);
|
||||
},
|
||||
setAttribute: function (unit, n) {
|
||||
if (isNaN(n)) { throw new Error('Units must be a number.'); }
|
||||
var dt = this._dateProxy;
|
||||
var meth = unit === 'year' ? 'FullYear' : unit.substr(0, 1).toUpperCase() + unit.substr(1);
|
||||
dt['set' + meth](n);
|
||||
this.setFromDateObjProxy(dt);
|
||||
},
|
||||
setUTCAttribute: function (unit, n) {
|
||||
if (isNaN(n)) { throw new Error('Units must be a number.'); }
|
||||
var meth = unit === 'year' ? 'FullYear' : unit.substr(0, 1).toUpperCase() + unit.substr(1);
|
||||
var dt = this.getUTCDateProxy();
|
||||
dt['setUTC' + meth](n);
|
||||
dt.setUTCMinutes(dt.getUTCMinutes() - this.getTimezoneOffset());
|
||||
this.setFromTimeProxy(dt.getTime() + this.getTimezoneOffset() * 60000, this.timezone);
|
||||
},
|
||||
setTimezone: function (tz) {
|
||||
var previousOffset = this.getTimezoneInfo().tzOffset;
|
||||
this.timezone = tz;
|
||||
this._useCache = false;
|
||||
// Set UTC minutes offsets by the delta of the two timezones
|
||||
this.setUTCMinutes(this.getUTCMinutes() - this.getTimezoneInfo().tzOffset + previousOffset);
|
||||
},
|
||||
removeTimezone: function () {
|
||||
this.timezone = null;
|
||||
this._useCache = false;
|
||||
},
|
||||
valueOf: function () { return this.getTime(); },
|
||||
clone: function () {
|
||||
return this.timezone ? new timezoneJS.Date(this.getTime(), this.timezone) : new timezoneJS.Date(this.getTime());
|
||||
},
|
||||
toGMTString: function () { return this.toString('EEE, dd MMM yyyy HH:mm:ss Z', 'Etc/GMT'); },
|
||||
toLocaleString: function () {},
|
||||
toLocaleDateString: function () {},
|
||||
toLocaleTimeString: function () {},
|
||||
toSource: function () {},
|
||||
toISOString: function () { return this.toString('yyyy-MM-ddTHH:mm:ss.SSS', 'Etc/UTC') + 'Z'; },
|
||||
toJSON: function () { return this.toISOString(); },
|
||||
// Allows different format following ISO8601 format:
|
||||
toString: function (format, tz) {
|
||||
// Default format is the same as toISOString
|
||||
if (!format) format = 'yyyy-MM-dd HH:mm:ss';
|
||||
var result = format;
|
||||
var tzInfo = tz ? timezoneJS.timezone.getTzInfo(this.getTime(), tz) : this.getTimezoneInfo();
|
||||
var _this = this;
|
||||
// If timezone is specified, get a clone of the current Date object and modify it
|
||||
if (tz) {
|
||||
_this = this.clone();
|
||||
_this.setTimezone(tz);
|
||||
}
|
||||
var hours = _this.getHours();
|
||||
return result
|
||||
// fix the same characters in Month names
|
||||
.replace(/a+/g, function () { return 'k'; })
|
||||
// `y`: year
|
||||
.replace(/y+/g, function (token) { return _fixWidth(_this.getFullYear(), token.length); })
|
||||
// `d`: date
|
||||
.replace(/d+/g, function (token) { return _fixWidth(_this.getDate(), token.length); })
|
||||
// `m`: minute
|
||||
.replace(/m+/g, function (token) { return _fixWidth(_this.getMinutes(), token.length); })
|
||||
// `s`: second
|
||||
.replace(/s+/g, function (token) { return _fixWidth(_this.getSeconds(), token.length); })
|
||||
// `S`: millisecond
|
||||
.replace(/S+/g, function (token) { return _fixWidth(_this.getMilliseconds(), token.length); })
|
||||
// `M`: month. Note: `MM` will be the numeric representation (e.g February is 02) but `MMM` will be text representation (e.g February is Feb)
|
||||
.replace(/M+/g, function (token) {
|
||||
var _month = _this.getMonth(),
|
||||
_len = token.length;
|
||||
if (_len > 3) {
|
||||
return timezoneJS.Months[_month];
|
||||
} else if (_len > 2) {
|
||||
return timezoneJS.Months[_month].substring(0, _len);
|
||||
}
|
||||
return _fixWidth(_month + 1, _len);
|
||||
})
|
||||
// `k`: AM/PM
|
||||
.replace(/k+/g, function () {
|
||||
if (hours >= 12) {
|
||||
if (hours > 12) {
|
||||
hours -= 12;
|
||||
}
|
||||
return 'PM';
|
||||
}
|
||||
return 'AM';
|
||||
})
|
||||
// `H`: hour
|
||||
.replace(/H+/g, function (token) { return _fixWidth(hours, token.length); })
|
||||
// `E`: day
|
||||
.replace(/E+/g, function (token) { return DAYS[_this.getDay()].substring(0, token.length); })
|
||||
// `Z`: timezone abbreviation
|
||||
.replace(/Z+/gi, function () { return tzInfo.tzAbbr; });
|
||||
},
|
||||
toUTCString: function () { return this.toGMTString(); },
|
||||
civilToJulianDayNumber: function (y, m, d) {
|
||||
var a;
|
||||
// Adjust for zero-based JS-style array
|
||||
m++;
|
||||
if (m > 12) {
|
||||
a = parseInt(m/12, 10);
|
||||
m = m % 12;
|
||||
y += a;
|
||||
}
|
||||
if (m <= 2) {
|
||||
y -= 1;
|
||||
m += 12;
|
||||
}
|
||||
a = Math.floor(y / 100);
|
||||
var b = 2 - a + Math.floor(a / 4)
|
||||
, jDt = Math.floor(365.25 * (y + 4716)) + Math.floor(30.6001 * (m + 1)) + d + b - 1524;
|
||||
return jDt;
|
||||
},
|
||||
getLocalOffset: function () {
|
||||
return this._dateProxy.getTimezoneOffset();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
timezoneJS.timezone = new function () {
|
||||
var _this = this
|
||||
, regionMap = {'Etc':'etcetera','EST':'northamerica','MST':'northamerica','HST':'northamerica','EST5EDT':'northamerica','CST6CDT':'northamerica','MST7MDT':'northamerica','PST8PDT':'northamerica','America':'northamerica','Pacific':'australasia','Atlantic':'europe','Africa':'africa','Indian':'africa','Antarctica':'antarctica','Asia':'asia','Australia':'australasia','Europe':'europe','WET':'europe','CET':'europe','MET':'europe','EET':'europe'}
|
||||
, regionExceptions = {'Pacific/Honolulu':'northamerica','Atlantic/Bermuda':'northamerica','Atlantic/Cape_Verde':'africa','Atlantic/St_Helena':'africa','Indian/Kerguelen':'antarctica','Indian/Chagos':'asia','Indian/Maldives':'asia','Indian/Christmas':'australasia','Indian/Cocos':'australasia','America/Danmarkshavn':'europe','America/Scoresbysund':'europe','America/Godthab':'europe','America/Thule':'europe','Asia/Yekaterinburg':'europe','Asia/Omsk':'europe','Asia/Novosibirsk':'europe','Asia/Krasnoyarsk':'europe','Asia/Irkutsk':'europe','Asia/Yakutsk':'europe','Asia/Vladivostok':'europe','Asia/Sakhalin':'europe','Asia/Magadan':'europe','Asia/Kamchatka':'europe','Asia/Anadyr':'europe','Africa/Ceuta':'europe','America/Argentina/Buenos_Aires':'southamerica','America/Argentina/Cordoba':'southamerica','America/Argentina/Tucuman':'southamerica','America/Argentina/La_Rioja':'southamerica','America/Argentina/San_Juan':'southamerica','America/Argentina/Jujuy':'southamerica','America/Argentina/Catamarca':'southamerica','America/Argentina/Mendoza':'southamerica','America/Argentina/Rio_Gallegos':'southamerica','America/Argentina/Ushuaia':'southamerica','America/Aruba':'southamerica','America/La_Paz':'southamerica','America/Noronha':'southamerica','America/Belem':'southamerica','America/Fortaleza':'southamerica','America/Recife':'southamerica','America/Araguaina':'southamerica','America/Maceio':'southamerica','America/Bahia':'southamerica','America/Sao_Paulo':'southamerica','America/Campo_Grande':'southamerica','America/Cuiaba':'southamerica','America/Porto_Velho':'southamerica','America/Boa_Vista':'southamerica','America/Manaus':'southamerica','America/Eirunepe':'southamerica','America/Rio_Branco':'southamerica','America/Santiago':'southamerica','Pacific/Easter':'southamerica','America/Bogota':'southamerica','America/Curacao':'southamerica','America/Guayaquil':'southamerica','Pacific/Galapagos':'southamerica','Atlantic/Stanley':'southamerica','America/Cayenne':'southamerica','America/Guyana':'southamerica','America/Asuncion':'southamerica','America/Lima':'southamerica','Atlantic/South_Georgia':'southamerica','America/Paramaribo':'southamerica','America/Port_of_Spain':'southamerica','America/Montevideo':'southamerica','America/Caracas':'southamerica'};
|
||||
function invalidTZError(t) { throw new Error('Timezone "' + t + '" is either incorrect, or not loaded in the timezone registry.'); }
|
||||
function builtInLoadZoneFile(fileName, opts) {
|
||||
var url = _this.zoneFileBasePath + '/' + fileName;
|
||||
return !opts || !opts.async
|
||||
? _this.parseZones(_this.transport({ url : url, async : false }))
|
||||
: _this.transport({
|
||||
async: true,
|
||||
url : url,
|
||||
success : function (str) {
|
||||
if (_this.parseZones(str) && typeof opts.callback === 'function') {
|
||||
opts.callback();
|
||||
}
|
||||
return true;
|
||||
},
|
||||
error : function () {
|
||||
throw new Error('Error retrieving "' + url + '" zoneinfo files');
|
||||
}
|
||||
});
|
||||
}
|
||||
function getRegionForTimezone(tz) {
|
||||
var exc = regionExceptions[tz]
|
||||
, reg
|
||||
, ret;
|
||||
if (exc) return exc;
|
||||
reg = tz.split('/')[0];
|
||||
ret = regionMap[reg];
|
||||
// If there's nothing listed in the main regions for this TZ, check the 'backward' links
|
||||
if (ret) return ret;
|
||||
var link = _this.zones[tz];
|
||||
if (typeof link === 'string') {
|
||||
return getRegionForTimezone(link);
|
||||
}
|
||||
// Backward-compat file hasn't loaded yet, try looking in there
|
||||
if (!_this.loadedZones.backward) {
|
||||
// This is for obvious legacy zones (e.g., Iceland) that don't even have a prefix like "America/" that look like normal zones
|
||||
_this.loadZoneFile('backward');
|
||||
return getRegionForTimezone(tz);
|
||||
}
|
||||
invalidTZError(tz);
|
||||
}
|
||||
function parseTimeString(str) {
|
||||
var pat = /(\d+)(?::0*(\d*))?(?::0*(\d*))?([wsugz])?$/;
|
||||
var hms = str.match(pat);
|
||||
hms[1] = parseInt(hms[1], 10);
|
||||
hms[2] = hms[2] ? parseInt(hms[2], 10) : 0;
|
||||
hms[3] = hms[3] ? parseInt(hms[3], 10) : 0;
|
||||
|
||||
return hms;
|
||||
}
|
||||
function processZone(z) {
|
||||
if (!z[3]) { return; }
|
||||
var yea = parseInt(z[3], 10);
|
||||
var mon = 11;
|
||||
var dat = 31;
|
||||
if (z[4]) {
|
||||
mon = SHORT_MONTHS[z[4].substr(0, 3)];
|
||||
dat = parseInt(z[5], 10) || 1;
|
||||
}
|
||||
var string = z[6] ? z[6] : '00:00:00'
|
||||
, t = parseTimeString(string);
|
||||
return [yea, mon, dat, t[1], t[2], t[3]];
|
||||
}
|
||||
function getZone(dt, tz) {
|
||||
var utcMillis = typeof dt === 'number' ? dt : new Date(dt).getTime();
|
||||
var t = tz;
|
||||
var zoneList = _this.zones[t];
|
||||
// Follow links to get to an actual zone
|
||||
while (typeof zoneList === "string") {
|
||||
t = zoneList;
|
||||
zoneList = _this.zones[t];
|
||||
}
|
||||
if (!zoneList) {
|
||||
// Backward-compat file hasn't loaded yet, try looking in there
|
||||
if (!_this.loadedZones.backward) {
|
||||
//This is for backward entries like "America/Fort_Wayne" that
|
||||
// getRegionForTimezone *thinks* it has a region file and zone
|
||||
// for (e.g., America => 'northamerica'), but in reality it's a
|
||||
// legacy zone we need the backward file for.
|
||||
_this.loadZoneFile('backward');
|
||||
return getZone(dt, tz);
|
||||
}
|
||||
invalidTZError(t);
|
||||
}
|
||||
if (zoneList.length === 0) {
|
||||
throw new Error('No Zone found for "' + tz + '" on ' + dt);
|
||||
}
|
||||
//Do backwards lookup since most use cases deal with newer dates.
|
||||
for (var i = zoneList.length - 1; i >= 0; i--) {
|
||||
var z = zoneList[i];
|
||||
if (z[3] && utcMillis > z[3]) break;
|
||||
}
|
||||
return zoneList[i+1];
|
||||
}
|
||||
function getBasicOffset(time) {
|
||||
var off = parseTimeString(time)
|
||||
, adj = time.charAt(0) === '-' ? -1 : 1;
|
||||
off = adj * (((off[1] * 60 + off[2]) * 60 + off[3]) * 1000);
|
||||
return off/60/1000;
|
||||
}
|
||||
|
||||
//if isUTC is true, date is given in UTC, otherwise it's given
|
||||
// in local time (ie. date.getUTC*() returns local time components)
|
||||
function getRule(dt, zone, isUTC) {
|
||||
var date = typeof dt === 'number' ? new Date(dt) : dt;
|
||||
var ruleset = zone[1];
|
||||
var basicOffset = zone[0];
|
||||
|
||||
// If the zone has a DST rule like '1:00', create a rule and return it
|
||||
// instead of looking it up in the parsed rules
|
||||
var staticDstMatch = ruleset.match(/^([0-9]):([0-9][0-9])$/);
|
||||
if (staticDstMatch) {
|
||||
return [-1000000,'max','-','Jan',1,parseTimeString('0:00'),parseInt(staticDstMatch[1]) * 60 + parseInt(staticDstMatch[2]), '-'];
|
||||
}
|
||||
|
||||
//Convert a date to UTC. Depending on the 'type' parameter, the date
|
||||
// parameter may be:
|
||||
//
|
||||
// - `u`, `g`, `z`: already UTC (no adjustment).
|
||||
//
|
||||
// - `s`: standard time (adjust for time zone offset but not for DST)
|
||||
//
|
||||
// - `w`: wall clock time (adjust for both time zone and DST offset).
|
||||
//
|
||||
// DST adjustment is done using the rule given as third argument.
|
||||
var convertDateToUTC = function (date, type, rule) {
|
||||
var offset = 0;
|
||||
|
||||
if (type === 'u' || type === 'g' || type === 'z') { // UTC
|
||||
offset = 0;
|
||||
} else if (type === 's') { // Standard Time
|
||||
offset = basicOffset;
|
||||
} else if (type === 'w' || !type) { // Wall Clock Time
|
||||
offset = getAdjustedOffset(basicOffset, rule);
|
||||
} else {
|
||||
throw("unknown type " + type);
|
||||
}
|
||||
offset *= 60 * 1000; // to millis
|
||||
|
||||
return new Date(date.getTime() + offset);
|
||||
};
|
||||
|
||||
//Step 1: Find applicable rules for this year.
|
||||
//
|
||||
//Step 2: Sort the rules by effective date.
|
||||
//
|
||||
//Step 3: Check requested date to see if a rule has yet taken effect this year. If not,
|
||||
//
|
||||
//Step 4: Get the rules for the previous year. If there isn't an applicable rule for last year, then
|
||||
// there probably is no current time offset since they seem to explicitly turn off the offset
|
||||
// when someone stops observing DST.
|
||||
//
|
||||
// FIXME if this is not the case and we'll walk all the way back (ugh).
|
||||
//
|
||||
//Step 5: Sort the rules by effective date.
|
||||
//Step 6: Apply the most recent rule before the current time.
|
||||
var convertRuleToExactDateAndTime = function (yearAndRule, prevRule) {
|
||||
var year = yearAndRule[0]
|
||||
, rule = yearAndRule[1];
|
||||
// Assume that the rule applies to the year of the given date.
|
||||
|
||||
var hms = rule[5];
|
||||
var effectiveDate;
|
||||
|
||||
if (!EXACT_DATE_TIME[year])
|
||||
EXACT_DATE_TIME[year] = {};
|
||||
|
||||
// Result for given parameters is already stored
|
||||
if (EXACT_DATE_TIME[year][rule])
|
||||
effectiveDate = EXACT_DATE_TIME[year][rule];
|
||||
else {
|
||||
//If we have a specific date, use that!
|
||||
if (!isNaN(rule[4])) {
|
||||
effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]], rule[4], hms[1], hms[2], hms[3], 0));
|
||||
}
|
||||
//Let's hunt for the date.
|
||||
else {
|
||||
var targetDay
|
||||
, operator;
|
||||
//Example: `lastThu`
|
||||
if (rule[4].substr(0, 4) === "last") {
|
||||
// Start at the last day of the month and work backward.
|
||||
effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]] + 1, 1, hms[1] - 24, hms[2], hms[3], 0));
|
||||
targetDay = SHORT_DAYS[rule[4].substr(4, 3)];
|
||||
operator = "<=";
|
||||
}
|
||||
//Example: `Sun>=15`
|
||||
else {
|
||||
//Start at the specified date.
|
||||
effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]], rule[4].substr(5), hms[1], hms[2], hms[3], 0));
|
||||
targetDay = SHORT_DAYS[rule[4].substr(0, 3)];
|
||||
operator = rule[4].substr(3, 2);
|
||||
}
|
||||
var ourDay = effectiveDate.getUTCDay();
|
||||
//Go forwards.
|
||||
if (operator === ">=") {
|
||||
effectiveDate.setUTCDate(effectiveDate.getUTCDate() + (targetDay - ourDay + ((targetDay < ourDay) ? 7 : 0)));
|
||||
}
|
||||
//Go backwards. Looking for the last of a certain day, or operator is "<=" (less likely).
|
||||
else {
|
||||
effectiveDate.setUTCDate(effectiveDate.getUTCDate() + (targetDay - ourDay - ((targetDay > ourDay) ? 7 : 0)));
|
||||
}
|
||||
}
|
||||
EXACT_DATE_TIME[year][rule] = effectiveDate;
|
||||
}
|
||||
|
||||
|
||||
//If previous rule is given, correct for the fact that the starting time of the current
|
||||
// rule may be specified in local time.
|
||||
if (prevRule) {
|
||||
effectiveDate = convertDateToUTC(effectiveDate, hms[4], prevRule);
|
||||
}
|
||||
return effectiveDate;
|
||||
};
|
||||
|
||||
var findApplicableRules = function (year, ruleset) {
|
||||
var applicableRules = [];
|
||||
for (var i = 0; ruleset && i < ruleset.length; i++) {
|
||||
//Exclude future rules.
|
||||
if (ruleset[i][0] <= year &&
|
||||
(
|
||||
// Date is in a set range.
|
||||
ruleset[i][1] >= year ||
|
||||
// Date is in an "only" year.
|
||||
(ruleset[i][0] === year && ruleset[i][1] === "only") ||
|
||||
//We're in a range from the start year to infinity.
|
||||
ruleset[i][1] === "max"
|
||||
)
|
||||
) {
|
||||
//It's completely okay to have any number of matches here.
|
||||
// Normally we should only see two, but that doesn't preclude other numbers of matches.
|
||||
// These matches are applicable to this year.
|
||||
applicableRules.push([year, ruleset[i]]);
|
||||
}
|
||||
}
|
||||
return applicableRules;
|
||||
};
|
||||
|
||||
var compareDates = function (a, b, prev) {
|
||||
var year, rule;
|
||||
if (a.constructor !== Date) {
|
||||
year = a[0];
|
||||
rule = a[1];
|
||||
a = (!prev && EXACT_DATE_TIME[year] && EXACT_DATE_TIME[year][rule])
|
||||
? EXACT_DATE_TIME[year][rule]
|
||||
: convertRuleToExactDateAndTime(a, prev);
|
||||
} else if (prev) {
|
||||
a = convertDateToUTC(a, isUTC ? 'u' : 'w', prev);
|
||||
}
|
||||
if (b.constructor !== Date) {
|
||||
year = b[0];
|
||||
rule = b[1];
|
||||
b = (!prev && EXACT_DATE_TIME[year] && EXACT_DATE_TIME[year][rule]) ? EXACT_DATE_TIME[year][rule]
|
||||
: convertRuleToExactDateAndTime(b, prev);
|
||||
} else if (prev) {
|
||||
b = convertDateToUTC(b, isUTC ? 'u' : 'w', prev);
|
||||
}
|
||||
a = Number(a);
|
||||
b = Number(b);
|
||||
return a - b;
|
||||
};
|
||||
|
||||
var year = date.getUTCFullYear();
|
||||
var applicableRules;
|
||||
|
||||
applicableRules = findApplicableRules(year, _this.rules[ruleset]);
|
||||
applicableRules.push(date);
|
||||
//While sorting, the time zone in which the rule starting time is specified
|
||||
// is ignored. This is ok as long as the timespan between two DST changes is
|
||||
// larger than the DST offset, which is probably always true.
|
||||
// As the given date may indeed be close to a DST change, it may get sorted
|
||||
// to a wrong position (off by one), which is corrected below.
|
||||
applicableRules.sort(compareDates);
|
||||
|
||||
//If there are not enough past DST rules...
|
||||
if (_arrIndexOf.call(applicableRules, date) < 2) {
|
||||
applicableRules = applicableRules.concat(findApplicableRules(year-1, _this.rules[ruleset]));
|
||||
applicableRules.sort(compareDates);
|
||||
}
|
||||
var pinpoint = _arrIndexOf.call(applicableRules, date);
|
||||
if (pinpoint > 1 && compareDates(date, applicableRules[pinpoint-1], applicableRules[pinpoint-2][1]) < 0) {
|
||||
//The previous rule does not really apply, take the one before that.
|
||||
return applicableRules[pinpoint - 2][1];
|
||||
} else if (pinpoint > 0 && pinpoint < applicableRules.length - 1 && compareDates(date, applicableRules[pinpoint+1], applicableRules[pinpoint-1][1]) > 0) {
|
||||
|
||||
//The next rule does already apply, take that one.
|
||||
return applicableRules[pinpoint + 1][1];
|
||||
} else if (pinpoint === 0) {
|
||||
//No applicable rule found in this and in previous year.
|
||||
return null;
|
||||
}
|
||||
return applicableRules[pinpoint - 1][1];
|
||||
}
|
||||
function getAdjustedOffset(off, rule) {
|
||||
return -Math.ceil(rule[6] - off);
|
||||
}
|
||||
function getAbbreviation(zone, rule) {
|
||||
var res;
|
||||
var base = zone[2];
|
||||
if (base.indexOf('%s') > -1) {
|
||||
var repl;
|
||||
if (rule) {
|
||||
repl = rule[7] === '-' ? '' : rule[7];
|
||||
}
|
||||
//FIXME: Right now just falling back to Standard --
|
||||
// apparently ought to use the last valid rule,
|
||||
// although in practice that always ought to be Standard
|
||||
else {
|
||||
repl = 'S';
|
||||
}
|
||||
res = base.replace('%s', repl);
|
||||
}
|
||||
else if (base.indexOf('/') > -1) {
|
||||
//Chose one of two alternative strings.
|
||||
res = base.split("/", 2)[rule[6] ? 1 : 0];
|
||||
} else {
|
||||
res = base;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
this.zoneFileBasePath = null;
|
||||
this.zoneFiles = ['africa', 'antarctica', 'asia', 'australasia', 'backward', 'etcetera', 'europe', 'northamerica', 'pacificnew', 'southamerica'];
|
||||
this.loadingSchemes = {
|
||||
PRELOAD_ALL: 'preloadAll',
|
||||
LAZY_LOAD: 'lazyLoad',
|
||||
MANUAL_LOAD: 'manualLoad'
|
||||
};
|
||||
this.loadingScheme = this.loadingSchemes.LAZY_LOAD;
|
||||
this.loadedZones = {};
|
||||
this.zones = {};
|
||||
this.rules = {};
|
||||
|
||||
this.init = function (o) {
|
||||
var opts = { async: true }
|
||||
, def = this.loadingScheme === this.loadingSchemes.PRELOAD_ALL
|
||||
? this.zoneFiles
|
||||
: (this.defaultZoneFile || 'northamerica')
|
||||
, done = 0
|
||||
, callbackFn;
|
||||
//Override default with any passed-in opts
|
||||
for (var p in o) {
|
||||
opts[p] = o[p];
|
||||
}
|
||||
if (typeof def === 'string') {
|
||||
return this.loadZoneFile(def, opts);
|
||||
}
|
||||
//Wraps callback function in another one that makes
|
||||
// sure all files have been loaded.
|
||||
callbackFn = opts.callback;
|
||||
opts.callback = function () {
|
||||
done++;
|
||||
(done === def.length) && typeof callbackFn === 'function' && callbackFn();
|
||||
};
|
||||
for (var i = 0; i < def.length; i++) {
|
||||
this.loadZoneFile(def[i], opts);
|
||||
}
|
||||
};
|
||||
|
||||
//Get the zone files via XHR -- if the sync flag
|
||||
// is set to true, it's being called by the lazy-loading
|
||||
// mechanism, so the result needs to be returned inline.
|
||||
this.loadZoneFile = function (fileName, opts) {
|
||||
if (typeof this.zoneFileBasePath === 'undefined') {
|
||||
throw new Error('Please define a base path to your zone file directory -- timezoneJS.timezone.zoneFileBasePath.');
|
||||
}
|
||||
//Ignore already loaded zones.
|
||||
if (this.loadedZones[fileName]) {
|
||||
return;
|
||||
}
|
||||
this.loadedZones[fileName] = true;
|
||||
return builtInLoadZoneFile(fileName, opts);
|
||||
};
|
||||
this.loadZoneJSONData = function (url, sync) {
|
||||
var processData = function (data) {
|
||||
data = eval('('+ data +')');
|
||||
for (var z in data.zones) {
|
||||
_this.zones[z] = data.zones[z];
|
||||
}
|
||||
for (var r in data.rules) {
|
||||
_this.rules[r] = data.rules[r];
|
||||
}
|
||||
};
|
||||
return sync
|
||||
? processData(_this.transport({ url : url, async : false }))
|
||||
: _this.transport({ url : url, success : processData });
|
||||
};
|
||||
this.loadZoneDataFromObject = function (data) {
|
||||
if (!data) { return; }
|
||||
for (var z in data.zones) {
|
||||
_this.zones[z] = data.zones[z];
|
||||
}
|
||||
for (var r in data.rules) {
|
||||
_this.rules[r] = data.rules[r];
|
||||
}
|
||||
};
|
||||
this.getAllZones = function () {
|
||||
var arr = [];
|
||||
for (var z in this.zones) { arr.push(z); }
|
||||
return arr.sort();
|
||||
};
|
||||
this.parseZones = function (str) {
|
||||
var lines = str.split('\n')
|
||||
, arr = []
|
||||
, chunk = ''
|
||||
, l
|
||||
, zone = null
|
||||
, rule = null;
|
||||
for (var i = 0; i < lines.length; i++) {
|
||||
l = lines[i];
|
||||
if (l.match(/^\s/)) {
|
||||
l = "Zone " + zone + l;
|
||||
}
|
||||
l = l.split("#")[0];
|
||||
if (l.length > 3) {
|
||||
arr = l.split(/\s+/);
|
||||
chunk = arr.shift();
|
||||
//Ignore Leap.
|
||||
switch (chunk) {
|
||||
case 'Zone':
|
||||
zone = arr.shift();
|
||||
if (!_this.zones[zone]) {
|
||||
_this.zones[zone] = [];
|
||||
}
|
||||
if (arr.length < 3) break;
|
||||
//Process zone right here and replace 3rd element with the processed array.
|
||||
arr.splice(3, arr.length, processZone(arr));
|
||||
if (arr[3]) arr[3] = Date.UTC.apply(null, arr[3]);
|
||||
arr[0] = -getBasicOffset(arr[0]);
|
||||
_this.zones[zone].push(arr);
|
||||
break;
|
||||
case 'Rule':
|
||||
rule = arr.shift();
|
||||
if (!_this.rules[rule]) {
|
||||
_this.rules[rule] = [];
|
||||
}
|
||||
//Parse int FROM year and TO year
|
||||
arr[0] = parseInt(arr[0], 10);
|
||||
arr[1] = parseInt(arr[1], 10) || arr[1];
|
||||
//Parse time string AT
|
||||
arr[5] = parseTimeString(arr[5]);
|
||||
//Parse offset SAVE
|
||||
arr[6] = getBasicOffset(arr[6]);
|
||||
_this.rules[rule].push(arr);
|
||||
break;
|
||||
case 'Link':
|
||||
//No zones for these should already exist.
|
||||
if (_this.zones[arr[1]]) {
|
||||
throw new Error('Error with Link ' + arr[1] + '. Cannot create link of a preexisted zone.');
|
||||
}
|
||||
//Create the link.
|
||||
_this.zones[arr[1]] = arr[0];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
};
|
||||
//Expose transport mechanism and allow overwrite.
|
||||
this.transport = _transport;
|
||||
this.getTzInfo = function (dt, tz, isUTC) {
|
||||
//Lazy-load any zones not yet loaded.
|
||||
if (this.loadingScheme === this.loadingSchemes.LAZY_LOAD) {
|
||||
//Get the correct region for the zone.
|
||||
var zoneFile = getRegionForTimezone(tz);
|
||||
if (!zoneFile) {
|
||||
throw new Error('Not a valid timezone ID.');
|
||||
}
|
||||
if (!this.loadedZones[zoneFile]) {
|
||||
//Get the file and parse it -- use synchronous XHR.
|
||||
this.loadZoneFile(zoneFile);
|
||||
}
|
||||
}
|
||||
var z = getZone(dt, tz);
|
||||
var off = z[0];
|
||||
//See if the offset needs adjustment.
|
||||
var rule = getRule(dt, z, isUTC);
|
||||
if (rule) {
|
||||
off = getAdjustedOffset(off, rule);
|
||||
}
|
||||
var abbr = getAbbreviation(z, rule);
|
||||
return { tzOffset: off, tzAbbr: abbr };
|
||||
};
|
||||
};
|
||||
}).call(this);
|
||||
@ -14,7 +14,7 @@
|
||||
],
|
||||
"type": "text",
|
||||
"title": "Welcome",
|
||||
"content": "Welcome to Kibana Dashboard, a technology preview of what's to come for Kibana, Logstash and Elasticsearch \n\nKibana dashboard is the easy way to share, build, use and extend interactive, real time dashboards and data analysis interfaces. \n\nReady to get started? \n\nLogstash users, click the 'Load' button to the right, paste this URL: https://gist.github.com/anonymous/e99d94a426956c45a288 into the 'Gist' loader, click 'Get' and select the 'Logstash Dashboard' link that appears",
|
||||
"content": "Welcome to Kibana Dashboard, a technology preview of what's to come for Kibana, Logstash and Elasticsearch \n\nKibana dashboard is the easy way to share, build, use and extend interactive, real time dashboards and data analysis interfaces. \n\nReady to get started? \n\nLogstash users, click the 'Load' button to the right, paste this URL: https://gist.github.com/88a4b1f22e3212e45cf3 into the 'Gist' loader, click 'Get' and select the 'Logstash Dashboard' link that appears",
|
||||
"style": {
|
||||
"font-size": "14pt"
|
||||
}
|
||||
|
||||
@ -36,8 +36,12 @@
|
||||
<label class="small">Chart Options</label>
|
||||
<select ng-change="$emit('render')" multiple style="width:95%" ng-model="panel.show" ng-options="f for f in ['bars','points','stack','lines','legend','x-axis','y-axis']"></select>
|
||||
</div>
|
||||
<div class="span2">
|
||||
<label class="small">Fill (0.0 - 1.0)</label>
|
||||
<div class="span3">
|
||||
<label class="small">Line Fill (1 - 10)</label>
|
||||
<input ng-change="$emit('render')" type="number" class="input-mini" ng-model="panel.fill">
|
||||
</div>
|
||||
<div class="span3">
|
||||
<label class="small">Time correction</label>
|
||||
<select ng-change="$emit('render')" ng-model="panel.timezone" class='input-small' ng-options="f for f in ['browser','utc']"></select>
|
||||
</div>
|
||||
</div>
|
||||
@ -8,7 +8,8 @@ angular.module('kibana.histogram', [])
|
||||
query : [ {query: "*", label:"Query"} ],
|
||||
interval: secondsToHms(calculate_interval($scope.from,$scope.to,40,0)/1000),
|
||||
show : ['bars','y-axis','x-axis','legend'],
|
||||
fill : false,
|
||||
fill : 3,
|
||||
timezone: 'browser', // browser, utc or a standard timezone
|
||||
group : "default",
|
||||
}
|
||||
_.defaults($scope.panel,_d)
|
||||
@ -144,6 +145,7 @@ angular.module('kibana.histogram', [])
|
||||
var scripts = $LAB.script("common/lib/panels/jquery.flot.js")
|
||||
.script("common/lib/panels/jquery.flot.time.js")
|
||||
.script("common/lib/panels/jquery.flot.stack.js")
|
||||
.script("common/lib/panels/timezone.js")
|
||||
|
||||
// Populate element. Note that jvectormap appends, does not replace.
|
||||
scripts.wait(function(){
|
||||
@ -159,13 +161,14 @@ angular.module('kibana.histogram', [])
|
||||
},
|
||||
series: {
|
||||
stack: show.stack,
|
||||
lines: { show: show.lines, fill: scope.panel.fill },
|
||||
lines: { show: show.lines, fill: scope.panel.fill/10 },
|
||||
bars: { show: show.bars, fill: 1, barWidth: barwidth/1.8 },
|
||||
points: { show: show.points },
|
||||
shadowSize: 1
|
||||
},
|
||||
yaxis: { show: show['y-axis'], min: 0, color: "#000" },
|
||||
xaxis: {
|
||||
timezone: scope.panel.timezone,
|
||||
show: show['x-axis'],
|
||||
mode: "time",
|
||||
timeformat: "%H:%M:%S<br>%m-%d",
|
||||
|
||||
Loading…
Reference in New Issue
Block a user