/// <summary>
/// method moves diagram into target package
/// </summary>
/// <param name="Repository">EA repository</param>
/// <param name="diagramGUID">GUID of diagram that should be moved</param>
/// <param name="packageGUID">GUID of target package</param>
public void moveDiagramToPackage(EA.Repository Repository, string diagramGUID, string packageGUID)
{
EA.Package package = (EA.Package)Repository.GetPackageByGuid(packageGUID);
EA.Diagram diagram = (EA.Diagram)Repository.GetDiagramByGuid(diagramGUID);
diagram.PackageID = package.PackageID;
diagram.Update();
package.Diagrams.Refresh();
BPAddIn.synchronizationWindow.addToList("Movement of diagram '" + diagram.Name + "' to package '" +
package.Name + "'");
}
public void showObjectProperties(EA.Repository Repository, string GUID, EA.ObjectType ot)
{
eaObjectType.Text = ot.ToString();
eaObjectName.Text = "?";
switch(ot)
{
case EA.ObjectType.otAttribute:
EA.Attribute attribute = Repository.GetAttributeByGuid(GUID);
currentEaObject = attribute;
currentEaObjectCollections = null;
eaObjectName.Text = attribute.Name;
showEmbeddedObjects.Enabled = false;
showEmbeddedObjects.Checked = false;
break;
case EA.ObjectType.otElement:
EA.Element element = Repository.GetElementByGuid(GUID);
currentEaObject = element;
currentEaObjectCollections = new EAElementCollections(element);
eaObjectName.Text = element.Name;
showEmbeddedObjects.Enabled = true;
break;
case EA.ObjectType.otMethod:
EA.Method method = Repository.GetMethodByGuid(GUID);
currentEaObject = method;
currentEaObjectCollections = null;
eaObjectName.Text = method.Name;
showEmbeddedObjects.Enabled = false;
showEmbeddedObjects.Checked = false;
break;
case EA.ObjectType.otPackage:
EA.Package package = Repository.GetPackageByGuid(GUID);
currentEaObject = package;
currentEaObjectCollections = new EAPackageCollections(package);
eaObjectName.Text = package.Name;
showEmbeddedObjects.Enabled = true;
break;
case EA.ObjectType.otConnector:
EA.Connector connector = Repository.GetConnectorByGuid(GUID);
currentEaObject = connector;
currentEaObjectCollections = null;
showEmbeddedObjects.Enabled = false;
showEmbeddedObjects.Checked = false;
break;
default:
currentEaObject = null;
currentEaObjectCollections = null;
propertyGrid.SelectedObject = null;
showEmbeddedObjects.Enabled = false;
showEmbeddedObjects.Checked = false;
break;
}
SynchPropertyGridSelection();
}
public override void save(EA.Repository rep, FindAndReplaceItem.FieldType fieldType)
{
_pkg = rep.GetPackageByGuid(GUID);
if ((fieldType & FindAndReplaceItem.FieldType.Description) > 0)
{ _pkg.Notes = _Description; }
if ((fieldType & (FindAndReplaceItem.FieldType.Name | FindAndReplaceItem.FieldType.Stereotype) ) > 0)
{
// model don't have an element
if (_pkg.ParentID != 0)
{
EA.Element el = rep.GetElementByGuid(GUID);
el.StereotypeEx = _Stereotype;
el.Name = _Name;
el.Update();
}
_pkg.Name = _Name;
}
_isUpdated = true;
_pkg.Update();
}
/// <summary>
/// method moves element or package into target package
/// </summary>
/// <param name="repository">EA repository</param>
/// <param name="itemGUID">GUID of item that should be moved</param>
/// <param name="targetPackageGUID">GUID of target package</param>
/// <param name="elementType">type of element</param>
public void moveElementOrPackageToPackage(EA.Repository repository, string itemGUID, string targetPackageGUID, int elementType)
{
EA.Package targetPackage = (EA.Package)repository.GetPackageByGuid(targetPackageGUID);
if (elementType == 3)
{
EA.Package package = (EA.Package)repository.GetPackageByGuid(itemGUID);
if (package.ParentID != targetPackage.PackageID)
{
package.ParentID = targetPackage.PackageID;
package.Update();
targetPackage.Packages.Refresh();
BPAddIn.synchronizationWindow.addToList("Movement of package '" + package.Name + "' to package '" +
targetPackage.Name + "'");
}
}
else
{
EA.Element element = (EA.Element)repository.GetElementByGuid(itemGUID);
if (element.ParentID != targetPackage.PackageID)
{
element.PackageID = targetPackage.PackageID;
element.Update();
targetPackage.Elements.Refresh();
BPAddIn.synchronizationWindow.addToList("Movement of element '" + element.Name + "' to package '" +
targetPackage.Name + "'");
}
}
}
// Find the operation from Activity / State Machine
// it excludes operations in state machines
public static EA.Package GetModelDocumentFromPackage(EA.Repository rep, EA.Package pkg)
{
EA.Package pkg1 = null;
string repositoryType = "JET";// rep.RepositoryType();
// get object_ID of package
var query = @"select pkg.ea_GUID AS EA_GUID " +
@" from (((t_object o INNER JOIN t_attribute a on (o.object_ID = a.Object_ID AND a.type = 'Package')) " +
@" INNER JOIN t_package pkg on (pkg.Package_ID = o.Package_ID)) " +
@" INNER JOIN t_object o1 on (cstr(o1.object_id) = a.classifier)) " +
@" where o1.ea_guid = '" + pkg.PackageGUID + "' ";
if (repositoryType== "JET")
{
query = @"select pkg.ea_GUID AS EA_GUID " +
@" from (((t_object o INNER JOIN t_attribute a on (o.object_ID = a.Object_ID AND a.type = 'Package')) " +
@" INNER JOIN t_package pkg on (pkg.Package_ID = o.Package_ID)) " +
@" INNER JOIN t_object o1 on (cstr(o1.object_id) = a.classifier)) " +
@" where o1.ea_guid = '" + pkg.PackageGUID + "' ";
}
if (repositoryType == "SQLSVR")
// SQL Server
{
query = @"select pkg.ea_GUID AS EA_GUID " +
@" from (((t_object o INNER JOIN t_attribute a on (o.object_ID = a.Object_ID AND a.type = 'Package')) " +
@" INNER JOIN t_package pkg on (pkg.Package_ID = o.Package_ID)) " +
@" INNER JOIN t_object o1 on o1.object_id = Cast(a.classifier As Int)) " +
@" where o1.ea_guid = '" + pkg.PackageGUID + "' ";
}
string str = rep.SQLQuery(query);
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(str);
XmlNode operationGuidNode = xmlDoc.SelectSingleNode("//EA_GUID");
if (operationGuidNode != null)
{
string guid = operationGuidNode.InnerText;
pkg1 = rep.GetPackageByGuid(guid);
}
return pkg1;
}
public static bool GetLatest(EA.Repository rep, EA.Package pkg, bool recursive, ref int count, int level, ref int errorCount)
{
if (pkg.IsControlled)
{
level = level + 1;
// check if checked out
string path = GetVccFilePath(rep, pkg);
string fText;
//rep.WriteOutput("Debug", "Path:" + pkg.Name + path, 0);
var sLevel = new string(' ', level * 2);
rep.WriteOutput("Debug", sLevel + (count+1).ToString(",0") + " Work for:" + path, 0);
if (path != "")
{
count = count + 1;
rep.ShowInProjectView(pkg);
// delete a potential write protection
try
{
var fileInfo = new FileInfo(path);
var attributes = (FileAttributes)(fileInfo.Attributes - FileAttributes.ReadOnly);
System.IO.File.SetAttributes(fileInfo.FullName, attributes);
System.IO.File.Delete(path);
}
catch (FileNotFoundException e)
{
fText = path + " " + e.Message;
rep.WriteOutput("Debug", fText, 0);
errorCount = errorCount + 1;
}
catch (DirectoryNotFoundException e)
{
fText = path + " " + e.Message;
rep.WriteOutput("Debug", fText, 0);
errorCount = errorCount + 1;
}
// get latest
try
{
// to make sure pkg is the correct reference
// new load of pkg after GetLatest
string pkgGuid = pkg.PackageGUID;
pkg.VersionControlGetLatest(true);
pkg = rep.GetPackageByGuid(pkgGuid);
count = count + 1;
}
catch
{
fText = path + " " + pkg.GetLastError();
rep.WriteOutput("Debug", fText, 0);
errorCount = errorCount + 1;
}
}
else
{
fText = pkg.XMLPath + " invalid path";
rep.WriteOutput("Debug", fText, 0);
errorCount = errorCount + 1;
}
}
//rep.WriteOutput("Debug", "Recursive:" +recursive.ToString(), 0);
if (recursive)
{
//rep.WriteOutput("Debug","Recursive count:" + pkg.Packages.Count.ToString(), 0);
// over all contained packages
foreach (EA.Package pkgNested in pkg.Packages)
{
//rep.WriteOutput("Debug", "Recursive:"+ pkgNested.Name, 0);
GetLatest(rep, pkgNested, true, ref count, level, ref errorCount);
}
}
return true;
}
/// <summary>
/// method adds a new diagram into parent element or package
/// </summary>
/// <param name="Repository">EA repository</param>
/// <param name="parentGUID">GUID of parent element</param>
/// <param name="packageGUID">GUID of parent package</param>
/// <param name="elementType">type of new diagram</param>
/// <param name="name">name of new diagram</param>
/// <param name="author">author of new diagram</param>
/// <returns>GUID of new diagram</returns>
public string addDiagram(EA.Repository Repository, string parentGUID, string packageGUID, int elementType, string name, string author)
{
if (getDiagramType(elementType) == "")
{
return "";
}
EA.Collection diagrams;
if (parentGUID == "0")
{
diagrams = (EA.Collection)Repository.GetPackageByGuid(packageGUID).Diagrams;
}
else
{
diagrams = (EA.Collection)Repository.GetElementByGuid(parentGUID).Diagrams;
}
EA.Diagram newDiagram = (EA.Diagram)diagrams.AddNew(name, getDiagramType(elementType));
newDiagram.Author = author;
newDiagram.Update();
diagrams.Refresh();
EA.Package parentPackage = (EA.Package)Repository.GetPackageByGuid(packageGUID);
if (parentGUID == "0")
{
BPAddIn.synchronizationWindow.addToList("Addition of " + itemTypes.getElementTypeInEnglish(elementType) + " '" + name +
"' to package '" + parentPackage.Name + "' - author: '" + author + "'");
}
else
{
EA.Element parentElement = (EA.Element)Repository.GetElementByGuid(parentGUID);
BPAddIn.synchronizationWindow.addToList("Addition of " + itemTypes.getElementTypeInEnglish(elementType) + " '" + name +
"' to element '" + parentElement.Name + "' in package '" + parentPackage.Name + "' - author: '" + author + "'");
}
return newDiagram.DiagramGUID;
}
/// <summary>
/// method adds a new package into parent package
/// </summary>
/// <param name="Repository">EA repository</param>
/// <param name="packageGUID">GUID of parent package</param>
/// <param name="name">name of new package</param>
/// <param name="author">author of new package</param>
/// <returns>GUID of new package</returns>
public String addPackage(EA.Repository Repository, string packageGUID, string name, string author)
{
EA.Package parentPackage = (EA.Package)Repository.GetPackageByGuid(packageGUID);
EA.Package newPackage = (EA.Package)parentPackage.Packages.AddNew(name, "");
newPackage.Update();
EA.Element packageMetaElement = (EA.Element)newPackage.Element;
packageMetaElement.Author = author;
newPackage.Update();
parentPackage.Packages.Refresh();
BPAddIn.synchronizationWindow.addToList("Addition of package '" + name + "' to package '" + parentPackage.Name
+ "' - author: '" + author + "'");
return newPackage.PackageGUID;
}
/// <summary>
/// method adds a new element into parent element or package
/// </summary>
/// <param name="Repository">EA repository</param>
/// <param name="parentGUID">GUID of parent element</param>
/// <param name="packageGUID">GUID of parent package</param>
/// <param name="coordinates">coordinates of new element</param>
/// <param name="elementType">type of new element</param>
/// <param name="name">name of new element</param>
/// <param name="author">author of new element</param>
/// <returns>GUID of new element</returns>
public string addElement(EA.Repository Repository, string parentGUID, string packageGUID, string coordinates,
int elementType, string name, string author)
{
if (getElementType(elementType) == "" && getElementStereotype(elementType) == "" && getElementSubtype(elementType) == -1)
{
return "";
}
EA.Collection elements;
if (parentGUID == "0")
{
elements = (EA.Collection)Repository.GetPackageByGuid(packageGUID).Elements;
}
else
{
elements = (EA.Collection)Repository.GetElementByGuid(parentGUID).Elements;
}
if (elementType == 6 || (elementType > 30 && elementType < 45))
{
elements = (EA.Collection)Repository.GetPackageByGuid(packageGUID).Elements;
}
EA.Element newElement = (EA.Element)elements.AddNew(name, getElementType(elementType));
if ((elementType >= 7 && elementType <= 10) || (elementType >= 18 && elementType <= 23))
{
newElement.Subtype = getElementSubtype(elementType);
}
if (elementType == 4 || (elementType >= 15 && elementType <= 17) || (elementType >= 31 && elementType <= 44))
{
newElement.Stereotype = getElementStereotype(elementType);
}
newElement.Author = author;
newElement.Update();
elements.Refresh();
EA.Package parentPackage = (EA.Package)Repository.GetPackageByGuid(packageGUID);
if (parentGUID == "0")
{
BPAddIn.synchronizationWindow.addToList("Addition of " + itemTypes.getElementTypeInEnglish(elementType) + " '" + name +
"' to package '" + parentPackage.Name + "' - author: '" + author + "'");
}
else
{
EA.Element parentElement = (EA.Element)Repository.GetElementByGuid(parentGUID);
BPAddIn.synchronizationWindow.addToList("Addition of " + itemTypes.getElementTypeInEnglish(elementType) + " '" + name +
"' to element '" + parentElement.Name + "' in package '" + parentPackage.Name + "' - author: '" + author + "'");
}
return newElement.ElementGUID;
}
/// <summary>
/// method deletes package
/// </summary>
/// <param name="Repository">EA repository</param>
/// <param name="packageGUID">GUID of package that should be deleted</param>
public void deletePackage(EA.Repository Repository, string packageGUID)
{
EA.Package packageToDelete = (EA.Package)Repository.GetPackageByGuid(packageGUID);
string name = packageToDelete.Name;
EA.Package parentPackage = (EA.Package)Repository.GetPackageByID(packageToDelete.ParentID);
for (short i = 0; i < parentPackage.Packages.Count; i++)
{
EA.Package actualPackage = (EA.Package)parentPackage.Packages.GetAt(i);
if (actualPackage.PackageGUID == packageGUID)
{
parentPackage.Packages.DeleteAt(i, false);
break;
}
}
parentPackage.Packages.Refresh();
BPAddIn.synchronizationWindow.addToList("Deletion of package '" + name + "' from package '" + parentPackage.Name + "'");
}
/// <summary>
/// method changes notes of package
/// </summary>
/// <param name="Repository">EA repository</param>
/// <param name="packageGUID">GUID of changed package</param>
/// <param name="notes">new notes of changed package</param>
public void changePackageNotes(EA.Repository Repository, string packageGUID, string notes)
{
EA.Package package = (EA.Package)Repository.GetPackageByGuid(packageGUID);
package.Notes = notes;
package.Update();
BPAddIn.synchronizationWindow.addToList("Change of notes of package '" + package.Name +
"' (Location of package: " + itemTypes.getLocationOfItem(Repository, package.ParentID, 0));
}
/// <summary>
/// method changes name of package
/// </summary>
/// <param name="Repository">EA repository</param>
/// <param name="packageGUID">GUID of changed package</param>
/// <param name="name">new name of changed package</param>
/// <param name="oldName">previous name of changed package</param>
public void changePackageName(EA.Repository Repository, string packageGUID, string name, string oldName)
{
EA.Package package = (EA.Package)Repository.GetPackageByGuid(packageGUID);
package.Name = name;
package.Update();
BPAddIn.synchronizationWindow.addToList("Change of name of package '" + name + "' - previous name: '" + oldName +
"' (Location of package: " + itemTypes.getLocationOfItem(Repository, package.ParentID, 0));
}
/// <summary>
/// method changes author of package
/// </summary>
/// <param name="Repository">EA repository</param>
/// <param name="packageGUID">GUID of changed package</param>
/// <param name="author">new author of changed package</param>
/// <param name="oldAuthor">previous author of changed package</param>
public void changePackageAuthor(EA.Repository Repository, string packageGUID, string author, string oldAuthor)
{
EA.Package package = (EA.Package)Repository.GetPackageByGuid(packageGUID);
EA.Element packageElement = (EA.Element)package.Element;
packageElement.Author = author;
package.Update();
BPAddIn.synchronizationWindow.addToList("Change of author of package '" + package.Name + "' - previous author: '" + oldAuthor +
"', current author: '" + author + "' (Location of package: " + itemTypes.getLocationOfItem(Repository, package.ParentID, 0));
}
/// <summary>
/// Create a package element. Be aware that a package element also contains an element to support
/// element specific things like tagged values.
/// </summary>
/// <param name="rep"></param>
/// <param name="GUID"></param>
public FindAndReplaceItemPackage(EA.Repository rep, string GUID) :base( rep, GUID)
{
this._el = rep.GetElementByGuid(GUID);
this._pkg = rep.GetPackageByGuid(GUID);
this.load(rep);
}
