/// <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; }