423 lines
10 KiB
JavaScript
423 lines
10 KiB
JavaScript
var NUT =
|
|
{
|
|
// UPS table DOM ids
|
|
listID: "#ups_list",
|
|
listBodyID: "#ups_list_body",
|
|
|
|
// Field names
|
|
fields:
|
|
[
|
|
"manufacturer",
|
|
"device-type",
|
|
"support-level",
|
|
"model",
|
|
"comment",
|
|
"driver"
|
|
],
|
|
|
|
// Actual HTML table columns
|
|
columns:
|
|
[
|
|
["manufacturer"],
|
|
["model","comment"],
|
|
["driver"],
|
|
["support-level"],
|
|
],
|
|
|
|
// driver => connection type mappings
|
|
driverMap: function(driver)
|
|
{
|
|
if(driver.match(/bcmxcp_usb|blazer_usb|richcomm_usb|tripplite_usb|usbhid-ups/))
|
|
return "USB";
|
|
|
|
if(driver.match(/snmp-ups|netxml-ups/))
|
|
return "Network";
|
|
|
|
return "Serial";
|
|
},
|
|
|
|
// Support level => CSS class mappings
|
|
supportLevelClasses:
|
|
{
|
|
0: "",
|
|
1: "red",
|
|
2: "orange",
|
|
3: "yellow",
|
|
4: "blue",
|
|
5: "green"
|
|
},
|
|
|
|
tableCache: false,
|
|
|
|
// Parse GET parameters from window url and return them as a hash
|
|
// The call format is:
|
|
// stable-hcl.html?<filter name>=<filter value>
|
|
// Refer to docs/website/stable-hcl.txt for examples
|
|
parseGetParameters: function()
|
|
{
|
|
var url = window.location.href;
|
|
url = url.replace(/#$/, "");
|
|
var fieldPos = url.indexOf("?");
|
|
var get = {};
|
|
if(fieldPos > -1)
|
|
{
|
|
var fileName = url.substring(0, fieldPos);
|
|
var getList = url.substring(fieldPos + 1).split("&");
|
|
for(var i = 0; i<getList.length; i++)
|
|
{
|
|
var getField = getList[i].split("=");
|
|
get[unescape(getField[0])] = unescape(getField[1]);
|
|
}
|
|
}
|
|
return get;
|
|
},
|
|
|
|
// UPS filter renderers by data column index
|
|
filterRenderers:
|
|
{
|
|
"support-level": function(value)
|
|
{
|
|
var result = [];
|
|
for(var i = 0; i < value; i++) result.push("*");
|
|
return result.join("");
|
|
},
|
|
"driver": function(value)
|
|
{
|
|
return this.driverMap(value);
|
|
},
|
|
"device-type": function(value)
|
|
{
|
|
var map =
|
|
{
|
|
"pdu": "Power Distribution Unit",
|
|
"ups": "Uninterruptible Power Supply",
|
|
"scd": "Solar Controller Device"
|
|
}
|
|
|
|
return map[value];
|
|
}
|
|
},
|
|
|
|
// Specific filter handlers
|
|
filterHandlers:
|
|
{
|
|
/**
|
|
* @param {string} value value to filter
|
|
* @param {array} row raw data fields
|
|
* @return {boolean} true if value passes the filter, false otherwise
|
|
*/
|
|
"driver": function(value, row)
|
|
{
|
|
var driver = row[this.fields.indexOf("driver")];
|
|
if(this.driverMap(driver) == value) return true;
|
|
|
|
return false;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Returns rendered UPS data according to column index
|
|
* @param {integer} index
|
|
* @param {string} value
|
|
*/
|
|
renderFilter: function(index, value)
|
|
{
|
|
var renderer = this.filterRenderers[this.fields[index]];
|
|
if(typeof renderer == "function")
|
|
return renderer.call(this, value);
|
|
return value;
|
|
},
|
|
|
|
/**
|
|
* Initialization method
|
|
*/
|
|
init: function()
|
|
{
|
|
this.initFilters();
|
|
this.sortUPSData(UPSData);
|
|
this.buildUPSList(UPSData);
|
|
this.buildFilters(UPSData);
|
|
|
|
var get = this.parseGetParameters();
|
|
for(var param in get)
|
|
{
|
|
var filter = $("#"+param);
|
|
if(filter)
|
|
{
|
|
filter.val(get[param]);
|
|
this.doFilter();
|
|
}
|
|
}
|
|
},
|
|
/**
|
|
* Initialize filter filters references
|
|
*/
|
|
initFilters: function()
|
|
{
|
|
// Display filters fieldset hidden by default for user-agents not using javascript
|
|
$("#filters-set").show();
|
|
|
|
this.filters =
|
|
{
|
|
"support-level": { index: this.fields.indexOf("support-level"), field: $("#support-level") },
|
|
"device-type": { index: this.fields.indexOf("device-type"), field: $("#device-type") },
|
|
"manufacturer": { index: this.fields.indexOf("manufacturer"), field: $("#manufacturer") },
|
|
"model": { index: this.fields.indexOf("model"), field: $("#model") },
|
|
"driver": { index: this.fields.indexOf("driver"), field: $("#connection") }
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Sorts table data by manufacturer and driver
|
|
* @param {Object} data
|
|
*/
|
|
sortUPSData: function(data)
|
|
{
|
|
var mI = this.fields.indexOf("manufacturer"), dI = this.fields.indexOf("driver");
|
|
data.sort(function(a,b)
|
|
{
|
|
var toLower = function(ar)
|
|
{
|
|
var res = ar.slice();
|
|
res.forEach(function(i, index) { if(typeof i == "string") res[index] = i.toLowerCase() });
|
|
return res;
|
|
}
|
|
var c = toLower(a), d = toLower(b);
|
|
return c[mI] == d[mI] ? c[dI] > d[dI] : c[mI] > d[mI];
|
|
});
|
|
},
|
|
/**
|
|
* Builds UPS list from provided data
|
|
* @param {array} data
|
|
*/
|
|
buildUPSList: function(data)
|
|
{
|
|
var list = $(this.listBodyID);
|
|
|
|
// Initialize table cache
|
|
if(!this.tableCache) this.tableCache = list.html();
|
|
|
|
// If we're rebuilding the original table, just use the one in cache
|
|
if(data == UPSData && this.tableCache)
|
|
{
|
|
list.html(this.tableCache);
|
|
return;
|
|
}
|
|
|
|
list.empty();
|
|
|
|
// Bailout if no data
|
|
if(!data || data.length == 0) return;
|
|
|
|
// Build rows
|
|
var cellHistory = [], rows = [];
|
|
var rowHistory = data[0][0];
|
|
var classes = ["even", "odd"], manufIndex = this.fields.indexOf("manufacturer"), currentClass = 0;
|
|
data.forEach(function(upsRow, rowIndex)
|
|
{
|
|
if(upsRow[manufIndex] != rowHistory)
|
|
{
|
|
currentClass = Number(!currentClass);
|
|
rowHistory = upsRow[manufIndex];
|
|
}
|
|
var cells = [];
|
|
// Build cells
|
|
this.columns.forEach(function(column, colIndex)
|
|
{
|
|
var cellContent = [];
|
|
column.forEach(function(field) {cellContent.push(upsRow[this.fields.indexOf(field)])}, this);
|
|
cellContent = cellContent.join("<br />");
|
|
|
|
// Inspect the last cell on this column and increase row span if the current cell has the same content
|
|
var cH = cellHistory[colIndex];
|
|
if(cH && cH.html == cellContent)
|
|
cH.rowSpan += 1;
|
|
else
|
|
{
|
|
var cell = "";
|
|
if(column.indexOf("driver") != -1)
|
|
{
|
|
cell = {html: cellContent, rowSpan: 1, cls: this.supportLevelClasses[upsRow[this.fields.indexOf("support-level") || ""]]};
|
|
}
|
|
else cell = {html: cellContent, rowSpan: 1, cls: classes[currentClass] }
|
|
|
|
if(column.indexOf("support-level") != -1) cell.cls += " hidden";
|
|
|
|
cells.push(cell);
|
|
cellHistory[colIndex] = cell;
|
|
}
|
|
}, this);
|
|
rows.push(cells);
|
|
}, this);
|
|
|
|
// Generate actual rows/cells tags
|
|
rows.forEach(function(r, index)
|
|
{
|
|
r.forEach(function(c, index)
|
|
{
|
|
r[index] = ["<td class='", c.cls, "' rowspan='", c.rowSpan, "'>", c.html, "</td>"].join("");
|
|
});
|
|
rows[index] = ["<tr>", r.join(""), "</tr>"].join("");
|
|
});
|
|
|
|
list.html(rows.join(""));
|
|
},
|
|
/**
|
|
* Initialize filters event listeners
|
|
* @param {Object} data
|
|
*/
|
|
buildFilters: function(data)
|
|
{
|
|
for(var f in this.filters)
|
|
{
|
|
var filter = this.filters[f];
|
|
this.populateCombo(data, filter);
|
|
filter.field.change(this.doFilter);
|
|
var op = $("#op-" + (filter.index));
|
|
if(op) op.change(this.doFilter);
|
|
}
|
|
},
|
|
/**
|
|
* Load data in filter combos
|
|
* @param {array} data
|
|
* @param {object} combo
|
|
* @param {integer} index
|
|
*/
|
|
populateCombo: function(data, filter)
|
|
{
|
|
var values = [];
|
|
var valueDict = {};
|
|
|
|
var combo = filter.field;
|
|
var oldValue = combo.val();
|
|
combo.html("<option value='-1'>---</option>");
|
|
|
|
// Special case for connection type
|
|
if(filter.field.attr("id") == "connection")
|
|
{
|
|
["Serial", "USB", "Network"].forEach(function(type)
|
|
{
|
|
values.push([type, type]);
|
|
}, this);
|
|
}
|
|
else
|
|
{
|
|
data.forEach(function(row)
|
|
{
|
|
var value = row[filter.index];
|
|
if(value != "" && !valueDict[value])
|
|
{
|
|
values.push([value, this.renderFilter(filter.index, value)]);
|
|
valueDict[value] = true;
|
|
}
|
|
}, this);
|
|
|
|
values = values.sort();
|
|
}
|
|
|
|
values.forEach(function(value)
|
|
{
|
|
var option = $(document.createElement("option"));
|
|
option.val(value[0]);
|
|
option.text(value[1]);
|
|
combo.append(option);
|
|
}, this);
|
|
|
|
combo.val(oldValue);
|
|
},
|
|
/**
|
|
* Apply selected filters on UPS list
|
|
*/
|
|
doFilter: function()
|
|
{
|
|
var initialRows = UPSData.slice();
|
|
var filteredRows = UPSData.slice();
|
|
|
|
/**
|
|
* Applies a single filter on provided UPS data set
|
|
* @param {string} value
|
|
* @param {integer} index
|
|
* @param {array} data
|
|
* @returns {array} filtered data set
|
|
*/
|
|
var applyFilter = function(value, index, data)
|
|
{
|
|
var tmpData = [];
|
|
tmpData = data.slice();
|
|
tmpData.forEach(function(row, rowIndex)
|
|
{
|
|
var field = row[index];
|
|
var handler = this.filterHandlers[this.fields[index]];
|
|
if(handler)
|
|
{
|
|
if(!handler.apply(this, [value, row]))
|
|
{
|
|
data.splice(data.indexOf(row), 1);
|
|
}
|
|
}
|
|
else if(row[index] != value) data.splice(data.indexOf(row), 1);
|
|
}, this);
|
|
return data;
|
|
}
|
|
|
|
// Sequentially apply filters
|
|
for(var f in NUT.filters)
|
|
{
|
|
var filter = NUT.filters[f];
|
|
var value = filter.field.val();
|
|
if(value != "-1") // Is filter active, i.e have the user picked a value in the filter combo
|
|
{
|
|
var opField = $("#op-" + filter.index);
|
|
filteredRows = applyFilter.apply(NUT, [value, filter.index, filteredRows]);
|
|
}
|
|
}
|
|
|
|
// Rebuild UPS list and combos according to filtered data
|
|
NUT.buildUPSList(filteredRows);
|
|
["manufacturer", "model", "driver"].forEach(function(id)
|
|
{
|
|
if(this.id != id) this.populateCombo(filteredRows, this.filters[id]);
|
|
}, NUT);
|
|
},
|
|
|
|
resetCombos: function()
|
|
{
|
|
for(var f in this.filters)
|
|
{
|
|
var field = this.filters[f].field;
|
|
this.populateCombo(UPSData, this.filters[f]);
|
|
field.val("-1");
|
|
}
|
|
this.buildUPSList(UPSData);
|
|
}
|
|
}
|
|
|
|
if(typeof Array.prototype.indexOf != "function")
|
|
{
|
|
Array.prototype.indexOf = function(elt)
|
|
{
|
|
var i = 0;
|
|
while(i < this.length)
|
|
{
|
|
if(this[i] == elt) return i;
|
|
i++;
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
if(typeof Array.prototype.forEach != "function")
|
|
{
|
|
Array.prototype.forEach = function(cb, scope)
|
|
{
|
|
for (var i = 0, n = this.length; i<n; i++)
|
|
if (i in this)
|
|
cb.call(scope, this[i], i, this);
|
|
}
|
|
}
|
|
|
|
// Global initialization
|
|
$(function()
|
|
{
|
|
NUT.init.call(NUT);
|
|
});
|