private static List <LinkElementModel> createLinkElementModelPartyCustomType(PartyType partyType, LinkElementRootModel rootModel, LinkElementModel parent, MappingManager mappingManager)
{
List <LinkElementModel> tmp = new List <LinkElementModel>();
PartyTypeManager partyTypeManager = new PartyTypeManager();
try
{
foreach (var partyCustomType in partyType.CustomAttributes)
{
long linkElementId = GetId(partyCustomType.Id, LinkElementType.PartyCustomType, mappingManager);
LinkElementModel LEModel = new LinkElementModel(
linkElementId,
partyCustomType.Id,
LinkElementType.PartyCustomType, partyCustomType.Name, partyType.Title + "/" + partyCustomType.Name, rootModel.Position, LinkElementComplexity.Simple, partyCustomType.Description);
LEModel.Parent = parent;
tmp.Add(LEModel);
}
return(tmp);
}
finally
{
partyTypeManager.Dispose();
}
}
public static LinkElement CreateLinkElement(LinkElementModel model)
{
MappingManager mappingManager = new MappingManager();
try
{
Debug.WriteLine("CreateLinkElement");
Debug.WriteLine(model.ElementId);
Debug.WriteLine(model.Type);
Debug.WriteLine(model.Name);
if (model.Parent != null)
{
Debug.WriteLine("Parent");
Debug.WriteLine(model.Parent.ElementId);
Debug.WriteLine(model.Parent.Type);
Debug.WriteLine(model.Parent.Name);
Debug.WriteLine("------------------");
}
return(mappingManager.CreateLinkElement(
model.ElementId,
model.Type,
model.Complexity,
model.Name,
model.XPath
));
}
finally
{
mappingManager.Dispose();
}
}
private static List <LinkElementModel> getChildrenFromMetadataNestedUsage(LinkElementModel model)
{
MetadataAttributeManager metadataAttributeManager = new MetadataAttributeManager();
try
{
MetadataNestedAttributeUsage metadataNestedAttributeUsage =
metadataAttributeManager.MetadataNestedAttributeUsageRepo.Get(model.ElementId);
LinkElementComplexity complexity = LinkElementComplexity.None;
LinkElementType type = LinkElementType.ComplexMetadataAttribute;
complexity = metadataNestedAttributeUsage.Member.Self is MetadataSimpleAttribute
? LinkElementComplexity.Simple
: LinkElementComplexity.Complex;
if (complexity == LinkElementComplexity.Complex)
{
return(getChildrenFromComplexMetadataAttribute(metadataNestedAttributeUsage.Member.Id, model.Position));
}
return(new List <LinkElementModel>());
}
finally
{
metadataAttributeManager.Dispose();
}
}
private static List <LinkElementModel> getChildrenFromPartyType(LinkElementModel model)
{
PartyTypeManager partyTypeManager = new PartyTypeManager();
try
{
IEnumerable <PartyCustomAttribute> ptAttr = partyTypeManager.PartyCustomAttributeRepository.Get().Where(p => p.PartyType.Id.Equals(model.ElementId));
foreach (var attr in ptAttr)
{
model.Children.Add(
new LinkElementModel(
0,
attr.Id,
LinkElementType.PartyCustomType, attr.Name, "", model.Position, LinkElementComplexity.Simple, attr.Description)
);
}
return(model.Children);
}
finally
{
partyTypeManager.Dispose();
}
}
public static bool ExistLinkElementModel(LinkElementModel leModel, List <LinkElementModel> leModels)
{
if (leModels.Any(le => le.ElementId.Equals(leModel.ElementId) &&
le.Type.Equals(leModel.Type) &&
le.Complexity.Equals(leModel.Complexity)))
{
return(true);
}
return(false);
}
public static LinkElement CreateIfNotExistLinkElement(LinkElementModel leModel, MappingManager mappingManager)
{
if (ExistLinkElement(leModel))
{
return(mappingManager.LinkElementRepo.Get()
.FirstOrDefault(le => le.ElementId.Equals(leModel.ElementId) && le.Type.Equals(leModel.Type)));
}
else
{
return(CreateLinkElement(leModel));
}
}
private static List <LinkElementModel> getChildrenFromMetadataPackageUsage(LinkElementModel model)
{
MetadataStructureManager msm = new MetadataStructureManager();
try
{
MetadataPackageUsage metadataPackageUsage = msm.PackageUsageRepo.Get(model.ElementId);
return(getChildrenFromMetadataPackage(metadataPackageUsage.MetadataPackage.Id, model.Position));
}
finally
{
msm.Dispose();
}
}
private static LinkElementModel createLinkElementModelType(
PartyType partyType,
LinkElementRootModel rootModel,
LinkElementModel parent, MappingManager mappingManager)
{
long linkElementId = GetId(partyType.Id, LinkElementType.PartyType, mappingManager);
LinkElementModel LEModel = new LinkElementModel(
linkElementId,
partyType.Id,
LinkElementType.PartyType, partyType.Title, "", rootModel.Position, LinkElementComplexity.Complex, partyType.Description);
LEModel.Parent = parent;
return(LEModel);
}
public static LinkElementModel LoadChildren(LinkElementModel model)
{
switch (model.Type)
{
case LinkElementType.PartyType:
{
model.Children = getChildrenFromPartyType(model);
break;
}
case LinkElementType.ComplexMetadataAttribute:
{
model.Children = getChildrenFromComplexMetadataAttribute(model);
break;
}
case LinkElementType.MetadataNestedAttributeUsage:
{
//ToDo load childrens from nestedUsage
model.Children = getChildrenFromMetadataNestedUsage(model);
break;
}
case LinkElementType.MetadataPackage:
{
//ToDo load childrens from packageUsage
model.Children = getChildrenFromMetadataPackage(model);
break;
}
case LinkElementType.MetadataPackageUsage:
{
//ToDo load childrens from packageUsage
model.Children = getChildrenFromMetadataPackageUsage(model);
break;
}
case LinkElementType.MetadataAttributeUsage:
{
//ToDo load childrens from packageUsage
model.Children = getChildrenFromMetadataAttributeUsage(model);
break;
}
}
return(model);
}
public static LinkElementRootModel LoadFromMetadataStructure(long id, LinkElementPostion rootModelType, MappingManager mappingManager)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(id);
LinkElementRootModel model = new LinkElementRootModel(LinkElementType.MetadataStructure, id, metadataStructure.Name, rootModelType);
if (metadataStructure != null)
{
LinkElement metadataStructureLinkElement = mappingManager.GetLinkElement(metadataStructure.Id,
LinkElementType.MetadataStructure);
long metadataStructureLinkElementId = 0;
if (metadataStructureLinkElement != null)
{
metadataStructureLinkElementId = metadataStructureLinkElement.Id;
}
LinkElementModel LEModel = new LinkElementModel(
metadataStructureLinkElementId,
metadataStructure.Id,
LinkElementType.MetadataStructure,
metadataStructure.Name, "Metadata",
rootModelType,
LinkElementComplexity.Complex,
metadataStructure.Description);
foreach (var pUsage in metadataStructure.MetadataPackageUsages)
{
addUsageAsLinkElement(pUsage, "Metadata", model, LEModel);
}
model = CreateLinkElementContainerModels(model);
model.Id = id;
}
return(model);
}
finally
{
metadataStructureManager.Dispose();
}
}
public static LinkElement CreateIfNotExistLinkElement(LinkElementModel leModel, long parentId, MappingManager mappingManager)
{
if (ExistLinkElement(leModel))
{
return(mappingManager.LinkElementRepo.Get()
.FirstOrDefault(le =>
le.ElementId.Equals(leModel.ElementId) &&
le.Type.Equals(leModel.Type) &&
le.Complexity.Equals(leModel.Complexity)
//le.Parent.Id.Equals(parentId)
));
}
else
{
return(CreateLinkElement(leModel, parentId));
}
}
public static LinkElement CreateLinkElement(LinkElementModel model, long parentId)
{
MappingManager mappingManager = new MappingManager();
try
{
return(mappingManager.CreateLinkElement(
model.ElementId,
model.Type,
model.Complexity,
model.Name,
model.XPath,
false
));
}
finally
{
mappingManager.Dispose();
}
}
public static bool ExistLinkElement(LinkElementModel leModel)
{
MappingManager mappingManager = new MappingManager();
try
{
if (mappingManager.LinkElementRepo.Get()
.Any(le => le.ElementId.Equals(leModel.ElementId) &&
le.Type.Equals(leModel.Type) &&
le.Complexity.Equals(leModel.Complexity)))
{
return(true);
}
return(false);
}
finally
{
mappingManager.Dispose();
}
}
public static SimpleMappingModel CreateSimpleMappingModel(Mapping mapping, LinkElement source, LinkElement target)
{
LinkElementModel sourceModel = CreateLinkElementModel(source, LinkElementPostion.Source);
LinkElementModel targetModel = CreateLinkElementModel(target, LinkElementPostion.Target);
TransformationRuleModel transformationRuleModel = null;
if (mapping.TransformationRule != null)
{
transformationRuleModel = new TransformationRuleModel();
transformationRuleModel.Id = mapping.TransformationRule.Id;
transformationRuleModel.RegEx = mapping.TransformationRule.RegEx;
transformationRuleModel.Mask = mapping.TransformationRule.Mask;
}
else
{
transformationRuleModel = new TransformationRuleModel();
}
long parentId = 0;
if (mapping.Parent != null)
{
parentId = mapping.Parent.Id;
}
//ToDo Load Rules
return(new SimpleMappingModel()
{
Id = mapping.Id,
Source = sourceModel,
Target = targetModel,
TransformationRule = transformationRuleModel,
ParentId = parentId
});
}
public static ComplexMappingModel CreateComplexMappingModel(Mapping mapping)
{
LinkElementModel sourceModel = CreateLinkElementModel(mapping.Source, LinkElementPostion.Source);
LinkElementModel targetModel = CreateLinkElementModel(mapping.Target, LinkElementPostion.Target);
sourceModel = LoadChildren(sourceModel);
targetModel = LoadChildren(targetModel);
long parentId = 0;
if (mapping.Parent != null)
{
parentId = mapping.Parent.Id;
}
return(new ComplexMappingModel()
{
Id = mapping.Id,
ParentId = parentId,
Source = sourceModel,
Target = targetModel
});
}
public static void addUsageAsLinkElement(BaseUsage usage, string parentXpath, LinkElementRootModel rootModel,
LinkElementModel parent)
{
int min = usage.MinCardinality;
string childName = "";
//MappingManager mappingManager = new MappingManager();
string usageName = usage.Label;
string typeName = "x";
long typeId = 0;
string typeDescription = "";
string xPath = parentXpath;
LinkElementType type = LinkElementType.ComplexMetadataAttribute;
LinkElementComplexity complexity = LinkElementComplexity.Complex;
bool addTypeAsLinkElement = false;
if (usage is MetadataPackageUsage)
{
type = LinkElementType.MetadataPackageUsage;
typeName = ((MetadataPackageUsage)usage).MetadataPackage.Name;
}
else if (usage is MetadataNestedAttributeUsage)
{
type = LinkElementType.MetadataNestedAttributeUsage;
MetadataNestedAttributeUsage n = (MetadataNestedAttributeUsage)usage;
typeName = n.Member.Name;
if (n.Member.Self is MetadataCompoundAttribute)
{
addTypeAsLinkElement = true;
typeId = n.Member.Self.Id;
typeDescription = n.Member.Self.Description;
}
if (n.Member.Self is MetadataSimpleAttribute)
{
complexity = LinkElementComplexity.Simple;
}
}
else if (usage is MetadataAttributeUsage)
{
type = LinkElementType.MetadataAttributeUsage;
MetadataAttributeUsage u = (MetadataAttributeUsage)usage;
typeName = u.MetadataAttribute.Name;
if (u.MetadataAttribute.Self is MetadataCompoundAttribute)
{
addTypeAsLinkElement = true;
typeId = u.MetadataAttribute.Self.Id;
typeDescription = u.MetadataAttribute.Self.Description;
}
if (u.MetadataAttribute.Self is MetadataSimpleAttribute)
{
complexity = LinkElementComplexity.Simple;
}
}
// add usage
xPath = parentXpath + "/" + usageName.Replace(" ", string.Empty) + "/" + typeName;
long linkElementId = 0;
string mask = "";
LinkElement linkElement = type.GetUnitOfWork().GetReadOnlyRepository <LinkElement>().Get()
.FirstOrDefault(le => le.ElementId.Equals(usage.Id) && le.Type.Equals(type));
if (linkElement != null)
{
linkElementId = linkElement.Id;
}
LinkElementModel LEModel = new LinkElementModel(
linkElementId,
usage.Id,
type, usage.Label, xPath, rootModel.Position, complexity, usage.Description);
LEModel.Parent = parent;
rootModel.LinkElements.Add(LEModel);
//add type
if (addTypeAsLinkElement)
{
linkElementId = 0;
linkElement =
type.GetUnitOfWork().GetReadOnlyRepository <LinkElement>().Get()
.FirstOrDefault(
le =>
le.ElementId.Equals(typeId) &&
le.Type.Equals(LinkElementType.ComplexMetadataAttribute));
if (linkElement != null)
{
linkElementId = linkElement.Id;
}
LEModel = new LinkElementModel(
linkElementId,
typeId,
LinkElementType.ComplexMetadataAttribute,
typeName,
xPath,
rootModel.Position,
complexity,
typeDescription);
LEModel.Parent = parent;
if (!rootModel.LinkElements.Any(le => le.ElementId.Equals(typeId) &&
le.Type.Equals(LinkElementType.ComplexMetadataAttribute)))
{
rootModel.LinkElements.Add(LEModel);
}
}
//Debug.WriteLine("1: " + LEModel.Name + " " + LEModel.Type);
List <BaseUsage> childrenUsages = metadataStructureUsageHelper.GetChildren(usage.Id, usage.GetType());
if (childrenUsages.Count > 0)
{
foreach (BaseUsage childUsage in childrenUsages)
{
addUsageAsLinkElement(childUsage, xPath, rootModel, LEModel);
}
//AddChildrens
//addLinkElementsFromChildrens(usage, xPath, rootModel);
}
}
public static LinkElementRootModel LoadfromSystem(LinkElementPostion rootModelType, MappingManager mappingManager)
{
//get all parties - complex
PartyTypeManager partyTypeManager = new PartyTypeManager();
try
{
LinkElementRootModel model = new LinkElementRootModel(LinkElementType.System, 0, "System", rootModelType);
LinkElement SystemRoot = mappingManager.GetLinkElement(0, LinkElementType.System);
long id = 0;
long elementId = 0;
if (SystemRoot != null)
{
id = SystemRoot.Id;
elementId = SystemRoot.ElementId;
}
LinkElementModel LEParent = new LinkElementModel(
id,
elementId,
LinkElementType.System,
"System", "",
rootModelType,
LinkElementComplexity.Complex,
"");
IEnumerable <PartyType> partyTypes = partyTypeManager.PartyTypeRepository.Get();
foreach (var pt in partyTypes)
{
LinkElementModel ptModel = createLinkElementModelType(pt, model, LEParent, mappingManager);
model.LinkElements.Add(ptModel);
//get all partyCustomTypeAttr -> simple
model.LinkElements.AddRange(createLinkElementModelPartyCustomType(pt, model, ptModel, mappingManager));
}
//get all keys -> simple
foreach (Key value in Key.GetValues(typeof(Key)))
{
long linkElementId = GetId((int)value, LinkElementType.Key, mappingManager);
//string mask = GetMask((int)value, LinkElementType.Key);
LinkElementModel LEModel = new LinkElementModel(
linkElementId,
(int)value,
LinkElementType.Key, value.ToString(), "", model.Position, LinkElementComplexity.Simple, "");
LEModel.Parent = LEParent;
model.LinkElements.Add(LEModel);
}
//create container
model = CreateLinkElementContainerModels(model);
return(model);
}
finally
{
partyTypeManager.Dispose();
}
}
private static List <LinkElementModel> getChildrenFromMetadataPackage(LinkElementModel model)
{
return(getChildrenFromMetadataPackage(model.ElementId, model.Position));
}
public static LinkElementRootModel LoadfromSystem(LinkElementPostion rootModelType, MappingManager mappingManager)
{
//get all parties - complex
using (PartyTypeManager partyTypeManager = new PartyTypeManager())
using (PartyRelationshipTypeManager partyRelationshipTypeManager = new PartyRelationshipTypeManager())
using (EntityManager entityManager = new EntityManager())
{
LinkElementRootModel model = new LinkElementRootModel(LinkElementType.System, 0, "System", rootModelType);
LinkElement SystemRoot = mappingManager.GetLinkElement(0, LinkElementType.System);
long id = 0;
long elementId = 0;
if (SystemRoot != null)
{
id = SystemRoot.Id;
elementId = SystemRoot.ElementId;
}
LinkElementModel LEParent = new LinkElementModel(
id,
elementId,
LinkElementType.System,
"System", "",
rootModelType,
LinkElementComplexity.Complex,
"");
#region get party types
IEnumerable <PartyType> partyTypes = partyTypeManager.PartyTypeRepository.Get();
foreach (var pt in partyTypes)
{
LinkElementModel ptModel = createLinkElementModelType(pt, model, LEParent, mappingManager);
model.LinkElements.Add(ptModel);
//get all partyCustomTypeAttr -> simple
model.LinkElements.AddRange(createLinkElementModelPartyCustomType(pt, model, ptModel, mappingManager));
}
#endregion get party types
#region keys
//get all keys -> simple
foreach (Key value in Key.GetValues(typeof(Key)))
{
long linkElementId = GetId((int)value, LinkElementType.Key, mappingManager);
//string mask = GetMask((int)value, LinkElementType.Key);
LinkElementModel LEModel = new LinkElementModel(
linkElementId,
(int)value,
LinkElementType.Key, value.ToString(), "", model.Position, LinkElementComplexity.Simple, "");
LEModel.Parent = LEParent;
model.LinkElements.Add(LEModel);
}
#endregion keys
#region get all relationships
IEnumerable <PartyRelationshipType> relationshipTypes = partyRelationshipTypeManager.PartyRelationshipTypeRepository.Get();
foreach (PartyRelationshipType partyRelationshipType in relationshipTypes)
{
long value = partyRelationshipType.Id;
long linkElementId = GetId(partyRelationshipType.Id, LinkElementType.Key, mappingManager);
LinkElementModel LEModel = new LinkElementModel(
linkElementId,
partyRelationshipType.Id,
LinkElementType.PartyRelationshipType,
partyRelationshipType.DisplayName,
"",
model.Position,
LinkElementComplexity.Simple,
"");
LEModel.Parent = LEParent;
model.LinkElements.Add(LEModel);
}
#endregion get all relationships
#region entities
foreach (Entity entity in entityManager.Entities)
{
long value = entity.Id;
long linkElementId = GetId(entity.Id, LinkElementType.Entity, mappingManager);
LinkElementModel LEModel = new LinkElementModel(
linkElementId,
entity.Id,
LinkElementType.Entity,
entity.Name,
"",
model.Position,
LinkElementComplexity.Simple,
"");
LEModel.Parent = LEParent;
model.LinkElements.Add(LEModel);
}
//test
#endregion entities
//create container
model = CreateLinkElementContainerModels(model);
return(model);
}
}
private static List <LinkElementModel> getChildrenFromComplexMetadataAttribute(LinkElementModel model)
{
return(getChildrenFromComplexMetadataAttribute(model.ElementId, model.Position));
}
public ActionResult AddMappingElement(LinkElementModel linkElementModel)
{
linkElementModel = MappingHelper.LoadChildren(linkElementModel);
return(PartialView("MappingLinkElement", linkElementModel));
}
