Gruppierte Forward-Pfad-Berichte

Dieses Thema bietet einen Überblick über die erweiterte Forward Path Funktionalität, mit der Sie Anwendungen nach Kategorien gruppieren können, die im Skript definiert sind (z. B. Eignung für die Bereitstellung auf einer bestimmten Plattform) oder nach der AppDNA-Anwendungsgruppe, zu der die Anwendungen gehören. Sie können Anwendungswerte auf Gruppenebene aggregieren, z. B. um Zwischensummen für jede Gruppe zu erstellen, und Summen auf Berichtsebene erstellen. Dies bedeutet beispielsweise, dass Sie, wenn Anwendungsgruppen Geschäftseinheiten darstellen, einen Forward Path Report erstellen können, der die Anwendungen nach Geschäftseinheiten gruppiert und Zwischensummen für jede einzelne zeigt.

Übersicht

Die folgende Abbildung zeigt einen Ausschnitt eines Forward Path-Berichts, in dem die Anwendungen nach ihrem RAG-Status für die Windows 7- und App-V Berichte gruppiert wurden. Für jede Gruppe werden die Gesamtkosten der Behebung zusammen mit einer Anzahl der Anwendungen in der Gruppe angezeigt. Sie können jede Gruppe erweitern, um die darin enthaltenen Anwendungen anzuzeigen. Die Summenzeile oben zeigt die Summen für den gesamten Bericht.

Bild des Forward-Pfadberichts

Wir werden das Forward Path Szenario erstellen, das diesen Bericht in den folgenden Beispielen generiert hat. Um die Beispiele so einfach wie möglich zu gestalten, verwenden wir für jede Anwendung einen hartcodierten Korrekturaufwand. Im wirklichen Leben würden Sie dies wahrscheinlich basierend auf der Anwendungskomplexität und der erforderlichen Korrektur berechnen. Ein Beispiel, das die Kosten auf diese Weise berechnet, finden Sie unter Variablen des Effort Calculator in einem Forward Path Szenario verwenden.

Das Szenario funktioniert

Das Szenario für einen gruppierten Forward Path Bericht implementiert in der Regel die folgenden standardmäßigen Forward Path Funktionen:

  • Initialize() — AppDNA ruft diese Funktion automatisch einmal am Anfang des Skripts auf. Typischerweise initialisiert diese Funktion Variablen.
  • ForwardPath() - Dies ist die Standardfunktion, die alle Forward Path Szenarien implementieren müssen. AppDNA ruft diese Funktion einmal für jede Anwendung auf, die beim Ausführen des Berichts ausgewählt wird. In einem gruppierten Forward Path Bericht erstellt diese Funktion Kategorien (sogenannte Berichtgruppen), in die die Anwendungen platziert werden. Die Berichtsgruppen können durch die Logik im Code erstellt werden oderAnwendungsgruppenauf der Grundlage der Anwendungen bereits angehören.
  • ProcessGroups() — AppDNA ruft diese Funktion einmal für jede Berichtsgruppe auf, die von der ForwardPath() -Funktion generiert wird. Diese Funktion definiert die Berichtsspalten auf Gruppenebene und die darin enthaltenen Werte.
  • GetGroupColumnSummary() — AppDNA ruft diese Funktion einmal für jede Spalte auf, die in der ProcessGroups() -Funktion definiert ist. In der Regel definiert diese Funktion die Summen auf Berichtsebene.
  • OnProcessingComplete() - Dies ist eine optionale Funktion, die AppDNA einmal aufruft, nachdem der Rest der Verarbeitung abgeschlossen ist. Sie können diese Funktion verwenden, um eine endgültige Verarbeitung durchzuführen, bevor der Bericht angezeigt wird.

Das folgende Diagramm zeigt, wie AppDNA die Funktionen aufruft, wenn Sie den Bericht ausführen. Dem Diagramm folgt die Spezifikation der einzelnen erweiterten Funktionen, zusammen mit einem Beispiel, das zusammen den Bericht erstellt, der im Abschnitt Übersicht oben gezeigt wird.

Erweiterte Funktionen

Hinweis: Einige der Beispiele in diesem Thema verwenden die Unterstriche (_) -Notation, um lange Linien in zwei oder mehr Zeilen zu unterteilen. Dies ist so, dass die Beispielcode-Snippets korrekt dargestellt werden, wenn sie in einer PDF-Datei enthalten sind. Weitere MSDN-Bibliothek Informationen zu dieser Notation finden Sie im.

Initialize()

Wenn im Szenario angegeben, ruft AppDNA automatisch die Funktion Initialize() zu Beginn des Skripts auf. Die Funktion Initialize() muss die folgende Signatur haben:

Public Overrides Sub Initialize()
   ' Enter your code here.
End Sub

In diesem Beispiel werden wir die Initialize() Funktion verwenden, um Variablen zu initialisieren, die wir verwenden, um Anwendungswerte zu speichern, so dass sie auf Gruppenebene aggregiert werden können. Zuerst müssen wir jedoch die Variablen deklarieren, die wir im gesamten Szenario verwenden möchten. Da wir diese Variablen in mehr als einer Funktion verwenden, werden wir sie am Anfang des Skripts definieren (vor der Initialize() Funktion), wie folgt:

' Declare a Dictionary variable to store the remediation
' costs for each application in the group.
Private Dim costs As Dictionary(Of String, List(Of Integer)) _
   = New Dictionary(Of String, List(Of Integer))

' Declare string variables that store the names of the
' report groups.
Private Dim win7group As String = "Windows 7"
Private Dim appvgroup As String = "App-V"
Private Dim othergroup As String = "Retire"

In diesem Beispiel haben wir eine Dictionary Variable namens Kosten deklariert. Dokumentation zu dieser Standard-.NET-Klasse finden Sie in der MSDN-Bibliothek. Die Wörterbuchvariable kann eine Sammlung von Schlüsseln und Werten speichern. In diesem Beispiel ist der Schlüssel eine Zeichenfolge (die wir verwenden, um den Namen der Berichtsgruppe zu speichern) und der Wert ist eine Liste von ganzen Zahlen (die wir verwenden, um die Korrekturkosten für alle Anwendungen in der Berichtsgruppe zu speichern). Dokumentation der MSDN-Bibliothek List-Klasse finden Sie in.

Neben dem Wörterbuch haben wir drei String-Variablen deklariert, um die Namen der drei Berichtsgruppen zu speichern, die wir erstellen werden.

Jetzt sind wir bereit, die Initialize() Funktion zu implementieren. Hier ist es:

Public Overrides Sub Initialize()
   costs.Add(win7group, New List(Of Integer))
   costs.Add(appvgroup, New List(Of Integer))
   costs.Add(othergroup, New List(Of Integer))
End Sub

In diesem Beispiel haben wir einfach einen Artikel zu unserer Kostenwörterbuchvariablen für jede unserer drei Berichtsgruppen hinzugefügt. Wir haben die Elementschlüssel mit den drei String-Variablen angegeben, die wir zuvor deklariert haben, um die Namen der Berichtsgruppen zu speichern.

ForwardPath()

Die ForwardPath() -Funktion ist die Standardfunktion, die alle ForwardPath-Szenarien implementieren müssen. Die ForwardPath() -Funktion muss die folgende Signatur haben:

Public Function ForwardPath(ByVal currentApplication _
   As Application) As Output
      ' Enter your code here.
End Function

In diesem Beispiel trennen wir die Anwendungen in drei Berichtsgruppen — wir fügen Anwendungen mit einem grünen Windows 7-RAG-Status zur Berichtsgruppe “Windows 7” hinzu, fügen Anwendungen hinzu, die einen grünen App-V RAG-Status haben, der Berichtsgruppe “App-V” hinzu und fügen den Rest der Anwendungen hinzu. in eine Berichtgruppe “Ruhestand”. Für jede Anwendung fügen wir dem Wörterbuch eine zufällige fest codierte Nummer hinzu, um die Kosten für die Wiederherstellung der Anwendung darzustellen:

Public Function ForwardPath(ByVal currentApplication _
   As Application) As Output

   Dim result As New Output()

   ' Is the application green for Windows 7?
   If (currentApplication.Modules.Windows7.RAG = RAG.Green) _
     Then
      result.Outcome = "Windows 7 OK"
      result.RAG = RAG.Green
      result.Cost = 33

      ' Add the application to the "Windows 7" group.
      result.ReportGroups.Add(win7group)

      ' Add the remediation cost to the dictionary variable.
      costs.Item(win7group).Add(33)
   Else

      ' Is the application green for App-V?
      If (currentApplication.Modules.AppV.RAG = RAG.Green) Then
         result.Outcome = "App-V OK"
         result.RAG = RAG.Green
         result.Cost = 170

         ' Add the application to the "App-V" group.
         result.ReportGroups.Add(appvgroup)

         ' Add the remediation cost to the dictionary variable.
         costs.Item(appvgroup).Add(170)
      Else

         ' The application is not green for Windows 7 or App-V.
         result.Outcome = "Not suitable for migration."
         result.RAG = RAG.Red
         result.Cost = 713

         ' Add the application to the "Retire" group.
         result.ReportGroups.Add(othergroup)

         ' Add the replacement cost to the dictionary variable.
         costs.Item(othergroup).Add(713)
      End If
   End If

   result.Display.SourcePath.Visible = false

   ForwardPath = result

End Function

Beachten Sie, dass wir verwendet haben Wenn… Dann… Else-Anweisungen, um die Anwendungen basierend auf dem RAG-Status für die Windows 7- und App-V Berichte in die drei Berichtsgruppen zu unterteilen. Wir hätten die Berichtsgruppen auf der Anwendungsgruppe basieren können, zu der die Anwendungen gehören. Ein späteres Beispiel in diesem Thema zeigt Ihnen, wie Sie das tun können.

Hinweis: Es ist möglich, dieselbe Anwendung mehreren Gruppen hinzuzufügen. Wenn Sie dies tun, wird die Anwendung beim Ausführen des Berichts unter jeder Gruppe angezeigt, der sie hinzugefügt wurde, und ihre Werte werden zu den Summen jeder Gruppe aggregiert. Dies kann dazu führen, dass die Werte der Anwendung dem Bericht insgesamt mehr als einmal hinzugefügt werden. Je nach Bericht könnte dies möglicherweise irreführend sein. Es liegt an Ihnen als Skriptautor, sicherzustellen, dass Anwendungen nicht mehr als einer Gruppe hinzugefügt werden, es sei denn, dies ist Ihre Absicht.

ProcessGroups()

Wenn sie im Szenario angegeben ist, ruft AppDNA die Funktion ProcessGroups() für jede Berichtsgruppe auf, die von der Funktion ForwardPath() generiert wird. In der Regel verwenden Sie die ProcessGroups() -Funktion, um die Spalten zu definieren, die auf Gruppenebene im Bericht “Forward Path” angezeigt werden.

Die Funktion ProcessGroups() muss die folgende Signatur haben:

Public Overrides Sub ProcessGroup(group As _
   ForwardPathReportGroup)
      ' Enter your code here.
End Sub

Beachten Sie, dass das ForwardPathReportGroup -Objekt an diese Funktion übergeben wird. Dies stellt die aktuelle Berichtgruppe dar. Es verfügt über zwei Eigenschaften: Name, ein,Stringdas den Namen der Gruppe speichert, und CustomColumns, ein Wörterbuch von Zeichenfolgen. Mit der CustomColumns -Eigenschaft geben Sie die Namen der Spalten an, die auf Gruppenebene angezeigt werden, und was sie enthalten.

Hier ein Beispiel:

Public Overrides Sub ProcessGroup(group As _
   ForwardPathReportGroup)

   ' 1. Define a report group column to show the total
   ' cost for the applications in the group and format it
   ' as currency.
   group.Columns.Item("Cost").Value = _
      costs.Item(group.Name).Sum()
   group.Columns.Item("Cost").Format = "{0:C}"
   group.Columns.Item("Cost").Culture = "en-US"

   ' 2. Define a report group column to show the number of
   ' applications in the group.
   group.Columns.Item("Count").Value = _
      costs.Item(group.Name).Count

   ' 3. Define a report group column that has a link to
   ' further information.
   group.Columns.Item("Link").Value = _
   "<a target=""_blank"" href=""http://www.google.com"">More information</a>"

End Sub

Beachten Sie, dass wir drei Spalten definiert haben:

  1. Dadurch wird die Spalte Kosten definiert, in der die Gesamtbehebungskosten der Anwendungen in jeder Gruppe angezeigt werden. Um die Gesamtkosten zu erhalten, verwenden wir die List.Sum() -Methode, um alle Kostenwerte für die Gruppe in der Kostenwörterbuchvariablen gespeichert zu aggregieren. Die List-Klasse verfügt über andere Aggregationsfunktionen, mit denen Sie beispielsweise den für die Gruppe gespeicherten Durchschnitts-, Minimal- oder Maximalwert abrufen können. Dokumentation der MSDN-Bibliothek List-Klasse finden Sie in.

    Beachten Sie, dass wir die Format -Eigenschaft für die Spalte auf {0:C} festgelegt haben (was angibt, dass der Wert eine Währung ist). Und wir haben die Eigenschaft Culture auf den Wert en-US gesetzt, um anzugeben, dass das Währungssymbol das US-Dollarsymbol ist. Weitere InformationenBerichte zum Weiterleitungspfad sortieren und formatierenzum Formatieren der Ausgabe finden Sie im.

  2. Dies definiert die Spalte “Anzahl”, die die Anzahl der Anwendungen in jeder Gruppe anzeigt. Dieses Mal verwenden wir die List.Count () Methode, um die Anzahl der Elemente (die Anwendungen darstellen) für die Gruppe in der Kostenwörterbuchvariable gespeichert zu erhalten.

  3. Dies definiert die Spalte Link, die HTML-Code enthält, der einen fest codierten Hyperlink definiert. Dies ist ein übervereinfachtes Beispiel, das zeigt, dass Sie HTML-Code in die Spalte einfügen können.

Hinweis: AppDNA generiert automatisch eine Spalte, die den Gruppennamen anzeigt. Dies wird die Spalte “Gruppe” genannt.

GetGroupColumnSummary()

Wenn sie im Szenario angegeben ist, ruft AppDNA automatisch die Funktion GetGroupColumnSummary() für jede Spalte auf, die in der ProcessGroups() -Funktion definiert ist, sowie die automatisch generierte Spalte “Group” (in der der Gruppenname gespeichert wird). Die Funktion GetGroupColumnSummary() muss die folgende Signatur aufweisen:

Public Overrides Function GetGroupColumnSummary(groupColumnName _
   As String) As String
      ' Enter your code here.
End Function

Beachten Sie, dass der Name der Spalte als String an die Funktion übergeben wird und die Funktion eine Zeichenfolge zurückgibt, d. h. der Text, der in die entsprechende Spalte in der Berichtssummenzeile eingefügt wird.

Sie verwenden die Funktion GetGroupColumnSummary(), um die Werte auf Berichtsebene zu definieren. Zum Beispiel:

Public Overrides Function GetGroupColumnSummary(groupColumnName _
   As String) As String

   If groupColumnName = "Group" Then

      ' Put the text "Total" in the automatically-generated
      ' "Group" column.
      GetGroupColumnSummary = "<b>Total</b>"

   Else If groupColumnName = "Cost" Then

      ' Declare a variable to store the total cost.
      Dim sum As Decimal = 0

      ' Iterate through the costs variable to get the total cost.
      For Each key As String In costs.Keys
         sum += costs.Item(key).Sum()
      Next

      ' Format the total as currency.
      GetGroupColumnSummary = _
         String.Format(New _
            System.Globalization.CultureInfo("en-US"), _
            "{0:C}", sum)

   Else If groupColumnName = "Count" Then

      ' Declare a variable to store the overall count.
      Dim count As Integer = 0

      ' Iterate through the costs variable to get the total
      ' count.
      For Each key As String In costs.Keys
         count += costs.Item(key).count()
      Next

      GetGroupColumnSummary = String.Format(count)

   Else

      ' Leave the "Link" column blank.
      GetGroupColumnSummary = ""

   End If

End Function

AppDNA ruft diese Funktion einmal für jede Gruppenspalte auf, die wir in der ProcessGroups() -Funktion definiert haben, plus die automatisch generierte Spalte “Gruppe”. Wir verwenden daher ein If… Dann… Else-Anweisung zu testen, welche Spalte verarbeitet wird. Schauen wir uns an, was wir für jede Spalte tun:

  1. Dies ist die automatisch generierte Gruppenspalte. Für diese Spalte generieren wir einfach den Text "Total". Beachten Sie, dass wir den Text in <b></b> Tags eingeschlossen haben. Dies sind Standard-HTML-Tags, die angeben, dass der Text fett gerendert werden soll. Sie können jeden HTML-Code in jeder der Spalten verwenden.

  2. Dies ist die Spalte Kosten. Um die Summe für den Bericht zu erhalten, deklarieren wir eine Arbeitsvariable. Dann durchlaufen wir alle Elemente in der globalen Kostenwörterbuchvariablen und fügen ihre Gesamtwerte der Arbeitsvariablen hinzu, die wir dann zurückgeben.

    Der Rückgabewert ist eine Zeichenfolge. Wir haben die String.Format() -Methode verwendet, um den Kostenwert als Währung zu formatieren, und wir haben dieCultureInfo Klasse verwendet, um das US-Dollar-Währungssymbol anzugeben. DokumentationMSDN-Bibliothekzum Formatieren von Zeichenfolgen finden Sie in der.

  3. Für die Spalte “Anzahl” haben wir eine ähnliche Technik verwendet, um einen Gesamtwert für den Bericht zu generieren.

  4. Wir haben die Spalte Link leer gelassen.

Dies führt uns zum Ende des Codes in dem Szenario, das verwendet wurde, um den Bericht “Weiterleitungspfad” zu generieren, der am Anfang dieses Themas angezeigt wurde. Später in diesem Thema werden wir lernen, wie Berichtgruppen basierend auf der AppDNA Anwendungsgruppe zu erstellen, zu der die Anwendungen bereits gehören.

OnProcessingComplete()

Wenn es im Szenario angegeben ist, ruft AppDNA automatisch OnProcessingComplete() auf, nachdem der gesamte Rest der Verarbeitung abgeschlossen ist. Sie können diese Funktion verwenden, um eine endgültige Verarbeitung durchzuführen, bevor der Bericht angezeigt wird.

Die OnProcessingComplete() -Funktion muss die folgende Signatur aufweisen:

Public Overrides Sub OnProcessingComplete()
   ' Enter your code here.
End Sub

Gruppe nach AppDNA-Anwendungsgruppe

In diesem Abschnitt werden wir das Szenario ändern, um die Anwendungen zu gruppieren,Anwendungsgruppezu denen sie bereits gehören. Wenn eine Anwendung kein Mitglied einer Gruppe ist, wird sie in einer nicht gruppierten Kategorie angezeigt.

Innerhalb des Szenarios können Sie über die Application.Groups -Eigenschaft herausfinden, zu welcher Gruppe eine Anwendung gehört. Anwendungen können zu mehr als einer Gruppe gehören. Wie oben erwähnt, wird die Anwendung, wenn Sie alle Gruppen zum Bericht hinzufügen, unter jeder Gruppe angezeigt, zu der sie gehört. Je nachdem, wie Sie das Skript erstellen, besteht die Möglichkeit, dass die Kosten für die Anwendungsbehebungen mehr als einmal in den Bericht aufgenommen werden können.

Diese Funktionen enthalten detaillierte Kommentare, die erklären, wie sie funktionieren.

Public Function ForwardPath(ByVal currentApplication _
   As Application) As Output

   Dim result As New Output()

   If (currentApplication.Modules.Windows7.RAG = RAG.Green) Then
      result.Outcome = "Windows 7 OK"
      result.RAG = RAG.Green
   Else
      ' If the RAG for Windows 7 is not green,
      ' check if it's green for App-V
      If (currentApplication.Modules.AppV.RAG = RAG.Green) Then
         result.Outcome = "App-V OK"
         result.RAG = RAG.Green
      Else
         result.Outcome = "Not suitable for migration."
         result.RAG = RAG.Red
      End If
    End If

   ' We're temporarily using a hard-coded cost.
   result.Cost = 713

   ' Iterate through the groups to which the application
   ' belongs.
   For Each group As String In currentApplication.Groups

      ' Add the application to the corresponding report group.
      result.ReportGroups.Add(group)

      ' Check whether the group has already been added to our
      ' global dictionary variable.
      If costs.ContainsKey(group) Then

         ' Add the application's cost to the global variable.
         costs.Item(group).Add(713)
      Else

         ' Add the group to the global variable and then
         ' add the application's cost.
         costs.Add(group, New List(Of Integer))
         costs.Item(group).Add(713)

      End If
   Next

   ForwardPath = result

End Function

Public Overrides Sub ProcessGroup(group As ForwardPathReportGroup)

   If costs.ContainsKey(group.Name) Then
      group.Columns.Item("Count").Value = _
         costs.Item(group.Name).Count
      group.Columns.Item("Cost").Value = _
         costs.Item(group.Name).Sum()
      group.Columns.Item("Cost").Format = "{0,-10:C}"
      group.Columns.Item("Cost").Culture = "en-US"
      group.Columns.Item("Link").Value = _
      "<a href=""http://www.google.com"">More information</a>"
   End If

End Sub

Anzeige von Gruppen ausblenden

Manchmal möchten Sie einen gruppierten Bericht ohne die Gruppierung anzeigen. Dazu verwenden Sie die ForwardPathReportSettings.DisplayGroups -Eigenschaft. Diese Eigenschaft wird automatisch auf true festgelegt, wenn Sie Gruppenbehandlungscode in Ihr Szenario aufnehmen. Sie können es jedoch explizit in Ihrem Szenario auf false setzen, um die Anzeige der Gruppen im Bericht auszublenden.

Das Settings -Objekt (vom Typ ForwardPathReportSettings) ist im gesamten Szenario verfügbar. Normalerweise legen Sie die Eigenschaft in der Funktion Initialize() wie folgt fest:

Settings.DisplayGroups = false

Um die Gruppe erneut anzuzeigen, kommentieren Sie einfach diese Zeile aus.