> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Scripts de ejemplo

> Ejemplos de JavaScript para escenarios comunes de las reglas avanzadas de script: presencia de campos, comparaciones numéricas, requisitos condicionales y validación de tablas.

Los siguientes ejemplos de JavaScript ilustran patrones habituales de las reglas avanzadas de script: comprobar la presencia de campos, comparar valores numéricos, aplicar validaciones condicionales y validar datos de tablas. Cópielos y adáptelos a sus propios nombres de campo y reglas de negocio.

<div id="check-that-a-field-is-present">
  ## Verificar que un campo esté presente
</div>

Por ejemplo, comprobemos que el campo `MyField` se haya encontrado y esté rellenado:

```javascript theme={null}
var field = Context.GetField("MyField");

if (!field) {
  Context.CheckSucceeded = false;
  Context.ErrorMessage = 'Campo MyField no encontrado';
} else if (!field.Value) {
  Context.CheckSucceeded = false;
  Context.ErrorMessage = 'Campo MyField vacío';
}
```

<div id="compare-floating-point-numbers">
  ## Comparar números de punto flotante
</div>

Comparar directamente números de punto flotante puede producir resultados impredecibles. Use métodos del objeto integrado `Math` para comparar números —especialmente valores monetarios— de forma fiable.

```javascript theme={null}
// comparar dos números de punto flotante
var floatField1 = Context.GetField("Number Field 1");
var floatField2 = Context.GetField("Number Field 2");
var floatVal1 = floatField1.Value;
var floatVal2 = floatField2.Value;

if (Math.round(floatVal1) === Math.round(floatVal2)) {
    return;
} else {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = 'The values are different';
}

// comparar dos valores monetarios
var moneyField1 = Context.GetField("Money Field 1");
var moneyField2 = Context.GetField("Money Field 2");
var value1 = moneyField1.Value.Amount;
var value2 = moneyField2.Value.Amount;

if (Math.abs(value1 - value2) <= 0.0001) {
    return;
} else {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = 'The values are different';
}
```

<div id="require-a-non-empty-value-depending-on-another-field">
  ## Exigir un valor no vacío en función de otro campo
</div>

Un campo opcional puede volverse obligatorio en función del valor de otro campo. Por ejemplo, si `MaritalStatus` es `Married`, se deben completar los campos de nombre del cónyuge.

Esta regla de script verifica que, cuando `MaritalStatus` es `Married`, tanto `SpouseFirstName` como `SpouseLastName` estén completos:

```javascript theme={null}
function checkFieldValuePresence(field) {
    if (!field.Value) {
        Context.ErrorMessage = 'Value of ' + field.Name + ' field should not be empty';
        return false;
    }
    return true;
}

var conditionField = Context.GetField("MaritalStatus");

if (conditionField === null) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = 'MaritalStatus field not found';
} else if (checkFieldValuePresence(conditionField)) {
    var lastName = Context.GetField("SpouseLastName");
    var firstName = Context.GetField("SpouseFirstName");
    if (conditionField.Text === "Married") {
        if (lastName === null || firstName === null) {
            Context.CheckSucceeded = false;
            Context.ErrorMessage = 'Spouse name field not found';
        } else if (!checkFieldValuePresence(lastName) || !checkFieldValuePresence(firstName)) {
            Context.CheckSucceeded = false;
        }
    }
} else { // estado civil no completado, la verificación falló
    Context.CheckSucceeded = false;
}
```

<div id="check-that-a-field-is-located-on-the-document">
  ## Compruebe que un campo esté localizado en el documento
</div>

Las reglas también pueden completar los valores de los campos, incluso si el valor no está realmente impreso en el documento. Por ejemplo, si se aplican varios impuestos, el impuesto total puede calcularse automáticamente. Sin embargo, algunos países exigen que el impuesto total aparezca impreso en el documento.

Esta regla de script comprueba que, para los recibos de Alemania, el impuesto total esté presente en la imagen. Para otros países, no se requiere ninguna comprobación adicional porque la opción **Required field** está activada para el campo de impuesto total:

```javascript theme={null}
function checkFieldRegion(field) {
    if (!field || !field.HasRegion) {
        Context.ErrorMessage = 'El campo (' + field.Name + ') no está presente en la imagen del documento';
        return false;
    }
    return true;
}

var conditionField = Context.GetField("CountryOfOrigin");

if (!conditionField.Value) {
    Context.ErrorMessage = 'País de origen desconocido, no se pueden verificar los impuestos';
    Context.CheckSucceeded = false;
} else {
    var totalTaxField = Context.GetField("TotalTax");
    if (conditionField.Text === "DE" && !checkFieldRegion(totalTaxField)) {
        Context.CheckSucceeded = false;
    }
}
```

<div id="validate-the-data-in-particular-cases">
  ## Validar los datos en casos particulares
</div>

Comprobar que el impuesto Total sea igual a la suma de todos los impuestos puede hacerse con una regla predefinida (**Check Sum**). Pero si uno de los impuestos puede tener un valor negativo en ciertos países, solo una regla de script puede contemplar ambos casos: sumar todos los impuestos o sumar y restar un impuesto de devolución, según el país de origen.

Este script comprueba que la suma de dos impuestos sea igual al impuesto Total, excepto en los recibos de España, donde la suma o la diferencia de ambos puede ser igual al impuesto Total:

```javascript theme={null}
var conditionField = Context.GetField("CountryOfOrigin");
var totalTaxField = Context.GetField("TotalTax");
var tax1Field = Context.GetField("Tax1");
var tax2Field = Context.GetField("Tax2");

if (!conditionField.Value || !totalTaxField.Value || !tax1Field.Value || !tax2Field.Value) {
    Context.ErrorMessage = 'No se pueden verificar los impuestos';
    Context.CheckSucceeded = false;
} else {
    if (conditionField.Text === "ES") {
        Context.CheckSucceeded = ((Math.round(tax1Field.Value - tax2Field.Value) === Math.round(totalTaxField.Value))
            || (Math.round(tax1Field.Value + tax2Field.Value) === Math.round(totalTaxField.Value)));
    } else {
        Context.CheckSucceeded = (Math.round(tax1Field.Value + tax2Field.Value) === Math.round(totalTaxField.Value));
    }
}
```

<div id="compare-a-column-sum-to-an-external-field">
  ## Comparar la suma de una columna con un campo externo
</div>

Los scripts pueden hacer referencia a valores de tablas, no solo a campos normales. Para acelerar la verificación de reglas, guarde las tablas como variables y haga referencia a esas variables en lugar de volver a recuperar la tabla. Si una variable contiene una tabla completa, use la propiedad [`Instances`](/es/vantage/documentation/skill-designer/document/rule-verification/field#instances) para acceder a las filas y luego use [`GetChild`](/es/vantage/documentation/skill-designer/document/rule-verification/field#getchild) para obtener una celda específica de una fila.

El ejemplo a continuación suma todos los valores de la columna `Total Price` y compara el resultado con el campo `Total`:

```javascript theme={null}
var totalField = Context.GetField("Total");
var tableField = Context.GetField("MyTable");

if (!totalField) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "No se encontró el campo Total";
    return;
}

if (!tableField) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "No se encontró el campo MyTable";
    return;
}

var sum = 0;

for (var i = 0; i < tableField.Instances.length; i++) {
    var tableTotalField = tableField.Instances[i].GetChild("MyTable/Total Price");
    sum += tableTotalField.Value.Amount;
}

if (Math.abs(sum - totalField.Value.Amount) > 0.02) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "La suma de Precio Total en la tabla no coincide con el Total";
}
```

<div id="compare-column-cells-to-an-external-field-and-list-failing-rows">
  ## Comparar las celdas de una columna con un campo externo y enumerar las filas con errores
</div>

También se puede hacer referencia a las columnas de una tabla con [`Context.GetFields`](/es/vantage/documentation/skill-designer/document/rule-verification/context#getfields) para obtener cada celda de la columna, lo cual resulta útil para configurar bucles.

El siguiente ejemplo compara la tasa impositiva de cada fila con la tasa impositiva general. Cuando los valores no coinciden, el script continúa en lugar de fallar de inmediato, recopila los números de fila con discrepancias y los muestra en el mensaje de error:

```javascript theme={null}
var taxRateFields = Context.GetFields("MyTable/TaxRate");
var taxRateField = Context.GetField("TaxRate");

if (!taxRateFields || !taxRateField)
    return;

var taxRate = taxRateField.Value ? taxRateField.Value : 0;
var wrongLines = [];
for (var i = 0; i < taxRateFields.length; i++) {
    if (taxRateFields[i].Value != taxRate)
        wrongLines.push(i + 1);
}

if (wrongLines.length > 0) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "Tasa impositiva incorrecta en las líneas: " + wrongLines.join(", ");
}
```

<div id="compare-the-product-of-row-values-to-another-row-value">
  ## Comparar el producto de los valores de una fila con otro valor de la misma fila
</div>

Puede realizar operaciones en diferentes columnas de una tabla fila por fila sin usar bucles explícitos: haga referencia a cada columna mediante [`Context.GetField`](/es/vantage/documentation/skill-designer/document/rule-verification/context#getfield). Esto crea una regla repetitiva que se ejecuta automáticamente para cada fila. Todas las columnas referenciadas de este modo deben pertenecer a la misma tabla.

El siguiente ejemplo multiplica la cantidad de unidades por el precio unitario en cada fila y compara el resultado con el precio total de la línea:

```javascript theme={null}
var quantityField = Context.GetField("MyTable/Quantity");
var unitPriceField = Context.GetField("MyTable/Unit Price");
var totalField = Context.GetField("MyTable/Total Price");

if (!quantityField || !unitPriceField || !totalField)
    return;

var quantity = quantityField.Value ? quantityField.Value : 0;
var unitPrice = unitPriceField.Value?.Amount ? unitPriceField.Value.Amount : 0;
var total = totalField.Value?.Amount ? totalField.Value.Amount : 0;

var result = quantity * unitPrice;

if (Math.abs(result - total) > 0.01) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "Cantidad * Precio unitario no es igual al Total";
}
```

<div id="related-topics">
  ## Temas relacionados
</div>

* [Automatización de reglas de negocio](/es/vantage/documentation/skill-designer/document/rule-verification/business-rules-automation)
* [Modelo de objetos](/es/vantage/documentation/skill-designer/document/rule-verification/object-model)
* [Context](/es/vantage/documentation/skill-designer/document/rule-verification/context)
* [Field](/es/vantage/documentation/skill-designer/document/rule-verification/field)