protected override void saveMe() { //create the _wrapped attribute if needed if (_wrappedattribute == null) { if (this._ownerTable._wrappedClass == null) { this.ownerTable.save(); } //now the wrappedClass should exist. if not then we have a problem this._wrappedattribute = this.factory.modelFactory.createNewElement <TSF_EA.Attribute>(this._ownerTable._wrappedClass, this.name); if (this.isNotNullable && this.ownerTable.primaryKey != null && this.ownerTable.primaryKey.involvedColumns.Contains(this)) { //not nullable columns that are not part of a Primary key get "DEFAULT" as default value, which results in "WITH DEFAULT" in the DDL this.initialValue = "DEFAULT"; //TODO: find a better way to define "DEFAULT" instead of hardcoding. } } if (_wrappedattribute != null) { //set steretotype this._wrappedattribute.setStereotype("column"); //set datatype; _wrappedattribute.type = this.factory.modelFactory.createPrimitiveType(this.type.name); if (this.type.type.hasPrecision) { _wrappedattribute.precision = this.type.length; _wrappedattribute.scale = this.type.precision; } else { _wrappedattribute.length = this.type.length; } //is not nullable this.isNotNullable = this.isNotNullable; //set position this.position = this.position; // InitialValue this.initialValue = this.initialValue; //save _wrappedattribute.save(); //following properties are saved as tagged values so need to be set after saving the wrapped atttribute //set isOverridden this.isOverridden = this.isOverridden; //set renamed this.isRenamed = this.isRenamed; //logical attribute tag value if (traceTaggedValue == null) { createTraceTaggedValue(); } } //save the columnn name in the alias if (logicalAttribute != null) { logicalAttribute.save(); } }
protected override Column transformLogicalAttribute(UTF_EA.Attribute attribute) { var columnTransformer = new DB2ColumnTransformer(this._table, this._nameTranslator); this._columnTransformers.Add(columnTransformer); return((Column)columnTransformer.transformLogicalProperty(attribute)); }
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); }
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); }
protected override void updateDetails(DB.DatabaseItem newDatabaseItem) { var newColumn = (Column)newDatabaseItem; this._isNotNullable = newColumn.isNotNullable; this._logicalAttribute = newColumn.logicalAttribute; this._type = newColumn._type; this.isOverridden = newColumn.isOverridden; }
private Column transformLogicalAttribute(UTF_EA.Attribute attribute) { bool isEqualDirty = false; //first translate the columname if needed if (string.IsNullOrEmpty(attribute.alias)) { attribute.alias = this._nameTranslator.translate(attribute.name, attribute.owner.name); isEqualDirty = true; //should we save here? } this.column = new Column(this._table, attribute.alias); this.column.isEqualDirty = isEqualDirty; //get base type var attributeType = attribute.type as UTF_EA.ElementWrapper; if (attributeType == null) { Logger.logError(string.Format("Attribute {0}.{1} does not have a element as datatype" , attribute.owner.name, attribute.name)); } else { DataType datatype = _table._owner._factory.createDataType(attributeType.alias); if (datatype == null) { Logger.logError(string.Format("Could not find {0} as Datatype for attribute {1}.{2}" , attributeType.alias, attribute.owner.name, attribute.name)); } else { column.type = datatype; } } //set not null property if (attribute.lower == 0) { column.isNotNullable = false; } else { column.isNotNullable = true; } //set inital value if (attribute.defaultValue != null && !string.IsNullOrEmpty(attribute.defaultValue.ToString())) { this.column.initialValue = attribute.defaultValue.ToString(); } //set position this.column.position = attribute.position; return(this._column); }
// adds an empty column and selects it. user can now select a Data Item. // because of magic values in de new empty column, validation will not only // validate, but also immediately perform a sync private void addEmptyColumn() { TSF_EA.Attribute attribute = this.ui.Addin.Model.factory.createNewElement <TSF_EA.Attribute>( this.context, "<new>" ); attribute.AddStereotype("column"); attribute.save(); this.context.save(); this.refreshTree(); this.selectNewColumn(); }
protected override void updateDetails(DB.DatabaseItem newDatabaseItem) { var newColumn = (Column)newDatabaseItem; this._isNotNullable = newColumn.isNotNullable; this._logicalAttribute = newColumn.logicalAttribute; this._type = newColumn._type; this.isOverridden = newColumn.isOverridden; this.isRenamed = newColumn.isRenamed; this.position = newColumn.position; this.initialValue = newColumn.initialValue; }
public override void save() { //create the _wrapped attribute if needed if (_wrappedattribute == null) { if (this._ownerTable._wrappedClass == null) { this.ownerTable.save(); } //now the wrappedClass should exist. if not then we have a problem this._wrappedattribute = this.factory.modelFactory.createNewElement <TSF_EA.Attribute>(this._ownerTable._wrappedClass, this.name); } if (_wrappedattribute != null) { //set steretotype this._wrappedattribute.setStereotype("column"); //set datatype; _wrappedattribute.type = this.factory.modelFactory.createPrimitiveType(this.type.name); if (this.type.type.hasPrecision) { _wrappedattribute.precision = this.type.length; _wrappedattribute.scale = this.type.precision; } else { _wrappedattribute.length = this.type.length; } //is not nullable this.isNotNullable = this.isNotNullable; //set position this.position = this.position; // InitialValue this.initialValue = this.initialValue; //save _wrappedattribute.save(); //following properties are saved as tagged values so need to be set after saving the wrapped atttribute //set isOverridden this.isOverridden = this.isOverridden; //set renamed this.isRenamed = this.isRenamed; //logical attribute tag value if (traceTaggedValue == null) { createTraceTaggedValue(); } } //save the columnn name in the alias if (logicalAttribute != null) { logicalAttribute.save(); } }
private TreeNode createColumnNode(TSF_EA.Attribute attribute, TreeNodeCollection parent) { TreeNode node = new TreeNode(attribute.name) { Tag = attribute, ImageKey = "column", SelectedImageKey = "column" }; parent.Add(node); return(node); }
private DataItem getDataItem(TSF_EA.Attribute attribute) { if (attribute == null) { return(null); } TSF_EA.TaggedValue tv = attribute.getTaggedValue("EDD::dataitem"); if (tv == null || tv.tagValue == null) { return(null); } return(GlossaryItemFactory <DataItem> .FromClass(tv.tagValue as TSF_EA.Class)); }
public static DB_EA.Column createColumn(TSF_EA.Attribute attribute) { //create the table var tableElement = attribute.owner as Class; if (tableElement == null) { return(null); } var table = createTable(tableElement); if (table == null) { return(null); } //create the column return(new Column(table, attribute)); }
private void sync(TSF_EA.Attribute column) { DataItem di = this.getDataItem(column); column.name = di.Label; // TODO DataType column.length = di.Size; // TODO Format // TODO ValueSpecification column.defaultValue = this.ui.Addin.Model.factory.createValueSpecificationFromString( di.InitialValue ); var context = this.context; column.save(); this.ui.Addin.SelectedItem = context; this.refreshTree(); }
/// <summary> /// finds the corresponding Schema property for the given attribut /// </summary> /// <param name="attribute">attribute</param> /// <returns>the corresponding Schema property if one is found. Else null</returns> public EASchemaProperty getMatchingSchemaProperty(UTF_EA.Attribute attribute) { EASchemaProperty result = null; var sourceAttributeTag = attribute.getTaggedValue(this.owner.settings.sourceAttributeTagName); if (sourceAttributeTag != null) { string tagReference = sourceAttributeTag.eaStringValue; foreach (EASchemaProperty property in this.schemaProperties) { //we have the same attribute if the given attribute has a tagged value //called sourceAttribute that refences the source attribute of the schema Property if (((UTF_EA.Attribute)property.sourceProperty).guid == tagReference) { result = property; break; } } } return(result); }
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; }
public override void save() { //create the _wrapped attribute if needed if (_wrappedattribute == null) { if (this._owner._wrappedClass == null) { this.ownerTable.save(); } //now the wrappedClass should exist. if not then we have a problem this._wrappedattribute = this.factory.modelFactory.createNewElement <TSF_EA.Attribute>(this._owner._wrappedClass, this.name); } if (_wrappedattribute != null) { //set steretotype this._wrappedattribute.setStereotype("column"); //set datatype; _wrappedattribute.type = this.factory.modelFactory.createPrimitiveType(this.type.name); _wrappedattribute.length = this.type.length; _wrappedattribute.precision = this.type.precision; //is not nullable this.isNotNullable = _isNotNullable; //save _wrappedattribute.save(); //set isOverridden this.isOverridden = this.isOverridden; //logical attribute tag value if (traceTaggedValue == null) { createTraceTaggedValue(); } } //save the columnn name in the alias if (logicalAttribute != null) { logicalAttribute.save(); } }
private void refreshTree() { this.prevSelection = this.Current; this.tree.SuspendLayout(); this.tree.Nodes.Clear(); if (this.ContextIsDataItem) { this.populateTreeForDataItem(); } else if (this.ContextIsTable) { this.populateTreeForTable(); } this.tree.ExpandAll(); this.tree.ResumeLayout(false); this.prevSelection = null; }
public AttributeMappingNode(TSF_EA.Attribute sourceAttribute, MappingSettings settings, MP.ModelStructure structure) : this(sourceAttribute, null, settings, structure) { }
protected override void saveMe() { //create the _wrapped attribute if needed if (_wrappedattribute == null) { if (this._ownerTable.wrappedClass == null) { this.ownerTable.save(); } //now the wrappedClass should exist. if not then we have a problem this._wrappedattribute = this.factory.modelFactory.createNewElement <TSF_EA.Attribute>(this._ownerTable.wrappedClass, this.name); if (this.logicalAttribute != null) { var attributeType = logicalAttribute.type as TSF_EA.ElementWrapper; if (attributeType != null) { //check if attributeType as any constraints var typeConstraint = attributeType.constraints.OfType <TSF_EA.Constraint>().FirstOrDefault(); if (typeConstraint != null) { //add a check constraint var checkConstraint = new CheckConstraint(this.name, this, typeConstraint.convertFromEANotes("TXT").Replace("<Column>", this.name)); //save? checkConstraint.save(); } } } } if (_wrappedattribute != null) { //set steretotype this._wrappedattribute.setStereotype("column"); //set datatype; _wrappedattribute.type = this.factory.modelFactory.createPrimitiveType(this.type.name); if (this.type.type != null && this.type.type.hasPrecision) { _wrappedattribute.precision = this.type.length; _wrappedattribute.scale = this.type.precision; } else { _wrappedattribute.length = this.type.length; } //is not nullable this.isNotNullable = this.isNotNullable; //set position this.position = this.position; // InitialValue this.initialValue = this.initialValue; //save _wrappedattribute.save(); //following properties are saved as tagged values so need to be set after saving the wrapped atttribute //set isOverridden this.isOverridden = this.isOverridden; //set renamed this.isRenamed = this.isRenamed; //logical attribute tag value if (traceTaggedValue == null) { createTraceTaggedValue(); } } //save the columnn name in the alias if (logicalAttribute != null) { logicalAttribute.save(); } }
public AttributeMappingNode(TSF_EA.Attribute sourceAttribute, ClassifierMappingNode parent, MappingSettings settings, MP.ModelStructure structure) : base(sourceAttribute, parent, settings, structure) { }
protected abstract void createColumn(UTF_EA.Attribute attribute);
public Column(Table owner, TSF_EA.Attribute attribute) { this._owner = owner; this._wrappedattribute = attribute; }
protected override void updateDetails(DB.DatabaseItem newDatabaseItem) { var newColumn = (Column)newDatabaseItem; this._isNotNullable = newColumn.isNotNullable; this._logicalAttribute = newColumn.logicalAttribute; this._type = newColumn._type; this.isOverridden = newColumn.isOverridden; this.isRenamed = newColumn.isRenamed; this.position = newColumn.position; }
public override void save() { //create the _wrapped attribute if needed if (_wrappedattribute == null) { if (this._ownerTable._wrappedClass == null) { this.ownerTable.save(); } //now the wrappedClass should exist. if not then we have a problem this._wrappedattribute = this.factory.modelFactory.createNewElement<TSF_EA.Attribute>(this._ownerTable._wrappedClass,this.name); } if (_wrappedattribute != null) { //set steretotype this._wrappedattribute.setStereotype("column"); //set datatype; _wrappedattribute.type = this.factory.modelFactory.createPrimitiveType(this.type.name); if (this.type.type.hasPrecision) { _wrappedattribute.precision = this.type.length; _wrappedattribute.scale = this.type.precision; } else { _wrappedattribute.length = this.type.length; } //is not nullable this.isNotNullable = _isNotNullable; //set position _wrappedattribute.position = _position; //save _wrappedattribute.save(); //set isOverridden this.isOverridden = this.isOverridden; //set renamed this.isRenamed = this.isRenamed; //logical attribute tag value if (traceTaggedValue == null) createTraceTaggedValue(); } //save the columnn name in the alias if (logicalAttribute != null) logicalAttribute.save(); }
public Column(Table owner, TSF_EA.Attribute attribute) { this._ownerTable = owner; this._wrappedattribute = attribute; }
public DB2ColumnTransformer(Table table, Column column, UTF_EA.Attribute attribute, NameTranslator nameTranslator) : this(table, nameTranslator) { this.logicalProperty = attribute; this.column = column; }
public Column(Table owner, TSF_EA.Attribute attribute) : base(owner.strategy.getStrategy <Column>()) { this._ownerTable = owner; this._wrappedattribute = attribute; }
protected override void createColumn(UTF_EA.Attribute attribute) { this.logicalProperty = attribute; this.column = transformLogicalAttribute(attribute); }
protected override void createColumn(UTF_EA.Attribute attribute) { //TODO: translate name to alias this.logicalProperty = attribute; this.column = transformLogicalAttribute(attribute); }
protected abstract Column transformLogicalAttribute(UTF_EA.Attribute attribute);
public override void correct() { //Log start EAOutputLogger.log(this.model, this.outputName , string.Format("{0} Starting converting embedded properties to attributes'" , DateTime.Now.ToLongTimeString()) , 0 , LogTypeEnum.log); //Start converting List <TSF_EA.ElementWrapper> properties = this.model.getElementWrappersByQuery(@"select o1.[Object_ID] from [t_object] o1 where o1.[Object_Type] = 'Part'"); foreach (TSF_EA.Property property in properties) { //Tell the user which property we are dealing with EAOutputLogger.log(this.model, this.outputName , string.Format("{0} Correcting property '{1}' with GUID '{2}'" , DateTime.Now.ToLongTimeString() , property.name , property.guid) , 0 , LogTypeEnum.log); if (!string.IsNullOrEmpty(property.name)) { //Create attribute with the name of the property TSF_EA.Attribute newAttribute = this.model.factory.createNewElement <TSF_EA.Attribute>(property.owner, property.name); if (property.classifier != null) { newAttribute.type = property.classifier; } newAttribute.multiplicity = property.multiplicity; newAttribute.save(); //Tell the user which attribute we created EAOutputLogger.log(this.model, this.outputName , string.Format("{0} Create attribute '{1}' with type '{2}'" , DateTime.Now.ToLongTimeString() , newAttribute.name , newAttribute.type) , 0 , LogTypeEnum.log); } else if (property.classifier != null) { //Create attribute with the name of the classifier TSF_EA.Attribute newAttribute = this.model.factory.createNewElement <TSF_EA.Attribute>(property.owner, property.classifier.name); newAttribute.type = property.classifier; newAttribute.multiplicity = property.multiplicity; newAttribute.save(); //Tell the user which attribute we created EAOutputLogger.log(this.model, this.outputName , string.Format("{0} Create attribute '{1}' with type '{2}'" , DateTime.Now.ToLongTimeString() , newAttribute.name , newAttribute.type) , 0 , LogTypeEnum.log); } else { //Alert the user that we couldn't create the attribute EAOutputLogger.log(this.model, this.outputName , string.Format("{0} Could not create attribute for property with id '{1}'" , DateTime.Now.ToLongTimeString() , property.guid ) , property.id , LogTypeEnum.error); //stop processing break; } //Delete property property.delete(); } //Log Finished EAOutputLogger.log(this.model, this.outputName , string.Format("{0} Finished converting embedded properties to attributes'" , DateTime.Now.ToLongTimeString()) , 0 , LogTypeEnum.log); }