Subversion Repositories DevTools

using System;

using System.Text;

using System.Globalization;

using System.Collections;

using System.Collections.Specialized;

using System.Windows.Forms;

using ReqPro40;

namespace EA_ReqPro

{

	/// <summary>

	/// Summary description for CopyReqProDatabaseToMemory.

	/// </summary>

	public class CopyReqProDatabaseToMemory : ReqProParser

	{

      protected bool allowPackageStructureFragments = false;

      protected EA_Utilities EA_Utils;

      // items setup by base class calling into provideReqProDatabaseInfo()

      protected ReqPro40.Project RQ_project;

      protected ReqPro40.Application RQ_app;

      protected ReqProDB_Artifact RQ_Artifact;

      protected EA.Element RQ_Element;

      // Where in an EA database, the copy of the ReqPro database content will be written

      protected EA.Package ea_rootPackage;

      // Hierarchy tracking data for the parsing of a ReqPro database

      protected Stack rq_objs = new Stack();      // Top of stack indicates current parent package

      protected Stack ea_treePos = new Stack();   // Top of stack indicates current tree position reflecting object ordering within the parent package

      protected int lastLevel;                    // Allows us to determine if we have gone down/up in the hierarchy

      // Collector for the results of the parsing

      protected ReqPro_object rq_root_package;

      private int writeTracesModulo = 100;

      /// <summary>

      /// Constructor logic

      /// </summary>

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

		public CopyReqProDatabaseToMemory(): base()

		{

         try

         {

            // create an EA_Utilities object

            EA_Utils = new EA_Utilities();

            // figure out where in the EA database we will place the results of parsing

            object o;

            EA.ObjectType type;

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

            if (type == EA.ObjectType.otElement)

            {

               ea_rootPackage = Main.EA_Repository.GetPackageByID( ((EA.Element)o).PackageID );

            }

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

            {

               ea_rootPackage = (EA.Package)o;

            }

            else

            {

               Exception e = new Exception("No Root Package given");

               throw e;

            }

         }

         catch (Exception ex)

         {

            MessageBoxEx.Show(ex.Message, "Error (CopyReqProDatabaseToMemory)", MessageBoxButtons.OK);

         }    

		}

      #region Requirement Type methods

      /// <summary>

      /// Recursively set the requirement type enum in each requirement object read

      /// from the ReqPro database. The enum give fast indication of the requirement type.

      /// If we didnt do this, each time the requirement type needs to be evaluated, a string 

      /// compare needs to be done. Here, we do them all up-front so that down the track a simple

      /// integer access is all that is required.

      /// </summary>

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

      private void set_rq_req_types_in_copied_data( ReqPro_object rq_obj )

         {

            if (rq_obj.isRequirement)

            {

               int i = 0;

               foreach (ReqPro_ReqType req_type in rq_req_types)

               {

                  if (rq_obj.tag.StartsWith(req_type.prefix))

                  {

                     rq_obj.tag_enum = i;

                  }

                  i++;

               }

            }

            foreach( ReqPro_object sub_obj in rq_obj.ReqPro_objects )

            {

               // recurse

               set_rq_req_types_in_copied_data(sub_obj);

            }

         }

      #endregion

      #region ReqProParser (base class) overrides

      /// <summary>

      /// This method is designed to prompt the user to select the ReqPro database file

      /// before opening and parsing it. Once parsed, the user is offered a chance to setup

      /// the filter controls.

      /// </summary>

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

      /// <returns></returns>

      public override bool prompt_and_parse(ReqProDB_Artifact.MODE mode)

      {

         try

         {

            pre_parsing();

            if (true == base.prompt_and_parse(mode))

            {

               // make sure all imported requirements have the correct requirement type enumeration

               // (converted from the string name of the tag)

               set_rq_req_types_in_copied_data(rq_root_package);

               // bring up the filter dialog to allow user to specify exactly what gets copied

               ReqProFilterForm rq_filter = new ReqProFilterForm(mode == ReqProDB_Artifact.MODE.TRACEABILITY);

               rq_filter.populate(rq_root_package, rq_req_types, rq_req_status_types);

               // Setup the filter based on the saved filter settings in the ReqProDB element (if any)

               if (RQ_Element != null)

               {

                  rq_filter.loadFilterSettings(RQ_Element.Notes);

               }

               DialogResult dlgRes = rq_filter.ShowDialog();

               if (dlgRes == DialogResult.OK)

               {

                  allowPackageStructureFragments = rq_filter.allowPackageStructureFragments;

                  RQ_project.CloseProject();

                  // Save filter settings to the ReqProDB element if it is available

                  if (RQ_Element != null)

                  {

                     RQ_Element.Notes = rq_filter.saveFilterSettings();

                     RQ_Element.Update();

                  }

                  return true;

               }

               RQ_project.CloseProject();

            }

         }

         catch (Exception ex)

         {

            MessageBoxEx.Show(ex.Message, "Error (parse)", MessageBoxButtons.OK);

         }      

         return false;

      }

      /// <summary>

      /// This method will be called by the base class parser when it has obtained a ReqPro

      /// project object. We capture that object here so we can interrogate the ReqPro database

      /// ourselves, if we need to. We wont do that for package/requirement reading, but we may

      /// do it for meta-data such as requirement types, etc.

      /// </summary>

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

      protected override void provideReqProDatabaseInfo(ReqPro40.Application rq_app, 

         ReqPro40.Project rq_project, 

         ReqProDB_Artifact rq_artifact,

         EA.Element rq_element)

      {

         RQ_app = rq_app;

         RQ_project = rq_project;

         RQ_Artifact = rq_artifact;

         RQ_Element = rq_element;

      }

      /// <summary>

      /// This method will be called by the base class parser whenever a package or requirement object

      /// is found in the ReqPro database. The method collects important information from the object 

      /// into a structure that begins with the ea_rootPackage object. The structure is highly dynamic

      /// with each object able to hold a list of other objects. This naturally allows for the ReqPro

      /// database hierarchy to be accurately reflected. The hierarchy tracking data maintained within

      /// the method allows us to know what object in the structure to hang off any new object derived

      /// from info given to us by the base class parser (ie. what object is the parent object at the

      /// present time during the parsing).

      /// </summary>

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

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

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

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

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

      protected override void processObject(int level,

                                            ReqPro40.Project rq_project, 

                                            ReqPro40.Package rq_package,

                                            ReqPro40.Requirement rq_requirement)

      {

         // If we are still at the same level as the previous package, then pop the previous object 

         // in readiness for pushing the one we are now dealing with.

         if (level == lastLevel)

         {

            rq_objs.Pop();

            ea_treePos.Pop();

         }

            // but if we are beneath the previous level, pop all objects that are above us because

            // we no longer need them in our hierarchy reference data.

         else if (level < lastLevel)

         {

            while (lastLevel >= level)

            {

               rq_objs.Pop();

               ea_treePos.Pop();

               lastLevel--;

            }

         }

         // bump the tree position at this level (controls display position in the EA project browser)

         int treePos = (int)ea_treePos.Pop();

         treePos++;

         ea_treePos.Push(treePos);

         // create the new requirement or package

         ReqPro_object new_rq_obj = new ReqPro_object();

         if (rq_requirement != null)

         {

            new_rq_obj.isRequirement = true;

            new_rq_obj.name   = rq_requirement.Name;

            new_rq_obj.text   = rq_requirement.Text;

            new_rq_obj.guid   = rq_requirement.GUID;

            new_rq_obj.tag    = rq_requirement.get_Tag(ReqPro40.enumTagFormat.eTagFormat_FullTag);

            bool hasStatus = false;

            bool hasDifficulty = false;

            bool hasPriority = false;

            if (reqTypeHasOneOrMoreAttrs(new_rq_obj, ref hasStatus, ref hasDifficulty, ref hasPriority))

            {

               if (hasStatus)

               {

                  new_rq_obj.status = rq_requirement.AttrValues["Status", ReqPro40.enumAttrValueLookups.eAttrValueLookup_Label].Text;

               }

               if (hasDifficulty)

               {

                  new_rq_obj.difficulty = rq_requirement.AttrValues["Difficulty", ReqPro40.enumAttrValueLookups.eAttrValueLookup_Label].Text;

               }

               if (hasPriority)

               {

                  new_rq_obj.priority = rq_requirement.AttrValues["Priority", ReqPro40.enumAttrValueLookups.eAttrValueLookup_Label].Text;

               }

            }

            new_rq_obj.version    = rq_requirement.VersionNumber;

            new_rq_obj.versionDateTime = rq_requirement.VersionDateTime;

            // requirements can trace to other requirements, so we have to find those in order to re-construct

            // that traceability later on. Currently, we only process TracesTo relationships from ReqPro.

            int limit_numberOfTracesTo = 0;

            if (true == rq_requirement.get_HasTracesTo(ref limit_numberOfTracesTo))

            {

               // scan through the TracesTo relationships

               ReqPro40.Relationships theseRelationships = (ReqPro40.Relationships)rq_requirement.TracesTo;

               int i_numberOfTracesTo;

               theseRelationships.MoveFirst();

               for (i_numberOfTracesTo = 0; i_numberOfTracesTo < limit_numberOfTracesTo; i_numberOfTracesTo++)

               {

                  // Obtain the traced-to requirement from the relationship, and parse it

                  ReqPro40.Relationship thisRelationship = theseRelationships.GetCurrentRelationship();

                  ReqPro40.Requirement tracedToRequirement = 

                     thisRelationship.get_DestinationRequirement(ReqPro40.enumRequirementsWeights.eReqWeight_Heavy);

                  if (tracedToRequirement != null)

                  {

                     // Add the GUID of the traced-to requirement to the relevant list within the

                     // object representing the traced-from requirement (ie. parent requirement).

                     new_rq_obj.ReqPro_traces.Add(tracedToRequirement.GUID);

                  }

                  theseRelationships.MoveNext();

               }

            }

         }

         else if (rq_package != null)

         {

            new_rq_obj.isPackage = true;

            // Packages in ReqPro may be prefixed by a number to force ReqPro's alphanumeric sorting

            // algorithm to order the packages in the way the user wants, as dictated by the actual 

            // numbers used. EA does not have this problem because it uses a tree position number to

            // control a package/element's position in the project browser. So, strip off any leading

            // numeric from the ReqPro packages.

            string trimstring = " 0123456789";

            char[] trimmer = trimstring.ToCharArray();

            string filtered_name = rq_package.Name.TrimStart(trimmer);

            new_rq_obj.name = filtered_name;

            new_rq_obj.guid = rq_package.GUID;

         }

         new_rq_obj.level = level;

         new_rq_obj.treePos = treePos;

         // attach it to its parent object

         ReqPro_object parent_rq_obj = (ReqPro_object)rq_objs.Peek();

         parent_rq_obj.ReqPro_objects.Add( new_rq_obj );

         new_rq_obj.parent = parent_rq_obj;

         // keep a count of the number of requirements the object has beneath it

         if (true == new_rq_obj.isRequirement)

            parent_rq_obj.numberOfRequirements++;

         // push the new object onto the stack, ready for any sub-objects that may belong to it.

         // If, the next time we enter this method, the level is the same, this will get popped off.

         // If, the next time we enter this method, the level is lower, this and possibly more will

         // get popped off.

         rq_objs.Push(new_rq_obj);

         ea_treePos.Push(0);

         // capture what the hierarchy level is for the object just processed.

         lastLevel = level;

      }

      #endregion

      /// <summary>

      /// Finds and returns the ReqPro_object instance that contains the specified GUID. The

      /// GUID is that of the originating ReqPro requirement, which is copied into a ReqPro_object

      /// instance when it is created. This find operation supports the ability to resolve object to

      /// object trace relationships mirrored from the ReqPro database during the construction

      /// of the ReqPro_object hierarchy.

      /// </summary>

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

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

      /// <returns></returns>

      protected ReqPro_object findReqPro_object_byReqProGUID(ReqPro_object rq_obj, string ReqProGUID)

      {

         if (rq_obj.guid.CompareTo(ReqProGUID) == 0)

         {

            return rq_obj;

         }

         foreach (ReqPro_object sub_rq_obj in rq_obj.ReqPro_objects)

         {

            ReqPro_object tgt_obj = findReqPro_object_byReqProGUID(sub_rq_obj, ReqProGUID);

            if (tgt_obj != null)

               return tgt_obj;

         }

         return null;

      }

      protected int write_traces(int totalRequirements)

      {

         Main.EA_Repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "Writing Trace Information", -1);

         int numberWritten = 0;

         // adjust modulo for logging purposes so that the number of output messages is restricted

         // for larger and larger numbers of requirements

         if (totalRequirements > 1000)

            writeTracesModulo = 100;

         else if (totalRequirements > 500)

            writeTracesModulo = 50;

         else if (totalRequirements > 100)

            writeTracesModulo = 20;

         else if (totalRequirements > 50)

            writeTracesModulo = 10;

         else if (totalRequirements > 20)

            writeTracesModulo = 5;

         else // 10 or less 

            writeTracesModulo = 1;

         foreach( ReqPro_object sub_obj in rq_root_package.ReqPro_objects )

         {

            if (Main.mustAbort)

               return numberWritten;

            numberWritten = write_traces(sub_obj, numberWritten, totalRequirements);

         }

         Main.EA_Repository.WriteOutput(Main.GUI_OUTPUT_TAB_NAME, "Traces Completed", -1);

         return numberWritten;

      }

      /// <summary>

      /// This method examines all of the ReqPro_object trace relationships and mirrors them in 

      /// the EA requirement elements that have been formed from each un-filtered ReqPro_objects.

      /// </summary>

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

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

      private int write_traces(ReqPro_object rq_obj, int numberWritten, int totalRequirements)

      {

         if (Main.mustAbort)

            return numberWritten;

         if (rq_obj.isRequirement)

         {

            // if this object had an EA element made for it during the write_ea_database() process...

            if (rq_obj.ea_element_ID != -1)

            {

               numberWritten++;

               if ((numberWritten % writeTracesModulo) == 0)

               {

                  Main.EA_Repository.WriteOutput(Main.GUI_OUTPUT_TAB_NAME, string.Format("   {0} of {1}", numberWritten, totalRequirements), -1);

               }

               EA.Element ea_rq_obj = Main.EA_Repository.GetElementByID(rq_obj.ea_element_ID);

               if (ea_rq_obj != null)

               {

                  foreach(string s in rq_obj.ReqPro_traces)

                  {

                     ReqPro_object tgt_obj = findReqPro_object_byReqProGUID(rq_root_package,s);

                     if (tgt_obj != null)

                     {

                        if (tgt_obj.ea_element_ID != -1)

                        {

                           EA.Element ea_tgt_obj = Main.EA_Repository.GetElementByID(tgt_obj.ea_element_ID);

                           if (ea_tgt_obj != null)

                           {

                              add_connection(ea_rq_obj, ea_tgt_obj);

                           }

                        }

                     }

                  }

               }

            }

         }

         // recurse to ensure we examine the entire hiearchy

         foreach(ReqPro_object sub_obj in rq_obj.ReqPro_objects)

         {

            if (Main.mustAbort)

               break;

            numberWritten = write_traces(sub_obj, numberWritten, totalRequirements);

         }

         return numberWritten;

      }

      /// <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>

      protected void add_connection(EA.Element src_element, EA.Element dest_element)

      {

         // Add the new requirement to the src_element

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

         c.SupplierID = dest_element.ElementID;

         //c.Stereotype = "trace";

         c.Direction = "Source -> Destination";

         if (false == c.Update())

         {

            Main.EA_Repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "New Connector Error : " + c.GetLastError(), dest_element.ElementID );

         }

         src_element.Connectors.Refresh();

      }

      /// <summary>

      /// A method to contain common pre-parsing steps.

      /// </summary>

      private void pre_parsing()

      {

         // create an object to represent the root of the database so that we can collect

         // sub-objects (packages or requirements) underneath it.

         rq_root_package = new ReqPro_object();

         rq_root_package.name = "ROOT";

         // initialise the ReqPro database hierarchy tracking data

         rq_objs.Clear();

         rq_objs.Push(rq_root_package);

         ea_treePos.Clear();

         ea_treePos.Push(0);

         lastLevel = 0;

      }

	}

}