/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="localUploadPath"></param>
public UploadDatasources(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
UploadBehaviorProjects uploadProjectBehavior,
CustomerManualActionManager manualActions,
bool attemptOwnershipAssignment,
IEnumerable<SiteUser> siteUsers,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(login)
{
System.Diagnostics.Debug.Assert(uploadChunkSizeBytes > 0, "Chunck size must be positive");
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_uploadProjectBehavior = uploadProjectBehavior;
_credentialManager = credentialManager;
_manualActions = manualActions;
if(_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//If we are going to attempt to reassign ownership after publication we'll need this information
_attemptOwnershipAssignment = attemptOwnershipAssignment;
_siteUsers = siteUsers;
//Test parameters
_uploadChunkSizeBytes = uploadChunkSizeBytes;
_uploadChunkDelaySeconds = uploadChunkDelaySeconds;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="localUploadPath"></param>
public UploadDatasources(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
UploadBehaviorProjects uploadProjectBehavior,
CustomerManualActionManager manualActions,
bool attemptOwnershipAssignment,
IEnumerable <SiteUser> siteUsers,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(login)
{
System.Diagnostics.Debug.Assert(uploadChunkSizeBytes > 0, "Chunck size must be positive");
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_uploadProjectBehavior = uploadProjectBehavior;
_credentialManager = credentialManager;
_manualActions = manualActions;
if (_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//If we are going to attempt to reassign ownership after publication we'll need this information
_attemptOwnershipAssignment = attemptOwnershipAssignment;
_siteUsers = siteUsers;
//Test parameters
_uploadChunkSizeBytes = uploadChunkSizeBytes;
_uploadChunkDelaySeconds = uploadChunkDelaySeconds;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="jobName">Name to associate with this work</param>
/// <param name="onlineUrls"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="taskOptions"></param>
/// <param name="manualActions"></param>
public TaskMaster(
string jobName,
TableauServerUrls onlineUrls,
string userName,
string password,
TaskMasterOptions taskOptions,
CustomerManualActionManager manualActions = null)
{
this.JobName = jobName;
_manualActions = manualActions;
if(_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//Get any export path
_exportToLocalPath = taskOptions.GetOptionValue(TaskMasterOptions.OptionParameter_PathDownloadTo);
_onlineUrls = onlineUrls;
_userName = userName;
_password = password;
//Store the status log at the class level where it is accessable
_statusLog = new TaskStatusLogs();
//Store the options
_taskOptions = taskOptions;
if(_taskOptions.IsOptionSet(TaskMasterOptions.Option_LogVerbose))
{
_statusLog.SetStatusLoggingLevel(int.MinValue);
}
}
/// <summary>
/// Create an instance of a Send Update User REST API Request
/// </summary>
/// <param name="onlineUrls">Tableau Server Information</param>
/// <param name="logInInfo">Tableau Sign In Information</param>
/// <param name="userId">User to update</param>
/// <param name="siteRole"></param>
public SendUpdateUserSiteRole(TableauServerUrls onlineUrls, TableauServerSignIn logInInfo, string userId, string siteRole)
: base(logInInfo)
{
_onlineUrls = onlineUrls;
_userID = userId;
_siteRole = siteRole;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="credentialManager">Set of database credentials to attach to associated content being published</param>
/// <param name="localUploadPath">Path to upload from</param>
/// <param name="remapWorkbookReferences">TRUE if we want to modify the workbooks to point datasource/other references to the new server</param>
/// <param name="localPathTempWorkspace">Path to perform local file work in</param>
/// <param name="uploadProjectBehavior">Instructions on whether to map content into projects</param>
/// <param name="manualActions">Any manual actions that need to be performed by the user are written here</param>
/// <param name="attemptOwnershipAssignment">TRUE: After upload attempt to reassign the ownership of the content based on local metadata we have</param>
/// <param name="siteUsers">List of users to perform ownership assignement with</param>
/// <param name="uploadChunkDelaySeconds">For testing, a delay we can inject</param>
public UploadWorkbooks(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
bool remapWorkbookReferences,
string localPathTempWorkspace,
UploadBehaviorProjects uploadProjectBehavior,
CustomerManualActionManager manualActions,
bool attemptOwnershipAssignment,
IEnumerable<SiteUser> siteUsers,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(login)
{
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_remapWorkbookReferences = remapWorkbookReferences;
_localPathTempWorkspace = localPathTempWorkspace;
_uploadProjectBehavior = uploadProjectBehavior;
_manualActions = manualActions;
_credentialManager = credentialManager;
if (_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//If we are going to attempt to reassign ownership after publication we'll need this information
_attemptOwnershipAssignment = attemptOwnershipAssignment;
_siteUsers = siteUsers;
//Test parameters
_uploadChunkSizeBytes = uploadChunkSizeBytes;
_uploadChunkDelaySeconds = uploadChunkDelaySeconds;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls">Tableau Server Information</param>
/// <param name="logInInfo">Tableau Sign In Information</param>
/// <param name="workbook">IEnumerable of SiteWorkbook objects</param>
/// <param name="localSavePath">Local path where the workbooks should be saved</param>
public DownloadWorkbook(TableauServerUrls onlineUrls, TableauServerSignIn logInInfo, SiteWorkbook workbook, string localSavePath)
: base(logInInfo)
{
_onlineUrls = onlineUrls;
_workbook = workbook;
_localSavePath = localSavePath;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="localUploadPath"></param>
public UploadDatasources(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
UploadBehaviorProjects uploadProjectBehavior,
CustomerManualActionManager manualActions,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(login)
{
System.Diagnostics.Debug.Assert(uploadChunkSizeBytes > 0, "Chunck size must be positive");
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_uploadProjectBehavior = uploadProjectBehavior;
_credentialManager = credentialManager;
_manualActions = manualActions;
if (_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//Test parameters
_uploadChunkSizeBytes = uploadChunkSizeBytes;
_uploadChunkDelaySeconds = uploadChunkDelaySeconds;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="jobName">Name to associate with this work</param>
/// <param name="onlineUrls"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="taskOptions"></param>
/// <param name="manualActions"></param>
public TaskMaster(
string jobName,
TableauServerUrls onlineUrls,
string userName,
string password,
TaskMasterOptions taskOptions,
CustomerManualActionManager manualActions = null)
{
this.JobName = jobName;
_manualActions = manualActions;
if (_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//Get any export path
_exportToLocalPath = taskOptions.GetOptionValue(TaskMasterOptions.OptionParameter_PathDownloadTo);
_onlineUrls = onlineUrls;
_userName = userName;
_password = password;
//Store the status log at the class level where it is accessable
_statusLog = new TaskStatusLogs();
//Store the options
_taskOptions = taskOptions;
if (_taskOptions.IsOptionSet(TaskMasterOptions.Option_LogVerbose))
{
_statusLog.SetStatusLoggingLevel(int.MinValue);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="credentialManager">Set of database credentials to attach to associated content being published</param>
/// <param name="localUploadPath">Path to upload from</param>
/// <param name="remapWorkbookReferences">TRUE if we want to modify the workbooks to point datasource/other references to the new server</param>
/// <param name="localPathTempWorkspace">Path to perform local file work in</param>
/// <param name="uploadProjectBehavior">Instructions on whether to map content into projects</param>
/// <param name="manualActions">Any manual actions that need to be performed by the user are written here</param>
/// <param name="uploadChunkDelaySeconds">For testing, a delay we can inject</param>
public UploadWorkbooks(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
bool remapWorkbookReferences,
string localPathTempWorkspace,
UploadBehaviorProjects uploadProjectBehavior,
CustomerManualActionManager manualActions,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(login)
{
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_remapWorkbookReferences = remapWorkbookReferences;
_localPathTempWorkspace = localPathTempWorkspace;
_uploadProjectBehavior = uploadProjectBehavior;
_manualActions = manualActions;
_credentialManager = credentialManager;
if (_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//Test parameters
_uploadChunkSizeBytes = uploadChunkSizeBytes;
_uploadChunkDelaySeconds = uploadChunkDelaySeconds;
}
public UploadWorkbooks(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
IHttpClientFactory httpClientFactory,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(onlineUrls, login, httpClientFactory)
{
LocalUploadPath = localUploadPath;
CredentialManager = credentialManager;
//If we are going to attempt to reassign ownership after publication we'll need this information
//Not implemented for now
AttemptOwnershipAssignment = false;
SiteUsers = new List <SiteUser>();
UploadChunkSizeBytes = uploadChunkSizeBytes;
UploadChunkDelaySeconds = uploadChunkDelaySeconds;
HttpClientFactory = httpClientFactory;
ProjectFindCreateHelper = new ProjectFindCreateHelper(Urls, Login, HttpClientFactory);
UploadSuccesses = 0;
UploadFailures = 0;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="credentialManager">Set of database credentials to attach to associated content being published</param>
/// <param name="localUploadPath">Path to upload from</param>
/// <param name="remapWorkbookReferences">TRUE if we want to modify the workbooks to point datasource/other references to the new server</param>
/// <param name="localPathTempWorkspace">Path to perform local file work in</param>
/// <param name="uploadProjectBehavior">Instructions on whether to map content into projects</param>
/// <param name="manualActions">Any manual actions that need to be performed by the user are written here</param>
/// <param name="uploadChunkDelaySeconds">For testing, a delay we can inject</param>
public UploadWorkbooks(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
bool remapWorkbookReferences,
string localPathTempWorkspace,
UploadBehaviorProjects uploadProjectBehavior,
CustomerManualActionManager manualActions,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(login)
{
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_remapWorkbookReferences = remapWorkbookReferences;
_localPathTempWorkspace = localPathTempWorkspace;
_uploadProjectBehavior = uploadProjectBehavior;
_manualActions = manualActions;
_credentialManager = credentialManager;
if (_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//Test parameters
_uploadChunkSizeBytes = uploadChunkSizeBytes;
_uploadChunkDelaySeconds = uploadChunkDelaySeconds;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="localUploadPath"></param>
public UploadDatasources(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
UploadBehaviorProjects uploadProjectBehavior,
CustomerManualActionManager manualActions,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(login)
{
System.Diagnostics.Debug.Assert(uploadChunkSizeBytes > 0, "Chunck size must be positive");
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_uploadProjectBehavior = uploadProjectBehavior;
_credentialManager = credentialManager;
_manualActions = manualActions;
if(_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//Test parameters
_uploadChunkSizeBytes = uploadChunkSizeBytes;
_uploadChunkDelaySeconds = uploadChunkDelaySeconds;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="credentialManager">Set of database credentials to attach to associated content being published</param>
/// <param name="localUploadPath">Path to upload from</param>
/// <param name="remapWorkbookReferences">TRUE if we want to modify the workbooks to point datasource/other references to the new server</param>
/// <param name="localPathTempWorkspace">Path to perform local file work in</param>
/// <param name="uploadProjectBehavior">Instructions on whether to map content into projects</param>
/// <param name="manualActions">Any manual actions that need to be performed by the user are written here</param>
/// <param name="attemptOwnershipAssignment">TRUE: After upload attempt to reassign the ownership of the content based on local metadata we have</param>
/// <param name="siteUsers">List of users to perform ownership assignement with</param>
/// <param name="uploadChunkDelaySeconds">For testing, a delay we can inject</param>
public UploadWorkbooks(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
bool remapWorkbookReferences,
string localPathTempWorkspace,
UploadBehaviorProjects uploadProjectBehavior,
CustomerManualActionManager manualActions,
bool attemptOwnershipAssignment,
IEnumerable <SiteUser> siteUsers,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(login)
{
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_remapWorkbookReferences = remapWorkbookReferences;
_localPathTempWorkspace = localPathTempWorkspace;
_uploadProjectBehavior = uploadProjectBehavior;
_manualActions = manualActions;
_credentialManager = credentialManager;
if (_manualActions == null)
{
_manualActions = new CustomerManualActionManager();
}
//If we are going to attempt to reassign ownership after publication we'll need this information
_attemptOwnershipAssignment = attemptOwnershipAssignment;
_siteUsers = siteUsers;
//Test parameters
_uploadChunkSizeBytes = uploadChunkSizeBytes;
_uploadChunkDelaySeconds = uploadChunkDelaySeconds;
}
public void WhenGivenUrlReturnTableauServerUrlsInstance()
{
var testObject =
TableauServerUrls.FromContentUrl("http://traffk-dev-tab.eastus.cloudapp.azure.com/#/projects", 1);
Assert.IsNotNull(testObject);
}
public UploadDatasources(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
CredentialManager credentialManager,
string localUploadPath,
bool attemptOwnershipAssignment,
IEnumerable <SiteUser> siteUsers,
IHttpClientFactory httpClientFactory,
int uploadChunkSizeBytes = TableauServerUrls.UploadFileChunkSize,
int uploadChunkDelaySeconds = 0)
: base(onlineUrls, login, httpClientFactory)
{
System.Diagnostics.Debug.Assert(uploadChunkSizeBytes > 0, "Chunck size must be positive");
LocalUploadPath = localUploadPath;
CredentialManager = credentialManager;
//If we are going to attempt to reassign ownership after publication we'll need this information
AttemptOwnershipAssignment = attemptOwnershipAssignment;
SiteUsers = siteUsers;
//Test parameters
UploadChunkSizeBytes = uploadChunkSizeBytes;
UploadChunkDelaySeconds = uploadChunkDelaySeconds;
UploadeDatasources = new List <SiteDatasource>();
UploadSuccesses = 0;
UploadFailures = 0;
HttpClientFactory = httpClientFactory;
}
/// <summary>
/// Sets up parameters needed by Site Import
/// </summary>
/// <param name="dirImportFromDirectory"></param>
/// <param name="urlToServerSite"></param>
/// <param name="useAccessToken"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="isSystemAdmin"></param>
/// <param name="remapDataserverReferences"></param>
/// <param name="pathDbCredentials"></param>
/// <param name="assignContentOwnership">TRUE: Look for metadata files for uploaded content and attempt to reassign its ownership</param>
/// <param name="options"></param>
/// <returns></returns>
private static TaskMaster helper_CreateTaskMaster_SiteImport(
string dirImportFromDirectory,
string urlToServerSite,
bool useAccessToken,
string userName,
string password,
bool isSiteAdmin,
bool remapDataserverReferences,
string pathDbCredentials,
bool assignContentOwnership,
TaskMasterOptions options)
{
//If we were passed in no existing options, then add them
if (options == null)
{
options = new TaskMasterOptions();
}
//The local file system path we want to upload from
options.AddOption(TaskMasterOptions.OptionParameter_PathUploadFrom, dirImportFromDirectory);
//Things we want to upload
options.AddOption(TaskMasterOptions.Option_UploadDatasources);
options.AddOption(TaskMasterOptions.Option_UploadWorkbooks);
//Some features are only accessible to System Admins
if (isSiteAdmin)
{
options.AddOption(TaskMasterOptions.Option_UploadCreateNeededProjects);
}
if (assignContentOwnership)
{
options.AddOption(TaskMasterOptions.Option_AssignContentOwnershipAfterPublish);
}
//Do we need to remap workbook references to point to the Server/Site we are uploading to
if (remapDataserverReferences)
{
options.AddOption(TaskMasterOptions.Option_RemapWorkbookReferencesOnUpload);
}
if (!string.IsNullOrWhiteSpace(pathDbCredentials))
{
options.AddOption(TaskMasterOptions.Option_DBCredentialsPath, pathDbCredentials);
}
//Generate the URLs mapping class
var onlineUrls = TableauServerUrls.FromContentUrl(urlToServerSite, TaskMasterOptions.RestApiReponsePageSizeDefault);
//Create the task master object
return(new TaskMaster(
JobName_SiteImport,
onlineUrls,
useAccessToken,
userName,
password,
options));
}
public DownloadPreviewImageForView(TableauServerUrls onlineUrls, TableauServerSignIn login, IHttpClientFactory httpClientFactory)
: base(login, httpClientFactory)
{
urls = onlineUrls;
var nsManager = XmlHelper.CreateTableauXmlNamespaceManager("iwsOnline", "http://tableau.com/api");
xmlNamespace = nsManager.LookupNamespace("iwsOnline");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls">Tableau Server Information</param>
/// <param name="logInInfo">Tableau Sign In Information</param>
/// <param name="workbooks">IEnumerable of SiteWorkbook objects</param>
/// <param name="localSavePath">Local path where the workbooks should be saved</param>
/// <param name="projectsList">IEnumerable of SiteProject objects</param>
public DownloadWorkbooks(TableauServerUrls onlineUrls, TableauServerSignIn logInInfo, IEnumerable <SiteWorkbook> workbooks, string localSavePath, IProjectsList projectsList)
: base(logInInfo)
{
_onlineUrls = onlineUrls;
_workbooks = workbooks;
_localSavePath = localSavePath;
_downloadToProjectDirectories = projectsList;
}
/// <summary>
/// Create the request for to download Data sources from the Tableau REST API
/// </summary>
/// <param name="onlineUrls">Tableau Server Information</param>
/// <param name="logInInfo">Tableau Sign In Information</param>
/// <param name="datasources">List of Tableau Data sources to save to disk</param>
/// <param name="localSavePath">File system location where data sources should be saved</param>
/// <param name="projectsList">List of projects for which we should pull data sources from</param>
public DownloadDatasources(TableauServerUrls onlineUrls, TableauServerSignIn logInInfo, IEnumerable <SiteDatasource> datasources, string localSavePath, IProjectsList projectsList)
: base(logInInfo)
{
_onlineUrls = onlineUrls;
_datasources = datasources;
_localSavePath = localSavePath;
_downloadToProjectDirectories = projectsList;
}
/// <summary>
/// Create the request for to download Data sources from the Tableau REST API
/// </summary>
/// <param name="onlineUrls">Tableau Server Information</param>
/// <param name="logInInfo">Tableau Sign In Information</param>
/// <param name="datasource">List of Tableau Data sources to save to disk</param>
/// <param name="localSavePath">File system location where data sources should be saved</param>
/// <param name="project"></param>
public DownloadDatasource(TableauServerUrls onlineUrls, TableauServerSignIn logInInfo, SiteDatasource datasource, string localSavePath, SiteProject project)
: base(logInInfo)
{
_onlineUrls = onlineUrls;
_datasource = datasource;
_localSavePath = localSavePath;
_downloadToProjectDirectory = project;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public SendCreateGroup(
TableauServerSignIn login,
string groupName)
: base(login)
{
_onlineUrls = login.ServerUrls;
_groupName = groupName;
}
protected TableauServerSignedInRequestBase(TableauServerUrls urls, TableauServerSignIn login, IHttpClientFactory httpClientFactory)
: base(httpClientFactory)
{
Login = login;
Urls = urls;
var nsManager = XmlHelper.CreateTableauXmlNamespaceManager(TableauXmlNamespaceName, TableauXmlNamespaceUrl);
XmlNamespace = nsManager.LookupNamespace(TableauXmlNamespaceName);
}
/// <summary>
/// Create an instance of a Create Project REST API request.
/// </summary>
/// <param name="onlineUrls">Tableau Server Information</param>
/// <param name="logInInfo">Tableau Sign In Information</param>
/// <param name="projectName">Project Name</param>
public SendCreateProject(
TableauServerUrls onlineUrls,
TableauServerSignIn logInInfo,
string projectName)
: base(logInInfo)
{
_onlineUrls = onlineUrls;
_projectName = projectName;
}
public SendCreateProject(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
string projectName)
: base(login)
{
_onlineUrls = onlineUrls;
_projectName = projectName;
}
public DownloadWorkbooksList(TableauServerUrls onlineUrls, TableauServerSignIn login, IHttpClientFactory httpClientFactory)
: base(login, httpClientFactory)
{
urls = onlineUrls;
UserId = login.UserId;
var nsManager = XmlHelper.CreateTableauXmlNamespaceManager("iwsOnline", "http://tableau.com/api");
xmlNamespace = nsManager.LookupNamespace("iwsOnline");
}
/// <summary>
/// Sets up parameters needed by site inventory
/// </summary>
/// <param name="pathToWriteInventoryFile"></param>
/// <param name="urlToServerSite"></param>
/// <param name="useAccessToken"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="isAdmin"></param>
/// <param name="options"></param>
/// <returns></returns>
private static TaskMaster helper_CreateTaskMaster_SiteInventory(
string pathToWriteInventoryFile,
string urlToServerSite,
bool useAccessToken,
string userName,
string password,
bool isAdmin,
bool generateTwbFile,
TaskMasterOptions options)
{
//If we were passed in no existing options, then add them
if (options == null)
{
options = new TaskMasterOptions();
}
//Where we want to write the results file to
options.AddOption(TaskMasterOptions.OptionParameter_SaveInventoryFile, pathToWriteInventoryFile);
//Things we want to download to
options.AddOption(TaskMasterOptions.Option_GetProjectsList);
options.AddOption(TaskMasterOptions.Option_GetDatasourcesList);
options.AddOption(TaskMasterOptions.Option_GetWorkbooksList);
options.AddOption(TaskMasterOptions.Option_GetWorkbooksConnections);
options.AddOption(TaskMasterOptions.Option_GetSubscriptionsList);
options.AddOption(TaskMasterOptions.Option_GetViewsList);
//Some features are only accessible to System/Site Admins
if (isAdmin)
{
options.AddOption(TaskMasterOptions.Option_GetSiteUsers);
options.AddOption(TaskMasterOptions.Option_GetSiteInfo);
options.AddOption(TaskMasterOptions.Option_GetGroupsList);
options.AddOption(TaskMasterOptions.Option_GetSchedulesList);
options.AddOption(TaskMasterOptions.Option_GetExtractTasksList);
}
//Do we want to create a Tableau Workbook that uses the inventory CSV file?
if (generateTwbFile)
{
options.AddOption(TaskMasterOptions.Option_GenerateInventoryTwb);
}
//Generate the URLs mapping class
var onlineUrls = TableauServerUrls.FromContentUrl(urlToServerSite, TaskMasterOptions.RestApiReponsePageSizeDefault);
//Create the task master object
return(new TaskMaster(
JobName_SiteInventory,
onlineUrls,
useAccessToken,
userName,
password,
options));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="login"></param>
/// <param name="datasourceId">GUID</param>
/// <param name="newOwnerId">GUID</param>
public SendUpdateDatasourceOwner(
TableauServerSignIn login,
string datasourceId,
string newOwnerId)
: base(login)
{
_onlineUrls = login.ServerUrls;
_datasourceId = datasourceId;
_newOwnerId = newOwnerId;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="login"></param>
/// <param name="flowId">GUID</param>
/// <param name="newOwnerId">GUID</param>
public SendUpdateFlowOwner(
TableauServerSignIn login,
string flowId,
string newOwnerId)
: base(login)
{
_onlineUrls = login.ServerUrls;
_flowId = flowId;
_newOwnerId = newOwnerId;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public SendAddUserToGroup(
TableauServerSignIn login,
string userId,
string groupId)
: base(login)
{
_onlineUrls = login.ServerUrls;
_userId = userId;
_groupId = groupId;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <param name="statusLog"></param>
public TableauServerSignIn(TableauServerUrls onlineUrls, string userName, string password, TaskStatusLogs statusLog)
{
if (statusLog == null) { statusLog = new TaskStatusLogs(); }
this.StatusLog = statusLog;
_onlineUrls = onlineUrls;
_userName = userName;
_password = password;
SiteUrlSegment = onlineUrls.SiteUrlSegement;
}
public void DownloadWorkbooksTest()
{
var url = new TableauServerUrls(ServerProtocol.Http, "10.107.0.240:8000", "ITCostSurvey", 10, ServerVersion.Server9);
var signIn = new TableauServerSignIn(
url, "public",
"tableau1user%", new TaskStatusLogs());
signIn.ExecuteRequest();
var a =
new DownloadWorkbooksList(url, signIn);
a.ExecuteRequest();
Assert.AreEqual(2, a.Workbooks.Count);
var b = new DownloadProjectsList(url, signIn);
b.ExecuteRequest();
Assert.AreEqual(1, b.Projects.Count());
signIn = new TableauServerSignIn(
new TableauServerUrls(ServerProtocol.Http, "10.107.0.240:8000", "ITCostSurvey", 10, ServerVersion.Server9),
"tableauAdmin",
"ta1user%", new TaskStatusLogs());
signIn.ExecuteRequest();
a =
new DownloadWorkbooksList(
new TableauServerUrls(ServerProtocol.Http, "10.107.0.240:8000", "ITCostSurvey", 10, ServerVersion.Server9),
signIn);
a.ExecuteRequest();
Assert.AreEqual(4, a.Workbooks.Count);
foreach (var workbook in a.Workbooks)
{
var viewQuery = new DownloadViewsForWorkbookList(workbook.Id, url, signIn);
viewQuery.ExecuteRequest();
Assert.AreEqual(1, viewQuery.Views.Count);
foreach (var view in viewQuery.Views)
{
var thumbnailQuery = new DownloadView(url, signIn);
var result = thumbnailQuery.GetPreviewImage(workbook.Id, view.Id);
Assert.AreNotEqual(0, result.Length);
}
}
b = new DownloadProjectsList(url, signIn);
b.ExecuteRequest();
Assert.AreEqual(1, b.Projects.Count());
var siteViews = new DownloadViewsForSiteList(url, signIn);
siteViews.ExecuteRequest();
Assert.AreEqual(0, siteViews.Views.Count);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="workbookId">GUID</param>
/// <param name="newOwnerId">GUID</param>
public SendUpdateWorkbookOwner(
// TableauServerUrls onlineUrls,
TableauServerSignIn login,
string workbookId,
string newOwnerId)
: base(login)
{
_onlineUrls = login.ServerUrls;
_workbookId = workbookId;
_newOwnerId = newOwnerId;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="datasourceId">GUID</param>
/// <param name="newOwnerId">GUID</param>
public SendUpdateDatasourceOwner(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
string datasourceId,
string newOwnerId)
: base(login)
{
_onlineUrls = onlineUrls;
_datasourceId = datasourceId;
_newOwnerId = newOwnerId;
}
public TableauServerSignIn(TableauServerUrls tableauUrls, string username, string password, IHttpClientFactory httpClientFactory, ILogger logger)
: base(httpClientFactory)
{
Logger = logger;
TableauUrls = tableauUrls;
Username = username;
Password = password;
SiteUrlSegment = tableauUrls.SiteUrlSegement;
HttpClientFactory = httpClientFactory;
}
/// <summary>
/// Synchronous call to test and make sure sign in works
/// </summary>
/// <param name="url"></param>
/// <param name="userId"></param>
/// <param name="userPassword"></param>
/// <param name="statusLog"></param>
public static void VerifySignInPossible(string url, string userId, string userPassword, TaskStatusLogs statusLog)
{
var urlManager = TableauServerUrls.FromContentUrl(url, TaskMasterOptions.RestApiReponsePageSizeDefault);
var signIn = new TableauServerSignIn(urlManager, userId, userPassword, statusLog);
bool success = signIn.Execute();
if (!success)
{
throw new Exception("Failed sign in");
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="workbook"></param>
/// <param name="localSavePath"></param>
public DownloadWorkbookThumbnail(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
SiteWorkbook workbook,
string localSavePath)
: base(login)
{
_onlineUrls = onlineUrls;
_workbook = workbook;
_localSavePathRoot = localSavePath;
}
/// <summary>
/// Synchronous call to test and make sure sign in works
/// </summary>
/// <param name="url">Tableau site url</param>
/// <param name="username">Tableau username</param>
/// <param name="userPassword">Tableau user's password</param>
/// <param name="statusLog">Status log</param>
public static void VerifySignInPossible(string url, string username, string userPassword, TaskStatusLogs statusLog)
{
var urlManager = TableauServerUrls.FromContentUrl(url, 1000);
var signIn = new TableauServerSignIn(urlManager, username, userPassword, statusLog);
var success = signIn.ExecuteRequest();
if (!success)
{
throw new Exception("Failed sign in");
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="scheduleId">Must be a GUID for a schedule</param>
public DownloadTasksExtractRefreshesList(TableauServerUrls onlineUrls, TableauServerSignIn login, string scheduleId)
: base(login)
{
if (string.IsNullOrWhiteSpace(scheduleId))
{
throw new ArgumentException("DownloadTasksExtractRefreshesList: Missign schedule id");
}
_onlineUrls = onlineUrls;
_scheduleId = scheduleId;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="workbookId">GUID</param>
/// <param name="newOwnerId">GUID</param>
public SendUpdateWorkbookOwner(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
string workbookId,
string newOwnerId)
: base(login)
{
_onlineUrls = onlineUrls;
_workbookId = workbookId;
_newOwnerId = newOwnerId;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="workbooks"></param>
/// <param name="localSavePath"></param>
/// <param name="projectsList"></param>
public DownloadWorkbooks(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
IEnumerable<SiteWorkbook> workbooks,
string localSavePath,
IProjectsList projectsList)
: base(login)
{
_onlineUrls = onlineUrls;
_workbooks = workbooks;
_localSavePath = localSavePath;
_downloadToProjectDirectories = projectsList;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="Datasources"></param>
/// <param name="localSavePath"></param>
/// <param name="projectsList"></param>
public DownloadDatasources(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
IEnumerable<SiteDatasource> Datasources,
string localSavePath,
IProjectsList projectsList)
: base(login)
{
_onlineUrls = onlineUrls;
_datasources = Datasources;
_localSavePath = localSavePath;
_downloadToProjectDirectories = projectsList;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="localUploadPath"></param>
/// <param name="uploadChunkSize"></param>
/// <param name="uploadChunkDelay"></param>
public UploadFile(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
string localUploadPath,
int uploadChunkSize = 8000000,
int uploadChunkDelay = 0)
: base(login)
{
_onlineUrls = onlineUrls;
_localUploadPath = localUploadPath;
_uploadChunkSize = uploadChunkSize;
_uploadChunkDelay = uploadChunkDelay;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="workbooks"></param>
/// <param name="localSavePath"></param>
/// <param name="projectsList"></param>
/// <param name="generateInfoFile">TRUE = Generate companion file for each download that contains metadata (e.g. whether "show tabs" is selected, the owner, etc)</param>
/// <param name="siteUsersLookup">If not NULL, use to look up the owners name, so we can write it into the InfoFile for the downloaded content</param>
public DownloadWorkbooks(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
IEnumerable<SiteWorkbook> workbooks,
string localSavePath,
IProjectsList projectsList,
bool generateInfoFile,
KeyedLookup<SiteUser> siteUserLookup)
: base(login)
{
_onlineUrls = onlineUrls;
_workbooks = workbooks;
_localSavePath = localSavePath;
_downloadToProjectDirectories = projectsList;
_generateInfoFile = generateInfoFile;
_siteUserLookup = siteUserLookup;
}
/// <summary>
/// Returns a file system path we can use to store information about the specified site
/// </summary>
/// <param name="siteUrl"></param>
/// <returns></returns>
private string GeneratePathFromSiteUrl(TableauServerUrls siteUrl)
{
string appPath =
Path.Combine(System.Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"TabMigrate");
//Add the server name to the path
appPath = Path.Combine(appPath, FileIOHelper.GenerateWindowsSafeFilename(siteUrl.ServerName));
//Add the site name to the path
string siteName = siteUrl.SiteUrlSegement;
if(!string.IsNullOrEmpty(siteName))
{
appPath = Path.Combine(appPath, siteName);
}
FileIOHelper.CreatePathIfNeeded(appPath);
return appPath;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="datasourceId"></param>
/// <param name="tagText"></param>
public SendDeleteDatasourceTag(
TableauServerUrls onlineUrls,
TableauServerSignIn login,
string datasourceId,
string tagText)
: base(login)
{
if(string.IsNullOrWhiteSpace(tagText))
{
throw new ArgumentException("Not allowed to delete a blank tag");
}
if (string.IsNullOrWhiteSpace(datasourceId))
{
throw new ArgumentException("Not allowed to delete a tag without datasource id");
}
_onlineUrls = onlineUrls;
_contentId = datasourceId;
_tagText = tagText;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="user"></param>
public TableauServerSignOut(TableauServerUrls onlineUrls, TableauServerSignIn login)
: base(login)
{
_onlineUrls = onlineUrls;
}
//Choose a keep alive time
/// <summary>
/// Constructor
/// </summary>
public KeepAliveBackgroundWebRequest(TableauServerUrls serverUrls, TableauServerSignIn signIn)
: base(TimeSpan.FromSeconds(60 * 2))
{
_serverUrls = serverUrls;
_signIn = signIn;
}
// private readonly OnlineUser _user;
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public DownloadDatasourcesList(TableauServerUrls onlineUrls, TableauServerSignIn login)
: base(login)
{
_onlineUrls = onlineUrls;
// _user = user;
}
/// <summary>
/// Constructor: Call when we want to query the Workbooks on behalf of an explicitly specified user
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="user"></param>
public DownloadWorkbooksList(TableauServerUrls onlineUrls, TableauServerSignIn login, string userId) : base(login)
{
_onlineUrls = onlineUrls;
_userId = userId;
}
/// <summary>
/// Constructor: Call when we want to query the workbooks on behalf of the currently logged in user
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public DownloadWorkbookConnections(TableauServerUrls onlineUrls, TableauServerSignIn login, string workbookId)
: base(login)
{
_workbookId = workbookId;
_onlineUrls = onlineUrls;
}
/// <summary>
/// Constructor: Call when we want to query the datasource on behalf of the currently logged in user
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public DownloadDatasourceConnections(TableauServerUrls onlineUrls, TableauServerSignIn login, string datasourceId)
: base(login)
{
_datasourceId = datasourceId;
_onlineUrls = onlineUrls;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
/// <param name="user"></param>
public DownloadSiteInfo(TableauServerUrls onlineUrls, TableauServerSignIn login)
: base(login)
{
_onlineUrls = onlineUrls;
// _user = user;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public DownloadUsersListBase(TableauServerUrls onlineUrls, TableauServerSignIn login)
: base(login)
{
_onlineUrls = onlineUrls;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public DownloadUsersListInGroup(TableauServerUrls onlineUrls, TableauServerSignIn login, string groupId)
: base(onlineUrls, login)
{
_groupId = groupId;
}
/// <summary>
/// Sign us out
/// </summary>
/// <param name="serverUrls"></param>
public void SignOut(TableauServerUrls serverUrls)
{
if(!_isSignedIn)
{
StatusLog.AddError("Session not signed in. Sign out aborted");
}
//Perform the sign out
var signOut = new TableauServerSignOut(serverUrls, this);
signOut.ExecuteRequest();
_isSignedIn = false;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public DownloadUsersList(TableauServerUrls onlineUrls, TableauServerSignIn login)
: base(onlineUrls, login)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="onlineUrls"></param>
/// <param name="login"></param>
public DownloadProjectsList(TableauServerUrls onlineUrls, TableauServerSignIn login)
: base(login)
{
_onlineUrls = onlineUrls;
}
public SendPostLogInCommand(TableauServerUrls onlineUrls, TableauServerSignIn login, string commandUrl)
: base(login)
{
_onlineUrls = onlineUrls;
_postLoginCommandUrl = commandUrl;
}
