public async Task <IEnumerable <AnalogyLogMessage> > Process(IAnalogyOfflineDataProvider fileDataProvider, string filename, CancellationToken token)
{
FileName = filename;
if (string.IsNullOrEmpty(FileName))
{
return(new List <AnalogyLogMessage>());
}
if (!DataWindow.ForceNoFileCaching && FileProcessingManager.Instance.AlreadyProcessed(FileName) && Settings.EnableFileCaching) //get it from the cache
{
var cachedMessages = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(cachedMessages, Utils.GetFileNameAsDataSource(FileName));
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(cachedMessages);
}
if (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
while (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
await Task.Delay(1000);
}
var cachedMessages = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(cachedMessages, Utils.GetFileNameAsDataSource(FileName));
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(cachedMessages);
}
//otherwise read file:
try
{
FileProcessingManager.Instance.AddProcessingFile(FileName);
if (!DataWindow.DoNotAddToRecentHistory)
{
Settings.AddToRecentFiles(fileDataProvider.ID, FileName);
}
var messages = (await fileDataProvider.Process(filename, token, DataWindow).ConfigureAwait(false)).ToList();
FileProcessingManager.Instance.DoneProcessingFile(messages.ToList(), FileName);
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(messages);
}
catch (Exception e)
{
AnalogyLogger.Intance.LogCritical("Analogy", $"Error parsing file: {e}");
AnalogyLogMessage error = new AnalogyLogMessage($"Error reading file {filename}: Error: {e.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
error.Source = nameof(FileProcessor);
error.Module = "Analogy";
DataWindow.AppendMessage(error, fileDataProvider.GetType().FullName);
return(new List <AnalogyLogMessage> {
error
});
}
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(IAnalogyOfflineDataSource fileDataSource, string filename, CancellationToken token)
{
FileName = filename;
if (string.IsNullOrEmpty(FileName))
{
return(new List <AnalogyLogMessage>());
}
if (FileProcessingManager.Instance.AlreadyProcessed(FileName) && Settings.EnableFileCaching) //get it from the cache
{
var msgs = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(msgs, Utils.GetFileNameAsDataSource(FileName));
return(msgs);
}
if (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
while (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
await Task.Delay(1000);
}
var msgs = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(msgs, Utils.GetFileNameAsDataSource(FileName));
return(msgs);
}
//otherwise read file:
FileProcessingManager.Instance.AddProcessingFile(FileName);
Settings.AddToRecentFiles(fileDataSource.ID, FileName);
var messages = await fileDataSource.Process(filename, token, DataWindow).ConfigureAwait(false);
FileProcessingManager.Instance.DoneProcessingFile(messages.ToList(), FileName);
return(messages);
}
private static IDataWindow[] TranslateToDataWindows(IEnumerable <CurrencyData> data, int windowSize)
{
var enumeratedData = data.ToList();
var sizeOfOutput = enumeratedData.Count() / windowSize;
var output = new IDataWindow[sizeOfOutput];
for (var index = 0; index < sizeOfOutput; index++)
{
var window = new DataWindow();
var inputLayer = enumeratedData
.Skip(windowSize * index)
.Take(windowSize).Select(x => x.Close)
.ToArray();
var outputLayer = enumeratedData
.Skip(windowSize * index)
.Skip(windowSize).Take(1)
.Select(d => d.Close)
.Select(x => x > inputLayer[^ 1] ? 1.0F : 0.0F)
.ToArray();
outputLayer = new[] { outputLayer[0], outputLayer[0] == 0F ? 1F : 0F };
window.InputLayer = inputLayer;
window.OutputLayer = outputLayer;
output[index] = window;
}
return(output);
}
public int removeChannel(ChannelModel oldChannel)
{
int retval = 0;
var res = dtList.Where(x => x.Alias.Equals(oldChannel.name)).FirstOrDefault();
if (res != null)
{
container.Controls.Clear();
dtList.Remove(res);
DataWindow dt = new DataWindow();
int viewInRow = container.Size.Width / dt.Size.Width;
for (int k = 0; k < dtList.Count; k++)
{
var i = dtList[k];
int yPos = (k / viewInRow) * i.Size.Height;
int xPos = (k % viewInRow) * i.Size.Width;
i.Location = new Point(10 + xPos, 15 + yPos);
container.Controls.Add(i);
}
}
else
{
retval = -1;
}
return(retval);
}
/// <summary>
/// Once a SSH_MSG_CHANNEL_OPEN_CONFIRMATION message is received the framework calls
/// this method to complete the channel open operation.
/// </summary>
/// <param name="remoteid">the senders id</param>
/// <param name="remotewindow">the initial window space available for sending data</param>
/// <param name="remotepacket">the maximum packet size available for sending data</param>
protected internal virtual void Open(int remoteid, int remotewindow, int remotepacket)
{
this.remoteid = remoteid;
this.remotewindow = new DataWindow(this, remotewindow, remotepacket);
this.state = CHANNEL_OPEN;
FireEvent(this, ChannelState.OPEN);
}
private void OnShowData(object sender, RoutedEventArgs e)
{
DataWindow w = new DataWindow()
{
Owner = this
};
w.DataTable.ItemsSource = DataManager.GetUserList();
w.ShowDialog();
}
/// <summary>
/// Perform Measurement Button shows DataWindow
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void PerformMeasurement_B_Click(object sender, RoutedEventArgs e)
{
//Hide Main Window
this.Hide();
//Data Window
dataWindow = new DataWindow(this, controller, measurementWindow);
//Shows Data
dataWindow.ShowDialog();
}
public void HideBar(IViewModel vm)
{
DataWindow window = null;
if (_storedManagedWindows.TryGetValue(vm, out window))
{
foreach (var behavior in GetOverlayBehaviors(window))
{
behavior.SetCurrentValue(BehaviorBase <DataWindow> .IsEnabledProperty, false);
_storedManagedWindows.Remove(vm);
}
}
}
/// <summary>
/// Shows raw text from the specified URL in a window box
/// </summary>
/// <param name="Title">Text to display in title</param>
/// <param name="URL">URL to fetch string data from</param>
public static void ShowDataWindow(string Title, string URL)
{
DataWindow frmInfo = new DataWindow {
Text = Title
};
using (var client = MainForm._webClient)
using (var stream = client.OpenRead(URL))
using (var reader = new StreamReader(stream))
frmInfo.labelData.Text = reader.ReadToEnd();
frmInfo.MaximumSize = new Size(frmInfo.MaximumSize.Width, MainForm.Form.Height - 100);
frmInfo.ShowDialog(MainForm.Form);
}
public int addChannel(ChannelModel newChannel)
{
int retvalue = 0;
DataWindow dt = new DataWindow(newChannel.name, newChannel.unit);
int viewInRow = container.Size.Width / dt.Size.Width;
dtList.Add(dt);
int k = dtList.Count - 1;
int yPos = (k / viewInRow) * dt.Size.Height;
int xPos = (k % viewInRow) * dt.Size.Width;
dt.Location = new Point(10 + xPos, 15 + yPos);
container.Controls.Add(dt);
return(retvalue);
}
public StudentModel obtainData()
{
DataWindow window = new DataWindow();
DialogResult result = window.ShowDialog();
if (DialogResult.OK == result)
{
StudentModel model = window.SelectedModel;
if (ConfigResolver.GetInstance().IsShowDetail())
{
MessageBox.Show(model.ToString());
}
return(model);
}
return(null);
}
private async void ShowDerivedData()
{
try
{
var dataObjectLoader = new DataObjectLoader(dataApiClient, clipboard, new DummyCollectionSwitcher());
var dataObjects = await dataObjectLoader.Load(Model.DerivedData, dataObject => { });
var windowTitle = $"Derived data for upload '{Model.Filename ?? Model.Id}'";
var dataWindowViewModel = new DataWindowViewModel(windowTitle, dataObjects);
var dataWindow = new DataWindow
{
ViewModel = dataWindowViewModel
};
dataWindow.ShowDialog();
}
catch (Exception e)
{
StaticMessageBoxSpawner.Show($"Could not show derived data: {e.InnermostException().Message}");
}
}
public int initialize(List <ChannelModel> channelList)
{
dtList.Clear();
container.Controls.Clear();
DataWindow dt = new DataWindow();
for (int k = 0; k < channelList.Count; k++)
{
dtList.Add(new DataWindow(channelList[k].name, channelList[k].unit));
}
int viewInRow = container.Size.Width / dt.Size.Width;
for (int k = 0; k < dtList.Count; k++)
{
var i = dtList[k];
int yPos = (k / viewInRow) * i.Size.Height;
int xPos = (k % viewInRow) * i.Size.Width;
i.Location = new Point(10 + xPos, 15 + yPos);
container.Controls.Add(i);
}
return(1);
}
private IEnumerable <AnimatedOverlayBehavior> GetOverlayBehaviors(DataWindow window)
{
var behaviors = Interaction.GetBehaviors(window);
return(behaviors.OfType <AnimatedOverlayBehavior>());
}
/// <summary>
/// Create an uninitialized channel.
/// </summary>
/// <param name="name">The name of the channel, for example "session"</param>
/// <param name="windowsize">The initial window size</param>
/// <param name="packetsize">The maximum packet size</param>
public SSH2Channel(String name, int windowsize, int packetsize)
{
this.name = name;
this.localwindow = new DataWindow(this, windowsize, packetsize);
this.stream = new SSH2ChannelStream(this, CHANNEL_DATA_MESSAGES);
}
private void OpenDataBrowser()
{
DataWindow.ShowWindow();
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(IAnalogyOfflineDataProvider fileDataProvider,
string filename, CancellationToken token, bool isReload = false)
{
//TODO in case of zip recursive call on all extracted files
FileName = filename;
if (string.IsNullOrEmpty(FileName))
{
return(new List <AnalogyLogMessage>());
}
if (!isReload && !DataWindow.ForceNoFileCaching &&
FileProcessingManager.Instance.AlreadyProcessed(FileName) &&
Settings.EnableFileCaching) //get it from the cache
{
var cachedMessages = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(cachedMessages, Utils.GetFileNameAsDataSource(FileName));
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(cachedMessages);
}
if (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
while (FileProcessingManager.Instance.IsFileCurrentlyBeingProcessed(FileName))
{
await Task.Delay(1000);
}
var cachedMessages = FileProcessingManager.Instance.GetMessages(FileName);
DataWindow.AppendMessages(cachedMessages, Utils.GetFileNameAsDataSource(FileName));
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(cachedMessages);
}
//otherwise read file:
try
{
if (fileDataProvider.CanOpenFile(filename)) //if can open natively: add to processing and process
{
FileProcessingManager.Instance.AddProcessingFile(FileName);
if (!DataWindow.DoNotAddToRecentHistory)
{
Settings.AddToRecentFiles(fileDataProvider.ID, FileName);
}
var messages = (await fileDataProvider.Process(filename, token, DataWindow).ConfigureAwait(false))
.ToList();
FileProcessingManager.Instance.DoneProcessingFile(messages.ToList(), FileName);
if (messages.Any())
{
lastNewestMessage = messages.Select(m => m.Date).Max();
}
OnFileReadingFinished?.Invoke(this, EventArgs.Empty);
if (LogWindow != null)
{
Interlocked.Decrement(ref LogWindow.fileLoadingCount);
}
return(messages);
}
else //cannot open natively. is it compressed file?
{
if (Utils.IsCompressedArchive(filename))
{
var compressedMessages = new List <AnalogyLogMessage>();
string extractedPath = UnzipFilesIntoTempFolder(filename, fileDataProvider);
if (string.IsNullOrEmpty(extractedPath))
{
string msg = $"File is not supported by {fileDataProvider}. File: {filename}";
AnalogyLogger.Instance.LogCritical("Analogy", msg);
AnalogyLogMessage error = new AnalogyErrorMessage(msg, "Analogy");
error.Source = nameof(FileProcessor);
error.Module = "Analogy";
DataWindow.AppendMessage(error, fileDataProvider.GetType().FullName);
return(new List <AnalogyLogMessage> {
error
});
}
CleanupManager.Instance.AddFolder(extractedPath);
var files = Directory.GetFiles(extractedPath);
files.ForEach(async file =>
{
var messages = await Process(fileDataProvider, file, token, isReload);
compressedMessages.AddRange(messages);
});
return(compressedMessages);
}
else
{
string msg = $"File is not supported by {fileDataProvider}. File: {filename}";
AnalogyLogger.Instance.LogCritical("Analogy", msg);
AnalogyLogMessage error = new AnalogyErrorMessage(msg, "Analogy");
error.Source = nameof(FileProcessor);
error.Module = "Analogy";
DataWindow.AppendMessage(error, fileDataProvider.GetType().FullName);
return(new List <AnalogyLogMessage> {
error
});
}
}
}
catch (Exception e)
{
AnalogyLogger.Instance.LogCritical("Analogy", $"Error parsing file: {e}");
var error = new AnalogyErrorMessage($"Error reading file {filename}: Error: {e.Message}", "Analogy");
error.Source = nameof(FileProcessor);
error.Module = "Analogy";
DataWindow.AppendMessage(error, fileDataProvider.GetType().FullName);
return(new List <AnalogyLogMessage> {
error
});
}
}
