@progress/telerik-jquery-report-viewer
Version:
Progress® Telerik® Report Viewer for jQuery
1,204 lines (1,201 loc) • 41.8 kB
JavaScript
import { tryParseInt, logError, isInvalidClientException, isInternalServerError, isApplicationException, getExceptionInstance, stringFormat, parseJSON, escapeHtml, isSystemArgumentException, exceptionTypeNamesMatch, isSvgSupported } from './utils.js';
import { stringResources } from './stringResources.js';
import { PrintManager } from './print.js';
import { ParameterValidators } from './parameterValidators.js';
import { ViewModes, PageModes, PrintModes, ScaleModes } from './enums.js';
import { ServiceClientSentinel } from './service-client-sentinel.js';
import { EventEmitter } from './event-emitter.js';
var defaultOptions = {
pagePollIntervalMs: 500,
documentInfoPollIntervalMs: 2e3
};
function ReportViewerController(options) {
var controller = {};
var clientId;
var reportInstanceId;
var reportDocumentId;
var registerClientPromise;
var registerInstancePromise;
var documentFormatsPromise;
var report;
var parameterValues;
var processedParameterValues;
var currentPageNumber;
var pageCount;
var viewMode = ViewModes.INTERACTIVE;
var pageMode = PageModes.CONTINUOUS_SCROLL;
var loader;
var printMode = PrintModes.AUTO_SELECT;
var bookmarkNodes;
var renderingExtensions;
var clientHasExpired = false;
var parameterValidators = ParameterValidators;
var eventEmitter = new EventEmitter();
var serviceClientSentinel;
clearReportState();
options = $.extend({}, defaultOptions, options);
var settings = options.settings;
if (typeof settings.getPrintMode === "function") {
printMode = settings.getPrintMode();
}
var client = options.serviceClient;
if (!client) {
throw stringResources.noServiceClient;
}
clientId = settings.getClientId();
initializeAndStartSentinel();
function setClientId(id) {
clientId = id;
stopSentinel();
settings.setClientId(clientId);
initializeAndStartSentinel();
}
function clearClientId() {
clientId = null;
registerClientPromise = null;
stopSentinel();
serviceClientSentinel = null;
settings.setClientId(null);
}
function initializeAndStartSentinel() {
if (typeof settings.getKeepClientAlive !== "function") {
throw new Error("Required settings.getKeepClientAlive() is not supplied for ReportViewerController");
}
if (settings.getKeepClientAlive() && clientId) {
return client.getClientsSessionTimeoutSeconds().then(function(sessionTimeout) {
serviceClientSentinel = new ServiceClientSentinel(client, clientId, sessionTimeout);
serviceClientSentinel.start();
});
}
}
function stopSentinel() {
if (settings.getKeepClientAlive() && !!serviceClientSentinel) {
serviceClientSentinel.stop();
}
}
function getFormat() {
if (viewMode === ViewModes.PRINT_PREVIEW) {
return "HTML5";
}
return "HTML5Interactive";
}
function handleRequestError(xhrData, localizedMessage, suppressErrorBubbling) {
var errorMessage = "";
if (!xhrData.xhr) {
errorMessage = xhrData;
controller.raiseError(formatXhrError({ "responseText": errorMessage }, null, null, null));
throw errorMessage;
}
var xhr = xhrData.xhr;
if (isInvalidClientException(xhr)) {
onClientExpired();
}
var formattedError = formatXhrError(
xhr,
xhrData.status,
isInternalServerError(xhrData.error) ? "" : xhrData.error,
localizedMessage
);
controller.raiseError(formattedError);
if (!suppressErrorBubbling) {
if (isApplicationException(xhr)) {
var exception = getExceptionInstance(xhr);
if (exception) {
throw exception;
}
}
throw xhr.responseJSON && xhr.responseJSON.exceptionMessage ? xhr.responseJSON.exceptionMessage : stringResources.promisesChainStopError;
}
}
function initializeClientAsync() {
if (!registerClientPromise) {
registerClientPromise = client.registerClient().catch(function(xhrErrorData) {
handleRequestError(xhrErrorData, stringResources.errorRegisteringViewer);
}).then(function(clientId2) {
setClientId(clientId2);
}).catch(clearClientId);
}
return registerClientPromise;
}
function registerInstanceAsync() {
if (!registerInstancePromise) {
registerInstancePromise = createReportInstanceAsync(report, parameterValues).then(function(instanceId) {
reportInstanceId = instanceId;
});
registerInstancePromise.catch(function(errorMessage) {
registerInstancePromise = null;
});
}
return registerInstancePromise;
}
function clearReportState() {
reportDocumentId = null;
reportInstanceId = null;
registerInstancePromise = null;
resetPageNumbers();
}
function resetPageNumbers() {
currentPageNumber = pageCount = 0;
}
function formatError(args) {
var len = args.length;
if (len === 1) {
return args[0];
}
if (len > 1) {
return stringFormat(args[0], Array.prototype.slice.call(args, 1));
}
return "";
}
function createReportInstanceAsync(report2, parameterValues2) {
throwIfNotInitialized();
return client.createReportInstance(clientId, report2, parameterValues2).catch(function(xhrErrorData) {
handleRequestError(xhrErrorData, stringFormat(stringResources.errorCreatingReportInstance, [escapeHtml(report2)]));
});
}
function registerDocumentAsync(format, deviceInfo, useCache, baseDocumentId, actionId) {
throwIfNotInitialized();
throwIfNoReportInstance();
return client.createReportDocument(clientId, reportInstanceId, format, deviceInfo, useCache, baseDocumentId, actionId).catch(function(xhrErrorData) {
handleRequestError(xhrErrorData, stringFormat(stringResources.errorCreatingReportDocument, [escapeHtml(report), escapeHtml(format)]));
});
}
function sendDocumentAsync(documentId, args) {
throwIfNotInitialized();
throwIfNoReportInstance();
return client.sendDocument(clientId, reportInstanceId, documentId, args).catch(function(xhrErrorData) {
handleRequestError(xhrErrorData, stringFormat(stringResources.errorSendingDocument, [escapeHtml(report)]));
});
}
function getDocumentInfoRecursive(clientId2, instanceId, documentId, options2) {
if (!options2.isCanceled && instanceId === reportInstanceId) {
return client.getDocumentInfo(clientId2, instanceId, documentId).catch(handleRequestError).then(function(info) {
if (info && info.documentReady) {
return info;
}
info["promise"] = new Promise(function(resolve, reject) {
window.setTimeout(resolve, options2.documentInfoPollIntervalMs);
}).then(function() {
return getDocumentInfoRecursive(clientId2, instanceId, documentId, options2);
});
return info;
});
}
return Promise.reject();
}
function ReportLoader(reportHost, useCache, baseDocumentId, actionId) {
var loaderOptions = {};
function onReportDocumentRegistered(id) {
if (reportHost) {
reportDocumentId = id;
onBeginLoadReport();
getReportDocumentReady();
}
}
function onBeforeLoadReport(args) {
loaderOptions.documentInfoPollIntervalMs = options.pagePollIntervalMs;
if (reportHost) {
reportHost.beforeLoadReport(args);
}
}
function onBeginLoadReport() {
if (reportHost) {
reportHost.beginLoadReport();
}
}
function onReportLoadComplete(info) {
if (reportHost) {
reportHost.onReportLoadComplete(info);
}
}
function onReportLoadProgress(info) {
if (reportHost) {
pageCount = info.pageCount;
reportHost.reportLoadProgress(info);
}
}
function getReportDocumentReady() {
throwIfNotInitialized();
throwIfNoReportInstance();
throwIfNoReportDocument();
progressReportDocumentReady(getDocumentInfoRecursive(clientId, reportInstanceId, reportDocumentId, loaderOptions));
}
function progressReportDocumentReady(getDocumentReadyPromise) {
getDocumentReadyPromise.then(function(info) {
if (info.documentReady) {
onReportLoadComplete(info);
} else {
onReportLoadProgress(info);
progressReportDocumentReady(info.promise);
}
});
}
function getPageAsync(pageNo) {
return new Promise(function(resolve, reject) {
var fn = function() {
client.getPage(clientId, reportInstanceId, reportDocumentId, pageNo).catch(handleRequestError).then(function(pageInfo) {
if (pageInfo.pageReady) {
resolve(pageInfo);
} else {
window.setTimeout(fn, options.pagePollIntervalMs);
}
});
};
fn();
});
}
function onBeginLoadPage(pageNo) {
if (reportHost) {
reportHost.beginLoadPage(pageNo);
}
}
var loadPromise;
function loadAsync() {
if (!loadPromise) {
var format = getFormat();
var deviceInfo = createPreviewDeviceInfo();
onBeforeLoadReport({ deviceInfo });
loadPromise = initializeClientAsync().then(registerInstanceAsync).then(function() {
return registerDocumentAsync(format, deviceInfo, useCache, baseDocumentId, actionId);
}).then(onReportDocumentRegistered);
}
return loadPromise;
}
function createPreviewDeviceInfo() {
var deviceInfo = createDeviceInfo();
deviceInfo.ContentOnly = true;
deviceInfo.UseSVG = isSvgSupported();
return deviceInfo;
}
return {
beginLoad: function() {
loadAsync();
},
beginGetPage: function(pageNo) {
throwIfNotInitialized();
loadAsync().then(function() {
onBeginLoadPage(pageNo);
return getPageAsync(pageNo);
}).then(function(pageInfo) {
loaderOptions.documentInfoPollIntervalMs = options.documentInfoPollIntervalMs;
if (reportHost) {
reportHost.pageReady(pageInfo);
}
});
},
getPageData: function(pageNo) {
throwIfNotInitialized();
return loadAsync().then(function() {
return getPageAsync(pageNo);
});
},
dispose: function() {
reportHost = null;
},
cancel: function() {
loaderOptions.isCanceled = true;
}
};
}
function createDeviceInfo() {
var deviceInfo = {};
if (settings.getEnableAccessibility()) {
deviceInfo.enableAccessibility = true;
deviceInfo.contentTabIndex = settings.contentTabIndex;
}
var args = {};
controller.getSearchDialogState(args);
var searchInitiated = args.visible;
var searchMetadataOnDemand = settings.getSearchMetadataOnDemand();
var enableSearch = !searchMetadataOnDemand || searchInitiated;
deviceInfo.enableSearch = enableSearch;
return deviceInfo;
}
function tryResolveClientErrorByExceptionType(exceptionType) {
var parameterExceptionShortName = "InvalidParameterException";
return exceptionTypeNamesMatch(exceptionType, parameterExceptionShortName, "Telerik.Reporting.Services.Engine." + parameterExceptionShortName) ? stringResources.missingOrInvalidParameter : "";
}
function formatXhrError(xhr, status, error, localizedMessage) {
var parsedXhr = parseJSON(xhr.responseText);
var result = "";
if (parsedXhr) {
var errorMessage = tryResolveClientErrorByExceptionType(parsedXhr.exceptionType || parsedXhr.error);
if (errorMessage) {
return errorMessage;
}
result = escapeHtml(parsedXhr.message);
var exceptionMessage = escapeHtml(parsedXhr.exceptionMessage || parsedXhr.error_description);
if (exceptionMessage) {
if (result) {
result += " " + exceptionMessage;
} else {
result = exceptionMessage;
}
}
} else {
result = escapeHtml(xhr.responseText);
}
if (localizedMessage || error) {
if (result) {
result = " " + result;
}
result = escapeHtml(localizedMessage ? localizedMessage : error) + result;
}
if (isInvalidClientException(xhr)) {
result += "<br />" + stringResources.clientExpired;
}
return result;
}
function getReportPage(pageNo) {
if (loader) {
loader.beginGetPage(pageNo);
}
}
function loadReportAsync(ignoreCache, baseDocumentId, actionId) {
if (!report) {
controller.raiseError(stringResources.noReport);
return;
}
if (loader) {
loader.dispose();
loader = null;
}
clearReportState();
loader = new ReportLoader(controller, !ignoreCache, baseDocumentId, actionId);
loader.beginLoad();
}
function printReport() {
throwIfNoReport();
var deviceInfo = {
ImmediatePrint: true
};
var printStartArgs = {
deviceInfo,
handled: false
};
controller.printStarted(printStartArgs);
if (!printStartArgs.handled) {
controller.setUIState({
operationName: "PrintInProgress",
inProgress: true
});
controller.showNotification({ stringResources: "preparingPrint" });
var canUsePlugin = getCanUsePlugin();
var contentDisposition = canUsePlugin ? "inline" : "attachment";
var queryString = "response-content-disposition=" + contentDisposition;
exportAsync("PDF", deviceInfo).then(
function(info) {
var url = client.formatDocumentUrl(info.clientId, info.instanceId, info.documentId, queryString);
var printEndArgs = {
url,
handled: false
};
controller.printReady(printEndArgs);
controller.hideNotification();
controller.setUIState({
operationName: "PrintInProgress",
inProgress: false
});
if (!printEndArgs.handled) {
PrintManager.print(url);
}
}
);
}
}
function getCanUsePlugin() {
switch (printMode) {
case PrintModes.FORCE_PDF_FILE:
case false:
return false;
case PrintModes.FORCE_PDF_PLUGIN:
case true:
return true;
default:
return PrintManager.getDirectPrintState();
}
}
function exportReport(format, deviceInfo) {
throwIfNoReport();
if (!deviceInfo) {
deviceInfo = createDeviceInfo();
}
var exportStartArgs = {
format,
deviceInfo,
handled: false
};
controller.exportStarted(exportStartArgs);
if (!exportStartArgs.handled) {
var queryString = "response-content-disposition=attachment";
controller.setUIState({
operationName: "ExportInProgress",
inProgress: true
});
controller.showNotification({ stringResources: "preparingDownload" });
exportAsync(format, exportStartArgs.deviceInfo).then(
function(info) {
var url = client.formatDocumentUrl(info.clientId, info.instanceId, info.documentId, queryString);
var exportEndArgs = {
url,
format,
handled: false,
windowOpenTarget: "_self"
};
controller.exportReady(exportEndArgs);
controller.hideNotification();
controller.setUIState({
operationName: "ExportInProgress",
inProgress: false
});
if (!exportEndArgs.handled) {
window.open(url, exportEndArgs.windowOpenTarget);
}
}
);
}
}
function sendReport(args) {
throwIfNoReport();
if (!args.deviceInfo) {
args.deviceInfo = createDeviceInfo();
}
var sendEmailStartArgs = {
deviceInfo: args.deviceInfo,
handled: false,
format: args.format
};
controller.sendEmailStarted(sendEmailStartArgs);
var queryString = "response-content-disposition=attachment";
if (!sendEmailStartArgs.handled) {
exportAsync(args.format, args.deviceInfo).then(
function(info) {
var url = client.formatDocumentUrl(info.clientId, info.instanceId, info.documentId, queryString);
args["url"] = url;
args["handled"] = false;
controller.sendEmailReady(args);
delete args.deviceInfo;
if (!args.handled) {
sendDocumentAsync(info.documentId, args);
}
}
);
}
}
function exportAsync(format, deviceInfo) {
throwIfNoReport();
return initializeClientAsync().then(registerInstanceAsync).then(function() {
return registerDocumentAsync(format, deviceInfo, true, reportDocumentId);
}).then(function(documentId) {
return waitReportDocumentReady(clientId, reportInstanceId, documentId, options);
});
}
function waitReportDocumentReady(clientId2, reportInstanceId2, documentId, options2) {
return new Promise(function(resolve, reject) {
var fn = function(promise) {
promise.then(function(info) {
if (info.documentReady) {
resolve({
clientId: clientId2,
instanceId: reportInstanceId2,
documentId
});
} else {
fn(info.promise);
}
});
};
fn(getDocumentInfoRecursive(clientId2, reportInstanceId2, documentId, options2));
});
}
function execServerAction(actionId) {
throwIfNoReport();
throwIfNoReportInstance();
throwIfNoReportDocument();
onServerActionStarted();
controller.refreshReportCore(false, reportDocumentId, actionId);
}
function throwIfNotInitialized() {
if (!clientId) {
throw stringResources.controllerNotInitialized;
}
}
function throwIfNoReportInstance() {
if (!reportInstanceId) {
throw stringResources.noReportInstance;
}
}
function throwIfNoReportDocument() {
if (!reportDocumentId) {
throw stringResources.noReportDocument;
}
}
function throwIfNoReport() {
if (!report) {
throw stringResources.noReport;
}
}
function eventFactory(event, args) {
if (typeof args[0] === "function") {
eventEmitter.on(event, args[0]);
} else {
eventEmitter.trigger(event, ...args);
}
return controller;
}
function loadParametersAsync(report2, paramValues) {
return initializeClientAsync().then(function() {
return client.getParameters(clientId, report2, paramValues || parameterValues || {}).catch(function(xhrErrorData) {
handleRequestError(xhrErrorData, stringResources.unableToGetReportParameters);
});
});
}
function getDocumentFormatsAsync() {
if (renderingExtensions) {
return Promise.resolve(renderingExtensions);
}
if (!documentFormatsPromise) {
documentFormatsPromise = client.getDocumentFormats().catch(handleRequestError);
}
return documentFormatsPromise;
}
function getServiceVersionAsync() {
return client.getServiceVersion().catch(handleRequestError);
}
function getPageForBookmark(nodes, id) {
if (nodes) {
for (var i = 0, len = nodes.length; i < len; i++) {
var node = nodes[i];
if (node.id === id) {
return node.page;
}
var page = getPageForBookmark(node.items, id);
if (page) {
return page;
}
}
}
return null;
}
function fixDataContractJsonSerializer(arr) {
var dict = {};
if (Array.isArray(arr)) {
arr.forEach(function(pair) {
dict[pair.Key] = pair.Value;
});
}
return dict;
}
function changeReportSource(rs) {
setStateReportSource(rs);
controller.reportSourceChanged();
}
function setStateReportSource(rs) {
if (typeof settings.setReportSource === "function") {
settings.setReportSource(rs);
}
}
function changePageNumber(pageNr) {
settings.setPageNumber(pageNr);
controller.currentPageChanged();
}
var actionHandlers = {
"sorting": function(action) {
execServerAction(action.Id);
},
"toggleVisibility": function(action) {
execServerAction(action.Id);
},
"navigateToReport": function(action) {
var args = action.Value;
onServerActionStarted();
controller.setReportSource({
report: args.Report,
parameters: fixDataContractJsonSerializer(args.ParameterValues)
});
controller.refreshReport(false);
},
"navigateToUrl": function(action) {
var args = action.Value;
window.open(args.Url, args.Target);
},
"navigateToBookmark": function(action) {
var id = action.Value;
var page = getPageForBookmark(bookmarkNodes, id);
controller.navigateToPage(page, {
type: "bookmark",
id
});
},
"customAction": function(action) {
}
};
function onInteractiveActionExecuting(interactiveActionArgs) {
controller.interactiveActionExecuting(interactiveActionArgs);
}
function executeReportAction(interactiveActionArgs) {
var action = interactiveActionArgs.action;
var handler = actionHandlers[action.Type];
if (typeof handler === "function") {
window.setTimeout(function() {
onInteractiveActionExecuting(interactiveActionArgs);
if (!interactiveActionArgs.cancel) {
handler(action);
}
}, 0);
}
}
function onServerActionStarted() {
controller.serverActionStarted();
}
function onReportActionEnter(args) {
controller.interactiveActionEnter({
action: args.action,
element: args.element
});
}
function onReportActionLeave(args) {
controller.interactiveActionLeave({
action: args.action,
element: args.element
});
}
function onClientExpired() {
clientHasExpired = true;
controller.clientExpired();
}
function onReportToolTipOpening(args) {
controller.toolTipOpening(args);
}
function getSearchResultsAsync(args) {
if (!args.searchToken || args.searchToken === "") {
return Promise.resolve(null);
}
return client.getSearchResults(clientId, reportInstanceId, reportDocumentId, args.searchToken, args.matchCase, args.matchWholeWord, args.useRegex).catch(handleSearchResultsError);
}
function handleSearchResultsError(xhrData) {
if (!isSystemArgumentException(xhrData.xhr)) {
handleRequestError(xhrData, null, true);
throw null;
}
var exceptionDetails = parseJSON(xhrData.xhr.responseText);
throw exceptionDetails.exceptionMessage;
}
function appendInvalidReportParameterNames(invalidParameters) {
var errorElement = document.querySelector(".trv-pages-area .trv-error-message");
var invalidParametersHolder = document.createElement("ul");
for (var index = 0; index < invalidParameters.length; index++) {
var invalidParameterText = document.createElement("li");
invalidParameterText.classList.add(invalidParameters[index].name);
invalidParameterText.innerText = stringFormat("{0} ({1})", [invalidParameters[index].text, invalidParameters[index].name]);
invalidParametersHolder.appendChild(invalidParameterText);
}
errorElement.appendChild(invalidParametersHolder);
}
controller.Events = {
ERROR: "error",
EXPORT_STARTED: "exportStarted",
EXPORT_DOCUMENT_READY: "exportDocumentReady",
PRINT_STARTED: "printStarted",
PRINT_DOCUMENT_READY: "printDocumentReady",
BEFORE_LOAD_PARAMETERS: "beforeLoadParameters",
LOADED_REPORT_CHANGE: "loadedReportChange",
BEFORE_LOAD_REPORT: "beforeLoadReport",
BEGIN_LOAD_REPORT: "beginLoadReport",
REPORT_LOAD_COMPLETE: "reportLoadComplete",
REPORT_LOAD_PROGRESS: "reportLoadProgress",
REPORT_LOAD_FAIL: "reportLoadFail",
BEGIN_LOAD_PAGE: "beginLoadPage",
PAGE_READY: "pageReady",
VIEW_MODE_CHANGED: "viewModeChanged",
PAGE_MODE_CHANGED: "pageModeChanged",
PRINT_MODE_CHANGED: "printModeChanged",
REPORT_SOURCE_CHANGED: "reportSourceChanged",
NAVIGATE_TO_PAGE: "navigateToPage",
CURRENT_PAGE_CHANGED: "currentPageChanged",
GET_DOCUMENT_MAP_STATE: "trv.GET_DOCUMENT_MAP_STATE",
SET_DOCUMENT_MAP_VISIBLE: "trv.SET_DOCUMENT_MAP_VISIBLE",
GET_PARAMETER_AREA_STATE: "trv.GET_PARAMETER_AREA_STATE",
SET_PARAMETER_AREA_VISIBLE: "trv.SET_PARAMETER_AREA_VISIBLE",
SCALE_CHANGED: "scaleChanged",
SCALE_MODE_CHANGED: "scaleModeChanged",
SERVER_ACTION_STARTED: "serverActionStarted",
SET_TOGGLE_SIDE_MENU: "trv.SET_TOGGLE_SIDE_MENU",
GET_TOGGLE_SIDE_MENU: "trv.GET_TOGGLE_SIDE_MENU",
UPDATE_UI: "trv.UPDATE_UI",
CSS_LOADED: "cssLoaded",
RELOAD_PARAMETERS: "reloadParameters",
INTERACTIVE_ACTION_EXECUTING: "interactiveActionExecuting",
INTERACTIVE_ACTION_ENTER: "interactiveActionEnter",
INTERACTIVE_ACTION_LEAVE: "interactiveActionLeave",
UPDATE_UI_INTERNAL: "trv.UPDATE_UI_INTERNAL",
CLIENT_EXPIRED: "clientExpired",
TOOLTIP_OPENING: "tooltipOpening",
TOOLTIP_CLOSING: "tooltipClosing",
PAGE_NUMBER: "trv.PAGE_NUMBER",
PAGE_COUNT: "trv.PAGE_COUNT",
GET_SEARCH_DIALOG_STATE: "trv.GET_SEARCH_DIALOG_STATE",
GET_SEND_EMAIL_DIALOG_STATE: "trv.GET_SEND_EMAIL_DIALOG_STATE",
SET_SEARCH_DIALOG_VISIBLE: "trv.SET_SEARCH_DIALOG_VISIBLE",
SET_SEND_EMAIL_DIALOG_VISIBLE: "trv.SET_SEND_EMAIL_DIALOG_VISIBLE",
SEND_EMAIL_STARTED: "sendEmailStarted",
SEND_EMAIL_READY: "sendEmailDocumentReady",
SHOW_NOTIFICATION: "trv.SHOW_NOTIFICATION",
HIDE_NOTIFICATION: "trv.HIDE_NOTIFICATION",
UI_STATE: "trv.UI_STATE",
SCROLL_PAGE_READY: "scrollPageReady",
UPDATE_SCROLL_PAGE_DIMENSIONS_READY: "trv.UPDATE_SCROLL_PAGE_DIMENSIONS_READY",
MISSING_OR_INVALID_PARAMETERS: "missingOrInvalidParameters",
RENDERING_STOPPED: "renderingStopped"
};
$.extend(
controller,
{
getPageData: function(pageNumber) {
if (loader) {
return loader.getPageData(pageNumber);
}
return;
},
getReportSource: function() {
if (report === null) {
return null;
}
return {
report,
parameters: $.extend({}, parameterValues)
};
},
setReportSource: function(rs) {
if (rs === null) {
report = parameterValues = null;
clearReportState();
changeReportSource(rs);
return this;
}
report = rs.report;
parameterValues = rs.parameters;
changeReportSource(rs);
return this;
},
updateSettings: function(settings2) {
options.settings = $.extend({}, settings2, options.settings);
},
clearReportSource: function() {
report = parameterValues = null;
clearReportState();
changeReportSource(void 0);
return this;
},
getReportDocumentId: function() {
return reportDocumentId;
},
setReportDocumentId: function(documentId) {
reportDocumentId = documentId;
},
setParameters: function(paramValues) {
parameterValues = paramValues;
},
setProcessedParameter: function(processedParamValues) {
processedParameterValues = processedParamValues;
},
getPageCount: function() {
return pageCount;
},
getCurrentPageNumber: function() {
return currentPageNumber;
},
setCurrentPageNumber: function(pageNo) {
var num = tryParseInt(pageNo);
if (num !== currentPageNumber) {
currentPageNumber = num;
changePageNumber(num);
}
return this;
},
getScale: function() {
return settings.getScale();
},
setScale: function(scale) {
if (settings.getScale() !== scale) {
settings.setScale(scale);
controller.scaleChanged(scale);
controller.setScaleMode(ScaleModes.SPECIFIC);
}
return controller;
},
getScaleMode: function() {
return settings.getScaleMode();
},
setScaleMode: function(scaleMode) {
if (settings.getScaleMode() !== scaleMode) {
settings.setScaleMode(scaleMode);
controller.scaleModeChanged(scaleMode);
}
return controller;
},
getViewMode: function() {
return viewMode;
},
setViewMode: function(vm) {
if (viewMode !== vm) {
viewMode = vm;
controller.viewModeChanged(vm);
if (report) {
controller.refreshReportCore(false, reportDocumentId);
}
}
return controller;
},
getPageMode: function() {
return pageMode;
},
setPageMode: function(psm) {
if (pageMode !== psm) {
pageMode = psm;
controller.pageModeChanged(psm);
if (report) {
controller.refreshReportCore(false, reportDocumentId);
}
}
return controller;
},
getPrintMode: function() {
return printMode;
},
setPrintMode: function(pm) {
if (printMode !== pm) {
printMode = pm;
controller.printModeChanged(pm);
}
return controller;
},
previewReport: function(ignoreCache, baseDocumentId, actionId) {
controller.loadedReportChange();
controller.refreshReportCore(ignoreCache, baseDocumentId, actionId);
},
refreshReportCore: function(ignoreCache, baseDocumentId, actionId) {
loadReportAsync(ignoreCache, baseDocumentId, actionId);
},
stopRendering: function() {
throwIfNoReport();
throwIfNoReportInstance();
throwIfNoReportDocument();
client.deleteReportDocument(clientId, reportInstanceId, reportDocumentId).catch(handleRequestError).then(function() {
if (loader) {
loader.cancel();
}
resetPageNumbers();
controller.renderingStopped();
});
},
getReportParameters: function() {
if (!parameterValues) {
return [];
}
var paramsToBeExposed = {};
for (var key in processedParameterValues) {
var processedParam = processedParameterValues[key];
var paramValue = parameterValues[key];
if (processedParam && processedParam.availableValues) {
if (processedParam.multivalue) {
paramsToBeExposed[key] = addMultiComboParam(processedParam, paramValue, key);
} else {
paramsToBeExposed[key] = addSingleComboParam(processedParam, paramValue, key);
}
} else {
paramsToBeExposed[key] = paramValue;
}
}
return paramsToBeExposed;
},
refreshReport: function(ignoreCache, baseDocumentId, actionId) {
controller.loadedReportChange();
if (clientHasExpired) {
clientHasExpired = false;
clearClientId();
}
if (!report) {
controller.raiseError(stringResources.noReport);
return;
}
var loadParametersPromise = controller.loadParameters(null);
loadParametersPromise.then(function(parameters) {
var parameterValues2 = {};
var invalidParameters = [];
var hasError = false;
Array.from(parameters || []).forEach((parameter) => {
try {
var value = parameterValidators.validate(parameter, parameter.value);
parameterValues2[parameter.id] = value;
} catch (e) {
hasError = true;
invalidParameters.push(parameter);
return;
}
});
if (hasError) {
controller.raiseError(stringResources.missingOrInvalidParameter);
appendInvalidReportParameterNames(invalidParameters);
controller.missingOrInvalidParameters();
} else {
controller.setParameters(parameterValues2);
controller.refreshReportCore(ignoreCache, baseDocumentId, actionId);
}
});
controller.reloadParameters(loadParametersPromise);
},
exportReport: function(format, deviceInfo) {
exportReport(format, deviceInfo);
},
sendReport: function(args) {
sendReport(args);
},
printReport: function() {
printReport();
},
getReportPage: function(pageNumber) {
getReportPage(pageNumber);
},
executeReportAction: function(interactiveActionArgs) {
executeReportAction(interactiveActionArgs);
},
reportActionEnter: function(args) {
onReportActionEnter(args);
},
reportActionLeave: function(args) {
onReportActionLeave(args);
},
reportToolTipOpening: function(args) {
onReportToolTipOpening(args);
},
loadParameters: function(paramValues) {
if (report === null) {
return {};
}
controller.beforeLoadParameters(paramValues === null);
return loadParametersAsync(report, paramValues);
},
getDocumentFormats: function() {
return getDocumentFormatsAsync();
},
getServiceVersion: function() {
return getServiceVersionAsync();
},
setAuthenticationToken: function(token) {
client.setAccessToken(token);
},
clientId: function() {
return clientId;
},
onReportLoadComplete: function(info) {
pageCount = info.pageCount;
bookmarkNodes = info.bookmarkNodes;
renderingExtensions = info.renderingExtensions;
setStateReportSource(controller.getReportSource());
controller.reportLoadComplete(info);
},
raiseError: function(...args) {
var errorMessage = formatError(args);
controller.error(errorMessage);
},
getSearchResults: function(args, results) {
return getSearchResultsAsync(args);
},
// --- E V E N T S ---
on: function(eventName, handler) {
eventEmitter.on(eventName, handler);
return controller;
},
trigger: function(eventName, ...args) {
eventEmitter.trigger(eventName, ...args);
return controller;
},
showNotification: function(...args) {
return eventFactory(controller.Events.SHOW_NOTIFICATION, args);
},
hideNotification: function(...args) {
return eventFactory(controller.Events.HIDE_NOTIFICATION, args);
},
setUIState: function(...args) {
return eventFactory(controller.Events.UI_STATE, args);
},
error: function(...args) {
return eventFactory(controller.Events.ERROR, args);
},
reloadParameters: function(...args) {
return eventFactory(controller.Events.RELOAD_PARAMETERS, args);
},
exportStarted: function(...args) {
return eventFactory(controller.Events.EXPORT_STARTED, args);
},
exportReady: function(...args) {
return eventFactory(controller.Events.EXPORT_DOCUMENT_READY, args);
},
sendEmailStarted: function(...args) {
return eventFactory(controller.Events.SEND_EMAIL_STARTED, args);
},
sendEmailReady: function(...args) {
return eventFactory(controller.Events.SEND_EMAIL_READY, args);
},
printStarted: function(...args) {
return eventFactory(controller.Events.PRINT_STARTED, args);
},
printReady: function(...args) {
return eventFactory(controller.Events.PRINT_DOCUMENT_READY, args);
},
beforeLoadParameters: function(...args) {
return eventFactory(controller.Events.BEFORE_LOAD_PARAMETERS, args);
},
loadedReportChange: function(...args) {
return eventFactory(controller.Events.LOADED_REPORT_CHANGE, args);
},
beforeLoadReport: function(...args) {
return eventFactory(controller.Events.BEFORE_LOAD_REPORT, args);
},
beginLoadReport: function(...args) {
return eventFactory(controller.Events.BEGIN_LOAD_REPORT, args);
},
reportLoadComplete: function(...args) {
return eventFactory(controller.Events.REPORT_LOAD_COMPLETE, args);
},
reportLoadProgress: function(...args) {
return eventFactory(controller.Events.REPORT_LOAD_PROGRESS, args);
},
reportLoadFail: function(...args) {
return eventFactory(controller.Events.REPORT_LOAD_FAIL, args);
},
beginLoadPage: function(...args) {
return eventFactory(controller.Events.BEGIN_LOAD_PAGE, args);
},
pageReady: function(...args) {
return eventFactory(controller.Events.PAGE_READY, args);
},
viewModeChanged: function(...args) {
return eventFactory(controller.Events.VIEW_MODE_CHANGED, args);
},
pageModeChanged: function(...args) {
return eventFactory(controller.Events.PAGE_MODE_CHANGED, args);
},
printModeChanged: function(...args) {
return eventFactory(controller.Events.PRINT_MODE_CHANGED, args);
},
reportSourceChanged: function(...args) {
return eventFactory(controller.Events.REPORT_SOURCE_CHANGED, args);
},
navigateToPage: function(...args) {
return eventFactory(controller.Events.NAVIGATE_TO_PAGE, args);
},
currentPageChanged: function(...args) {
return eventFactory(controller.Events.CURRENT_PAGE_CHANGED, args);
},
getDocumentMapState: function(...args) {
return eventFactory(controller.Events.GET_DOCUMENT_MAP_STATE, args);
},
setDocumentMapVisible: function(...args) {
return eventFactory(controller.Events.SET_DOCUMENT_MAP_VISIBLE, args);
},
getParametersAreaState: function(...args) {
return eventFactory(controller.Events.GET_PARAMETER_AREA_STATE, args);
},
setParametersAreaVisible: function(...args) {
return eventFactory(controller.Events.SET_PARAMETER_AREA_VISIBLE, args);
},
setSideMenuVisible: function(...args) {
return eventFactory(controller.Events.SET_TOGGLE_SIDE_MENU, args);
},
getSideMenuVisible: function(...args) {
return eventFactory(controller.Events.GET_TOGGLE_SIDE_MENU, args);
},
scaleChanged: function(...args) {
return eventFactory(controller.Events.SCALE_CHANGED, args);
},
scaleModeChanged: function(...args) {
return eventFactory(controller.Events.SCALE_MODE_CHANGED, args);
},
serverActionStarted: function(...args) {
return eventFactory(controller.Events.SERVER_ACTION_STARTED, args);
},
cssLoaded: function(...args) {
return eventFactory(controller.Events.CSS_LOADED, args);
},
interactiveActionExecuting: function(...args) {
return eventFactory(controller.Events.INTERACTIVE_ACTION_EXECUTING, args);
},
interactiveActionEnter: function(...args) {
return eventFactory(controller.Events.INTERACTIVE_ACTION_ENTER, args);
},
interactiveActionLeave: function(...args) {
return eventFactory(controller.Events.INTERACTIVE_ACTION_LEAVE, args);
},
updateUI: function(...args) {
return eventFactory(controller.Events.UPDATE_UI, args);
},
updateUIInternal: function(...args) {
return eventFactory(controller.Events.UPDATE_UI_INTERNAL, args);
},
toolTipOpening: function(...args) {
return eventFactory(controller.Events.TOOLTIP_OPENING, args);
},
pageNumberChange: function(...args) {
return eventFactory(controller.Events.PAGE_NUMBER, args);
},
pageCountChange: function(...args) {
return eventFactory(controller.Events.PAGE_COUNT, args);
},
getSearchDialogState: function(...args) {
return eventFactory(controller.Events.GET_SEARCH_DIALOG_STATE, args);
},
getSendEmailDialogState: function(...args) {
return eventFactory(controller.Events.GET_SEND_EMAIL_DIALOG_STATE, args);
},
setSearchDialogVisible: function(...args) {
return eventFactory(controller.Events.SET_SEARCH_DIALOG_VISIBLE, args);
},
setSendEmailDialogVisible: function(...args) {
return eventFactory(controller.Events.SET_SEND_EMAIL_DIALOG_VISIBLE, args);
},
scrollPageReady: function(...args) {
return eventFactory(controller.Events.SCROLL_PAGE_READY, args);
},
updatePageDimensionsReady: function(...args) {
return eventFactory(controller.Events.UPDATE_SCROLL_PAGE_DIMENSIONS_READY, args);
},
missingOrInvalidParameters: function(...args) {
return eventFactory(controller.Events.MISSING_OR_INVALID_PARAMETERS, args);
},
renderingStopped: function(...args) {
return eventFactory(controller.Events.RENDERING_STOPPED, args);
},
clientExpired: function(...args) {
return eventFactory(controller.Events.CLIENT_EXPIRED, args);
},
dispose: function() {
stopSentinel();
this.serviceClientSentinel = null;
}
}
);
return controller;
}
function addSingleComboParam(processedParam, paramValue, key) {
try {
var nameValuePair = processedParam.availableValues.find((obj) => {
return obj["value"] === paramValue;
});
if (!nameValuePair) {
throw new Error(`The available values of parameter ${key} do not contain Value property that equals ${paramValue}`);
}
return { valueMember: paramValue, displayMember: nameValuePair["name"] };
} catch (e) {
logError(e);
}
}
function addMultiComboParam(processedParam, paramValue, key) {
var paramArr = [];
for (var i in paramValue) {
paramArr.push(addSingleComboParam(processedParam, paramValue[i], key));
}
return paramArr;
}
export { ReportViewerController };