/// <summary>
/// creates a new user based on the given details
/// </summary>
/// <param name="model">the model containing the user</param>
/// <param name="login">the string used to log in into the tool</param>
/// <param name="firstName">the first name of the user</param>
/// <param name="lastName">the last name of the user</param>
public User(EAWrappers.Model model,string login,string firstName,string lastName)
{
this.model = model;
this.login = login;
this.firstName = firstName;
this.lastName = lastName;
}
protected DB2TableTransformer addDB2Table(UTF_EA.Class classElement)
{
DB2TableTransformer transformer = null;
if (classElement.owningPackage.Equals(this.logicalPackage))
{
if ( ! this._tableTransformers.Any(x => x.logicalClasses.Any(y => y.Equals(classElement))))
{
transformer = new DB2TableTransformer(this._newDatabase,_nameTranslator);
this._tableTransformers.Add(transformer);
}
}
else
{
if (!this.externalTableTransformers.Any(x => x.logicalClasses.Any(y => y.Equals(classElement))))
{
transformer = new DB2TableTransformer(this._externalDatabase,_nameTranslator);
this.externalTableTransformers.Add(transformer);
}
}
if (transformer != null)
{
//transform to table
transformer.transformLogicalClass(classElement);
//now do the external tables linked to this classElement
foreach (var dependingAssociationEnd in transformer.getDependingAssociationEnds())
{
var dependingEndTransformer = addDB2Table(dependingAssociationEnd);
if (dependingEndTransformer != null)transformer.dependingTransformers.Add(dependingEndTransformer);
}
//add the remote columns and primary and foreign keys
transformer.addRemoteColumnsAndKeys();
}
return transformer;
}
public WorkingSet(EAWrappers.Model model,string ID,User user, string name)
{
this.model = model;
this.ID = ID;
this.user = user;
this.name = name;
}
public EAImvertorException(UTF_EA.Model model, string exceptionType, string guid, string step, string construct, string message)
{
this._model = model;
this.exceptionType = exceptionType;
this.guid = guid;
this.step = step;
this.construct = construct;
this.message = message;
}
public TFSConnectorSettingsForm(EATFSConnectorSettings settings, TSF_EA.Model model )
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
this.settings = settings;
this.model = model;
this.loadData();
this.enableDisable();
}
public EASearchOutput(string name,List<string> fields,List<UML.Extended.UMLModelOutPutItem> output, UTF_EA.Model model)
{
this.name = name;
//add the default fields for EA Searches
this.fields = new List<string> { "CLASSGUID", "CLASSTYPE" };
this.fields.AddRange(fields);
this.output = output;
if (this.output == null)
{
this.output = new List<UML.Extended.UMLModelOutPutItem>();
}
this._model = model;
}
protected DB2TableTransformer addDB2Table(UTF_EA.AssociationEnd associationEnd)
{
DB2TableTransformer transformer = addDB2Table(associationEnd.type as UTF_EA.Class);
if (transformer == null)
{
transformer = this.tableTransformers.OfType<DB2TableTransformer>().FirstOrDefault( x => x.logicalClass.Equals(associationEnd.type));
}
if (transformer == null)
{
transformer = this.externalTableTransformers.FirstOrDefault( x => x.logicalClass.Equals(associationEnd.type));
}
if (transformer != null)
{
transformer.associationEnd = associationEnd;
}
return transformer;
}
/// <summary>
/// copies only the tagged values necesarry
/// </summary>
/// <param name="source">the source element</param>
/// <param name="target">the target element</param>
public void copyTaggedValues(UTF_EA.Element source, UTF_EA.Element target)
{
//copy tagged values
foreach (UTF_EA.TaggedValue sourceTaggedValue in source.taggedValues)
{
bool updateTaggedValue = true;
if (this.settings.ignoredTaggedValues.Contains(sourceTaggedValue.name))
{
UTF_EA.TaggedValue targetTaggedValue =
target.getTaggedValue(sourceTaggedValue.name);
if (targetTaggedValue != null &&
targetTaggedValue.eaStringValue != string.Empty)
{
//don't update any of the tagged values of the ignoredTaggeValues if the value is already filled in.
updateTaggedValue = false;
}
}
if (updateTaggedValue)
{
target.addTaggedValue(sourceTaggedValue.name,
sourceTaggedValue.eaStringValue, sourceTaggedValue.comment);
}
}
}
private void copyAssociationEndProperties(UTF_EA.AssociationEnd source, UTF_EA.AssociationEnd target)
{
target.name = source.name;
target.multiplicity = source.multiplicity;
target.isNavigable = source.isNavigable;
target.aggregation = source.aggregation;
target.ownedComments = source.ownedComments;
target.save();
}
protected abstract void addTable(UTF_EA.Class classElement);
/// <summary>
/// gets the superclasses of an element
/// </summary>
/// <param name="classElement"></param>
/// <returns></returns>
protected virtual List<UTF_EA.Class> getsuperClasses(UTF_EA.Class classElement)
{
if (!_superClasses.ContainsKey(classElement))
{
if (classElement.superClasses.Count == 0)
{
//no superclasses, return empty list
_superClasses.Add(classElement, new List<UTF_EA.Class>());
}
else
{
var superClasses = new List<UTF_EA.Class>();
//first add the superclasses of the superclasses
foreach (UTF_EA.Class superClass in classElement.superClasses)
{
superClasses.AddRange(getsuperClasses(superClass));
}
//the add the superclasses themselves
foreach (UTF_EA.Class superClass in classElement.superClasses)
{
superClasses.Add(superClass);
}
_superClasses.Add(classElement, superClasses);
}
}
return _superClasses[classElement];
}
/// <summary>
/// Constructor of the EASchema. Only to be used by the EASchemaBuilderFactory
/// </summary>
/// <param name="model">The model containing this Scheam</param>
/// <param name="composer">The EA.SchemaComposer object to be wrapped</param>
internal EASchema(UTF_EA.Model model, EA.SchemaComposer composer)
{
this.model = model;
this.wrappedComposer = composer;
}
public EASchemaPropertyWrapper(UTF_EA.Model model, EASchemaElement owner, EA.SchemaProperty objectToWrap)
{
this._owner = owner;
this.model = model;
this.wrappedProperty = objectToWrap;
}
public EASchemaElement(UTF_EA.Model model,EASchema owner, EA.SchemaType objectToWrap)
{
this.model = model;
this.ownerSchema = owner;
this.wrappedSchemaType = objectToWrap;
}
public static DatabaseFactory getFactory(UTF_EA.Model model)
{
return DB_EA.DatabaseFactory.getFactory("DB2",model);
}
public DB2DatabaseTransformer(DatabaseFactory factory,UTF_EA.Model model,NameTranslator nameTranslator)
: base(factory,model,nameTranslator)
{
this._externalDatabase = factory.createDatabase("external");
}
public DB2DatabaseTransformer(UTF_EA.Model model,NameTranslator nameTranslator)
: this(getFactory(model),model,nameTranslator)
{
}
public DB2DatabaseTransformer(UTF_EA.Package logicalPackage,NameTranslator nameTranslator)
: this(logicalPackage.model, nameTranslator)
{
this._logicalPackage = logicalPackage;
}
public Column(Table owner, TSF_EA.Attribute attribute)
{
this._ownerTable = owner;
this._wrappedattribute = attribute;
}
public Event(UTF_EA.Model model, global::EA.Element wrappedElement)
: base(model,wrappedElement)
{
}
public EASchemaAssociation(UTF_EA.Model model,EASchemaElement owner, EA.SchemaProperty objectToWrap):base(model,owner, objectToWrap)
{
}
/// <summary>
/// Writes a transitions connector source at the current indent level.
/// </summary>
/// <param name="connectorWrapper"></param>
/// <param name="addProperties"></param>
/// <returns>The TransformationILWriter instance for use in concatenated output.</returns>
public TransformationILWriter WriteILConnectorTarget(UTF_EA.ConnectorWrapper connectorWrapper, StringDictionary addProperties = null)
{
if(connectorWrapper != null) {
WriteIndented("target");
WriteIndented("{");
Indent();
if(addProperties != null) {
foreach(string propertyName in addProperties.Keys) {
WriteILProperty(propertyName,addProperties[propertyName]);
}
}
GenerateXRef(connectorWrapper.supplier);
Indent(-1);
WriteIndented("}");
}
return this;
}
protected abstract void createTable(UTF_EA.Class classElement);
/// <summary>
/// Writes an IL 'XRef' declaration for connectorWrapper at the current indentation level.
/// </summary>
/// <param name="name"></param>
/// <param name="connectorWrapper"></param>
/// <returns>The TransformationILWriter instance for use in concatenated output.</returns>
public TransformationILWriter GenerateXRef(string name, UTF_EA.ConnectorWrapper connectorWrapper)
{
string sourceGuid = GetConnectorGuid(connectorWrapper);
OpenILXRef()
.WriteILProperty("namespace","C++STTCL")
.WriteILProperty("name",name)
.WriteILProperty("source",sourceGuid)
.CloseIL();
return this;
}
protected abstract Column transformLogicalAttribute(UTF_EA.Attribute attribute);
private string GetElementGuid(UTF_EA.ElementWrapper elementWrapper)
{
return elementWrapper.WrappedElement.ElementGUID;
}
public EADatabaseTransformer(DatabaseFactory factory, UTF_EA.Model model,NameTranslator nameTranslator)
: base(nameTranslator)
{
this._factory = factory;
this._model = model;
}
private string GetConnectorGuid(UTF_EA.ConnectorWrapper connectorWrapper)
{
return connectorWrapper.WrappedConnector.ConnectorGUID;
}
public EASchemaAssociation(UTF_EA.Model model, EASchemaElement owner, EA.SchemaProperty objectToWrap)
: base(model, owner, objectToWrap)
{
this.subsetAssociations = new List<Association>();
}
protected abstract void createColumn(UTF_EA.Attribute attribute);
