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

 namespace EA_ReqPro
+{
 	/// <summary>
    /// ImportReqProDatabase is a specialisation of CopyReqProDatabaseToMemory, designed to copy the
    /// ReqPro database content into an EA database, discarding the structure of and hierarchy of
    /// packages, selecting just the requirements found in the ReqPro database for storage into EA,
    /// where they will be used for design traceability purposes.
 	/// </summary>
    public class ImportReqProDatabase : CopyReqProDatabaseToMemory
+   {
+      {
          public ArrayList ea_reqs;
          public ArrayList ea_GUIDs;
          public ArrayList new_ea_reqs;
          public ArrayList new_ea_GUIDs;
+         public ArrayList orphaned_ea_reqs;
       };
-      private req_lists_t req_lists = new req_lists_t();
+      private req_lists_t gReq_lists = new req_lists_t();
       private int totalRequirements = 0;
       private EA.Package gCurrentPackage = null;
       private EA.Package gNewReqProDBPackage = null;
       private EA.Package gChangeHistoryPackage = null;
       private EA.Package gOrphansPackage = null;
+      private int gNewRequirementCount = 0;
+      private int gModifiedRequirementCount = 0;
+      private int gStatusUpdatedRequirementCount = 0;
+      private int gOrphanedCount = 0;
+      private EA.Element gChangeLog = null;
       /// <summary>
       /// Constructor logic
       /// </summary>
       /// <param name="ea_repository"></param>
+            }
+         }
          catch (Exception ex)
+         {
             Main.MessageBoxException(ex, "Exception (parse)");
          }
          return false;
+      }
             // a time.
             string delimStr = "\n";
             char [] delim = delimStr.ToCharArray();
             string[] log_strings = changeLog.Notes.Split(delim,2000);
-            // Prepare a string to form an updated change log (needed to support the activity of orphaned
-            // requirement deletion).
-            string newList = "";
             // modify delimiters to : character so that we can extract the parameters for each log entry
             delimStr = ":";
             delim = delimStr.ToCharArray();
+            {
                if (Main.mustAbort)
                   break;
                // over time, users may delete the orphaned requirements from the EA database, but their
                // GUIDs will still exist in the change log. Use of such a GUID will cause
                // an exception in the GetElementByGuid() function. What should we do? We can attempt
                // to remove those GUIDs from the list. We can do this by accumulating a new list of GUIDs
                // that is formed from the old list, where only good items from the old list find their
                // way into the new list. Gradually, the list is wittled away as EA users delete orphaned
                // requirements having first dealt with the design change impacts that resulted from their
                // orphanage.
                try
+               {
                            // we dont care about direction of relationship, so test for both
                            if (theConnector.ClientID == ea_req.ElementID)
                               destId = theConnector.SupplierID;
                            else if (theConnector.SupplierID == ea_req.ElementID)
                               destId = theConnector.ClientID;
                            else
                               destId = theConnector.SupplierID;
                            // and make sure we filter out self-referential connectors
                            if (destId != ea_req.ElementID)
+                           {
+                     {
                         Main.WriteOutput(string.Format("  Modified {0}: {1}", Constants.CHG_LOG_SOURCE, ea_req.Name), ea_req.ElementID );
                         Main.WriteOutput("     <<< " + parameters[2], ea_req.ElementID);
                         Main.WriteOutput("     >>> " + parameters[3], ea_req.ElementID);
+                     }
-                     // accumulate good item into the newList
-                     newList += trimmed_s + "\r\n";
+                  }
+               }
                catch
+               {
-                  // do nothing - the newList accumulator will not have the GUID that caused the exception
-                  // so the next time a display operation is attempted, the exception wont happen.
+               }
+            }
-            // Update the change log
-            changeLog.Notes = newList;
-            changeLog.Update();
+         }
+      }
       /// <summary>
       /// Rid a string of any : char because we use that as a delimiter in the change log and so we
       /// do not want a users use of the character to confuse the change log display mechanism.
       /// </summary>
       /// <param name="s"></param>
       /// <returns></returns>
       private string NO_COLONS(string s)
+      {
          string sc =  s.Replace(':', ' ');
          sc = sc.Replace('\r' , ' ');
          sc = sc.Replace('\n' , ' ');
          return sc;
+      }
          try
+         {
             DialogResult dlgres;
             // begin to initialise some of our element lists
-            req_lists.new_ea_reqs = new ArrayList();
+            gReq_lists.new_ea_reqs = new ArrayList();
-            req_lists.new_ea_GUIDs = new ArrayList();
+            gReq_lists.new_ea_GUIDs = new ArrayList();
-            req_lists.ea_GUIDs = new ArrayList();
+            gReq_lists.ea_GUIDs = new ArrayList();
+            gReq_lists.orphaned_ea_reqs = new ArrayList();
             ArrayList ea_req_matched = new ArrayList();
             // Obtain the EA parent package so that we can create under it our ReqProDB structure and change history packages
             EA.Package parentPackage = Main.EA_Repository.GetPackageByID( base.RQ_Element.PackageID );
             Main.WriteOutput("Acquiring list of elements already in EA", -1);
             EA_ElementAccumulator reqLister = new EA_ElementAccumulator(allowedElementTypes);
             EA_Parsing.findAndProcessPackageElements( parentPackage, reqLister, true );
-            req_lists.ea_reqs = reqLister.Elements;
+            gReq_lists.ea_reqs = reqLister.Elements;
             if (Main.mustAbort)
                return;
-            // For the lsit we just found, get an adjacent list of the associated ReqPro GUIDs.
+            // For the list we just found, get an adjacent list of the associated ReqPro GUIDs.
             // The two lists will be indexable by the same index.
-            foreach (EA.Element ea_req in req_lists.ea_reqs)
+            foreach (EA.Element ea_req in gReq_lists.ea_reqs)
+            {
                string GUID = EA_TaggedValues.Read(ea_req, Constants.TAG_GUID);
-               req_lists.ea_GUIDs.Add(GUID);
+               gReq_lists.ea_GUIDs.Add(GUID);
                ea_req_matched.Add(false);
+            }
             if (Main.mustAbort)
                return;
             // Create the change log element in the change history package
-            EA.Element changeLog = (EA.Element)gChangeHistoryPackage.Elements.AddNew("Change Log" + " - import " + importDateTime, "InformationItem");
+            gChangeLog = (EA.Element)gChangeHistoryPackage.Elements.AddNew("Change Log" + " - import " + importDateTime, "InformationItem");
+            gChangeLog.Notes = "";
-            changeLog.TreePos = gChangeHistoryPackage.Elements.Count - 1;
+            gChangeLog.TreePos = gChangeHistoryPackage.Elements.Count - 1;
-            changeLog.Update();
+            gChangeLog.Update();
             // Get a flattened list of requirements from the hierarchical data the user has filtered
             ArrayList rq_req_collection = new ArrayList();
             get_rq_req_collection(ref rq_req_collection);
             // initialise some statistical vars
-            int newRequirementCount = 0;
+            gNewRequirementCount = 0;
-            int modifiedRequirementCount = 0;
+            gModifiedRequirementCount = 0;
-            int statusUpdatedRequirementCount = 0;
+            gStatusUpdatedRequirementCount = 0;
-            int orphanedCount = 0;
+            gOrphanedCount = 0;
             Main.WriteOutput("Merging ReqPro content to EA", -1);
             // loop through all of the ReqPro requirements we have captured from the ReqPro database
                try
+               {
                   // Find which EA requirement element refers to the current ReqPro GUID
                   int i_ea_req;
-                  i_ea_req = req_lists.ea_GUIDs.IndexOf( rq_obj.guid );
+                  i_ea_req = gReq_lists.ea_GUIDs.IndexOf( rq_obj.guid );
                   // If EA element was found
                   if (0 <= i_ea_req)
+                  {
+                     // update orphanage detection data
                      ea_req_matched[i_ea_req] = true;
+                     rq_obj.matched = true;
-                     EA.Element ea_req = ((EA.Element)req_lists.ea_reqs[i_ea_req]);
+                     EA.Element ea_req = ((EA.Element)gReq_lists.ea_reqs[i_ea_req]);
                      rq_obj.ea_element_ID = ea_req.ElementID;
                      // Only update the requirement if it was not mastered in EA, or
                      // unrestricted imports have been enabled
                      if (  (false == EA_TaggedValues.Read(ea_req, Constants.TAG_CREATED_IN_EA, Constants.DEFAULT_CREATED_IN_EA))
                         || (true == EA_TaggedValues.Read(ea_req, Constants.TAG_UNRESTRICTED_IMPORTS, Constants.DEFAULT_UNRESTRICTED_IMPORTS)) )
+                     {
                         // This ReqPro requirement already has a counterpart in EA, so we must simply
                         // update the counterpart. But, to aid the designer, we need to try to tell them
                         // how the requirement has changed, which could ofcoarse change the meaning
                         // of the requirement and require design changes to be done.
                         bool meaningMayHaveChanged = false;
                         bool statusMayHaveChanged = false;
                         string ea_req_name = rq_obj.tag + " " + rq_obj.name;
                         Main.WriteOutput("Updating: " + ea_req_name, rq_obj.ea_element_ID);
-                        ea_req.Name       = updated_property_value_if_changed(changeLog, ea_req, ea_req.Name, Constants.CHG_LOG_NAME, ea_req_name, ref meaningMayHaveChanged);
+                        ea_req.Name       = updated_property_value_if_changed(gChangeLog, ea_req, ea_req.Name, Constants.CHG_LOG_NAME, ea_req_name, ref meaningMayHaveChanged);
-                        ea_req.Notes      = updated_property_value_if_changed(changeLog, ea_req, ea_req.Notes, Constants.CHG_LOG_NOTES, rq_obj.text, ref meaningMayHaveChanged);
+                        ea_req.Notes      = updated_property_value_if_changed(gChangeLog, ea_req, ea_req.Notes, Constants.CHG_LOG_NOTES, rq_obj.text, ref meaningMayHaveChanged);
-                        ea_req.Difficulty = updated_property_value_if_changed(changeLog, ea_req, ea_req.Difficulty, Constants.CHG_LOG_DIFFICULTY, rq_obj.difficulty, ref statusMayHaveChanged);
+                        ea_req.Difficulty = updated_property_value_if_changed(gChangeLog, ea_req, ea_req.Difficulty, Constants.CHG_LOG_DIFFICULTY, rq_obj.difficulty, ref statusMayHaveChanged);
-                        ea_req.Priority   = updated_property_value_if_changed(changeLog, ea_req, ea_req.Priority, Constants.CHG_LOG_PRIORITY, rq_obj.priority, ref statusMayHaveChanged);
+                        ea_req.Priority   = updated_property_value_if_changed(gChangeLog, ea_req, ea_req.Priority, Constants.CHG_LOG_PRIORITY, rq_obj.priority, ref statusMayHaveChanged);
-                        ea_req.Status     = updated_property_value_if_changed(changeLog, ea_req, ea_req.Status, Constants.CHG_LOG_STATUS, rq_obj.status, ref statusMayHaveChanged);
+                        ea_req.Status     = updated_property_value_if_changed(gChangeLog, ea_req, ea_req.Status, Constants.CHG_LOG_STATUS, rq_obj.status, ref statusMayHaveChanged);
-                        if_tagged_value_changed_update_it(changeLog, ea_req, Constants.TAG_SOURCE, Constants.CHG_LOG_SOURCE, rq_obj.source, ref statusMayHaveChanged);
+                        if_tagged_value_changed_update_it(gChangeLog, ea_req, Constants.TAG_SOURCE, Constants.CHG_LOG_SOURCE, rq_obj.source, ref statusMayHaveChanged);
-                        if_tagged_value_changed_update_it(changeLog, ea_req, Constants.TAG_SOURCE_VERSION, Constants.CHG_LOG_SOURCE_VERSION, rq_obj.sourceVersion, ref statusMayHaveChanged);
+                        if_tagged_value_changed_update_it(gChangeLog, ea_req, Constants.TAG_SOURCE_VERSION, Constants.CHG_LOG_SOURCE_VERSION, rq_obj.sourceVersion, ref statusMayHaveChanged);
-                        if_tagged_value_changed_update_it(changeLog, ea_req, Constants.TAG_SOURCE_SECTION, Constants.CHG_LOG_SOURCE_SECTION, rq_obj.sourceSection, ref statusMayHaveChanged);
+                        if_tagged_value_changed_update_it(gChangeLog, ea_req, Constants.TAG_SOURCE_SECTION, Constants.CHG_LOG_SOURCE_SECTION, rq_obj.sourceSection, ref statusMayHaveChanged);
-                        if_tagged_value_changed_update_it(changeLog, ea_req, Constants.TAG_SUBSYSTEM, Constants.CHG_LOG_SUBSYSTEM_TYPE, rq_obj.subsystem, ref statusMayHaveChanged);
+                        if_tagged_value_changed_update_it(gChangeLog, ea_req, Constants.TAG_SUBSYSTEM, Constants.CHG_LOG_SUBSYSTEM_TYPE, rq_obj.subsystem, ref statusMayHaveChanged);
-                        if_tagged_value_changed_update_it(changeLog, ea_req, Constants.TAG_STABILITY, Constants.CHG_LOG_STABILITY, rq_obj.stability, ref statusMayHaveChanged);
+                        if_tagged_value_changed_update_it(gChangeLog, ea_req, Constants.TAG_STABILITY, Constants.CHG_LOG_STABILITY, rq_obj.stability, ref statusMayHaveChanged);
                         // Requirement Types are actually implemented using ordinary EA element stereotypes.
                         string[] sar = ea_req.StereotypeEx.Split(",".ToCharArray());
                         // if we didnt get a requirement type from the ReqPro database, set it to an empty string so that it can
                            // thinks is assigned to the requirement element, so check against that for changes
                            string sar0 = sar[0].Trim();
                            if (!sar0.Equals(rq_obj.type))
+                           {
-                              changeLog.Notes += ea_req.ElementGUID + ":" + Constants.CHG_LOG_REQ_TYPE + ":" + sar0 + ":" + rq_obj.type + "\r\n";
+                              gChangeLog.Notes += ea_req.ElementGUID + ":" + Constants.CHG_LOG_REQ_TYPE + ":" + sar0 + ":" + rq_obj.type + "\r\n";
-                              changeLog.Update();
+                              gChangeLog.Update();
                               statusMayHaveChanged = true;
                               ea_req.StereotypeEx = rq_obj.type;
                               ea_req.Stereotype = rq_obj.type;
+                           }
+                        }
                         else if (!ea_req.Stereotype.Equals(rq_obj.type))
+                        {
-                           changeLog.Notes += ea_req.ElementGUID + ":" + Constants.CHG_LOG_REQ_TYPE + ":" + ea_req.Stereotype + ":" + rq_obj.type + "\r\n";
+                           gChangeLog.Notes += ea_req.ElementGUID + ":" + Constants.CHG_LOG_REQ_TYPE + ":" + ea_req.Stereotype + ":" + rq_obj.type + "\r\n";
-                           changeLog.Update();
+                           gChangeLog.Update();
                            statusMayHaveChanged = true;
                            ea_req.StereotypeEx = rq_obj.type;
                            ea_req.Stereotype = rq_obj.type;
+                        }
                         ea_req.Update();
                         if (meaningMayHaveChanged)
+                        {
-                           modifiedRequirementCount++;
+                           gModifiedRequirementCount++;
+                        }
                         if (statusMayHaveChanged)
+                        {
-                           statusUpdatedRequirementCount++;
+                           gStatusUpdatedRequirementCount++;
+                        }
                         totalRequirements++;
+                     }
+                  }
                   else
+                  {
+                     // update orphanage detection data
+                     rq_obj.matched = true;
                      totalRequirements++;
                      // This ReqPro requirement does not have a counterpart in EA, so we must create
                      // a new one.
-                     newRequirementCount++;
+                     gNewRequirementCount++;
                      // create the new EA requirement in the import package
                      EA.Element ea_req = (EA.Element)gChangeHistoryPackage.Elements.AddNew( rq_obj.tag + " " + rq_obj.name, "Requirement");
                      rq_obj.ea_element_ID = ea_req.ElementID;
                      ea_req.Notes = rq_obj.text;
                      ea_req.Update();
                      // add the new requirement to our list for later processing
-                     req_lists.new_ea_reqs.Add(ea_req);
+                     gReq_lists.new_ea_reqs.Add(ea_req);
-                     req_lists.new_ea_GUIDs.Add(rq_obj.guid);
+                     gReq_lists.new_ea_GUIDs.Add(rq_obj.guid);
-                     changeLog.Notes += ea_req.ElementGUID + ":Created:" + ea_req.Name + "\r\n";
+                     gChangeLog.Notes += ea_req.ElementGUID + ":Created:" + ea_req.Name + "\r\n";
-                     changeLog.Update();
+                     gChangeLog.Update();
                      Main.WriteOutput("Created: " + ea_req.Name, ea_req.ElementID);
+                  }
+               }
                catch (Exception ex)
+               {
                   Main.WriteOutput("Exception (ImportFromReqPro), " + ex.Message + ", " + rq_obj.name, -1);
+               }
             if (Main.mustAbort)
                return;
             Main.WriteOutput("Checking for orphaned requirements", -1);
-            // Now check for orphaned EA requirements
+            // Now do initial check for orphaned EA requirements
-            for (int i = 0; i < req_lists.ea_GUIDs.Count; i++)
+            for (int i = 0; i < gReq_lists.ea_GUIDs.Count; i++)
+            {
                if (Main.mustAbort)
                   break;
-               string rq_GUID = (string)req_lists.ea_GUIDs[i];
+               string rq_GUID = (string)gReq_lists.ea_GUIDs[i];
                if (rq_GUID != "")
+               {
                   if ((bool)ea_req_matched[i] == false)
+                  {
-                     EA.Element ea_req = (EA.Element)req_lists.ea_reqs[i];
+                     EA.Element ea_req = (EA.Element)gReq_lists.ea_reqs[i];
-                     orphanedCount++;
-                     changeLog.Notes += ea_req.ElementGUID + ":Orphaned:" + ea_req.Name + "\r\n";
-                     changeLog.Update();
+                     add_to_orphan_list(ref ea_req);
+                  }
+               }
+            }
-            // If there is any change to report, ask user if they want to see it now, and if so, display it
-            if (changeLog.Notes != null && changeLog.Notes.Length > 0)
-            {
-               dlgres = MessageBoxEx.Show("Display Change Log?", "Change Log", MessageBoxButtons.YesNo);
-               if (dlgres == DialogResult.Yes)
-                  displayChangeLog(changeLog);
-            }
-            if (Main.mustAbort)
-               return;
             // Now we import the ReqPro database package structure and migrate all of our existing or
             // new requirements into it. We only create the structure we need, ie. empty package structure
             // will not be created unecessarily.
             Main.WriteOutput("Importing latest ReqPro database package structure", -1);
             populate_latest_reqprodb_structure_package(rq_root_package);
             gNewReqProDBPackage.Packages.Refresh();
             Main.EA_Repository.RefreshModelView(parentPackage.PackageID);
             if (Main.mustAbort)
                return;
+            // If there is any change to report, ask user if they want to see it now, and if so, display it
+            if (gChangeLog.Notes != null && gChangeLog.Notes.Length > 0)
+            {
+               dlgres = MessageBoxEx.Show("Display Change Log?", "Change Log", MessageBoxButtons.YesNo);
+               if (dlgres == DialogResult.Yes)
+                  displayChangeLog(gChangeLog);
+            }
+            if (Main.mustAbort)
+               return;
+            // Take care of orphaned packages that have been orphaned due to a reduction in the scope of import.
+            //Main.WriteOutput("Re-locating orphaned requirements (if any)", -1);
+            //foreach (EA.Element ea_req_orphaned in ea_reqs_orphaned)
+            //{
+            //   ea_req_orphaned.PackageID = gOrphansPackage.PackageID;
+            //   ea_req_orphaned.Update();
+            //}
             // Remove the old superseded facsimile of the ReqPro database package structure. At this point,
             // orphaned requirements left in these will be moved to the Orphaned package, before the old
             // structure package is removed.
             Main.WriteOutput("Removing old ReqPro database package structures", -1);
             remove_old_empty_structures(parentPackage, gNewReqProDBPackage);
             if (Main.mustAbort)
                return;
                return;
             // Output any messages the underlying parser may have collected as a result of observations it has made
             // regarding the data it has read from the ReqPro database.
             writeDelayedMessages();
             // display summary stats
-            Main.WriteOutput(newRequirementCount.ToString() + " new requirements", -1);
+            Main.WriteOutput(gNewRequirementCount.ToString() + " new requirements", -1);
-            Main.WriteOutput(modifiedRequirementCount.ToString() + " requirements modified", -1);
+            Main.WriteOutput(gModifiedRequirementCount.ToString() + " requirements modified", -1);
-            Main.WriteOutput(statusUpdatedRequirementCount.ToString() + " requirements had status changes", -1);
+            Main.WriteOutput(gStatusUpdatedRequirementCount.ToString() + " requirements had status changes", -1);
-            Main.WriteOutput(orphanedCount.ToString() + " requirements were orphaned", -1);
+            Main.WriteOutput(gOrphanedCount.ToString() + " requirements were orphaned", -1);
             Main.WriteOutput("Import Completed", -1);
             MessageBoxEx.Show("Import Completed");
+         }
          catch (Exception ex)
+         {
             Main.MessageBoxException(ex, "Exception (ImportFromReqPro)");
+         }
+      }
       private string updated_property_value_if_changed(EA.Element changeLog,
          EA.Element ea_req,
          string dest_value,
          string changeLogName,
          string source_value,
          ref bool mayHaveChanged)
+      {
          if (dest_value.CompareTo(source_value) != 0 )
+         {
+         }
          return dest_value;
+      }
       private void if_tagged_value_changed_update_it(EA.Element changeLog,
          EA.Element ea_req,
          string tagname,
          string changeLogName,
          string source_value,
          ref bool statusMayHaveChanged)
+      {
          string value = EA_TaggedValues.Read(ea_req, tagname, "");
          if ((source_value != null) && (false == source_value.Equals(value)))
+      }
       /// <summary>
       /// This method (along with its sibling overload) obtains a flattened view of the
       /// hierarchical requirements obtained from the ReqPro database. This accumulation
       /// takes account of the users filtering requests.
       /// </summary>
       /// <param name="ea_repository"></param>
       private void get_rq_req_collection(ref ArrayList rq_req_collection)
+            {
                // Add this requirement to the flattened list we are accumulating
                rq_req_collection.Add(rq_obj);
                // In ReqPro, a requirement can be related to another requirement in several ways:
                // 1. By virtue of its position relative to another in the browser display. That is,
                //    if you place a requirement beneath a parent requirement, you are establishing a
                //    parent-child relationship.
                // 2. By virtue of a specific TraceTo relationship being made via the Traceability menu
                //    option.
                // Interestingly, ReqPro prevents you creating a relationship of one of the above types,
                // if a relationship of the other type already exists. This implies that the relationship
                // between a parent and child requirement must be singular and is important regardless
                // of the manner in which it was created or represented.
                // The CopyReqProDatabaseToMemory base class will already have taken care of recording
                // relationships detected from ReqPro made using method 2 above. What we need to do here is
                // take care of those apparent from the browser based hierarchical organisation (ie. made
                // in ReqPro using method 1).
                // All we need to do is grab the parent object (if any) and add the GUID of the child to
                // its list of trace-to's. Later on, the write_traces() class method will turn these into
                // EA based connection objects that belong to the parent requirement elements.
                if (rq_obj.parent != null)
+               {
                   rq_obj.parent.ReqPro_traces.Add(rq_obj.guid);
+               }
                // Using recursion, scan this objects sub-objects, which in practise will all
                // be requirement objects. At this time requirement objects cannot have packages
                // as children.
                foreach( ReqPro_object sub_obj in rq_obj.ReqPro_objects )
+               {
                   get_rq_req_collection(ref rq_req_collection, sub_obj);
+               }
       /// <summary>
       /// Populates a ReqProDB structure package to be used as a home for the requirements within the
       /// overall import container, and re-locate requirements into it from wherever they may be elsewhere
       /// within and under the import container.
       /// </summary>
       /// <param name="rq_obj"></param>
       private void populate_latest_reqprodb_structure_package(ReqPro_object rq_obj)
                // Examine all of our requirement lists to try and re-locate the requirements from
                // the old structure(s) to the new one.
                // re-locate existing requirements updated during this import
                int i_ea_req;
-               i_ea_req = req_lists.ea_GUIDs.IndexOf( sub_obj.guid );
+               i_ea_req = gReq_lists.ea_GUIDs.IndexOf( sub_obj.guid );
                if (0 <= i_ea_req)
+               {
-                  ea_req = ((EA.Element)req_lists.ea_reqs[i_ea_req]);
+                  ea_req = ((EA.Element)gReq_lists.ea_reqs[i_ea_req]);
                   EA.Package pkg = get_or_create_latest_structure(sub_obj);
+                  if (sub_obj.matched == false)
+                  {
+                     add_to_orphan_list(ref ea_req);
+                     ea_req.PackageID = gOrphansPackage.PackageID;   // re-locate
+                     ea_req.Update();
+                  }
+                  else if (sub_obj.filtered == false)
+                  {
-                  ea_req.PackageID = pkg.PackageID;   // re-locate
+                     ea_req.PackageID = pkg.PackageID;   // re-locate
-                  ea_req.TreePos = sub_obj.treePos;
+                     ea_req.TreePos = sub_obj.treePos;
-                  ea_req.Update();
+                     ea_req.Update();
+                  }
+                  else
+                  {
+                     // QUESTION: So what if it is filtered? What happens to it then?
+                     // Will it stay in the same place or be relocated as an orphan?
+                     // ANSWER: relocate_elements_to_orphans_package() does this, called later
+                     // in the import sequence.
+                  }
+               }
                else
+               {
                   // re-locate new requirements that have come in for the first time on this import.
-                  i_ea_req = req_lists.new_ea_GUIDs.IndexOf( sub_obj.guid );
+                  i_ea_req = gReq_lists.new_ea_GUIDs.IndexOf( sub_obj.guid );
                   if (0 <= i_ea_req)
+                  {
-                     ea_req = ((EA.Element)req_lists.new_ea_reqs[i_ea_req]);
+                     ea_req = ((EA.Element)gReq_lists.new_ea_reqs[i_ea_req]);
                      EA.Package pkg = get_or_create_latest_structure(sub_obj);
                      ea_req.PackageID = pkg.PackageID;   // re-locate
                      ea_req.TreePos = sub_obj.treePos;
                      ea_req.Update();
+                  }
+               }
                // Re-locate requirement under its parent requirement, if such a relationship exists.
                if (ea_req != null && sub_obj.parent.isRequirement)
+               {
-                  // Only do this if the parent requirement has not been orphaned
+                  // Only do this if the parent requirement has not been orphaned or filtered out of the import
                   if (sub_obj.parent.ea_element_ID != -1)
+                  {
                      EA.Element parent_ea_req = Main.EA_Repository.GetElementByID(sub_obj.parent.ea_element_ID);
                      if (parent_ea_req != null)
+                     {
+                        // make sure we only assign ele-to-ele relationship if both elements are in the same
+                        // package
+                        if (ea_req.PackageID == parent_ea_req.PackageID)
+                        {
-                        ea_req.ParentID = parent_ea_req.ElementID;   // re-locate
+                           ea_req.ParentID = parent_ea_req.ElementID;   // re-locate
-                        ea_req.TreePos = sub_obj.treePos;
+                           ea_req.TreePos = sub_obj.treePos;
-                        ea_req.Update();
+                           ea_req.Update();
+                        }
+                     }
+                  }
                   else
+                  {
                      // TODO: what if the parent requirement has been orphaned, but the child as represented by
+      }
       /// <summary>
       /// This is a helper for the populate_latest_reqprodb_structure_package() function. It allows on-the-fly
       /// EA package path construction, triggered whenever we find we have a requirement to
       /// re-locate into the latest facsimile of the ReqPro database structure.
       /// </summary>
       /// <param name="rq_obj"></param>
       /// <returns></returns>
       private EA.Package get_or_create_latest_structure(ReqPro_object rq_obj)
          // to here.
          return Main.EA_Repository.GetPackageByID(rq_root_package.ea_element_ID);
+      }
       /// <summary>
       /// Remove the old ReqProDB structure packages if they are now empty of requirements. IF some
       /// requirements remain in them, they are moved to the orphaned package so that the old ReqProDB
       /// packages can be removed.
       /// </summary>
       /// <param name="parentPackage"></param>
       /// <param name="new_structure_pkg"></param>
             relocate_elements_to_orphans_package(gCurrentPackage);
             // Now delete the old ReqProDB structure package
             parentPackage.Packages.DeleteAt(i, false);
+         }
          parentPackage.Packages.Refresh();
          Main.EA_Repository.RefreshModelView(parentPackage.PackageID);
+      }
       /// <summary>
       /// Re-locate all requirements that remain under a ReqProDB structure package, to its
       /// top level, so that later on, the package hierarchy within it can be removed.
       /// </summary>
       /// <param name="parentPackage"></param>
       private void relocate_elements_to_orphans_package(EA.Package parentPackage)
+      {
+         }
+      }
       /// <summary>
       /// Moves all elements out of an old-style import package, and into the new ReqProDB structure package.
       /// Change Log elements are handled in a special way such that they are renamed from plain "Change Log"
       /// to the new style "Change Log - import <date> <time>" format, and are moved into the new "Change History"
       /// package.
       /// </summary>
       /// <param name="parentPackage"></param>
       private void migrate_old_import_packages_to_change_history_package_recurser(EA.Package parentPackage)
          return pkg;
+      }
       /// <summary>
       /// This function removes any empty packages it can find in the ReqPro import area. This is
       /// a tidying up operation.
       /// </summary>
       /// <param name="parentPackage"></param>
       /// <returns></returns>
       private bool prune_empty_packages(EA.Package parentPackage)
          if (needRefresh)
+         {
             parentPackage.Packages.Refresh();
+         }
          if (parentPackage.Packages.Count == 0
             && parentPackage.Elements.Count == 0
             && parentPackage.Diagrams.Count == 0)
+         {
             retVal = true;
+         }
          return retVal;
+      }
+      private void add_to_orphan_list(ref EA.Element ea_req)
+      {
+         if (!gReq_lists.orphaned_ea_reqs.Contains(ea_req.ElementID))
+         {
+            gReq_lists.orphaned_ea_reqs.Add(ea_req.ElementID);
+            gOrphanedCount++;
+            gChangeLog.Notes += ea_req.ElementGUID + ":Orphaned:" + ea_req.Name + "\r\n";
+            gChangeLog.Update();
+         }
+      }
+	}
+}

Subversion Repositories DevTools

(root)/EA_ReqPro/trunk/EA_ReqPro/ImportReqProDatabase.cs – Rev 2171 → 2173