Subversion Repositories DevTools

using System;

using System.Text;

using System.Globalization;

using System.Collections;

using System.Windows.Forms;

using ReqPro40;

namespace EA_ReqPro

{

	/// <summary>

	/// Summary description for EA_Utils.

	/// </summary>

	public class EA_Utilities

	{

		public EA_Utilities()

		{

		}

      /// <summary>

      /// This function is designed to parse EA models/packages in a predefined way, whilst allowing

      /// a user to specify what processing is to be done upon or with each element found.

      /// </summary>

      /// <param name="thePackage"></param>

      /// <param name="worker"></param>

      /// <param name="recurse"></param>

      public static void findAndProcessPackageElements( EA.Package thePackage, EA_UtilitiesRecursionWorker worker, bool recurse)

      {

         worker.processPackage( thePackage );

         foreach (EA.Element theElement in thePackage.Elements)

         {

            worker.processElement( theElement );

            if (Main.mustAbort)

               return;

         }

         if (recurse == true)

         {

            foreach (EA.Package subPackage in thePackage.Packages)

            {

               // RECURSION

               findAndProcessPackageElements( subPackage, worker, true);

               if (Main.mustAbort)

                  return;

            }         

         }

      }

      public static void deletePackage(EA.Package packageToDelete)

      {

         EA.Package parentPackage = Main.EA_Repository.GetPackageByID(packageToDelete.ParentID);

         if (parentPackage != null)

         {

            short i = 0;

            foreach(EA.Package pkg in parentPackage.Packages)

            {

               if (pkg.PackageID == packageToDelete.PackageID)

               {

                  parentPackage.Packages.Delete(i);

                  break;

               }

               i++;

            }

            parentPackage.Packages.Refresh();

         }

      }

      public static EA.Element get_selected_element(ArrayList allowedElementTypes)

      {

         object o;

         EA.ObjectType type;

         type = Main.EA_Repository.GetTreeSelectedItem(out o);

         if (type == EA.ObjectType.otElement)

         {

            if (allowedElementTypes == null)

               return (EA.Element)o;

            if (allowedElementTypes.Contains( ((EA.Element)o).Type ))

               return (EA.Element)o;

         }

         return null;

      }

      public static EA.Package get_selected_package()

      {

         object o;

         EA.ObjectType type;

         type = Main.EA_Repository.GetTreeSelectedItem(out o);

         if (type == EA.ObjectType.otElement)

         {

            return Main.EA_Repository.GetPackageByID(((EA.Element)o).PackageID);

         }

         else if (type == EA.ObjectType.otDiagram)

         {

            return Main.EA_Repository.GetPackageByID(((EA.Diagram)o).PackageID);

         }

         else if (type == EA.ObjectType.otPackage)

         {

            return (EA.Package)o;

         }

         return null;

      }

      /// <summary>

      /// Creates a package under the specified parent package. the package is given a tree position

      /// as specified in order for it to be ordered in the model as the caller requires.

      /// </summary>

      /// <param name="parentPackage"></param>

      /// <param name="name"></param>

      /// <param name="treePos"></param>

      /// <returns></returns>

      public static EA.Package createPackage(EA.Package parentPackage, string name, int treePos)

      {

         EA.Package newobj = (EA.Package)parentPackage.Packages.AddNew(name, "Package");

         newobj.TreePos = treePos;

         newobj.Update();

         return newobj;

      }

      /// <summary>

      /// Adds a connection between one EA element and another

      /// </summary>

      /// <param name="repository"></param>

      /// <param name="rq_artifact"></param>

      /// <param name="ea_req"></param>

      public static void add_connection(EA.Element src_element, EA.Element dest_element)

      {

         if (false == ea_element_traces_to_or_from(src_element, dest_element))

         {

            // Add the new connection between the src_element and dest_element

            EA.Connector c = (EA.Connector)src_element.Connectors.AddNew("", "Dependency");

            c.SupplierID = dest_element.ElementID;

            c.Direction = "Source -> Destination";

            c.Update();

            src_element.Connectors.Refresh();

         }

      }

      private static bool ea_element_traces_to_or_from(EA.Element src_element, EA.Element dest_element)

      {

         foreach(EA.Connector ea_c in src_element.Connectors)

         {

            int destId = -1;

            // we dont care about direction of relationship, so test for both

            if (ea_c.ClientID == src_element.ElementID)

               destId = ea_c.SupplierID;

            else if (ea_c.SupplierID == src_element.ElementID)

               destId = ea_c.ClientID;

            // and make sure we filter out self-referential connectors

            if (destId != src_element.ElementID)

            {

               if (destId == dest_element.ElementID)

                  return true;

            }

         }

         return false;

      }

      public static void DumpEAElement()

      {

         EA.Element ea_ele = (EA.Element)Main.EA_Repository.GetTreeSelectedObject();

         Main.WriteOutput("EA Element : " + ea_ele.Name, ea_ele.ElementID);

         Main.WriteOutput(              "Author : " + ea_ele.Author, -1);

         Main.WriteOutput(         "ClassfierID : " + ea_ele.ClassfierID.ToString(), -1);

         Main.WriteOutput(      "ClassifierName : " + ea_ele.ClassifierName, -1);

         Main.WriteOutput(      "ClassifierType : " + ea_ele.ClassifierType, -1);

         Main.WriteOutput(          "Complexity : " + ea_ele.Complexity, -1);

         Main.WriteOutput(          "Difficulty : " + ea_ele.Difficulty, -1);

         Main.WriteOutput(         "ElementGUID : " + ea_ele.ElementGUID, -1);

         Main.WriteOutput(           "ElementID : " + ea_ele.ElementID.ToString(), ea_ele.ElementID);

         Main.WriteOutput(          "EventFlags : " + ea_ele.EventFlags, -1);

         Main.WriteOutput(     "ExtensionPoints : " + ea_ele.ExtensionPoints, -1);

         Main.WriteOutput(             "Genfile : " + ea_ele.Genfile, -1);

         Main.WriteOutput(            "Genlinks : " + ea_ele.Genlinks, -1);

         Main.WriteOutput(             "Gentype : " + ea_ele.Gentype, -1);

         Main.WriteOutput(        "GetLastError : " + ea_ele.GetLastError(), -1);

         Main.WriteOutput(   "GetLinkedDocument : " + ea_ele.GetLinkedDocument(), -1);

         Main.WriteOutput(   "GetStereotypeList : " + ea_ele.GetStereotypeList(), -1);

         Main.WriteOutput(            "MetaType : " + ea_ele.MetaType, -1);

         Main.WriteOutput(        "Multiplicity : " + ea_ele.Multiplicity, -1);

         Main.WriteOutput(               "Notes : " + ea_ele.Notes, -1);

         Main.WriteOutput(           "PackageID : " + ea_ele.PackageID.ToString(), ea_ele.PackageID);

         Main.WriteOutput(            "ParentID : " + ea_ele.ParentID.ToString(), ea_ele.ParentID);

         Main.WriteOutput(         "Persistence : " + ea_ele.Persistence, -1);

         Main.WriteOutput(               "Phase : " + ea_ele.Phase, -1);

         Main.WriteOutput(            "Priority : " + ea_ele.Priority, -1);

         Main.WriteOutput(        "PropertyType : " + ea_ele.PropertyType.ToString(), -1);

         Main.WriteOutput(            "RunState : " + ea_ele.RunState, -1);

         Main.WriteOutput(              "Status : " + ea_ele.Status, -1);

         Main.WriteOutput(          "Stereotype : " + ea_ele.Stereotype, -1);

         Main.WriteOutput(        "StereotypeEx : " + ea_ele.StereotypeEx, -1);

         Main.WriteOutput(             "StyleEx : " + ea_ele.StyleEx, -1);

         Main.WriteOutput(             "Subtype : " + ea_ele.Subtype.ToString(), -1);

         Main.WriteOutput(          "Tablespace : " + ea_ele.Tablespace, -1);

         Main.WriteOutput(                 "Tag : " + ea_ele.Tag, -1);

         Main.WriteOutput(             "TreePos : " + ea_ele.TreePos.ToString(), -1);

         Main.WriteOutput(                "Type : " + ea_ele.Type, -1);

         Main.WriteOutput(             "Version : " + ea_ele.Version, -1);

         Main.WriteOutput(          "Visibility : " + ea_ele.Visibility, -1);

      }

	}

   /// <summary>

   /// A Base Class designed to work with the findAndProcessPackageElements method.

   /// Users will normally derive their own classes from this and add real functionality

   /// to the over-ridable methods the base class provides.

   /// </summary>

   public class EA_UtilitiesRecursionWorker

   {

      public EA_UtilitiesRecursionWorker()

      {

      }

      public virtual void processElement( EA.Element theElement )

      {

      }

      public virtual void processPackage( EA.Package thePackage )

      {

      }

   }

   /// <summary>

   /// This class is one derived from the EA_UtilitiesRecursionWorker base class so that

   /// an instance of it can be used as a parameter in the EA_Utilities.findAndProcessPackageElements

   /// method which recursively parses a given package. Thus, clients can parse EA model structure but

   /// specify their own functionality to be carried out on packages and elements found in the

   /// parsing.

   /// This particular derived class is designed to collect a list of element names from the

   /// package, from elements that have a type that is acceptable.

   /// </summary>

   public class ElementAccumulator : EA_UtilitiesRecursionWorker

   {

      public ArrayList Elements = null;

      public ArrayList ElementIDs = null;

      private ArrayList validElementTypes = null;

      public ElementAccumulator(ArrayList elementTypeList): base()

      {

         validElementTypes = elementTypeList;

         Elements = new ArrayList();

         ElementIDs = new ArrayList();

      }

      public override void processElement( EA.Element theElement )

      {

         if (validElementTypes.Contains( theElement.Type ))

         {

            Elements.Add( theElement );

            ElementIDs.Add( theElement.ElementID );

         }

      }

   }

}