Importing and Exporting Dundas BI Objects

Contents[Hide]

1. Overview

This article will show how to import and export objects in Dundas BI. You will learn the following:

  • How to get started
  • How to import/export using the Dundas BI Engine and .NET
  • How to import/export using REST Services
  • How to import/export using the Dundas BI JavaScript API

Some of the objects that can be imported and exported are:

  • Accounts
  • File System Entries
  • Groups
  • Custom Attributes
  • Tokens
  • Tenants

For a full list of the objects that can be exported, click here.

2. Getting started

There are three ways to import and export the Dundas BI objects:

  • Using the Dundas BI Engine and referencing the .NET assemblies located in the instances SDK folder.
  • Using Dundas BI Rest Services. The advantage of this method is no references are required, and the code can be written in any language that has a REST client available.
  • Using the Dundas BI JavaScript API. This method requires that the script be run from within the Dundas BI application.

3. How to import and export using the Dundas BI Engine and .NET

To call the import and export functionality in .NET you will need the following:

  • Microsoft .NET Framework 4.5.1 or higher
  • A .NET IDE preferably Microsoft Visual Studio

You will need to reference the assemblies in the SDK folder in the instance. By default, these are located here:

  • [INSTALLDIR]\sdk\bin\Dundas.BI.Core.dll
  • [INSTALLDIR]\sdk\bin\Newtonsoft.Json.dll

The samples in the section below were developed using the Dundas BI .NET API. For more information on this API, click here.

3.1. Importing in .NET

When importing, start the Dundas BI Engine, and logon with a user account that has administrator privileges. The Import method of the ITransferService is used to import Dundas BI objects in .NET. This method takes a ImportConfig object. The following example demonstrates how to start the Dundas BI Engine, and import a file 'C:\Temp\Project.dbie', with a project with the ID = '3cc17f9d-b796-45da-a799-c529ea636401'.

using Dundas.BI;
using Dundas.BI.AccountServices
using Dundas.BI.Services;
using Dundas.BI.Transfer;
using Dundas.BI.FileSystem;
using System.Collections.ObjectModel;
   ...

try
{
    MultithreadedCallerContextService callerContextService = new MultithreadedCallerContextService();
    EngineManager.CreateEngine(
        // Connection string for the application database. Type: System.String
        "Data Source=.;Initial Catalog=Dundas BI Instance1;Integrated Security=True",
        // Path to the application's data folder. Type: System.String
        @"C:\Program Files\Dundas Data Visualization Inc\Dundas BI\Instances\Instance1\" + 
        @"www\BIWebsite\App_Data",
        // Used to uniquely identify the engine instance. Type: System.String
        "CreateExportFiles",
        // The caller context service, or null. Type: Dundas.BI.Services.CallerContextService
        callerContextService
    );
    // Start the engine.
    EngineManager.StartEngine();
    // Set the current context to null.
    Engine.Current.GetService<ICallerContextService>().CreateAndSetCurrentContext(null);
    LogOnResult logOnResult = Engine.Current.GetService<ILogOnService>().LogOn(
        // The account name. Type: System.String
        "admin",
        // The password. Type: System.String
        "1234",
        // Delete other sessions for the logon to succeed. Type: System.Boolean
        true,
        // Culture to associate with the session, or null. Type: System.Globalization.CultureInfo
        null
    );
    // Set the current session to logon.
    Engine.Current.GetService<ICallerContextService>().CurrentContext.SetCurrentSessionId(
        logOnResult.Session.Id
    );
    // The ID of the project to import.
    Guid projectId = new Guid("3cc17f9d-b796-45da-a799-c529ea636401");
    // Create an export configuration file.
    ImportConfig importConfig = new ImportConfig(@"C:\Temp\Project.dbie");
    // Add the ID of project you would like to import.
    importConfig.FileSystemEntryIds.Add(projectId);
    // Add the ID of project you would like to export.
    importConfig.FileSystemEntryIds.Add(projectId);
    // This flag will include all the file system entries I added
    // above, and any items they reference.
    importConfig.IncludeReferencedItems = true;
    // Get the transfer service.
    ITransferService transferService =
    Engine.Current.GetService<ITransferService>();
    // Call the export method of the transfer service.
    TransferResult result = transferService.Import(importConfig);
    if(result.Status == TransferItemResultStatus.Success)
    {
        Console.WriteLine("Success");
    }
}
finally
{
    EngineManager.ShutdownEngine();
}

3.2. Exporting in .NET

When exporting, start the Dundas BI Engine, and logon with a user account that has administrator privileges. The Export method of the ITransferService is used to export Dundas BI objects in .NET. This method takes a ExportConfig object. The following example demonstrates how to start the Dundas BI Engine, and export a project with the ID = '3cc17f9d-b796-45da-a799-c529ea636401', and save it to a file at 'C:\Temp\Project.dbie'.

using Dundas.BI;
using Dundas.BI.AccountServices
using Dundas.BI.Services;
using Dundas.BI.Transfer;
using Dundas.BI.FileSystem;
using System.Collections.ObjectModel;
   ...

try
{
	MultithreadedCallerContextService callerContextService = new MultithreadedCallerContextService();
	EngineManager.CreateEngine(
		// Connection string for the application database. Type: System.String
		"Data Source=.;Initial Catalog=Dundas BI Instance1;Integrated Security=True",
		// Path to the application's data folder. Type: System.String
		@"C:\Program Files\Dundas Data Visualization Inc\Dundas BI\Instances\Instance1\" + 
                @"www\BIWebsite\App_Data",
		// Used to uniquely identify the engine instance. Type: System.String
		"CreateExportFiles",
		// The caller context service, or null. Type: Dundas.BI.Services.CallerContextService
		callerContextService
	);
	// Start the engine.
	EngineManager.StartEngine();
	
	// Set the current context to null.
	Engine.Current.GetService<ICallerContextService>().CreateAndSetCurrentContext(null);
	
	LogOnResult logOnResult = Engine.Current.GetService<ILogOnService>().LogOn(
		// The account name. Type: System.String
		"admin",
		// The password. Type: System.String
		"1234",
		// Delete other sessions for the logon to succeed. Type: System.Boolean
		true,
		// Culture to associate with the session, or null. Type: System.Globalization.CultureInfo
		null
	);
	
	// Set the current session to logon.
	Engine.Current.GetService<ICallerContextService>().CurrentContext.SetCurrentSessionId(
		logOnResult.Session.Id
	);
	
	// The ID of the project to export.
	Guid projectId = new Guid("3cc17f9d-b796-45da-a799-c529ea636401");
	// Create an export configuration file.
	ExportConfig exportConfiguration = new ExportConfig();
	// Add the ID of project you would like to export.
	exportConfiguration.FileSystemEntryIds.Add(projectId);
	// This flag will include all the file system entries I added
	// above, and any items they reference.
	exportConfiguration.IncludeReferencedItems = true;
	// Get the transfer service.
	ITransferService transferService = 
		Engine.Current.GetService<ITransferService>();
	// Call the export method of the transfer service.
	TransferResult result = transferService.Export(exportConfiguration);
	
	// Create a file path to save the file to.
	string filePath =
		@"C:\Temp\Project.dbie";
	
	// Delete the file if it already exists.
	if(System.IO.File.Exists(filePath))
	{
		System.IO.File.SetAttributes(filePath, FileAttributes.Normal);
		System.IO.File.Delete(filePath);
	}
	
	// Write the export to a file.
	using (System.IO.FileStream output = 
		new System.IO.FileStream(
			filePath, FileMode.CreateNew)
			)
	{
		transferService.RetrieveTransferFile(result.TransferFileId).CopyTo(output);
	}
}
finally
{
	EngineManager.ShutdownEngine();
}
    

4. Importing and exporting using REST Services

Importing and exporting using REST services is accomplished by using the Transfer controller. The two requests that are used for this are:

The samples in the section below were developed using the Dundas BI REST API. For more information on this API, click here.

4.1. Importing using REST Services

This example will login and import the file C:\Temp\SomeExportFile.dbie with the project ID = bd767e1f-1fd2-4411-8b70-af9fdfd763e3.

using System.Net;
using System.Net.Http;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Web.Script.Serialization;
   ...
using (HttpClient httpClient = new HttpClient())
{
    // Get Session Id
    string logonUri = "http://localhost:8004/Api/LogOn/";
    var logonOptions = new
    {
        accountName = "admin",
        password = "1234",
        cultureName = string.Empty,
        deleteOtherSessions = true,
        isWindowsLogOn = false
    };
    JavaScriptSerializer serializer = new JavaScriptSerializer();
    var requestBodyAsString = serializer.Serialize(logonOptions);
    StringContent content =
        new StringContent(
            requestBodyAsString,
            Encoding.UTF8,
            "application/json"
        );
    string jsonString = string.Empty;
    using (var response = httpClient.PostAsync(logonUri, content).Result)
    {
        jsonString =
            response.Content.ReadAsStringAsync().Result;
    }
    var obj = (Dictionary<string,object>) serializer.DeserializeObject(jsonString);
    string sessionId = obj["sessionId"].ToString();
    string url = "http://localhost:8004/API/Transfer/Import/?sessionId=" + sessionId + "";
    // Define the request body
    HttpContent requestBody = null;
    requestBody = new StringContent(@"{ 
	    ""transferFileUncPath"": ""C:\\Temp\\SomeExportFile.dbie"",
	    ""importEntityTransferVersionPolicy"": ""CurrentVersionOnly"",
	    ""groupMembershipTransferPolicy"": ""DoNotImport"",
	    ""includeReferencedItems"": true,
	    ""includeCustomAttributes"": true,
	    ""includeTokens"": true,
	    ""fileSystemEntryIds"": [ ""bd767e1f-1fd2-4411-8b70-af9fdfd763e3"" ],
	    ""__classType"": ""dundas.transfer.ImportConfig""}",
    Encoding.UTF8,"application/json");
    using (var response = httpClient.PostAsync(url, requestBody).Result)
    {
        if(response.StatusCode == HttpStatusCode.OK)
        {
            Console.WriteLine("Success");
            //HTTP Status code as well as a <b>Dundas.BI.WebApi.Models.TransferResultData</b> 
            //object or a error message.
            string jsonObject = response.Content.ReadAsStringAsync().Result;
        }
    }
}
    
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import org.apache.http.entity.StringEntity;
import org.json.JSONObject;
   ...
HttpClient httpClient = HttpClientBuilder.create().build();
String url = "http://localhost:8004";
// Get Session Id
String logonUri = url + "Api/LogOn/"
HttpPost httpPost = new HttpPost(logonUri);                    
StringEntity stringEntity = new StringEntity(
    "{\"accountName\":\"admin\","
	    + "\"password":\"1234\","
	    + "\"cultureName\":\"\","
	    + "\"deleteOtherSessions\":false,"
	    + "\"isWindowsLogOn\":false}"
);
stringEntity.setContentType("application/json");
httpPost.setEntity(stringEntity);
HttpResponse httpResponse = httpClient.execute(httpPost);
String jsonString = EntityUtils.toString(httpResponse.getEntity());
JSONObject jsonObj = new JSONObject(jsonString);
String sessionId = jsonObj.getString("sessionId")
String requestUrl = "http://localhost:8004/API/Transfer/Import/?sessionId=" + sessionId + "";
// Define the Request Method.
HttpPost requstMethod = new HttpPost(requestUrl);
// Define the Request Body.
StringEntity input = new StringEntity(
    "{ \"transferFileUncPath\": \"C:\\\\Temp\\\\SomeExportFile.dbie\","
			+ "\"importEntityTransferVersionPolicy\": \"CurrentVersionOnly\","
			+ "\"groupMembershipTransferPolicy\": \"DoNotImport\","
			+ "\"includeReferencedItems\": true,"
			+ "\"includeCustomAttributes\": true,"
			+ "\"includeTokens\": true,"
			+ "\"fileSystemEntryIds\": [ \"bd767e1f-1fd2-4411-8b70-af9fdfd763e3\" ],"
			+ "\"__classType\": \"dundas.transfer.ImportConfig\""
			+ "}"
);
input.setContentType("application/json");
requstMethod.setEntity(input);
HttpResponse response =
    httpClient.execute(requstMethod);
if(response.getStatusLine().getStatusCode() == 200)
{
    System.out.println("Success");
}
//HTTP Status code as well as a <b>Dundas.BI.WebApi.Models.TransferResultData</b> 
// object or a error message.
String json = EntityUtils.toString(response.getEntity());
var logonOptions =
{
    accountName: 'admin',
    password: '1234',
    cultureName: 'en-us',
    deleteOtherSessions: false,
    isWindowsLogOn: false
};
$.ajax({
    type: 'POST',
    url: 'http://localhost:8005/Api/LogOn/',
    data: logonOptions,
    dataType:'json',
    success: function(logOnResultData) {
        var sessionId = logOnResultData.sessionId;
        var dataObject =        {
            { 
                "transferFileUncPath": "C:\\\\Temp\\\\SomeExportFile.dbie",
                "importEntityTransferVersionPolicy": "CurrentVersionOnly",
                "groupMembershipTransferPolicy": "DoNotImport",
                "includeReferencedItems": true,
                "includeCustomAttributes": true,
                "includeTokens": true,
                "fileSystemEntryIds": [ "bd767e1f-1fd2-4411-8b70-af9fdfd763e3" ],
                "__classType": "dundas.transfer.ImportConfig"
            }
        };
        $.ajax({
            type: "POST",
            url: "/API/Transfer/Import/?sessionId=" + sessionId + "",
            data: dataObject,
            dataType:"json",
            success: function(data) {
                // data = HTTP Status code as well as a 
                // <b>Dundas.BI.WebApi.Models.TransferResultData</b> 
                // object or a error message.
            },
            error: function(data) { alert('failed' + data); }
        });
});

4.2. Export using REST Services

This example will login and create a transfer export for the project with ID = 32bd85be-8980-4153-8919-746990220ab4.


using System.Net;
using System.Net.Http;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Web.Script.Serialization;
 
   ...
 
using (HttpClient httpClient = new HttpClient())
{
    // Get Session Id
    string logonUri = "http://localhost:8004/Api/LogOn/";
    var logonOptions = new
    {
        accountName = "admin",
        password = "1234",
        cultureName = string.Empty,
        deleteOtherSessions = true,
        isWindowsLogOn = false
    };
 
    JavaScriptSerializer serializer = new JavaScriptSerializer();
    var requestBodyAsString = serializer.Serialize(logonOptions);
    StringContent content =
        new StringContent(
            requestBodyAsString,
            Encoding.UTF8,
            "application/json"
        );
 
    string jsonString = string.Empty;
 
    using (var response = httpClient.PostAsync(logonUri, content).Result)
    {
        jsonString =
            response.Content.ReadAsStringAsync().Result;
    }
 
    var obj = (Dictionary<string,object>) serializer.DeserializeObject(jsonString);
    string sessionId = obj["sessionId"].ToString();
    string url = "http://localhost:8004/API/Transfer/Export/?sessionId=" + sessionId + "";
 
    // Define the request body
    HttpContent requestBody = null;
    requestBody = new StringContent(@"{ 
            ""__classType"":""dundas.transfer.ExportConfig"",
			""name"":""Export Configuration 20160224_1250"",
			""entityTransferVersionPolicy"":""CurrentVersionOnly"",
			""includeReferencedItems"":true,
			""includeAllAccounts"":false,
			""includeAllGroups"":false,
			""includeGroupMemberships"":false,
			""includeCustomAttributes"":false,
			""includeTokens"":false,
			""accountIds"":[],
			""groupIds"":[],
			""fileSystemEntryIds"":[""32bd85be-8980-4153-8919-746990220ab4""]
			}"
            ,Encoding.UTF8,"application/json");
    using (var response = httpClient.PostAsync(url, requestBody).Result)
    {
        if(response.StatusCode == HttpStatusCode.OK)
        {
            Console.WriteLine("Success");
 
            //A status code indicating success and 
            //<b>Dundas.BI.WebApi.Models.TransferResultData</b> 
            //object or failure and the reason for the failure.
            string jsonObject = response.Content.ReadAsStringAsync().Result;
        }
    }
}

    
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import org.apache.http.entity.StringEntity;
import org.json.JSONObject;
 
   ...
 
HttpClient httpClient = HttpClientBuilder.create().build();
 
String url = "http://localhost:8004";
 
// Get Session Id
String logonUri = url + "Api/LogOn/"
HttpPost httpPost = new HttpPost(logonUri);
StringEntity stringEntity = new StringEntity(
        "{\"accountName\":\"admin\","
	    + "\"password":\"1234\","
	    + "\"cultureName\":\"\","
	    + "\"deleteOtherSessions\":false,"
	    + "\"isWindowsLogOn\":false}"
);
stringEntity.setContentType("application/json");
httpPost.setEntity(stringEntity);
HttpResponse httpResponse = httpClient.execute(httpPost);
String jsonString = EntityUtils.toString(httpResponse.getEntity());
JSONObject jsonObj = new JSONObject(jsonString);
String sessionId = jsonObj.getString("sessionId")
 
String requestUrl = "http://localhost:8004/API/Transfer/Export/?sessionId=" + sessionId + "";
 
// Define the Request Method.
HttpPost requstMethod = new HttpPost(requestUrl);
 
// Define the Request Body.
StringEntity input = new StringEntity(
    "{"
	+ "\"__classType\":\"dundas.transfer.ExportConfig\","
	+ "\"name\":\"Export Configuration 20160224_1250\","
	+ "\"entityTransferVersionPolicy\":\"CurrentVersionOnly\","
	+ "\"includeReferencedItems\":true,"
	+ "\"includeAllAccounts\":false,"
	+ "\"includeAllGroups\":false,"
	+ "\"includeGroupMemberships\":false,"
	+ "\"includeCustomAttributes\":false,"
	+ "\"includeTokens\":false,"
	+ "\"accountIds\":[],"
	+ "\"groupIds\":[],"
	+ "\"fileSystemEntryIds\":[\"32bd85be-8980-4153-8919-746990220ab4\"]"
	+ "}"
);
input.setContentType("application/json");
requstMethod.setEntity(input);
HttpResponse response =
    httpClient.execute(requstMethod);
 
if(response.getStatusLine().getStatusCode() == 200)
{
    System.out.println("Success");
}
 
//A status code indicating success and <b>Dundas.BI.WebApi.Models.TransferResultData</b> 
//object or failure and the reason for the failure.
String json = EntityUtils.toString(response.getEntity());
var logonOptions =
{
    accountName: 'admin',
    password: '1234',
    cultureName: 'en-us',
    deleteOtherSessions: false,
    isWindowsLogOn: false
};
$.ajax({
    type: 'POST',
    url: 'http://localhost:8005/Api/LogOn/',
    data: logonOptions,
    dataType:'json',
    success: function(logOnResultData) {
        var sessionId = logOnResultData.sessionId;
 
        var dataObject =        
        {
            {   
                "__classType":"dundas.transfer.ExportConfig",
                "name":"Export Configuration 20160224_1250",
                "entityTransferVersionPolicy":"CurrentVersionOnly",
                "includeReferencedItems":true,
                "includeAllAccounts":false,
                "includeAllGroups":false,
                "includeGroupMemberships":false,
                "includeCustomAttributes":false,
                "includeTokens":false,
                "accountIds":[],
                "groupIds":[],
                "fileSystemEntryIds":["32bd85be-8980-4153-8919-746990220ab4"]
            }
        };
 
        $.ajax({
            type: "POST",
            url: "/API/Transfer/Export/?sessionId=" + sessionId + "",
            data: dataObject,
            dataType:"json",
            success: function(data) {
                // data = A status code indicating success and 
                // <b>Dundas.BI.WebApi.Models.TransferResultData</b> 
                // object or failure and the reason for the failure.
            },
            error: function(data) { alert('failed' + data); }
        });
});

 

5. How to import/export using the Dundas BI JavaScript API

To import or export using the JavaScript API you will need to write the code in an event provided by the Dundas BI User interface, or inside of a custom extension that provides a mechanism for running script. The samples in the section below were developed using the Dundas BI JavaScript API. For more information on this API, click here.

6. Importing using the Dundas BI JavaScript API

The following script imports a project from "\\MySharedFolder\ShareFolder\ExportShares\Dummy.dbie" into Dundas BI. Note, this script was designed to run on a button click, on a dashboard, and requires the executing session to be an administrator:

    // Check if user is an admin, 
// if not pop-up message and return.
if(!dundas.context.currentSession.isAdministrator)
{
 	alert('This user is not an administrator'); 
  	return;
}
var applicationConfigurationService  = 
    this.getService("ApplicationConfigurationService");
// Get the transfer service.
var transferService  = 
    this.getService("TransferService");
// Core Config Setting Ids can be found: 
// http://www.dundas.com/support/api-docs/net/#html/T_Dundas_BI_CoreConfigSettingIds.htm
var getSettingPromise = 
    applicationConfigurationService.getEffectiveValueForSetting(
       'a6015caf-7d1d-4d2f-b636-3d9073cb5f5c', 
       dundas.configuration.AppSettingScope.SERVER
       );
getSettingPromise.done(function(externalUrlSetting)
{
  var externalUrlSettingValue = 
      externalUrlSetting.value;
  
  // Trim trailing slash
  if (externalUrlSettingValue.charAt(externalUrlSettingValue.length - 1) == "/")
  {
    externalUrlSettingValue = externalUrlSettingValue.substr(0, externalUrlSettingValue.length - 1);
  }
  var dummyDbieUncPath = externalUrlSettingValue + '/Content/DownloadExports/dummy.dbie';
  debugger;
  
  var importConfig = 
      new dundas.transfer.ImportConfig();
  
            
  importConfig.transferFileUncPath = 
     "\\\\\\\\MySharedFolder\\\\ShareFolder\\\\ExportShares\\\\Dummy.dbie",
  importConfig.importEntityTransferVersionPolicy = 
     dundas.transfer.EntityTransferVersionPolicy.CURRENT_VERSION_ONLY,
  importConfig.groupMembershipTransferPolicy = 
     dundas.transfer.GroupMembershipTransferPolicy.DO_NOT_IMPORT,
  importConfig.includeReferencedItems= true;
  importConfig.includeCustomAttributes= true;
  importConfig.includeTokens= true;
  // The dummy project id.
  importConfig.fileSystemEntryIds = [ "12e00c72-14ab-436c-bccb-7ab56d30e5cc" ];
  // Set to empty ID as we are not using it.
  importConfig.transferFileId = "00000000-0000-0000-0000-000000000000";
  
  var importPromise = transferService.importProject(importConfig);
  importPromise.done(function(transferResult)
  {
      debugger;
      alert(transferResult.status);
  });
});

6.1. Exporting using the Dundas BI JavaScript API

The following example demonstrates how to export a project, pushing a file to the browser using the Dundas BI JavaScript API. Note, this script was designed to run on a button click, on the dashboard, and requires the executing session to be an administrator:

// Check if user is an admin, 
// if not pop-up message and return.
if(!dundas.context.currentSession.isAdministrator)
{
 	alert('This user is not an administrator'); 
  	return;
}
// Get the transfer service.
var transferService  = 
    this.getService("TransferService");
// Get the web app service.
var webAppService = 
    this.getService('WebAppService');
// The export config.
var exportConfig = new dundas.transfer.ExportConfig(
    {
        "name":"Export Configuration " + new Date().toString(),
        "entityTransferVersionPolicy":"CurrentVersionOnly",
        "includeReferencedItems":true,
        "includeAllAccounts":false,
        "includeAllGroups":false,
        "includeGroupMemberships":false,
        "includeCustomAttributes":false,
        "includeTokens":false,
        "accountIds":[],
        "groupIds":[],
      	// The Dundas Script Library ID.
        "fileSystemEntryIds":["899f8f4f-aa2c-46aa-8a68-bac2c8ab367e"]
    }
  );
var exportPromise = transferService.exportConfiguration(exportConfig);
exportPromise.done(function(transferResult)
{
  var downloadUrl = 
      '../' + 
      dundas.constants.WEB_API_PATH + 
      dundas.RequestPath.TRANSFER_FILE_DOWNLOAD + 
      transferResult.transferFileId + 
      '?sessionId=' + dundas.context.currentSessionId;
    
  // Force the browser to download the file.  
  window.location.replace(downloadUrl);
});

7. See Also

7.1. .NET

7.2. REST

7.3. JavaScript

Dundas Data Visualization, Inc.
500-250 Ferrand Drive
Toronto, ON, Canada
M3C 3G8

North America: 1.800.463.1492
International: 1.416.467.5100

Dundas Support Hours: 7am-6pm, ET, Mon-Fri