WebSVN – DevTools – Diff – /EA_ReqPro/trunk/EA_ReqPro/ReqProParser.cs

 using System;
 using System.Text;
 using System.Globalization;
 using System.Collections;
+using System.Collections.Specialized;
 using System.Windows.Forms;
 using ReqPro40;
 namespace EA_ReqPro
+{
 	/// to a client with sufficient information to allow it to build a model of that ReqPro
 	/// database content in memory, maintaining the hierarchy and ordering of objects found.
 	/// </summary>
 	public class ReqProParser
+	{
+      // lists of meta-data in the ReqPro database
+      protected ArrayList rq_req_types;
+      protected ArrayList rq_req_status_types;
+      protected ArrayList delayedMessages;
+      // constructor
 		public ReqProParser()
+		{
+         delayedMessages = new ArrayList();
+		}
       /// <summary>
       /// The parser will call this virtual method when it has opened a ReqPro project
       /// </summary>
       /// </summary>
       /// <param name="level"></param>
       /// <param name="ea_repository"></param>
       /// <param name="rq_project"></param>
       /// <param name="rq_Package"></param>
       protected virtual void processPackage(int level,
-                                            EA.Repository ea_repository,
                                             ReqPro40.Project rq_project,
                                             ReqPro40.Package rq_package)
+      {
+      }
       /// <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 virtual void processRequirement(int level,
-                                                EA.Repository ea_repository,
                                                 ReqPro40.Project rq_project,
                                                 ReqPro40.Package rq_package,
                                                 ReqPro40.Requirement rq_requirement)
+      {
+      }
       /// <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 virtual void processObject(int level,
-                                           EA.Repository ea_repository,
                                            ReqPro40.Project rq_project,
                                            ReqPro40.Package rq_package,
                                            ReqPro40.Requirement rq_requirement)
+      {
+      }
+      protected void writeDelayedMessages()
+      {
+         foreach(string s in delayedMessages)
+         {
+            Main.EA_Repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, s, -1);
+         }
+      }
+      #region Requirement Type methods
+      /// <summary>
+      /// Get the requirement types from the ReqPro database, into a simple list, where each element
+      /// describes the requirement type and whether it is filtered or not. This list can be given to
+      /// the ReqProFilterForm to capture the users requirement type filtering decisions.
+      /// </summary>
+      protected void get_rq_req_types_from_database(ReqPro40.Project RQ_project)
+      {
+         rq_req_types = new ArrayList();
+         ReqPro40.ReqTypes rqtypes = RQ_project.ReqTypes;
+         foreach (ReqPro40.ReqType rq_type in rqtypes)
+         {
+            ReqPro_ReqType new_req_type = new ReqPro_ReqType(rq_type);
+            new_req_type.name     = rq_type.Name;
+            new_req_type.prefix   = rq_type.ReqPrefix;
+            rq_req_types.Add(new_req_type);
+         }
+      }
+      /// <summary>
+      /// Examine the requirement type list to see if the requirement type of the specified object
+      /// has been filtered or not.
+      /// </summary>
+      /// <param name="rq_obj"></param>
+      /// <returns></returns>
+      protected bool reqTypeIsFiltered(ReqPro_object rq_obj)
+      {
+         return ((ReqPro_ReqType)rq_req_types[rq_obj.tag_enum]).filtered;
+      }
+      protected bool reqTypeHasOneOrMoreAttrs(ReqPro_object rq_obj, ref bool hasStatus, ref bool hasDiff, ref bool hasPrio)
+      {
+         foreach (ReqPro_ReqType rp_rt in rq_req_types)
+         {
+            if (rq_obj.tag.StartsWith(rp_rt.prefix))
+            {
+               hasStatus = rp_rt.hasStatus;
+               hasDiff = rp_rt.hasDifficulty;
+               hasPrio = rp_rt.hasPriority;
+               return hasStatus | hasDiff | hasPrio;
+            }
+         }
+         return false;
+      }
+      #endregion
+      #region Requirement Status Type methods
+      /// <summary>
+      /// Get the requirement status types from the ReqPro database, into a simple list, where each element
+      /// describes the requirement status type and whether it is filtered or not. This list can be given to
+      /// the ReqProFilterForm to capture the users requirement status type filtering decisions.
+      /// </summary>
+      protected void get_rq_req_status_types_from_database(ReqPro40.Project RQ_project)
+      {
+         StringCollection status_values = new StringCollection();
+         // Each requirement type can have its own unique list of status attribute values
+         // so we have to go through each requirement type and find the set of status values
+         // that each one has and add them to out string collection, if the collection does
+         // not already have the strings ofcoarse. So, we are merging together all the status
+         // values in the ReqPro database, into one set.
+         foreach (ReqPro_ReqType rp_rt in rq_req_types)
+         {
+            try
+            {
+               ReqPro40.Attr attr = rp_rt.rq_type.get_Attr("Status", ReqPro40.enumAttrLookups.eAttrLookups_Label);
+               rp_rt.hasStatus = true;
+               foreach (ReqPro40.ListItem listItem in attr.ListItems)
+               {
+                  if (!status_values.Contains(listItem.Text))
+                  {
+                     status_values.Add(listItem.Text);
+                  }
+               }
+            }
+            catch
+            {
+               delayedMessages.Add( string.Format("WARNING, ReqPro requirement type ({0}) has no Status attribute", rp_rt.prefix) );
+            }
+            // Also check if this requirement type has any of the other attributes we might import. This is
+            // a little off topic for this function but this is a convenient place to do this until another
+            // function is written.
+            try
+            {
+               ReqPro40.Attr attr = rp_rt.rq_type.get_Attr("Difficulty", ReqPro40.enumAttrLookups.eAttrLookups_Label);
+               rp_rt.hasDifficulty = true;
+            }
+            catch
+            {
+               delayedMessages.Add( string.Format("WARNING, ReqPro requirement type ({0}) has no Difficulty attribute", rp_rt.prefix) );
+            };
+            try
+            {
+               ReqPro40.Attr attr = rp_rt.rq_type.get_Attr("Priority", ReqPro40.enumAttrLookups.eAttrLookups_Label);
+               rp_rt.hasPriority = true;
+            }
+            catch
+            {
+               delayedMessages.Add( string.Format("WARNING, ReqPro requirement type ({0}) has no Priority attribute", rp_rt.prefix) );
+            };
+         }
+         // if reqpro had no status values, then add a dummy one
+         if (status_values.Count == 0)
+         {
+            status_values.Add("Approved");
+         }
+         // With our merged set of status values, create a list of ReqPro_ReqStatus objects.
+         rq_req_status_types = new ArrayList();
+         foreach (string s in status_values)
+         {
+            ReqPro_ReqStatus new_ReqPro_ReqStatus = new ReqPro_ReqStatus();
+            new_ReqPro_ReqStatus.filtered = false;
+            new_ReqPro_ReqStatus.status_value = s;
+            rq_req_status_types.Add(new_ReqPro_ReqStatus);
+         }
+      }
+      /// <summary>
+      /// Examine the requirement status type list to see if the requirement status type of
+      /// the specified object has been filtered or not.
+      /// </summary>
+      /// <param name="rq_obj"></param>
+      /// <returns></returns>
+      protected bool reqStatusTypeIsFiltered(ReqPro_object rq_obj)
+      {
+         foreach (ReqPro_ReqStatus rqs in rq_req_status_types)
+         {
+            if (0 == rqs.status_value.CompareTo(rq_obj.status))
+            {
+               return rqs.filtered;
+            }
+         }
+         return false;
+      }
+      #endregion
       /// <summary>
       /// Initiates a ReqPro database parsing operation using a prompted reqpro database open operation
       /// </summary>
       /// <param name="ea_repository"></param>
       /// <returns></returns>
-      public virtual bool prompt_and_parse(EA.Repository ea_repository, ReqProDB_Artifact.MODE mode)
+      public virtual bool prompt_and_parse(ReqProDB_Artifact.MODE mode)
+      {
          ReqPro40.Application rq_app = null;
          ReqPro40.Project rq_project = null;
          try
          {
             // If we can find a ReqProDB artifact in the package, use it to logon to the ReqPro database
             ReqProDB_Artifact RQ_Artifact = new ReqProDB_Artifact();
-            EA.Element RQ_Element = RQ_Artifact.get_rq_artifact(ea_repository);
+            EA.Element RQ_Element = RQ_Artifact.get_rq_artifact();
             if (RQ_Element != null)
             {
                // check to see if the ReqProDB element has the same mode as that specified by parameter
-               ReqProDB_Artifact.MODE rq_art_mode = RQ_Artifact.get_mode(ea_repository, RQ_Element);
+               ReqProDB_Artifact.MODE rq_art_mode = RQ_Artifact.get_mode(RQ_Element);
                if (rq_art_mode != ReqProDB_Artifact.MODE.UNDEFINED)
                {
                   if (rq_art_mode != mode)
                   {
-                     DialogResult dlgRes = MessageBox.Show("You are attempting to use a ReqProDB element\n" +
+                     DialogResult dlgRes = MessageBoxEx.Show("You are attempting to use a ReqProDB element " +
-                        "for a different purpose than that which was\n" +
+                        "for a different purpose than that which was " +
-                        "specified when the element was first created.\n" +
+                        "specified when the element was first created. " +
                         "Continue Anyway?", "Confirm", MessageBoxButtons.YesNo);
                      if (dlgRes != DialogResult.Yes)
                      {
                         return false;
                      }
                   }
                }
+               if (Main.mustAbort)
+                  return false;
-               rq_project = RQ_Artifact.OpenReqProProject(ea_repository, RQ_Element);
+               rq_project = RQ_Artifact.OpenReqProProject(RQ_Element);
                if (rq_project != null)
                   rq_app = RQ_Artifact.RQ_app;
             }
+            if (Main.mustAbort)
+               return false;
             // If no ReqProDB artifact found, prompt user to logon to the ReqPro database
             if (rq_project == null)
             {
                // let user select the ReqPro database file name
                OpenFileDialog ofd = new OpenFileDialog();
                ofd.Title = "Select Requisite Pro project file";
                ofd.Filter = "ReqPro files (*.rqs)|*.rqs|All files (*.*)|*.*";
                DialogResult dlgRes = ofd.ShowDialog();
                if (dlgRes != DialogResult.OK)
+                  return false;
+               if (Main.mustAbort)
                   return false;
                // let user specifiy username/password
                Logon logon = new Logon("");
                dlgRes = logon.ShowDialog();
                if (dlgRes != DialogResult.OK)
+                  return false;
+               if (Main.mustAbort)
                   return false;
                string username = logon.ebUserName.Text;
                string password = logon.ebPassword.Text;
                // Connect to the ReqPro database using the ReqPro extensibility mechanism
                rq_app = new ReqPro40.ApplicationClass();
                rq_project =
                   rq_app.OpenProject(ofd.FileName,
                   ReqPro40.enumOpenProjectOptions.eOpenProjOpt_RQSFile,
                   username,
                   password,
                   enumProjectFlags.eProjFlag_Normal,
                   enumRelatedProjectOptions.eRelatedProjOption_ConnectAsSpecified);
+               if (Main.mustAbort)
+                  return false;
                // if we do not currently have a ReqProDB artifact, create one
                if (RQ_Element == null)
                {
-                  EA_Utilities EA_Utils = new EA_Utilities(ea_repository);
+                  EA_Utilities EA_Utils = new EA_Utilities();
-                  RQ_Element = RQ_Artifact.create_rq_artifact( ea_repository,
+                  RQ_Element = RQ_Artifact.create_rq_artifact(
                      EA_Utils.get_selected_package(),
                      rq_project.Name,
                      rq_project.Description,
                      logon.ebUserName.Text,
                      ofd.FileName,
                      rq_project.GUID);
                }
+               if (Main.mustAbort)
+                  return false;
             }
+            if (Main.mustAbort)
+               return false;
             // Now do the parsing of the ReqPro database
             if (rq_project != null)
             {
                // give req pro project object to user of this class
                provideReqProDatabaseInfo(rq_app, rq_project, RQ_Artifact, RQ_Element);
+               // get the requirement types from the req pro project
+               get_rq_req_types_from_database(rq_project);
+               get_rq_req_status_types_from_database(rq_project);
                // Get the ReqPro root package and parse it
+               Main.EA_Repository.WriteOutput(Main.GUI_OUTPUT_TAB_NAME, "Acquiring ReqPro Database", -1);
                ReqPro40.RootPackage rq_rootPackage = rq_project.GetRootPackage(true);
-               parseRootPackage(0, ea_repository, rq_project, rq_rootPackage);
+               parseRootPackage(0, rq_project, rq_rootPackage);
+               if (Main.mustAbort)
+                  return false;
                return true;
             }
          }
          catch (Exception ex)
          {
-            MessageBox.Show(ex.Message, "Error (ReqProParser::prompt_and_parse)", MessageBoxButtons.OK);
+            MessageBoxEx.Show(ex.Message, "Error (prompt_and_parse)", MessageBoxButtons.OK);
             if (rq_project != null)
                rq_project.CloseProject();
+         }
          return false;
       }
       /// <summary>
       /// This method handles the parsing of the root package in the ReqPro database.
       /// The method is almost identical to the parsePackage method, except that this
       /// deals with a ReqPro40.RootPackage object, whereas the latter deals with a
       /// ReqPro40.Package object. Perhaps the two functions could be combined into
       /// one if we move to .NET 2 where c# has some support for generic (template)
       /// programming.
       /// </summary>
       /// <param name="repository"></param>
       /// <param name="rq_project"></param>
       /// <param name="thisPackage"></param>
       private void parseRootPackage(int level,
-                                    EA.Repository ea_repository,
                                     ReqPro40.Project rq_project,
                                     ReqPro40.RootPackage thisPackage)
       {
          // Scan through the sub-packages of the root package
          int limit_packageCount = thisPackage.get_Count(ReqPro40.enumElementTypes.eElemType_Package);
          if (limit_packageCount > 0)
          {
             int i_packageCount;
             thisPackage.MoveFirst();
             for (i_packageCount = 0; i_packageCount < limit_packageCount; i_packageCount++)
             {
+               if (Main.mustAbort)
+                  break;
                // Read the sub-package and parse it
                ReqPro40.Package subPackage = (ReqPro40.Package)thisPackage.GetCurrentElement();
-               parsePackage(level+1, ea_repository, rq_project, subPackage);
+               parsePackage(level+1, "", rq_project, subPackage);
                thisPackage.MoveNext();
             }
          }
+         if (Main.mustAbort)
+            return;
          // Scan through the requirements directly beneath the root package
          int limit_reqCount = thisPackage.get_Count(ReqPro40.enumElementTypes.eElemType_Requirement);
          if (limit_reqCount > 0)
          {
             // Obtain the requirement element key list from the root package and scan through each entry
             int i_reqCount;
             System.Object[,] keyList = (System.Object[,])thisPackage.KeyList(ReqPro40.enumElementTypes.eElemType_Requirement);
             for (i_reqCount = 0; i_reqCount < limit_reqCount; i_reqCount++)
             {
+               if (Main.mustAbort)
+                  break;
                // Obtain the ReqPro requirement from its key, and parse it
                ReqPro40.Requirement thisRequirement =
                   rq_project.GetRequirement(keyList[0,i_reqCount],
                                             ReqPro40.enumRequirementLookups.eReqLookup_Key,
                                             ReqPro40.enumRequirementsWeights.eReqWeight_Heavy,
                                             ReqPro40.enumRequirementFlags.eReqFlag_RetainHierarchy);
                if (thisRequirement != null)
                {
-                  parseRequirement(level+1, ea_repository, rq_project, null, thisRequirement);
+                  parseRequirement(level+1, rq_project, null, thisRequirement);
                }
             }
          }
       }
       /// <summary>
       /// This method handles the parsing of each package beneath the root package
       /// in the ReqPro database.
       /// The method is almost identical to the parseRootPackage method, except that
       /// this deals with a ReqPro40.Package object, whereas the latter deals with a
       /// one if we move to .NET 2 where c# has some support for generic (template)
       /// programming.
       /// </summary>
       /// <param name="repository"></param>
       /// <param name="rq_project"></param>
       /// <param name="thisPackage"></param>
       private void parsePackage(int level,
-                                EA.Repository ea_repository,
+                                string prefix,
                                 ReqPro40.Project rq_project,
                                 ReqPro40.Package thisPackage)
       {
+         if (Main.mustAbort)
+            return;
+         Main.EA_Repository.WriteOutput(Main.GUI_OUTPUT_TAB_NAME, prefix + thisPackage.Name, -1);
          // call user defined functions
-         processPackage(level, ea_repository, rq_project, thisPackage);
+         processPackage(level, rq_project, thisPackage);
-         processObject(level, ea_repository, rq_project, thisPackage, null);
+         processObject(level, rq_project, thisPackage, null);
          // Scan through the sub-packages of this package
          int limit_packageCount = thisPackage.get_Count(ReqPro40.enumElementTypes.eElemType_Package);
          if (limit_packageCount > 0)
          {
             int i_packageCount;
             thisPackage.MoveFirst();
             for (i_packageCount = 0; i_packageCount < limit_packageCount; i_packageCount++)
             {
+               if (Main.mustAbort)
+                  break;
                // Read the sub-package and parse it
                ReqPro40.Package subPackage = (ReqPro40.Package)thisPackage.GetCurrentElement();
-               parsePackage(level+1, ea_repository, rq_project, subPackage);
+               parsePackage(level+1, prefix + "    ", rq_project, subPackage);
                thisPackage.MoveNext();
             }
          }
+         if (Main.mustAbort)
+            return;
          // Scan through the requirements directly beneath this package
          int limit_reqCount = thisPackage.get_Count(ReqPro40.enumElementTypes.eElemType_Requirement);
          if (limit_reqCount > 0)
          {
             // Obtain the requirement element key list from this package and scan through each entry
             int i_reqCount;
             System.Object[,] keyList = (System.Object[,])thisPackage.KeyList(ReqPro40.enumElementTypes.eElemType_Requirement);
             for (i_reqCount = 0; i_reqCount < limit_reqCount; i_reqCount++)
             {
+               if (Main.mustAbort)
+                  break;
                // Obtain the ReqPro requirement from its key, and parse it
                ReqPro40.Requirement thisRequirement =
                   rq_project.GetRequirement(keyList[0,i_reqCount],
                                             ReqPro40.enumRequirementLookups.eReqLookup_Key,
                                             ReqPro40.enumRequirementsWeights.eReqWeight_Heavy,
                                             ReqPro40.enumRequirementFlags.eReqFlag_RetainHierarchy);
                if (thisRequirement != null)
                {
-                  parseRequirement(level+1, ea_repository, rq_project, thisPackage, thisRequirement);
+                  parseRequirement(level+1, rq_project, thisPackage, thisRequirement);
                }
             }
          }
       }
       /// <summary>
       /// This method parses a requirement and any sub-requirements found in the
       /// ReqPro database by the package/root package parsers.
       /// NOTE that when called from the parseRootPackage method, the thisPackage
       /// parameter will be null.
       /// </summary>
       /// <param name="repository"></param>
       /// <param name="rq_project"></param>
       /// <param name="thisPackage"></param>
       /// <param name="thisRequirement"></param>
       private void parseRequirement(int level,
-                                    EA.Repository ea_repository,
                                     ReqPro40.Project rq_project,
                                     ReqPro40.Package thisPackage,
                                     ReqPro40.Requirement thisRequirement)
       {
+         if (Main.mustAbort)
+            return;
          // call user defined functions
-         processRequirement(level, ea_repository, rq_project, thisPackage, thisRequirement);
+         processRequirement(level, rq_project, thisPackage, thisRequirement);
-         processObject(level, ea_repository, rq_project, thisPackage, thisRequirement);
+         processObject(level, rq_project, thisPackage, thisRequirement);
          // requirements can have children that are requirements, so we have to find those
          int limit_numberOfChildren = 0;
          if (true == thisRequirement.get_HasChildren(ref limit_numberOfChildren))
          {
             // scan through the child relationships
             ReqPro40.Relationships theseRelationships = (ReqPro40.Relationships)thisRequirement.Children;
             int i_numberOfChildren;
             theseRelationships.MoveFirst();
             for (i_numberOfChildren = 0; i_numberOfChildren < limit_numberOfChildren; i_numberOfChildren++)
             {
+               if (Main.mustAbort)
+                  break;
                // Obtain the sub-requirement from the relationship, and parse it
                ReqPro40.Relationship thisRelationship = theseRelationships.GetCurrentRelationship();
                ReqPro40.Requirement subRequirement =
                   thisRelationship.get_DestinationRequirement(ReqPro40.enumRequirementsWeights.eReqWeight_Heavy);
                if (subRequirement != null)
                {
-                  parseRequirement(level+1, ea_repository, rq_project, thisPackage, subRequirement);
+                  parseRequirement(level+1, rq_project, thisPackage, subRequirement);
                }
                theseRelationships.MoveNext();
             }
          }
       }
+	}
+}

Subversion Repositories DevTools

(root)/EA_ReqPro/trunk/EA_ReqPro/ReqProParser.cs – Rev 2145 → 2151