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

          m_ExportExtent = exportExtent;
+      }
+      /// <summary>
+      /// Function to schedule and control the export sequence. Here is where the real work
+      /// begins of exporting requirements and traceability from EA to RequisitePro.
+      /// </summary>
+      /// <param name="exportDateTime"></param>
+      /// <param name="cancelled"></param>
       private void ExportToReqPro(string exportDateTime, out bool cancelled)
+      {
          cancelled = false;
          try
             #region DETERMINE PARENT PACKAGE
             // Obtain the EA parent package so that we can scan it for existing requirement elements.
             EA.Package parentPackage;
             if (m_ExportExtent == ExportForm.ExportExtent.PACKAGE_REQS)
+            {
-               parentPackage = EA_Utilities.get_selected_package();
+               parentPackage = EA_ProjectBrowser.get_selected_package();
+            }
             else
+            {
                // default to the ReqProDB container package. This is probably what most exports
                // will use.
             if (m_ExportExtent != ExportForm.ExportExtent.SINGLE_REQ)
+            {
                // create the element accumulator, and use it to find all the requirement
                // elements in the container package
-               ElementAccumulator reqLister = new ElementAccumulator(allowedElementTypes);
+               EA_ElementAccumulator reqLister = new EA_ElementAccumulator(allowedElementTypes);
-               EA_Utilities.findAndProcessPackageElements( parentPackage, reqLister, true );
+               EA_Parsing.findAndProcessPackageElementsInBrowserOrder( parentPackage, reqLister, true );
                if (Main.mustAbort)
                   return;
+               // Sanity check the EA requirements
+               Main.WriteOutput("Sanity checking requirement elements in EA", -1);
+               if (false == sanity_check_requirements(reqLister.Elements))
+               {
+                  cancelled = true;
+                  return;
+               }
                // Remove requirements from the accumulated list if they have already been linked
                // to ReqPro requirement elements, by virtue of them seeming to have a valid GUID
                // We dont actually validate the GUID, just check that one is present or not.
                ea_reqs = reqLister.Elements;
                int i_ea_reqs;
                if (Main.mustAbort)
                   return;
+            }
             else // user wants to export a single selected requirement
+            {
-               EA.Element ea_ele = EA_Utilities.get_selected_element(allowedElementTypes);
+               EA.Element ea_ele = EA_ProjectBrowser.get_selected_element(allowedElementTypes);
                if (ea_ele == null)
+               {
                   MessageBoxEx.Show(
                      "The export extent chosen (single requirement export)\n" +
                      "is not compatible with the item selected in the EA\n" +
                   return;
+               }
                ea_reqs = new ArrayList();
                ea_reqs.Add(ea_ele);
+               // Sanity check the EA requirement
+               Main.WriteOutput("Sanity checking requirement element in EA", -1);
+               if (false == sanity_check_requirements(ea_reqs))
+               {
+                  cancelled = true;
+                  return;
+               }
+            }
             #endregion
             // Export newly mastered EA requirements to ReqPro
             if (false == export_new_EA_mastered_requirements(ref ea_reqs, ref ea_mastered_reqs, ref ea_mastered_reqs_rp_guids, out cancelled))
+         {
             Main.MessageBoxException(ex, "Exception (ExportToReqPro)");
+         }
+      }
+      /// <summary>
+      /// sanity check a list of requirements to make sure they all meet ReqPro's constraints
+      /// </summary>
+      /// <param name="al"></param>
+      /// <returns></returns>
+      private bool sanity_check_requirements(ArrayList al)
+      {
+         int numBadRequirements = 0;
+         foreach (EA.Element ele in al)
+         {
+            if (false == requirement_meets_reqpro_constraints(ele))
+            {
+               numBadRequirements++;
+            }
+            if (Main.mustAbort)
+               return false;
+         }
+         if (numBadRequirements > 0)
+         {
+            MessageBoxEx.Show(
+               "One or more EA requirement objects for export do not meet the constraints\n" +
+               "imposed by RequisitePro - see EA_ReqPro output tab for the list of bad objects.",
+               "Error");
+            return false;
+         }
+         return true;
+      }
+      /// <summary>
+      /// sanity check a requirement in EA to make sure it meets ReqPro's constraints
+      /// and issue and message to the output tab if it does not.
+      /// </summary>
+      /// <param name="ele"></param>
+      /// <returns></returns>
+      private bool requirement_meets_reqpro_constraints(EA.Element ele)
+      {
+         string tag = null;
+         if (ele.Name == null)
+         {
+            Main.WriteOutput("???", ele.ElementID);
+            Main.WriteOutput("   Element has no name", ele.ElementID);
+            return false;
+         }
+         string untagged_name = untaggedReqName(ele.Name, ref tag, false);
+         if (untagged_name.Length > 128)
+         {
+            Main.WriteOutput(untagged_name, ele.ElementID);
+            Main.WriteOutput(string.Format("   Element name exceeds 128 char limit - actual length is {0}", untagged_name.Length), ele.ElementID);
+            return false;
+         }
+         if (untagged_name.IndexOfAny("\r\n".ToCharArray(), 0) >= 0)
+         {
+            Main.WriteOutput(untagged_name, ele.ElementID);
+            Main.WriteOutput("   Element name contains carriage return or line feed", ele.ElementID);
+            return false;
+         }
+         if (ele.Notes != null && ele.Notes.Length > 16000)
+         {
+            Main.WriteOutput(untagged_name, ele.ElementID);
+            Main.WriteOutput(string.Format("   Element notes exceeds 16000 char limit - actual length is {0}", ele.Notes.Length), ele.ElementID);
+            return false;
+         }
+         return true;   // requirement is good
+      }
       /// <summary>
       /// Exports newly EA mastered requirements to ReqPro
       /// </summary>
       /// <param name="ea_reqs"></param>
                string tag = null;
                string ea_req_untagged_name = untaggedReqName(ea_req.Name, ref tag, false);
                Main.WriteOutput("Exporting : " + ea_req.Name, ea_req.ElementID);
+               // If the EA requirement has a parent requirement, then in ReqPro we must organise it such
+               // that it has a parent-child hierarchical relationship
+               ReqPro40.Requirement parent_rp_req = null;
+               EA.Element parent_ea_req = null;
+               if (ea_req.ParentID != 0)
+               {
+                  parent_ea_req = Main.EA_Repository.GetElementByID(ea_req.ParentID);
+                  if (parent_ea_req != null)
+                  {
+                     // get GUID of ReqPro parent requirement
+                     string parent_guid = EA_TaggedValues.Read(parent_ea_req, Constants.TAG_GUID);
+                     if (parent_guid != null && parent_guid.Length > 0 && parent_guid.StartsWith("{"))
+                     {
+                        // Get the parent ReqPro requirement
+                        parent_rp_req = ReqProDatabase.get_requirement_by_guid(parent_guid);
+                     }
+                     // Even though in EA, a parent-child relationship exists, we want to re-enforce that
+                     // with a connection relationship too, so that when the parent and child exists on
+                     // a diagram, they are shown linked together.
+                     EA_Connectors.add(parent_ea_req, ea_req);
+                  }
+               }
                // Add the requirement to ReqPro requirement collection
+               ReqPro40.Requirement rp_req = null;
+               if (parent_rp_req != null)
+                  rp_req = ReqProDatabase.add_requirement(req_collection, ea_req_untagged_name, ea_req.Notes, this.m_ReqType, parent_rp_req);
+               else
-               ReqPro40.Requirement rp_req = ReqProDatabase.add_requirement(req_collection, ea_req_untagged_name, ea_req.Notes, this.m_ReqType);
+                  rp_req = ReqProDatabase.add_requirement(req_collection, ea_req_untagged_name, ea_req.Notes, this.m_ReqType);
                if (rp_req != null)
+               {
                   // Get the tag for the new requirement from ReqPro and use it to form a new name for
                   // the EA requirement. Note that at this point in time the tag has a pending form. It
                   // only becomes correct once we do a rq_req.Save() later on, so this update has to be
                   // Commit changes to ReqPro database
                   rp_req.Save();
-                  // Now locate the new requirement under the selected package in ReqPro
+                  // Now locate the new requirement under the selected package in ReqPro, but we only need to do this if the
+                  // requirement is a root level requirement that has no parent requirement.
-                  if (rp_pkg != null)
+                  if ((rp_pkg != null) && (parent_rp_req == null))
+                  {
                      rp_pkg.AddElement(rp_req, ReqPro40.enumPackageLookups.ePackageLookup_Object, ReqPro40.enumElementTypes.eElemType_Requirement);
+                  }
-                  // If the EA requirement has a parent requirement, then in ReqPro we must organise it such
-                  // that it has a parent-child hierarchical relationship
-                  if (ea_req.ParentID != 0)
-                  {
-                     EA.Element parent_ea_req = Main.EA_Repository.GetElementByID(ea_req.ParentID);
-                     if (parent_ea_req != null)
-                     {
-                        // get GUID of ReqPro parent requirement
-                        string parent_guid = EA_TaggedValues.Read(parent_ea_req, Constants.TAG_GUID);
-                        if (parent_guid != null && parent_guid.Length > 0 && parent_guid.StartsWith("{"))
-                        {
-                           // Get the parent ReqPro requirement
-                           ReqPro40.Requirement parent_rp_req = ReqProDatabase.get_requirement_by_guid(parent_guid);
-                           if (parent_rp_req != null)
-                           {
-                              // Establish relationship in ReqPro
-                              rp_req.AssignParent(parent_rp_req, ReqPro40.enumRequirementLookups.eReqLookup_Object);
-                              // Even though in EA, a parent-child relationship exists, we want to re-enforce that
-                              // with a connection relationship too, so that when the parent and child exists on
-                              // a diagram, they are shown linked together.
-                              EA_Utilities.add_connection(parent_ea_req, ea_req);
-                           }
-                        }
-                     }
-                  }
                   // Now re-acquire the tag, which should no longer be in a pending form but have a real number
                   // assigned to it as a result of the commit we just did above.
                   rp_req_tag = rp_req.get_Tag(ReqPro40.enumTagFormat.eTagFormat_FullTag);

Subversion Repositories DevTools

(root)/EA_ReqPro/trunk/EA_ReqPro/ExportToReqProDatabase.cs – Rev 2163 → 2169