public static List <Mapping> createOwnedMappings(ElementWrapper ownerElement, string basepath, ElementWrapper targetRootElement, bool includeOwnedElements)
{
List <Mapping> returnedMappings = new List <Mapping>();
//connectors to an attribute
foreach (ConnectorWrapper mappedConnector in ownerElement.relationships.OfType <ConnectorWrapper>()
.Where(y => y.targetElement is AttributeWrapper))
{
string connectorPath = basepath + "." + getConnectorString(mappedConnector);
var connectorMapping = new ConnectorMapping(mappedConnector, connectorPath, targetRootElement);
returnedMappings.Add(connectorMapping);
}
//loop owned attributes
foreach (TSF.UmlToolingFramework.Wrappers.EA.Attribute ownedAttribute in ownerElement.ownedAttributes)
{
returnedMappings.AddRange(createNewMappings(ownedAttribute, basepath, targetRootElement));
}
//loop owned Elements
if (includeOwnedElements)
{
foreach (var ownedElement in ownerElement.ownedElements.OfType <ElementWrapper>())
{
returnedMappings.AddRange(createOwnedMappings(ownedElement, basepath + "." + ownedElement.name, targetRootElement, includeOwnedElements));
}
}
return(returnedMappings);
}
public static List <Mapping> createNewMappings(TSF.UmlToolingFramework.Wrappers.EA.Attribute attribute, string basepath, ElementWrapper targetRootElement)
{
List <Mapping> returnedMappings = new List <Mapping>();
//connectors from owned attributes
foreach (ConnectorWrapper mappedConnector in attribute.relationships.OfType <ConnectorWrapper>())
{
if (!mappedConnector.taggedValues.Any(x => x.name == mappingSourcePathName && x.tagValue.ToString() != basepath))
{
//get the target base path
ConnectorMapping connectorMapping;
var targetTV = mappedConnector.taggedValues.FirstOrDefault(x => x.name == mappingTargetPathName);
string targetBasePath = string.Empty;
if (targetTV != null)
{
targetBasePath = targetTV.tagValue.ToString();
}
if (!string.IsNullOrEmpty(targetBasePath))
{
connectorMapping = new ConnectorMapping(mappedConnector, basepath, targetBasePath);
}
else
{
connectorMapping = new ConnectorMapping(mappedConnector, basepath, targetRootElement);
}
returnedMappings.Add(connectorMapping);
}
}
//tagged value references from owned attributes
foreach (TaggedValue mappedTaggedValue in attribute.taggedValues.Where(x => x.tagValue is Element))
{
string mappingSourcePath = KeyValuePairsHelper.getValueForKey(mappingSourcePathName, mappedTaggedValue.comment);
string targetBasePath = KeyValuePairsHelper.getValueForKey(mappingTargetPathName, mappedTaggedValue.comment);
//if not filled in or corresponds to the attributeBasePath or the attributeBasePath + the name of the attribute
if (string.IsNullOrEmpty(mappingSourcePath) || mappingSourcePath == basepath ||
mappingSourcePath == basepath + "." + attribute.name)
{
TaggedValueMapping tagMapping;
if (!string.IsNullOrEmpty(targetBasePath))
{
tagMapping = new TaggedValueMapping(mappedTaggedValue, basepath, targetBasePath);
}
else
{
tagMapping = new TaggedValueMapping(mappedTaggedValue, basepath, targetRootElement);
}
returnedMappings.Add(tagMapping);
}
}
//add the mappings for the type of the attribute
var attributeType = attribute.type as ElementWrapper;
if (attributeType != null)
{
returnedMappings.AddRange(createOwnedMappings(attributeType, basepath + "." + attribute.name, false));
}
return(returnedMappings);
}
public static List<Mapping> createNewMappings(TSF.UmlToolingFramework.Wrappers.EA.Attribute attribute,string basepath,ElementWrapper targetRootElement)
{
List<Mapping> returnedMappings = new List<Mapping>();
//connectors from owned attributes
foreach (ConnectorWrapper mappedConnector in attribute.relationships.OfType<ConnectorWrapper>())
{
if (! mappedConnector.taggedValues.Any( x => x.name == mappingSourcePathName && x.tagValue.ToString() != basepath))
{
//get the target base path
ConnectorMapping connectorMapping;
var targetTV = mappedConnector.taggedValues.FirstOrDefault(x => x.name == mappingTargetPathName);
string targetBasePath = string.Empty;
if (targetTV != null) targetBasePath = targetTV.tagValue.ToString();
if (! string.IsNullOrEmpty(targetBasePath))
{
connectorMapping = new ConnectorMapping(mappedConnector,basepath,targetBasePath);
}
else
{
connectorMapping = new ConnectorMapping(mappedConnector,basepath,targetRootElement);
}
returnedMappings.Add(connectorMapping);
}
}
//tagged value references from owned attributes
foreach (TaggedValue mappedTaggedValue in attribute.taggedValues.Where(x => x.tagValue is Element) )
{
string mappingSourcePath = getValueForKey(mappingSourcePathName,mappedTaggedValue.comment);
string targetBasePath = getValueForKey(mappingTargetPathName,mappedTaggedValue.comment);
//if not filled in or corresponds to the attributeBasePath
if (string.IsNullOrEmpty(mappingSourcePath) || mappingSourcePath == basepath)
{
TaggedValueMapping tagMapping;
if (! string.IsNullOrEmpty(targetBasePath))
{
tagMapping = new TaggedValueMapping(mappedTaggedValue,basepath,targetBasePath);
}
else
{
tagMapping = new TaggedValueMapping(mappedTaggedValue,basepath,targetRootElement);
}
returnedMappings.Add(tagMapping);
}
}
//add the mappings for the type of the attribute
var attributeType = attribute.type as ElementWrapper;
if (attributeType != null) returnedMappings.AddRange(createOwnedMappings(attributeType,basepath + "." + attribute.name));
return returnedMappings;
}
public static List<Mapping> createOwnedMappings(ElementWrapper ownerElement,string basepath,ElementWrapper targetRootElement)
{
List<Mapping> returnedMappings = new List<Mapping>();
//connectors to an attribute
foreach (ConnectorWrapper mappedConnector in ownerElement.relationships.OfType<ConnectorWrapper>()
.Where(y => y.targetElement is AttributeWrapper))
{
string connectorPath = basepath + "." + getConnectorString(mappedConnector);
var connectorMapping = new ConnectorMapping(mappedConnector,connectorPath,targetRootElement);
returnedMappings.Add(connectorMapping);
}
//loop owned attributes
foreach (TSF.UmlToolingFramework.Wrappers.EA.Attribute ownedAttribute in ownerElement.ownedAttributes)
{
returnedMappings.AddRange(createNewMappings(ownedAttribute,basepath, targetRootElement));
}
return returnedMappings;
}
/// <summary>
/// create a mappingSet based on the data in the CSV file
/// </summary>
/// <param name="model">the model that contains the elements</param>
/// <param name="filePath">the path to the CSV file</param>
/// <returns>a mapping set representing the mapping in the file</returns>
public static MappingSet createMappingSet(Model model, string filePath, MappingSettings settings, Element sourceRootElement = null, Element targetRootElement = null)
{
MappingSet newMappingSet = null;
var engine = new FileHelperEngine <CSVMappingRecord>();
var parsedFile = engine.ReadFile(filePath);
int i = 1;
Package rootPackage = null;
foreach (CSVMappingRecord mappingRecord in parsedFile)
{
//find source
var source = findElement(model, mappingRecord.sourcePath, sourceRootElement);
//find target
var target = findElement(model, mappingRecord.targetPath, targetRootElement);
if (source == null)
{
EAOutputLogger.log(model, settings.outputName
, string.Format("Could not find element that matches: '{0}'", mappingRecord.sourcePath)
, 0, LogTypeEnum.error);
}
else if (target == null)
{
EAOutputLogger.log(model, settings.outputName
, string.Format("Could not find element that matches: '{0}'", mappingRecord.targetPath)
, 0, LogTypeEnum.error);
}
else
{
//first check if the mappingSet is already created
if (newMappingSet == null)
{
//determine if this should be a PackageMappingSet or an ElementMappingSet
if (sourceRootElement is Package)
{
rootPackage = sourceRootElement as Package;
newMappingSet = new PackageMappingSet(sourceRootElement as Package);
}
else if (sourceRootElement is ElementWrapper)
{
rootPackage = sourceRootElement.owningPackage as Package;
newMappingSet = new ElementMappingSet(sourceRootElement as ElementWrapper);
}
else
{
rootPackage = source.owningPackage as Package;
newMappingSet = new PackageMappingSet((Package)source.owningPackage);
}
}
MappingLogic newMappingLogic = null;
//check if there is any mapping logic
if (!string.IsNullOrEmpty(mappingRecord.mappingLogic))
{
if (settings.useInlineMappingLogic)
{
newMappingLogic = new MappingLogic(mappingRecord.mappingLogic);
}
else
{
//Check fo an existing mapping logic
newMappingLogic = getExistingMappingLogic(model, settings, mappingRecord.mappingLogic, rootPackage);
if (newMappingLogic == null)
{
var mappingElement = model.factory.createNewElement(rootPackage, "mapping logic " + i, settings.mappingLogicType) as ElementWrapper;
if (mappingElement != null)
{
//increase counter for new mapping element name
i++;
mappingElement.notes = mappingRecord.mappingLogic;
mappingElement.save();
//create the mappingLogic
newMappingLogic = new MappingLogic(mappingElement);
}
else
{
//else we create an inline mapping logic anyway
newMappingLogic = new MappingLogic(mappingRecord.mappingLogic);
}
}
}
}
Mapping newMapping = null;
var sourceAssociationEnd = source as AssociationEnd;
var targetAssociationEnd = target as AssociationEnd;
//create the new mapping
//we can't create connector mappings for mappings to or from associations so we have to use tagged value mappings for those.
if (settings.useTaggedValues ||
sourceAssociationEnd != null || targetAssociationEnd != null)
{
//if the source or target are associationEnds then we replace them by their association
if (sourceAssociationEnd != null)
{
source = sourceAssociationEnd.association as Element;
}
if (targetAssociationEnd != null)
{
target = targetAssociationEnd.association as Element;
}
newMapping = new TaggedValueMapping(source, target, mappingRecord.sourcePath, mappingRecord.targetPath, settings);
}
else
{
newMapping = new ConnectorMapping(source, target, mappingRecord.sourcePath, mappingRecord.targetPath, settings);
}
if (newMappingLogic != null)
{
newMapping.mappingLogic = newMappingLogic;
}
newMapping.save();
newMappingSet.addMapping(newMapping);
}
}
return(newMappingSet);
}