public static void ExecuteJobThroughSteps(ProgramOptions programOptions)
{
// Read job file from the location
logger.Info("Starting job from status {0}({0:d})", programOptions.ReportJob.Status);
loggerConsole.Info("Starting job from status {0}({0:d})", programOptions.ReportJob.Status);
// Run the step and move to next until things are done
while (programOptions.ReportJob.Status != JobStatus.Done && programOptions.ReportJob.Status != JobStatus.Error)
{
logger.Info("Executing job step {0}({0:d})", programOptions.ReportJob.Status);
loggerConsole.Info("Executing job step {0}({0:d})", programOptions.ReportJob.Status);
JobStepBase jobStep = getJobStepFromFactory(programOptions.ReportJob.Status);
if (jobStep != null)
{
if (jobStep.ShouldExecute(programOptions) == true)
{
if (jobStep.Execute(programOptions) == false)
{
programOptions.ReportJob.Status = JobStatus.Error;
}
}
}
if (programOptions.ReportJob.Status != JobStatus.Error)
{
programOptions.ReportJob.Status = jobStepsLinked.Find(programOptions.ReportJob.Status).Next.Value;
}
// Save progress of the report in case we want to resume or rerun later
FileIOHelper.WriteReportJobToFile(programOptions.ReportJob, programOptions.ReportJobFilePath);
}
return;
}
private void AddProfile(Profile profileData = null)
{
var isNew = profileData == null;
var newName = GetFileName("Profile Name", Paths.ProfilePath, new[] { Vendor.ProfileExtension }, "", "Create");
if (string.Empty == newName)
{
return;
}
var root = (null != _contextProfile && _contextProfile.FileName != null)
? Path.GetDirectoryName(_contextProfile.FileName) ?? Paths.ProfilePath : Paths.ProfilePath;
var newFileName = Path.Combine(root, newName + Vendor.ProfileExtension);
DeleteIfExists(newFileName);
var profile = isNew ? new Profile() : profileData;
profile.FileName = newFileName;
profile.Name = newName;
profile.FileIOHandler = FileIOHelper.GetNativeHelper();
SaveProfile(profile);
RefreshProfileComboBox(newName);
}
public static async Task SaveLibraryIndex(List <int> l)
{
var j = Newtonsoft.Json.JsonConvert.SerializeObject(l);
var file = await FileIOHelper.GetFileFromLocalAsync("LibraryIndex");
await FileIO.WriteTextAsync(file, j);
}
/// <summary>
/// Attempts to upload a single file a Tableau Server, and then make it a published workbook
/// </summary>
/// <param name="localFilePath"></param>
/// <returns></returns>
private bool AttemptUploadSingleFile_Inner(
string localFilePath,
string projectId,
CredentialManager.Credential dbCredentials,
WorkbookPublishSettings publishSettings)
{
string uploadSessionId;
try
{
var fileUploader = new UploadFile(_onlineUrls, _onlineSession, localFilePath, _uploadChunkSizeBytes, _uploadChunkDelaySeconds);
uploadSessionId = fileUploader.ExecuteRequest();
}
catch (Exception exFileUpload)
{
this.StatusLog.AddError("Unexpected error attempting to upload file " + localFilePath + ", " + exFileUpload.Message);
throw exFileUpload;
}
SiteWorkbook workbook;
this.StatusLog.AddStatus("File chunks upload successful. Next step, make it a published workbook", -10);
try
{
string fileName = Path.GetFileNameWithoutExtension(localFilePath);
string uploadType = RemoveFileExtensionDot(Path.GetExtension(localFilePath).ToLower());
workbook = FinalizePublish(
uploadSessionId,
FileIOHelper.Undo_GenerateWindowsSafeFilename(fileName), //[2016-05-06] If the name has escapted characters, unescape them
uploadType,
projectId,
dbCredentials,
publishSettings);
StatusLog.AddStatus("Upload content details: " + workbook.ToString(), -10);
StatusLog.AddStatus("Success! Uploaded workbook " + Path.GetFileName(localFilePath));
}
catch (Exception exPublishFinalize)
{
this.StatusLog.AddError("Unexpected error finalizing publish of file " + localFilePath + ", " + exPublishFinalize.Message);
LogManualAction_UploadWorkbook(localFilePath);
throw exPublishFinalize;
}
//See if we want to reassign ownership of the workbook
if (_attemptOwnershipAssignment)
{
try
{
AttemptOwnerReassignment(workbook, publishSettings, _siteUsers);
}
catch (Exception exOwnershipAssignment)
{
this.StatusLog.AddError("Unexpected error reassigning ownership of published workbook " + workbook.Name + ", " + exOwnershipAssignment.Message);
LogManualAction_ReassignOwnership(workbook.Name);
throw exOwnershipAssignment;
}
}
return(true); //Success
}
public static T Read(string path)
{
string text = FileIOHelper.ReadFile(path);
return(JsonUtility.FromJson <T>(text));
}
public void ReadFromFileTest()
{
var filepath = @"D:\\Weather Info\\Source\CityList.txt";
IEnumerable <City> cities = FileIOHelper.ReadFromFile(filepath);
Assert.AreEqual(10, cities.Count());
}
public static async void JsonUnitTest()
{
Dictionary <int, Notification> notificationStore = new Dictionary <int, Notification>();
var dataSource = new DataSource();
for (int i = 0; i < 5; i++)
{
var notification = new Notification()
{
Id = i,
HtmlUrl = new Uri("http://details.HtmlUrl"),
UserId = i * 10,
SubjectTitle = String.Format("note.Subject.Title {0}", i.ToString()),
Body = String.Format("details.Body {0}", i.ToString()),
TimeStamp = DateTimeHelper.DateTimeToUtcString(DateTime.UtcNow)
};
notificationStore.Add(i, notification);
}
var text = JsonHelper.StorageToJsonString("Notifications", notificationStore);
await FileIOHelper.WriteUtf8ToLocalFileAsync("GitMeTests", "Notifications", text);
var text2 = await FileIOHelper.ReadLocalFileAsync("GitMeTests", "Notifications");
await FileIOHelper.WriteUtf8ToSDAsync("GitMeTests", "JsonUnitTesttext.json", text);
await FileIOHelper.WriteUtf8ToSDAsync("GitMeTests", "JsonUnitTesttext2.json", text2);
Dictionary <int, Notification> notes = JsonHelper.DeserializeToStorage("Notifications", text);
Dictionary <int, Notification> notes2 = JsonHelper.DeserializeToStorage("Notifications", text2);
bool b = String.Equals(notes[0].Body, notes2[0].Body);
return;
}
public async Task <IActionResult> Index(IFormFile file)
{
if (file == null || file.Length == 0)
{
return(Content("file not selected"));
}
var destPath = _configuration["DestinationDir"];
using (var stream = new FileStream(file.FileName, FileMode.Create))
{
await file.CopyToAsync(stream);
}
IEnumerable <City> cities = FileIOHelper.ReadFromFile(file.FileName);
Parallel.ForEach(cities, (currentCity) =>
{
IWeatherFetcher wf = new WeatherFetcher(_configuration["WeatherAPIUrl"], _configuration["WeatherAPIKey"]);
var currentWeather = wf.GetCurrentWeather(currentCity.CityId);
var dirInfo = FileIOHelper.CreateDestinationFolder(destPath);
FileIOHelper.WriteToJsonFile <CurrentWeather>($"{dirInfo.FullName}\\{currentCity.Cityname}_{currentCity.CityId} .txt", currentWeather, append: false);
});
ViewBag.Message = string.Format("Report generated at specified destination path.\\nCurrent Date and Time: {0}", DateTime.Now.ToString());
return(View());
}
public async Task SaveDataAsync(string currentId, string resstr, DataSource source)
{
try
{
switch (source)
{
case DataSource.HeWeather:
await FileIOHelper.SaveStringtoStorageAsync(currentId + "_H", resstr);
break;
case DataSource.Caiyun:
await FileIOHelper.SaveStringtoStorageAsync(currentId + "_C", resstr);
break;
case DataSource.Wunderground:
await FileIOHelper.SaveStringtoStorageAsync(currentId + "_W", resstr);
break;
default:
break;
}
}
catch (Exception)
{
}
}
private string GetDBfileInfo()
{
try
{
LogHelper.WriteMethodLog(true);
string tempzip = Path.Combine(AppSettings.XXPTempFolder, ConstHelper.BC_DBZipName);
if (File.Exists(tempzip))
{
FileIOHelper.DeleteFile(tempzip);
}
ZipHelper.Zip(AppSettings.XXPDBFolder, tempzip);
FileInfo tempzipInfo = new FileInfo(tempzip);
LeveldbOperator.OpenDB(AppSettings.XXPDBFolder);
string strLastblock = LeveldbOperator.GetValue(ConstHelper.BC_LastKey);
Block block = JsonHelper.Deserialize <Block>(strLastblock);
LeveldbOperator.CloseDB();
DBFileInfo dbinfo = new DBFileInfo(tempzipInfo.Length, block.Header.Height);
return(JsonHelper.Serializer <DBFileInfo>(dbinfo));;
}
catch (Exception ex)
{
LogHelper.WriteErrorLog(ex.Message);
return(string.Empty);
}
finally
{
LogHelper.WriteMethodLog(false);
}
}
internal void ImmersiveIn(Uri uri)
{
continueUpdate();
if (uri == null)
{
backBlur.ImmersiveOut(false);
return;
}
if (Canvas != null)
{
var task = Canvas.RunOnGameLoopThreadAsync(async() =>
{
using (var stream = await FileIOHelper.ReadRandomAccessStreamByUriAsync(uri))
{
if (Canvas != null)
{
await backBlur.LoadSurfaceAsync(Canvas, stream);
}
}
backBlur.ImmersiveIn();
});
}
if (!EnableBGBlur)
{
stopUpdate();
}
if (EnableDynamic && ((condition == WeatherCondition.cloudy) || (condition == WeatherCondition.few_clouds) || (condition == WeatherCondition.partly_cloudy) || (condition == WeatherCondition.overcast)))
{
smoke.ImmersiveIn();
}
}
private void btnProvisionFromAzureAd_Click(object sender, EventArgs e)
{
var statusLogs = new TaskStatusLogs();
statusLogs.AddStatus("Starting...");
UpdateStatusText(statusLogs, true);
string pathSecrets = txtPathToSecrets.Text;
if (!File.Exists(pathSecrets))
{
MessageBox.Show("Secrets file does not exist at specified path (" + pathSecrets + ")");
return;
}
string pathProvisionPlan = txtPathToAzureAdProvisioningConfig.Text;
if (!File.Exists(pathProvisionPlan))
{
MessageBox.Show("Config file does not exist at specified path (" + pathProvisionPlan + ")");
return;
}
string pathOutput =
Path.Combine(
Path.GetDirectoryName(pathProvisionPlan),
"out");
FileIOHelper.CreatePathIfNeeded(pathOutput);
//Show the user a command line that they can use to run this same work
GenerateProvisioningCommandLine(
CommandLineParser.Command_ProvisionFromAzure,
pathSecrets,
pathProvisionPlan,
pathOutput);
//Run the work
try
{
ProvisionFromAzureAd(
statusLogs,
pathSecrets,
txtPathToAzureAdProvisioningConfig.Text,
pathOutput);
}
catch (Exception exError)
{
MessageBox.Show("Error: " + exError.Message);
}
UpdateStatusText(statusLogs, true);
//Open the file explorer to the output directory
if (Directory.Exists(pathOutput))
{
System.Diagnostics.Process.Start(pathOutput);
}
}
private int extractAuditLogEvents(JobConfiguration jobConfiguration, JobTarget jobTarget, ControllerApi controllerApi)
{
JArray listOfAuditEvents = new JArray();
foreach (JobTimeRange jobTimeRange in jobConfiguration.Input.HourlyTimeRanges)
{
string auditEventsJSON = controllerApi.GetAuditEvents(jobTimeRange.From, jobTimeRange.To);
if (auditEventsJSON != String.Empty)
{
JArray listOfAuditEventsInTimeRange = JArray.Parse(auditEventsJSON);
if (listOfAuditEventsInTimeRange != null)
{
// Load audit log events
foreach (JObject auditEvent in listOfAuditEventsInTimeRange)
{
listOfAuditEvents.Add(auditEvent);
}
}
}
}
if (listOfAuditEvents.Count > 0)
{
FileIOHelper.WriteJArrayToFile(listOfAuditEvents, FilePathMap.AuditEventsDataFilePath(jobTarget));
logger.Info("{0} audit events from {1:o} to {2:o}", listOfAuditEvents.Count, jobConfiguration.Input.TimeRange.From, jobConfiguration.Input.TimeRange.To);
loggerConsole.Info("{0} audit events", listOfAuditEvents.Count);
}
return(listOfAuditEvents.Count);
}
public RoadNetwork()
{
string modelFilePath = ConfigurationSettings.AppSettings["ModelFile"];
Model model = (Model)FileIOHelper.loadObject(modelFilePath);
NetworkModel = model;
}
private async void AccountDataDeleteInvokedHandler(IUICommand command)
{
// Display message showing the label of the command that was invoked
switch ((int)command.Id)
{
case 0:
try
{
await FileIOHelper.WriteUtf8ToLocalFileAsync("Data", "Notifications.json", "");
await FileIOHelper.WriteUtf8ToLocalFileAsync("Data", "Repositories.json", "");
await FileIOHelper.WriteUtf8ToLocalFileAsync("Data", "Users.json", "");
DataState.LastDataFetchSuccess = false;
DataState.LastDataFetchAt = DateTime.UtcNow;
NotifyUser(Constants.AccountDataDeleteSuccess, NotifyType.StatusMessage);
return;
}
catch
{
// ignore
}
break;
default:
break;
}
NotifyUser(Constants.AccountDataDeleteSuccess2, NotifyType.StatusMessage);
}
/// <summary>
///
/// </summary>
/// <param name="serverName"></param>
public List <SiteDatasource> ExecuteRequest()
{
var downloadedContent = new List <SiteDatasource>();
//Depending on the HTTP download file type we want different file extensions
var typeMapper = new DownloadPayloadTypeHelper("tdsx", "tds");
var datasources = Datasources;
if (datasources == null)
{
Login.Logger.Error("NULL datasources. Aborting download.");
return(null);
}
//For each datasource, download it and save it to the local file system
foreach (var dsInfo in datasources)
{
//Local path save the workbook
string urlDownload = Urls.Url_DatasourceDownload(Login, dsInfo);
Login.Logger.Information("Starting Datasource download " + dsInfo.Name);
try
{
//Generate the directory name we want to download into
var pathToSaveTo = FileIOHelper.EnsureProjectBasedPath(
LocalSavePath,
DownloadToProjectDirectories,
dsInfo,
Login.Logger);
var fileDownloaded = this.DownloadFile(urlDownload, pathToSaveTo, dsInfo.Name, typeMapper);
var fileDownloadedNoPath = System.IO.Path.GetFileName(fileDownloaded);
Login.Logger.Information("Finished Datasource download " + fileDownloadedNoPath);
//Add to the list of our downloaded data sources
if (!string.IsNullOrEmpty(fileDownloaded))
{
downloadedContent.Add(dsInfo);
//Generate the metadata file that has additional server provided information about the workbook
if (GenerateInfoFile)
{
Helpers.DatasourcePublishSettings.CreateSettingsFile(dsInfo, fileDownloaded, SiteUserLookup);
}
}
else
{
//We should never hit this code; just being defensive
Login.Logger.Error("Download error, no local file path for downloaded content");
}
}
catch (Exception ex)
{
Login.Logger.Error("Error during Datasource download " + dsInfo.Name + "\r\n " + urlDownload + "\r\n " + ex.ToString());
}
}
//Return the set of successfully downloaded content
return(downloadedContent);
}
private int extractHealthRuleViolations(JobConfiguration jobConfiguration, JobTarget jobTarget, ControllerApi controllerApi)
{
JArray listOfHealthRuleViolations = new JArray();
foreach (JobTimeRange jobTimeRange in jobConfiguration.Input.HourlyTimeRanges)
{
long fromTimeUnix = UnixTimeHelper.ConvertToUnixTimestamp(jobTimeRange.From);
long toTimeUnix = UnixTimeHelper.ConvertToUnixTimestamp(jobTimeRange.To);
string healthRuleViolationsJSON = controllerApi.GetHealthRuleViolations(jobTarget.ApplicationID, fromTimeUnix, toTimeUnix);
if (healthRuleViolationsJSON != String.Empty)
{
// Load health rule violations
JArray healthRuleViolationsInHour = JArray.Parse(healthRuleViolationsJSON);
foreach (JObject healthRuleViolation in healthRuleViolationsInHour)
{
listOfHealthRuleViolations.Add(healthRuleViolation);
}
}
}
if (listOfHealthRuleViolations.Count > 0)
{
FileIOHelper.WriteJArrayToFile(listOfHealthRuleViolations, FilePathMap.HealthRuleViolationsDataFilePath(jobTarget));
logger.Info("{0} health rule violations from {1:o} to {2:o}", listOfHealthRuleViolations.Count, jobConfiguration.Input.TimeRange.From, jobConfiguration.Input.TimeRange.To);
loggerConsole.Info("{0} health rule violations", listOfHealthRuleViolations.Count);
}
return(listOfHealthRuleViolations.Count);
}
public static void Write(string path, T data)
{
string file_path = path;
string json = JsonUtility.ToJson(data, true);
FileIOHelper.WriteFile(file_path, json);
}
private int extractEvents(JobConfiguration jobConfiguration, JobTarget jobTarget, ControllerApi controllerApi, string eventType)
{
JArray listOfEvents = new JArray();
foreach (JobTimeRange jobTimeRange in jobConfiguration.Input.HourlyTimeRanges)
{
long fromTimeUnix = UnixTimeHelper.ConvertToUnixTimestamp(jobTimeRange.From);
long toTimeUnix = UnixTimeHelper.ConvertToUnixTimestamp(jobTimeRange.To);
string eventsJSON = controllerApi.GetEvents(jobTarget.ApplicationID, eventType, fromTimeUnix, toTimeUnix);
if (eventsJSON != String.Empty)
{
// Load events
JArray eventsInHour = JArray.Parse(eventsJSON);
foreach (JObject interestingEvent in eventsInHour)
{
listOfEvents.Add(interestingEvent);
}
}
}
if (listOfEvents.Count > 0)
{
FileIOHelper.WriteJArrayToFile(listOfEvents, this.FilePathMap.EventsDataFilePath(jobTarget, eventType));
logger.Info("{0} {1} events from {2:o} to {3:o}", eventType, listOfEvents.Count, jobConfiguration.Input.TimeRange.From, jobConfiguration.Input.TimeRange.To);
loggerConsole.Info("{0} {1} events", eventType, listOfEvents.Count);
}
return(listOfEvents.Count);
}
public void ReadFromFileCheckIfFiledoesnotExistTest()
{
var filepath = @"D:\\Weather Info\\Destination";
var cities = FileIOHelper.ReadFromFile(filepath);
Assert.IsNull(cities);
}
/// <summary>
/// Provision the site based on the provisioning manifest in a file
/// </summary>
/// <param name="statusLogs">Store status logs here</param>
/// <param name="pathSecrets">Where the log in secrets are</param>
/// <param name="pathProvisioningManifest">Where the provisioning steps are</param>
/// <param name="outputPath">Where output files go</param>
private void ProvisionFromFileManifest(TaskStatusLogs statusLogs, string pathSecrets, string pathProvisioningManifest, string outputPath)
{
//Load the config from the files
var secretsConfig = new ProvisionConfigSiteAccess(pathSecrets);
//Load the user provisioning instructions
var provisionUsersInfo = new ProvisionUserInstructions(
pathProvisioningManifest);
var provisionSite = new ProvisionSite(secretsConfig, provisionUsersInfo, this, statusLogs);
provisionSite.Execute();
//---------------------------------------------------------------------
//Generate an output file
//---------------------------------------------------------------------
FileIOHelper.CreatePathIfNeeded(outputPath);
var outputFilePath = Path.Combine(outputPath, "ProvisionSiteOutput.csv");
provisionSite.CSVResultsReport.GenerateCSVFile(outputFilePath);
statusLogs.AddStatusHeader("Done!");
((IShowLogs)this).NewLogResultsToShow(statusLogs);
}
public void WriteToJsonFileTest()
{
string path = "D:\\Weather Info\\Source";
var directoryInfo = FileIOHelper.CreateDestinationFolder(path);
var now = DateTime.Now;
var yearName = now.ToString("yyyy");
var monthName = now.ToString("MMMM");
var dayName = now.ToString("dd-MM-yyyy");
string filepath = $"{path}\\{yearName}\\{monthName}\\{dayName}";
City city = new City()
{
Cityname = "London", CityId = "2643741"
};
IWeatherFetcher wf = new WeatherFetcher("http://api.openweathermap.org", "aa69195559bd4f88d79f9aadeb77a8f6");
var currentWeather = wf.GetCurrentWeather(city.CityId);
var destinationFilepath = $"{filepath}\\{city.Cityname}_{city.CityId}.txt";
FileIOHelper.WriteToJsonFile <CurrentWeather>(destinationFilepath, currentWeather, append: false);
var DoesFileExist = File.Exists(destinationFilepath);
Assert.IsTrue(DoesFileExist);
}
private void readGranularRangeOfMetricsIntoEntities(
Dictionary <string, DBEntityBase> entitiesDictionaryByName,
JobTimeRange jobTimeRange,
JobTarget jobTarget,
List <MetricExtractMapping> entityMetricExtractMappingList,
string entityFolderName,
string entityType,
Dictionary <string, List <MetricValue> > metricValuesDictionary)
{
List <MetricExtractMapping> entityMetricExtractMappingListFiltered = entityMetricExtractMappingList.Where(m => m.EntityType == entityType).ToList();
foreach (MetricExtractMapping metricExtractMapping in entityMetricExtractMappingListFiltered)
{
List <AppDRESTMetric> metricData = FileIOHelper.LoadListOfObjectsFromFile <AppDRESTMetric>(FilePathMap.MetricHourRangeDataFilePath(jobTarget, entityFolderName, metricExtractMapping.FolderName, jobTimeRange));
if (metricData != null)
{
List <MetricValue> metricValues = readMetricsIntoEntities(metricData, entitiesDictionaryByName, jobTarget, jobTimeRange);
if (metricValues != null)
{
if (metricValuesDictionary.ContainsKey(metricExtractMapping.FolderName) == false)
{
metricValuesDictionary.Add(metricExtractMapping.FolderName, metricValues);
}
else
{
metricValuesDictionary[metricExtractMapping.FolderName].AddRange(metricValues);
}
}
}
}
}
/// <summary>
/// Downloads a file
/// </summary>
/// <param name="urlDownload"></param>
/// <param name="downloadToDirectory"></param>
/// <param name="baseFileName">Filename without extension</param>
/// <returns>The path to the downloaded file</returns>
private string DownloadFile_inner(string urlDownload, string downloadToDirectory, string baseFilename, DownloadPayloadTypeHelper downloadTypeMapper)
{
//[2016-05-06] Interestingly 'GetFileNameWithoutExtension' does more than remove a ".xxxx" extension; it will also remove a preceding
// path (e.g. GetFileNameWithoutExtension('foo/bar.xxx') -> "bar'. This is undesirable because these characters are valid
// in Tableau Server content names. Since this function is supposed to be called with a 'baseFilename' that DOES NOT have a .xxx
// extension, it is safe to remove this call
//baseFilename = FileIOHelper.GenerateWindowsSafeFilename(System.IO.Path.GetFileNameWithoutExtension(baseFilename));
//Strip off an extension if its there
baseFilename = FileIOHelper.GenerateWindowsSafeFilename(baseFilename);
var webClient = this.CreateLoggedInWebClient();
using (webClient)
{
//Choose a temp file name to download to
var starterName = System.IO.Path.Combine(downloadToDirectory, baseFilename + ".tmp");
_onlineSession.StatusLog.AddStatus("Attempting file download: " + urlDownload, -10);
webClient.DownloadFile(urlDownload, starterName); //Download the file
//Look up the correct file extension based on the content type downloaded
var contentType = webClient.ResponseHeaders["Content-Type"];
var fileExtension = downloadTypeMapper.GetFileExtension(contentType);
var finishName = System.IO.Path.Combine(downloadToDirectory, baseFilename + fileExtension);
//Rename the downloaded file
System.IO.File.Move(starterName, finishName);
return(finishName);
}
}
private void InitializeProfiles(bool reload = false)
{
var errors = new StringBuilder();
cbProfiles.Items.Clear();
cbProfiles.Items.Add("Select or add a profile");
foreach (var profileFile in
Directory.GetFiles(Paths.ProfilePath, Vendor.All + Vendor.ProfileExtension).Where(
profileFile => Path.GetExtension(profileFile) == Vendor.ProfileExtension))
{
try {
var nativeIO = FileIOHelper.GetNativeHelper();
cbProfiles.Items.Add(nativeIO.OpenProfile(profileFile));
}
catch (XmlException e) {
errors.AppendLine(string.Format("{0}\nFailed to load because: {1}\n", profileFile, e.Message));
}
}
if (errors.Length <= 0 || _suppressErrors || reload)
{
return;
}
errors.AppendLine(
"You will continue to see this message until the offending files are fixed, moved or deleted. You can also supress this message in preferences by selecting 'Silence profile editor errors'");
MessageBox.Show(errors.ToString(), "Errors loading some profiles");
}
internal List <MetricExtractMapping> getMetricsExtractMappingList(JobConfiguration jobConfiguration)
{
List <MetricExtractMapping> entityMetricExtractMappingList = FileIOHelper.ReadListFromCSVFile <MetricExtractMapping>(FilePathMap.EntityMetricExtractMappingFilePath(), new MetricExtractMappingReportMap());
List <MetricExtractMapping> entityMetricExtractMappingListFiltered = new List <MetricExtractMapping>(entityMetricExtractMappingList.Count);
foreach (string metricSet in jobConfiguration.Input.MetricsSelectionCriteria)
{
List <MetricExtractMapping> entityMetricExtractMappingListForMetricSet = entityMetricExtractMappingList.Where(m => m.MetricSet == metricSet).ToList();
if (entityMetricExtractMappingListForMetricSet != null)
{
logger.Info("Input job specified {0} metric set, resulted in {1} metrics from mapping file", metricSet, entityMetricExtractMappingListForMetricSet.Count);
loggerConsole.Info("Input job specified {0} metric set, resulted in {1} metrics from mapping file", metricSet, entityMetricExtractMappingListForMetricSet.Count);
entityMetricExtractMappingListFiltered.AddRange(entityMetricExtractMappingListForMetricSet);
foreach (MetricExtractMapping mem in entityMetricExtractMappingListForMetricSet)
{
logger.Trace("{0}, path={1}", mem, mem.MetricPath);
}
}
}
logger.Info("Selected {0} metrics from mapping file", entityMetricExtractMappingListFiltered.Count);
loggerConsole.Info("Selected {0} metrics from mapping file", entityMetricExtractMappingListFiltered.Count);
return(entityMetricExtractMappingListFiltered);
}
public void StringStreamText()
{
string origin = "mother f****r what you are!\r\t";
string actual = FileIOHelper.StreamToString(FileIOHelper.StringToStream(origin));
Assert.AreEqual(origin, actual);
}
public static async Task WriteToStorageFile(string storageType)
{
string fileName = String.Format("{0}.json", storageType);
string result;
switch (storageType)
{
case "Notifications":
result = JsonHelper.StorageToJsonString(storageType, notificationStore);
break;
case "Repositories":
result = JsonHelper.StorageToJsonString(storageType, repositoryStore);
break;
case "Users":
result = JsonHelper.StorageToJsonString(storageType, userStore);
break;
default:
throw new ArgumentException();
}
await FileIOHelper.WriteUtf8ToLocalFileAsync("Data", fileName, result);
#if DEBUG
await FileIOHelper.WriteUtf8ToSDAsync("GitMe", fileName, result);
#endif
}
private static async Task GetStorageFileAsync(string fileType)
{
dynamic jsonStore = await FileIOHelper.GetStorageFromLocalFileAsync("Data", fileType);
if (jsonStore == null || jsonStore.Count == 0)
{
return;
}
foreach (var key in jsonStore.Keys)
{
switch (fileType)
{
case "Notifications":
notificationStore.UpdateOrInsert(key, jsonStore[key]);
break;
case "Repositories":
repositoryStore.UpdateOrInsert(key, jsonStore[key]);
break;
case "Users":
userStore.UpdateOrInsert(key, jsonStore[key]);
break;
default:
throw new ArgumentException();
}
}
}
/// <summary>
/// Attempts to upload a single file a Tableau Server, and then make it a published data source
/// </summary>
/// <param name="localFilePath"></param>
/// <param name="projectId"></param>
/// <param name="dbCredentials">If not NULL, then these are the DB credentials we want to associate with the content we are uploading</param>
/// <returns></returns>
private bool AttemptUploadSingleFile(
string localFilePath,
string projectId,
CredentialManager.Credential dbCredentials,
DatasourcePublishSettings publishSettings)
{
string uploadSessionId;
try
{
var fileUploader = new UploadFile(Urls, Login, localFilePath, HttpClientFactory, UploadChunkSizeBytes, UploadChunkDelaySeconds);
uploadSessionId = fileUploader.ExecuteRequest();
}
catch (Exception exFileUpload)
{
Login.Logger.Error("Unexpected error attempting to upload file " + localFilePath + ", " + exFileUpload.Message);
throw exFileUpload;
}
SiteDatasource dataSource = null;
Login.Logger.Information("File chunks upload successful. Next step, make it a published datasource");
try
{
string fileName = Path.GetFileNameWithoutExtension(localFilePath);
string uploadType = RemoveFileExtensionDot(Path.GetExtension(localFilePath).ToLower());
dataSource = FinalizePublish(
uploadSessionId,
FileIOHelper.Undo_GenerateWindowsSafeFilename(fileName), //[2016-05-06] If the name has escapted characters, unescape them
uploadType,
projectId,
dbCredentials);
UploadeDatasources.Add(dataSource);
Login.Logger.Information("Upload content details: " + dataSource.ToString());
Login.Logger.Information("Success! Uploaded datasource " + Path.GetFileName(localFilePath));
}
catch (Exception exPublishFinalize)
{
Login.Logger.Error("Unexpected error finalizing publish of file " + localFilePath + ", " + exPublishFinalize.Message);
throw exPublishFinalize;;
}
//See if we want to reassign ownership of the datasource
if (AttemptOwnershipAssignment)
{
try
{
AttemptOwnerReassignment(dataSource, publishSettings, SiteUsers);
}
catch (Exception exOwnershipAssignment)
{
Login.Logger.Error("Unexpected error reassigning ownership of published datasource " + dataSource.Name + ", " + exOwnershipAssignment.Message);
LogManualAction_ReassignOwnership(dataSource.Name);
throw exOwnershipAssignment;
}
}
return(true); //Success
}
