private void PopulateData(ISession s)
{
for (var i = 0; i < 2; i++)
{
var p = new HierarchyModel
{
Hid = string.Format("/{0}/", i + 1),
Name = string.Format("Parent {0}", i + 1)
};
s.Save(p);
var childs = new List <string>();
for (var j = 0; j < 10; j++)
{
var c = new HierarchyModel
{
Hid = string.Format("/{0}/{1}/", i + 1, j + 1),
Name = string.Format("Child {0}/{1}", i + 1, j + 1)
};
childs.Add(c.Hid);
s.Save(c);
}
Items.Add(p.Hid, childs);
}
}
public void UIFor(HierarchyModel model, Transform parent)
{
if (model == null)
{
return;
}
if (model.uiObject != null)
{
model.uiObject.transform.parent = parent;
}
else
{
GameObject hierarchyUIElement = pool.GetItem();
hierarchyUIElement.transform.SetParent(parent);
activeItems.Add(hierarchyUIElement);
GUIHierarchyItem guihi = hierarchyUIElement.GetComponent <GUIHierarchyItem>();
guihi.data = model.data;
foreach (var child in model.GetChildren())
{
UIFor(child, guihi.childTransfrom);
}
}
}
protected HierarchyModel ParseHierarchicalFile(string fileName)
{
string methodName = new StackTrace().GetFrame(1).GetMethod().Name.Replace("_", "-");
FileInfo file = new FileInfo(fileName);
Assert.That(file.Exists, Is.True, "File doesn't exist {0}", fileName);
FileReader reader = new FileReader(fileName);
List <IModelParser> list = new List <IModelParser> {
modelParser
};
IDataParser dataParser = new DataParser(reader, list.ToArray());
dataParser.OnMissingParser = s =>
{
Assert.Fail("Unable to Parse: {0}", reader);
return(false);
};
dataParser.Parse();
Assert.That(dataParser.Results, Is.Not.Empty, "Results should not be empty");
Assert.That(dataParser.Results[0], Is.TypeOf <HierarchyModel>(), "Expected a Cobol Model");
HierarchyModel hierarchyModel = dataParser.Results[0] as HierarchyModel;
Assert.That(hierarchyModel, Is.Not.Null, "Class Model not found: {0}", dataParser.Results[0]);
if (hierarchyModel != null)
{
StringModel model = (StringModel)hierarchyModel.Model;
Assert.That(file.Name, Is.StringContaining(model.Data), "Class name doesn't match the filename");
Assert.That(model.Data, Is.EqualTo(methodName), "Class name doesn't match the method name");
}
return(hierarchyModel);
}
public IModel Parse(IReader reader)
{
IModel currentModel = modelParser.Parse(reader);
IModel childModel = childrenParser.Parse(reader);
List <IModel> children = new List <IModel>();
while (childModel != null)
{
children.Add(childModel);
childModel = childrenParser.Parse(reader);
}
HierarchyModel currentHierarchy = currentModel as HierarchyModel;
if (currentHierarchy != null && children.Count > 0)
{
if (currentHierarchy.ChildModels.Length == 1)
{
return(new HierarchyModel(currentHierarchy.Model, new IModel[]
{
new HierarchyModel(currentHierarchy.ChildModels[0], children.ToArray())
}));
}
}
return(children.Count == 0 ? currentModel : new HierarchyModel(currentModel, children.ToArray()));
}
public async Task <ActionResult> Edit(HierarchyModel model)
{
try
{
if (ModelState.IsValid)
{
var entiry = Mapper.Map <HierarchyModel, Hierarchy>(model);
_hierarchyService.UpdateDetalhe(entiry.HierarchyDetalhe, CurrentUser.UserId);
_hierarchyService.Update(entiry, CurrentUser.UserId, referenceCircular: true);
ShowMessageDialog(MensagensResource.SucessoAtualizar, Message.MessageKind.Success);
}
else
{
model.HierarchyTypeDictionary = await _dictionaryAllService.GetHierarchyTypeDictionaryAsync();
return(View(model));
}
}
catch (Exception e)
{
ShowMessageDialog(MensagensResource.ErroAtualizar, e);
}
return(RedirectToAction("Index"));
}
public IModel Parse(IModel model)
{
IModel parsed = parentParser.Parse(model);
HierarchyModel hParsed = parsed as HierarchyModel;
if (hParsed != null)
{
IModel childModel = hParsed.ChildModels.Length > 0 ? hParsed.ChildModels[0] : null;
if (childModel != null)
{
IModel child = childParser.Parse(childModel);
return(new HierarchyModel(hParsed.Model, new[] { child }));
}
}
return(model);
}
public void SingleDataParser()
{
IImpliedModelParser modelParser = new DataParser();
IModel model = new CobolModel("Parent", "NAME SHOULD SEPARATE TEST DATA 1", "This is test data");
Assert.That(modelParser.Matches(model), Is.True);
IModel child = modelParser.Parse(model);
Assert.That(child, Is.Not.Null);
Assert.That(child, Is.Not.SameAs(model));
IModel expected = new HierarchyModel(new CobolModel("Parent", "NAME SHOULD SEPARATE TEST", "This is test data"), new IModel[]
{
new CobolModel("Data", "1", "Implied")
});
AssertModelIsSame(child, expected, true);
}
public virtual List <HierarchyModel> GetRoot()
{
List <HierarchyModel> root = new List <HierarchyModel>();
HierarchyModel mroot = new HierarchyModel(new HierarchyData {
name = "Root"
});
mroot.AddChild(new HierarchyModel(new HierarchyData {
name = "Node 1"
}));
mroot.AddChild(new HierarchyModel(new HierarchyData {
name = "Node 2"
}));
root.Add(mroot);
return(root);
}
private List <HierarchyModel> CreateHierarchy(string rootId, List <Hierarchy> data)
{
List <HierarchyModel> result = new List <HierarchyModel>();
var element = data.Where(p => p.RowGuid.Equals(rootId)).FirstOrDefault();
var elements = data.Where(d => d.IdentPuesto.Equals(rootId)).ToList();
HierarchyModel m = new HierarchyModel()
{
Area = element.Area
};
elements.ForEach(g =>
{
var t = CreateHierarchy(g.RowGuid, data);
m.SubArea.AddRange(t);
});
result.Add(m);
return(result);
}
public async Task <ActionResult> Create(HierarchyModel model)
{
try
{
if (ModelState.IsValid)
{
_hierarchyService.Add(Mapper.Map <HierarchyModel, Hierarchy>(model), CurrentUser.UserId);
ShowMessageDialog(MensagensResource.SucessoCadastrar, Message.MessageKind.Success);
}
else
{
model.HierarchyTypeDictionary = await _dictionaryAllService.GetHierarchyTypeDictionaryAsync();
return(View(model));
}
}
catch (Exception e)
{
ShowMessageDialog(MensagensResource.ErroCadastrar, e);
}
return(RedirectToAction("Index"));
}
public override List <HierarchyModel> GetRoot()
{
List <HierarchyModel> root = new List <HierarchyModel>();
var parents = new Dictionary <string, HierarchyModel>();
var childs = new Dictionary <string, List <HierarchyModel> >();
foreach (var sgoKVp in SessionManager.Instance.sceneGameObjects)
{
SceneGameObject scgo = sgoKVp.Value;
bool selected = SessionManager.Instance.selectedSceneObject?.data.id == sgoKVp.Key;
HierarchyModel model = new HierarchyModel(new HierarchyData {
name = scgo.sceneObject.GetDisplayName(), key = sgoKVp.Key, selected = selected
});
if (childs.ContainsKey(sgoKVp.Key))
{
List <HierarchyModel> scgoChilds = childs[sgoKVp.Key];
foreach (HierarchyModel hm in scgoChilds)
{
model.AddChild(hm);
}
childs.Remove(sgoKVp.Key);
}
if (scgo.parent != null)
{
string parentKey = scgo.parent.data.id;
if (parents.ContainsKey(parentKey))
{
parents[scgo.parent.data.id].AddChild(model);
}
else
{
if (childs.ContainsKey(parentKey))
{
List <HierarchyModel> scgoChilds = childs[parentKey];
scgoChilds.Add(model);
childs[parentKey] = scgoChilds;
}
else
{
List <HierarchyModel> scgoChilds = new List <HierarchyModel>();
scgoChilds.Add(model);
childs.Add(parentKey, scgoChilds);
}
}
}
else
{
root.Add(model);
}
parents.Add(sgoKVp.Key, model);
}
return(root);
}
public void AddChild(HierarchyModel child)
{
children.Add(child);
}
/// <summary>
/// Save the Hierarchy details
/// </summary>
/// <param name="hierarchyModel"></param>
/// <returns></returns>
public JsonResult SetHierarchyDetails(HierarchyModel hierarchyModel)
{
Message result = oAdminManager.SetHierarchyDetails(hierarchyModel, CookieManager.GetCookie(CookieManager.CookieName).logindetail.EmpID);
return(Json(new { result }, JsonRequestBehavior.AllowGet));
}
public void HierarchySystemTests()
{
IReader reader = new FileReader(@".\Resources\DataDictionary\datadict.rpt");
IModelParser[] parsers = new IModelParser[] {
new AccessInformationParser(),
new DescriptionParser(),
new DetailsParser(),
new ModifiedParser(),
new ModuleParser(),
new PageHeaderParser(),
new RecordLengthParser(),
new RecordParser(),
new TechnicalInformationParser(),
CobolParser.CobolHierarchy(),
new IgnoreParser(),
};
IDataParser dataParser = new DataParser(reader, parsers);
dataParser.Corrections = corrections;
dataParser.OnMissingParser = (line) =>
{
throw new InvalidOperationException("No Parser for: " + reader);
};
dataParser.Parse();
string typename = GetType().Name;
string directory = Path.Combine(".", typename);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
foreach (IModel model in dataParser.Results)
{
HierarchyModel hiearchyModel = model as HierarchyModel;
if (hiearchyModel != null)
{
ClassModel classModel = hiearchyModel.Model as ClassModel;
if (classModel != null)
{
ModelXmlFormatter formatter = new ModelXmlFormatter(model);
string xml = formatter.Render();
string objectName = classModel.Data;
string fileName = directory + @"\" + objectName + ".xml";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
Assert.That(File.Exists(fileName), Is.False);
using (StreamWriter writer = new StreamWriter(fileName))
{
writer.Write(xml);
}
}
}
}
}
public override List <HierarchyModel> GetRoot()
{
List <HierarchyModel> root = new List <HierarchyModel>();
Dictionary <string, HierarchyModel> parents = new Dictionary <string, HierarchyModel>();
foreach (Type t in ReflectionUtilities.nodeTypes)
{
if (t.IsAbstract || t.IsGenericType)
{
continue;
}
if (typeof(IVariableNode).IsAssignableFrom(t))
{
continue;
}
if (t == typeof(FlowNode) || t == typeof(NTNode))
{
continue;
}
//FIXME: Freindly names
var node = (NTNode)Activator.CreateInstance(t);
List <string> pathParts = node.GetPath();
HierarchyModel parent = null;
if (pathParts.Count > 1)
{
string fullPath = "";
for (int i = 0; i < pathParts.Count - 1; i++)
{
fullPath += "/" + pathParts[i];
if (parents.ContainsKey(fullPath))
{
parent = parents[fullPath];
}
else
{
if (parent == null)
{
parent = new HierarchyModel(new NodeHierarchyData {
name = pathParts[i]
});
root.Add(parent);
parents.Add(fullPath, parent);
}
else
{
HierarchyModel hm = new HierarchyModel(new NodeHierarchyData {
name = pathParts[i]
});
parent.AddChild(hm);
parent = hm;
}
}
}
}
if (parent != null)
{
parent.AddChild(new HierarchyModel(new NodeHierarchyData {
name = pathParts[pathParts.Count - 1], nodeType = t
}));
}
else
{
root.Add(new HierarchyModel(new NodeHierarchyData {
name = pathParts[pathParts.Count - 1], nodeType = t
}));
}
}
return(root);
}
