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);
});
