/// <summary>
/// a package can be published if it's stereotype is present in the list of allowed stereotypes in the settings
/// </summary>
/// <param name="package">the package to publish</param>
/// <returns>whether or not a package can be published</returns>
private bool canBePublished(UML.Classes.Kernel.Package package)
{
return(package != null &&
package.stereotypes.Any
(x => this.settings.imvertorStereotypes.Any
(y => y.Equals(x.name, StringComparison.InvariantCultureIgnoreCase))));
}
/// <summary>
/// Creates a new message subset from the given schema in the given targetPackage
/// </summary>
/// <param name="schema">the Schema to generate a message subset from</param>
/// <param name="targetPackage">the Package to create the new Message subset in</param>
private void createNewMessageSubset(Schema schema, UML.Classes.Kernel.Package targetPackage)
{
//log progress
EAOutputLogger.clearLog(this.EAModel, this.settings.outputName);
EAOutputLogger.log(this.EAModel, this.settings.outputName
, string.Format("{0} Starting creation of new subset for schema '{1}' in package '{2}'"
, DateTime.Now.ToLongTimeString()
, schema.name
, targetPackage.name)
, ((TSF_EA.ElementWrapper)targetPackage).id
, LogTypeEnum.log);
if (targetPackage != null)
{
//Logger.log("before ECDMMessageComposerAddin::schema.createSubsetModel");
//Todo create global setting
bool copyDataType = this.settings.copyDataTypes;
List <String> datatypesToCopy = null;
if (copyDataType && this.settings.limitDataTypes)
{
datatypesToCopy = this.settings.dataTypesToCopy;
}
schema.createSubsetModel(targetPackage, schema.elements);
this.createNewSubsetDiagram(schema, targetPackage);
}
//log progress
EAOutputLogger.log(this.EAModel, this.settings.outputName
, string.Format("{0} Finished creation of new subset for schema '{1}' in package '{2}'"
, DateTime.Now.ToLongTimeString()
, schema.name
, targetPackage.name)
, ((TSF_EA.ElementWrapper)targetPackage).id
, LogTypeEnum.log);
}
private string createSpecificPropertiesFile(UML.Classes.Kernel.Package projectPackage)
{
string propertiesContent = this.getDefaultPropertiesFileContent();
//add application name
propertiesContent += Environment.NewLine + "application = " + this.sourcePackage.name;
if (projectPackage != null)
{
var nameparts = projectPackage.name.Split(':');
if (nameparts.Count() >= 2)
{
string ownerName = nameparts[0].Trim();
string projectName = nameparts[1].Trim();
//add owner name
if (ownerName.Length > 0)
{
propertiesContent += Environment.NewLine + "owner = " + ownerName;
}
if (projectName.Length > 0)
{
propertiesContent += Environment.NewLine + "project = " + projectName;
}
}
}
//create file
string tempFilePath = Path.GetTempFileName();
File.WriteAllText(tempFilePath, propertiesContent);
return(tempFilePath);
}
/// <summary>
/// returns all databases under this package and the one above
/// </summary>
/// <param name="package">the package to start from</param>
/// <returns>all databases under the given package or above it</returns>
private List <DB.Database> getDatabases(UML.Classes.Kernel.Package package)
{
var foundDatabases = new List <DB.Database>();
//return empty list if package null
if (package == null)
{
return(foundDatabases);
}
var databasePackages = new List <UML.Classes.Kernel.Package>();
//first get the «database» packages from the selected package
databasePackages.AddRange(package.getNestedPackageTree(true));
//then add the parent package(s)
databasePackages.AddRange(package.getAllOwners().OfType <UML.Classes.Kernel.Package>());
foreach (TSF_EA.Package databasePackage in databasePackages.Where(x => x.stereotypes.Any(y => y.name.ToLower() == "database")))
{
string databaseType = databasePackage.taggedValues.FirstOrDefault(x => x.name.ToLower() == "dbms")?.tagValue.ToString();
if (!string.IsNullOrEmpty(databaseType))
{
var dbFactory = DB_EA.DatabaseFactory.getFactory(databaseType, this.model, new DB_EA.Strategy.StrategyFactory());
foundDatabases.Add(dbFactory.createDataBase(databasePackage));
}
}
return(foundDatabases);
}
/// <summary>
/// If a user selects any of the outputs listed by the Add-in, this function will be invoked.
/// The function receives the Schema Composer automation interface, which can be used to traverse the schema.
/// </summary>
/// <param name="Repository"></param>
/// <param name="composer"></param>
public override void EA_GenerateFromSchema(EA.Repository Repository, EA.SchemaComposer composer, string exports)
{
try
{
Schema schema = this.schemaFactory.createSchema(composer, this.settings);
UML.Classes.Kernel.Package targetPackage = null;
if (this.settings.generateToArtifactPackage)
{
targetPackage = schema.containerElement?.owningPackage;
}
if (targetPackage == null)
{
targetPackage = this.model.getUserSelectedPackage() as UML.Classes.Kernel.Package;
}
if (targetPackage != null)
{
Cursor.Current = Cursors.WaitCursor;
bool writable = true;
//check if package is writable
if (this.settings.checkSecurity)
{
writable = targetPackage.isCompletelyWritable;
if (!writable)
{
DialogResult lockPackageResponse = MessageBox.Show("Package is read-only" + Environment.NewLine + "Would you like to lock the package?"
, "Lock target Package?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
//lock the elements immediately
if (lockPackageResponse == DialogResult.Yes)
{
writable = makeCompletelyWritable(targetPackage);
if (!writable)
{
//if not writable then inform user and stop further processing;
MessageBox.Show("Target package could not be locked", "Target Read-Only", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
//only proceed if target package is writable
if (writable)
{
//check if the already contains classes
DialogResult response = DialogResult.No;
response = MessageBox.Show($"Are you sure you want to generate the subset to package '{targetPackage.name}'?"
, "Generate Subset?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (response == DialogResult.Yes)
{
this.updateMessageSubset(schema, targetPackage);
}
}
Cursor.Current = Cursors.Default;
}
}
catch (Exception e)
{
processException(e);
}
}
private void publish(UML.Classes.Kernel.Package selectedPackage, EAImvertorJobSettings jobSettings)
{
//somebody called the imvertor, we can show the control
this._imvertorCalled = true;
var imvertorJob = new EAImvertorJob(selectedPackage, jobSettings);
this.startJob(imvertorJob);
}
public Domain(UML.Classes.Kernel.Package businessItemsPackage, UML.Classes.Kernel.Package businessItemsTopLevelPackage
, UML.Classes.Kernel.Package dataItemsPackage, UML.Classes.Kernel.Package dataItemsTopLevelPackage)
{
this.businessItemsPackage = businessItemsPackage;
this.businessItemsTopLevelPackage = businessItemsTopLevelPackage;
this.dataItemsPackage = dataItemsPackage;
this.dataItemsTopLevelPackage = dataItemsTopLevelPackage;
}
private void publish(UML.Classes.Kernel.Package selectedPackage)
{
EAImvertorJobSettings jobSettings = new EAImvertorJobSettings(this.settings);
if (new ImvertorStartJobForm(jobSettings).ShowDialog(this.model.mainEAWindow) == DialogResult.OK)
{
publish(selectedPackage, jobSettings);
}
}
/// <summary>
/// updates an existing message subset for a schema
/// </summary>
/// <param name="schema">the schema to use as basis</param>
/// <param name="messageElement">the root element of the subset</param>
private void updateMessageSubset(Schema schema, UML.Classes.Kernel.Package targetPackage)
{
//log progress
var startTime = DateTime.Now;
EAOutputLogger.clearLog(this.EAModel, this.settings.outputName);
EAOutputLogger.log(this.EAModel, this.settings.outputName
, $"{startTime.ToLongTimeString()} Starting update of existing subset for schema '{schema.name}' in package '{targetPackage.name}'"
, ((TSF_EA.ElementWrapper)targetPackage).id
, LogTypeEnum.log);
bool copyDataType = this.settings.copyDataTypes;
List <String> datatypesToCopy = null;
if (copyDataType && this.settings.limitDataTypes)
{
datatypesToCopy = this.settings.dataTypesToCopy;
}
bool useMessage = false;
if (!this.settings.usePackageSchemasOnly)
{
//check if we have a message element to folow
var messageElement = targetPackage.ownedElements.OfType <UML.Classes.Kernel.Classifier>().FirstOrDefault();
if (messageElement != null)
{
useMessage = true;
schema.updateSubsetModel(messageElement);
}
}
if (this.settings.usePackageSchemasOnly || !useMessage)
{
schema.updateSubsetModel(targetPackage);
}
if (this.settings.generateDiagram)
{
var subsetDiagrams = targetPackage.ownedDiagrams;
if (subsetDiagrams.Count > 0)
{
//if there are existing diagram then we update the existing diagrams
this.updateExistingDiagrams(schema, subsetDiagrams);
}
else
{
//if not we create a new diagram
this.createNewSubsetDiagram(schema, targetPackage);
}
}
//log progress
var endTime = DateTime.Now;
var processingTime = (endTime - startTime).TotalSeconds;
EAOutputLogger.log(this.EAModel, this.settings.outputName
, $"{endTime.ToLongTimeString()} Finished update of existing subset for schema '{schema.name}' in package '{targetPackage.name}' in {processingTime.ToString("N0")} seconds"
, ((TSF_EA.Package)targetPackage).id
, LogTypeEnum.log);
}
public T addNew <T>(UML.Classes.Kernel.Package ownerPackage) where T : GlossaryItem, new()
{
var wrappedClass = ((TSF_EA.Package)ownerPackage).addOwnedElement <TSF_EA.Class>(string.Empty);
var stereotype = new T().Stereotype;
wrappedClass.setStereotype(stereotype);
wrappedClass.name = stereotype + "1";
return(CreateFrom <T>(wrappedClass));
}
/// <summary>
/// updates an existing message subset for a schema
/// </summary>
/// <param name="schema">the schema to use as basis</param>
/// <param name="messageElement">the root element of the subset</param>
private void updateMessageSubset(Schema schema, UML.Classes.Kernel.Package targetPackage)
{
//log progress
EAOutputLogger.clearLog(this.EAModel, this.settings.outputName);
EAOutputLogger.log(this.EAModel, this.settings.outputName
, string.Format("{0} Starting update of existing subset for schema '{1}' in package '{2}'"
, DateTime.Now.ToLongTimeString()
, schema.name
, targetPackage.name)
, ((UTF_EA.ElementWrapper)targetPackage).id
, LogTypeEnum.log);
bool copyDataType = this.settings.copyDataTypes;
List <String> datatypesToCopy = null;
if (copyDataType && this.settings.limitDataTypes)
{
datatypesToCopy = this.settings.dataTypesToCopy;
}
bool useMessage = false;
if (!settings.usePackageSchemasOnly)
{
//check if we have a message element to folow
var messageElement = targetPackage.ownedElements.OfType <UML.Classes.Kernel.Classifier>().FirstOrDefault();
if (messageElement != null)
{
useMessage = true;
schema.updateSubsetModel(messageElement);
}
}
if (settings.usePackageSchemasOnly || !useMessage)
{
schema.updateSubsetModel(targetPackage);
}
var subsetDiagrams = targetPackage.ownedDiagrams;
if (subsetDiagrams.Count > 0)
{
//if there are existing diagram then we update the existing diagrams
updateExistingDiagrams(schema, subsetDiagrams);
}
else
{
//if not we create a new diagram
createNewSubsetDiagram(schema, targetPackage);
}
//log progress
EAOutputLogger.log(this.EAModel, this.settings.outputName
, string.Format("{0} Finished update of existing subset for schema '{1}' in package '{2}'"
, DateTime.Now.ToLongTimeString()
, schema.name
, targetPackage.name)
, ((UTF_EA.Package)targetPackage).id
, LogTypeEnum.log);
}
public virtual DatabaseFramework.Database transformLogicalPackage(UML.Classes.Kernel.Package logicalPackage)
{
this.logicalPackage = logicalPackage;
createNewDatabase();
//first create all tables
this.createTables();
//return the database
return(newDatabase);
}
/// <summary>
/// a package can be published if it's stereotype is present in the list of allowed stereotypes in the settings
/// </summary>
/// <param name="package">the package to publish</param>
/// <returns>whether or not a package can be published</returns>
private bool canBePublished(UML.Classes.Kernel.Package package)
{
return(package != null &&
(package.stereotypes.Any
(x => this.settings.imvertorStereotypes.Any
(y => y.Equals(x.name, StringComparison.InvariantCultureIgnoreCase))) ||
package.taggedValues.Any(x => "imvertor".Equals(x.name, StringComparison.InvariantCultureIgnoreCase) &&
"model".Equals(x.tagValue.ToString(), StringComparison.InvariantCultureIgnoreCase))) &&
EAImvertorJob.getProjectPackage(package) != null);
}
private List <UML.Classes.Kernel.Package> getDomains(UML.Classes.Kernel.Package domainPackage)
{
var domains = new List <UML.Classes.Kernel.Package>();
domains.Add(domainPackage);
if (domainPackage.owningPackage != null && !domainPackage.owningPackage.Equals(this.settings.businessItemsPackage))
{
domains.AddRange(getDomains(domainPackage.owningPackage));
}
return(domains);
}
/// <summary>
/// create a new subsetdiagram that will visualize the whole schema
/// </summary>
/// <param name="schema">the schema to visualize</param>
/// <param name="targetPackage">the package where the new diagram should be created.</param>
void createNewSubsetDiagram(Schema schema, UML.Classes.Kernel.Package targetPackage)
{
if (targetPackage != null)
{
//Logger.log("after ECDMMessageComposerAddin::schema.createSubsetModel");
// then make a diagram and put the subset on it
UML.Diagrams.ClassDiagram subsetDiagram = this.model.factory.createNewDiagram <UML.Diagrams.ClassDiagram>(targetPackage, targetPackage.name);
subsetDiagram.save();
//Logger.log("after ECDMMessageComposerAddin::create subsetDiagram");
//put the subset elements on the new diagram
foreach (SchemaElement schemaElement in schema.elements)
{
if (this.shouldElementBeOnDiagram(schemaElement.subsetElement))
{
subsetDiagram.addToDiagram(schemaElement.subsetElement);
}
bool addSourceElement = false;
//check the settings to see if we need to add the source element
if (schemaElement.sourceElement is UML.Classes.Kernel.Class ||
schemaElement.sourceElement is UML.Classes.Kernel.Enumeration)
{
addSourceElement = this.settings.addSourceElements;
}
else
{
//or the datatype
if (schemaElement.subsetElement != null)
{
addSourceElement = this.settings.addSourceElements;
}
else
{
addSourceElement = this.settings.addDataTypes;
}
}
//add source element to the diagram if needed
if (addSourceElement &&
this.shouldElementBeOnDiagram(schemaElement.sourceElement))
{
//we add the source element if the subset element doesn't exist.
subsetDiagram.addToDiagram(schemaElement.sourceElement);
}
}
//Logger.log("after ECDMMessageComposerAddin::adding elements");
//layout the diagram (this will open the diagram as well)
subsetDiagram.autoLayout();
//Logger.log("after ECDMMessageComposerAddin::autolayout");
}
}
/// <summary>
/// save the target package in a tagged value on the schema container element
/// </summary>
/// <param name="schema"></param>
/// <param name="package"></param>
private void saveTargetPackageTag(Schema schema, UML.Classes.Kernel.Package targetPackage)
{
if (schema.containerElement != null)
{
if (schema.containerElement.isReadOnly)
{
schema.containerElement.makeWritable(false);
}
if (!schema.containerElement.isReadOnly)
{
((TSF_EA.ElementWrapper)schema.containerElement).addTaggedValue(targetPackageTagName, targetPackage.uniqueID);
}
}
}
public static List <Domain> getAllDomains(UML.Classes.Kernel.Package businessItemsTopLevelPackage, UML.Classes.Kernel.Package dataItemsTopLevelPackage)
{
if (alldomains == null)
{
alldomains = new Dictionary <string, Domain>();
}
//clear domains
alldomains.Clear();
//recreate them
if (businessItemsTopLevelPackage != null)
{
foreach (var domainPackage in businessItemsTopLevelPackage.nestedPackages)
{
var currentDomain = new Domain(domainPackage, businessItemsTopLevelPackage, null, dataItemsTopLevelPackage);
alldomains[currentDomain.uniqueID] = currentDomain;
currentDomain.getAllSubdomains().ForEach(x => alldomains[x.uniqueID] = x);
}
}
if (dataItemsTopLevelPackage != null)
{
foreach (var domainPackage in dataItemsTopLevelPackage.nestedPackages)
{
//check if domain like this exists
var currentDomain = new Domain(null, businessItemsTopLevelPackage, domainPackage, dataItemsTopLevelPackage);
var correspondingDomain = alldomains.Values.FirstOrDefault(x => x.domainPath == currentDomain.domainPath);
if (correspondingDomain != null)
{
correspondingDomain.dataItemsPackage = domainPackage;
}
else
{
alldomains[currentDomain.uniqueID] = currentDomain;
}
foreach (var subdomain in currentDomain.getAllSubdomains())
{
var correspondingSubDomain = alldomains.Values.FirstOrDefault(x => x.domainPath == subdomain.domainPath);
if (correspondingSubDomain != null)
{
correspondingSubDomain.dataItemsPackage = subdomain.dataItemsPackage;
}
else
{
alldomains[subdomain.uniqueID] = subdomain;
}
}
}
}
return(alldomains.Values.ToList());
}
public static UML.Classes.Kernel.Package getProjectPackage(UML.Classes.Kernel.Package startingPackage)
{
if (startingPackage.owningPackage == null)
{
return(null);
}
if (startingPackage.owningPackage.stereotypes.Any(x => x.name.Equals("project", StringComparison.InvariantCultureIgnoreCase)))
{
return(startingPackage.owningPackage);
}
else
{
return(getProjectPackage(startingPackage.owningPackage));
}
}
private BusinessItem addNewBusinessItem()
{
UML.Classes.Kernel.Package package = this.mainControl.selectedDomain != null
? this.mainControl.selectedDomain.businessItemsPackage
: this.settings.businessItemsPackage;
if (package == null &&
this.mainControl.selectedDomain != null)
{
//add the missing package
this.mainControl.selectedDomain.createMissingPackage();
package = this.mainControl.selectedDomain.businessItemsPackage;
}
var newBusinessItem = this.factory.addNew <BusinessItem>(package);
return(newBusinessItem);
}
public static Domain getDomain(UML.Classes.Kernel.Package package)
{
Domain foundDomain = null;
if (package != null)
{
//first look on unique id
foundDomain = alldomains.ContainsKey(package.uniqueID) ? alldomains[package.uniqueID] : null;
// then check the dataItemsPackage
if (foundDomain == null)
{
foundDomain = alldomains.Values.FirstOrDefault(x => x.dataItemsPackage?.uniqueID == package?.uniqueID);
}
}
return(foundDomain);
}
/// <summary>
/// Creates a new message subset from the given schema in the given targetPackage
/// </summary>
/// <param name="schema">the Schema to generate a message subset from</param>
/// <param name="targetPackage">the Package to create the new Message subset in</param>
private void createNewMessageSubset(Schema schema, UML.Classes.Kernel.Package targetPackage)
{
if (targetPackage != null)
{
//Logger.log("before ECDMMessageComposerAddin::schema.createSubsetModel");
//Todo create global setting
bool copyDataType = this.settings.copyDataTypes;
List <String> datatypesToCopy = null;
if (copyDataType && this.settings.limitDataTypes)
{
datatypesToCopy = this.settings.dataTypesToCopy;
}
schema.createSubsetModel(targetPackage);
createNewSubsetDiagram(schema, targetPackage);
}
}
/// <summary>
/// returns all owned workitems for this package and if requested for all owned packages recursively
/// </summary>
/// <param name="ownerPackage">the owner package</param>
/// <param name="recursive">indicates whether or not we should recursively search workitems in owned packages</param>
/// <returns>a list of owned workitems for the given package</returns>
public override List <WT.Workitem> getOwnedWorkitems(UML.Classes.Kernel.Package ownerPackage, bool recursive)
{
List <WT.Workitem> foundWorkItems = new List <WT.Workitem>();
var elementTypes = settings.mappedElementTypes;
var stereotypes = settings.mappedStereotypes;
string elementTypeClause = "o.Object_Type in ('" + string.Join("','", elementTypes) + "')";
string stereotypeClause = "o.Stereotype in ('" + string.Join("','", stereotypes) + "')";
string getWorkitemsSQL = @"select o.Object_ID from t_object o
where o.Package_ID =" + ((Package)ownerPackage).packageID;
if (elementTypes.Count > 0)
{
if (stereotypes.Count > 0)
{
getWorkitemsSQL += " and ( " + elementTypeClause;
getWorkitemsSQL += " or " + stereotypeClause + ")";
}
else
{
getWorkitemsSQL += " and " + elementTypeClause;
}
}
else
{
if (stereotypes.Count > 0)
{
getWorkitemsSQL += " and " + stereotypeClause;
}
}
//add the direct owned workitems
foreach (var workitemElement in ((Package)ownerPackage).model.getElementWrappersByQuery(getWorkitemsSQL))
{
foundWorkItems.Add(new TFSWorkItem(this, workitemElement));
}
//recurse owned packages
if (recursive)
{
foreach (var ownedPackage in ownerPackage.ownedElements.OfType <Package>())
{
foundWorkItems.AddRange(getOwnedWorkitems(ownedPackage, recursive));
}
}
return(foundWorkItems);
}
//public void startJob(string imvertorURL, string pincode,string processName ,string imvertorProperties,string imvertorPropertiesFilePath, string imvertorHistoryFilePath)
public void startJob(BackgroundWorker backgroundWorker)
{
this._startDateTime = DateTime.Now;
this._backgroundWorker = backgroundWorker;
//UML.Classes.Kernel.Package projectPackage = getProjectPackage(this.sourcePackage); //export only the source package
UML.Classes.Kernel.Package projectPackage = this.sourcePackage;
if (projectPackage != null)
{
//create the specific properties for this job
this.settings.PropertiesFilePath = createSpecificPropertiesFile(projectPackage);
string xmiFileName = Path.ChangeExtension(Path.GetTempFileName(), ".xmi");
this.setStatus("Exporting Model");
projectPackage.exportToXMI(xmiFileName);
//TODO: export diagram and add them to the zip file
//projectPackage.exportAllDiagrams(@"C:\temp\testImages\");
this.setStatus("Compressing File");
if (File.Exists(xmiFileName))
{
xmiFileName = CompressFile(xmiFileName);
this.setStatus("Uploading Model");
try {
this._jobID = this.Upload(settings.imvertorURL + settings.urlPostFix + "upload", settings.PIN, settings.ProcessName, settings.Properties
, xmiFileName, settings.HistoryFilePath, settings.PropertiesFilePath);
this.setStatus("Upload Finished");
getJobReport();
} catch (Exception e)
{
this.setStatus("Error");
Logger.logError("Error in StartJob: " + e.Message + " stacktrace: " + e.StackTrace);
}
}
else
{
this.setStatus("Cancelled");
}
}
else
{
this.setStatus("Error");
Logger.logError("no «project» package found");
}
}
private void _mainControl_newButtonClick(object sender, EventArgs e)
{
switch (this.mainControl.selectedTab)
{
case GlossaryTab.BusinessItems:
UML.Classes.Kernel.Package package = this.mainControl.selectedDomain != null
? this.mainControl.selectedDomain.businessItemsPackage
: this.settings.businessItemsPackage;
if (package == null &&
this.mainControl.selectedDomain != null)
{
//add the missing package
this.mainControl.selectedDomain.createMissingPackage();
package = this.mainControl.selectedDomain.businessItemsPackage;
}
var newBusinessItem = this.factory.addNew <BusinessItem>(package);
this.mainControl.addItem(newBusinessItem);
break;
case GlossaryTab.DataItems:
package = this.mainControl.selectedDomain != null
? this.mainControl.selectedDomain.dataItemsPackage
: this.settings.dataItemsPackage;
if (package == null &&
this.mainControl.selectedDomain != null)
{
//add the missing package
this.mainControl.selectedDomain.createMissingPackage();
package = this.mainControl.selectedDomain.dataItemsPackage;
}
var newDataItem = this.factory.addNew <DataItem>(package);
this.mainControl.addItem(newDataItem);
break;
case GlossaryTab.Columns:
//TODO
break;
}
}
private void publish(UML.Classes.Kernel.Package selectedPackage, EAImvertorJobSettings jobSettings)
{
//somebody called the imvertor, we can show the control
this._imvertorCalled = true;
//create new backgroundWorker
var imvertorJobBackgroundWorker = new BackgroundWorker();
//imvertorJobBackgroundWorker.WorkerSupportsCancellation = true; //TODO: implement cancellation
imvertorJobBackgroundWorker.WorkerReportsProgress = true;
imvertorJobBackgroundWorker.DoWork += imvertorBackground_DoWork;
imvertorJobBackgroundWorker.ProgressChanged += imvertorBackground_ProgressChanged;
imvertorJobBackgroundWorker.RunWorkerCompleted += imvertorBackgroundRunWorkerCompleted;
var imvertorJob = new EAImvertorJob(selectedPackage, jobSettings);
//update gui
this.imvertorControl.addJob(imvertorJob);
//show the control
this.model.showWindow(windowName);
//start job in the background
imvertorJobBackgroundWorker.RunWorkerAsync(imvertorJob);
}
private MappingFramework.MappingSet getCurrentMappingSet(UML.Classes.Kernel.Package package)
{
return(new EA_MP.PackageMappingSet((TSF_EA.Package)package));
}
public EAImvertorJob(UML.Classes.Kernel.Package package, EAImvertorJobSettings settings)
{
this._sourcePackage = package;
this._settings = settings;
this._status = "Created";
}
public EAImvertorJob(UML.Classes.Kernel.Package package, EAImvertorJobSettings settings)
{
this._sourcePackage = package;
this._settings = settings;
this._status = "Created";
}
/// <summary>
/// If a user selects any of the outputs listed by the Add-in, this function will be invoked.
/// The function receives the Schema Composer automation interface, which can be used to traverse the schema.
/// </summary>
/// <param name="Repository"></param>
/// <param name="composer"></param>
public override void EA_GenerateFromSchema(EA.Repository Repository, EA.SchemaComposer composer, string exports)
{
try
{
Schema schema = this.schemaFactory.createSchema(composer, this.settings);
UML.Classes.Kernel.Package targetPackage = null;
if (this.settings.generateToArtifactPackage)
{
targetPackage = schema.containerElement?.owningPackage;
}
else
{
var targetPackageTag = schema.containerElement?.taggedValues.FirstOrDefault(x => x.name == targetPackageTagName);
if (targetPackageTag != null)
{
targetPackage = targetPackageTag?.tagValue as UML.Classes.Kernel.Package;
}
}
if (targetPackage == null)
{
targetPackage = this.model.getUserSelectedPackage() as UML.Classes.Kernel.Package;
}
if (targetPackage != null)
{
//save target package as tagged value on schema artifact
if (!this.settings.generateToArtifactPackage)
{
this.saveTargetPackageTag(schema, targetPackage);
}
Cursor.Current = Cursors.WaitCursor;
bool writable = true;
//check if package is writable
if (this.settings.checkSecurity)
{
writable = targetPackage.isCompletelyWritable;
if (!writable)
{
var lockPackageResponse = MessageBox.Show("Package is read-only" + Environment.NewLine + "Would you like to lock the package?"
, "Lock target Package?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
//lock the elements immediately
if (lockPackageResponse == DialogResult.Yes)
{
writable = this.makeCompletelyWritable(targetPackage);
if (!writable)
{
//if not writable then inform user and stop further processing;
MessageBox.Show("Target package could not be locked", "Target Read-Only", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
//only proceed if target package is writable
if (writable)
{
//check if the already contains classes
var response = DialogResult.No;
response = MessageBox.Show($"Are you sure you want to generate the subset to package '{targetPackage.name}'?"
, "Generate Subset?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (response == DialogResult.Yes)
{
if (this.EAModel.EAVersion >= 1308)
{
//disable ui updates to speed up process. Only for v13 or higher
this.EAModel.wrappedModel.EnableUIUpdates = false;
}
//update the subset
this.updateMessageSubset(schema, targetPackage);
//refresh package to make changes visible Only for v13 or higher
if (this.EAModel.EAVersion >= 1308)
{
targetPackage.refresh();
}
//check for any errors or warnings
var errorCount = EAOutputLogger.getErrors(this.EAModel, this.settings.outputName).Count();
var warningCount = EAOutputLogger.getWarnings(this.EAModel, this.settings.outputName).Count();
if (errorCount > 0 || warningCount > 0)
{
MessageBox.Show(this.EAModel.mainEAWindow, $"Generation resulted in {errorCount} errors and {warningCount} warnings.\nPlease check the output log"
, "Errors or Warnings!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
Cursor.Current = Cursors.Default;
}
}
catch (Exception e)
{
processException(e);
}
finally
{
if (this.EAModel.EAVersion >= 1308)
{
//re-enable gui updates. Only for V13 or higher
this.EAModel.wrappedModel.EnableUIUpdates = true;
}
}
}
/// <summary>
/// Writes the IL declarations for a packages standard properties.
/// </summary>
/// <param name="package">The UML model package instance that declares the properties to generate.</param>
/// <returns>The TransformationILWriter instance for use in concatenated output.</returns>
public TransformationILWriter WriteStdPackageProperties(UML.Classes.Kernel.Package package)
{
WriteILProperty("name", package.name);
//WriteILProperty( levelIndent,"language","C++");
return(this);
}
/// <summary> /// returns all owned workitems for this package and if requested for all owned packages recursively /// </summary> /// <param name="ownerPackage">the owner package</param> /// <param name="recursive">indicates whether or not we should recursively search workitems in owned packages</param> /// <returns>a list of owned workitems for the given package</returns> public abstract List <WT.Workitem> getOwnedWorkitems(UML.Classes.Kernel.Package ownerPackage, bool recursive);
