Sprachlicher Stil von Anforderungen

Aufbau der Anforderungen nach IREB

Rechtliche Vebindlichkeit

VerbindlichkeitDeutsches SchlüsselwortEnglisches SchlüsselwortKommentar
PflichtmussshallEine Pflicht-Anforderung bedeutet, dass eine Forderung unbedingt erfüllt sein muss. Die Abnahme kann verweigert werden, wenn das System die Anforderung nicht erfüllt.
Wunschsollteshould Eine Wunsch-Anforderung drückt aus, dass es ganz gut wäre, wenn z.B. ein Bericht vom Entwickler wöchentlich erstellt wird. Allerdings fordert der Anforderer verpflichtend nur monatliche Berichte.
AbsichtwirdwillDie Absichts-Anforderungen werden vom Anforderer gestellt, um dem Entwickler die Punkte aufzuzeigen, zu denen er schon Pläne für die Zukunft hat. Diese Information soll es dem Entwickler ermöglichen, das System zukunftssicher zu konzipieren
Vorschlagkanncannforderer kommen beim Nachdenken über zu entwickelnde Systeme auf verschiedene Lösungsmöglichkeiten für ein Problem. Diese werden für die spätere Verwendung durch Entwickler in Form von Vorschlags-Anforderungen konserviert.

Verwendung von Satzschablonen

Selbstständige Systemaktivität

Systemaktivitäten, die ohne Zutun des Benutzers ausgeführt werden.

[<Wann?>] [<Unter welcher Bedingung?>]
MUSS | SOLLTE | WIRD
DAS SYSTEM
<Objekt & Ergänzung des Objektes>
<Prozesswort>

Benutzerinteraktion

Funktionalitäten, die dem Benutzer vom System zur Verfügung gestellt werden.

[<Wann?>] [<Unter welcher Bedingung?>]
MUSS | SOLLTE | WIRD
DAS SYSTEM (shall provide the operator the possibility to …)
<Wem?>
DIE MÖGLICHKEIT BIETEN
<Objekt & Ergänzung des Objektes>
<Prozesswort>

Schnittstellenanforderung

Systemaktivitäten, die (nur) in Abhängigkeit von Nachbarsystemen ausgeführt werden.

[<Wann?>] [<Unter welcher Bedingung?>]
MUSS | SOLLTE | WIRD
DAS SYSTEM FÄHIG SEIN (shall be able to)
<Objekt & Ergänzung des Objektes>
<Prozesswort>

Beispiele für Prozessworte

Prozessworte sind Verben, die aus den Anforderungen hervorgehen

anlegen (syn.: erzeugen, erstellen), ändern (syn.: bearbeiten), speichern, löschen, drucken, ausgeben, anzeigen, archivieren, historisieren, senden, übertragen, empfangen

Überprüfung auf Verständlichkeit

Nachdem eine Anforderung erfasst wurde, liest man den Satz nochmal und stellt die folgenden Fragen:

um unvollständig definierte Prozessworte zu eleminieren…

  • von wem?
  • wann?
  • wie (genau)?
  • wodurch?
  • wer?
  • was?
  • Mit wem?

um Generalisierungen mit Universalquantoren (bsp. für alle / für jedes) zu prüfen

  • soll das beschriebene Verfahren wirklich für alles / alle (bsp. Daten) gelten?
  • gibt es (unter bestimmten Voraussetzungen) Ausnahmen?

um unvollständig definierte Bedingungen zu eleminieren

  • was passiert wenn die Bedingung nicht erfüllt ist (else-Zweig)?
  • Gibt es mehr als nur zwei Fälle (else if?)

um Substantive ohne Bezugsindex zu vermeiden

  • Welche (bsp. Daten) … genau?
  • Was (für eine Frist?) … genau?

um Nominalisierungen aufzulösen

  • “Die Dateneingabe soll überwacht werden”

 

Veröffentlicht unter Allgemein | Hinterlasse einen Kommentar

Projekt Fahrgemeinschaftsbörse

Ausgangssituation

Der Zusammenschluss mehrerer Personen zu einer Fahrgemeinschaft mit gemeinsamen Zielort wirft jeden Morgen die Frage nach der gerechten Fahrten-Verteilung unter den Teilnehmern auf.

  • Wer nimmt heute an der Fahrt teil?
  • Ist die Teilnehmerzahl für eine Autofahrt zu hoch ( >5 Personen) ?
  • Wer ist heute mit dem Fahren dran?
  • Benötigt heute jemand ein Auto und muss deswegen ungeachtet einer vorbestimmten Reihenfolge fahren?
  • Wie behält man bei Ausfällen (z.B. Urlaub, Dienstreisen, Krankheit) von Personen eine gerechte Reihenfolge unter Berücksichtigung der vorherigen Fahrten bei?
  • Wie geht man fair mit der Situation um, dass aufgrund schwankender Teilnehmerzahlen bestimmte Mitglieder

Definition der Projektziele

  • Minimierung des Koordinationsaufwands zwischen den Teilnehmern der Fahrgemeinschaft.
  • Definition eines fairen Rechenmodells für die Punkteverteilung an die Fahrgemeinschaftsmitglieder
    • nicht kostenorientiertes, geldloses Rechenmodell
    • rein auf den Personentransport bezogen

Zielgruppe

Die angestrebten Nutznießer des Projektes sind vorwiegend Berufspendler und weitere Personen, die an der häufigen Inanspruchnahme einer Fahrgemeinschaft zu einem bestimmten Zielort, oder einer Teilstrecke interessiert sind.

Intention

Die Teilnehmer haben als Ziel die Minimierung ihrer Kraftstoff- und Kraftfahrzeugkosten und/oder ein Interesse den Schadstoffausstoß nachhaltig zu reduzieren.

Voraussetzungen und Prämissen

Die Teilnehmer…

  • gehen den Kompromiss geregelter Abfahrtszeiten ein
  • können sich arrangieren und gemeinsame Treffpunkte/Parkplätze finden
  • haben ähnliche/gleiche Arbeitszeiten und/oder ein Arbeitszeitmodell (Gleitzeit), dass eine flexible Arbeitszeitgestaltung im Sinne der Fahrgemeinschaftsteilnehmer erlaubt.

Systemidee

Es wird ein mobilfähiges, webbasiertes Fahrgemeinschaftsportal geschaffen, dass das Gründen, Finden und Verwalten von Fahrgemeinschaften ermöglicht.

Das Herzstück der Anwendung ist ein punktebasiertes Rechenmodell, welches die Fahrerreihenfolge anhand der individuell erbrachten Vorleistungen/Fahrten der Fahrgemeinschaftsmitglieder bestimmt.

Feature Liste / Anwendungsfälle

Das System muss dem Benutzer die Möglichkeit bieten …

  • Benutzer registrieren
  • Benutzer per eMail freischalten
  • Benutzerlogin
  • Fahrgemeinschaft gründen
  • Fahrgemeinschaft suchen
  • Fahrgemeinschaft beitreten (evtl. über Freundschaftsanfrage)
  • Teilnehmer anlegen
  • Teilnehmer suchen
  • Teilnehmer löschen
  • Strecke suchen
  • Strecke anlegen
  • Strecke löschen
  • Treffpunkt suchen
  • Treffpunkt anlegen
  • Treffpunkt löschen
  • Fahrt anlegen
  • Fahrt nachtragen (für ein Datum)
  • Fahrt editieren (für ein Datum)
  • Fairnessausgleich, wenn ein Benutzer öfter die Fahrten mit wenigen Teilnehmern erwischt.

Anforderungen

Ein Benutzer registriert sich bei der Fahrgemeinschaftsanwendung. Nachdem er seine Login-Daten per eMail erhalten hat, kann er sich im System einloggen.

Der Benutzer sucht nach Fahrgemeinschaften und kann diesen eine Freundschaftsanfrage senden, die durch den Fahrgemeinschaftsadministrator freigegeben wird.

Wenn die Freundschaftsanfrage vom Fahrgemeinschaftsadministrator genehmigt wurde, hat der Benutzer Zugriff auf die Strecke / die Strecken, die von der Fahrgemeinschaft angelegt wurden, und kann auf diesen Strecken teilnehmen.

Der Benutzer hat die Möglichkeit eine eigene Fahrgemeinschaft zu gründen, wenn für seine Strecken noch kein passender Eintrag existiert.

Eine Fahrgemeinschaft hat mindestens eine Strecke, die von einem Starttreffpunkt zu einem Zieltreffpunkt definiert ist.

Der Starttreffpunkt hat eine festgelegte Abfahrtszeit, der Zieltreffpunkt eine festgelegte Ankunftszeit.

Eine Fahrt findet zu einem Datum auf einer Strecke statt. Eine Fahrt besteht aus mindestens 2 Teilnehmern.

Ein Teilnehmer besitzt ein Punktekonto an einer Strecke, welches bei der Teilnahme als Nicht-Fahrer um einen Punkt (Streckenkonto = Streckenkonto – 1) reduziert wird.

Wenn der Teilnehmer als Fahrer ausgewählt wurde oder sich selbst anbietet, wird sein Punktekonto um die Anzahl der Mitfahrer erhöht (Streckenkonto = Streckenkonto + Anzahl d. Mitfahrer).

Wenn die Teilnehmerzahl die Transportkapazität einer Fahrt übersteigt, können mehrere Teilnehmer als Fahrer fungieren, die jeweils die Punkte gutgeschrieben bekommen, die der mitgenommenen Teilnehmerzahl entsprechen. Die Teilnehmer teilen die Fahrten dann selbständig auf.

Ein neuer Teilnehmer steigt in eine Strecke mit einem Punktestand von 0 Punkten ein, so dass die Summe aller Fahrten auf einer Strecke immer 0 ergibt.

Wenn ein Teilnehmer von einer Strecke entfernt wird, werden seine Fahrten durch die Anzahl der Teilnehmer geteilt und den übrigen Teilnehmern zugeordnet, so dass die Summe aller Fahrten auf einer Strecke wieder 0 ergibt.

Veröffentlicht unter Allgemein | Hinterlasse einen Kommentar

IBM Doors DXL: Delete and Create Attributes for Doors Module

Problem

An Attribute shall be deleted and replaced (recreated) by the same attribute with another type.

Approach

– Delete old attribute
– Create new one
– Views will not get lost with this method!

Solution

void deleteAttrDef(Module m, string s)
{
  string err;
  AttrDef ad = find(m, s);
  err = delete(ad);
  if (err !="") ack err;
} 

void modifyAttributeType(Module m, string theAttribute, string newAttributType)
{
  current = m;
	
  // Delete Attribute attribute1 if exists
  if (exists(attribute(string theAttribute))) 
  {	
    deleteAttrDef(m, theAttribute);
  }
	
  // Create new attribute1 of type TEXT (not string)
  AttrDef ad = create object type newAttributType attribute theAttribute
		
  if (null ad)
  {
    print "attr didn't create for module " fullName(m) "\n";
    halt;
  }			
}

modifyAttributeType(current Module, "My_Attribut_To_Change_Type", "Text");
Veröffentlicht unter Allgemein | Hinterlasse einen Kommentar

IBM Doors DXL: Attribut eines verlinkten Objektes Ausgeben

Problem

Es soll eine LayoutDXL Spalte erzeugt werden, die ein Attribut aus einem verlinktem Requirement (Im V-Model z.B. obendrüber also hier Outlink) ausgibt.

Ansatz

* Öffnen des Moduls
* Nutzen der obj Referenz für das Objekt in der aktuellen Zeile
* Link Modul spezifizieren

Lösung

Module rsModule = read("/pathTo/RS", false);

Link lnk;
Object trg;
string lnkMod;
string strSat = "/pathToLinkModules/Satisfies";

for lnk in obj->"*" do 
{
  lnkMod= fullName module(lnk);
  
  if(!null lnkMod)
  {
	  if(lnkMod == strSat)
	  {
	      Object trg = target(lnk);
	      display trg."BB_PlannedRelease" "";
	  }
  }
}
Veröffentlicht unter DXL, IBM DOORS | Hinterlasse einen Kommentar

IBM Doors DXL: Import from Sparx Systems Enterprise Architect

Problem

To refresh all UML Diagrams within an Formal Doors Module, a script is needed that imports all actual versions of a UML Diagram.

Approach

* Copy the GUID of the Diagram / Note
** right-click the project menu on the right side.
** Select “Copy Reference -> Copy Node GUID to clipboard”
* If not done before, create an Module attribute (here ATTRIBUT_WITH_GUID)
* Paste the GUID to the place in your doors module, where the diagram should be created

Solution

// Recommended as module plugin
/**
 * Run through all objects of the current module 
 * and watch for the attribute ATTRIBUT_WITH_GUID.
 * If it is not empty, fetch the diagram/note
 * from this attribute an load it into the 
 * Object Text of Sparx Systems Enterprise Architect
 */

Object o
Filter currentFilter, f
Module m
DB updateWin

string guid
string projectPath = "DP_ENTARCHITECT --- DBType=1;" //-
"Connect=Provider=SQLOLEDB.1;Integrated Security=SSPI;" //-
"Persist Security Info=False;Initial Catalog=DBNAME;" //-
"Data Source=EA_DB_SERVER"

OleAutoObj eaProject, eaRepository, diaObj, actObj
OleAutoArgs autoArgs = create
string diagramName, elementNotes

void establishInterface()
{
 eaProject = oleGetAutoObject("EA.Project")
 if(null(eaProject))
 { 
   eaProject = oleCreateAutoObject("EA.Project")
 }

 if(null(eaProject))
 {
   ack "Creating OLE-Object 'EA.Project' not possible."
   progressStop
   halt
 }

 eaRepository = oleGetAutoObject("EA.Project")

 if(null(eaRepository))
 {
   eaRepository = oleCreateAutoObject("EA.Repository")
 }

 if(null(eaRepository))
 {
   ack "Creating OLE-Object 'EA.Repository' not possible."
  progressStop
  halt
 }

 put(autoArgs,projectPath)
 oleMethod(eaRepository,"OpenFile",autoArgs)
 clear(autoArgs)
}

void closeInterface()
{
  oleMethod(eaRepository,"CloseFile",autoArgs)
  oleMethod(eaRepository,"Exit",autoArgs)
	
  delete(autoArgs)
}

void updateObjects()
{
 int progessbarStep = 0
 bool diagramCopied
 string fileName

 for o in m do
 {
  guid = o."BB_ImageFileName"
  diagramCopied = false
	
  if(guid != "" && guid[0:0] == "{")
  {
   progressMessage("Updating " identifier(o))
   put(autoArgs, guid)
		
   /**************************************************
    * Gets a pointer to a diagram using an absolute 
    * reference number (local ID). This is usually 
    * found using the DiagramID property of an 
    * element, and stored for later use to open a diagram 
    * without using the 
    * collection GetAt() function.
    **************************************************/
    oleMethod(eaRepository, "GetDiagramByGuid", autoArgs, diaObj)
		
    /*************************************************
     * An Element is the main modeling unit. 
     * It corresponds to (for example) a Class, 
     * Use Case, Node or Component. 
     * You create new elements by adding to the 
     * Package Elements collection. 
     * Once you have created an element, you can add it
     * to the DiagramObject 
     * Class of a diagram to include it in the diagram.
     ****************************************************/
     oleMethod(eaRepository, "GetElementByGuid", autoArgs, actObj)
     clear(autoArgs)
		
     // Wenn das Diagramm mit der GUID nicht gefunden wurde
     if(null(diaObj))
     {
      // ... und auch kein Element mit der GUID gefunden wurde
      if(null(actObj))
      {
         ack "GUID " guid " of object " identifier(o) "" //-
            " not found in EA as diagram or element."
      }
      else
      {
        // Es wurde kein Diagramm, aber ein Element 
        // mit der GUID gefunden
        oleGet(actObj, "Notes", elementNotes)
        if(null(elementNotes))
        {
          ack "Getting Notes of GUID " guid " failed."
        }
        else
        {
	 o."Object Text" = elementNotes
	 progressStep(++progessbarStep)
        }
      }
    }
    else // Es wurde ein Diagramm mit der GUID gefunden
    {					
      /***************************************************
       *  EA.Project.PutDiagramImageOnClipboard: 
       *  ======================================
       *  Copies an image of the specified diagram to the 
       *  clipboard.
       *	
       *  Parameters:
       *	•	DiagramGUID: String - the GUID 
       *        (in XML format) 
       *        of the diagram 
       *        to copy
       *	•	Type: Long - the file type
       *		•	If Type = 0 then it is a metafile
       *		•	If Type = 1 then it is a Device 
       *            Independent Bitmap
       *
       *****************************************************/
       put(autoArgs, guid)
       put(autoArgs, 0)				
       oleMethod(eaProject, "PutDiagramImageOnClipboard", autoArgs, 
	             diagramCopied)
       clear(autoArgs)
		
       if(diagramCopied)
       {
         while(oleDelete(o));
         if(olePaste(o))					
         {
	       oleSetMaxWidth(o."Object Text", 400)
	        progressStep(++progessbarStep)
         }
         else
         {
	       ack "Pasting from clipboard of GUID " guid " failed."
         }
       }
       else
       {
         ack "Copying to clipboard of GUID " guid " failed."
       }
     }
	 diaObj = null
     actObj = null
   }
  }
}

void main(DB updateWin)
{
  int accepted, rejected

  currentFilter = current	
  f = contains(attribute("ATTRIBUT_WITH_GUID"),"{", false)
  set(m, f, accepted, rejected)
  unApplyFiltering(m)
  progressStart(updateWin, "Executing update", "Processing...", accepted)
  establishInterface()
  updateObjects()
  if(!null(currentFilter)) set(m, currentFilter, accepted, rejected)
  closeInterface()
  progressStop
  refresh(m)
  hide(updateWin)
  destroy(updateWin)
  updateWin = null
}

m = current
if(null(m))
{
  ack "Update can only be started within a module."
}
else
{
 if(isEdit(m))
 {
   updateWin = create("Update EA ", styleCentered|styleFloating)
   label(updateWin, "Do you wish to update?")
   ok(updateWin, main)
   show updateWin
 }
 else
 {
  ack "Module must be opend in 'Exclusive Edit'."
 }
}
Veröffentlicht unter DXL, Modellierung, Sparx Systems Enterprise Architect | Hinterlasse einen Kommentar

IBM Doors DXL: Browse Triggers on module

Problem

When there are triggers on a module it often is not visible to administrators and other users that can perform DXL operations.

Approach

A menu point as module add in should be generated. Copy the following script to the moduleaddins directory of your doors installation.

Solution

// This is necessary that it works
/*******************************************************
 * Author: Björn Karpenstein
 * Date:   2014-10-01
 * 
 * This script lists all triggers of the module
 ******************************************************/
pragma runLim, 0;

string lstArray [] = {}; 
 
DB mainWindow;
DBE textBox;
DBE textList;

void listAllTriggerForMod (Module mod) 
{
  string theResult="";
  Trigger t;
  int i = 0;
  for t in mod do 
  {
    insert(textList, i, name(t) "", iconNone);
    i++;
  }
}

string getSourceForTriggerName (string theTrigger) 
{
  string sourceCode = "";
  Trigger t;
  for t in current Module do 
  {
    if(name(t) "" == theTrigger)
    {
      sourceCode = dxl(t) "";
    }		
  }
	
  return sourceCode;
}

void doDeselect(DBE dbe, int idx)
{
  //infoBox "You deselected " dbe[idx] "";
} 


void doActivate(DBE dbe, int idx)
{
  // infoBox "You activated " dbe[idx] "";	
}

void doSelect(DBE dbe, int idx)
{
  string triggerName = getColumnValue(textList,idx,0);
  set(textBox, getSourceForTriggerName(triggerName));	
} 

void main(void)
{
  User currentUser = find();
  bool mayDXL = currentUser.mayEditDXL;
  if (!mayDXL)
  {
   // Show error box and inform user. Stop execution of script.
   errorBox "You are not allowed to run/edit DXL code!";
   halt;
  }		
	
  mainWindow = create("List all triggers");
	
  textList = listView(mainWindow, 0, 310, 20, lstArray);		
  textBox = text(mainWindow, "", "", 400, false);
	
  textList->"right"->"unattached";
  textBox->"left"->"flush"->textList;
  textBox->"top"->"aligned"->textList;	

  realize(mainWindow);			
	
  insertColumn(textList, 0, "Trigger Name", 300, iconNone);
	
  set(textList,doSelect,doDeselect,doActivate);		
  listAllTriggerForMod(current);
	
  // set(textBox, listAllTriggerForMod(current));
  show(mainWindow);	
}

main();
Veröffentlicht unter DXL, IBM DOORS | Hinterlasse einen Kommentar

IBM Doors DXL: Auslesen aller Module eines Projektes einer BaselineSetDefinition und eines BaselineSets in ihren jeweils gebaseline-ten Versionen

Problem

Alle Module eines Projektes, die in einem BaselineSet freigegeben wurden, sollen in Ihrer Version im BaselineSet ausgelesen werden.

Approach

  1. Generell auslesen der Module in einer BaselineSetDefinition
  2. Auslesen des BaselineSets der Version {baselineSetVersion}
  • Die BaselineSetDefinition beinhaltet die Module, die für ein BaselineSet (hier Release_Set) vorgesehen sind. Eine BaselineSetDefinition hat einen Namen, unter dem die BaselineSet-Versionen erzeugt werden.
  • Das BaselineSet ist eine Version einer BaselineSetDefinition und hat den Namen der BaselineSetDefinition. In einem BaselineSet befinden sich Baseline-Versionen der Module aus der BaselineSetDefinition;

Solution

string baselineSetDefinition="Release_Set";
string baselineSetVersion="5.0";

BaselineSetDefinition bsd;
Folder f = folder "/MyProject";
ModName_ modName;

for bsd in f do
{
  if(name(bsd) "" == baselineSetDefinition)
  {
    // 1.) Generell auslesen der Module in einer BaselineSetDefinition
    for modName in bsd do
    {
      print name(bsd) " " name(modName) "\n";
    }

    // 2.) Bsp: Auslesen des BaselineSets der Version {baselineSetVersion}
    BaselineSet bs;
    for bs in bsd do
    {
       if(versionID(bs) "" == baselineSetVersion)
       {
         ModuleVersion modver;
	for modver in all bs do 
         {
           string versionsString = versionString modver;
           if(versionsString=="") versionsString="N/A";
           print fullName(modver) "\t" versionsString "\n";
	} 
        }
     }
   }
}
Veröffentlicht unter Allgemein | Hinterlasse einen Kommentar

IBM Doors DXL: A Layout DXL column that shows the differences to a previous baseline

Problem

A Layout DXL Column script should show the differences to another baseline

Approach

  • Right-click column header
  • Select “New”
  • Choose “Layout DXL”  radio button
  • Click on the browser button
  • Click on New
  • Insert the script below
  • Be aware to have all line breaks in the code like below

Replace {baselineToCompare} to the major version that you want to compare with the current version.

Solution

// This script shall be replace {baselineToCompare}
/**************************************************
 * Author: Björn Karpenstein
 * Date:   2014-10-09
 *
 * This is a layout DXL to show the differences from 
 * the current version to another baseline. 
 **************************************************/
Baseline oldBaseline = baseline({baselineToCompare}, 0,"");

Buffer bBefore = create;
Buffer bAfter = create;
Buffer result = create;
AttrDef ad;

Module oldModule = load(module(obj), oldBaseline, false)
Module currModule = current
showDeletedObjects(true)
int i = obj."Absolute Number"
Object oldObject = object(i, oldModule)

void compareColumn(string columnName)
{
  ad = find(oldModule, columnName);
		
  if(!null(ad) &amp;&amp; !null(oldObject))
  {
    bBefore = oldObject.columnName;
  }
  else bBefore = "";
		
  ad = find(currModule, columnName)

  if(!null(ad))
  {
    bAfter = obj.columnName;
  }
  else bAfter = "";
		
  bAfter = obj.columnName;

  if( bBefore != bAfter )
  {
    diff(result, bBefore, bAfter);
    displayRichWithColor("{\\b " columnName " CHANGED}");
    displayRichWithColor(stringOf(result));
  }
}
				
if(null(oldObject))
{
  displayRichWithColor("{\\b NEW}");
  if(isDeleted(obj)) displayRichWithColor("{\\b DELETED}");
}
else
{			
  if(isDeleted(obj) &amp;&amp; !isDeleted(oldObject))
  {
    displayRichWithColor("{\\b DELETED}");
  }
  else
  {
    if(!isDeleted(obj) &amp;&amp; isDeleted(oldObject))
    {
      displayRichWithColor("{\\b UNDELETED}");
    }
  
    // Here you can add the 
    // module attributes to compare	
		
    /*** BB_ReqStatus ***/		
    compareColumn("BB_ReqStatus");
	
    /*** BB_Type ***/
    compareColumn("BB_Type");

    /*** Last Modified On ***/
    compareColumn("Last Modified On");
		
    /*** Object Heading ***/
    compareColumn("Object Heading");

    /*** Object Text ***/
    compareColumn("Object Text");
  }
}
		
delete bBefore;
delete bAfter;
delete result;
Veröffentlicht unter DXL, IBM DOORS | Hinterlasse einen Kommentar

IBM Doors DXL: Filtern mit accept und reject

Problem

Ein Standard-Filter kann aus logischen Ausdrücke nach Spalten und Attributen bestehen. Möchte man einen Filter anhand komplexerer Strukturen aufbauen, stößt man bei den Möglichkeiten, die die Doors GUI bietet, an die Grenzen.

Approach

In solchen Fällen kann man die internen Funktionen benutzen, die bei einer Filterung verwendet werden.

  • Filtern ausschalten
  • Iteration über das Modul
  • Abfrage der komplexeren Bedingungen, die das Filtern tun sollen (hier einfache IF() Struktur)
  • accept(obj) <– diese Objekte kommen in den Filter
  • reject(obj) <– diese Object werden aus dem Filter entfernt
  • Filtern einschalten

Solution

Module m = current;
filtering off;	
Object anObject = null;
for anObject in m do
{
  if(anObject."BB_Type" "" != "Reviewer")
  {
    reject anObject;
  }
  else
  {
    accept anObject;
  }
}
filtering on;
Veröffentlicht unter DXL, IBM DOORS | Hinterlasse einen Kommentar

IBM Doors DXL: How to create a new view with LayoutDXL, Object Text and Object Heading, several attributes

Problem

A new view with the Main-Column (Object Heading and Object Text), a LayoutDXL Attribute and any other attribute shall be created.

Approach

  • Create View from Default View (overwrite existing)
  • Delete all columns in the Default View
  • Insert Columns

Solution

With this script you can iterate over all Attributes you can select for the view:

Module m = current;
string attr;

for attr in m do
{
  print attr "\n";
}

The following script generates the view:

void createViewForModule(Module m, string viewName)
{	
  // construct view of attributes chosen
  Column c;
  int n = 0; // number of existing columns
  int i; // column index
	
  View v = view(viewName);
  bool isLoaded = load(m,v);

  if(!isLoaded)
  {
    // If the view is not existing
    // Save the view
    // Normally the default View 
    // is constructed 	
    // save(m,v) is not asking
    // if a view exists -&gt; it 
    // overwrites any view with
    // the same name	
    save(m,v);
   }		
	
   // count the columns
   for c in m do
   {
      n++; 
   }
	
   // Delete all columns that were
   // contained in the default View
   // used as template
   for(i=1;i&lt;=n;i++)
   {
     delete(column 0); 
   }
	
   // Add Object Identifier (i.e. CRS-CS-2)
   insert(column 0);
   attribute(column 0, "Object Identifier");
   width(column 0, 80);
   justify(column 0, left);
	
    // Add the main Column (Object Heading+
    // Object Text) to the View
    Column mainColumn = null;
    mainColumn = insert mainColumn;
    main mainColumn;
    width(mainColumn, 300);
	
    // Add Object Identifier (i.e. CRS-CS-2)
    insert(column 2);
    attribute(column 2, "BB_ReqStatus");
    width(column 2, 80);	
	
    // Create a LayoutDXL Column in a view
    insert(column 3);  
    // I would recommend to #include scripts
    dxl(column 3, "displayRich \"huhu\""); 
    width(column 3, 80);	

    // important! (last column does not appear
    // otherwise)
    refresh m; 
    save view viewName; 
}
Veröffentlicht unter DXL, IBM DOORS | Hinterlasse einen Kommentar