private void checkContext(TSF_EA.ElementWrapper context)
{
// clean up for new context build-up
this.clear();
this.notify("Please select a Data Item or Table");
this.context = null;
this.syncButton.Enabled = false;
this.addButton.Enabled = false;
this.filterButton.Enabled = false;
// validate context
if (context != null && context is TSF_EA.Class)
{
TSF_EA.Class clazz = context as TSF_EA.Class;
if (clazz.HasStereotype("Data Item") || clazz.HasStereotype("table"))
{
this.context = clazz;
this.addButton.Enabled = true;
this.filterButton.Enabled = true;
this.hideNotifications();
}
}
this.refreshTree();
}
/// <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]);
}
public void refresh()
{
List <DataItem> dataItems = this.list <DataItem>(this.managedPackage);
// add all Logical DataTypes from this package and optionally others
// from the dataItems
if (this.managedPackage != null)
{
foreach (TSF_EA.Class clazz in
this.managedPackage.ownedElements.OfType <TSF_EA.Class>())
{
if (clazz.stereotypes.Count == 1)
{
if (clazz.stereotypes.ToList()[0].name == "LogicalDataType")
{
}
}
}
}
foreach (DataItem item in dataItems)
{
TSF_EA.Class element = this.model.getElementByGUID(item.datatypeDisplayName) as TSF_EA.Class;
}
this.model.activateTab(appTitle);
}
private bool notInSync(TSF_EA.Attribute column, TSF_EA.Class clazz)
{
//DataItem di = GlossaryItemFactory<DataItem>.FromClass(clazz);
DataItem di = null;
if (di == null)
{
return(true);
} // ???
if (column.name != di.Label)
{
return(true);
}
// TODO DataType
if (column.length != di.Size)
{
return(true);
}
// TODO Format
if (column.defaultValue.ToString() != di.InitialValue)
{
return(true);
}
return(false);
}
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())
{
transformer.dependingTransformers.Add(addDB2Table(dependingAssociationEnd));
}
//add the remote columns and primary and foreign keys
transformer.addRemoteColumnsAndKeys();
}
return(transformer);
}
public static DB_EA.Table createTable(TSF_EA.Class tableElement)
{
//get the database
var database = getDatabase(tableElement);
if (database == null)
{
return(null);
}
//create the table
return(new Table(database, tableElement));
}
private TreeNode createDataItemNode(TSF_EA.Class clazz,
TreeNodeCollection parent)
{
TreeNode node = new TreeNode(clazz.name)
{
Tag = clazz,
ImageKey = "data item",
SelectedImageKey = "data item"
};
parent.Add(node);
this.hideCheckBox(node);
return(node);
}
public void refresh()
{
this.ui.BusinessItems.Show <BusinessItem>(this.list <BusinessItem>(this.managedPackage));
List <DataItem> dataItems = this.list <DataItem>(this.managedPackage);
this.ui.DataItems.Show <DataItem>(dataItems);
// add all Logical DataTypes from this package and optionally others
// from the dataItems
List <FieldValue> logicalDataTypes = new List <FieldValue>();
if (this.managedPackage != null)
{
foreach (TSF_EA.Class clazz in
this.managedPackage.ownedElements.OfType <TSF_EA.Class>())
{
if (clazz.stereotypes.Count == 1)
{
if (clazz.stereotypes.ToList()[0].name == "LogicalDataType")
{
logicalDataTypes.Add(new FieldValue()
{
Key = clazz.name,
Value = clazz.guid
});
}
}
}
}
foreach (DataItem item in dataItems)
{
TSF_EA.Class element = this.model.getElementByGUID(item.LogicalDatatypeName) as TSF_EA.Class;
if (element != null && !logicalDataTypes.Any(x => x.Value == element.guid))
{
logicalDataTypes.Add(new FieldValue()
{
Key = element.name,
Value = element.guid
});
}
}
this.ui.DataItems.LogicalDataTypes = logicalDataTypes;
this.ui.ColumnLinks.DataItems = dataItems;
this.model.activateTab(appTitle);
}
private void linkColumnToDataItem()
{
// TODO: this allows for selecting/creating a new table anywhere
// currently the TreeView will only be populated with tables
// that are within the managed (gloaasry) package.
// select a table (or create a new one)
TSF_EA.Class table =
(TSF_EA.Class) this.ui.Addin.Model.getUserSelectedElement(
new List <string>()
{
"Class"
}
);
if (!table.HasStereotype("table"))
{
return;
}
// create new column on table
TSF_EA.Attribute attribute =
this.ui.Addin.Model.factory.createNewElement <TSF_EA.Attribute>(
table, "<new>"
);
attribute.AddStereotype("column");
var context = this.context;
attribute.save();
// link the column to the DataItem
attribute.addTaggedValue("EDD::dataitem", context.guid);
attribute.save();
// sync
this.sync(attribute);
this.ui.Addin.SelectedItem = context;
}
protected override void createTable(UTF_EA.Class classElement)
{
this._logicalClasses.Add(classElement);
this.table = new Table(_database, classElement.alias);
setTableSpaceName();
}
protected abstract void addTable(UTF_EA.Class classElement);
protected abstract void createTable(UTF_EA.Class classElement);
protected override void addTable(UTF_EA.Class classElement)
{
addDB2Table(classElement);
}
public Table(Database owner,Class wrappedClass)
{
this._wrappedClass = wrappedClass;
this._owner = owner;
}
public override void save()
{
if (_wrappedClass == null)
{
var databasePackage = this._owner._wrappedPackage;
if (databasePackage != null)
{
Package tablePackage = databasePackage.ownedElements.OfType<Package>()
.FirstOrDefault(x => x.name.Equals("Tables",StringComparison.InvariantCultureIgnoreCase));
Package ownerPackage = databasePackage;
if (tablePackage != null) ownerPackage = tablePackage;
_wrappedClass = this._factory._modelFactory.createNewElement<Class>(ownerPackage, this.name);
//TODO: provide wrapper function for gentype?
_wrappedClass.wrappedElement.Gentype = this.factory.databaseName;
_wrappedClass.setStereotype("table");
_wrappedClass.save();
//add trace relation to logical class(ses)
setTracesToLogicalClasses();
}
else
{
throw new Exception(string.Format("cannot save {0} because wrapped pacakge for database {1} does not exist",this.name, this.databaseOwner.name));
}
}
}
