WebBuild/wwwroot/platform/analytics/components/tableviewer/tableviewer.js

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var Unibase;
(function (Unibase) {
    let Platform;
    (function (Platform) {
        let Analytics;
        (function (Analytics) {
            let Viewers;
            (function (Viewers) {
                class TableViewer extends Platform.Core.BaseComponent {
                    constructor() {
                        super();
                        this.IsTenure = false;
                        this.CommonFilter = [];
                        this.Filter = [];
                        this.subreportpagination = [];
                        this._lists_default_index = 0;
                        this.IsSelectable = false;
                        this.IdColumn = null;
                        this.TextColumn = null;
                        this.dataListId = 0;
                        this.subreportResponse = "";
                        this.widgetHeightNum = Unibase.Themes.Compact.Components.Index.Instance().widgetHeightNum;
                        this.isTouchScreen = Unibase.Themes.Compact.Components.Index.Instance().isTouchScreen;
                        this.reportManager = Analytics.Managers.ReportManager.Instance();
                        this._reportBuilder = Analytics.Reports.ReportBuilder.Instance();
                        this._reportViewer = Analytics.Components.ReportViewer.Instance();
                        this.ListSearchTerm = "";
                    }
                    loadView(reportresponse, reportid, viewerid, page, pageSize, containerid, ViewerSettings, callback, reportwidgetdata) {
                        var instance = this;
                        let rv_instance = instance._reportViewer.getReportViewerInstance(containerid);
                        var pivotdata;
                        let portletWidgetId = 0;
                        if (containerid.indexOf("div_portletwidget") > -1) {
                            portletWidgetId = Number(containerid.split("_")[2]);
                            if (containerid.indexOf("viewall") == -1)
                                instance._reportViewer.IsPortletWidget = true;
                        }
                        else {
                            $(".report-search").addClass("d-sm-flex");
                            $('.search_icon').removeClass("hidden");
                        }
                        instance._reportViewer.toggleGroupByAndShowAllBtn(containerid, true);
                        if (ViewerSettings.InstalledAppId != 0)
                            Unibase.Platform.Analytics.Reports.ReportBuilder.Instance().appConfigType = Unibase.Platform.Apps.Enums.AppConfigeType.Details;
                        if (rv_instance.pivotTypeId == Analytics.Reports.Enums.PivotType.PivotTable) {
                            return instance.loadPivotTable(reportid, containerid, reportresponse);
                        }
                        instance.initTable(reportresponse, containerid, reportid, null, reportwidgetdata);
                        Unibase.Platform.Helpers.NavigationHelper.Instance().hideLoading();
                    }
                    initTable(reportresponse, containerid, reportid, filters, reportwidgetdata) {
                        return __awaiter(this, void 0, void 0, function* () {
                            var subuniquearray = [];
                            var instance = this;
                            let rv_instance = instance._reportViewer.getReportViewerInstance(containerid);
                            var data;
                            let level = 0;
                            const isPivotTree = reportresponse.result.ReportInfo.IsPivotTree;
                            var radioIcon = function (cell, formatterParams, onRendered) {
                                var Selected = "";
                                if ($("#" + Unibase.Platform.Analytics.Viewers.TableViewer.Instance().AutoCompleteElement).val() == cell.getRow().getData()[Unibase.Platform.Analytics.Viewers.TableViewer.Instance().IdColumn]) {
                                    Selected = " checked";
                                }
                                var textdata = cell.getRow().getData()[Unibase.Platform.Analytics.Viewers.TableViewer.Instance().TextColumn];
                                var iddata = cell.getRow().getData()[Unibase.Platform.Analytics.Viewers.TableViewer.Instance().IdColumn];
                                return '<input type="radio" name="select" onclick="Unibase.Forms.Controls.AutoComplete.Instance().reportOnClick(' + "'" + textdata + "'," + iddata + ",'" + Unibase.Platform.Analytics.Viewers.TableViewer.Instance().AutoCompleteElement + "'" + ');" ' + Selected + ' />';
                            };
                            var groupBy = [];
                            var autoNumFormatter = function (cell) {
                                if (!isPivotTree) {
                                    var row = cell.getRow();
                                    var rowIndex = row.getPosition(false);
                                    return (rowIndex + 1);
                                }
                                else {
                                    return;
                                }
                            };
                            var tableresponse = reportresponse.result.ReportJsonData;
                            var maintabledata = reportresponse.result.ReportJsonData.Result;
                            let user = Unibase.Platform.Membership.Infos.Identity.getCurrentUser();
                            var columnresponse;
                            let postData = [];
                            let parentEl = $("#Viewer_" + containerid);
                            let height = "100%";
                            let viewerMarginWidth = parseInt(parentEl.css('margin-left')) + parseInt(parentEl.css('margin-right'));
                            parentEl.css({ "max-width": `calc(100% - ${viewerMarginWidth}px)`, 'max-height': '' });
                            if (instance._reportViewer.IsPortletWidget) {
                                let widgetHeight = instance.widgetHeightNum;
                                height = widgetHeight;
                                parentEl.css({ "overflow": "auto", "height": "100%", "max-height": `${widgetHeight}px` });
                            }
                            if (containerid.includes('div_dashboardportletwidget')) {
                                let portletWidgetHeight = $(`#${containerid}`).siblings('.hf_portletwidgetheight').val();
                                portletWidgetHeight = parseInt(portletWidgetHeight);
                                if (portletWidgetHeight <= 0) {
                                    height = "100%";
                                }
                                else {
                                    height = portletWidgetHeight + 48;
                                }
                            }
                            var res;
                            res = reportresponse.result.ReportInfo.ReportColumns;
                            var res = res.filter(x => x.Isvisible == true);
                            let IsPivotColumn = res.filter(function (o) { return o.IsPivotColumn === true; });
                            if (IsPivotColumn.length > 0 || reportresponse.result.ReportInfo.IsPivotTree) {
                                instance._reportViewer.ispivottable = true;
                            }
                            instance._reportViewer.table = new Tabulator("#Viewer_" + containerid, {
                                placeholder: "<div class='alert alert-primary text-center mb-0 border-0 w-100 font-14 rounded-0'>No data available</div>",
                                downloadDataFormatter: function (data) {
                                    return data;
                                },
                                columnCalcs: "both",
                                dataTree: instance._reportViewer.ispivottable,
                                dataTreeStartExpanded: reportresponse.result.ReportInfo.IsTreeExpand,
                                dataTreeRowExpanded: function (row, level) {
                                    if (!reportresponse.result.ReportInfo.IsTreeExpand) {
                                        instance._reportBuilder.datatreeIndex_Width = (instance._reportBuilder.datatreeIndex_Width) ? instance._reportBuilder.datatreeIndex_Width : 70;
                                        if (instance._reportBuilder.datatreeIndex_Width / 70 <= level) {
                                            instance._reportBuilder.datatreeIndex_Width = instance._reportBuilder.datatreeIndex_Width + 70;
                                        }
                                        Unibase.Platform.Analytics.Reports.ReportBuilder.Instance().tabulatorColumns[0].width = instance._reportBuilder.datatreeIndex_Width;
                                        Unibase.Platform.Analytics.Reports.ReportBuilder.Instance().tabulatorColumns[0].minWidth = instance._reportBuilder.datatreeIndex_Width;
                                        const id = (eval("row.getData()." + instance._reportViewer.pivotparentcolumn[0].ReportColumnName + ""));
                                        let { fromDate, toDate } = instance._reportViewer.checkForReportDatePicker(reportid, containerid);
                                        if (rv_instance.fromDate && rv_instance.toDate) {
                                            fromDate = rv_instance.fromDate;
                                            toDate = rv_instance.toDate;
                                        }
                                        var postdata = {
                                            ReportId: reportid,
                                            page: 1,
                                            pageSize: 0,
                                            IsPivot: true,
                                            PivotId: Number(id),
                                            FromDate: fromDate,
                                            ToDate: toDate,
                                            IsJson: true,
                                            InputParameters: rv_instance.inputParameters,
                                            Filter: rv_instance.dynamicFilters
                                        };
                                        instance._reportBuilder.dataTreeRowExpandedColumn.push({ Level: level });
                                        $.when(instance.reportManager.getReportViewerData(postdata)).done(function (response1) {
                                            let res = JSON.parse(response1.result);
                                            var pivotdata = JSON.parse(res.Data);
                                            var hasChild = pivotdata.filter(x => x.haschild == true).forEach(c => c["_children"] = []);
                                            row.getData()._children = pivotdata;
                                            return row.update(row.getData());
                                        });
                                    }
                                },
                                cellClick: function (e, cell) {
                                    if ($(cell.getElement()).closest('.tabulator-footer').length === 0) {
                                        if (instance.subreportResponse && instance.subreportResponse.length) {
                                            let cellAliasName = cell._cell.column.field;
                                            let subRpt = instance.subreportResponse.find(x => x.AliasName == cellAliasName);
                                            if (subRpt) {
                                                return instance.tableCellClick(e, cell, level, reportid, instance.subreportResponse, containerid);
                                            }
                                        }
                                        var row = cell.getRow();
                                        let onclick = rv_instance.ViewerSettings.OnClick.trim();
                                        let InstalledAppId = rv_instance.ViewerSettings.InstalledAppId;
                                        if (onclick) {
                                            onclick = onclick.replace("{{appinstalledappid}}", InstalledAppId.toString());
                                            let row_data = row.getData();
                                            var templateScript = Handlebars.compile(onclick);
                                            onclick = templateScript(row_data);
                                            eval(onclick);
                                        }
                                    }
                                },
                                ajaxProgressiveLoadScrollMargin: 500,
                                ajaxError: function (errortabletable1, error) {
                                    let id;
                                    id = eval('postmethod1(parameters)');
                                    var userinfo = Unibase.Platform.Membership.Infos.Identity.getCurrentUser();
                                    id.then(function (res) {
                                        var report = JSON.parse(JSON.parse(res.result).Result.Data);
                                        let column = new PaginationObject();
                                        column.last_page = 1;
                                        column.data = report;
                                        error.setData(column.data);
                                        $('#Viewer_pagintion' + containerid).html(Math.ceil(JSON.parse(JSON.parse(res.result).Result.Data).length) + ' ' + 'of' + ' ' + JSON.parse(res.result).Result.Count);
                                        if (JSON.parse(res.result).Result.Count > 20) {
                                            $(error.element.childNodes[1]).append(`<div class="text-center text-white mt-10-removed mb-20-removed my-2 bg-white-removed"> <a class="btn btn-success m-b btn-list-load-more btn-list-load-more_${containerid} btncount_2" id="btn-list-load-more_${containerid}">More</a></div>`);
                                            $(".btn-list-load-more_" + containerid).unbind().click(function () {
                                                let listsearch = $("#" + containerid).find("#ListSearch").val();
                                                var page = error.element.childNodes[1].lastChild.lastChild.classList[5].match(/\d+/g).map(Number)[0];
                                                let isdynamicfilters = instance._reportViewer.isIdentityFilter(rv_instance.dynamicFilters);
                                                let repObj = new Report();
                                                repObj.ReportId = Number(reportid);
                                                repObj.page = Number(page);
                                                repObj.Filter = rv_instance.dynamicFilters;
                                                repObj.DateFilter = rv_instance.dateFilters;
                                                repObj.InputParameters = rv_instance.inputParameters;
                                                repObj.FilterId = rv_instance.filterId;
                                                repObj.pageSize = instance._reportViewer.PageSize;
                                                repObj.SearchTerm = listsearch ? $("#" + containerid).find("#ListSearch").val().toString() : null;
                                                repObj.IsDynamicFilterApplied = isdynamicfilters;
                                                let method;
                                                method = eval('postmethod1(parameters)');
                                                method.then(function (res) {
                                                    error.addData(JSON.parse(res.result).Result.Data, false);
                                                    error.element.childNodes[1].lastChild.lastChild.classList.remove('btncount_' + page + '');
                                                    error.element.childNodes[1].lastChild.lastChild.classList.add('btncount_' + (page + 1) + '');
                                                    let datalength = (error.getDataCount());
                                                    if (datalength >= JSON.parse(res.result).Result.Count) {
                                                        if (JSON.parse(res.result).Result.Count != 0) {
                                                            $("#btn-list-load-more_" + containerid).addClass('hidden');
                                                        }
                                                        $('#Viewer_pagintion' + containerid).html(JSON.parse(res.result).Result.Count + ' ' + 'of' + ' ' + JSON.parse(res.result).Result.Count);
                                                    }
                                                    else {
                                                        $('#Viewer_pagintion' + containerid).html(Math.ceil(datalength) + ' ' + 'of' + ' ' + JSON.parse(res.result).Result.Count);
                                                    }
                                                });
                                            });
                                        }
                                    });
                                },
                                ajaxResponse: function (url, params, response) {
                                    var editeditems = {};
                                    var _children = [];
                                    var data = [];
                                    let column = new PaginationObject();
                                    if (response.length > 0) {
                                        var report = JSON.parse(JSON.parse(response.result).Result.Data);
                                        if (instance._reportViewer.ispivottable == true) {
                                            for (let i = 0; i < report.length; i++) {
                                                editeditems = report[i];
                                                if (report[i].haschild == true) {
                                                    editeditems["_children"] = [];
                                                }
                                                data.push(editeditems);
                                            }
                                            column.data = data;
                                        }
                                        else if (instance.IsTenure == true) {
                                            column.data = report;
                                        }
                                        else {
                                            column.data = report;
                                        }
                                        let datalength = (instance._reportViewer.table.getDataCount() + JSON.parse(JSON.parse(response.result).Result.Data).length);
                                        $('#Viewer_pagintion' + containerid).html(Math.ceil(datalength) + ' ' + 'of' + ' ' + JSON.parse(response.result).Result.Count);
                                        column.last_page = Math.ceil(JSON.parse(response.result).Result.Count / 20);
                                        return column;
                                    }
                                },
                                height: height,
                                layout: "fitDataFill",
                                resizableColumns: !instance.isTouchScreen ? true : 'header',
                                columns: [
                                    { title: "", formatter: autoNumFormatter, frozen: true, minWidth: 40, width: 40 }
                                ],
                                rowTap: function (e, row) {
                                    let id = $(row.getTable().element).attr('id').replace(/Viewer_/g, '');
                                    $('.portletwidget-item').attr('data-mobileSwipe', 'false');
                                    $('#' + id).parents('.portletwidget-item').attr('data-mobileSwipe', 'true');
                                },
                                dataSorting: function (sorters) {
                                    if (sorters.length > 0) {
                                        var sort = [];
                                        if (rv_instance.sortColumn) {
                                            var Sort;
                                            if (typeof (rv_instance.sortColumn) == 'string') {
                                                Sort = JSON.parse(rv_instance.sortColumn);
                                            }
                                            else {
                                                Sort = rv_instance.sortColumn;
                                            }
                                            var sortCol = Sort.find(s => s.Name == sorters[0].field);
                                            if (sortCol) {
                                                let order = (sortCol.Order.toLowerCase() == "asc") ? "Desc" : "Asc";
                                                sort.push({ "Order": order, "Name": sorters[0].field });
                                            }
                                            else
                                                sort.push({ "Order": sorters[0].dir, "Name": sorters[0].field });
                                        }
                                        else
                                            sort.push({ "Order": sorters[0].dir, "Name": sorters[0].field });
                                        rv_instance.sortColumn = sort;
                                        instance._reportViewer.getReportData(reportid, containerid, reportwidgetdata, null);
                                    }
                                },
                                virtualDom: rv_instance.virtualDom,
                                layoutColumnsOnNewData: true,
                                dataLoaded: rows => {
                                    if (rows.length && rv_instance.js) {
                                        this.bindWidgetConfigurations(containerid, rows);
                                    }
                                    instance.setTableHolderHeight(containerid);
                                },
                            });
                            rv_instance.table = instance._reportViewer.table;
                            if (maintabledata.Data == "") {
                                $(".tabulator-loader").remove();
                            }
                            if (filters != null) {
                                if (tableresponse.TotalRecords == 0) {
                                    $("#Viewer_" + containerid).css("height", "100");
                                }
                                else {
                                    $("#Viewer_" + containerid).css("height", "88%");
                                    let calWidth = "67%";
                                    if (window.innerWidth <= 575) {
                                        calWidth = "100%";
                                    }
                                    $("#Viewer_" + containerid).next('.modal-footer').css({ 'position': 'fixed', 'bottom': '0px', 'width': calWidth });
                                }
                            }
                            var len = 0;
                            if (maintabledata.Data != "") {
                                len = JSON.parse(maintabledata.Data).length;
                                if (len >= 5 && instance._reportViewer.IsPortletWidget) {
                                    const viewAllHtml = instance._reportViewer.getViewAllHtml(containerid, 'mobile', reportid);
                                    $(`#Viewer_${containerid}`).find('.tabulator-tableHolder').append(viewAllHtml);
                                    $(`#lnkViewAll_${containerid}`).removeClass("hidden");
                                }
                            }
                            if (instance._reportViewer.IsPortletWidget) {
                                $("#WidgetTitleLink_" + containerid).addClass('widget-title-link');
                                $("#ViewerHeader_" + containerid).attr('data-toggle', 'collapse').attr('data-target', "#Viewer_" + containerid);
                                $("#Viewer_" + containerid).addClass('collapse');
                                if (reportwidgetdata != "undefined" && reportwidgetdata != null) {
                                    if (reportwidgetdata != 0) {
                                        if (reportwidgetdata.Data.CssProperty != null && reportwidgetdata.Data.CssProperty != undefined && reportwidgetdata.Data.CssProperty != "") {
                                            if (JSON.parse(reportwidgetdata.Data.CssProperty)[0].ReportCollapase != undefined && rv_instance.ViewerSettings.defaultViewerTypeId == Unibase.Platform.Analytics.Reports.Enums.ReportType.Table) {
                                                if (reportwidgetdata.Data.PortletWidgetCss == undefined) {
                                                    if (JSON.parse(reportwidgetdata.Data.CssProperty)[0].ReportCollapase == true) {
                                                        $("#Viewer_" + containerid).addClass('show');
                                                        $("#ViewerHeader_" + containerid).attr('aria-expanded', 'true');
                                                    }
                                                    else {
                                                        $("#Viewer_" + containerid).removeClass('show');
                                                        $("#ViewerHeader_" + containerid).attr('aria-expanded', 'false');
                                                        $("#Viewer_" + containerid).on('shown.bs.collapse', function () {
                                                            if (rv_instance.table)
                                                                rv_instance.table.redraw(true);
                                                        });
                                                    }
                                                }
                                                if (reportwidgetdata.Data.PortletWidgetCss != undefined) {
                                                    if (reportwidgetdata.Data.portletWidgetIsCollapse == true) {
                                                        $("#Viewer_" + containerid).addClass('show');
                                                        $("#ViewerHeader_" + containerid).attr('aria-expanded', 'true');
                                                    }
                                                    else {
                                                        $("#Viewer_" + containerid).removeClass('show');
                                                        $("#ViewerHeader_" + containerid).attr('aria-expanded', 'false');
                                                        $(`#Viewer_${containerid}`).on('shown.bs.collapse', function () {
                                                            if (rv_instance.table)
                                                                rv_instance.table.redraw(true);
                                                        });
                                                    }
                                                }
                                                $("#Viewer_" + containerid).attr('data-iscollapseapplied', 'true');
                                            }
                                        }
                                    }
                                }
                                let widgetHeight = instance.widgetHeightNum - Math.abs($("#Viewer_" + containerid).find(".tabulator-header").height());
                                $("#Viewer_" + containerid).css({ "overflow": "auto", "height": "100%", "max-height": "" + widgetHeight + "px" });
                                instance._reportViewer.appendWidgetNoDataIcon(maintabledata, containerid);
                                if (maintabledata.Data === '') {
                                    $("#Viewer_" + containerid).off('shown.bs.collapse').on('shown.bs.collapse', function () {
                                        rv_instance.table.redraw(true);
                                    });
                                }
                            }
                            else {
                                var checkcontainerid = "#Viewer_" + containerid;
                                var checkcontainer = checkcontainerid.includes('div_dashboardportletwidget');
                                let countHtml = '';
                                const isCountVisible = instance._reportViewer.tabMode && (!checkcontainer || instance.navigationHelper.isReportPopup(containerid));
                                if (isCountVisible && maintabledata.Data != "") {
                                    countHtml = `<div class="text-center text-white bg-white-removed report-viewer-footer ${isCountVisible ? 'footer-count-wrap' : ''}"><div class="reportCountWrap_${containerid} text-right report-count-wrap font-14"><span class="biz-highlight-bg-color" id="visibleReportCountWrap_${containerid}"><span id="visibleReportCount_${containerid}">0</span> of </span><a href="javascript:;" class="rpt-Count${containerid} biz-highlight-bg-color text-underline" onclick="Unibase.Platform.Analytics.Components.ReportViewer.Instance().getCount(${rv_instance.ReportId}, ${rv_instance.InstalledAppId},'${containerid}');">Get count</a><span class="biz-highlight-bg-color hidden" id="Viewer_pagintion${containerid}">0 of 0</span>
							</div>`;
                                }
                                else {
                                    countHtml = '<div class="text-center text-white bg-white-removed report-viewer-footer">';
                                }
                                const btnHtml = `<div class="btn-group btn-group-sm btn-list-load-more more-btn-group" id="btn-list-load-more_${containerid}">
								<a class="btn btn-outline-primary load-more-list-btn btncount_2 rounded-left" id="loadMoreListBtn_${containerid}">More</a>
                                <button type="button" class="btn btn-primary dropdown-toggle dropdown-toggle-split rounded-right px-10"
                                    data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
                                    <span class="sr-only">Toggle Dropdown</span>
                                </button>
                                <div class="dropdown-menu p-1" id="moreBtnDpMenu_${containerid}">
                                    <a class="dropdown-item d-flex align-items-center c-gap-5 showall-link" href="javascript:;" id="showAllLink_${containerid}" onclick="Unibase.Platform.Analytics.Components.ReportViewer.Instance().showAllData(${rv_instance.ReportId}, ${rv_instance.InstalledAppId},'${containerid}');">Next <span class="showall-count" id="showAllCount_${containerid}">500</span><input class="showall-input w-100 ml-1 hidden" id="showAllInput_${containerid}" pattern="[0-9]+"></a>
								</div>
                            </div>`;
                                if (checkcontainer == true) {
                                    if (tableresponse.TotalRecords > 5 || !reportresponse.result.ReportInfo.IsEnableCount) {
                                        countHtml += btnHtml;
                                    }
                                }
                                else {
                                    if (tableresponse.TotalRecords > 15 || !reportresponse.result.ReportInfo.IsEnableCount) {
                                        countHtml += btnHtml;
                                    }
                                }
                                countHtml += '</div>';
                                $(instance._reportViewer.table.element).find('.tabulator-tableHolder').append(countHtml);
                                instance._reportViewer.bindShowAllCountChangeEvents(containerid);
                            }
                            rv_instance.reportDatalength = len;
                            $(`#visibleReportCount_${containerid}`).text(len);
                            $('#Viewer_pagintion' + containerid).html(len + ' ' + 'of' + ' ' + tableresponse.TotalRecords);
                            if ((!containerid.includes('div_dashboardportletwidget') && !instance._reportViewer.IsPortletWidget) || instance.navigationHelper.isReportPopup(containerid)) {
                                $("#Viewer_" + containerid).find('.tabulator-tableHolder').addClass('pb-10');
                            }
                            if (tableresponse.TotalRecords == 0) {
                                if (tableresponse.Result.Data == "") {
                                    $("#btn-list-load-more_" + containerid).addClass('hidden');
                                }
                                else if (instance._reportViewer.PageSize == JSON.parse(tableresponse.Result.Data).length && !reportresponse.result.ReportInfo.IsEnableCount) {
                                    $("#btn-list-load-more_" + containerid).removeClass('hidden');
                                }
                                else if (JSON.parse(tableresponse.Result.Data).length < instance._reportViewer.PageSize || JSON.parse(tableresponse.Result.Data).length == 0) {
                                    $("#btn-list-load-more_" + containerid).addClass('hidden');
                                }
                            }
                            else {
                                if (tableresponse.Result.Data != "") {
                                    if (reportresponse.result.ReportJsonData.TotalRecords == JSON.parse(tableresponse.Result.Data).length)
                                        $("#btn-list-load-more_" + containerid).addClass('hidden');
                                }
                                $(`#visibleReportCountWrap_${containerid}`).addClass('d-none');
                                $(`.reportCountWrap_${containerid} .rpt-Count${containerid}`).addClass("hidden");
                                $(`#Viewer_pagintion${containerid}`).removeClass('hidden');
                            }
                            if (rv_instance.isShowAll && tableresponse.Result.Data != "" && JSON.parse(tableresponse.Result.Data).length < rv_instance.PageSize) {
                                $("#btn-list-load-more_" + containerid).addClass('hidden');
                            }
                            $(`#loadMoreListBtn_${containerid}`).off('click').click(function () {
                                instance.moreButtonClick(containerid, reportid);
                            });
                            var col = [];
                            columnresponse = res;
                            if (Unibase.Platform.Analytics.Viewers.TableViewer.Instance().IsSelectable) {
                                col.push({ title: "", formatter: autoNumFormatter, frozen: true, minWidth: 70, width: 70 }, { title: "", formatter: radioIcon, frozen: true, minWidth: 40, width: 40 });
                            }
                            else {
                                let hozAlign = 'right';
                                if (isPivotTree) {
                                    hozAlign = 'center';
                                }
                                col.push({ title: "", formatter: autoNumFormatter, minWidth: 40, hozAlign: hozAlign, headerHozAlign: hozAlign });
                            }
                            if (rv_instance.pivotTypeId != Analytics.Reports.Enums.PivotType.Pivot && reportresponse.result.ReportInfo.PivotTypeId != Analytics.Reports.Enums.PivotType.PivotTreeView) {
                                let data = instance.setColumns(reportresponse, col);
                                if (data && data.length) {
                                    maintabledata.Data = data;
                                }
                            }
                            instance._reportViewer.table.redraw(true);
                            if (rv_instance.pivotTypeId != 0 && !reportresponse.result.ReportInfo.IsTreeExpand) {
                                res.forEach(c => !c.IsPivotAggrColumn && col.push({ title: c.DisplayText, field: c.AliasName.toLowerCase() }));
                                instance.pivotReport(containerid, reportresponse, maintabledata, reportresponse.result.ReportInfo.ReportColumns, col, IsPivotColumn, reportid);
                                yield instance._reportViewer.table.setData(maintabledata.Data).then((rows) => __awaiter(this, void 0, void 0, function* () {
                                    instance._reportViewer.table.redraw(true);
                                    yield instance.setGroupBy(rv_instance, containerid, rows);
                                }));
                            }
                            else if (reportresponse.result.ReportInfo.IsTreeExpand) {
                                let treedata = instance.getTreeViewData(reportresponse);
                                yield rv_instance.table.setData(treedata).then((rows) => __awaiter(this, void 0, void 0, function* () {
                                    instance._reportViewer.table.redraw(true);
                                    yield instance.setGroupBy(rv_instance, containerid, treedata);
                                }));
                            }
                            else {
                                if (maintabledata.Data != "") {
                                    yield rv_instance.table.setData(maintabledata.Data).then((rows) => __awaiter(this, void 0, void 0, function* () {
                                        instance._reportViewer.table.redraw(true);
                                        yield instance.setGroupBy(rv_instance, containerid, maintabledata.Data ? JSON.parse(maintabledata.Data) : []);
                                    }));
                                }
                                else {
                                    if (rv_instance.reportResponse && rv_instance.reportResponse.result && !rv_instance.reportResponse.result.ReportInfo.IsAutoData && !rv_instance.dynamicFilters.length && !rv_instance.dateFilters.length) {
                                        $("#" + containerid).find(".tabulator-placeholder").children().children().text("Please select the filter to show data");
                                    }
                                    instance._reportViewer.table.redraw(true);
                                    yield instance.setGroupBy(rv_instance, containerid, maintabledata.Data ? JSON.parse(maintabledata.Data) : []);
                                }
                            }
                            Unibase.Platform.Analytics.Viewers.TableViewer.Instance().table = instance._reportViewer.table;
                            rv_instance.table = instance._reportViewer.table;
                            instance.reportManager.getSubReports(reportid).then(function (response) {
                                return __awaiter(this, void 0, void 0, function* () {
                                    if (response.status == Unibase.Data.Status.Success) {
                                        var subreportdata = response.result;
                                        instance.subreportResponse = subreportdata;
                                        data = subreportdata;
                                        if (subreportdata.length > 0) {
                                            if (!rv_instance.isTable) {
                                                var subdata = subreportdata.find(s => s.RowClick == true);
                                                if (subdata) {
                                                    if (subdata.RowClick) {
                                                        var hideIcon = function (cell, formatterParams, onRendered) {
                                                            $(cell.getElement()).addClass('clickable-cell');
                                                            return "<i class='fa fa-plus'></i>";
                                                        };
                                                        instance._reportViewer.table.addColumn({ formatter: hideIcon, width: 5, title: "", headerSort: false }, true);
                                                    }
                                                }
                                            }
                                            subreportdata.forEach(function (subreport) {
                                                if (subreport.AliasName && instance._reportViewer.table.getColumn(subreport.AliasName)) {
                                                    instance._reportViewer.table.getColumn(subreport.AliasName).getCells().forEach(function (cell) {
                                                        if ($(cell.getElement()).closest('.tabulator-footer').length === 0) {
                                                            $(cell.getElement()).addClass("text-underline clickable-cell");
                                                        }
                                                    });
                                                }
                                            });
                                        }
                                        yield instance.reportManager.getColumns(reportid).then(function (response) {
                                            instance._reportViewer.pivotparentcolumn = response.result.filter(function (o) { return o.IsPivotParentColumn === true; });
                                            var result = response.result.filter(x => x.GroupByCategory == true);
                                            if (result.length != 0) {
                                                for (var i = 0; i < result.length; i++) {
                                                    groupBy.push(result[i].ReportColumnName);
                                                }
                                            }
                                        });
                                    }
                                });
                            });
                            instance.tabulatorColumnHeaderMenu(containerid, res);
                            if (tableresponse.Result.Data == "") {
                                instance._reportViewer.table.redraw(true);
                            }
                            if (rv_instance.tblGroupedCols && rv_instance.tblGroupedCols.length > 0) {
                                rv_instance.tblGroupedCols.forEach(function (tg) {
                                    rv_instance.table.hideColumn(tg);
                                });
                            }
                            return instance._reportViewer.table;
                        });
                    }
                    setTableHolderHeight(containerid) {
                        let deductHeight = 0;
                        const viewerEl = $("#Viewer_" + containerid);
                        deductHeight += viewerEl.find('.tabulator-header').prop('scrollHeight');
                        deductHeight += viewerEl.find('.tabulator-footer').outerHeight(true) || 0;
                        viewerEl.find(".tabulator-tableHolder").addClass("h-100").css({ "max-height": `calc(100% - ${deductHeight}px)` });
                    }
                    setColumnDpMenuPosition(event, id, colId, AliasName) {
                        event.stopPropagation();
                        const targetEl = $(event.currentTarget);
                        if (targetEl.siblings('.column-dp-menu').hasClass('show')) {
                            targetEl.siblings('.column-dp-menu').removeClass('show');
                        }
                        else {
                            $('#Viewer_' + id + ' .tabulator-header').find('.column-dp-menu.show').removeClass('show');
                            const elLeftPos = targetEl.offset().left - $('#Viewer_' + id).offset().left;
                            const headerHeight = $('#Viewer_' + id + ' .tabulator-header').outerHeight(true);
                            targetEl.siblings('.dropdown-menu_' + colId).css({ position: 'fixed', top: headerHeight, left: elLeftPos }).addClass('show').attr('onclick', 'event.stopPropagation();');
                            if ($('#Viewer_' + id).width() < (targetEl.offset().left + 200)) {
                                $('.dropdown-menu_' + colId).find('.sub-dropdown-menu .dropdown-menu').addClass('open-left-side');
                            }
                            else {
                                $('.dropdown-menu_' + colId).find('.sub-dropdown-menu .dropdown-menu').addClass('open-right-side');
                            }
                        }
                    }
                    tabulatorColumnHeaderMenu(containerId, reportColumns) {
                        const instance = this;
                        const selectedColumns = reportColumns;
                        let reportId = reportColumns[0].ReportId;
                        var len = selectedColumns.length;
                        for (var i = 0; i < len; i++) {
                            let colId = selectedColumns[i].ReportColumnId;
                            let aliasName = selectedColumns[i].AliasName.replace(" ", "");
                            let colName = selectedColumns[i].ColumnName;
                            let html = `<div class="dropdown column-dropdown"><span class="dropdown-toggle no-caret column-dpmenu-icon" onClick="Unibase.Platform.Analytics.Viewers.TableViewer.Instance().setColumnDpMenuPosition(event, '${containerId}', ${colId},'${aliasName}');"><span
                class="tabulator-header-menu-button px-0"><i class="las la-ellipsis-v"></i></span></span>
        <div class="dropdown-menu column-dp-menu dropdown-radio dropdown-menu-right dropdown-menu_` + colId + `" style="position:relative;">
            <div><a class="dropdown-item  d-flex align-items-center" href="javascript:;" onclick='Unibase.Platform.Analytics.Viewers.TableViewer.Instance().applySorting("${containerId}","${aliasName}","Asc")'><span class="mr-2"><i class="fa fa-sort-asc" style="    vertical-align: bottom;"></span></i><span>Sort Ascending</span></a></div>
            <div><a class="dropdown-item d-flex align-items-center" href="javascript:;" onclick = 'Unibase.Platform.Analytics.Viewers.TableViewer.Instance().applySorting("${containerId}","${aliasName}","Desc")'><span class="mr-2"><i class="fa fa-sort-desc" style="    vertical-align: top;"></i></span><span>Sort Descending</span></a></div>
            <div class="dropdown-divider"></div>
            <div>
                <div class="sub-dropdown-menu show-on-hover">
                    <a class="dropdown-item" href="javascript:;"><i class="fa fa-filter mr-2"></i><span>Filter</span></a>
                    <div class="dropdown-menu dropdown-radio" id="dropdown_menu_${aliasName}">
                        <p class="px-2 mb-2 font-weight-normal text-dark">Show items with value that :</p>
                        <select class="dropdown-item p-1 coulmn-dp-select border-0 cursor-pointer" id="dynamic_filtering_${aliasName}_exp1" style="outline: none;">
                            <option selected value="0">is equal to</option>
                            <option value="1">Is not equal to</option>
                            <option value="2">Starts with</option>
                            <option value="3">Contains</option>
                            <option value="4">Does not contain</option>
                            <option value="5">Ends with</option>
                            <option value="6">Is null</option>
                            <option value="7">Is not null</option>
                            <option value="8">Is empty</option>
                            <option value="9">Is not empty</option>
                        </select>

                        <a class="dropdown-item p-1" href="javascript:;"><span>
                            <input type="text" id="dynamic_filtering_${aliasName}_value1" class="border"></span></a>
                        <select class="dropdown-item p-1 coulmn-dp-select cursor-pointer" id="dynamic_filtering_${aliasName}_operator" style="outline: none;">
                            <option selected value="0">And</option>
                            <option value="1">Or</option>
                        </select>
                        <select class="dropdown-item p-1 coulmn-dp-select border-0 cursor-pointer" id="dynamic_filtering_${aliasName}_exp2" style="outline: none;">
                            <option selected value="0">is equal to</option>
                            <option value="1">Is not equal to</option>
                            <option value="2">Starts with</option>
                            <option value="3">Contains</option>
                            <option value="4">Does not contain</option>
                            <option value="5">Ends with</option>
                            <option value="6">Is null</option>
                            <option value="7">Is not null</option>
                            <option value="8">Is empty</option>
                            <option value="9">Is not empty</option>
                        </select>
                        <a class="dropdown-item p-1" href="javascript:;"><span>
                            <input type="text" class="border" id="dynamic_filtering_${aliasName}_value2"></span></a>
                        <div class="d-flex align-items-center justify-content-between p-1 pt-2">
                            <a href="javascript:;" class="btn btn-sm btn-outline-primary" onclick='Unibase.Platform.Analytics.Viewers.TableViewer.Instance().applyTableDynamicFiltering("${containerId}","${aliasName}")'>Filter</a>
                            <a href="javascript:;" class="btn btn-sm btn-outline-danger" onclick='Unibase.Platform.Analytics.Viewers.TableViewer.Instance().clearTableDynamicFiltering("${containerId}","${aliasName}")'>Clear</a></div>
                    </div>
                </div>
            </div>
        </div>
    </div>`;
                            $("#Viewer_" + containerId).find("[tabulator-field='" + aliasName.toLocaleLowerCase() + "']").find(".tabulator-col-title-holder").prepend(html);
                            $("#Viewer_" + containerId).find(".tabulator-col-title-holder").addClass('flex-center');
                        }
                        this.bindTableDynamicfiltersIfExists(containerId);
                    }
                    moreButtonClick(containerid, reportid) {
                        var instance = this;
                        let rv_instance = instance._reportViewer.getReportViewerInstance(containerid);
                        let listsearch = $("#" + containerid).find("#ListSearch").val();
                        let pagesize = rv_instance.PageSize == 500 ? rv_instance.PageSize : instance._reportViewer.PageSize;
                        var page = 0;
                        if (rv_instance.pivotTypeId == Analytics.Reports.Enums.PivotType.PivotTable) {
                            var pivotTotalRecords = Number($(".pvtTable").attr("data-numrows"));
                            if (pagesize * rv_instance.Page == pivotTotalRecords) {
                                rv_instance.Page = rv_instance.Page + 1;
                                page = rv_instance.Page;
                            }
                        }
                        else {
                            page = +$(`#loadMoreListBtn_${containerid}`).attr('class').match(/btncount_\d+/)[0].split('_').pop();
                        }
                        let { fromDate, toDate } = this._reportViewer.checkForReportDatePicker(reportid, containerid);
                        if (rv_instance.fromDate && rv_instance.toDate) {
                            fromDate = rv_instance.fromDate;
                            toDate = rv_instance.toDate;
                        }
                        rv_instance.Page = Number(page);
                        let isdynamicfilters = instance._reportViewer.isIdentityFilter(rv_instance.dynamicFilters);
                        let repObj = new Report();
                        repObj.ReportId = Number(reportid);
                        repObj.page = rv_instance.Page;
                        repObj.FilterId = rv_instance.filterId;
                        repObj.Filter = rv_instance.dynamicFilters;
                        repObj.InputParameters = rv_instance.inputParameters;
                        repObj.DateFilter = rv_instance.dateFilters;
                        repObj.pageSize = pagesize;
                        repObj.SearchTerm = listsearch ? $("#" + containerid).find("#ListSearch").val().toString() : null;
                        repObj.IsEnableCount = rv_instance.isEnableCount;
                        repObj.IsJson = true;
                        repObj.FromDate = fromDate;
                        repObj.ToDate = toDate;
                        repObj.IsDynamicFilterApplied = isdynamicfilters;
                        let { stringifiedSortColumns } = rv_instance.getStringfySortColsAlongWithGrpByCols(containerid, rv_instance);
                        if (stringifiedSortColumns) {
                            repObj.SortColumn = stringifiedSortColumns;
                        }
                        if (rv_instance.pivotTypeId != Analytics.Reports.Enums.PivotType.PivotTable) {
                            $(`#loadMoreListBtn_${containerid}`).addClass(`btncount_${page + 1}`).removeClass(`btncount_${page}`);
                        }
                        instance.reportManager.getReportViewerData(repObj).then(function (response) {
                            if (response.status == Unibase.Data.Status.Success) {
                                var rptRes = JSON.parse(response.result);
                                if (rptRes.Data != "") {
                                    let tableData = JSON.parse(rptRes.Data);
                                    let prevData = rv_instance.reportData;
                                    rv_instance.reportData = $.merge(prevData, tableData);
                                    rv_instance.reportDatalength = rv_instance.reportData.length;
                                    if (rv_instance.pivotTypeId == Analytics.Reports.Enums.PivotType.PivotTable) {
                                        return instance.pivotMoreButtonClick(containerid, reportid, rv_instance.reportData);
                                    }
                                    if (rv_instance.pivotTypeId == Analytics.Reports.Enums.PivotType.PivotTreeView) {
                                        for (var i = 0; i < tableData.length; i++) {
                                            if (tableData[i].haschild == true) {
                                                tableData[i]["_children"] = [];
                                            }
                                        }
                                    }
                                    let tableDataJson = JSON.stringify(tableData);
                                    var tabulatorHolder = $("#" + containerid).find(".tabulator-tableHolder");
                                    var scroll = tabulatorHolder.scrollTop();
                                    let { hasImageUrl, data } = instance.checkForImageUrlAndUpdateTableData(rv_instance.reportColumns, tableData);
                                    if (hasImageUrl)
                                        tableDataJson = data;
                                    instance._reportViewer.table.redraw(true);
                                    instance._reportViewer.table.addData(tableDataJson).then((rows) => {
                                        instance._reportViewer.table.redraw(true);
                                        rows = rows.map(x => x._row);
                                        instance.bindWidgetConfigurations(containerid, rows);
                                        tabulatorHolder.scrollTop(scroll);
                                    });
                                    let datalength = (instance._reportViewer.table.getDataCount());
                                    if (datalength >= response.totalRecords) {
                                        if (response.totalRecords != 0)
                                            $("#btn-list-load-more_" + containerid).addClass('hidden');
                                        $('#Viewer_pagintion' + containerid).html(response.totalRecords + ' ' + 'of' + ' ' + response.totalRecords);
                                    }
                                    else {
                                        $('#Viewer_pagintion' + containerid).html(Math.ceil(datalength) + ' ' + 'of' + ' ' + response.totalRecords);
                                    }
                                    rv_instance.reportDatalength = datalength;
                                    $(`#visibleReportCount_${containerid}`).text(datalength);
                                }
                                else {
                                    $("#btn-list-load-more_" + containerid).addClass('hidden');
                                }
                            }
                            else {
                                $(`#loadMoreListBtn_${containerid}`).removeClass(`btncount_${page + 1}`).addClass(`btncount_${page}`);
                            }
                        });
                    }
                    pivotReport(containerid, reportresponse, maintabledata, res, col, pivotColumn, reportid) {
                        var res;
                        return __awaiter(this, void 0, void 0, function* () {
                            var instance = this;
                            let reportInfo = reportresponse.result.ReportInfo;
                            var pivotcol = [];
                            var pivotreportcoulmn;
                            var pivotaggrcolumn;
                            if (pivotColumn.length > 0) {
                                pivotreportcoulmn = res.filter(function (o) { return o.IsPivotColumn === true; })[0].ReportColumnName;
                            }
                            let IsPivotRow = res.filter(function (o) { return o.IsPivotRow === true; });
                            if (IsPivotRow.length > 0) {
                                if (instance._reportBuilder.DataSourceId == 0 || instance._reportBuilder.DataSourceId == Platform.DataSources.Enums.DataSource.Sql || instance._reportBuilder.DataSourceId == Platform.DataSources.Enums.DataSource.MySql) {
                                    IsPivotRow.forEach(c => pivotcol.push({ title: c.DisplayText, field: c.ReportColumnName.toLowerCase(), bottomCalc: instance._reportBuilder.getAggregationName(c.TableAggrTypeId) }));
                                }
                                else {
                                    IsPivotRow.forEach(c => pivotcol.push({ title: c.DisplayText, field: c.ReportColumnName, bottomCalc: instance._reportBuilder.getAggregationName(c.TableAggrTypeId) }));
                                }
                                let pivotarry = {
                                    title: pivotreportcoulmn,
                                    columns: pivotcol
                                };
                                col.push(pivotarry);
                                instance._reportBuilder.tabulatorColumns = col;
                                instance._reportViewer.table.setColumns(col);
                            }
                            if (reportInfo.PivotTypeId == Analytics.Reports.Enums.PivotType.Pivot) {
                                instance.pivoting(reportInfo.DataListId, pivotColumn, pivotreportcoulmn, col);
                            }
                            else if (reportInfo.PivotTypeId == Analytics.Reports.Enums.PivotType.TreeView) {
                                var pivotdata = instance.treeView_Children(maintabledata);
                                maintabledata.Data = pivotdata;
                            }
                            else if (reportInfo.PivotTypeId == Analytics.Reports.Enums.PivotType.PivotTreeView) {
                                instance.pivoting(reportInfo.DataListId, pivotColumn, pivotreportcoulmn, col);
                                var pivotdata = instance.treeView_Children(maintabledata);
                                maintabledata.Data = pivotdata;
                            }
                            else if (reportInfo.PivotTypeId == Analytics.Reports.Enums.PivotType.TimeInterval) {
                                let tenurearr = instance.tenureReport(res);
                                col.push(tenurearr);
                                instance._reportViewer.table.setColumns(col);
                            }
                        });
                    }
                    treeView_Children(maintabledata) {
                        var instance = this;
                        var pivotdata = [];
                        var editeditems = {};
                        if (instance._reportViewer.ispivottable == true) {
                            var TableData = [];
                            if (maintabledata.Data != "" && maintabledata.Data != "") {
                                TableData = JSON.parse(maintabledata.Data);
                            }
                            for (let i = 0; i < TableData.length; i++) {
                                editeditems = TableData[i];
                                if (TableData[i].haschild == true) {
                                    editeditems["_children"] = [];
                                }
                                pivotdata.push(editeditems);
                            }
                        }
                        return pivotdata;
                    }
                    pivoting(datalistid, pivot, pivotcoulmn, col) {
                        var instance = this;
                        var pobj = {
                            pivotColumnId: pivot[0].ReportColumnId,
                            pivotColumnName: pivot[0].ReportColumnName,
                            pivotDataType: pivot[0].PivotDateType,
                            pivotAggregationColumnName: pivotcoulmn
                        };
                        instance.pivot_PivotRows(pobj, datalistid, pivotcoulmn, col);
                    }
                    pivot_PivotRows(pobj, dataListId, pivotcoulmn, col) {
                        return __awaiter(this, void 0, void 0, function* () {
                            var instance = this;
                            var pivotcol = [];
                            var AggrFuncId = 0;
                            if (pobj.pivotDataType == Analytics.Reports.Enums.AggregationType.year) {
                                AggrFuncId = Analytics.Reports.Enums.AggregationType.year;
                            }
                            else if (pobj.pivotDataType == Analytics.Reports.Enums.AggregationType.month) {
                                AggrFuncId = Analytics.Reports.Enums.AggregationType.month;
                            }
                            instance.dataListId = dataListId;
                            instance.pivotColumns = new PivotColumns();
                            yield instance.getDistinctData(pobj.pivotColumnId, pobj.pivotColumnName, AggrFuncId);
                            if (instance.pivotColumns.PivotRows) {
                                instance.pivotColumns.PivotRows.forEach(c => pivotcol.push({ title: c, field: c }));
                                var pivotCol_Index = col.findIndex(function (c) { return (c.title === pivotcoulmn); });
                                if (pivotCol_Index > -1) {
                                    col.splice(pivotCol_Index, 1, ...pivotcol);
                                }
                                instance._reportBuilder.tabulatorColumns = col;
                                instance._reportViewer.table.setColumns(col);
                            }
                        });
                    }
                    tenureReport(res) {
                        let TenureReportColumn = res.filter(function (o) { return o.IsPivotColumn === true; })[0].ReportColumnName;
                        var timeInterval = res.filter(function (o) { return o.IsPivotColumn === true; })[0].TimeInterval.split(',');
                        var tenure = [];
                        for (var t = 0; t < timeInterval.length; t++) {
                            var start = 0;
                            if (t != timeInterval.length - 1) {
                                if (t == 0) {
                                    start = Number(timeInterval[t]);
                                }
                                else {
                                    start = Number(timeInterval[t]) + 1;
                                }
                                var end = timeInterval[t + 1];
                                tenure.push(start + "-" + end);
                            }
                            else {
                                tenure.push(">" + timeInterval[t]);
                            }
                        }
                        let TenureCol = [];
                        for (var t = 0; t < tenure.length; t++) {
                            TenureCol.push({ title: tenure[t], field: tenure[t], visible: true });
                        }
                        let tenureArray = {
                            title: TenureReportColumn,
                            columns: TenureCol
                        };
                        return tenureArray;
                    }
                    setColumns(reportresponse, col) {
                        var instance = this;
                        var rptInfo = reportresponse.result.ReportInfo;
                        var rptCols = reportresponse.result.ReportInfo.ReportColumns;
                        var maintabledata = reportresponse.result.ReportJsonData.Result;
                        rptCols = rptCols.filter(x => x.Isvisible == true);
                        const underlineFormatter = function (cell) {
                            if (instance.subreportResponse.length) {
                                instance.subreportResponse.forEach(function (subreport) {
                                    if (subreport.AliasName == cell.getField()) {
                                        $(cell.getElement()).addClass("text-underline");
                                        return false;
                                    }
                                });
                            }
                            return cell.getValue();
                        };
                        if (rptInfo.DataSourceId == 0 || rptInfo.DataSourceId == Platform.DataSources.Enums.DataSource.Sql || rptInfo.DataSourceId == Platform.DataSources.Enums.DataSource.MySql) {
                            rptCols.forEach((c) => {
                                const colHozAlign = instance.getColHorizontalAlign(c);
                                col.push({ title: c.DisplayText, field: c.AliasName.toLowerCase(), bottomCalc: instance._reportBuilder.getAggregationName(c.TableAggrTypeId), bottomCalcParams: { precision: 2 }, hozAlign: colHozAlign, headerHozAlign: colHozAlign, formatter: underlineFormatter, visible: true });
                            });
                        }
                        else {
                            rptCols.forEach((c) => {
                                const colHozAlign = instance.getColHorizontalAlign(c);
                                col.push({ title: c.DisplayText, field: c.ReportColumnName, bottomCalc: instance._reportBuilder.getAggregationName(c.TableAggrTypeId), bottomCalcParams: { precision: 2 }, hozAlign: colHozAlign, headerHozAlign: colHozAlign, formatter: underlineFormatter, visible: true });
                            });
                        }
                        let isRowTotal = rptCols.find(rt => rt.IsRowTotal == true) ? true : false;
                        if (isRowTotal) {
                            col.push({ title: "Total", field: "total", bottomCalc: "none", bottomCalcParams: { precision: 2 }, headerHozAlign: "right", hozAlign: "right", visible: true, cssClass: "font-weight-600" });
                        }
                        if (maintabledata.Data) {
                            let { hasImageUrl, data, tabulatorColumns } = instance.checkForImgUrlAndUpdateTableDataAndTabuCols(rptCols, JSON.parse(maintabledata.Data), col);
                            if (hasImageUrl)
                                col = tabulatorColumns;
                            instance._reportBuilder.tabulatorColumns = col;
                            instance._reportViewer.table.setColumns(col);
                            if (hasImageUrl)
                                return data;
                        }
                        else {
                            instance._reportBuilder.tabulatorColumns = col;
                            instance._reportViewer.table.setColumns(col);
                        }
                    }
                    checkForImgUrlAndUpdateTableDataAndTabuCols(reportColumns, tableData, tabulatorColumns) {
                        let hasImageUrl;
                        let imageUrlRows = reportColumns.filter(function (x) { return x.IsImageUrl; });
                        if (tableData && tableData.length) {
                            for (var i = 0; i < imageUrlRows.length; i++) {
                                let idx = tabulatorColumns.findIndex(x => x.field == imageUrlRows[i].AliasName.toLowerCase());
                                if (idx > -1) {
                                    tabulatorColumns[idx]["formatter"] = "image";
                                    tabulatorColumns[idx]["formatterParams"] = {
                                        height: "50px",
                                        width: "50px",
                                    };
                                    hasImageUrl = true;
                                }
                                tableData.forEach((row) => row[imageUrlRows[i].AliasName] = _appsettings.asset_url() + "/" + row[imageUrlRows[i].AliasName]);
                            }
                        }
                        return { data: JSON.stringify(tableData), tabulatorColumns: tabulatorColumns, hasImageUrl: hasImageUrl };
                    }
                    checkForImageUrlAndUpdateTableData(reportColumns, tableData) {
                        let hasImageUrl;
                        let imageUrlRows = reportColumns.filter(function (x) { return x.IsImageUrl; });
                        if (tableData) {
                            for (var i = 0; i < imageUrlRows.length; i++) {
                                hasImageUrl = true;
                                tableData.forEach((row) => row[imageUrlRows[i].AliasName] = _appsettings.asset_url() + "/" + row[imageUrlRows[i].AliasName]);
                            }
                        }
                        return { data: JSON.stringify(tableData), hasImageUrl: hasImageUrl };
                    }
                    getColHorizontalAlign(col) {
                        let colHozAlign = '';
                        if (col.DataType == Analytics.Reports.Enums.DataType.decimal || col.DataType == Analytics.Reports.Enums.DataType.int32 || col.DataType == Analytics.Reports.Enums.DataType.int64) {
                            colHozAlign = 'right';
                        }
                        else if (col.DataType == Analytics.Reports.Enums.DataType.date || col.DataType == Analytics.Reports.Enums.DataType.dateTime) {
                            colHozAlign = 'center';
                        }
                        else {
                            colHozAlign = 'left';
                        }
                        return colHozAlign;
                    }
                    isPivot(reportresponse) {
                        var instance = this;
                        var pivotdata = reportresponse.result.filter(function (o) { return o.IsPivotAggrColumn === true; });
                        if (pivotdata.length > 0) {
                            instance._reportViewer.ispivottable = true;
                        }
                    }
                    isTenure(reportresponse) {
                        var instance = this;
                        var tenure = reportresponse.result.filter(function (o) { return o.IsTenureApplied === true; });
                        if (tenure.length > 0) {
                            instance.IsTenure = true;
                        }
                    }
                    getDistinctData(colId, colName, AggrFuncId) {
                        return __awaiter(this, void 0, void 0, function* () {
                            var instance = this;
                            instance.pivotColumns.ColumnName = "";
                            var cf_fromDate = btoa(Unibase.Platform.Helpers.NavigationHelper.commonFilter_FromDate);
                            var cf_toDate = btoa(Unibase.Platform.Helpers.NavigationHelper.commonFilter_ToDate);
                            yield Unibase.Platform.Analytics.Managers.ReportManager.Instance().getDistinctColumnData(instance.dataListId, colName, AggrFuncId, cf_fromDate, cf_toDate).then(function (response) {
                                if (response != "") {
                                    let PivotRows = [];
                                    instance.pivotColumns.ColumnName = colName;
                                    for (var i = 0; i < response.length; i++) {
                                        PivotRows.push(response[i][colName]);
                                    }
                                    if ($("#PivotRows_Select2").is(":visible")) {
                                        $("#PivotRows_Select2").select2({
                                            placeholder: 'Select Pivot Rows',
                                            data: PivotRows
                                        });
                                    }
                                    instance.pivotColumns.PivotRows = PivotRows;
                                }
                            });
                        });
                    }
                    generatesubtables(e, row, level, rowposition, isfirstlevel, mainreportid, subreportid, containerid) {
                        var instance = this;
                        function subtablesArray(subarray, e, row, level, rowpostion) {
                            return __awaiter(this, void 0, void 0, function* () {
                                if (row._row.cells[0].element == e.target || row._row.cells[0].element == e.target.parentElement) {
                                    if ($(row._row.element.children[0]).find('i').eq(0).hasClass('fa-plus')) {
                                        $(row._row.element.children[0]).find('i').eq(0).removeClass('fa-plus').addClass('fa-minus');
                                    }
                                    else {
                                        $(row._row.element.children[0]).find('i').eq(0).removeClass('fa-minus').addClass('fa-plus');
                                    }
                                }
                                else {
                                    $(row._row.element.children[0]).find('i').eq(0).removeClass('fa-minus').addClass('fa-plus');
                                }
                                if (typeof (subarray) == 'string') {
                                    subarray = JSON.parse(subarray);
                                }
                                if (subarray.length > 0) {
                                    for (const item of subarray) {
                                        if ($(row._row.getElement()).find(`#subTable_sub_${rowposition}_${item.ChildReportId}_${item.SubReportId}_${subreportid[1]}`).length > 0) {
                                            const subTableEl = $(`#subTable_sub_${rowposition}_${item.ChildReportId}_${item.SubReportId}_${subreportid[1]}`);
                                            if (subTableEl.is(':visible')) {
                                                subTableEl.hide();
                                                continue;
                                            }
                                            else {
                                                $(row._row.getElement()).find('.subtable').hide();
                                                subTableEl.show();
                                            }
                                        }
                                        $(row._row.getElement()).find('.subtable').hide();
                                        instance.reportManager.getSubReports(item.ChildReportId).then(function (subresponse) {
                                            const contanierId = instance.navigationHelper.getLastContainerId();
                                            let parentcontainerid = contanierId + "_" + mainreportid;
                                            const rv_instance_parentreport = instance._reportViewer.getReportViewerInstance(parentcontainerid);
                                            const rv_instance = instance._reportViewer.getReportViewerInstance(contanierId);
                                            const datetimeIns = Unibase.Platform.Helpers.DateTimeHelper.Instance();
                                            var subReportFilters = [];
                                            if (rv_instance && rv_instance.dynamicFilters && rv_instance.dynamicFilters.length) {
                                                subReportFilters = subReportFilters.concat(rv_instance.dynamicFilters);
                                            }
                                            subReportFilters = subReportFilters.filter((f, i, a) => a.findIndex(f2 => (f.ParameterName === f2.ParameterName)) === i);
                                            var filters = JSON.parse(item.Filters);
                                            var value = 0;
                                            for (var i = 0; i < filters.length; i++) {
                                                let fill = filters[i];
                                                let paramValCol = (fill.ParameterValue.trim()).replace('@', '');
                                                if (!fill.Isvalue)
                                                    value = (eval("row.getData()." + fill.ParameterName + ""));
                                                else
                                                    value = fill.ParameterName;
                                                let expid = instance.getExpId(fill.Operator);
                                                subReportFilters.push({
                                                    ParameterName: paramValCol.trim(),
                                                    ParameterValue: value.toString(),
                                                    ExpOp: expid
                                                });
                                            }
                                            var fromDate = "";
                                            var toDate = "";
                                            var cf_fromDate = Unibase.Platform.Helpers.NavigationHelper.commonFilter_FromDate;
                                            var cf_toDate = Unibase.Platform.Helpers.NavigationHelper.commonFilter_ToDate;
                                            if (cf_fromDate != null && cf_toDate != null) {
                                                fromDate = cf_fromDate.toString();
                                                toDate = cf_toDate.toString();
                                            }
                                            else {
                                                fromDate = Unibase.Platform.Helpers.DateTimeHelper.Instance().formatLocalDateformat(new Date(Unibase.Platform.Helpers.DateTimeHelper.Instance().currentDate()), "YYYY/MM/DD");
                                                toDate = Unibase.Platform.Helpers.DateTimeHelper.Instance().formatLocalDateformat(new Date(Unibase.Platform.Helpers.DateTimeHelper.Instance().currentDate()), "YYYY/MM/DD");
                                            }
                                            if (rv_instance && rv_instance.reportResponse && rv_instance.reportResponse.result && rv_instance.reportResponse.result.ReportInfo && rv_instance.reportResponse.result.ReportInfo.IsEnableGlobalDatepicker) {
                                                let dyFilDate = $("#dynamic-filters" + containerid).find("#report-daterange" + containerid + "-1").val();
                                                if (dyFilDate) {
                                                    cf_fromDate = datetimeIns.formatLocalDateformat(cf_fromDate, "DD/MM/YYYY");
                                                    cf_toDate = datetimeIns.formatLocalDateformat(cf_toDate, "DD/MM/YYYY");
                                                    if (dyFilDate != cf_fromDate + " - " + cf_toDate) {
                                                        fromDate = dyFilDate.split("-")[0].trim();
                                                        toDate = dyFilDate.split("-")[1].trim();
                                                    }
                                                }
                                            }
                                            let subrpt_PostData = {
                                                ReportId: item.ChildReportId,
                                                Filter: subReportFilters,
                                                LinkSubReport: true,
                                                pageSize: instance._reportViewer.PageSize,
                                                page: 0,
                                                IsJson: true,
                                                FromDate: fromDate,
                                                ToDate: toDate,
                                                viewerTypeId: rv_instance && rv_instance.ViewerSettings && rv_instance.ViewerSettings.selectedViewerTypeId,
                                                DisplayModeTypeId: instance._reportViewer.getDisplayModeTypeId(),
                                                IsDynamicFilterApplied: rv_instance_parentreport && rv_instance_parentreport.IsDynamicFilterApplied
                                            };
                                            instance.reportManager.getReportInfo(subrpt_PostData).then(function (subrpt_response) {
                                                if (subrpt_response.status == Unibase.Data.Status.Error) {
                                                    return MessageHelper.Instance().showError(subrpt_response.message, rv_instance.parentContainerId + " #div_ErrorMessage");
                                                }
                                                if (subrpt_response.result.ReportJsonData.Status == Unibase.Data.Status.Error) {
                                                    return MessageHelper.Instance().showError(subrpt_response.result.ReportJsonData.Message, "div_ErrorMessage", "." + contanierId);
                                                }
                                                else {
                                                    var holderEl = document.createElement("div");
                                                    var tableEl = document.createElement("div");
                                                    holderEl.style.boxSizing = "border-box";
                                                    holderEl.style.padding = "10px 10px 10px 10px";
                                                    holderEl.style.borderTop = "1px solid #333";
                                                    holderEl.style.borderBottom = "1px solid #333";
                                                    holderEl.style.background = "#ddd";
                                                    holderEl.setAttribute('id', "subTable_sub_" + (rowposition) + "_" + item.ChildReportId + "_" + item.SubReportId + "_" + subreportid[1] + "");
                                                    holderEl.setAttribute('class', "subTable_sub_" + level + "_" + (value + 1) + " subtable");
                                                    tableEl.style.border = "1px solid #333";
                                                    tableEl.setAttribute('class', "subTable_sub" + (value + 1) + "");
                                                    tableEl.setAttribute('id', "subTable_sub" + item.ChildReportId + "_" + subreportid[1] + "");
                                                    holderEl.appendChild(tableEl);
                                                    row.getElement().appendChild(holderEl);
                                                    var subTable = new Tabulator(tableEl, {
                                                        layout: "fitColumns",
                                                        virtualDom: true,
                                                        virtualDomBuffer: 300,
                                                        columnMinWidth: 120,
                                                        movableRows: true,
                                                        tooltips: true,
                                                        movableColumns: true,
                                                        resizableColumns: !instance.isTouchScreen ? true : 'header',
                                                        cellClick: function (e, cell) {
                                                            if ($(cell.getElement()).closest('.tabulator-footer').length === 0) {
                                                                var subres = JSON.parse(subresponse.result.toString());
                                                                instance.tableCellClick(e, cell, level, mainreportid, subres, containerid);
                                                            }
                                                        }
                                                    });
                                                    let cols = [];
                                                    var subrptCols = subrpt_response.result.ReportInfo.ReportColumns;
                                                    subrptCols = subrptCols.filter(x => x.Isvisible == true);
                                                    subrptCols.forEach((c) => {
                                                        const colHozAlign = instance.getColHorizontalAlign(c);
                                                        if (subrpt_response.result.DataSourceId == Number(Platform.DataSources.Enums.DataSource.MongoDB)) {
                                                            cols.push({ title: c.DisplayText, field: c.AliasName, hozAlign: colHozAlign, headerHozAlign: colHozAlign });
                                                        }
                                                        else {
                                                            cols.push({ title: c.DisplayText, field: c.AliasName.toLowerCase(), hozAlign: colHozAlign, headerHozAlign: colHozAlign });
                                                        }
                                                    });
                                                    var subreportdata = subrpt_response.result.ReportJsonData && subrpt_response.result.ReportJsonData.Result && subrpt_response.result.ReportJsonData.Result.Data;
                                                    if (subreportdata && typeof (subreportdata) == 'string') {
                                                        subreportdata = JSON.parse(subreportdata);
                                                    }
                                                    if (subreportdata && subreportdata.length) {
                                                        let { hasImageUrl, data, tabulatorColumns } = instance.checkForImgUrlAndUpdateTableDataAndTabuCols(subrptCols, subreportdata, cols);
                                                        if (hasImageUrl) {
                                                            subreportdata = JSON.parse(data);
                                                            cols = tabulatorColumns;
                                                        }
                                                    }
                                                    subTable.setColumns(cols);
                                                    if (subreportdata && subreportdata.length) {
                                                        var subfill = subreportdata.find(s => s.RowClick == true);
                                                        if (subfill) {
                                                            var hideIcon = function (cell, formatterParams, onRendered) {
                                                                $(cell.getElement()).addClass('clickable-cell');
                                                                return "<i class='fa fa-plus' id=" + item.ChildReportId + "></i>";
                                                            };
                                                            subTable.addColumn({ formatter: hideIcon, width: 5, title: "Icon", headerSort: false }, true);
                                                        }
                                                    }
                                                    else {
                                                        $(holderEl).find(".tabulator-tableHolder").html(`<div class='alert alert-primary text-center mb-0 border-0 w-100 font-14 rounded-0'>No data available</div>`);
                                                    }
                                                    if (subrpt_response.result.ReportJsonData.TotalRecords > 15) {
                                                        subTable.element.childNodes[1].insertAdjacentHTML('beforeend', `<div class="text-center text-white my-10 bg-white-removed"> <a class="btn btn-success m-b btn-list-load-more btn-list-load-more_` + containerid + ` btncount_2" id = "btn-list-load-more_` + containerid + ` " pagination=` + containerid + `>More<i class=""> </i></a></div>`);
                                                        $(".btn-list-load-more_" + containerid).unbind().click(function (ele) {
                                                            let listsearch = $("#" + containerid).find("#ListSearch").val();
                                                            var containr = $(ele.currentTarget).attr("pagination");
                                                            var page = subTable.element.childNodes[1].lastChild.lastChild.classList[5].match(/\d+/g).map(Number)[0];
                                                            let isdynamicfilters = instance._reportViewer.isIdentityFilter(rv_instance.dynamicFilters);
                                                            let repObj = new ReportObject();
                                                            repObj.ReportId = item.ChildReportId;
                                                            repObj.Filter = subReportFilters;
                                                            repObj.LinkSubReport = true;
                                                            repObj.pageSize = instance._reportViewer.PageSize;
                                                            repObj.page = page;
                                                            repObj.IsJson = true;
                                                            repObj.FromDate = fromDate;
                                                            repObj.ToDate = toDate;
                                                            repObj.IsDynamicFilterApplied = isdynamicfilters;
                                                            instance.reportManager.getReportViewerData(repObj).then(function (res) {
                                                                var subres = JSON.parse(res.result);
                                                                subTable.addData(subres.Data, false);
                                                                subTable.element.childNodes[1].lastChild.lastChild.classList.remove('btncount_' + page + '');
                                                                subTable.element.childNodes[1].lastChild.lastChild.classList.add('btncount_' + (page + 1) + '');
                                                                let datalength = (subTable.getDataCount());
                                                                if (datalength >= subres.totalRecords) {
                                                                    $("#btn-list-load-more_" + containr + "").addClass('hidden');
                                                                }
                                                            });
                                                        });
                                                    }
                                                    if (subreportdata && subreportdata.length) {
                                                        subTable.setData(subreportdata);
                                                        let tableHeaderWidth = $("#Viewer_" + containerid + ' .tabulator-headers').width();
                                                        let viewAllTableHeaderWidth = $("#Viewer_" + containerid + '_viewall .tabulator-headers').width();
                                                        $("#Viewer_" + containerid + ' .subtable').css('width', tableHeaderWidth - 18);
                                                        $("#Viewer_" + containerid + '_viewall .subtable').css('width', viewAllTableHeaderWidth - 18);
                                                    }
                                                }
                                            });
                                        });
                                    }
                                }
                            });
                        }
                        if (!e1)
                            var e1 = window.event;
                        e1.cancelBubble = true;
                        if (e1.stopPropagation)
                            e1.stopPropagation();
                        instance.reportManager.getSubReportById(subreportid).then(function (response) {
                            if (response.status == Unibase.Data.Status.Success && response.result.length) {
                                var subreportdata = response.result;
                                if (subreportdata.length > 0) {
                                    subtablesArray(subreportdata, e, row, level, rowposition);
                                }
                            }
                        });
                    }
                    tableCellClick(e, cell, level, mainreportid, subres, containerid) {
                        var instance = this;
                        var appliedFilters = [];
                        if (subres.length != 0) {
                            var subrpt = subres.find(s => s.AliasName == cell["_cell"].column.definition.field);
                            if (subrpt) {
                                var row = cell.getRow();
                                let row_data = row.getData();
                                if (subrpt.SubReportTypeId == Unibase.Platform.Analytics.Reports.Enums.SubReportType.Detail) {
                                    var onclick = `Unibase.Platform.Helpers.NavigationHelper.Instance().loadDetail({{${subrpt.PrimaryKeyColumn}}},{{appinstalledappid}},null,null);`;
                                    onclick = onclick.replace("{{appinstalledappid}}", subrpt.InstalledAppId);
                                    onclick = onclick.replace("{{" + subrpt.PrimaryKeyColumn + "}}", row_data[subrpt.PrimaryKeyColumn]);
                                    var templateScript = Handlebars.compile(onclick);
                                    onclick = templateScript(row_data);
                                    eval(onclick);
                                }
                                else {
                                    if (!subrpt.Inline) {
                                        const rv_instance = instance._reportViewer.getReportViewerInstance(containerid);
                                        if (rv_instance && rv_instance.dynamicFilters && rv_instance.dynamicFilters.length) {
                                            const dynamicFilters = $.extend(true, [], rv_instance.dynamicFilters);
                                            dynamicFilters.forEach(filter => {
                                                filter.IsSubReportFilter = true;
                                            });
                                            appliedFilters = appliedFilters.concat(dynamicFilters);
                                        }
                                        var subRepFilters = JSON.parse(subrpt.Filters);
                                        subRepFilters = subRepFilters.filter(item1 => appliedFilters.some(item2 => item1.ParameterName === item2.ParameterName));
                                        for (var i = 0; i < subRepFilters.length; i++) {
                                            let fill = subRepFilters[i];
                                            let value = row_data[fill.ParameterName.trim()];
                                            let expid = instance.getExpId(fill.Operator);
                                            if (fill.Isvalue)
                                                value = fill.ParameterName;
                                            appliedFilters.push({
                                                ParameterName: fill.ParameterValue.trim(),
                                                ParameterValue: value.toString(),
                                                ExpOp: expid, IsSubReportFilter: true
                                            });
                                        }
                                        instance._reportViewer.dynamicFilters = appliedFilters.filter((f, i, a) => a.findIndex(f2 => (f.ParameterName === f2.ParameterName)) === i);
                                        instance._reportViewer.isSubReport = true;
                                        return instance._reportViewer.report_ViewAll(subrpt.ChildReportId, 0, "_linkedreport_" + subrpt.ChildReportId);
                                    }
                                    else {
                                        return instance.generatesubtables(e, row, level, row.getPosition(false), true, mainreportid, subrpt.SubReportId, containerid + "_" + subrpt.SubReportId);
                                    }
                                }
                            }
                        }
                    }
                    getExpId(Operator) {
                        var expid = Platform.Core.Enums.ExpressionOperator.Equals;
                        switch (Operator) {
                            case "Equals":
                                expid = Platform.Core.Enums.ExpressionOperator.Equals;
                                break;
                            case "NotEquals":
                                expid = Platform.Core.Enums.ExpressionOperator.NotEquals;
                                break;
                            case "GreaterThan":
                                expid = Platform.Core.Enums.ExpressionOperator.GreaterThan;
                                break;
                            case "GreaterThanOrEquals":
                                expid = Platform.Core.Enums.ExpressionOperator.GreaterThanOrEquals;
                                break;
                            case "LessThan":
                                expid = Platform.Core.Enums.ExpressionOperator.LessThan;
                                break;
                            case "LessThanOrEquals":
                                expid = Platform.Core.Enums.ExpressionOperator.LessThanOrEquals;
                                break;
                            case "EqualsColumn":
                                expid = Platform.Core.Enums.ExpressionOperator.EqualsColumn;
                                break;
                            case "NotEqualsColumn":
                                expid = Platform.Core.Enums.ExpressionOperator.NotEqualsColumn;
                                break;
                            case "LessThanColumn":
                                expid = Platform.Core.Enums.ExpressionOperator.LessThanColumn;
                                break;
                            case "LessThanOrEqualsColumn":
                                expid = Platform.Core.Enums.ExpressionOperator.LessThanOrEqualsColumn;
                                break;
                            case "GreaterThanColumn":
                                expid = Platform.Core.Enums.ExpressionOperator.GreaterThanColumn;
                                break;
                            case "GreaterThanOrEqualsColumn":
                                expid = Platform.Core.Enums.ExpressionOperator.GreaterThanOrEqualsColumn;
                                break;
                        }
                        return expid;
                    }
                    Export(reportid, reportname) {
                        let instance = this;
                        var obj = {
                            ReportId: Number(reportid)
                        };
                        $.when(instance.reportManager.getReportViewerData(obj)).done(function (response) {
                            if (response.Count >= 100) {
                                Unibase.Platform.Analytics.Managers.ReportManager.Instance().startDownloadLargeFile(obj).then(function (Response) {
                                });
                            }
                            else {
                                instance.exportdata = response;
                                Unibase.Platform.Analytics.Viewers.TableViewer.Instance().table.download("xlsx", "" + reportname + ".xlsx");
                            }
                        });
                    }
                    getTreeViewData(reportresponse) {
                        var instance = this;
                        if (reportresponse.result.ReportJsonData.Result.Data != "") {
                            let parentrecords = [];
                            let reportjsondata = JSON.parse(reportresponse.result.ReportJsonData.Result.Data);
                            parentrecords = reportjsondata.filter(function (col) {
                                return col.parentid == reportresponse.result.ReportInfo.PivotValue;
                            });
                            if (parentrecords.length == 0) {
                                parentrecords = reportjsondata;
                            }
                            for (var p = 0; p < parentrecords.length; p++) {
                                let childrecords = _children(parentrecords[p].childid);
                                if (childrecords != undefined) {
                                    parentrecords[p]["_children"] = [];
                                    parentrecords[p]._children = childrecords;
                                }
                            }
                            function _children(childid) {
                                let childrecords = instance.gettreeChildRecords(reportjsondata, childid);
                                if (childrecords.length > 0) {
                                    for (var c = 0; c < childrecords.length; c++) {
                                        let subchilds = _children(childrecords[c].childid);
                                        if (subchilds != undefined) {
                                            childrecords[c]["_children"] = [];
                                            childrecords[c]._children = subchilds;
                                        }
                                    }
                                    return childrecords;
                                }
                            }
                            return parentrecords;
                        }
                    }
                    gettreeChildRecords(reportjsondata, childid) {
                        return reportjsondata.filter(function (col) {
                            return col.parentid == childid;
                        });
                    }
                    loadPivotTable(reportid, containerid, reportresponse) {
                        return __awaiter(this, void 0, void 0, function* () {
                            var instance = this;
                            if (reportresponse.result != "") {
                                var maintabledata = reportresponse.result.ReportJsonData.Result;
                                if (maintabledata.Data != "") {
                                    var rptData = JSON.parse(maintabledata.Data);
                                    if (rptData != "") {
                                        instance.fileCacheHelper.loadCssFile("libs/pivottable/css/pivot.css", function () {
                                            instance.fileCacheHelper.loadJsFile("libs/pivottable/js/pivot.js", function () {
                                                instance.pivotTable(reportid, containerid, rptData);
                                            });
                                        });
                                    }
                                    else {
                                        instance.showPivotTableNoDataMsg(containerid);
                                    }
                                }
                                else {
                                    instance.showPivotTableNoDataMsg(containerid);
                                }
                            }
                            else {
                                instance.showPivotTableNoDataMsg(containerid);
                            }
                        });
                    }
                    showPivotTableNoDataMsg(containerid) {
                        $(`#Viewer_${containerid}`).html(`<div class="biz-custom-scrollbar templateviewer-body h-100"><div class="alert alert-primary text-center mb-0 border-0 rounded-0 w-100 font-14 font-weight-500">No data available</div></div>`);
                    }
                    pivotTable(reportid, containerid, rptData) {
                        var instance = this;
                        let rv_instance = instance._reportViewer.getReportViewerInstance(containerid);
                        rv_instance.pivotTableRowCols = [];
                        rv_instance.pivotTableColumnCols = [];
                        if (rv_instance.reportColumns.length != 0) {
                            for (var p = 0; p < rv_instance.reportColumns.length; p++) {
                                if (rv_instance.reportColumns[p].Isvisible) {
                                    if (rv_instance.reportColumns[p].IsPivotTableCol) {
                                        rv_instance.pivotTableColumnCols.push("" + rv_instance.reportColumns[p].AliasName + "");
                                    }
                                    else {
                                        rv_instance.pivotTableRowCols.push("" + rv_instance.reportColumns[p].AliasName + "");
                                    }
                                }
                                if (rv_instance.reportColumns[p].IsPivotAggrColumn) {
                                    rv_instance.pivotTableAggCol = rv_instance.reportColumns[p].AliasName;
                                    rv_instance.pivotTableAgg = instance.getAggregation(rv_instance.reportColumns[p].AggrFuncId);
                                }
                            }
                        }
                        var pivotTableObj = {
                            Cols: rv_instance.pivotTableColumnCols,
                            Rows: rv_instance.pivotTableRowCols,
                            AggCol: rv_instance.pivotTableAggCol,
                            PivotTableAgg: rv_instance.pivotTableAgg,
                            EnablePTConfig: rv_instance.enablePivotTableConfig
                        };
                        instance.fileCacheHelper.loadJsFileAsync("platform/analytics/enums/pivottableaggregationtype.js", function () {
                            return __awaiter(this, void 0, void 0, function* () {
                                yield instance.pivotUI(reportid, containerid, rptData, pivotTableObj);
                            });
                        });
                    }
                    getAggregation(aggid) {
                        let aggrName = "";
                        switch (aggid) {
                            case Unibase.Platform.Analytics.Reports.Enums.AggregationType.sum:
                                aggrName = "Sum";
                                break;
                        }
                        return aggrName;
                    }
                    pivotUI(reportid, containerid, rptData, pivotTableObj) {
                        return __awaiter(this, void 0, void 0, function* () {
                            var instance = this;
                            let rv_instance = instance._reportViewer.getReportViewerInstance(containerid);
                            var pt_subreportdata = [];
                            var underlineCols = [];
                            yield instance.reportManager.getSubReports(reportid).then(function (response) {
                                return __awaiter(this, void 0, void 0, function* () {
                                    if (response.status == Unibase.Data.Status.Success) {
                                        pt_subreportdata = response.result;
                                        for (var s = 0; s < pt_subreportdata.length; s++) {
                                            var col = rv_instance.reportColumns.find(x => x.ReportColumnId == pt_subreportdata[s].ReportColumnId);
                                            if (col) {
                                                underlineCols.push(col.AliasName);
                                            }
                                        }
                                    }
                                });
                            });
                            let viewerEl = $("#Viewer_" + containerid);
                            let viewerHeaderEl = $("#ViewerHeader_" + containerid);
                            const tpl = $.pivotUtilities.aggregatorTemplates;
                            let pivotAggrTypeId = 0;
                            let aggCol = [];
                            let agg = "Count";
                            if (rv_instance.reportColumns.length > 0) {
                                var rptCol = rv_instance.reportColumns.find(pt => pt.PivotTableAggrTypeId != 0);
                                if (rptCol != undefined && rptCol.PivotTableAggrTypeId != 0) {
                                    pivotAggrTypeId = rptCol.PivotTableAggrTypeId;
                                    aggCol = [rptCol.ReportColumnName];
                                }
                            }
                            if (pivotAggrTypeId == 0 && pivotTableObj.AggCol != "") {
                                aggCol = [pivotTableObj.AggCol];
                                agg = pivotTableObj.PivotTableAgg;
                            }
                            else {
                                var aggrtypeid = instance.getPivotTableAggregationType(pivotAggrTypeId);
                                agg = aggrtypeid;
                            }
                            viewerEl.pivotUI(rptData, {
                                cols: pivotTableObj.Cols,
                                rows: pivotTableObj.Rows,
                                vals: aggCol,
                                aggregatorName: agg,
                                rendererName: "Table",
                                rendererOptions: {
                                    table: {
                                        clickCallback: function (e, value, rowData, pivotData) {
                                            for (var f = 0; f < pt_subreportdata.length; f++) {
                                                var col = rv_instance.reportColumns.find(x => x.ReportColumnId == pt_subreportdata[f].ReportColumnId);
                                                if (col) {
                                                    if (col.AliasName == pivotData.colAttrs[0]) {
                                                        var filter = [];
                                                        instance._reportViewer.dateFilters = [];
                                                        var filters = JSON.parse(pt_subreportdata[f].Filters);
                                                        for (var i = 0; i < filters.length; i++) {
                                                            let fill = filters[i];
                                                            let value = rowData[fill.ParameterName.trim()];
                                                            let expid = instance.getExpId(fill.Operator);
                                                            if (fill.Isvalue)
                                                                value = fill.ParameterName;
                                                            if (fill.ParameterValue.indexOf("date") > -1) {
                                                                var dt = new Date(value.split("/").reverse().join("-"));
                                                                var dd = dt.getDate();
                                                                var mm = dt.getMonth() + 1;
                                                                var yy = dt.getFullYear();
                                                                var date = yy + "/" + mm + "/" + dd;
                                                                instance._reportViewer.dateFilters.push({ ParameterName: fill.ParameterName, FromDate: date, ToDate: date });
                                                            }
                                                            else {
                                                                filter.push({
                                                                    ParameterName: fill.ParameterValue.trim(),
                                                                    ParameterValue: value.toString(),
                                                                    ExpOp: expid
                                                                });
                                                            }
                                                        }
                                                        instance._reportViewer.dynamicFilters = filter;
                                                        return instance._reportViewer.report_ViewAll(pt_subreportdata[f].ChildReportId, 0, "_linkedreport_" + pt_subreportdata[f].ChildReportId);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                },
                                onRefresh: function (config) {
                                    const pvtTableEl = viewerEl.find('.pvtTable');
                                    $(`#exportCSVBtn_${containerid}`).removeClass('d-none');
                                    $(`#DownloadReport_${containerid}`).addClass('d-none');
                                    pvtTableEl.find('.pvtAxisLabel').each(function (i, e) {
                                        const aliasName = $(e).contents().get(0).nodeValue;
                                        const displayText = rv_instance.reportColumns.find(col => col.AliasName === aliasName).DisplayText;
                                        $(e).contents().get(0).nodeValue = displayText;
                                    });
                                    underlineCols.forEach((column) => {
                                        if (pvtTableEl.find(`.pvtAxisLabel:contains("${column}")`).siblings('.pvtColLabel').length > 0) {
                                            pvtTableEl.find('.pvtVal[data-value!="null"]').addClass('text-underline');
                                            return;
                                        }
                                        let colSpan = 0;
                                        pvtTableEl.find(`.pvtAxisLabel:contains("${column}")`).prevAll('th[colspan]').each(function (i, e) {
                                            if (Number($(e).attr("colspan")) > 0) {
                                                colSpan += Number($(e).attr("colspan"));
                                            }
                                        });
                                        if (pvtTableEl.find(`.pvtAxisLabel:contains("${column}")`).length) {
                                            let columnIndex = pvtTableEl.find(`.pvtAxisLabel:contains("${column}")`).index() + colSpan;
                                            pvtTableEl.find(`tbody tr`).each(function (i, e) {
                                                $(e).find('.pvtRowLabel').eq(columnIndex).addClass('text-underline');
                                            });
                                        }
                                    });
                                    if (rv_instance.reportResponse.result.ReportInfo.Js != "") {
                                        eval(rv_instance.reportResponse.result.ReportInfo.Js);
                                    }
                                }
                            });
                            if (!pivotTableObj.EnablePTConfig) {
                                viewerEl.find('.pvtUiCell').addClass('d-none');
                                viewerEl.find('.pvtRendererArea').addClass('pa-0');
                            }
                            Unibase.Platform.Helpers.NavigationHelper.Instance().hideLoading();
                            viewerEl.addClass('pivot-ui-tableview');
                            viewerEl.find('button').each(function (i, e) {
                                if ($(e).text().toLowerCase().includes('cancel')) {
                                    $(e).addClass('btn btn-outline-danger btn-sm');
                                }
                                else {
                                    $(e).addClass('btn btn-primary btn-sm');
                                }
                            });
                        });
                    }
                    getPivotTableAggregationType(aggrTypeId) {
                        var aggrName = "";
                        switch (aggrTypeId) {
                            case Analytics.Reports.Enums.PivotTableAggregationType.Count:
                                aggrName = "Count";
                                break;
                            case Analytics.Reports.Enums.PivotTableAggregationType.ListUniqueValues:
                                aggrName = "List Unique Values";
                                break;
                        }
                        return aggrName;
                    }
                    pivotMoreButtonClick(containerid, reportid, rptData) {
                        var instance = this;
                        let rv_instance = instance._reportViewer.getReportViewerInstance(containerid);
                        $(".pvtUi").remove();
                        var pivotTableObj = {
                            Cols: rv_instance.pivotTableColumnCols,
                            Rows: rv_instance.pivotTableRowCols,
                            AggCol: rv_instance.pivotTableAggCol,
                            EnablePTConfig: rv_instance.enablePivotTableConfig
                        };
                        instance.pivotUI(reportid, containerid, rptData, pivotTableObj);
                    }
                    applySorting(ContainerId, AliasName, Order) {
                        let rv_ins = Unibase.Platform.Analytics.Components.ReportViewer.Instance().getReportViewerInstance(ContainerId);
                        let col = rv_ins.reportColumns.find(x => x.AliasName == AliasName);
                        if (col) {
                            if (typeof (rv_ins.sortColumn) == 'string')
                                rv_ins.sortColumn = JSON.parse(rv_ins.sortColumn);
                            let sortCol = rv_ins.sortColumn.find(x => x.Name == AliasName);
                            if (sortCol) {
                                sortCol.Order = Order;
                            }
                            else {
                                rv_ins.sortColumn = [{ Name: AliasName, Order: Order }];
                            }
                            rv_ins.getReportData(rv_ins.ReportId, ContainerId, "", "");
                        }
                    }
                    applyTableDynamicFiltering(ContainerId, AliasName) {
                        let rv_ins = Unibase.Platform.Analytics.Components.ReportViewer.Instance().getReportViewerInstance(ContainerId);
                        let dropDownElement = $("#" + ContainerId).find(`#dropdown_menu_${AliasName}`);
                        if (dropDownElement.length) {
                            let option1Val = dropDownElement.find(`#dynamic_filtering_${AliasName}_value1`).val();
                            let option2Val = dropDownElement.find(`#dynamic_filtering_${AliasName}_value2`).val();
                            let expOp1Text = dropDownElement.find(`#dynamic_filtering_${AliasName}_exp1`).find(":selected").text();
                            let expOp2Text = dropDownElement.find(`#dynamic_filtering_${AliasName}_exp2`).find(":selected").text();
                            let expOpJoinOp = Number(dropDownElement.find(`#dynamic_filtering_${AliasName}_operator`).val()) + 1;
                            if (option1Val) {
                                if (!rv_ins.tableDynamicFilters.find(x => x.Key == AliasName && x.Value == option1Val)) {
                                    rv_ins.inputParameters.push({ Key: AliasName, Value: option1Val, ExpOp: this.getOperatorForTableDynamicFilter(expOp1Text) });
                                    rv_ins.tableDynamicFilters.push({ Key: AliasName, Value: option1Val, ExpOp: this.getOperatorForTableDynamicFilter(expOp1Text) });
                                }
                            }
                            if (option2Val) {
                                if (!rv_ins.tableDynamicFilters.find(x => x.Key == AliasName && x.Value == option2Val)) {
                                    rv_ins.inputParameters.push({ Key: AliasName, Value: option2Val, ExpOp: this.getOperatorForTableDynamicFilter(expOp2Text), ConjectiveOp: expOpJoinOp });
                                    rv_ins.tableDynamicFilters.push({ Key: AliasName, Value: option2Val, ExpOp: this.getOperatorForTableDynamicFilter(expOp2Text), ConjectiveOp: expOpJoinOp });
                                }
                            }
                            rv_ins.loadFilteredReport(rv_ins.ReportId, 0, ContainerId);
                        }
                    }
                    clearTableDynamicFiltering(ContainerId, AliasName) {
                        let rv_ins = Unibase.Platform.Analytics.Components.ReportViewer.Instance().getReportViewerInstance(ContainerId);
                        let ipIdx = rv_ins.inputParameters.findIndex(x => x.Key == AliasName);
                        let tdfIdx = rv_ins.tableDynamicFilters.findIndex(x => x.Key == AliasName);
                        while (ipIdx > -1) {
                            rv_ins.inputParameters.splice(ipIdx, 1);
                            ipIdx = rv_ins.inputParameters.findIndex(x => x.Key == AliasName);
                        }
                        while (tdfIdx > -1) {
                            rv_ins.tableDynamicFilters.splice(tdfIdx, 1);
                            ipIdx = rv_ins.tableDynamicFilters.findIndex(x => x.Key == AliasName);
                        }
                        let dropDownElement = $("#" + ContainerId).find(`#dropdown_menu_${AliasName}`);
                        if (dropDownElement.length) {
                            dropDownElement.find(`#dynamic_filtering_${AliasName}_value1`).val("");
                            dropDownElement.find(`#dynamic_filtering_${AliasName}_value2`).val("");
                            dropDownElement.find(`#dynamic_filtering_${AliasName}_exp1`).val("0");
                            dropDownElement.find(`#dynamic_filtering_${AliasName}_exp2`).val("0");
                            dropDownElement.find(`#dynamic_filtering_${AliasName}_operator`).val("0");
                        }
                        rv_ins.loadFilteredReport(rv_ins.ReportId, 0, ContainerId);
                    }
                    getOperatorForTableDynamicFilter(OperatorName) {
                        let exp;
                        switch (OperatorName) {
                            case "is equal to":
                                exp = Platform.Core.Enums.ExpressionOperator.Equals;
                                break;
                            case "Is not equal to":
                                exp = Platform.Core.Enums.ExpressionOperator.NotEquals;
                                break;
                            case "Starts with":
                                exp = Platform.Core.Enums.ExpressionOperator.StartsWith;
                                break;
                            case "Contains":
                                exp = Platform.Core.Enums.ExpressionOperator.Contains;
                                break;
                            case "Does not contain":
                                exp = Platform.Core.Enums.ExpressionOperator.DoesNotContains;
                                break;
                            case "Ends with":
                                exp = Platform.Core.Enums.ExpressionOperator.EndsWith;
                                break;
                            case "Is null":
                                exp = Platform.Core.Enums.ExpressionOperator.IsNull;
                                break;
                            case "Is not null":
                                exp = Platform.Core.Enums.ExpressionOperator.IsNotNull;
                                break;
                            case "Is empty":
                                exp = Platform.Core.Enums.ExpressionOperator.Empty;
                                break;
                            case "Is not empty":
                                exp = Platform.Core.Enums.ExpressionOperator.NotEmpty;
                                break;
                        }
                        return exp;
                    }
                    bindTableDynamicfiltersIfExists(containerId) {
                        let rv_instance = Unibase.Platform.Analytics.Components.ReportViewer.Instance().getReportViewerInstance(containerId);
                        if (rv_instance && rv_instance.tableDynamicFilters && rv_instance.tableDynamicFilters.length) {
                            var fils = rv_instance.tableDynamicFilters;
                            for (var i = 0; i < fils.length; i++) {
                                let fil = fils[i];
                                let col = $(`[tabulator-field='${fil.Key}'].tabulator-col`);
                                if (fil.ConjectiveOp) {
                                    col.find(`#dynamic_filtering_${fil.Key}_value2`).val(fil.Value);
                                    col.find(`#dynamic_filtering_${fil.Key}_exp2`).val(fil.ExpOp - 1);
                                    col.find(`#dynamic_filtering_${fil.Key}_operator`).val(fil.ConjectiveOp - 1);
                                }
                                else {
                                    col.find(`#dynamic_filtering_${fil.Key}_value1`).val(fil.Value);
                                    col.find(`#dynamic_filtering_${fil.Key}_exp1`).val(fil.ExpOp - 1);
                                }
                            }
                        }
                    }
                    bindWidgetConfigurations(containerid, rows) {
                        this.fileCacheHelper.loadJsFiles(["platform/forms/managers/formmanager.js", "platform/forms/components/formviewer/formviewer.js", "platform/core/helpers/token/tokenhelper.js"], () => {
                            let rv_instance = Unibase.Platform.Analytics.Components.ReportViewer.Instance().getReportViewerInstance(containerid);
                            if (rv_instance.js) {
                                let { jsToEval, statusconditions, widgetconditions } = this.getWidgetConfigsHtml(rv_instance.js, containerid);
                                if (jsToEval) {
                                    var templateScript = Handlebars.compile(jsToEval);
                                    for (var i = 0; i < rv_instance.table.rowManager.activeRows.length; i++) {
                                        var rowElement = rv_instance.table.rowManager.activeRows[i].element;
                                        var rowsData = rv_instance.table.rowManager.activeRows[i].data;
                                        let compliedScript = templateScript(rowsData);
                                        eval(compliedScript);
                                    }
                                }
                                if (statusconditions) {
                                    if (rows != null) {
                                        for (var i = 0; i < rows.length; i++) {
                                            var model = rows[i];
                                            var condition = Unibase.Core.Helpers.TokenHelper.Instance().replace(statusconditions, model);
                                            eval(condition);
                                        }
                                    }
                                }
                                if (widgetconditions) {
                                    widgetconditions = widgetconditions.replaceAll("\\", "");
                                    eval(widgetconditions);
                                }
                            }
                        });
                    }
                    getWidgetConfigsHtml(jsToEval, containerId) {
                        let rv_ins = Unibase.Platform.Analytics.Components.ReportViewer.Instance().getReportViewerInstance(containerId);
                        let _queryParser = Unibase.Platform.DataSources.Components.QueryParser.Instance();
                        let _templateViewer = Unibase.Platform.Analytics.Viewers.TemplateViewer.Instance();
                        var statusconditions = "";
                        var designhtml = '';
                        var widgetconditions = '';
                        var sub = '';
                        let portletWidgetId = Number(containerId.split("_")[2]);
                        let htmlIdx = jsToEval.indexOf("html(");
                        if (htmlIdx != -1) {
                            let htmlStartString = jsToEval.slice(htmlIdx + 5);
                            let closingIdx = _queryParser.getIndexOfCorrespondingCloseBracket(htmlStartString);
                            let widgetHtml = htmlStartString.substring(0, closingIdx - 1);
                            widgetHtml = widgetHtml.replaceAll("\\", "").replaceAll("`", "");
                            let TemplateText = HtmlHelper.getHelper().decode(widgetHtml);
                            let widgetitemid = $(TemplateText).find("#hf_widgetitem_Id").val();
                            if (TemplateText.indexOf('widgetitem_config') > -1) {
                                var detailsub = jsToEval.substring(jsToEval.indexOf('widgetitem_config') - 15, jsToEval.indexOf('widgetitem_config') + 40);
                                sub = detailsub.substring(detailsub.indexOf('<div'), detailsub.indexOf('</div>') + 6);
                                if (rv_ins.reportWidgetData != null) {
                                    if (rv_ins.reportWidgetData.AppConfigurations.WidgetItemGrouped.length != 0) {
                                        var widgetitemgrouped = rv_ins.reportWidgetData.AppConfigurations.WidgetItemGrouped;
                                        designhtml = `<div class='dropdown widget-item-config-dp'><a href='javascript:;' class='no-caret pull-right dropdown-link btn btn-icon btn-flush-biz-theme btn-rounded flush-soft-hover w-25p h-25p' data-toggle='dropdown'><span class="btn-icon-wrap"><i class='fa fa-ellipsis-h dropdown-icon text-dark'></i></span></a><ul class='dropdown-menu pull-right clearfix'><li class='dropdown-menu-item hidden'>`;
                                        for (var i = 0; i < widgetitemgrouped.length; i++) {
                                            var sname = widgetitemgrouped[i].SettingName.replace(/ /g, '');
                                            var onlickurl = "";
                                            let jsfunction1 = "";
                                            if (widgetitemgrouped[i].JsFunction != null && widgetitemgrouped[i].JsFunction != "")
                                                jsfunction1 = HtmlHelper.getHelper().decode(widgetitemgrouped[i].JsFunction);
                                            if (widgetitemgrouped[i].SettingUrlType == 4) {
                                                statusconditions += HtmlHelper.getHelper().decode(widgetitemgrouped[i].JsFunction);
                                                var onclick = widgetitemgrouped[i].SettingUrl.replace(/ /g, '');
                                                onlickurl = onclick;
                                            }
                                            else {
                                                onlickurl = _templateViewer.load_appconfigurations(widgetitemgrouped[i], TemplateText, portletWidgetId);
                                                if (jsfunction1 != null && jsfunction1 != "") {
                                                    if (jsfunction1.indexOf("{{") > -1 || jsfunction1.indexOf("}}") > -1) {
                                                        statusconditions += jsfunction1 + ";";
                                                    }
                                                    else {
                                                        widgetconditions += jsfunction1 + ";";
                                                    }
                                                }
                                            }
                                            if (!Unibase.Themes.Compact.Components.Details.Instance().isSystemLock || (Unibase.Themes.Compact.Components.Details.Instance().isSystemLock && widgetitemgrouped[i].ExcludeFromLock)) {
                                                designhtml += '<li id="li_' + containerId + '"><a class="dropdown-item" href="javascript:;" id="widgetconfig_' + widgetitemid + '_' + sname + '" onclick="' + onlickurl + '">' + widgetitemgrouped[i].SettingName + '</a></li>';
                                            }
                                        }
                                        designhtml += "</li></ul></div>";
                                        _templateViewer.autoFixConfigDpVisibility(containerId);
                                    }
                                    if (rv_ins.reportWidgetData.AppConfigurations.WidgetItemUnGrouped.length != 0) {
                                        designhtml += "<div class='pull-right'>";
                                        var WidgetItemUnGrouped = rv_ins.reportWidgetData.AppConfigurations.WidgetItemUnGrouped;
                                        for (var i = 0; i < WidgetItemUnGrouped.length; i++) {
                                            var sname = WidgetItemUnGrouped[i].SettingName.replace(/ /g, '');
                                            let jsfunction2 = "";
                                            if (WidgetItemUnGrouped[i].JsFunction != null && WidgetItemUnGrouped[i].JsFunction != "")
                                                jsfunction2 = HtmlHelper.getHelper().decode(WidgetItemUnGrouped[i].JsFunction);
                                            onlickurl = WidgetItemUnGrouped[i].SettingUrl;
                                            if (jsfunction2 != null && jsfunction2 != "") {
                                                if (jsfunction2.indexOf("{{") > -1 || jsfunction2.indexOf("}}") > -1) {
                                                    statusconditions += jsfunction2 + ";";
                                                }
                                                else {
                                                    widgetconditions += jsfunction2 + ";";
                                                }
                                            }
                                            if (!Unibase.Themes.Compact.Components.Details.Instance().isSystemLock || (Unibase.Themes.Compact.Components.Details.Instance().isSystemLock && WidgetItemUnGrouped[i].ExcludeFromLock)) {
                                                designhtml += ' <span class="mr-10"><a href="javascript:;"  id="widgetconfig_' + widgetitemid + '_' + sname + '" onclick="' + onlickurl + '">' +
                                                    '<i class="' + WidgetItemUnGrouped[i].Icon + '"></i>' +
                                                    '</a> </span>';
                                            }
                                        }
                                        designhtml += "</div>";
                                    }
                                    jsToEval = jsToEval.replace(sub, designhtml);
                                    let iconhtml = "";
                                    let threeDotsHtml = '<div class="mx-2 my-auto"><a href="javascript:void(0);" id="dropdownMenuButton_' + containerId + '" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"><i class="fa fa-ellipsis-v"></i></a><div class="dropdown-menu drop-Button_' + containerId + '" aria-labelledby="dropdownMenuButton_"' + containerId + '></div></div>';
                                    if (rv_ins.reportWidgetData.AppConfigurations != null && rv_ins.reportWidgetData.Data.ReportId == rv_ins.ReportId) {
                                        var widgetcreate = rv_ins.reportWidgetData.AppConfigurations.WidgetGrouped.filter(o => o.AppConfigType === 3);
                                        if (widgetcreate.length > 0) {
                                            var onlickurl_grouped = "";
                                            for (var i = 0; i < widgetcreate.length; i++) {
                                                var createjsfunction = "";
                                                var settingdesignhtml = "";
                                                if (widgetcreate[i].JsFunction != null && widgetcreate[i].JsFunction != "")
                                                    createjsfunction = HtmlHelper.getHelper().decode(widgetcreate[i].JsFunction);
                                                if (widgetcreate[i].SettingDesignHtml != null && widgetcreate[i].SettingDesignHtml != "")
                                                    settingdesignhtml = HtmlHelper.getHelper().decode(widgetcreate[i].SettingDesignHtml);
                                                onlickurl_grouped = _templateViewer.load_appconfigurations(widgetcreate[i], TemplateText, portletWidgetId);
                                                if (!Unibase.Themes.Compact.Components.Details.Instance().isSystemLock || (Unibase.Themes.Compact.Components.Details.Instance().isSystemLock && widgetcreate[i].ExcludeFromLock)) {
                                                    let details_btn_p = 'pr-3';
                                                    if (Unibase.Platform.Membership.Infos.Identity.getCurrentUser().isAdmin) {
                                                        details_btn_p = '';
                                                    }
                                                    if ((widgetcreate[i].Icon == "null" || widgetcreate[i].Icon == "") && widgetcreate[i].SettingUrlType == 3) {
                                                        iconhtml += '<span class="' + details_btn_p + '"><a href="javascript:;" class="nav-link biz-highlight-bg-color"  id="LinkButton" title="' + widgetcreate[i].SettingName + '" onclick="' + onlickurl_grouped + '"><i class=""></i>' + settingdesignhtml + '</a></span>';
                                                    }
                                                    else if ((widgetcreate[i].Icon == "null" || widgetcreate[i].Icon == "") && (widgetcreate[i].SettingUrlType == 10 || widgetcreate[i].SettingUrlType == 11)) {
                                                        iconhtml += '<span class="' + details_btn_p + '"><a href="javascript:;" class="nav-link biz-highlight-bg-color btn btn-sm btn-outline-primary"  id="LinkButton" title="' + widgetcreate[i].SettingName + '" onclick="' + onlickurl_grouped + '">' + widgetcreate[i].SettingName + '</a></span>';
                                                    }
                                                    else {
                                                        iconhtml += '<span class="' + details_btn_p + '"><a href="javascript:;" class="nav-link biz-highlight-bg-color"  id="LinkButton" title="' + widgetcreate[i].SettingName + '" onclick="' + onlickurl_grouped + '"><i class="' + widgetcreate[i].Icon + '"></i></a></span>';
                                                    }
                                                }
                                                if (createjsfunction != null && createjsfunction != "") {
                                                    if (createjsfunction.indexOf("{{") > -1 || createjsfunction.indexOf("}}") > -1) {
                                                        statusconditions += createjsfunction + ";";
                                                    }
                                                    else {
                                                        widgetconditions += createjsfunction + ";";
                                                    }
                                                }
                                            }
                                            $(".sp_widget_create_" + containerId + "").addClass('d-flex flex-row align-items-center');
                                            $(".sp_widget_create_" + containerId + "").html(iconhtml);
                                        }
                                        let widgetUngrouped = rv_ins.reportWidgetData.AppConfigurations.WidgetUnGrouped.filter(function (o) { return o.AppConfigType === 3; });
                                        if (widgetUngrouped.length > 0) {
                                            $(".sp_widget_create_" + containerId).parent().addClass('align-items-center').append(threeDotsHtml);
                                            let onlickurl_ungrouped = "", Ungroupedhtml = '';
                                            for (var i = 0; i < widgetUngrouped.length; i++) {
                                                var jsfunction = HtmlHelper.getHelper().decode(widgetUngrouped[i].JsFunction);
                                                onlickurl_ungrouped = _templateViewer.load_appconfigurations(widgetUngrouped[i], TemplateText, portletWidgetId);
                                                if (!Unibase.Themes.Compact.Components.Details.Instance().isSystemLock || (Unibase.Themes.Compact.Components.Details.Instance().isSystemLock && widgetcreate[i].ExcludeFromLock)) {
                                                    if (widgetUngrouped[i].Icon == "null" || widgetUngrouped[i].Icon == "" && widgetUngrouped[i].SettingUrlType == 3) {
                                                        Ungroupedhtml += '<a href="javascript:;" class="nav-link biz-highlight-bg-color"  id="LinkButton" title="' + widgetUngrouped[i].SettingName + '" onclick="' + onlickurl_ungrouped + '"><i class=""></i>' + HtmlHelper.getHelper().decode(widgetUngrouped[i].SettingDesignHtml) + '</a>';
                                                    }
                                                    else {
                                                        Ungroupedhtml += '<a href="javascript:;" class="nav-link d-flex flex-row"  id="LinkButton" title="' + widgetUngrouped[i].SettingName + '" onclick="' + onlickurl_ungrouped + '"><span>' + widgetUngrouped[i].SettingName + '</span><i class="ml-auto my-auto font-14 ' + widgetUngrouped[i].Icon + '"></i></a>';
                                                    }
                                                }
                                                if (jsfunction != null && jsfunction != "") {
                                                    if (jsfunction.indexOf("{{") > -1 || jsfunction.indexOf("}}") > -1) {
                                                        statusconditions += jsfunction + ";";
                                                    }
                                                    else {
                                                        widgetconditions += jsfunction + ";";
                                                    }
                                                }
                                            }
                                            $('.drop-Button_' + containerId).empty().append(Ungroupedhtml);
                                        }
                                    }
                                }
                            }
                        }
                        return { jsToEval, statusconditions, widgetconditions };
                    }
                    setGroupBy(rv_instance, containerid, rows) {
                        return __awaiter(this, void 0, void 0, function* () {
                            if (rv_instance.tblGroupedCols && rv_instance.tblGroupedCols.length) {
                                rv_instance.table.options.dataTree = false;
                                yield rv_instance.table.setGroupBy(rv_instance.tblGroupedCols);
                            }
                            if (rv_instance.js) {
                                this.bindWidgetConfigurations(containerid, rows);
                            }
                        });
                    }
                    static Instance() {
                        if (this._instance === undefined)
                            this._instance = new TableViewer();
                        return this._instance;
                    }
                }
                Viewers.TableViewer = TableViewer;
            })(Viewers = Analytics.Viewers || (Analytics.Viewers = {}));
        })(Analytics = Platform.Analytics || (Platform.Analytics = {}));
    })(Platform = Unibase.Platform || (Unibase.Platform = {}));
})(Unibase || (Unibase = {}));