async Task KillDataAsync()
{
if (!Confirm())
{
return;
}
try
{
using (var db = new ResultDB())
{
Application.Current.Dispatcher.Invoke(() => Status = "Loading...");
await db.TestStopwatches.TruncateAsync();
await db.TestMethods.TruncateAsync();
await db.TestRuns.TruncateAsync();
}
await RefreshDataAsync();
}
catch (Exception ex)
{
Application.Current.Dispatcher.Invoke(() =>
MessageBox.Show(ex.Message, "Exception", MessageBoxButton.OK, MessageBoxImage.Error));
}
Application.Current.Dispatcher.Invoke(() => Status = "");
}
public void ResetResultDB()
{
ResultDB resultDB = new ResultDB();
resultDB.RunSQLScript("reset");
Console.WriteLine("Resetted Result Database");
}
private void PrintMessage()
{
if (ResultDB == null)
{
return;
}
if (!SelectedNotEmpty())
{
messageTextBlock.Text = "";
}
if (!QuerySubmitted)
{
if (ResultDB.IsEmpty() && SelectedNotEmpty())
{
messageTextBlock.Text = "No results containing all your search terms were found.";
}
}
else
{
if (ResultDB.Count == 1)
{
messageTextBlock.Text = "One row was found.";
}
else
{
messageTextBlock.Text = $"{ResultDB.Count} rows were found.";
}
}
}
/// <summary>
/// Metodo para ejecutar un procedimiento almacenado en la bd
/// </summary>
/// <param name="parameter">Lista de parametros que se le va a asociar</param>
/// <param name="query">Cadena con el query a ejecutar</param>
public List <ResultDB> ExecuteStoredProcedure(string query, List <ParameterDB> parameters)
{
try
{
Connect();
List <ResultDB> results = new List <ResultDB>();
using (connection)
{
command = new SqlCommand(query, connection);
command.CommandType = CommandType.StoredProcedure;
AssignParameters(parameters);
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
command.ExecuteNonQuery();
if (command.Parameters != null)
{
foreach (SqlParameter parameter in command.Parameters)
{
if (parameter.Direction.Equals(ParameterDirection.Output))
{
ResultDB result = new ResultDB(parameter.ParameterName, parameter.Value.ToString());
results.Add(result);
}
}
if (results != null)
{
return(results);
}
}
return(null);
}
}
catch (SqlException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
finally
{
Disconnect();
}
}
public void ProcessBatchFromSourceDBToResultDB(int amount)
{
int leftToDo = amount;
int batch = 50;
SourceDB sourceDB = new SourceDB();
int imageFilesInSourceDB = sourceDB.GetImageFilesCount();
ResultDB resultDB = new ResultDB();
int imageFilesInResultDB = resultDB.GetImageFilesCount();
int diffResultDBandSourceDB = imageFilesInSourceDB - imageFilesInResultDB;
if (diffResultDBandSourceDB == 0)
{
Console.WriteLine("No new images in sourceDB to process");
return;
}
while (leftToDo > 0)
{
if (leftToDo <= batch)
{
batch = leftToDo;
}
if (leftToDo > diffResultDBandSourceDB)
{
batch = diffResultDBandSourceDB;
}
if (batch == 0)
{
break;
}
CopyJpgFiles(ETLcontroller.sourceDBDataFolder, ETLcontroller.stageDBDataUnporssedFolder, batch);
InsertDataIntoStageDBFromUnprocessed();
ExtractMetadataIntoStageDB();
ImageRegonitionPrediction();
SortFilesInStageDBData();
MoveFilesFromStageDBDataToResultDBData();
LoadDataFromStageDBtoResultDB();
ResetStageDB();
leftToDo -= 50;
}
}
async Task DeleteDataAsync()
{
if (!Confirm())
{
return;
}
App.Root.ViewModel.Status = "Deleting...";
try
{
using (var db = new ResultDB())
{
var runs =
from r in db.TestRuns
where r.Platform == Platform && r.Name == Name
select r;
var methods =
from m in db.TestMethods
join r in runs on m.TestRunID equals r.ID
select m;
var watches =
from w in db.TestStopwatches
join m in methods on w.TestMethodID equals m.ID
select w;
await watches.DeleteAsync();
await methods.DeleteAsync();
await runs.DeleteAsync();
}
await App.Root.ViewModel.RefreshDataAsync();
}
catch (Exception ex)
{
Application.Current.Dispatcher.Invoke(() =>
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK));
}
App.Root.ViewModel.Status = "";
}
private bool SatisfyFields()
{
if (SelectedNotEmpty())
{
Customer userInput;
if (companyNameBox.IsEnabled)
{
userInput = new Customer("", companyNameBox.Text, contactNameBox.Text, phoneNumberBox.Text);
}
else
{
userInput = new Customer(customerIdBox.Text, "", "", "");
}
ResultDB = _db.Select(userInput);
return(!ResultDB.IsEmpty());
}
return(false);
}
async Task DeleteBestWorstDataAsync()
{
if (!Confirm())
{
return;
}
App.Root.ViewModel.Status = "Deleting...";
var dataToDelete =
(
from m in Methods
from t in m.Times
from d in t.GetBestWorst()
select new { ID = d }
)
.ToList();
try
{
using (var db = new ResultDB())
// Need CreateTempTableAsync
using (var tmp = db.CreateTempTable("#tmp", dataToDelete))
{
var q =
from w in db.TestStopwatches
join t in tmp on w.ID equals t.ID
select w;
await q.DeleteAsync();
}
await App.Root.ViewModel.RefreshDataAsync();
}
catch (Exception ex)
{
Application.Current.Dispatcher.Invoke(() =>
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK));
}
App.Root.ViewModel.Status = "";
}
public void LoadDataFromStageDBtoResultDB()
{
List <ImageFile> imageFiles = new List <ImageFile>();
List <ImageInfo> imageInfos = new List <ImageInfo>();
StageDB stageDB = new StageDB();
ResultDB resultDB = new ResultDB();
imageFiles = stageDB.GetAllImageFiles();
imageInfos = stageDB.GetAllImageInfos();
foreach (ImageFile imageFile in imageFiles)
{
imageFile.FilePath.Replace("StageDBData", "ResultDBData");
resultDB.InsertImageFile(imageFile);
}
foreach (ImageInfo imageInfo in imageInfos)
{
resultDB.InsertImageInfo(imageInfo);
}
}
/// <summary>
/// Computes the influence of all configuration options and interactions based on the measurements of the given result db. It uses linear programming (simplex) and is an exact algorithm.
/// </summary>
/// <param name="nfp">The non-functional property for which the influences of configuration options are to be computed. If null, we use the property of the global model.</param>
/// <param name="infModel">The influence model containing the variability model, all configuration options and interactions.</param>
/// <param name="db">The result database containing the measurements.</param>
/// <param name="evaluateFeatureInteractionsOnly">Only interactions are learned.</param>
/// <param name="withDeviation">(Not used) We can specify whether learned influences must be greater than a certain value (e.g., greater than measurement bias).</param>
/// <param name="deviation">(Not used) We can specify whether learned influences must be greater than a certain value (e.g., greater than measurement bias).</param>
/// <returns>Returns the learned influences of each option in a map whereas the String (Key) is the name of the option / interaction.</returns>
public Dictionary <String, double> computeOptionInfluences(NFProperty nfp, InfluenceModel infModel, ResultDB db, bool evaluateFeatureInteractionsOnly, bool withDeviation, double deviation)
{
//Initialization
List <List <BinaryOption> > configurations = new List <List <BinaryOption> >();
this.evaluateInteractionsOnly = evaluateFeatureInteractionsOnly;
this.withStandardDeviation = withDeviation;
this.standardDeviation = deviation;
List <double> results = new List <double>();
foreach (Configuration c in db.Configurations)
{
configurations.Add(c.getBinaryOptions(BinaryOption.BinaryValue.Selected));
if (nfp != null)
{
results.Add(c.GetNFPValue(nfp));
}
else
{
results.Add(c.GetNFPValue());
}
}
List <BinaryOption> variables = new List <BinaryOption>();
Dictionary <String, double> featureValues = new Dictionary <string, double>();
Dictionary <String, double> faultRates = new Dictionary <string, double>();
List <int> indexOfErrorMeasurements = new List <int>();
if (configurations.Count == 0)
{
return(null);
}
//For the case there is an empty base
if (configurations.Count != 0)
{
if (configurations[0].Count == 0)
{//Should never occur that we get a configuration with no option selected... at least the root must be there
BinaryOption root = infModel.Vm.Root;
//Element baseElement = new Element("base_gen", infModel.getID(), infModel);
//variables.Add(baseElement);
// featureValues.Add(baseElement.getName(), 0);
foreach (List <BinaryOption> config in configurations)
{
if (!config.Contains(root))
{
config.Insert(0, root);
}
}
}
}
//Building the variable list
foreach (var elem in infModel.Vm.BinaryOptions)
{
variables.Add(elem);
featureValues.Add(elem.Name, 0);
}
featureValues = solve(variables, results, configurations, null);
return(featureValues);
}
/// <summary>
/// Computes the influence of all configuration options based on the measurements of the given result db. It uses linear programming (simplex) and is an exact algorithm.
/// </summary>
/// <param name="nfp">The non-functional property for which the influences of configuration options are to be computed. If null, we use the property of the global model.</param>
/// <param name="infModel">The influence model containing options and interactions. The state of the model will be changed by the result of the process</param>
/// <param name="db">The result database containing the measurements.</param>
/// <returns>A map of binary options to their computed influences.</returns>
public Dictionary <BinaryOption, double> computeOptionInfluences(NFProperty nfp, InfluenceModel infModel, ResultDB db)
{
List <BinaryOption> variables = infModel.Vm.BinaryOptions;
List <double> results = new List <double>();
List <List <BinaryOption> > configurations = new List <List <BinaryOption> >();
foreach (Configuration c in db.Configurations)
{
configurations.Add(c.getBinaryOptions(BinaryOption.BinaryValue.Selected));
if (nfp != null)
{
results.Add(c.GetNFPValue(nfp));
}
else
{
results.Add(c.GetNFPValue());
}
}
List <String> errorEqs = new List <string>();
Dictionary <String, double> faultRates = new Dictionary <string, double>();
List <int> indexOfErrorMeasurements = new List <int>();
Dictionary <String, double> featureValuedAsStrings = solve(variables, results, configurations, infModel.InteractionInfluence.Keys.ToList());
foreach (String current in featureValuedAsStrings.Keys)
{
BinaryOption temp = infModel.Vm.getBinaryOption(current);
this.featureValues[temp] = featureValuedAsStrings[current];
InfluenceFunction influence = new InfluenceFunction(temp.Name + " + " + featureValuedAsStrings[current].ToString(), infModel.Vm);
if (infModel.BinaryOptionsInfluence.Keys.Contains(temp))
{
infModel.BinaryOptionsInfluence[temp] = influence;
}
else
{
infModel.BinaryOptionsInfluence.Add(temp, influence);
}
}
return(this.featureValues);
}
/// <summary>
/// Computes the influence of all configuration options and interactions based on the measurements of the given result db. It uses linear programming (simplex) and is an exact algorithm.
/// </summary>
/// <param name="nfp">The non-funcitonal property for which the influences of configuration options are to be computed. If null, we use the property of the global model.</param>
/// <param name="infModel">The influence model containing the variability model, all configuration options and interactions.</param>
/// <param name="db">The result database containing the measurements.</param>
/// <param name="evaluateFeatureInteractionsOnly">Only interactions are learned.</param>
/// <param name="withDeviation">(Not used) We can specifiy whether learned influences must be greater than a certain value (e.g., greater than measurement bias).</param>
/// <param name="deviation">(Not used) We can specifiy whether learned influences must be greater than a certain value (e.g., greater than measurement bias).</param>
/// <returns>Returns the learned infleunces of each option in a map whereas the String (Key) is the name of the option / interaction.</returns>
public Dictionary <String, double> computeOptionInfluences(NFProperty nfp, InfluenceModel infModel, ResultDB db, bool evaluateFeatureInteractionsOnly, bool withDeviation, double deviation)
{
//Initialization
List <List <BinaryOption> > configurations = new List <List <BinaryOption> >();
this.evaluateInteractionsOnly = evaluateFeatureInteractionsOnly;
this.withStandardDeviation = withDeviation;
this.standardDeviation = deviation;
List <double> results = new List <double>();
foreach (Configuration c in db.Configurations)
{
configurations.Add(c.getBinaryOptions(BinaryOption.BinaryValue.Selected));
if (nfp != null)
{
results.Add(c.GetNFPValue(nfp));
}
else
{
results.Add(c.GetNFPValue());
}
}
List <BinaryOption> variables = new List <BinaryOption>();
Dictionary <String, double> featureValues = new Dictionary <string, double>();
Dictionary <String, double> faultRates = new Dictionary <string, double>();
List <int> indexOfErrorMeasurements = new List <int>();
if (configurations.Count == 0)
{
return(null);
}
//For the case there is an empty base
if (configurations.Count != 0)
{
if (configurations[0].Count == 0)
{//Should never occur that we get a configuration with no option selected... at least the root must be there
BinaryOption root = infModel.Vm.Root;
//Element baseElement = new Element("base_gen", infModel.getID(), infModel);
//variables.Add(baseElement);
// featureValues.Add(baseElement.getName(), 0);
foreach (List <BinaryOption> config in configurations)
{
if (!config.Contains(root))
{
config.Insert(0, root);
}
}
}
}
//Building the variable list
foreach (var elem in infModel.Vm.BinaryOptions)
{
variables.Add(elem);
featureValues.Add(elem.Name, 0);
}
//First run
featureValues = solve(variables, results, configurations, null);
//if (evaluateFeatureInteractionsOnly == false)
return(featureValues);
/*
* //We might have some interactions here and cannot compute all values
* //1. identify options that are only present in these equations
* Dictionary<Element, int> featureCounter = new Dictionary<Element, int>();
* for (int i = 0; i < indexOfErrorMeasurements.Count; i++)
* {
*
* }
*
*/
/*Todo: get compute interactins from deviations / errors of the LP results
* if (errorEqs != null)
* {
* foreach (string eq in errorEqs)
* {
* double value = Double.Parse(eq.Substring(eq.IndexOf("==") + 2));
*
* StringBuilder sb = new StringBuilder();
* List<Element> derivativeParents = new List<Element>();
* sb.Append("derivate_");
* string[] splittedEQ = eq.Split('+');
* foreach (string element in splittedEQ)
* {
* string name = element;
* if (name.Contains("=="))
* name = name.Substring(0, name.IndexOf("=="));
* if (name.Contains("yp") && name.Contains("-yn"))
* continue;
* // string featureName = name.Substring(0, name.IndexOf("_p-"));
* Element elem = infModel.getElementByNameUnsafe(name);
* if (elem == null)
* continue;
* sb.Append("_" + name);
* derivativeParents.Add(elem);
* }
* Element interaction = new Element(sb.ToString(), infModel.getID(), infModel);
* interaction.setType("derivative");
* interaction.addDerivativeParents(derivativeParents);
* infModel.addElement(interaction);
* this.featureValues.Add(interaction, value);
* }
* }
* return featureValues;*/
}
/// <summary>
/// This method searches for a corresponding methods in the dynamically loadeda assemblies and calls it if found. It prefers due to performance reasons the Microsoft Solver Foundation implementation.
/// </summary>
/// <param name="nfp">The non-funcitonal property for which the influences of configuration options are to be computed. If null, we use the property of the global model.</param>
/// <param name="infModel">The influence model containing options and interactions. The state of the model will be changed by the result of the process</param>
/// <param name="db">The result database containing the measurements.</param>
/// <returns>A map of binary options to their computed influences.</returns>
public Dictionary <BinaryOption, double> computeOptionInfluences(NFProperty nfp, InfluenceModel infModel, ResultDB db)
{
foreach (Lazy <ISolverLP, ISolverType> solver in solvers)
{
if (solver.Metadata.SolverType.Equals("MSSolverFoundation"))
{
return(solver.Value.computeOptionInfluences(nfp, infModel, db));
}
}
//If not MS Solver, take any solver. Should be changed when supporting more than 2 solvers here
foreach (Lazy <ISolverLP, ISolverType> solver in solvers)
{
return(solver.Value.computeOptionInfluences(nfp, infModel, db));
}
return(null);
}
/// <summary>
/// This method searches for a corresponding methods in the dynamically loadeda assemblies and calls it if found. It prefers due to performance reasons the Microsoft Solver Foundation implementation.
/// </summary>
/// <param name="nfp">The non-funcitonal property for which the influences of configuration options are to be computed. If null, we use the property of the global model.</param>
/// <param name="infModel">The influence model containing the variability model, all configuration options and interactions.</param>
/// <param name="db">The result database containing the measurements.</param>
/// <param name="evaluateFeatureInteractionsOnly">Only interactions are learned.</param>
/// <param name="withDeviation">(Not used) We can specifiy whether learned influences must be greater than a certain value (e.g., greater than measurement bias).</param>
/// <param name="deviation">(Not used) We can specifiy whether learned influences must be greater than a certain value (e.g., greater than measurement bias).</param>
/// <returns>Returns the learned infleunces of each option in a map whereas the String (Key) is the name of the option / interaction.</returns>
public Dictionary <string, double> computeOptionInfluences(NFProperty nfp, InfluenceModel infModel, ResultDB db, bool evaluateFeatureInteractionsOnly, bool withDeviation, double deviation)
{
foreach (Lazy <ISolverLP, ISolverType> solver in solvers)
{
if (solver.Metadata.SolverType.Equals("MSSolverFoundation"))
{
return(solver.Value.computeOptionInfluences(nfp, infModel, db, evaluateFeatureInteractionsOnly, withDeviation, deviation));
}
}
//If not MS Solver, take any solver. Should be changed when supporting more than 2 solvers here
foreach (Lazy <ISolverLP, ISolverType> solver in solvers)
{
return(solver.Value.computeOptionInfluences(nfp, infModel, db, evaluateFeatureInteractionsOnly, withDeviation, deviation));
}
return(null);
}
public async Task RefreshDataAsync()
{
try
{
using (var db = new ResultDB())
{
Status = "Loading...";
var runs = await db.TestRuns.ToListAsync();
var methods = await db.TestMethods.ToListAsync();
var watches = await db.TestStopwatches.ToListAsync();
var ws =
(
from w in watches
group w by w.TestMethodID into g
select new { g.Key, Items = g.ToList() }
)
.ToDictionary(t => t.Key, t => t.Items);
var ms =
(
from m in methods
group m by m.TestRunID into g
select new
{
g.Key,
Items = g.Select(mt => new
{
Method = mt,
Watches = ws.ContainsKey(mt.ID) ? ws[mt.ID] : new List <TestStopwatch>()
}).ToList()
}
)
.ToDictionary(t => t.Key, t => t.Items);
var rs =
(
from r in runs
group r by new { r.Platform, r.Name } into g
//orderby g.Key.Platform, g.Key.Name
select new { g.Key, Items = g.Select(rt => new { Run = rt, Methods = ms[rt.ID] }).ToList() }
)
.ToDictionary(t => t.Key, t => t.Items);
var providers = ws.Values.SelectMany(w => w).Select(w => w.Provider).Distinct().OrderBy(p => p);
SolidColorBrush GetBrush(Color color, int delta)
{
return(new SolidColorBrush(Color.FromRgb(
(byte)Math.Min(Math.Max(color.R + delta, 0), 255),
(byte)Math.Min(Math.Max(color.G + delta, 0), 255),
(byte)Math.Min(Math.Max(color.B + delta, 0), 255))));
}
Application.Current.Dispatcher.Invoke(() =>
{
ProviderBrushes = new Dictionary <string, Brush>
{
["AdoNet"] = new SolidColorBrush(Color.FromRgb(0xAA, 0x40, 0xFF)),
["Dapper"] = new SolidColorBrush(Color.FromRgb(0x63, 0x2F, 0x00)),
["PetaPoco"] = new SolidColorBrush(Color.FromRgb(0xFF, 0x76, 0xBC)),
["L2DB Sql"] = GetBrush(Color.FromRgb(0x19, 0x99, 0x00), 0x1A),
["L2DB Compiled"] = GetBrush(Color.FromRgb(0x19, 0x99, 0x00), 0x00),
["L2DB Linq"] = GetBrush(Color.FromRgb(0x19, 0x99, 0x00), -0x1A),
["EF Core Sql"] = GetBrush(Color.FromRgb(0xFF, 0x98, 0x1D), 0x1A),
["EF Core Compiled"] = GetBrush(Color.FromRgb(0xFF, 0x98, 0x1D), 0x00),
["EF Core Linq"] = GetBrush(Color.FromRgb(0xFF, 0x98, 0x1D), -0x1A),
["L2S Sql"] = GetBrush(Color.FromRgb(0x1F, 0xAE, 0xFF), 0x1A),
["L2S Compiled"] = GetBrush(Color.FromRgb(0x1F, 0xAE, 0xFF), 0x00),
["L2S Linq"] = GetBrush(Color.FromRgb(0x1F, 0xAE, 0xFF), -0x1A),
["EF6 Sql"] = GetBrush(Color.FromRgb(0xC1, 0x00, 0x4F), 0x1A),
["EF6 Compiled"] = GetBrush(Color.FromRgb(0xC1, 0x00, 0x4F), 0x00),
["EF6 Linq"] = GetBrush(Color.FromRgb(0xC1, 0x00, 0x4F), -0x1A),
["BLToolkit Sql"] = GetBrush(Color.FromRgb(0x7F, 0x6E, 0x94), 0x1A),
["BLToolkit Compiled"] = GetBrush(Color.FromRgb(0x7F, 0x6E, 0x94), 0x00),
["BLToolkit Linq"] = GetBrush(Color.FromRgb(0x7F, 0x6E, 0x94), -0x1A),
};
var colors = new[]
{
Color.FromRgb(0xFF, 0x2E, 0x12),
Color.FromRgb(0x25, 0x72, 0xEB),
Color.FromRgb(0x46, 0x17, 0xB4),
Color.FromRgb(0x72, 0x00, 0xAC),
Color.FromRgb(0xFE, 0x7C, 0x22),
Color.FromRgb(0xFF, 0x1D, 0x77),
Color.FromRgb(0x4F, 0x1D, 0x77),
Color.FromRgb(0x91, 0xD1, 0x00),
Color.FromRgb(0x77, 0xB9, 0x00),
Color.FromRgb(0x00, 0xC1, 0x3F),
Color.FromRgb(0xE1, 0xB7, 0x00),
Color.FromRgb(0xE1, 0xB7, 0xA0),
Color.FromRgb(0xF3, 0xB2, 0x00),
Color.FromRgb(0xFF, 0x98, 0x1D),
Color.FromRgb(0x56, 0xC5, 0xFF),
Color.FromRgb(0x56, 0x05, 0xFF),
Color.FromRgb(0x00, 0xD8, 0xCC),
Color.FromRgb(0x00, 0x82, 0x87),
Color.FromRgb(0x00, 0xA3, 0xA3),
Color.FromRgb(0x00, 0x6A, 0xC1),
Color.FromRgb(0x00, 0xA3, 0xA3),
Color.FromRgb(0x90, 0xA3, 0xA3),
};
var count = ProviderBrushes.Count;
foreach (var item in providers)
{
if (!ProviderBrushes.ContainsKey(item))
{
ProviderBrushes[item] = new SolidColorBrush(colors[ProviderBrushes.Count - count]);
}
}
});
foreach (var platform in Platforms)
{
foreach (var test in platform.Tests)
{
test.Test = null;
}
}
var tests = rs
.Select(r => new TestViewModel
{
Platform = r.Key.Platform,
Name = r.Key.Name,
Methods = new ObservableCollection <MethodViewModel>(
from rt in r.Value
from m in rt.Methods
group new { rt, m } by new { m.Method.Name, m.Method.Repeat, m.Method.Take } into gr
select new MethodViewModel(
from t in gr
from w in t.m.Watches
group new { t, w } by w.Provider into g
select new TimeViewModel(g.Select(tw => tw.w))
{
Name = g.Key,
})
{
Name = gr.Key.Name,
Repeat = gr.Key.Repeat,
Take = gr.Key.Take,
})
})
.ToList();
for (var i = 0; i < tests.Count; i++)
{
var test = tests[i];
var idx = Tests
.Select((t, n) => new { t, n })
.Where(t => t.t.Platform == test.Platform && t.t.Name == test.Name)
.Select(t => (int?)t.n)
.FirstOrDefault();
var platform = Platforms.FirstOrDefault(p => p.Name == test.Platform);
if (platform == null)
{
Application.Current.Dispatcher.Invoke(() => Platforms.Add(platform = new PlatformViewModel {
Name = test.Platform
}));
}
var platformTest = platform.Tests.FirstOrDefault(t => t.Name == test.Name);
if (platformTest == null)
{
platformTest = new PlatformTestViewModel {
Name = test.Name
};
Application.Current.Dispatcher.Invoke(() => platform.Tests.Add(platformTest));
}
if (idx == null)
{
platformTest.Test = test;
Application.Current.Dispatcher.Invoke(() => Tests.Insert(i, test));
}
else
{
if (i != idx)
{
Application.Current.Dispatcher.Invoke(() => Tests.Move(idx.Value, i));
}
platformTest.Test = Tests[i];
Tests[i].Merge(test);
}
}
foreach (var platform in Platforms.ToList())
{
foreach (var test in platform.Tests.ToList())
{
if (test.Test == null)
{
Application.Current.Dispatcher.Invoke(() => platform.Tests.Remove(test));
}
}
if (platform.Tests.Count == 0)
{
Application.Current.Dispatcher.Invoke(() => Platforms.Remove(platform));
}
}
while (Tests.Count > tests.Count)
{
Application.Current.Dispatcher.Invoke(() => Tests.RemoveAt(Tests.Count - 1));
}
}
}
catch (Exception ex)
{
Application.Current.Dispatcher.Invoke(() =>
MessageBox.Show(ex.Message, "Exception", MessageBoxButton.OK, MessageBoxImage.Error));
}
Status = "";
}
