AppDNA

Usar variables de la calculadora de esfuerzo en un caso de Forward Path

En este tema se proporciona una introducción al uso de las variables Calculadora de esfuerzo en el caso Forward Path. En este tema se utiliza un ejemplo para introducir el uso de estas funciones.

Acerca de las variables de la calculadora de esfuerzo

La calculadora de esfuerzo calcula el coste y el esfuerzo que implica corregir su cartera de aplicaciones para una plataforma de destino (representada por uno de los informes de AppDNA). El cálculo utiliza dos tipos principales de variables:

  • Variables definidas por el usuario: Estos valores almacenan como el coste diario de un probador, remediador y jefe de proyecto, el número de horas de un día laborable típico, el tiempo promedio que tarda en remediar aplicaciones de diferentes complejidades (simples, normales y complejas), teniendo en cuenta la dificultad de la acción de remediación (fácil, medio o duro). Puede establecer estas variables por separado para cada informe AppDNA en elPantalla Calculadora de esfuerzo.
  • Variables de nivel de aplicación: Se derivan del análisis AppDNA e incluyen la complejidad de la aplicación (esto se basa en el número de archivos y entradas de registro que tiene la aplicación), y la dificultad (o complejidad) de las acciones que se deben tomar para remediar el para el informe seleccionado.

Utilizando esta información, la Calculadora de esfuerzo calcula el coste esperado de migrar toda la cartera de aplicaciones a la nueva plataforma. Ahora puede utilizar estas variables en el caso Forward Path, por ejemplo, para estimar el coste de remediar cada aplicación. Este tema proporciona un ejemplo relativamente simple de cómo hacerlo. Uno de los casos de ejemplo que viene con AppDNA proporciona un ejemplo más complejo y sofisticado.

Para obtener información detallada sobre las variables de la Calculadora de esfuerzo y cómo se utilizan, consulte Calculadora de esfuerzo.

Recuperación de las variables de Calculadora de esfuerzo definidas por el usuario

Puede acceder a las variables de Calculadora de esfuerzo definidas por el usuario a través del objeto EffortCalculatorSettings, que se recupera a través del objeto Host. El objeto Host está implícitamente disponible para toda la script de caso. Aquí hay un fragmento que recupera el objeto EffortCalculatorSettings para el informe de Windows 7:

``` pre codeblock Private Dim vars As EffortCalculatorSettings

’ Get the Windows 7 Effort Calculator settings object. vars = Host.GetEffortCalculatorSettings(“Win7Module”)


Observe que hemos utilizado el identificador de informe interno de Windows 7 para recuperar las variables de la Calculadora de esfuerzo para Windows 7. Para obtener una lista de los identificadores de informe, consulte [Crear vínculos a vistas de informes de corrección](/es-es/dna/current-release/configure/forward-path/dna-forward-path-remediation-links.html).

Puede ver todas las propiedades del objeto EffortCalculatorSettings en el Explorador de propiedades en el lado derecho de[Pantalla Editor de lógica de Forward Path](/es-es/dna/current-release/configure/forward-path/dna-forward-path-logic-editor.html). Los nombres de las propiedades se relacionan estrechamente con el texto mostrado para las variables en la pantalla Calculadora de esfuerzo. Por ejemplo, la propiedad AppStagingHours corresponde a la variable Tiempo de ensayo en la sección Variables de dotación de personal de la pantalla Calculadora de esfuerzo. Vamos a utilizar esta variable en el ejemplo que sigue.

Es posible establecer los valores de estas variables en su caso para usarlos en ese caso, así:

``` pre codeblock
vars.TesterStagerCostPerDay = 23

Nota: Esto no cambia ni sobrescribe las variables que utiliza la Calculadora de esfuerzo.

Acerca del ejemplo

Para ilustrar cómo utilizar los dos tipos de variables de la calculadora de esfuerzo para calcular los costes estimados de las aplicaciones de corrección en su caso de Forward Path, recorremos un caso de ejemplo. Lo construiremos por etapas, en un intento de que sea fácil de entender.

Aquí hay una captura de pantalla de la salida que crea el ejemplo:

Ejemplo de salida

Nota: Los ejemplos de este tema utilizan la notación de subrayado (_) para dividir líneas largas en dos o más líneas. Esto es para que los fragmentos de código de ejemplo se procesen correctamente cuando se incluyen en un PDF. Vea la Biblioteca MSDN para más información sobre esta notación.

Inicializar las variables

AppDNA incluye una función de caso Forward Path llamada Initialize(). Si está presente en el caso, AppDNA llama automáticamente a esto al inicio del procesamiento. Usaremos esto para inicializar variables que usaremos más adelante en el caso. Para obtener más información acerca de la función Initialize(), consulte Informes de Forward Path agrupados.

Antes de la función Initialize(), declaramos algunas variables que usaremos a lo largo del script.

``` pre codeblock ‘ Declare variables for use throughout the script. Private Dim vars As EffortCalculatorSettings Private Dim testingPerHour As Decimal = 0 Private Dim remediationPerHour As Decimal = 0


Aquí está la función Initialize():

``` pre codeblock
Public Overrides Sub Initialize()

   ' Get the Windows 7 Effort Calculator settings object.
   vars = Host.GetEffortCalculatorSettings("Win7Module")

   ' Calculate the testing and remediation cost per hour.
   testingPerHour = vars.TesterStagerCostPerDay / _
      vars.NormalAppTestingHours
   remediationPerHour = vars.RemediatorCostPerDay / _
      vars.NormalAppTestingHours

   ' Sort the report in descending order of cost.
   Settings.ApplicationSortBy = "Cost"
   Settings.ApplicationSortDescending = true
End Sub

Tenga en cuenta que estamos calculando los costes de prueba y corrección por hora. Para ello, dividimos los valores almacenados en las variables que representan el coste del probador o remediador por día por el valor almacenado en el número normal de horas de trabajo en una variable de día.

Al final de la función Initialize(), establecemos el orden de clasificación para estar en orden descendente de los valores en la columna Coste. En esta columna mostraremos el coste calculado de remediar la aplicación y la puesta en escena para UAT.

La función principal

Aquí está la función principal ForwardPath(). AppDNA llama automáticamente a esto una vez para cada aplicación seleccionada al ejecutar el informe. Las notas explicativas siguen el ejemplo.

``` pre codeblock Public Function ForwardPath(ByVal currentApplication _ As Application) As Output

Dim result As New Output()

’ We will use three custom columns. result.CustomField1.Name = “Application Complexity” result.CustomField2.Name = “Action RAG” result.CustomField2.Value = _ currentApplication.Modules.Windows7.ActionRAG result.CustomField3.Name = “Action Complexity”

’ Set the culture on the Cost column to US English, ‘ so that the US dollar currency symbol is used. result.Display.Cost.Culture = “en-US”

’ Test the application’s main RAG status, because ‘ the remediation depends on this. Select Case currentApplication.Modules.Windows7.RAG

  Case Rag.Green

     ' The RAG is green, so no remediation is necessary
     ' and the application can be staged for UAT.
     result.Outcome = "Stage UAT"
     result.RAG = RAG.Green

     ' No remediation is required, so the cost is of
     ' the staging only.
     result.Cost = testingPerHour * vars.AppStagingHours
     result.CustomField3.Value = "--"

     ' Convert the unfriendly application complexity
     ' "RAG" to a text.
     Select Case currentApplication.Complexity
        Case RAG.Red
           result.CustomField1.Value = "Complex"
        Case RAG.Amber
           result.CustomField1.Value = "Medium"
        Case RAG.Green
           result.CustomField1.Value = "Simple"
     End Select

  Case Rag.Amber

     ' The RAG is amber, so the application needs
     ' remediation.
     result.RAG = RAG.Amber
     result.Outcome = "Remediate"

     ' The cost calculation is more complicated,
     ' so we will do it in a separate "GetCost()"
     ' function.
     result.Cost = GetCost(currentApplication, result)

  Case Rag.Red

     ' The RAG is red - we need to check the action
     ' RAG to see if remdiation is possible.
     result.RAG = RAG.Red

     ' If the action RAG is red, the application
     ' cannot be remediated.
     If (currentApplication.Modules.Windows7.ActionRAG = _
        RAG.Red) Then

        result.Outcome = "Redevelop"
        result.CustomField3.Value = "Hard"

        ' Convert the unfriendly application complexity
        ' "RAG" to a text and set an arbitrary
        ' replacement/redevelopment cost.
        Select Case currentApplication.Complexity
           Case RAG.Red
              result.CustomField1.Value = "Complex"
              result.Cost = 3000
           Case RAG.Amber
              result.CustomField1.Value = "Medium"
              result.Cost = 2000
           Case RAG.Green
              result.CustomField1.Value = "Simple"
              result.Cost = 1000
        End Select

     ' The action RAG is not red, so remediation is
     ' possible.
     Else
        result.Outcome = "Remediate"
        result.Cost = GetCost(currentApplication, result)
     End If

  Case Else

     ' Catch all for applications that have not been
     ' analyzed or that are locked.
     result.Outcome = "Unknown"
     result.RAG = RAG.Unknown
     result.CustomField1.Value = "--"
     result.CustomField3.Value = "--"
     result.Cost = 0

End Select

result.Display.SourcePath.Visible = false

ForwardPath = result

End Function


Observe que esta función comienza configurando tres columnas personalizadas (llamadas CustomFieldn): estas son las tres columnas situadas más a la derecha en la captura de pantalla de la salida anterior. Los usamos de la siguiente manera:

| Columna  | Pantallas |
| ---| --- |
| CustomField1 | La complejidad de la aplicación. Forward Path almacena esto como un "RAG" rojo/ámbar/verde. Traducimos estos valores en textos complejos/medios/simples en el script. |
| CustomField2 | Acción de la aplicación RAG. Obtenemos el valor mediante la propiedad Application.Modules.Windows7.ActionRag.|
| CustomField3 | La complejidad/dificultad de la acción de remediación de la aplicación. Recuperaremos el valor de esta columna más adelante en el script.  |

La columna Coste se muestra automáticamente en formato de moneda. De forma predeterminada, Forward Path utiliza el símbolo de moneda para la configuración regional en el equipo del usuario. En un entorno internacional, esto significa que el símbolo de moneda puede variar dependiendo de la configuración del dispositivo de la persona que ve el informe. (Por ejemplo, puede mostrar el signo del euro para un usuario en Francia, el signo de la libra esterlina para un usuario en Inglaterra y el signo del dólar estadounidense para un usuario en los Estados Unidos). En este ejemplo, especificaremos el símbolo del dólar estadounidense para que siempre se muestre independientemente de la configuración regional del usuario. Para ello, establecemos la propiedad Cultura en la columna Coste en "en-US", que indica los Estados Unidos.

El cuerpo principal de la función consiste en una instrucción Select Case que prueba el estado de Windows 7 RAG de la aplicación y proporciona un procesamiento diferente dependiendo de ese estado. Veamos cómo manejamos cada valor:

-  **Green RAG**: La aplicación puede ir directamente a UAC. Por lo tanto, calculamos el coste de la puesta en escena de la aplicación multiplicando el coste de las pruebas por hora (que calculamos en Initialize ()) por la variable Calculadora de esfuerzo que almacena el número de horas que tarda en poner en escena una aplicación para la prueba. Definimos la complejidad de la acción en "—" porque la corrección no es necesaria, y utilizamos otra instrucción Select Case para probar la complejidad de la aplicación y convertir el valor "RAG" no amigable en un texto.
-  **Amber RAG**: La aplicación necesita remediación. Llamamos a la función GetCost() para calcular el coste de corrección. Lo veremos en breve.
-  **Red RAG**: Primero probamos el RAG de acción. Si es rojo, significa que la aplicación no puede ser remediada y necesita ser desarrollada de nuevo o reemplazada. A continuación, utilizamos una instrucción Select Case para probar la complejidad de la aplicación como hicimos para el RAG verde. Sin embargo, esta vez establecemos un coste de reemplazo arbitrario basado en la complejidad de la aplicación. Para las aplicaciones que se pueden remediar (es decir, su acción RAG es verde o ámbar), llamamos a la función GetCost() para calcular el coste de remediación.
-  **Otros valores de RAG**: Manejamos todos los demás valores de RAG mediante el uso de una declaración Case Else. Esto manejará las aplicaciones que no se han analizado y las que están bloqueadas (sin licencia).

## Calcular el coste de corrección

Aquí está la función GetCost(), a la que llamamos en la función principal para calcular los costes de corrección de las aplicaciones ámbar y las rojas que se pueden remediar. Las notas explicativas siguen el ejemplo.

``` pre codeblock
Private Function GetCost(app As Application, _
   cols As Output) As Decimal

   Dim remediationCost As Decimal = 0
   Dim testingCost As Decimal = 0

   ' 1. Using the triggered algorithms, get the
   ' algorithm with the hardest action. We will use this
   ' in our calculations.
   Dim maxAlgorithm As TriggeredRule = _
      (From r in app.TriggeredRules _
      Where r.ModuleIdentifier = "Win7Module" _
      Where r.Action.Complexity = ActionComplexity.Hard Or _
      r.Action.Complexity = ActionComplexity.Medium Or _
      r.Action.Complexity = ActionComplexity.Easy _
      Order By r.Action.Complexity Descending _
      Select r).FirstOrDefault()

   ' 2. Display the algorithm's action complexity.
   cols.CustomField3.Value = maxAlgorithm.Action.Complexity

   ' 3. The remediation cost depends on the application
   ' complexity.
   Select Case app.Complexity

      ' A complex application.
      Case RAG.Red

         cols.CustomField1.Value = "Complex"

         ' The remediation cost also depends on
         ' the complexity of the action. So we will
         ' calculate the time based on the number of
         ' hours held in the Effort Calculator matrix.
         Select Case maxAlgorithm.Action.Complexity
            Case ActionComplexity.Easy
               remediationCost = remediationPerHour * _
                  vars.ComplexAppEasyRemediationHours
            Case ActionComplexity.Medium
               remediationCost = remediationPerHour * _
                  vars.ComplexAppMediumRemediationHours
            Case ActionComplexity.Hard
               remediationCost = remediationPerHour * _
                  vars.ComplexAppHardRemediationHours
            Case Else
               remediationCost = remediationPerHour * _
                  vars.ComplexAppMediumRemediationHours
         End Select

         If app.Modules.Windows7.ActionRAG = RAG.Amber Then

            ' Add the additional post-remediation testing
            ' because the application has an amber action RAG.
            testingCost = testingPerHour * _
               vars.ComplexAppTestingHours

         End If

      ' A medium-complexity application.
      Case RAG.Amber

         cols.CustomField1.Value = "Medium"

         Select Case maxAlgorithm.Action.Complexity
            Case ActionComplexity.Easy
               remediationCost = remediationPerHour * _
                  vars.NormalAppEasyRemediationHours
            Case ActionComplexity.Medium
               remediationCost = remediationPerHour * _
                  vars.NormalAppMediumRemediationHours
            Case ActionComplexity.Hard
               remediationCost = remediationPerHour * _
                  vars.NormalAppHardRemediationHours
            Case Else
               remediationCost = remediationPerHour * _
                  vars.NormalAppMediumRemediationHours
         End Select

         If app.Modules.Windows7.ActionRAG = RAG.Amber Then

            ' Add the additional post-remediation testing
            ' because the application has an amber action RAG.
            testingCost = testingPerHour * _
               vars.NormalAppTestingHours

         End If

      ' A simple application.
      Case RAG.Green

         cols.CustomField1.Value = "Simple"

         Select Case maxAlgorithm.Action.Complexity
            Case ActionComplexity.Easy
               remediationCost = remediationPerHour * _
                  vars.SimpleAppEasyRemediationHours
            Case ActionComplexity.Medium
               remediationCost = remediationPerHour * _
                  vars.SimpleAppMediumRemediationHours
            Case ActionComplexity.Hard
               remediationCost = remediationPerHour * _
                  vars.SimpleAppHardRemediationHours
            Case Else
               remediationCost = remediationPerHour * _
                  vars.SimpleAppMediumRemediationHours
         End Select

         If app.Modules.Windows7.ActionRAG = RAG.Amber Then

            ' Add the additional post-remediation testing
            ' because the application has an amber action RAG.
            testingCost = testingPerHour * _
               vars.SimpleAppTestingHours

         End If

   End Select

   ' 4. Add the remediation and testing costs,
   ' and the cost of staging for UAT.
   GetCost = remediationCost + testingCost + _
      (testingPerHour * vars.AppStagingHours)

End Function

Las siguientes notas se refieren a los números de los comentarios en el ejemplo anterior:

1. Utilizamos la propiedad de Windows 7 TriggeredRules de la aplicación actual. Esta propiedad es una colección de objetos TriggeredRule, que representan todos los algoritmos que la aplicación desencadenó durante el análisis para Windows 7. De esta colección, obtenemos el algoritmo que tiene la acción de remediación más difícil. Usaremos esto para calcular el coste de remediar la aplicación.

2. Mostramos la complejidad (dificultad) de la acción de corrección del algoritmo en CustomField3.

3. A continuación, usamos una instrucción Select Case de nuevo para probar la complejidad de la aplicación. Proporcionaremos un procesamiento diferente para cada complejidad. Veamos cómo manejamos una aplicación compleja:

  • Primero usamos otra instrucción Select Case para probar la complejidad (dificultad) de la acción asociada al algoritmo que recuperamos en el paso 1. A continuación, para cada una de las complejidades de acción posibles, calculamos el coste de remediación multiplicando el coste de remediación por hora (calculado en Initialize()) por la variable Calculadora de esfuerzo que representa el tiempo que tarda en remediar una aplicación compleja de la complejidad de acción correspondiente.
  • A continuación, comprobamos si la acción RAG es ámbar, porque esto significa que la aplicación necesita pruebas adicionales después de que se haya implementado la corrección. Si la acción RAG es ámbar, calculamos el coste de prueba multiplicando el coste de prueba por hora (calculado en Initialize()) por la variable Calculadora de esfuerzo que representa el tiempo que tarda en probar una aplicación compleja.

El código para aplicaciones de complejidad media y simples refleja el código para la aplicación compleja, pero cada vez seleccionamos las variables de Calculadora de esfuerzo para aplicaciones medianas y simples, respectivamente.

4. Finalmente, agregamos los costes de corrección y prueba calculados al coste de la puesta en escena de la aplicación para UAT y establecemos esto en el valor de retorno.

Para ver un ejemplo que calcula los costes de corrección teniendo en cuenta las acciones asociadas con todos los algoritmos desencadenados por la aplicación, vea el caso de ejemplo que viene con AppDNA.

Usar variables de la calculadora de esfuerzo en un caso de Forward Path