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

                ea_repository.EnsureOutputVisible(Main.GUI_OUTPUT_TAB_NAME);
                // write the captured info from reqpro, into the ea database, obeying the filter
                // settings the user has specified.
                write_ea_database(ea_repository);
+               MessageBox.Show("Import Completed");
                return true;
+            }
+         }
          catch (Exception ex)
+         {
          return false;
+      }
+      /// <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>
+      private 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;
+      }
+      /// <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 void write_traces(EA.Repository ea_repository, ReqPro_object rq_obj)
+      {
+         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)
+            {
+               EA.Element ea_rq_obj = 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 = ea_repository.GetElementByID(tgt_obj.ea_element_ID);
+                           if (ea_tgt_obj != null)
+                           {
+                              add_connection(ea_repository, ea_rq_obj, ea_tgt_obj);
+                           }
+                        }
+                     }
+                  }
+               }
+            }
+         }
+         // recurse to ensure we examine the entire hiearchy
+         foreach(ReqPro_object sub_obj in rq_obj.ReqPro_objects)
+         {
+            write_traces(ea_repository, sub_obj);
+         }
+      }
+      /// <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>
+      private void add_connection(EA.Repository ea_repository, 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("", "Relationship");
+         c.SupplierID = dest_element.ElementID;
+         //c.Stereotype = "trace";
+         c.Direction = "Source -> Destination";
+         if (false == c.Update())
+         {
+            ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "New Connector Error : " + c.GetLastError(), dest_element.ElementID );
+         }
+         src_element.Connectors.Refresh();
+      }
       /// <summary>
       /// This method (along with its sibling overloads) perform the copy operation once
       /// the ReqPro database content has been acquired, and the user has submitted their
       /// filtering requirements. This method begins the copy operation, but the real nitty
+         }
          ea_rootPackage.Packages.Refresh();
          // refresh project browser view
          ea_repository.RefreshModelView(ea_rootPackage.PackageID);
+         // Setup the internal requirement to requirement connectivity. This is seperate from the browser
+         // organisation of elements in EA, but since in ReqPro, that organisation tells part of the story
+         // of requirement to requirement connectivity, it is mirrored in the internal connectivity, along
+         // with explicit trace relationships setup in ReqPro.
+         // The purpose of this internal connectivity is to support relationship matrix tables in documentation
+         // generated by EA_DocGen, or to support diagrammatic representations of the requirements in EA,
+         // where the connectivity will become apparent through links ajoining the requirement elements in the
+         // diagram.
+         ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "Writing Trace Information", -1);
+         foreach( ReqPro_object sub_obj in rq_root_package.ReqPro_objects )
+         {
+            write_traces(ea_repository, sub_obj);
+         }
+      }
       private void write_ea_database(EA.Repository ea_repository,
                                      EA.Package ea_parent_package,
                                      EA.Element ea_parent_element,
+            {
                if (ea_parent_package != null)
+               {
                   // create a representative package in EA
                   EA.Package new_ea_package = EA_Utils.createPackage(ea_parent_package, rq_obj.name, rq_obj.treePos);
+                  rq_obj.ea_element_ID = new_ea_package.PackageID;
                   ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "Created Package : " + rq_obj.name, new_ea_package.PackageID );
                   // Using recursion, scan this objects sub-objects
                   foreach( ReqPro_object sub_obj in rq_obj.ReqPro_objects )
+                  {
                      write_ea_database(ea_repository, new_ea_package, null, sub_obj);
+                  }
+               }
                else
+               {
+                  // should never get here - I have never seen it happen so far.
                   ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "ERROR,write_ea_database, parent package was null", -1);
+               }
+            }
             else if (base.allowPackageStructureFragments)
+            {
+         }
          else if (rq_obj.isRequirement)
+         {
             if ( ! (reqTypeIsFiltered(rq_obj) || reqStatusTypeIsFiltered(rq_obj)))
+            {
+               string rq_obj_name = rq_obj.tag + " " + rq_obj.name;
+               // If needed, create the requirement element as a child of a parent element
                if (ea_parent_element != null)
+               {
                   // create a representative element in EA
-                  EA.Element new_ea_element = (EA.Element)ea_parent_element.Elements.AddNew(rq_obj.tag + " " + rq_obj.name, "Requirement");
+                  EA.Element new_ea_element = (EA.Element)ea_parent_element.Elements.AddNew(rq_obj_name, "Requirement");
+                  rq_obj.ea_element_ID = new_ea_element.ElementID;
-                  ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "Created Element : " + rq_obj.name, new_ea_element.ElementID );
+                  ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "Created Element : " + rq_obj_name, new_ea_element.ElementID );
+                  // 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);
+                  }
                   // If the ReqPro requirements detailed text is more than what the name already contains (allowing for it
                   // to have a stop character that the name may not have) then copy it over, otherwise ignore it. This
                   // prevents the same text appearing twice in any generated document made using EA_DocGen.
                   if (!rq_obj.text.StartsWith(rq_obj.name) || (rq_obj.text.Length > (rq_obj.name.Length + 1)))
                   new_ea_element.TreePos = rq_obj.treePos;
                   new_ea_element.Status  = rq_obj.status;
                   new_ea_element.Update();
+                  // Write EA tag information exactly as is done for the import for traceability use. This
+                  // opens up the possibility that a document model import could be converted into a traceability
+                  // use model in some future update to EA_ReqPro addin.
+                  EA_Utils.WriteTag(new_ea_element, "GUID", rq_obj.guid);
+                  EA_Utils.WriteTag(new_ea_element, "TAG", rq_obj.tag);
                   // Using recursion, scan this objects sub-objects
                   foreach( ReqPro_object sub_obj in rq_obj.ReqPro_objects )
+                  {
                      write_ea_database(ea_repository, null, new_ea_element, sub_obj);
+                  }
+               }
+               // else create the requirement element as a child of a parent package
                else if (ea_parent_package != null)
+               {
                   // create a representative element in EA
-                  EA.Element new_ea_element = (EA.Element)ea_parent_package.Elements.AddNew(rq_obj.tag + " " + rq_obj.name, "Requirement");
+                  EA.Element new_ea_element = (EA.Element)ea_parent_package.Elements.AddNew(rq_obj_name, "Requirement");
+                  rq_obj.ea_element_ID = new_ea_element.ElementID;
-                  ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "Created Element : " + rq_obj.name, new_ea_element.ElementID );
+                  ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "Created Element : " + rq_obj_name, new_ea_element.ElementID );
                   // If the ReqPro requirements detailed text is more than what the name already contains (allowing for it
                   // to have a stop character that the name may not have) then copy it over, otherwise ignore it. This
                   // prevents the same text appearing twice in any generated document made using EA_DocGen.
                   if (!rq_obj.text.StartsWith(rq_obj.name) || (rq_obj.text.Length > (rq_obj.name.Length + 1)))
                   new_ea_element.TreePos = rq_obj.treePos;
                   new_ea_element.Status  = rq_obj.status;
                   new_ea_element.Update();
+                  // Write EA tag information exactly as is done for the import for traceability use. This
+                  // opens up the possibility that a document model import could be converted into a traceability
+                  // use model in some future update to EA_ReqPro addin.
+                  EA_Utils.WriteTag(new_ea_element, "GUID", rq_obj.guid);
+                  EA_Utils.WriteTag(new_ea_element, "TAG", rq_obj.tag);
                   // Using recursion, scan this objects sub-objects
                   foreach( ReqPro_object sub_obj in rq_obj.ReqPro_objects )
+                  {
                      write_ea_database(ea_repository, null, new_ea_element, sub_obj);
+                  }
+               }
                else
+               {
+                  // should never get here - I have never seen it happen so far.
                   ea_repository.WriteOutput( Main.GUI_OUTPUT_TAB_NAME, "ERROR,write_ea_database, parent package was null", -1);
+               }
+            }
+         }
+      }

Subversion Repositories DevTools

(root)/EA_ReqPro/trunk/EA_ReqPro/CopyReqProDatabase.cs – Rev 2141 → 2143