Subversion Repositories DevTools

using System;

using System.Collections;

using System.Text;

using System.ComponentModel;

using System.Windows.Forms;

namespace EA_DocGen

{

	/// <summary>

	/// Summary description for EA_RelationshipMatrix.

	/// </summary>

	public class EA_RelationshipMatrix

	{

      private static ArrayList processedElements = null;

      // declare option variables

      private static int style = 1;

      private static string fromIntroText = null;     // This one is optional 

      private static string fromPackageGUID = null;

      private static string fromToTableTitle = null;  // This one is optional

      private static string fromColumnTitle = null;

      private static ArrayList fromElementTypes = null;

      private static bool fromPackageRecursion = true;

      private static EA.Package fromPackage = null;

      private static bool fromPackageTrimming = false;

      private static string toIntroText = null;       // This one is optional

      private static string toPackageGUID = null;

      private static string toFromTableTitle = null;  // This one is optional

      private static string toColumnTitle = null;

      private static ArrayList toElementTypes = null;

      private static bool toPackageRecursion = true;

      private static EA.Package toPackage = null;

      private static bool toPackageTrimming = false;

      private static string [] options_string = null;

		public static void initialise(ArrayList processedElementsRef)

		{

         processedElements = processedElementsRef;

         fromElementTypes  = new ArrayList();

         toElementTypes    = new ArrayList();

		}

      private static void reset()

      {

         style = 1;

         fromIntroText = null;

         fromPackageGUID = null;

         fromToTableTitle = null;

         fromColumnTitle = null;

         fromElementTypes.Clear();

         fromPackageRecursion = true;

         fromPackageTrimming = false;

         fromPackage = null;

         toIntroText = null;

         toPackageGUID = null;

         toFromTableTitle = null;

         toColumnTitle = null;

         toElementTypes.Clear();

         toPackageRecursion = true;

         toPackageTrimming = false;

         toPackage = null;

      }

      public static bool processRelationshipMatrixOptions(EA.Element theElement)

      {

         reset();

         // Extract the control options from the notes of the element

         string delimStr = "\n";

         char [] delim = delimStr.ToCharArray();

         options_string = theElement.Notes.ToString().Split(delim,100);

         int i = 0;

         foreach(string s in options_string)

         {

            options_string[i] = s.Trim();

            i++;

         }

         // scan the options string and assign values into the options variables as required

         foreach(string s in options_string)

         {

            if (s.Length > 0 && s != "\n" && s != "\r" && s[0] != '\\')

            {

               if (s.StartsWith("style="))

               {

                  style = EA_DocGenOptions.getOptionValue(s, style);

               }

               // FROM items

               else if (s.StartsWith("fromIntroText="))

               {

                  fromIntroText = EA_DocGenOptions.getOptionValue(s, null);

               }

               else if (s.StartsWith("fromToTableTitle=")) 

               {

                  fromToTableTitle = EA_DocGenOptions.getOptionValue(s, null);

               }

               else if (s.StartsWith("fromColumnTitle=")) 

               {

                  fromColumnTitle = EA_DocGenOptions.getOptionValue(s, fromColumnTitle);

               }

               else if (s.StartsWith("fromPackageRecursion=")) 

               {

                  fromPackageRecursion = EA_DocGenOptions.getOptionValue(s, fromPackageRecursion);

               }

               else if (s.StartsWith("fromPackageTrimming="))

               {

                  fromPackageTrimming = EA_DocGenOptions.getOptionValue(s, fromPackageTrimming);

               }

               else if (s.StartsWith("fromPackage=")) 

               {

                  fromPackageGUID = EA_DocGenOptions.getOptionValue(s, fromPackageGUID);

               }

               else if (s.StartsWith("fromElementType=")) 

               {

                  string et = EA_DocGenOptions.getOptionValue(s,null);

                  if (et != null) 

                  {

                     fromElementTypes.Add( et );

                  }

               }

                  // TO items

               else if (s.StartsWith("toIntroText="))

               {

                  toIntroText = EA_DocGenOptions.getOptionValue(s, null);

               }

               else if (s.StartsWith("toFromTableTitle=")) 

               {

                  toFromTableTitle = EA_DocGenOptions.getOptionValue(s, null);

               }

               else if (s.StartsWith("toColumnTitle=")) 

               {

                  toColumnTitle = EA_DocGenOptions.getOptionValue(s, toColumnTitle);

               }

               else if (s.StartsWith("toPackageRecursion=")) 

               {

                  toPackageRecursion = EA_DocGenOptions.getOptionValue(s, toPackageRecursion);

               }

               else if (s.StartsWith("toPackageTrimming=")) 

               {

                  toPackageTrimming = EA_DocGenOptions.getOptionValue(s, toPackageTrimming);

               }               

               else if (s.StartsWith("toPackage=")) 

               {

                  toPackageGUID = EA_DocGenOptions.getOptionValue(s, toPackageGUID);

               }

               else if (s.StartsWith("toElementType=")) 

               {

                  string et = EA_DocGenOptions.getOptionValue(s,null);

                  if (et != null) 

                  {

                     toElementTypes.Add( et );

                  }

               }

            }

         }

         // Verify that we have all the necessary compulsory options

         if (fromToTableTitle == null && toFromTableTitle == null)

         {

            MessageBox.Show("Error in EA_DocGenRelationshipMatrix options list\n\n" +

               "Missing option: Must specify at least one table title");

            return false;

         }

         // FROM items

         if (fromColumnTitle == null)

         {

            MessageBox.Show("Error in EA_DocGenRelationshipMatrix options list\n\n" +

               "Missing option: fromColumnTitle");

            return false;

         }

         if (fromPackageGUID == null)

         {

            MessageBox.Show("Error in EA_DocGenRelationshipMatrix options list\n\n" +

               "Missing option: fromPackageGUID");

            return false;

         }

         if (fromElementTypes.Count == 0)

         {

            MessageBox.Show("Error in EA_DocGenRelationshipMatrix options list\n\n" +

               "Missing option(s): fromElementTypes");

            return false;

         }      

         // TO items

         if (toColumnTitle == null)

         {

            MessageBox.Show("Error in EA_DocGenRelationshipMatrix options list\n\n" +

               "Missing option: toColumnTitle");

            return false;

         }

         if (toPackageGUID == null)

         {

            MessageBox.Show("Error in EA_DocGenRelationshipMatrix options list\n\n" +

               "Missing option: toPackageGUID");

            return false;

         }

         if (toElementTypes.Count == 0)

         {

            MessageBox.Show("Error in EA_DocGenRelationshipMatrix options list\n\n" +

               "Missing option(s): toElementTypes");

            return false;

         }   

         // Find GUID linked packages in the repository

         fromPackage = Main.EA_Repository.GetPackageByGuid( fromPackageGUID );

         if (fromPackage == null)

         {

            MessageBox.Show("Error processing EA_DocGenRelationshipMatrix\n\n" +

               "could not locate fromPackage in Repository");

            return false;

         }

         toPackage = Main.EA_Repository.GetPackageByGuid( toPackageGUID );

         if (toPackage == null)

         {

            MessageBox.Show("Error processing EA_DocGenRelationshipMatrix\n\n" +

               "could not locate toPackage in Repository");

            return false;

         }

         return true;

      }

      public static string optionTemplateForRelationshipMatrix(int style)

      {

         switch (style)

         {

            case 1:

               return

               "style=1\r\n"

               + "fromToTableTitle=\r\n"

               + "fromIntroText=\r\n"

               + "fromColumnTitle=\r\n"

               + "fromPackage=\r\n"

               + "fromElementType=\r\n"

               + "fromElementType=\r\n"

               + "fromPackageRecursion=true\r\n"

               + "fromPackageTrimming=false\r\n"

               + "toFromTableTitle=\r\n"

               + "toIntroText=\r\n"

               + "toColumnTitle=\r\n"

               + "toPackage=\r\n"

               + "toElementType=\r\n"

               + "toPackageRecursion=true\r\n"

               + "toPackageTrimming=false\r\n";

            case 2:

               return

               "style=2\r\n"

               + "fromToTableTitle=Requirement Dependencies\r\n"

               + "fromIntroText=The following table identifies the source requirements (if any) for each requirement stated in this document.\r\n"

               + "fromColumnTitle=Requirement\r\n"

               + "fromPackage=\r\n"

               + "fromElementType=Requirement\r\n"

               + "fromPackageRecursion=true\r\n"

               + "fromPackageTrimming=false\r\n"

               + "toPackageRecursion=true\r\n"

               + "toPackage=\r\n"

               + "toColumnTitle=Source Requirements\r\n"

               + "toElementType=Requirement\r\n";

            default:

               return "";

         }

      }

      /// <summary>

      /// This function will insert one or more relationship matrix tables into the document, 

      /// built from content specified in options that are provided in the notes section of 

      /// the special element that has led to this function being called.

      /// </summary>

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

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

      public static void processRelationshipMatrixElement( EA.Element theElement, int recurse_level )

      {

         switch (style)

         {

            case 1:

               processRelationshipMatrixElementStyle1();

               break;

            case 2:

               processRelationshipMatrixElementStyle2();

               break;

         }

      }

      /// <summary>

      /// This function will insert a relationship matrix table into the document, built from content

      /// specified in options that are provided in the notes section of the special element that

      /// has led to this function being called.

      /// 

      /// The style of these tables is that required for requirement to design traceability.

      /// </summary>

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

      private static void processRelationshipMatrixElementStyle1()

      {

         int tableNum = 0;

         Word.Table table = null;

         // Scan the fromPackage to find all the "from elements".

         ElementAccumulator fromLister = new ElementAccumulator(fromElementTypes);

         EA_Utilities.findAndProcessPackageElements( fromPackage, fromLister, fromPackageRecursion );

         if (createWordDoc.abortCreationThread)

            return;

         // Sort the "from elements"

         elementSortByName sorter = new elementSortByName();

         fromLister.Elements.Sort( sorter );

         if (createWordDoc.abortCreationThread)

            return;

         // dictionary to support from-to table construction.

         ArrayList fromToDictionary = new ArrayList();

         // dictionary to support to-from table construction.

         ArrayList toFromDictionary = new ArrayList();

         bool needFromToTable = false;

         if (fromToTableTitle != null && fromToTableTitle.Length > 0)

            needFromToTable = true;

         bool needToFromTable = false;

         if (toFromTableTitle != null && toFromTableTitle.Length > 0)

            needToFromTable = true;

         // NOTE: this code has to execute even if no from-to table is needed, in order to support the

         // generation of a to-from table, assuming the user has requested one.

         int numberOfFromToRows = 0;

         foreach(EA.Element fromElement in fromLister.Elements)

         {

            if (createWordDoc.abortCreationThread)

               return;

            // look at the elements connection collection to find references to the

            // destination elements

            bool foundToElement = false;

            EA.Collection conCollection = fromElement.Connectors;

            foreach (EA.Connector thisCon in conCollection)

            {

               if (createWordDoc.abortCreationThread)

                  return;

               EA.Element destE = Main.EA_Repository.GetElementByID( thisCon.SupplierID );

               if (destE == null)

                  continue;

               // ignore self-referential connections

               if (fromElement.ElementID == thisCon.SupplierID)

                  continue;

               // if the destination element is of a type that the user has requested to include...

               if (!toElementTypes.Contains( destE.Type ))

                  continue;

               // Capture the from-to relationship in a dictionary where the key is the

               // "from element", and the value is the "to element".

               DictionaryEntry newFromToEntry = new DictionaryEntry(fromElement, destE);

               fromToDictionary.Add( newFromToEntry );

               foundToElement = true;

               // Capture the from-to relationship in a dictionary where the key is the

               // ID of the destination element, and the value is the from element name.

               // This dictionary will enable rapid construction of the to-from table if

               // the user has requested it, from the exact same relationship info used

               // to construct the from-to table.

               if (needToFromTable)

               {

                  DictionaryEntry newToFromEntry = new DictionaryEntry(destE.ElementID, fromElement.Name);

                  toFromDictionary.Add( newToFromEntry );

               }

            }

            // If we found a from-to relationship that table needs a new row.

            if (foundToElement)

            {

               numberOfFromToRows++;

            }

               // If we did not find a from-to relationship that table still needs a new row 

               // if the user wants all "from elements", even if some have no "to elements".

            else if (fromPackageTrimming == false)

            {

               DictionaryEntry newFromToEntry = new DictionaryEntry(fromElement, null);

               fromToDictionary.Add( newFromToEntry );

               numberOfFromToRows++;

            }

         }

         if (createWordDoc.abortCreationThread)

            return;

         if (needFromToTable)

         {

            // Now we can actually serialise the table

            if (fromIntroText != null && fromIntroText.Length > 0)

            {

               TextualContent.appendAndSelectText( fromIntroText, EA_Constants.styleName_Body1 );

            }

            // create the from-to table in the word doc

            tableNum = TabularContent.Table_Create( fromToTableTitle, true, numberOfFromToRows + 1, 2 );

            table = createWordDoc.WordDocument.Tables[tableNum];

            TabularContent.Table_SetTableColumnTitle(table, fromColumnTitle, 1);

            TabularContent.Table_SetTableColumnTitle(table, toColumnTitle, 2);

            fillInTable(fromToDictionary, table);

         }

         if (createWordDoc.abortCreationThread)

            return;

         // Does user want a to-from table ?

         if (needToFromTable)

         {

            // re-use the fromToDictionary to prepare the to-from table content 

            fromToDictionary.Clear();

            // find all elements for the left hand column of the to-from table.

            ElementAccumulator toLister = new ElementAccumulator(toElementTypes);

            EA_Utilities.findAndProcessPackageElements( toPackage, toLister, toPackageRecursion );

            if (createWordDoc.abortCreationThread)

               return;

            // Sort the "to" elements

            toLister.Elements.Sort( sorter );

            if (createWordDoc.abortCreationThread)

               return;

            // To make the to-from table, we use the dictionary that was built when making the from-to

            // table. The dictionary will allow rapid determination of what "from" items belong to each

            // "to" item, without us having to go back to EA and enquire on the database.

            // We build a new fromToDictionary from the toFromDictionary, in advance of actually making 

            // the table so that we can figure out how many rows the table needs to have.

            numberOfFromToRows = 0;

            foreach(EA.Element toElement in toLister.Elements)

            {

               if (createWordDoc.abortCreationThread)

                  return;

               bool foundToElement = false;

               // right-column cell content

               foreach (DictionaryEntry de in toFromDictionary)

               {

                  if ((int)de.Key == toElement.ElementID)

                  {

                     DictionaryEntry newFromToEntry = new DictionaryEntry(toElement, (string)de.Value);

                     fromToDictionary.Add( newFromToEntry );

                     foundToElement = true;

                  }

               }

               if (createWordDoc.abortCreationThread)

                  return;

               // If we found a from-to relationship that table needs a new row.

               if (foundToElement)

               {

                  numberOfFromToRows++;

               }

                  // if user wants all "from elements", even if some have no "to elements", then add a dictionary

                  // entry and bump row count.

               else if (toPackageTrimming == false)

               {

                  DictionaryEntry newFromToEntry = new DictionaryEntry(toElement, "");

                  fromToDictionary.Add( newFromToEntry );

                  numberOfFromToRows++;

               }

            }

            if (createWordDoc.abortCreationThread)

               return;

            // Now begin to add the to-from table to the word document

            if (toIntroText != null && toIntroText.Length > 0)

            {

               TextualContent.appendAndSelectText( toIntroText, EA_Constants.styleName_Body1 );

            }

            // create the table in the word doc

            tableNum = TabularContent.Table_Create( toFromTableTitle, true, numberOfFromToRows + 1, 2 );

            table = createWordDoc.WordDocument.Tables[tableNum];

            TabularContent.Table_SetTableColumnTitle(table, toColumnTitle, 1);

            TabularContent.Table_SetTableColumnTitle(table, fromColumnTitle, 2);

            fillInTable(fromToDictionary, table);

         }

      }

      private static void fillInTable(ArrayList fromToDictionary, Word.Table table )

      {

         int lastFromElementId = -1;

         bool firstToFromCon = true;

         int row = 1;

         foreach (DictionaryEntry de in fromToDictionary)

         {

            if (createWordDoc.abortCreationThread)

               return;

            if ( ((EA.Element)de.Key).ElementID != lastFromElementId )

            {

               lastFromElementId = ((EA.Element)de.Key).ElementID;

               row++;

               table.Cell(row,1).Range.Text = ((EA.Element)de.Key).Name;

               firstToFromCon = true;

            }

            if (((string)de.Value).Length > 0)

            {

               if (firstToFromCon)

               {

                  firstToFromCon = false;

                  table.Cell(row,2).Range.Text = (string)de.Value;

               }

               else

               {

                  table.Cell(row,2).Range.Text += (string)de.Value;

               }

            }

            else

            {

               if (EA_DocGenOptions.optionValue(EA_DocGenOptions.boolean_options_e.SUPPRESS_UN_ALLOCATED_RELATIONSHIP_WARNINGS) == false)

               {

                  table.Cell(row,2).Range.Text = "Un-allocated relationship!";

                  table.Cell(row,2).Range.Font.Color = Word.WdColor.wdColorRed;

               }

            }

         }

      }

      /// <summary>

      /// This function will insert a relationship matrix table into the document, built from content

      /// specified in options that are provided in the notes section of the special element that

      /// has led to this function being called.

      /// 

      /// The style of this single table is that required for requirement to requirement traceability.

      /// Here, only a single table is generated, and the only elements in the left hand column will

      /// be those serialised to the document earlier on, and the content of the right hand column

      /// will be the parental requirements (all the way up to root requirements).

      /// </summary>

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

      private static void processRelationshipMatrixElementStyle2()

      {

         int i;

         int tableNum = 0;

         Word.Table table = null;

         // Scan the fromPackage to find all the "from elements".

         ElementAccumulator fromLister = new ElementAccumulator(fromElementTypes);

         EA_Utilities.findAndProcessPackageElements( fromPackage, fromLister, fromPackageRecursion );

         if (createWordDoc.abortCreationThread)

            return;

         // Remove all elements from the list that did not go to form content in the document

         // prior to this point in the document generation process.

         for (i=0; i<fromLister.Elements.Count; )

         {

            if (createWordDoc.abortCreationThread)

               return;

            if ( !processedElements.Contains( ((EA.Element)fromLister.Elements[i]).ElementID ) )

            {

               fromLister.Elements.RemoveAt(i);

               continue;

            }

            i++;

         }

         if (createWordDoc.abortCreationThread)

            return;

         // Sort the remaining "from elements"

         elementSortByName sorter = new elementSortByName();

         fromLister.Elements.Sort( sorter );

         if (createWordDoc.abortCreationThread)

            return;

         // Scan the toPackage to find all the "to elements".

         // Extract their element IDs into a new list.

         ElementAccumulator toLister = new ElementAccumulator(toElementTypes);

         EA_Utilities.findAndProcessPackageElements( toPackage, toLister, toPackageRecursion );

         ArrayList acceptableParents = new ArrayList();

         foreach(EA.Element ele in toLister.Elements)

         {

            if (createWordDoc.abortCreationThread)

               return;

            acceptableParents.Add( ele.ElementID);

         }

         if (createWordDoc.abortCreationThread)

            return;

         // The list of from elements dictates the number of rows in our table.

         int numberOfFromToRows = fromLister.Elements.Count;

         if (fromIntroText != null && fromIntroText.Length > 0)

         {

            TextualContent.appendAndSelectText( fromIntroText, EA_Constants.styleName_Body1 );

         }

         // create the from-to table in the word doc

         tableNum = TabularContent.Table_Create( fromToTableTitle, true, numberOfFromToRows + 1, 2 );

         table = createWordDoc.WordDocument.Tables[tableNum];

         TabularContent.Table_SetTableColumnTitle(table, fromColumnTitle, 1);

         TabularContent.Table_SetTableColumnTitle(table, toColumnTitle, 2);

         int row = 2;

         foreach(EA.Element ele in fromLister.Elements)

         {

            if (createWordDoc.abortCreationThread)

               return;

            table.Cell(row,1).Range.Text = ele.Name;

            StringBuilder sb = new StringBuilder();

            ArrayList parentsDiscovered = new ArrayList();

            // Find this requirement's parent (source) requirements

            elementParenthood(ele, ref acceptableParents, ref parentsDiscovered, ref sb);

            // if no source requirements found and user has opted for trimming, delete the table row

            if (fromPackageTrimming == true && sb.Length == 0)

            {

               TabularContent.Table_DeleteThisRow(table, row);

               continue;

            }

            // fill in the right hand cell on this row of the table with the source requirement list

            table.Cell(row,2).Range.Text = sb.ToString();

            row++;

         }

      }

      private static void elementParenthood(EA.Element ele, ref ArrayList acceptableParents, ref ArrayList parentsDiscovered, ref StringBuilder sb)

      {

         foreach(EA.Connector con in ele.Connectors)

         {

            if (createWordDoc.abortCreationThread)

               return;

            // ignore downwards direction, indicated by the client ID being equal to the element ID

            if (con.ClientID != ele.ElementID)

            {

               // if we have not already come across this upward path before...

               if (!parentsDiscovered.Contains(con.ClientID))

               {

                  parentsDiscovered.Add(con.ClientID);

                  // is this parent is in the list of acceptable parents...

                  if (acceptableParents.Contains(con.ClientID))

                  {

                     // get the parent element, add its name to our list, and ascend through the element

                     // using recursion.

                     EA.Element client = Main.EA_Repository.GetElementByID(con.ClientID);

                     if (client != null)

                     {

                        if (sb.Length > 0)

                           sb.Append("\n");

                        sb.Append(client.Name);

                        elementParenthood(client, ref acceptableParents, ref parentsDiscovered, ref sb);

                     }

                  }

               }

            }

         }

      }

	}

}