private void importTasksFromArchive(Archive archive)
{
List <Entity> tasks = models.Task.all(typeof(models.Task));
List <ArchiveTask> archTasks = archive.Tasks;
foreach (ArchiveTask archTask in archTasks)
{
var task = tasks.FirstOrDefault(x => archTask.equalsEntity(x));
if (task != null)
{
List <TaskTemplate> templates = TaskTemplate.templatesOfTaskId(task.ID);
List <ArchiveTemplate> archTemps = archTask.Templates;
foreach (ArchiveTemplate archTemp in archTemps)
{
var template = templates.FirstOrDefault(x => archTemp.equalsEntity(x));
if (template != null)
{
List <Selection> selections = Selection.selectionsOfTaskTemplateId(template.ID);
List <ArchiveSelection> archSels = archTemp.Selections;
foreach (ArchiveSelection archSel in archSels)
{
var selection = selections.FirstOrDefault(x => archSel.equalsEntity(x));
if (selection == null)
{
importSelection(archSel, template.ID);
}
else
{
archSel.ID = selection.ID;
}
}
}
else
{
importTemplate(archTemp, task.ID);
}
}
List <TaskSolver> solvers = TaskSolver.solversOfTaskId(task.ID);
List <ArchiveTaskSolver> archSolvs = archTask.Solvers;
foreach (ArchiveTaskSolver archSolver in archSolvs)
{
var solver = solvers.FirstOrDefault(x => archSolver.equalsEntity(x));
if (solver == null)
{
importTaskSolver(archSolver, task.ID);
}
else
{
archSolver.ID = solver.ID;
}
}
}
else
{
importTask(archTask);
}
}
}
public void UpdateTaskTree()
{
for (int i = Tasks.Count - 1; i >= 0; i--)
{
Tasks.RemoveAt(i);
}
List <Entity> tasks = models.Task.all(typeof(models.Task));
foreach (models.Task task in tasks)
{
List <TaskSolver> solvers = TaskSolver.solversOfTaskId(task.ID);
List <Selection> selections = Selection.selectionsOfDefaultTemplateWithTaskId(task.ID);
var pers = new List <TaskSolver>();
var wards = new List <TaskSolver>();
var convnets = new List <TaskSolver>();
var dectrees = new List <TaskSolver>();
var kohnets = new List <TaskSolver>();
foreach (TaskSolver solver in solvers)
{
if (solver.TypeName.Equals("Perceptron"))
{
pers.Add(solver);
}
else if (solver.TypeName.Equals("WardNN"))
{
wards.Add(solver);
}
else if (solver.TypeName.Equals("ConvNN"))
{
convnets.Add(solver);
}
else if (solver.TypeName.Equals("DecisionTree"))
{
dectrees.Add(solver);
}
else if (solver.TypeName.Equals("KohonenNet"))
{
kohnets.Add(solver);
}
}
Tasks.Add(new TaskTree
(task,
selections.ToArray(),
pers.ToArray(),
dectrees.ToArray(),
wards.ToArray(),
convnets.ToArray(),
kohnets.ToArray(),
new string[] { },
this));
}
}
public Archive generateArchiveSystem()
{
scenarioRelations.Clear();
selectionRelations.Clear();
taskSolverRelations.Clear();
Archive archive = new Archive();
List <Entity> tasks = models.Task.all(typeof(models.Task));
foreach (models.Task task in tasks)
{
ArchiveTask archTask = new ArchiveTask(task);
List <TaskTemplate> templates = TaskTemplate.templatesOfTaskId(task.ID);
foreach (TaskTemplate template in templates)
{
ArchiveTemplate archTemp = new ArchiveTemplate(template);
List <Selection> selections = Selection.selectionsOfTaskTemplateId(template.ID);
foreach (Selection sel in selections)
{
ArchiveSelection archSel = new ArchiveSelection(sel);
selectionRelations.Add(new RelationExport(sel.ID, archSel));
archTemp.Selections.Add(archSel);
}
List <Parameter> parameters = Parameter.parametersOfTaskTemplateId(template.ID);
foreach (Parameter par in parameters)
{
ArchiveParameter archPar = new ArchiveParameter(par);
archTemp.Parameters.Add(archPar);
}
archTask.Templates.Add(archTemp);
}
List <TaskSolver> solvers = TaskSolver.solversOfTaskId(task.ID);
foreach (TaskSolver solver in solvers)
{
ArchiveTaskSolver archSol = new ArchiveTaskSolver(solver);
taskSolverRelations.Add(new RelationExport(solver.ID, archSol));
archTask.Solvers.Add(archSol);
}
archive.Tasks.Add(archTask);
}
List <Entity> scenarios = LearningScenario.all(typeof(LearningScenario));
foreach (LearningScenario scenario in scenarios)
{
ArchiveScenario archScenario = new ArchiveScenario(scenario);
scenarioRelations.Add(new RelationExport(scenario.ID, archScenario));
archive.Scenarios.Add(archScenario);
}
List <Entity> lSolvers = LearnedSolver.all(typeof(LearnedSolver));
foreach (LearnedSolver solver in lSolvers)
{
ArchiveLearnedSolver archSol = new ArchiveLearnedSolver(solver);
List <LearningQuality> quailties = LearningQuality.qualitiesOfSolverId(solver.ID);
foreach (LearningQuality quality in quailties)
{
ArchiveLearningQuality archQ = new ArchiveLearningQuality(quality);
archSol.Qualities.Add(archQ);
}
var find = taskSolverRelations.Find(x => x.ID == solver.TaskSolverID);
archSol.TaskSolver = (find != null) ? (ArchiveTaskSolver)find.model : null;
find = selectionRelations.Find(x => x.ID == solver.SelectionID);
archSol.Selection = (find != null) ? (ArchiveSelection)find.model : null;
find = scenarioRelations.Find(x => x.ID == solver.LearningScenarioID);
archSol.Scenario = (find != null) ? (ArchiveScenario)find.model : null;
archive.LearnedSolvers.Add(archSol);
}
return(archive);
}
