ConstructionCost/modules/reports/rpt_component/jpc_cross_tab.js

let JV = require('./jpc_value_define');
let JpcFieldHelper = require('./helper/jpc_helper_field');
let JpcBandHelper = require('./helper/jpc_helper_band');
let JpcBand = require('./jpc_band');
let JpcCrossTabHelper = require('./helper/jpc_helper_cross_tab');
let JpcCommonHelper = require('./helper/jpc_helper_common');
let JpcDiscreteHelper = require('./helper/jpc_helper_discrete');
let JpcTextHelper = require('./helper/jpc_helper_text');
let JpcCommonOutputHelper = require('./helper/jpc_helper_common_output');
let JpcAreaHelper = require('./helper/jpc_helper_area');

let JpcCrossTabSrv = function(){};
JpcCrossTabSrv.prototype.createNew = function(){
    function private_addTabValue(tabValuedIdxLst, sortedSequence, segIdx, preRec, nextRec, dispSerialIdxLst, sorted_sum_value_Lst, rst_sum_value_Lst) {
        if (tabValuedIdxLst) {
            let serial1stTier = null;
            if (dispSerialIdxLst) serial1stTier = [];
            let pgseg1stTier = [];
            let sumVal = [];
            let sumValL = 1;
            if (sortedSequence) {
                let arrDupVals = sortedSequence[segIdx];
                let arrDupSumVals = null;
                if (sorted_sum_value_Lst !== null) {
                    arrDupSumVals = sorted_sum_value_Lst[segIdx];
                    sumValL = arrDupSumVals[0].length;
                }

                for (let i = 0; i < nextRec; i++) {
                    if (arrDupVals.length <= preRec + i) {
                        pgseg1stTier[i] = JV.BLANK_VALUE_INDEX;
                        sumVal[i] = [];
                        for (let ei = 0; ei < sumValL; ei++) {
                            sumVal[i][ei] = null;
                        }
                        if (serial1stTier !== null) {
                            serial1stTier[i] = JV.BLANK_VALUE_INDEX;
                        }
                        continue;
                    }
                    let duplicateValueArr = arrDupVals[preRec + i];
                    pgseg1stTier[i] = duplicateValueArr[0];
                    if (arrDupSumVals !== null) sumVal[i] = arrDupSumVals[preRec + i];

                    if (serial1stTier !== null) {
                        serial1stTier[i] = preRec + i;
                    }
                }
                tabValuedIdxLst.push(pgseg1stTier);
                if (dispSerialIdxLst !== null) {
                    dispSerialIdxLst.push(serial1stTier);
                }
                if (sorted_sum_value_Lst !== null && rst_sum_value_Lst !== null) {
                    rst_sum_value_Lst.push(sumVal);
                }
            } else {
                //should push blank value index rather than null
                for (let i = 0; i < nextRec; i++) {
                    pgseg1stTier[i] = JV.BLANK_VALUE_INDEX;
                    sumVal[i] = null;
                    if (serial1stTier !== null) {
                        serial1stTier[i] = JV.BLANK_VALUE_INDEX;
                    }
                }
                tabValuedIdxLst.push(pgseg1stTier);
                if (dispSerialIdxLst !== null) {
                    dispSerialIdxLst.push(serial1stTier);
                }
                if (sorted_sum_value_Lst !== null && rst_sum_value_Lst !== null) {
                    rst_sum_value_Lst.push(sumVal);
                }
            }
        }
    }
    function private_addContentValue(dispValueIdxLst_Content, sortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, page_seg_map, pageIdx) {
        if (dispValueIdxLst_Content !== null) {
            page_seg_map.push([pageIdx,segIdx]);
            let arrContents = [];
            if (sortedContentSequence !== null) {
                let arrAllContent = sortedContentSequence[segIdx];
                for (let i = 0; i < maxRowRec; i++) {
                    arrContents.push([]);
                    for (let j = 0; j < maxColRec; j++) {
                        if (arrAllContent.length <= counterRowRec + i || arrAllContent[counterRowRec + i].length <= counterColRec + j) {
                            arrContents[i][j] = JV.BLANK_VALUE_INDEX;
                        } else {
                            arrContents[i][j] = arrAllContent[counterRowRec + i][counterColRec + j];
                        }
                    }
                }
                dispValueIdxLst_Content.push(arrContents);
            } else {
                //should push blank value index rather than null
                for (let i = 0; i < maxRowRec; i++) {
                    arrContents.push([]);
                    for (let j = 0; j < maxColRec; j++) {
                        arrContents[i][j] = JV.BLANK_VALUE_INDEX;
                    }
                }
                dispValueIdxLst_Content.push(arrContents);
            }
        }
    }
    function private_SortAndOptimize(rptTpl, dataObj, dataSeq, sortTab, rstFieldsIdx) {
        let result = [];
        let tab = rptTpl[JV.NODE_CROSS_INFO][sortTab];
        if (tab) {
            let sIDX = 0;
            //1. prepare and sort by tab-field
            let fields = [];
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, tab[JV.TAB_CROSS_FIELDS], fields, rstFieldsIdx);
            let data_details = dataObj[JV.DATA_DETAIL_DATA];
            JpcCrossTabHelper.sortTabFields(fields, rstFieldsIdx, data_details, dataSeq);
            //2. distinguish sort tab fields value
            let b1 = false;
            for (let i = 0; i < dataSeq.length; i++) {
                sIDX = 0;
                let segArr = [];
                if (dataSeq[i].length === 1) {
                    JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, 0, 1);
                } else {
                    for (let j = 1; j < dataSeq[i].length; j++) {
                        b1 = false;
                        for (let k = 0; k < rstFieldsIdx.length; k++) {
                            if (data_details[rstFieldsIdx[k]][dataSeq[i][j - 1]] !== data_details[rstFieldsIdx[k]][dataSeq[i][j]]) {
                                b1 = true;
                                break;
                            }
                        }
                        if (b1) {
                            JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, sIDX, j);
                            sIDX = j;
                            if (j === dataSeq[i].length - 1) {
                                JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, j, dataSeq[i].length);
                            }
                        } else if (j === dataSeq[i].length - 1) {
                            JpcCrossTabHelper.pushToSeg(segArr, dataSeq, i, sIDX, dataSeq[i].length);
                        }
                    }
                }
                if (segArr.length > 0) result.push(segArr);
            }
        }
        return result;
    }
    function private_SortForDisplayContent(rptTpl, rowSeq, colSeq, rstFieldsIdx){
        let result = [];
        let tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_CONTENT];
        if (tab) {
            JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, tab[JV.TAB_CROSS_FIELDS], null, rstFieldsIdx);
        }
        for (let i = 0; i < rowSeq.length; i++) {
            let rl = rowSeq[i], cl = colSeq[i];
            let ds = [];
            //1. initialize to blank value index
            for (let j = 0; j < rl.length; j++) {
                ds.push([]);
                for (let k = 0; k < cl.length; k++) {
                    ds[j].push(JV.BLANK_VALUE_INDEX);
                }
            }
            //2. then fill up the right index
            for (let j = 0; j < rl.length; j++) {
                let ra = rl[j];
                for (let k = 0; k < ra.length; k++) {
                    let colIdx = JpcCrossTabHelper.getColIDX(cl, ra[k]);
                    if (colIdx >= 0) {
                        ds[j][colIdx] = ra[k];
                    }
                }
            }
            result.push(ds);
        }
        return result;
    }

    let JpcCrossTabResult = {};
    JpcCrossTabResult.initialize = function() {
        let me = this;
        me.dispValueIdxLst_Row = [];
        me.dispValueIdxLst_Col = [];
        me.dispValueIdxLst_Content = [];
        me.dispSerialIdxLst_Row = [];
        me.col_sum_fields_idx = [];
        me.col_sum_fields_value_total = [];
        me.dispSumValueLst_Col = [];
        me.page_seg_map = [];
        me.row_fields_idx = [];
        me.col_fields_idx = [];
        me.content_fields_idx = [];
        me.row_extension_fields_idx = [];
        me.row_sum_extension_fields_idx = [];
        me.crsOrient = JV.PAGE_ORIENTATION_V_FIRST;
        me.pageStatusLst = [];
        me.paging_option = JV.PAGING_OPTION_NORMAL;
    };
    JpcCrossTabResult.sorting = function(rptTpl, dataObj, dataSeq) {
        let me = this;
        //IMPORTANT: the data should be sorted in SQL/NoSQL level!
        me.sortedRowSequence = private_SortAndOptimize(rptTpl, dataObj, dataSeq, JV.NODE_CROSS_ROW, me.row_fields_idx);
        me.sortedColSequence = private_SortAndOptimize(rptTpl, dataObj, dataSeq, JV.NODE_CROSS_COL, me.col_fields_idx);
        me.sortedContentSequence = private_SortForDisplayContent(rptTpl, me.sortedRowSequence, me.sortedColSequence, me.content_fields_idx);
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_COL_SUM][JV.TAB_CROSS_FIELDS], null, me.col_sum_fields_idx);
        //pre-sum the data(for col sum display)
        let data_details = dataObj[JV.DATA_DETAIL_DATA],
            data_fields = [];
        for (let i = 0; i < me.col_sum_fields_idx.length; i++) {
            let data_field = data_details[me.col_sum_fields_idx[i]];
            data_fields.push(data_field);
        }
        for (let i = 0; i < me.sortedRowSequence.length; i++) { //seg level
            if (me.sortedRowSequence[i].length > 0) {
                me.col_sum_fields_value_total.push([]);
                for (let j = 0; j < me.sortedRowSequence[i].length; j++) {
                    let rowGrandTotal = [];
                    for (let di = 0; di < data_fields.length; di++) {
                        rowGrandTotal.push(0.0);
                        for (let k = 0; k < me.sortedRowSequence[i][j].length; k++) {
                            //3. start to sum
                            rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * JpcFieldHelper.getValue(data_fields[di], me.sortedRowSequence[i][j][k]);
                        }
                    }
                    me.col_sum_fields_value_total[i].push(rowGrandTotal);
                }
            }

        }
    };
    JpcCrossTabResult.preSetupPages = function(rptTpl, defProperties, option) {
        let me = this, rst = 0;
        me.paging_option = option||JV.PAGING_OPTION_NORMAL;
        //1. original initialize
        let maxRowRec = 1, maxColRec = 1, counterRowRec = 0, counterColRec = 0, pageIdx = 0, segCnt = me.sortedContentSequence.length;
        let pageStatus = [true, true, false, true, false, false, false, false];
        //2. calculate the page info one by one
        let bands = JpcBand.createNew(rptTpl, defProperties);
        function private_resetBandArea() {
            JpcBandHelper.setBandArea(bands, rptTpl, pageStatus);
            maxRowRec = JpcCrossTabHelper.getMaxRowsPerPage(bands, rptTpl);
            maxColRec = JpcCrossTabHelper.getMaxColsPerPage(bands, rptTpl);
        }
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_EXT][JV.TAB_CROSS_FIELDS], null, me.row_extension_fields_idx);
        JpcFieldHelper.findAndPutDataFieldIdx(rptTpl, rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_SUM_EXT][JV.TAB_CROSS_FIELDS], null, me.row_sum_extension_fields_idx);
        if (me.paging_option === JV.PAGING_OPTION_INFINITY) {
            /*
            rst = segCnt;
            pageStatus[JV.STATUS_SEGMENT_START] = true;
            pageStatus[JV.STATUS_SEGMENT_END] = true;
            pageStatus[JV.STATUS_CROSS_ROW_END] = true;
            pageStatus[JV.STATUS_CROSS_COL_END] = true;
            for (let segIdx = 0; segIdx < segCnt; segIdx++) {
                if (segIdx === segCnt - 1) {
                    pageStatus[JV.STATUS_REPORT_END] = true;
                }
                if (segIdx > 0) {
                    pageStatus[JV.STATUS_REPORT_START] = false;
                }
                me.pageStatusLst.push(pageStatus.slice(0));
                pageIdx++;
                private_addTabValue(me.dispValueIdxLst_Row, me.sortedRowSequence, segIdx, 0, me.sortedRowSequence[segIdx].length, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
                private_addTabValue(me.dispValueIdxLst_Col, me.sortedColSequence, segIdx, 0, me.sortedColSequence[segIdx].length, null, null, null);
                private_addContentValue(me.dispValueIdxLst_Content, me.sortedContentSequence, segIdx, 0, me.sortedRowSequence[segIdx].length, 0, me.sortedColSequence[segIdx].length, me.page_seg_map, pageIdx);
            }
            //*/
        } else {
            for (let segIdx = 0; segIdx < segCnt; segIdx++) {
                //2.1. seg level initialize
                private_resetBandArea();
                let orgMaxRowRec = maxRowRec, orgMaxColRec = maxColRec;
                let rowSplitCnt = Math.ceil(1.0 * me.sortedRowSequence[segIdx].length / maxRowRec);
                let colSplitCnt = Math.ceil(1.0 * me.sortedColSequence[segIdx].length / maxColRec);
                pageStatus[JV.STATUS_CROSS_ROW_END] = true;
                private_resetBandArea();
                let hasAdHocRow = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_ROW_SUM, rptTpl, bands, me.sortedRowSequence, segIdx, (rowSplitCnt - 1) * orgMaxRowRec, maxRowRec);
                if (hasAdHocRow) {
                    hasAdHocRow = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_ROW_EXT, rptTpl, bands, me.sortedRowSequence, segIdx, (rowSplitCnt - 1) * orgMaxRowRec, maxRowRec);
                }
                pageStatus[JV.STATUS_CROSS_ROW_END] = false;
                pageStatus[JV.STATUS_CROSS_COL_END] = true;
                private_resetBandArea();
                let hasAdHocCol = !JpcCrossTabHelper.chkTabEnd(JV.NODE_CROSS_COL_SUM, rptTpl, bands, me.sortedColSequence, segIdx, (colSplitCnt - 1) * orgMaxColRec, maxColRec);
                pageStatus[JV.STATUS_CROSS_COL_END] = false;
                private_resetBandArea();
                if (hasAdHocRow) rowSplitCnt++;
                if (hasAdHocCol) colSplitCnt++;
                //2.2
                for (let colIdx = 0; colIdx < colSplitCnt; colIdx++) {
                    pageStatus[JV.STATUS_CROSS_COL_END] = (colIdx === (colSplitCnt - 1));
                    private_resetBandArea();
                    counterColRec = orgMaxColRec * colIdx;
                    let currentSortedContentSequence = me.sortedContentSequence;
                    let currentSortedColSequence = me.sortedColSequence;
                    if (hasAdHocCol && colIdx === (colSplitCnt - 1)) {
                        currentSortedColSequence = null;
                        currentSortedContentSequence = null;
                        counterColRec = 0;
                    }
                    for (let rowIdx = 0; rowIdx < rowSplitCnt; rowIdx++) {
                        pageStatus[JV.STATUS_CROSS_ROW_END] = (rowIdx === (rowSplitCnt - 1));
                        private_resetBandArea();
                        me.pageStatusLst.push(pageStatus.slice(0));
                        pageIdx++;
                        counterRowRec = orgMaxRowRec * rowIdx;
                        let currentSortedRowSequence = me.sortedRowSequence;
                        if (hasAdHocRow && rowIdx === (rowSplitCnt - 1)) {
                            currentSortedRowSequence = null;
                            currentSortedContentSequence = null;
                            counterRowRec = 0;
                        }
                        private_addTabValue(me.dispValueIdxLst_Row, currentSortedRowSequence, segIdx, counterRowRec, maxRowRec, me.dispSerialIdxLst_Row, me.col_sum_fields_value_total, me.dispSumValueLst_Col);
                        private_addTabValue(me.dispValueIdxLst_Col, currentSortedColSequence, segIdx, counterColRec, maxColRec, null, null, null);
                        private_addContentValue(me.dispValueIdxLst_Content, currentSortedContentSequence, segIdx, counterRowRec, maxRowRec, counterColRec, maxColRec, me.page_seg_map, pageIdx);
                    }
                }
                JpcCrossTabHelper.initialPageStatus(pageStatus);
            }
            //3. set pageSeq and return the result
            rst = pageIdx;
        }
        bands = null;
        return rst;
    };
    JpcCrossTabResult.outputAsSimpleJSONPage = function(rptTpl, dataObj, page, bands, controls, $CURRENT_RPT) {
        let me = this, rst = [], tabRstLst = [];
        let unitFactor = JpcCommonHelper.getUnitFactor(rptTpl);
        if (me.paging_option === JV.PAGING_OPTION_INFINITY) {
            /*
            let segIdx = page - 1;
            //1 calculate the band position
            JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1]);
            //2. then reset the band height
            let tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_CONTENT];
            let crossContentBand = bands[tab[JV.PROP_BAND_NAME]];
            let actH = JpcCrossTabHelper.getActualRowsHeight(bands, rptTpl, me.sortedRowSequence, page);
            let actW = JpcCrossTabHelper.getActualColsWidth(bands, rptTpl, me.sortedColSequence, page);
            let offsetY = actH - (crossContentBand.Bottom - crossContentBand.Top);
            let offsetX = actW - (crossContentBand.Right - crossContentBand.Left);
            JpcBandHelper.resetBandPos(rptTpl[JV.NODE_BAND_COLLECTION], bands, crossContentBand, offsetX, offsetY);

            //2.1 Row-Tab
            tabRstLst.push(me.outputRowTab(rptTpl, dataObj, page, bands, unitFactor, controls));
            //2.2 Col-Tab
            tabRstLst.push(me.outputColTab(rptTpl, dataObj, page, bands, unitFactor, controls));
            //2.3 Content-Tab
            tabRstLst.push(me.outputContent(rptTpl, dataObj, page, bands, unitFactor, controls));
            //2.4 Sum-Tab Row
            //2.4 Sum-tab Col
            tabRstLst.push(me.outputTabSum(rptTpl, dataObj, page, bands, unitFactor, JV.NODE_CROSS_COL_SUM, controls));
            //2.x row tab ext
            tabRstLst.push(me.outputTabExt(rptTpl, dataObj, page, bands, unitFactor, controls));
            tabRstLst.push(me.outputSumTabExt(rptTpl, dataObj, page, bands, unitFactor, segIdx, controls));
            //2.5 Discrete
            tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(rptTpl[JV.NODE_CROSS_INFO][JV.NODE_DISCRETE_INFO], bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, 1, 0, $CURRENT_RPT));
            //*/
        } else {
            let segIdx = JpcCommonHelper.getSegIdxByPageIdx(page, me.page_seg_map);
            //1 calculate the band position
            JpcBandHelper.setBandArea(bands, rptTpl, me.pageStatusLst[page - 1]);
            //2. start to output detail-part
            //2.1 Row-Tab
            tabRstLst.push(me.outputRowTab(rptTpl, dataObj, page, bands, unitFactor, controls));
            //2.2 Col-Tab
            tabRstLst.push(me.outputColTab(rptTpl, dataObj, page, bands, unitFactor, controls));
            //2.3 Content-Tab
            tabRstLst.push(me.outputContent(rptTpl, dataObj, page, bands, unitFactor, controls));
            //2.4 Sum-Tab Row
            //2.4 Sum-tab Col
            tabRstLst.push(me.outputTabSum(rptTpl, dataObj, page, bands, unitFactor, JV.NODE_CROSS_COL_SUM, controls));
            //2.x row tab ext
            tabRstLst.push(me.outputTabExt(rptTpl, dataObj, page, bands, unitFactor, controls));
            tabRstLst.push(me.outputSumTabExt(rptTpl, dataObj, page, bands, unitFactor, segIdx, controls));
            //2.5 Discrete
            tabRstLst.push(JpcDiscreteHelper.outputDiscreteInfo(rptTpl[JV.NODE_CROSS_INFO][JV.NODE_DISCRETE_INFO], bands, dataObj, unitFactor, me.pageStatusLst[page - 1], segIdx, 1, 0, $CURRENT_RPT));
        }
        for (let i = 0; i < tabRstLst.length; i++) {
            rst = rst.concat(tabRstLst[i]);
            tabRstLst[i] = null;
        }
        return rst;
    };
    JpcCrossTabResult.outputRowTab = function(rptTpl, dataObj, page, bands, unitFactor, controls) {
        let me = this, rst = [];
        let tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW];
        let band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                let tab_fields = tab[JV.TAB_CROSS_FIELDS];
                let data_details = dataObj[JV.DATA_DETAIL_DATA];
                let valuesIdx = me.dispValueIdxLst_Row[page - 1];
                let serialsIdx = me.dispSerialIdxLst_Row[page - 1];
                for (let i = 0; i < me.row_fields_idx.length; i++) {
                    let tab_field = tab_fields[i];
                    let data_field = data_details[me.row_fields_idx[i]];
                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        let rows = valuesIdx.length;
                        for (let rowIdx = 0; rowIdx < rows; rowIdx++) {
                            rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[rowIdx], serialsIdx[rowIdx], rows, rowIdx, 1, 0, unitFactor, true, controls));
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputColTab = function(rptTpl, dataObj, page, bands, unitFactor, controls) {
        let me = this, rst = [], firstTextOutput = true;
        let tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_COL];
        let band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                let tab_fields = tab[JV.TAB_CROSS_FIELDS];
                let data_details = dataObj[JV.DATA_DETAIL_DATA];
                let valuesIdx = me.dispValueIdxLst_Col[page - 1];
                for (let i = 0; i < me.col_fields_idx.length; i++) {
                    let tab_field = tab_fields[i];
                    let data_field = data_details[me.col_fields_idx[i]];
                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        let cols = valuesIdx.length;
                        for (let colIdx = 0; colIdx < cols; colIdx++) {
                            rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[colIdx], -1, 1, 0, cols, colIdx, unitFactor, false, controls));
                            //2. output texts
                            if (firstTextOutput) {
                                if (tab[JV.PROP_TEXT]) {
                                    rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                }
                                if (tab[JV.PROP_TEXTS]) {
                                    for (let j = 0; j < tab[JV.PROP_TEXTS].length; j++) {
                                        rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                    }
                                }
                            }
                        }
                        firstTextOutput = false;
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputContent = function (rptTpl, dataObj, page, bands, unitFactor, controls) {
        let me = this, rst = [];
        let tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_CONTENT];
        let band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                let tab_fields = tab[JV.TAB_CROSS_FIELDS];
                let data_details = dataObj[JV.DATA_DETAIL_DATA];
                let contentValuesIdx = me.dispValueIdxLst_Content[page - 1];
                for (let i = 0; i < tab_fields.length; i++) {
                    let tab_field = tab_fields[i];
                    let data_field = data_details[me.content_fields_idx[i]];
                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        let rows = contentValuesIdx.length;
                        for (let rowIdx = 0; rowIdx < rows; rowIdx++) {
                            let cols = contentValuesIdx[rowIdx].length;
                            for (let colIdx = 0; colIdx < cols; colIdx++) {
                                rst.push(me.outputTabField(band, tab_field, data_field, contentValuesIdx[rowIdx][colIdx], -1, rows, rowIdx, cols, colIdx, unitFactor, true, controls));
                            }
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputTabSum = function (rptTpl, dataObj, page, bands, unitFactor, tabNodeName, controls) {
        let me = this, rst = [],
            tab = rptTpl[JV.NODE_CROSS_INFO][tabNodeName],
            band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                let tab_fields = tab[JV.TAB_CROSS_FIELDS];
                for (let i = 0; i < me.dispSumValueLst_Col[page - 1].length; i++) {
                    if (me.dispSumValueLst_Col[page - 1][i] !== null) {
                        for (let j = 0; j < me.dispSumValueLst_Col[page - 1][i].length; j++) {
                            let tab_field = tab_fields[j];
                            let val = me.dispSumValueLst_Col[page - 1][i][j];
                            let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                            cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, me.dispSumValueLst_Col[page - 1].length, i, 1, 0, 1, 0, true, false);
                            rst.push(cellItem);
                        }
                    } else {
                        let sumL = 1;
                        for (let si = 0; si < me.dispSumValueLst_Col.length; si++) {
                            if (me.dispSumValueLst_Col[si][0] !== null) {
                                sumL = me.dispSumValueLst_Col[si][0].length;
                                break;
                            }
                        }
                        for (let j = 0; j < sumL; j++) {
                            let tab_field = tab_fields[j];
                            let val = null;
                            let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                            cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, me.dispSumValueLst_Col[page - 1].length, i, 1, 0, 1, 0, true, false);
                            rst.push(cellItem);
                        }
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputTabExt = function (rptTpl, dataObj, page, bands, unitFactor, controls) {
        let me = this, rst = [], firstTextOutput = true,
            tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_EXT];
        let band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true) {
                let tab_fields = tab[JV.TAB_CROSS_FIELDS],
                    data_details = dataObj[JV.DATA_DETAIL_DATA],
                    valuesIdx = me.dispValueIdxLst_Col[page - 1];
                for (let i = 0; i < me.row_extension_fields_idx.length; i++) {
                    let tab_field = tab_fields[i];
                    let data_field = data_details[me.row_extension_fields_idx[i]];
                    if (!(tab_field[JV.PROP_HIDDEN])) {
                        let cols = valuesIdx.length;
                        for (let colIdx = 0; colIdx < cols; colIdx++) {
                            rst.push(me.outputTabField(band, tab_field, data_field, valuesIdx[colIdx], -1, 1, 0, cols, colIdx, unitFactor, false, controls));
                            //2. output texts if has
                            if (firstTextOutput) {
                                if (tab[JV.PROP_TEXT]) {
                                    rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                }
                                if (tab[JV.PROP_TEXTS]) {
                                    for (let j = 0; j < tab[JV.PROP_TEXTS].length; j++) {
                                        rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, 1, 0, cols, colIdx, 1, 0));
                                    }
                                }
                            }
                        }
                        firstTextOutput = false;
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputSumTabExt = function (rptTpl, dataObj, page, bands, unitFactor, segIdx, controls) {
        let me = this, rst = [],
            tab = rptTpl[JV.NODE_CROSS_INFO][JV.NODE_CROSS_ROW_SUM_EXT];
        let band = bands[tab[JV.PROP_BAND_NAME]];
        if (band) {
            let pageStatus = me.pageStatusLst[page - 1];
            if (pageStatus[band[JV.BAND_PROP_DISPLAY_TYPE]] === true && pageStatus[JV.STATUS_CROSS_ROW_END] === true) {
                let tab_fields = tab[JV.TAB_CROSS_FIELDS],
                    data_details = dataObj[JV.DATA_DETAIL_DATA],
                    data_fields = [];
                for (let i = 0; i < me.row_sum_extension_fields_idx.length; i++) {
                    let data_field = data_details[me.row_sum_extension_fields_idx[i]];
                    data_fields.push(data_field);
                }
                //2. initialize grand total value
                let rowGrandTotal = [];
                for (let di = 0; di < data_fields.length; di++) {
                    rowGrandTotal[di] = 0.0;
                    //3. start to sum
                    for (let i = 0; i < me.sortedColSequence[segIdx].length; i++) {
                        //me.sortedColSequence[segIdx][i][0] //this is the data field value index!
                        rowGrandTotal[di] = rowGrandTotal[di] + 1.0 * JpcFieldHelper.getValue(data_fields[di], me.sortedColSequence[segIdx][i][0]);
                    }
                }
                //4. output
                for (let di = 0; di < tab_fields.length; di++) {
                    let tab_field = tab_fields[di];
                    if (!tab_field[JV.PROP_HIDDEN]) {
                        let val = rowGrandTotal[di];
                        let cellItem = JpcCommonOutputHelper.createCommonOutput(tab_field, val, controls);
                        cellItem[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, 1, 0, 1, 0, 1, 0, false, false);
                        rst.push(cellItem);
                    }
                }
                //output texts if has
                if (tab[JV.PROP_TEXT]) {
                    rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXT], band, unitFactor, 1, 0, 1, 0, 1, 0));
                }
                if (tab[JV.PROP_TEXTS]) {
                    for (let j = 0; j < tab[JV.PROP_TEXTS].length; j++) {
                        rst.push(JpcTextHelper.outputText(tab[JV.PROP_TEXTS][j], band, unitFactor, 1, 0, 1, 0, 1, 0));
                    }
                }
            }
        }
        return rst;
    };
    JpcCrossTabResult.outputTabField = function (band, tab_field, data_field, valueIdx, serialIdx, rows, rowIdx, cols, colIdx, unitFactor, isRow, controls) {
        let rst = null;
        if (isRow === true && tab_field[JV.PROP_IS_SERIAL] && tab_field[JV.PROP_IS_SERIAL] === true) {
            if (serialIdx >= 0) {
                rst = JpcCommonOutputHelper.createCommonOutput(tab_field, serialIdx + 1)
            } else rst = JpcCommonOutputHelper.createCommonOutput(tab_field, "", controls);
        } else {
            rst = JpcCommonOutputHelper.createCommonOutput(tab_field, JpcFieldHelper.getValue(data_field, valueIdx), controls);
        }
        //position
        if (isRow === true) {
            rst[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, rows, rowIdx, cols, colIdx, 1, 0, true, false);
        } else {
            rst[JV.PROP_AREA] = JpcAreaHelper.outputArea(tab_field[JV.PROP_AREA], band, unitFactor, rows, rowIdx, cols, colIdx, 1, 0, false, false);
        }
        return rst;
    };

    return JpcCrossTabResult;
};

module.exports = new JpcCrossTabSrv();