private async void Page_LoadedAsync(object sender, RoutedEventArgs e)
{
PageBusy("Loading events from dataset " + _viewModel.Dataset.Name + " ...");
await _viewModel.LoadDataAsync();
PopulateSensors();
DrawSensors();
PopulateAnnotateFlyout();
// Check Application Settings for last saved states. If the state exists and is valid, load the state
ApplicationDataCompositeValue datasetLastSavedStates =
AppSettingsService.RetrieveFromSettings <ApplicationDataCompositeValue>(
"DatasetLastSavedStates", new ApplicationDataCompositeValue()
);
if (datasetLastSavedStates.TryGetValue(_viewModel.Dataset.Name, out object jsonDatasetSavedState))
{
DatasetViewSavedState datasetState = JsonConvert.DeserializeObject <DatasetViewSavedState>((string)jsonDatasetSavedState);
if (datasetState.Day <= _viewModel.LastEventDate && datasetState.Day >= _viewModel.FirstEventDate)
{
await _viewModel.LoadEventsAsync(datasetState.Day);
}
_viewModel.EventViewFilter = datasetState.Filter;
_viewModel.RefreshEventsInView();
if (datasetState.EventTimeTag != null)
{
int i = 0;
for (i = 0; i < _viewModel.EventsInView.Count; i++)
{
SensorEventViewModel sensorEvent = (SensorEventViewModel)_viewModel.EventsInView[i];
if (sensorEvent.TimeTag >= datasetState.EventTimeTag)
{
_viewModel.SelectedSensorEvent = sensorEvent;
break;
}
}
if (i == _viewModel.EventsInView.Count && i != 0)
{
_viewModel.SelectedSensorEvent = (SensorEventViewModel)_viewModel.EventsInView.Last();
}
}
else
{
if (datasetState.EventInView >= 0 && datasetState.EventInView < _viewModel.EventsInView.Count)
{
_viewModel.SelectedSensorEvent = (SensorEventViewModel)dataListView.Items[datasetState.EventInView];
}
}
if (_viewModel.SelectedSensorEvent != null)
{
dataListView.ScrollIntoView(_viewModel.SelectedSensorEvent);
}
}
PageReady();
}
private void btnExpandDown_Click(object sender, RoutedEventArgs e)
{
SensorEventViewModel sensorEvent = (SensorEventViewModel)((Button)sender).Tag;
_viewModel.FilterExpand(sensorEvent);
}
private async void MenuExport_ClickAsync(object sender, RoutedEventArgs e)
{
// Check and see if there are unsaved changes
if (_viewModel.IsEventsModified)
{
await ClosePageAsync();
}
DatasetExportDialog dialog = new DatasetExportDialog(_viewModel);
var result = await dialog.ShowAsync();
if (result == ContentDialogResult.Primary)
{
StorageFolder folder = dialog.ExportFolder;
DatasetExportViewModel datasetExportConfig = dialog.DatasetExportConfiguration;
if (datasetExportConfig.ExportInCSV)
{
// Dataset exported in csv events, where metadata about the dataset is stored in json file.
StorageFolder targetDatasetFolder;
try
{
targetDatasetFolder = await folder.GetFolderAsync(datasetExportConfig.DatasetName);
string message = "A folder named " + datasetExportConfig.DatasetName + " already existed at " + folder.Path + ". Do you want to overwrite?";
var dlg = new MessageDialog(message, "Overwrite Folder?");
UICommand yesCmd = new UICommand("Yes");
UICommand cancelCmd = new UICommand("Cancel");
dlg.Commands.Add(yesCmd);
dlg.Commands.Add(cancelCmd);
dlg.DefaultCommandIndex = 1;
dlg.CancelCommandIndex = 1;
var cmd = await dlg.ShowAsync();
if (cmd == cancelCmd)
{
return;
}
}
catch (Exception)
{ }
targetDatasetFolder = await folder.CreateFolderAsync(datasetExportConfig.DatasetName, CreationCollisionOption.ReplaceExisting);
PageBusy(string.Format("Exporting dataset {0} to folder {1}", datasetExportConfig.DatasetName, targetDatasetFolder.Path));
if (datasetExportConfig.ExportDateSelectionEnabled)
{
// Copy all files
foreach (var datasetFile in await _viewModel.Dataset.Folder.GetFilesAsync())
{
if (datasetFile.FileType == ".csv")
{
List <string> eventStringList = new List <string>();
// Open file, read each line, parse the time. If the time is inbetween the start date and stop date, write the line back to file.
using (var inputStream = await datasetFile.OpenReadAsync())
using (var classicStream = inputStream.AsStreamForRead())
using (var streamReader = new StreamReader(classicStream))
{
int lineNo = 0;
while (streamReader.Peek() >= 0)
{
string curEventString = streamReader.ReadLine();
if (string.IsNullOrWhiteSpace(curEventString))
{
continue;
}
try
{
string [] tokenList = curEventString.Split(new char[] { ',' });
// Get the Date of the String and add to dictionary
DateTimeOffset curEventTimeTag = DateTimeOffset.Parse(tokenList[0]);
if (curEventTimeTag.Date >= datasetExportConfig.ExportStartDate && curEventTimeTag.Date <= datasetExportConfig.ExportStopDate)
{
eventStringList.Add(curEventString);
}
if (curEventTimeTag.Date > datasetExportConfig.ExportStopDate)
{
break;
}
lineNo++;
}
catch (Exception except)
{
Logger.Instance.Error(this.GetType().Name, string.Format("Failed at line {0} with error message {1}", lineNo, except.Message));
}
}
}
StorageFile newDatasetFile = await targetDatasetFolder.CreateFileAsync(datasetFile.Name, CreationCollisionOption.ReplaceExisting);
using (var outputStream = await newDatasetFile.OpenAsync(FileAccessMode.ReadWrite))
using (var classicStream = outputStream.AsStreamForWrite())
using (var streamWriter = new StreamWriter(classicStream))
{
foreach (string eventString in eventStringList)
{
streamWriter.WriteLine(eventString);
}
}
}
else if (datasetFile.FileType == ".json")
{
await datasetFile.CopyAsync(targetDatasetFolder, datasetFile.Name, NameCollisionOption.ReplaceExisting);
}
}
}
else
{
// Copy all files
foreach (var datasetFile in await _viewModel.Dataset.Folder.GetFilesAsync())
{
await datasetFile.CopyAsync(targetDatasetFolder, datasetFile.Name, NameCollisionOption.ReplaceExisting);
}
}
// Change name of the copied metadata file
if (datasetExportConfig.DatasetRenameEnabled)
{
Dataset dataset = await Dataset.LoadMetadataFromFolderAsync(targetDatasetFolder);
dataset.Name = datasetExportConfig.DatasetName;
await dataset.WriteMetadataToFolderAsync();
}
PageReady();
return;
}
if (datasetExportConfig.ExportInTxt)
{
// For backward compatibility, one can export the dataset in old-style txt format.
string txtFileName = datasetExportConfig.DatasetName + "_" + DateTime.Now.ToString("yyyyMMdd_HHmmss") + ".txt";
StorageFile newDatasetFile = await folder.CreateFileAsync(txtFileName, CreationCollisionOption.ReplaceExisting);
PageBusy(string.Format("Exporting dataset {0} to {1}", datasetExportConfig.DatasetName, newDatasetFile.Path));
List <string> eventStringList = new List <string>();
SensorEventViewModel sensorEvent = _viewModel.ParseSensorEventFromString(_viewModel.AllEventsStringList[0]);
SensorEventViewModel nextSensorEvent;
string previousActivity = "";
for (int idEvent = 0; idEvent < _viewModel.AllEventsStringList.Count; idEvent++)
{
nextSensorEvent = (idEvent == _viewModel.AllEventsStringList.Count - 1) ? null :
_viewModel.ParseSensorEventFromString(_viewModel.AllEventsStringList[idEvent + 1]);
if (sensorEvent.TimeTag.Date >= datasetExportConfig.ExportStartDate &&
sensorEvent.TimeTag.Date <= datasetExportConfig.ExportStopDate)
{
string annotationString = "";
if (sensorEvent.Activity.Name != "Other_Activity")
{
if (sensorEvent.Activity.Name != previousActivity)
{
annotationString = sensorEvent.Activity.Name + "=\"begin\"";
}
else if (nextSensorEvent == null)
{
annotationString = sensorEvent.Activity.Name + "=\"end\"";
}
else if (nextSensorEvent.Activity.Name != sensorEvent.Activity.Name)
{
annotationString = sensorEvent.Activity.Name + "=\"end\"";
}
}
eventStringList.Add(
sensorEvent.TimeTag.ToString("yyyy-MM-dd") + "\t" +
sensorEvent.TimeTag.ToString("HH:mm:ss.ffffff") + "\t" +
sensorEvent.Sensor.Name + "\t" +
sensorEvent.SensorState + "\t" +
annotationString
);
previousActivity = sensorEvent.Activity.Name;
}
if (sensorEvent.TimeTag.Date > datasetExportConfig.ExportStopDate)
{
break;
}
sensorEvent = nextSensorEvent;
}
using (var outputStream = await newDatasetFile.OpenAsync(FileAccessMode.ReadWrite))
using (var classicStream = outputStream.AsStreamForWrite())
using (var streamWriter = new StreamWriter(classicStream))
{
foreach (string eventString in eventStringList)
{
streamWriter.WriteLine(eventString);
}
}
PageReady();
return;
}
}
}
