ReqIF_Roundtrip - Helmut-Ortmann/EnterpriseArchitect_hoReverse GitHub Wiki

ReqIF Roundtrip

hoReverse supports ReqIF Workflow/Roundtrip. The hoReverse ReqIF Import Specification contains the Attributes to write back to sender. In EA these ReqIF Attributes are Tagged Values with possible Enumeration type to easily comment on Requirements.

Example for Roundtrip

First make an Import and than send back your comments by Roundtrip.

See also the generated Tagged Value Types

See Export Tutorial

EA Structure

These priciples cover Import, Roundtrip, Export.

EA Package An EA package is a ReqIF Specification. In Doors you would name it a Formal Module
EA Elements are the requirements. Usually, you would use nested Elements to denote the ReqIF hierarchical structure
- EA standard Properties
  - Name: ReqIF.Name, the name or short text of the requirements
  - Notes: ReqIF.Text, the ReqIF Text in EA specification/note format
  - Linked Document: ReqIF.Text, the reqIF Text as *.docx with images and embedded files)
  - Alias: Possible mapping to ReqIF attribute via Import Specification
  - Multiplicity: The ReqIF identifier
- Tagged Values for ReqIF Attributes
  - EA Tagged Value Types are used for Enumerations (single-value: Enumeration, multi-value: CheckList)
  - If no Tagged Value type exists the content is XHTML formatted
Trash Package: A package to move deleted Requirements into to handle existing dependencies and to remove them later

Workflow

In hoReverse you can define attribute names you want to write back to the owner of the requirements. If you configure a reference to EA as GUID (=EA.Guid) you reach bi-directional tracability according to SPICE.

Workflow Specification

Specify the attributes for Roundtrip:

"PrefixTaggedValueTypeList": ["ArchA_", "ArchB_"], // Prefix for each ReqIF module (optional)
"WriteAttrNameList": [ "_ArchBlockId=EA.GUID", "_ArchitectureStatComment","_ArchitectureStatus","_SortingCrit"]

ReqIF Studio

The workflow specification is just a line inside the Import Specification

"WriteAttrNameList": [ "_ArchBlockId=EA.GUID", "_ArchitectureStatComment","_ArchitectureStatus","_SortingCrit"]

A complete set would contain:

EA.GUID for full bi-directional traceability
Comment as string or XHTML to comment on the current requiremnt
State as enumeration like 'Init', 'Accepted', 'Rejected'
etc.

Export Formats

hoReverse exports the whole ReqIF file and updates the specified attribute values.

Export
- ReqIF
- Specified EA Tagged values to update and write back
  - e.g: "WriteAttrNameList": [ "_ArchBlockId=EA.GUID", "_ArchitectureStatComment","_ArchitectureStatus","_SortingCrit"]
- Format: XHTML, string, Enumeration with single or multi value selection

Features

ReqIF (Version 1.0, 1.1, 1.2)
Import/Export specification to easily re-run
- Make groups to import a bulk of requirements with one click
Roundtrip
- Auto generate EA values like "GUID", here called macros.
Structured/nested requirements
Images and formatting in EA 'Linked Docucuments'
Attributes
- For ReqIF Requirement in EA Element and TaggedValues
- For ReqIF Module in EA Packages
- For ReqIF Roundtrip in TaggedValues
Specify what you see in EA
- Name (which ReqIF attributes it's constructed of)
- Alias (which ReqIF attributes it's constructed of)
- LinkedDocument/RTF (which ReqIF attributes it's constructed of)
- Notes (which ReqIF attribute it's constructed of)
- GUID of package (always import in the specified package)
- Deleted folder to see deleted requirements
- The EA object to create (EA Object Type like 'Requirment' and the ≪Stereotype≫)
- The ReqIF attributes as EA Tagged Values
Embedded ReqIF files are stored with the EA Requirement as EA Files.
- DOORS: *.ole files and if .pdf/.wmf converted to their type
- Search to find embedded files

Procedure

The whole process:

Define ReqIF Specification

User: In Settings.Json define the attributes you want to write back to the sender ["Writeable1","Writable2"]
User: In Settings.Json define the EA macros to auto-write attributes (e.g. EA GUID for be-directional traceability) ["Writeable1","Writable2=EA.Guid"]

Initial: Import Requirements into EA

User: Import initial ReqIF Requirements from your Requirement Tool
User: EA Menu Do, Import ReqIF, Select the import from the list
EA: Imports the requirements in the specified EA-Packages (see Example)

Roundtrip: Send back to sender

User: Edit the tagged values you want to send to the sender Requirement Tool
User: EA Menu Do, Export ReqIF, Select the export from the list
EA: Exports the ReqIF with the tagged values updated in ReqIF

Roundtrip: Receive from sender

User: Export ReqIF
User: EA Menu Do, Import ReqIF, Select the import from the list
EA: EA imports all Requirements accept from the configured Attributes/Tagged Values to write back

Specification of Attributes / EA tagged values for Roundtrip

Atributes for Roundtrip
- "WriteAttrNameList": ["ReqIF.ChapterName", "ReqIF.ForeignModifiedBy=EA.GUID","ReqIF.ChapterName", "ReqIF.ForeignCreatedBy"]
- Macros to auto update EA Tagged Values during export
  - = EA.GUID // set the EA GUID, for bi-directional traceability
  - = EA.Version
  - = EA.Phase
  - = EA.Status
  - = EA.Author
  - = EA.Created
  - = EA.Modified
  - = EA.Name
  - = EA.Stereotype
  - = EA.Type

Import Specification

See Settings

The import specification specifies:

Import
Roundtrip
Grouping of imports/roundtrips
Mapping of columns betweem EA and the Requirement Tool.

You can edit the Import Specification in Settings.json , chapter "Importer".

  // Importer settings to import ReqIf, DoorsCsv, DoorsReqIF, xmlStruct into EA packages:
  // - Specify import rules to import a type of file into one or more EA Packages
  // - Specify roundtrip for ReqIF
  // - see class: 'FileImportSettingsItem'
  //
  // Rules: 
  // - A File path may be written with either '\', or '/'
  //
  // Settings:
  // - Name:            The name in the EA menu to use this particular specification  
  // - Description:     Further description visualied as tooltip in the menu description
  // - ListNo:          hoReverse imports all specifications with the same ListNo with one click in the EA Menu 
  // - InputFile:       The Path of the file to import, you have to use the extensions (*.csv, *.reqif,, *.reqifz, *.xml) depending on the particular 'ImportType'
  // - PackageGuidList: The list of Guids for the packages to import into. The compressed *.reqifz format allows/demands one GUID for each imported 'Module'. The other file types only support one GUID/package.
  //                    ["{F199A750-C7BF-4625-A95D-F4C1AF8E4900}","{157D337C-13BB-4fc0-AA10-79F0A7587C99}" ],
  // - PrefixTaggedValueTypeList
  //                    List of prefixes to use for each ReqIF module like ["ArchA_", "ArchB_"]
  // - ObjectType:      The valid EA ObjectType to create for each imported row (e.g. 'Requirement').
  // - Stereotype:      The EA Stereotype to use for each imported row (e.g. 'Functional Requirement')
  // - ImportType:      'DoorsCsv'   = Doors *.csv import format for requirements (tested with Doors 9.6)
  //                    'DoorsReqIf' = DOORS reqif format (*.reqif, *.reqifz)
  //                    'ReqIf'      = ReqIf format (*.reqif, *.reqifz)
  //                    'XmlStruct'  = Structured xml for requirements, tests or so
  // - StatusNew:       The EA status property to set for new EA element
  // - StatusChanged:   The EA status property to set for changed EA elements (only supported for ImportType 'DoorsCsv')
  // - RtfNameList      List of ReqIF attribute names to put in EA Linked Document (support of graphics)
  //                    ["Object Text",],
  // - AttrNameList     List of ReqIF attribute names to put in EA Name
  //                    ["ReqIF.ForeignID", "ReqIF.Chaptername", "ReqIF.Text"],
  // - AttrNotes        The attribute name to import into the EA property 'Note', e.g. "Object Text"
  // - AliasList        List of attribute names to import into the EA property 'Alias', e.g. ["RequirementID"] or ["ReqIF.ForeignID"]
  // - WriteAttrNameList List of attribue names to export back to the ReqIF file (Implementation of ReqIF Workflow). Only Tagged values of string or xhtml are allowed.
  //                    You can use variables to autfill fields. ["MyReferenceToEA=EA.GUID"]
  //                    hoReverse supports the following autofill fields:
  //                    - EA.GUID
  //                    - EA.Created
  //                    - EA.Modified
  //                    - EA.Version
  //                    - EA.Status
  //                    - EA.Author
  //                    - EA.Phase
  // - EmbeddedFileStorageDictionary
  //                    Dictionary/Folder of ReqIF embedded files to store. If blank or empty then don't store
  // - IdList"          Only "XmlStruct":
  //                    List of attribute names to use for ImportType "XmlStruct" as unique ID, e.g.  ["ForeignID"]  
  "Importer":
  [

Example

See: Settings Import, Roundtrip, Export

Tested with ReqIF Studio and DOORS.

{
          "Name"            :  "13. Roundtrip 'RoundTrip_Arch.reqifz'",
          "Description"     :  "Roundtrip with DOORS",
          "ListNo"          :  "13",
          "InputFile"       :  "c:/hoData/Projects/00Current/Veoneer/ReqIF/RoundTrip_Arch.reqifz" ,
          "ExportFile"      :  "c:/hoData/Projects/00Current/Veoneer/ReqIF/RoundTrip_ArchExport.reqifz" ,
          "PackageGuidList" :  ["{F199A750-C7BF-4625-A95D-F4C1AF8E4900}","{157D337C-13BB-4fc0-AA10-79F0A7587C99}" ],
          "PrefixTaggedValueTypeList": ["ArchA_", "ArchB_"],
          "ObjectType"      :  "Requirement",
          "Stereotype"      :  "",
          "ImportType"      :  "DoorsReqIF",
          "StatusNew"       :  "Proposed",
          "StatusChanged"   :  "None",
          "RtfNameList"     :  ["ReqIF.Text"],
          "AttrNameList"    :  ["ReqIF.ForeignID", "ReqIF.Chaptername", "ReqIF.Text"],
          "AttrNotes"       :  "ReqIF.Text",
          "AliasList"       :  ["ReqIF.ForeignID"],
          "EmbeddedFileStorageDictionary" : "c:/Temp/ReqIF/Store/12/",
          "WriteAttrNameList": [ "_ArchBlockId=EA.GUID", "_ArchitectureStatComment","_ArchitectureStatus","_SortingCrit"]

      }

Search

Find embedded files

Select the package with requirements and run the Search. It shows you all Requirements with stored embedded files.

select o.ea_guid as CLASSGUID, o.object_type as CLASSTYPE, pkg.name As[Package], o.name As [Requirement], f.FileName as [File Name]
         from (t_object o
         inner join t_objectfiles f on o.object_id = f.object_id)
		     inner join t_package pkg on o.package_id = pkg.package_id
where pkg.package_id in (#Branch#)
order by 3,4

Thanks

ReqIF#, open-source C# Library to read/write ReqIF via .NET
ReqIF.academy
OpenMCDF

References

Naming conventiona

.reqif for a single ReqIF XML file
.reqifz for a ZIP achieve containing ReqIF files and additional files

Glossary

Attribute (ReqIF) With Attributes a Requirement may contain additional information stored in the Attributes. In EA this are Tagged Values.
EA Tagged Values are a UML/SysML compliant method to provide additional properties to UML/SysML elements and connectors. Here we use it to define arbitrary ReqIF Attributes to exchange with other tools.
GUID Universally unique identifier used by EA to uniquely identify an object
MCDF Microsoft Compound Document Format (used by DOORS embedded files)
Package The Package which contains the requirements. In terms of ReqIF its the Specification or in DOORS the Module.
ReqIF Information of a file or folder with *.reqif or *.reqifz
ReqIF Requirements Interchange Format
ReqIF Roundtrip, often called ReqIF Workflow. The Standard how to exchange ReqIF requirements between two partners
ReqIF Standard of the OMG to exchange requirements between different tools, see OMG Specification
ReqIF Workflow: ReqIF workflow specifies how to exchange requirements between tools. Often called Roundtrip
ReqIF Tool: A tool that imports/exports ReqIF compliant XML documents
Requirements authoring tool: A tool to create and modifying requirements
Specification In ReqIF the container which contains the requirements. In DOORS it's named 'Module'.
SPICE Process Reference Model to assess process maturity.
Tagged Values UML/EA measure to add values to a classifier/requirement. For enumerations EA needs Tagged Value Types (Enum or Checklist).
Traceability