addNames = function(response) {
// All dimensions
var dimensions = arrayClean([].concat(view.columns || [], view.rows || [], view.filters || [])),
metaData = response.metaData,
peIds = metaData[dimConf.period.objectName];
for (var i = 0, dimension; i < dimensions.length; i++) {
dimension = dimensions[i];
for (var j = 0, item; j < dimension.items.length; j++) {
item = dimension.items[j];
if (item.id.indexOf('.') !== -1) {
var ids = item.id.split('.');
item.name = metaData.names[ids[0]] + ' ' + metaData.names[ids[1]];
}
else {
item.name = metaData.names[item.id];
}
}
}
// Period name without changing the id
view.filters[0].items[0].name = metaData.names[peIds[peIds.length - 1]];
};
Layout.prototype.getDimensions = function(includeFilter, isSorted, axes) {
var dimensions = [];
axes = arrayClean(axes ? arrayFrom(axes) : this.getAxes(includeFilter));
axes.forEach(function(axis) {
dimensions = dimensions.concat(axis);
});
return isSorted ? dimensions.sort(function(a, b) {return a.dimension > b.dimension;}) : dimensions;
};
util.layout.getDataDimensionsFromLayout = function(layout) {
var dimensions = arrayClean([].concat(layout.columns || [], layout.rows || [], layout.filters || [])),
ignoreKeys = ['pe', 'ou'],
dataDimensions = [];
for (var i = 0; i < dimensions.length; i++) {
if (!arrayContains(ignoreKeys, dimensions[i].dimension)) {
dataDimensions.push(dimensions[i]);
}
}
return dataDimensions;
};
validateSpecialCases = function(config) {
var dimensions = arrayClean([].concat(config.columns || [], config.rows || [], config.filters || [])),
map = conf.period.integratedRelativePeriodsMap,
dxDim,
peDim,
ouDim;
for (var i = 0, dim; i < dimensions.length; i++) {
dim = dimensions[i];
if (dim.dimension === dimConf.data.objectName) {
dxDim = dim;
}
else if (dim.dimension === dimConf.period.objectName) {
peDim = dim;
}
else if (dim.dimension === dimConf.organisationUnit.objectName) {
ouDim = dim;
}
}
if (!ouDim) {
gis.alert('No organisation units specified');
return;
}
if (dxDim) {
dxDim.items = [dxDim.items[0]];
}
if (peDim) {
peDim.items = [peDim.items[0]];
peDim.items[0].id = map[peDim.items[0].id] ? map[peDim.items[0].id] : peDim.items[0].id;
}
if (config.layer !== 'event') {
config.columns = [dxDim];
//console.log(dxDim);
}
if (config.layer !== 'event') {
config.rows = [ouDim];
}
if (config.layer !== 'event') {
config.filters = [peDim];
}
return config;
};
load = function(dataElements) {
var attributes = attributeStorage[programId],
data = arrayClean([].concat(attributes || [], dataElements || []));
dataElementsByStageStore.loadData(data);
if (layout) {
var dataDimensions = gis.util.layout.getDataDimensionsFromLayout(layout),
records = [];
for (var i = 0, dim, row; i < dataDimensions.length; i++) {
dim = dataDimensions[i];
row = dataElementsByStageStore.getById(dim.dimension);
if (row) {
records.push(Ext.applyIf(dim, row.data));
}
}
selectDataElements(records, layout);
}
};
Layout.prototype.getAxes = function(includeFilter) {
return arrayClean([this.columns, this.rows, (includeFilter ? this.filters : null)]);
};
setMap = function() {
var basemap = gis.map.basemap || 'openStreetMap',
views = gis.map.mapViews,
handler,
layer;
// title
if (gis.dashboard && gis.container && gis.map && gis.map.name) {
gis.container.childNodes[0].innerText = gis.map.name;
}
if (!(isArray(views) && views.length)) {
if (gis.mask) {
gis.mask.hide();
}
gis.alert(GIS.i18n.favorite_outdated_create_new);
return;
}
for (var i = 0, applyView; i < views.length; i++) {
applyView = applyViews ? applyViews[i] : null;
views[i] = gis.api.layout.Layout(views[i], applyView);
}
views = arrayClean(views);
if (!views.length) {
if (gis.mask) {
gis.mask.hide();
}
return;
}
if (gis.viewport && gis.viewport.favoriteWindow && gis.viewport.favoriteWindow.isVisible()) {
gis.viewport.favoriteWindow.destroy();
}
clearAllLayers();
// Add basemap
if (basemap !== 'none' && gis.layer[basemap]) {
layer = gis.layer[basemap];
if (layer.instance) { // Layer instance already exist
gis.instance.addLayer(layer.instance);
} else { // Create and add layer instance
layer.instance = gis.instance.addLayer(layer.config);
}
if (layer.item) {
layer.item.setValue(true, 1);
}
}
// Add views/overlays
for (var i = 0, layout, layer; i < views.length; i++) {
layout = views[i];
layer = gis.layer[layout.layer];
handler = layer.handler(gis, layer);
handler.updateGui = !gis.el;
handler.callBack = callBack;
handler.load(layout);
}
};
Table = function(layout, response, colAxis, rowAxis) {
var t = this,
klass = Table,
dimensionConfig = klass.dimensionConfig,
optionConfig = klass.optionConfig;
// init
var getRoundedHtmlValue,
getTdHtml,
getValue,
roundIf,
getNumberOfDecimals,
prettyPrint,
doColTotals,
doRowTotals,
doColCumulativeTotals,
doRowCumulativeTotals,
doColSubTotals,
doRowSubTotals,
doSortableColumnHeaders,
getColAxisHtmlArray,
getRowHtmlArray,
rowAxisHtmlArray,
getColTotalHtmlArray,
getColCumulativeTotalHtmlArray,
getGrandTotalHtmlArray,
getTotalHtmlArray,
getHtml,
getUniqueFactor = function(xAxis) {
var unique;
if (!xAxis.xItems) {
return null;
}
unique = xAxis.xItems.unique;
if (unique) {
return unique.length < 2 ? 1 : (xAxis.size / unique[0].length);
}
return null;
},
colUniqueFactor = getUniqueFactor(colAxis),
rowUniqueFactor = getUniqueFactor(rowAxis),
valueItems = [],
valueObjects = [],
totalColObjects = [],
cumulativeTotalColObjects = [],
uuidDimUuidsMap = {},
//isLegendSet = isObject(xLayout.legendSet) && isArray(xLayout.legendSet.legends) && xLayout.legendSet.legends.length,
isLegendSet = false,
tdCount = 0,
htmlArray,
dimensionNameMap = dimensionConfig.getDimensionNameMap(),
objectNameMap = dimensionConfig.getObjectNameMap(),
idValueMap = response.getIdValueMap(layout),
sortableIdObjects = []; //todo
getRoundedHtmlValue = function(value, dec) {
dec = dec || 2;
return parseFloat(roundIf(value, 2)).toString();
};
getTdHtml = function(config, metaDataId) {
var color,
bgColor,
legends,
colSpan,
rowSpan,
htmlValue,
displayDensity,
fontSize,
isNumeric = isObject(config) && isString(config.type) && config.type.substr(0,5) === 'value' && !config.empty,
isValue = isNumeric && config.type === 'value',
cls = '',
html = '',
getHtmlValue;
getHtmlValue = function(config) {
var str = config.htmlValue,
n = parseFloat(config.htmlValue);
if (config.collapsed) {
return '';
}
if (isValue) {
if (isBoolean(str)) {
return str;
}
//if (!isNumber(n) || n != str || new Date(str).toString() !== 'Invalid Date') {
if (!isNumber(n) || n != str) {
return str;
}
return n;
}
return str || '';
}
if (!isObject(config)) {
return '';
}
if (config.hidden || config.collapsed) {
return '';
}
// number of cells
tdCount = tdCount + 1;
// background color from legend set
if (isValue && layout.legendSet && layout.legendSet.legends) {
var value = parseFloat(config.value);
legends = layout.legendSet.legends;
for (var i = 0; i < legends.length; i++) {
if (value >= legends[i].startValue && value <= legends[i].endValue) {
color = legends[i].color;
bgColor = legends[i].bgColor;
}
}
}
colSpan = config.colSpan ? 'colspan="' + config.colSpan + '" ' : '';
rowSpan = config.rowSpan ? 'rowspan="' + config.rowSpan + '" ' : '';
htmlValue = getHtmlValue(config);
htmlValue = config.type !== 'dimension' ? prettyPrint(htmlValue, layout.digitGroupSeparator) : htmlValue;
cls += config.hidden ? ' td-hidden' : '';
cls += config.collapsed ? ' td-collapsed' : '';
cls += isValue ? ' pointer' : '';
//cls += bgColor ? ' legend' : (config.cls ? ' ' + config.cls : '');
cls += config.cls ? ' ' + config.cls : '';
// if sorting
if (isString(metaDataId)) {
cls += ' td-sortable';
sortableIdObjects.push({
id: metaDataId,
uuid: config.uuid
});
}
html += '<td ' + (config.uuid ? ('id="' + config.uuid + '" ') : '');
html += ' class="' + cls + '" ' + colSpan + rowSpan;
//if (bgColor && isValue) {
//html += 'style="color:' + bgColor + ';padding:' + displayDensity + '; font-size:' + fontSize + ';"' + '>' + htmlValue + '</td>';
//html += '>';
//html += '<div class="legendCt">';
//html += '<div class="number ' + config.cls + '" style="padding:' + displayDensity + '; padding-right:3px; font-size:' + fontSize + '">' + htmlValue + '</div>';
//html += '<div class="arrowCt ' + config.cls + '">';
//html += '<div class="arrow" style="border-bottom:8px solid transparent; border-right:8px solid ' + bgColor + '"> </div>';
//html += '</div></div></div></td>';
//}
//else {
html += 'style="' +
(color && isValue ? 'color:' + color + '; ' : '') +
(bgColor && isValue ? 'background-color:' + bgColor + '; ' : '') +
'">' + htmlValue + '</td>';
//}
return html;
};
getValue = function(str) {
var n = parseFloat(str);
if (isBoolean(str)) {
return 1;
}
// return string if
// - parsefloat(string) is not a number
// - string is just starting with a number
// - string is a valid date
//if (!isNumber(n) || n != str || new Date(str).toString() !== 'Invalid Date') {
if (!isNumber(n) || n != str) {
return 0;
}
return n;
};
roundIf = function(number, precision) {
number = parseFloat(number);
precision = parseFloat(precision);
if (isNumber(number) && isNumber(precision)) {
var numberOfDecimals = getNumberOfDecimals(number);
return numberOfDecimals > precision ? numberToFixed(number, precision) : number;
}
return number;
};
getNumberOfDecimals = function(number) {
var str = new String(number);
return (str.indexOf('.') > -1) ? (str.length - str.indexOf('.') - 1) : 0;
};
prettyPrint = function(number, separator) {
var oc = optionConfig,
spaceId = oc.getDigitGroupSeparator('space').id,
noneId = oc.getDigitGroupSeparator('none').id;
separator = separator || spaceId;
if (separator === noneId) {
return number;
}
return number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, oc.getDigitGroupSeparatorValueById(separator) || '');
};
doColTotals = function() {
return !!layout.showColTotals;
};
doRowTotals = function() {
return !!layout.showRowTotals;
};
doColCumulativeTotals = function() {
return !!layout.showColCumulativeTotals;
};
doRowCumulativeTotals = function() {
return !!layout.showRowCumulativeTotals;
};
doColSubTotals = function() {
return !!layout.showColSubTotals && rowAxis.type && rowAxis.dims > 1;
};
doRowSubTotals = function() {
return !!layout.showRowSubTotals && colAxis.type && colAxis.dims > 1;
};
doSortableColumnHeaders = function() {
return (rowAxis.type && rowAxis.dims === 1);
};
getColAxisHtmlArray = function() {
var a = [],
columnDimensionNames = colAxis.type ? layout.columns.getDimensionNames(response) : [],
rowDimensionNames = rowAxis.type ? layout.rows.getDimensionNames(response) : [],
getEmptyNameTdConfig,
getEmptyHtmlArray;
getEmptyNameTdConfig = function(config) {
config = config || {};
return getTdHtml({
cls: config.cls ? ' ' + config.cls : 'pivot-empty',
colSpan: config.colSpan ? config.colSpan : 1,
rowSpan: config.rowSpan ? config.rowSpan : 1,
htmlValue: config.htmlValue ? config.htmlValue : ' '
});
};
getEmptyHtmlArray = function(i) {
var a = [];
// if not the intersection cell
if (i < colAxis.dims - 1) {
if (rowAxis.type && rowAxis.dims) {
for (var j = 0; j < rowAxis.dims - 1; j++) {
a.push(getEmptyNameTdConfig({
cls: 'pivot-dim-label'
}));
}
}
a.push(getEmptyNameTdConfig({
cls: 'pivot-dim-label',
htmlValue: response.getNameById(columnDimensionNames[i]) // objectNameMap[columnDimensionNames[i]].name
}));
}
else {
if (rowAxis.type && rowAxis.dims) {
for (var j = 0; j < rowAxis.dims - 1; j++) {
a.push(getEmptyNameTdConfig({
cls: 'pivot-dim-label',
htmlValue: response.getNameById(rowDimensionNames[j]) //(objectNameMap[rowDimensionNames[j]] || {}).name
}));
}
}
a.push(getEmptyNameTdConfig({
cls: 'pivot-dim-label',
htmlValue: response.getNameById(rowDimensionNames[j]) + (colAxis.type && rowAxis.type ? ' / ' : '') + response.getNameById(columnDimensionNames[i])
}));
}
return a;
};
if (!colAxis.type) {
// show row dimension labels
if (rowAxis.type && layout.showDimensionLabels) {
var dimLabelHtml = [];
// labels from row object names
for (var i = 0; i < rowDimensionNames.length; i++) {
dimLabelHtml.push(getEmptyNameTdConfig({
cls: 'pivot-dim-label',
htmlValue: response.getNameById(rowDimensionNames[i])
}));
}
// pivot-transparent-column unnecessary
a.push(dimLabelHtml);
}
return a;
}
// for each col dimension
for (var i = 0, dimHtml; i < colAxis.dims; i++) {
dimHtml = [];
if (layout.showDimensionLabels) {
dimHtml = dimHtml.concat(getEmptyHtmlArray(i));
}
else if (i === 0) {
dimHtml.push(colAxis.type && rowAxis.type ? getEmptyNameTdConfig({
colSpan: rowAxis.dims,
rowSpan: colAxis.dims
}) : '');
}
for (var j = 0, obj, spanCount = 0, condoId, totalId; j < colAxis.size; j++) {
spanCount++;
condoId = null;
totalId = null;
obj = colAxis.objects.all[i][j];
obj.type = 'dimension';
obj.cls = 'pivot-dim';
obj.noBreak = false;
obj.hidden = !(obj.rowSpan || obj.colSpan);
obj.htmlValue = response.getItemName(obj.id, layout.showHierarchy, true);
// sortable column headers. last dim only.
if (i === colAxis.dims - 1 && doSortableColumnHeaders()) {
//condoId = colAxis.ids[j].split('-').join('');
condoId = colAxis.ids[j];
}
dimHtml.push(getTdHtml(obj, condoId));
if (i === 0 && spanCount === colAxis.span[i] && doRowSubTotals() ) {
dimHtml.push(getTdHtml({
type: 'dimensionSubtotal',
cls: 'pivot-dim-subtotal cursor-default',
rowSpan: colAxis.dims,
htmlValue: ' '
}));
spanCount = 0;
}
if (i === 0 && (j === colAxis.size - 1) && doRowTotals()) {
totalId = doSortableColumnHeaders() ? 'total' : null;
dimHtml.push(getTdHtml({
uuid: uuid(),
type: 'dimensionTotal',
cls: 'pivot-dim-total',
rowSpan: colAxis.dims,
htmlValue: 'Total'
}, totalId));
}
if (i === 0 && (j === colAxis.size - 1) && doRowCumulativeTotals()) {
dimHtml.push(getTdHtml({
uuid: uuid(),
type: 'dimensionTotal',
cls: 'pivot-dim-total',
rowSpan: colAxis.dims,
htmlValue: 'Cumulative Total'
}, null));
}
}
a.push(dimHtml);
}
return a;
};
getRowHtmlArray = function() {
var a = [],
axisAllObjects = [],
xValueObjects,
totalValueObjects = [],
cumulativeTotalValueObjects = [],
mergedObjects = [],
valueItemsCopy,
colAxisSize = colAxis.type ? colAxis.size : 1,
rowAxisSize = rowAxis.type ? rowAxis.size : 1,
recursiveReduce;
recursiveReduce = function(obj) {
if (!obj.children) {
obj.collapsed = true;
if (obj.parent) {
obj.parent.oldestSibling.children--;
}
}
if (obj.parent) {
recursiveReduce(obj.parent.oldestSibling);
}
};
// dimension
if (rowAxis.type) {
for (var i = 0, row; i < rowAxis.size; i++) {
row = [];
for (var j = 0, obj, newObj; j < rowAxis.dims; j++) {
obj = rowAxis.objects.all[j][i];
obj.type = 'dimension';
obj.cls = 'pivot-dim td-nobreak' + (layout.showHierarchy ? ' align-left' : '');
obj.noBreak = true;
obj.hidden = !(obj.rowSpan || obj.colSpan);
obj.htmlValue = response.getItemName(obj.id, layout.showHierarchy, true);
row.push(obj);
}
axisAllObjects.push(row);
}
}
else {
if (layout.showDimensionLabels) {
axisAllObjects.push([{
type: 'transparent',
cls: 'pivot-transparent-row'
}]);
}
}
//axisAllObjects = [ [ dim, dim ]
// [ dim, dim ]
// [ dim, dim ]
// [ dim, dim ] ];
// value
for (var i = 0, valueItemsRow, valueObjectsRow; i < rowAxisSize; i++) {
valueItemsRow = [];
valueObjectsRow = [];
for (var j = 0, rric, value, responseValue, htmlValue, empty, _uuid, uuids; j < colAxisSize; j++) {
rric = new ResponseRowIdCombination();
empty = false;
uuids = [];
// meta data uid
rric.add(colAxis.type ? colAxis.ids[j] : '');
rric.add(rowAxis.type ? rowAxis.ids[i] : '');
// value html element id
_uuid = uuid();
// get uuids array from colaxis/rowaxis leaf
if (colAxis.type) {
uuids = uuids.concat(colAxis.objects.all[colAxis.dims - 1][j].uuids);
}
if (rowAxis.type) {
uuids = uuids.concat(rowAxis.objects.all[rowAxis.dims - 1][i].uuids);
}
// value, htmlValue
responseValue = idValueMap[rric.get()];
if (isDefined(responseValue)) {
value = getValue(responseValue);
htmlValue = responseValue;
}
else {
value = 0;
htmlValue = ' ';
empty = true;
}
valueItemsRow.push(value);
valueObjectsRow.push({
uuid: _uuid,
type: 'value',
cls: 'pivot-value' + (empty ? ' cursor-default' : ''),
value: value,
htmlValue: htmlValue,
empty: empty,
uuids: uuids
});
// map element id to dim element ids
uuidDimUuidsMap[_uuid] = uuids;
}
valueItems.push(valueItemsRow);
valueObjects.push(valueObjectsRow);
}
// totals
if (colAxis.type && doRowTotals()) {
for (var i = 0, empty = [], total = 0; i < valueObjects.length; i++) {
for (j = 0, obj; j < valueObjects[i].length; j++) {
obj = valueObjects[i][j];
empty.push(obj.empty);
total += obj.value;
}
// row totals
totalValueObjects.push({
type: 'valueTotal',
cls: 'pivot-value-total',
value: total,
htmlValue: arrayContains(empty, false) ? getRoundedHtmlValue(total) : '',
empty: !arrayContains(empty, false)
});
// add row totals to idValueMap to make sorting on totals possible
if (doSortableColumnHeaders()) {
var totalIdComb = new ResponseRowIdCombination(['total', rowAxis.ids[i]]),
isEmpty = !arrayContains(empty, false);
idValueMap[totalIdComb.get()] = isEmpty ? null : total;
}
empty = [];
total = 0;
}
}
// cumulative totals
if (colAxis.type && doRowCumulativeTotals()) {
for (var i = 0, empty = [], total = 0; i < valueObjects.length; i++) {
for (j = 0, obj; j < valueObjects[i].length; j++) {
obj = valueObjects[i][j];
empty.push(obj.empty);
total += obj.value;
}
cumulativeTotalValueObjects.push({
type: 'valueTotal',
cls: 'pivot-value-total',
value: total,
htmlValue: arrayContains(empty, false) ? getRoundedHtmlValue(total) : '',
empty: !arrayContains(empty, false)
});
empty = [];
}
}
// hide empty rows (dims/values/totals)
if (colAxis.type && rowAxis.type) {
if (layout.hideEmptyRows) {
for (var i = 0, valueRow, isValueRowEmpty, dimLeaf; i < valueObjects.length; i++) {
valueRow = valueObjects[i];
isValueRowEmpty = !arrayContains(arrayPluck(valueRow, 'empty'), false);
// if value row is empty
if (isValueRowEmpty) {
// hide values by adding collapsed = true to all items
for (var j = 0; j < valueRow.length; j++) {
valueRow[j].collapsed = true;
}
// hide totals by adding collapsed = true to all items
if (doRowTotals()) {
totalValueObjects[i].collapsed = true;
}
// hide cumulative totals by adding collapsed = true to all items
if (doRowCumulativeTotals()) {
cumulativeTotalValueObjects[i].collapsed = true;
}
// hide/reduce parent dim span
dimLeaf = axisAllObjects[i][rowAxis.dims-1];
recursiveReduce(dimLeaf);
}
}
}
}
xValueObjects = valueObjects;
// col subtotals
if (doRowSubTotals()) {
var tmpValueObjects = [];
for (var i = 0, row, rowSubTotal, colCount; i < xValueObjects.length; i++) {
row = [];
rowSubTotal = 0;
colCount = 0;
for (var j = 0, item, collapsed = [], empty = []; j < xValueObjects[i].length; j++) {
item = xValueObjects[i][j];
rowSubTotal += item.value;
empty.push(!!item.empty);
collapsed.push(!!item.collapsed);
colCount++;
row.push(item);
if (colCount === colUniqueFactor) {
var isEmpty = !arrayContains(empty, false);
row.push({
type: 'valueSubtotal',
cls: 'pivot-value-subtotal' + (isEmpty ? ' cursor-default' : ''),
value: rowSubTotal,
htmlValue: isEmpty ? ' ' : getRoundedHtmlValue(rowSubTotal),
empty: isEmpty,
collapsed: !arrayContains(collapsed, false)
});
colCount = 0;
rowSubTotal = 0;
empty = [];
collapsed = [];
}
}
tmpValueObjects.push(row);
}
xValueObjects = tmpValueObjects;
}
// row subtotals
if (doColSubTotals()) {
var tmpAxisAllObjects = [],
tmpValueObjects = [],
tmpTotalValueObjects = [],
getAxisSubTotalRow;
getAxisSubTotalRow = function(collapsed) {
var row = [];
for (var i = 0, obj; i < rowAxis.dims; i++) {
obj = {};
obj.type = 'dimensionSubtotal';
obj.cls = 'pivot-dim-subtotal cursor-default';
obj.collapsed = arrayContains(collapsed, true);
if (i === 0) {
obj.htmlValue = ' ';
obj.colSpan = rowAxis.dims;
}
else {
obj.hidden = true;
}
row.push(obj);
}
return row;
};
// tmpAxisAllObjects
for (var i = 0, row, collapsed = []; i < axisAllObjects.length; i++) {
tmpAxisAllObjects.push(axisAllObjects[i]);
collapsed.push(!!axisAllObjects[i][0].collapsed);
// insert subtotal after last objects
if (!isArray(axisAllObjects[i+1]) || !!axisAllObjects[i+1][0].root) {
tmpAxisAllObjects.push(getAxisSubTotalRow(collapsed));
collapsed = [];
}
}
// tmpValueObjects
for (var i = 0; i < tmpAxisAllObjects.length; i++) {
tmpValueObjects.push([]);
}
for (var i = 0; i < xValueObjects[0].length; i++) {
for (var j = 0, rowCount = 0, tmpCount = 0, subTotal = 0, empty = [], collapsed, item; j < xValueObjects.length; j++) {
item = xValueObjects[j][i];
tmpValueObjects[tmpCount++].push(item);
subTotal += item.value;
empty.push(!!item.empty);
rowCount++;
if (axisAllObjects[j][0].root) {
collapsed = !!axisAllObjects[j][0].collapsed;
}
if (!isArray(axisAllObjects[j+1]) || axisAllObjects[j+1][0].root) {
var isEmpty = !arrayContains(empty, false);
tmpValueObjects[tmpCount++].push({
type: item.type === 'value' ? 'valueSubtotal' : 'valueSubtotalTotal',
value: subTotal,
htmlValue: isEmpty ? ' ' : getRoundedHtmlValue(subTotal),
collapsed: collapsed,
cls: (item.type === 'value' ? 'pivot-value-subtotal' : 'pivot-value-subtotal-total') + (isEmpty ? ' cursor-default' : '')
});
rowCount = 0;
subTotal = 0;
empty = [];
}
}
}
// tmpTotalValueObjects
for (var i = 0, obj, collapsed = [], empty = [], subTotal = 0, count = 0; i < totalValueObjects.length; i++) {
obj = totalValueObjects[i];
tmpTotalValueObjects.push(obj);
collapsed.push(!!obj.collapsed);
empty.push(!!obj.empty);
subTotal += obj.value;
count++;
if (count === rowAxis.span[0]) {
var isEmpty = !arrayContains(empty, false);
tmpTotalValueObjects.push({
type: 'valueTotalSubgrandtotal',
cls: 'pivot-value-total-subgrandtotal' + (isEmpty ? ' cursor-default' : ''),
value: subTotal,
htmlValue: isEmpty ? ' ' : getRoundedHtmlValue(subTotal),
empty: isEmpty,
collapsed: !arrayContains(collapsed, false)
});
collapsed = [];
empty = [];
subTotal = 0;
count = 0;
}
}
axisAllObjects = tmpAxisAllObjects;
xValueObjects = tmpValueObjects;
totalValueObjects = tmpTotalValueObjects;
}
// merge dim, value, total
for (var i = 0, row; i < xValueObjects.length; i++) {
row = [];
//if (rowAxis) {
row = row.concat(axisAllObjects[i]);
//}
row = row.concat(xValueObjects[i]);
if (colAxis.type) {
row = row.concat(totalValueObjects[i]);
row = row.concat(cumulativeTotalValueObjects[i]);
}
mergedObjects.push(row);
}
// create html items
for (var i = 0, row; i < mergedObjects.length; i++) {
row = [];
for (var j = 0; j < mergedObjects[i].length; j++) {
row.push(getTdHtml(mergedObjects[i][j]));
}
a.push(row);
}
return a;
};
getColTotalHtmlArray = function() {
var a = [];
if (rowAxis.type && doColTotals()) {
var xTotalColObjects;
// total col items
for (var i = 0, total = 0, empty = []; i < valueObjects[0].length; i++) {
for (var j = 0, obj; j < valueObjects.length; j++) {
obj = valueObjects[j][i];
total += obj.value;
empty.push(!!obj.empty);
}
// col total
totalColObjects.push({
type: 'valueTotal',
value: total,
htmlValue: arrayContains(empty, false) ? getRoundedHtmlValue(total) : '',
empty: !arrayContains(empty, false),
cls: 'pivot-value-total'
});
total = 0;
empty = [];
}
xTotalColObjects = totalColObjects;
if (colAxis.type && doRowSubTotals()) {
var tmp = [];
for (var i = 0, item, subTotal = 0, empty = [], colCount = 0; i < xTotalColObjects.length; i++) {
item = xTotalColObjects[i];
tmp.push(item);
subTotal += item.value;
empty.push(!!item.empty);
colCount++;
if (colCount === colUniqueFactor) {
tmp.push({
type: 'valueTotalSubgrandtotal',
value: subTotal,
htmlValue: arrayContains(empty, false) ? getRoundedHtmlValue(subTotal) : '',
empty: !arrayContains(empty, false),
cls: 'pivot-value-total-subgrandtotal'
});
subTotal = 0;
colCount = 0;
}
}
xTotalColObjects = tmp;
}
// total col html items
for (var i = 0; i < xTotalColObjects.length; i++) {
a.push(getTdHtml(xTotalColObjects[i]));
}
}
return a;
};
getColCumulativeTotalHtmlArray = function() {
var a = [];
if (rowAxis.type && doColCumulativeTotals()) {
// total col items
for (var i = 0, total = 0, empty = []; i < valueObjects[0].length; i++) {
for (var j = 0, obj; j < valueObjects.length; j++) {
obj = valueObjects[j][i];
total += obj.value;
empty.push(!!obj.empty);
}
// col total
cumulativeTotalColObjects.push({
type: 'valueTotal',
value: total,
htmlValue: arrayContains(empty, false) ? getRoundedHtmlValue(total) : '',
empty: !arrayContains(empty, false),
cls: 'pivot-value-total'
});
empty = [];
}
for (var i = 0; i < cumulativeTotalColObjects.length; i++) {
a.push(getTdHtml(cumulativeTotalColObjects[i]));
}
}
return a;
}
getGrandTotalHtmlArray = function() {
var total = 0,
empty = [],
a = [];
if (doRowTotals() && doColTotals()) {
for (var i = 0, obj; i < totalColObjects.length; i++) {
obj = totalColObjects[i];
total += obj.value;
empty.push(obj.empty);
}
if (colAxis.type && rowAxis.type) {
a.push(getTdHtml({
type: 'valueGrandTotal',
cls: 'pivot-value-grandtotal',
value: total,
htmlValue: arrayContains(empty, false) ? getRoundedHtmlValue(total) : '',
empty: !arrayContains(empty, false)
}));
}
}
return a;
};
getTotalHtmlArray = function() {
var dimTotalArray,
colTotal = getColTotalHtmlArray(),
grandTotal = getGrandTotalHtmlArray(),
cumulativeTotal = getColCumulativeTotalHtmlArray(),
row,
a = [];
if (doColTotals()) {
if (rowAxis.type) {
dimTotalArray = [getTdHtml({
type: 'dimensionSubtotal',
cls: 'pivot-dim-total',
colSpan: rowAxis.dims,
htmlValue: 'Total'
})];
}
row = [].concat(dimTotalArray || [], colTotal || [], grandTotal || []);
a.push(row);
}
if (doColCumulativeTotals()) {
if (rowAxis.type) {
dimTotalArray = [getTdHtml({
type: 'dimensionSubtotal',
cls: 'pivot-dim-total',
colSpan: rowAxis.dims,
htmlValue: 'Cumulative Total'
})];
}
row = [].concat(dimTotalArray || [], cumulativeTotal || []);
a.push(row);
}
return a;
};
getHtml = function() {
var cls = 'pivot',
table;
cls += layout.displayDensity && layout.displayDensity !== optionConfig.getDisplayDensity('normal').id ? ' displaydensity-' + layout.displayDensity : '';
cls += layout.fontSize && layout.fontSize !== optionConfig.getFontSize('normal').id ? ' fontsize-' + layout.fontSize : '';
table = '<table class="' + cls + '">';
for (var i = 0; i < htmlArray.length; i++) {
table += '<tr>' + htmlArray[i].join('') + '</tr>';
}
return table += '</table>';
};
// get html
htmlArray = arrayClean([].concat(getColAxisHtmlArray() || [], getRowHtmlArray() || [], getTotalHtmlArray() || []));
// constructor
t.html = getHtml(htmlArray);
t.uuidDimUuidsMap = uuidDimUuidsMap;
t.sortableIdObjects = sortableIdObjects;
t.idValueMap = idValueMap;
t.layout = layout;
t.response = response;
t.colAxis = colAxis;
t.rowAxis = rowAxis;
t.tdCount = tdCount;
};
util.map.map2plugin = function(map) {
map.url = init.contextPath;
if (map.id) {
return {id: map.id};
}
delete map.access;
delete map.created;
//delete lastUpdated;
//delete name;
for (var i = 0, dimensions, layout; i < map.mapViews.length; i++) {
layout = map.mapViews[i];
dimensions = arrayClean([].concat(layout.columns || [], layout.rows || [], layout.filters || []));dimension = dimensions[i];
for (var j = 0, dimension; j < dimensions.length; j++) {
dimension = dimensions[j];
delete dimension.id;
delete dimension.ids;
delete dimension.type;
delete dimension.dimensionName;
delete dimension.objectName;
for (var k = 0, item; k < dimension.items.length; k++) {
item = dimension.items[k];
delete item.name;
delete item.code;
delete item.created;
delete item.lastUpdated;
}
}
if (layout.legendSet) {
delete layout.method;
delete layout.classes;
delete layout.colorLow;
delete layout.colorHigh;
delete layout.radiusLow;
delete layout.radiusHigh;
}
else {
if (layout.method === 2) {
delete layout.method;
}
if (layout.classes === 5) {
delete layout.classes;
}
if (layout.colorLow === 'ff0000') {
delete layout.colorLow;
}
if (layout.colorHigh === '00ff00') {
delete layout.colorHigh;
}
if (layout.radiusLow === 5) {
delete layout.radiusLow;
}
if (layout.radiusHigh === 15) {
delete layout.radiusHigh;
}
}
if (layout.opacity === gis.conf.layout.layer.opacity) {
delete layout.opacity;
}
if (!layout.userOrganisationUnit) {
delete layout.userOrganisationUnit;
}
if (!layout.userOrganisationUnitChildren) {
delete layout.userOrganisationUnitChildren;
}
if (!layout.userOrganisationUnitGrandChildren) {
delete layout.userOrganisationUnitGrandChildren;
}
if (!layout.organisationUnitGroupSet) {
delete layout.organisationUnitGroupSet;
}
delete layout.parentGraphMap;
}
return map;
};
return function() {
var objectNames = [],
dimConf = conf.finals.dimension,
isOu = false,
isOuc = false,
isOugc = false;
config = validateSpecialCases(config);
if (!config) {
return;
}
config.columns = getValidatedDimensionArray(config.columns);
config.rows = getValidatedDimensionArray(config.rows);
config.filters = getValidatedDimensionArray(config.filters);
if (!config.rows) {
console.log('Organisation unit dimension is invalid', config.rows);
return;
}
if (arrayContains([gis.layer.thematic1.id, gis.layer.thematic2.id, gis.layer.thematic3.id, gis.layer.thematic4.id], config.layer)) {
if (!config.columns) {
return;
}
}
// Collect object names and user orgunits
for (var i = 0, dim, dims = arrayClean([].concat(config.columns, config.rows, config.filters)); i < dims.length; i++) {
dim = dims[i];
if (dim) {
// Object names
if (isString(dim.dimension)) {
objectNames.push(dim.dimension);
}
// user orgunits
if (dim.dimension === dimConf.organisationUnit.objectName && isArray(dim.items)) {
for (var j = 0; j < dim.items.length; j++) {
if (dim.items[j].id === 'USER_ORGUNIT') {
isOu = true;
}
else if (dim.items[j].id === 'USER_ORGUNIT_CHILDREN') {
isOuc = true;
}
else if (dim.items[j].id === 'USER_ORGUNIT_GRANDCHILDREN') {
isOugc = true;
}
}
}
}
}
// Layout
layout.columns = config.columns;
layout.rows = config.rows;
layout.filters = config.filters;
// program
if (isObject(config.program) && config.program.id) {
layout.program = config.program;
}
// program stage
if (isObject(config.programStage) && config.programStage.id) {
layout.programStage = config.programStage;
}
if (config.startDate) {
layout.startDate = config.startDate.substring(0, 10);
}
if (config.endDate) {
layout.endDate = config.endDate.substring(0, 10);
}
if (config.valueType) {
layout.valueType = config.valueType;
}
if (config.eventClustering) {
layout.eventClustering = config.eventClustering;
}
if (config.eventPointColor) {
layout.eventPointColor = config.eventPointColor;
}
if (config.eventPointRadius) {
layout.eventPointRadius = config.eventPointRadius;
}
// Properties
layout.layer = isString(config.layer) && !isEmpty(config.layer) ? config.layer : 'thematic1';
layout.classes = isNumber(config.classes) && !isEmpty(config.classes) ? config.classes : 5;
layout.method = isNumber(config.method) && !isEmpty(config.method) ? config.method : 2;
layout.colorLow = isString(config.colorLow) && !isEmpty(config.colorLow) ? config.colorLow : 'ff0000';
layout.colorHigh = isString(config.colorHigh) && !isEmpty(config.colorHigh) ? config.colorHigh : '00ff00';
layout.radiusLow = isNumber(config.radiusLow) && !isEmpty(config.radiusLow) ? config.radiusLow : 5;
layout.radiusHigh = isNumber(config.radiusHigh) && !isEmpty(config.radiusHigh) ? config.radiusHigh : 15;
layout.opacity = isNumber(config.opacity) && !isEmpty(config.opacity) ? config.opacity : gis.conf.layout.layer.opacity;
layout.areaRadius = config.areaRadius;
layout.labels = !!config.labels;
layout.labelFontSize = config.labelFontSize || '11px';
layout.labelFontSize = parseInt(layout.labelFontSize) + 'px';
layout.labelFontWeight = isString(config.labelFontWeight) || isNumber(config.labelFontWeight) ? config.labelFontWeight : 'normal';
layout.labelFontWeight = arrayContains(['normal', 'bold', 'bolder', 'lighter'], layout.labelFontWeight) ? layout.labelFontWeight : 'normal';
layout.labelFontWeight = isNumber(parseInt(layout.labelFontWeight)) && parseInt(layout.labelFontWeight) <= 1000 ? layout.labelFontWeight.toString() : layout.labelFontWeight;
layout.labelFontStyle = arrayContains(['normal', 'italic', 'oblique'], config.labelFontStyle) ? config.labelFontStyle : 'normal';
layout.labelFontColor = isString(config.labelFontColor) || isNumber(config.labelFontColor) ? config.labelFontColor : 'normal';
layout.labelFontColor = isNumber(layout.labelFontColor) ? layout.labelFontColor.toString() : layout.labelFontColor;
layout.labelFontColor = layout.labelFontColor.charAt(0) !== '#' ? '#' + layout.labelFontColor : layout.labelFontColor;
layout.hidden = !!config.hidden;
layout.userOrganisationUnit = isOu;
layout.userOrganisationUnitChildren = isOuc;
layout.userOrganisationUnitGrandChildren = isOugc;
layout.parentGraphMap = isObject(config.parentGraphMap) ? config.parentGraphMap : null;
layout.legendSet = config.legendSet;
layout.organisationUnitGroupSet = config.organisationUnitGroupSet;
layout.dataDimensionItems = config.dataDimensionItems;
layout.key = config.key; // Earth Engine layer
if (arrayFrom(config.userOrgUnit).length) {
layout.userOrgUnit = arrayFrom(config.userOrgUnit);
}
// relative period date
if (util.date.getYYYYMMDD(config.relativePeriodDate)) {
layout.relativePeriodDate = support.prototype.date.getYYYYMMDD(config.relativePeriodDate);
}
return Ext.apply(layout, forceApplyConfig);
}();
util.geojson.decode = function(organisationUnits, levelOrder) {
var features = [];
levelOrder = levelOrder || 'ASC';
// sort
util.array.sort(organisationUnits, levelOrder, 'le');
for (var i = 0, ou, coord, gpid = '', gppg = '', type; i < organisationUnits.length; i++) {
ou = organisationUnits[i];
coord = JSON.parse(ou.co);
// Only add features with coordinates
if (coord && coord.length) {
type = 'Point';
if (ou.ty === 2) {
type = 'Polygon';
if (ou.co.substring(0, 4) === '[[[[') {
type = 'MultiPolygon';
}
}
// grand parent
if (isString(ou.pg) && ou.pg.length) {
var ids = arrayClean(ou.pg.split('/'));
// grand parent id
if (ids.length >= 2) {
gpid = ids[ids.length - 2];
}
// grand parent parentgraph
if (ids.length > 2) {
gppg = '/' + ids.slice(0, ids.length - 2).join('/');
}
}
features.push({
type: 'Feature',
id: ou.id,
geometry: {
type: type,
coordinates: coord
},
properties: {
id: ou.id,
name: ou.na,
hasCoordinatesDown: ou.hcd,
hasCoordinatesUp: ou.hcu,
level: ou.le,
grandParentParentGraph: gppg,
grandParentId: gpid,
parentGraph: ou.pg,
parentId: ou.pi,
parentName: ou.pn
}
});
}
}
return features;
};