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

                parentPackage = Main.EA_Repository.GetPackageByID( base.RQ_Element.PackageID );
+            }
             #endregion
             #region GET_EXPORT_LIST
-            Main.WriteOutput("Acquiring list of elements already in EA", -1);
+            Main.WriteOutput("Acquiring list of requirement elements in EA", -1);
             // setup the element types list to control the element accumulation
             ArrayList allowedElementTypes = new ArrayList();
             allowedElementTypes.Add("Requirement");
             //allowedElementTypes.Add("UseCase");
             // process each requirement found in EA that needs exporting
             foreach(EA.Element ea_req in ea_reqs)
+            {
                // get EA requirement without any temporary tag that the modeller may have given it
+               string tag = null;
-               string ea_req_untagged_name = untaggedReqName(ea_req.Name, false);
+               string ea_req_untagged_name = untaggedReqName(ea_req.Name, ref tag, false);
                Main.WriteOutput("Exporting : " + ea_req.Name, ea_req.ElementID);
                // Add the requirement to ReqPro requirement collection
                ReqPro40.Requirement rp_req = ReqProDatabase.add_requirement(req_collection, ea_req_untagged_name, ea_req.Notes, this.m_ReqType);
                      cancelled = true;
                      return false;
+                  }
-                  // Attempt to set any attributes in the new ReqPro requirement.
-                  exportAttributes(rp_req, ea_req);
                   // Commit changes to ReqPro database
                   rp_req.Save();
                   // Now locate the new requirement under the selected package in ReqPro
                   // 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);
+                  // Attempt to set any attributes in the new ReqPro requirement.
+                  exportAttributes(rp_req, ea_req, rp_req_tag);
+                  rp_req.Save();
                   // Update the EA requirement for the second time, now with the correct and final tag
                   ea_req.Name = rp_req_tag + " " + ea_req_untagged_name;
                   ea_req.Update();
                   Main.WriteOutput("   (Re)Assigned Tag : " + ea_req.Name, ea_req.ElementID);
                   // Try and find the requirement in ReqPro
                   rp_req = ReqProDatabase.get_requirement_by_guid(GUID);
                   if (rp_req != null)
+                  {
                      // copy name and notes from EA to ReqPro
+                     string tag = null;
-                     string ea_req_untagged_name = untaggedReqName(ea_req.Name, true);
+                     string ea_req_untagged_name = untaggedReqName(ea_req.Name, ref tag, true);
                      // Test that the EA requirement can be updated.
                      ea_req.Name = ea_req_untagged_name;
                      ea_req.Update();
                      if (false == ea_req.Update())
                      // copy content to the existing ReqPro requirement
                      rp_req.Name = ea_req_untagged_name;
                      rp_req.Text = ea_req.Notes;
+                     string rp_req_tag = rp_req.get_Tag(ReqPro40.enumTagFormat.eTagFormat_FullTag);
                      // Attempt to set any attributes in the existing ReqPro requirement.
-                     exportAttributes(rp_req, ea_req);
+                     exportAttributes(rp_req, ea_req, rp_req_tag);
                      // Commit changes to ReqPro database
                      rp_req.Save();
                      // Although we are allowing EA to be the master repository of requirements
                      // if they were originally created in EA, we still want to use ReqPro as the
                      // master for any numbering scheme (ie. tags), so update the EA requirements
                      // Tag as necessary.
-                     string rp_req_tag = rp_req.get_Tag(ReqPro40.enumTagFormat.eTagFormat_FullTag);
                      ea_req.Name = rp_req_tag + " " + ea_req_untagged_name;
                      ea_req.Update();
                      EA_TaggedValues.Write(ea_req, Constants.TAG_TAG, rp_req_tag);
                      Main.WriteOutput("Updated : " + ea_req.Name, ea_req.ElementID);
+                  }
       /// Look for and strip any temporary tag from the requirement name, returning a new
       /// string to be used as the requirement name
       /// </summary>
       /// <param name="taggedReqName"></param>
       /// <returns></returns>
-      private string untaggedReqName(string taggedReqName, bool force)
+      private string untaggedReqName(string taggedReqName, ref string tag, bool force)
+      {
          if (taggedReqName != null)
+         {
             // Try and split the string into two tokens at the first space character
             char [] delim = {' '};
             string [] tokens = taggedReqName.Split(delim, 2);
             // if there are two tokens resulting from the split
             if (tokens.GetLength(0) == 2)
+            {
+               // return tag
+               tag = tokens[0];
                // if the first token appears to be a tag
                if (force == true
                   || tokens[0].StartsWith("REQ")
                   || tokens[0].StartsWith("TAG")
                   || tokens[0].StartsWith("SPR")
+         }
          // default to the input string
          return taggedReqName;
+      }
+      private string tagPrefix(string tag)
+      {
+         if (tag != null && tag.Length > 0)
+         {
+            string[] prefixes = tag.Split("0123456789.".ToCharArray());
+            if (prefixes.GetLength(0) > 0)
+            {
+               return prefixes[0];
+            }
+         }
+         return tag;
+      }
-      private void exportAttributes(ReqPro40.Requirement rp_req, EA.Element ea_req)
+      private void exportAttributes(ReqPro40.Requirement rp_req, EA.Element ea_req, string rp_req_tag)
+      {
          // Update the attributes of a ReqPro requirement. We have to be very careful here.
          // ReqPro does not like us trying to set the value of attributes that do not exist for the
          // specified requirement type, and it also does not like us trying to set an attribute that is
          // a list type, to a value that is not in the predefined set of values for the list type.
          bool hasSourceSection = false;
          bool hasSubsystem = false;
          bool hasStability = false;
          bool hasType = false;
+         string reqType = tagPrefix(rp_req_tag);
          // Use the ReqProParser's knowledge of requirement types and attribute type associations to tell
          // us what attributes we can set, and then use the setListItemValue() function to do the setting.
          // That function knows how to set List items correctly and safely so as to not cause exceptions
          // to be raised in the ReqPro automation onject.
-         if (reqTypeHasOneOrMoreAttrs(this.m_ReqType,
+         if (reqTypeHasOneOrMoreAttrs(reqType,
             ref hasStatus, ref hasDifficulty, ref hasPriority,
             ref hasSource, ref hasSourceVersion, ref hasSourceSection,
             ref hasSubsystem, ref hasStability, ref hasType))
+         {
             if (hasStatus)
+            {
-               setListItemAttrValue(rp_req, "Status", ea_req.Status);
+               setListItemAttrValue(rp_req, ea_req, "Status", ea_req.Status, rp_req_tag);
+            }
             if (hasDifficulty)
+            {
-               setListItemAttrValue(rp_req, "Difficulty", ea_req.Difficulty);
+               setListItemAttrValue(rp_req, ea_req, "Difficulty", ea_req.Difficulty, rp_req_tag);
+            }
             if (hasPriority)
+            {
-               setListItemAttrValue(rp_req, "Priority", ea_req.Priority);
+               setListItemAttrValue(rp_req, ea_req, "Priority", ea_req.Priority, rp_req_tag);
+            }
+            if (hasSource)
+            {
+               string s = EA_TaggedValues.Read(ea_req, Constants.TAG_SOURCE);
+               if (s != null && s.Length > 0)
+               {
+                  setListItemAttrValue(rp_req, ea_req, "Source", s, rp_req_tag);
+               }
+            }
+            if (hasSourceVersion)
+            {
+               string s = EA_TaggedValues.Read(ea_req, Constants.TAG_SOURCE_VERSION);
+               if (s != null && s.Length > 0)
+               {
+                  setTextAttrValue(rp_req, ea_req, "Source Version", s, rp_req_tag);
+               }
+            }
+            if (hasSourceSection)
+            {
+               string s = EA_TaggedValues.Read(ea_req, Constants.TAG_SOURCE_SECTION);
+               if (s != null && s.Length > 0)
+               {
+                  setTextAttrValue(rp_req, ea_req, "Source Section", s, rp_req_tag);
+               }
+            }
+            if (hasSubsystem)
+            {
+               string s = EA_TaggedValues.Read(ea_req, Constants.TAG_SUBSYSTEM);
+               if (s != null && s.Length > 0)
+               {
+                  setListItemAttrValue(rp_req, ea_req, "Subsystem", s, rp_req_tag);
+               }
+            }
+            if (hasStability)
+            {
+               string s = EA_TaggedValues.Read(ea_req, Constants.TAG_STABILITY);
+               if (s != null && s.Length > 0)
+               {
+                  setListItemAttrValue(rp_req, ea_req, "Stability", s, rp_req_tag);
+               }
+            }
+            if (hasType)
+            {
+               if (ea_req.Stereotype != null && ea_req.Stereotype.Length > 0)
+               {
+                  setListItemAttrValue(rp_req, ea_req, "Requirement Type", ea_req.Stereotype, rp_req_tag);
+               }
+               else if (ea_req.StereotypeEx != null && ea_req.StereotypeEx.Length > 0)
+               {
+                  string[] s_arr = ea_req.StereotypeEx.Split(",".ToCharArray());
+                  if (s_arr[0] != null && s_arr[0].Length > 0)
+                  {
+                     setListItemAttrValue(rp_req, ea_req, "Requirement Type", s_arr[0], rp_req_tag);
+                  }
+               }
+            }
+         }
+      }
       /// ReqPro automation object.
       /// </summary>
       /// <param name="rp_req"></param>
       /// <param name="label"></param>
       /// <param name="value"></param>
-      private void setListItemAttrValue(ReqPro40.Requirement rp_req, string label, string value)
+      private void setListItemAttrValue(ReqPro40.Requirement rp_req, EA.Element ea_req, string label, string value, string rp_req_tag)
+      {
+         bool attribute_type_found = false;
+         bool attribute_value_found = false;
          // look through each attribute value, for the one whose label matches the one specified
          ReqPro40.AttrValues rp_attr_values = rp_req.AttrValues;
          foreach (ReqPro40.AttrValue rp_attr_value in rp_attr_values)
+         {
             if (rp_attr_value != null && rp_attr_value.Label.Equals(label))
+            {
+               attribute_type_found = true;
                // Look through each list item value to make sure that one exists that matches
                // the value specified
                ReqPro40.ListItemValues rp_list_item_values = rp_attr_value.ListItemValues;
                if (rp_list_item_values != null)
+               {
                      if (rp_list_item_value.Text.Equals(value))
+                     {
                         // We found that the list contains the value specified, so set the value of the attribute
                         rp_list_item_value.Selected = true;
+                        attribute_value_found = true;
                         // exit inner loop
                         break;
+                     }
+                  }
+               }
                // exit outer loop
                break;
+            }
+         }
+         if (!attribute_type_found)
+         {
+            Main.WriteOutput(string.Format("WARNING, Failed to export attribute type ({0}) for ({1})",
+               label, rp_req_tag), ea_req.ElementID);
+         }
+         if (!attribute_value_found)
+         {
+            Main.WriteOutput(string.Format("WARNING, Failed to export attribute type/value ({0}/{1}) for ({2})",
+               label, value, rp_req_tag), ea_req.ElementID);
+         }
+      }
+      /// <summary>
+      /// Set a ReqPro requirement attribute value, for an attribute that is a text type.
+      /// </summary>
+      /// <param name="rp_req"></param>
+      /// <param name="label"></param>
+      /// <param name="value"></param>
+      private void setTextAttrValue(ReqPro40.Requirement rp_req, EA.Element ea_req, string label, string value, string rp_req_tag)
+      {
+         bool attribute_type_found = false;
+         // look through each attribute value, for the one whose label matches the one specified
+         ReqPro40.AttrValues rp_attr_values = rp_req.AttrValues;
+         foreach (ReqPro40.AttrValue rp_attr_value in rp_attr_values)
+         {
+            if (rp_attr_value != null && rp_attr_value.Label.Equals(label))
+            {
+               attribute_type_found = true;
+               rp_attr_value.Text = value;
+               // exit outer loop
+               break;
+            }
+         }
+         if (!attribute_type_found)
+         {
+            Main.WriteOutput(string.Format("WARNING, Failed to export attribute type ({0}) for ({1})",
+               label, rp_req_tag), ea_req.ElementID);
+         }
+      }
+	}
+}

Subversion Repositories DevTools

(root)/EA_ReqPro/trunk/EA_ReqPro/ExportToReqProDatabase.cs – Rev 2155 → 2157