> ## 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.

# Características especiales de ABBYY FlexiLayout Studio para crear FlexiLayouts adicionales

> Cree FlexiLayouts adicionales para facturas con ABBYY FlexiLayout Studio: consulte conjuntos de datos con funciones como RecordOfFCDataset y use archivos de parámetros XML.

ABBYY FlexiLayout Studio incluye varias características especiales para desarrollar FlexiLayouts adicionales para proyectos de facturas:

* Puede especificar la ubicación de los elementos en relación con las regiones de los campos detectados cuando se aplicó el FlexiLayout principal del proyecto de facturas.
* Los identificadores de proveedores y unidades de negocio pueden usarse en solicitudes al conjunto de datos de la Definición de Document.
* Las listas de palabras clave y otros parámetros de un FlexiLayout pueden exportarse a un archivo XML, lo que permite editarlas sin modificar el FlexiLayout ni la Definición de Document.

<div id="create-an-additional-flexilayout">
  ## Crear un FlexiLayout adicional
</div>

<Steps>
  <Step title="Abrir un lote en FlexiCapture">
    Abra un lote con facturas reconocidas en FlexiCapture.
  </Step>

  <Step title="Crear un proyecto de FlexiLayout Studio">
    Cree un proyecto nuevo en ABBYY FlexiLayout Studio. En el menú principal, seleccione **Herramientas → Exportar lote a FlexiLayout Studio → Crear nuevo proyecto de FlexiLayout Studio...**.
  </Step>
</Steps>

<Note>
  Este comando solo está disponible para proyectos de FlexiCapture almacenados en su equipo. Si está usando la versión Distributed de FlexiCapture y el proyecto está almacenado en el servidor, primero descárguelo a su equipo haciendo clic en **Exportar proyecto...** en el menú **Project**.
</Note>

<Note>
  El sufijo del proyecto de ABBYY FlexiLayout Studio indica la versión de la Definición de Document en el momento en que se creó el proyecto.
</Note>

El proyecto de ABBYY FlexiLayout Studio que acaba de crear contiene todos los documentos del lote de FlexiCapture, además de las regiones de campo detectadas durante el reconocimiento, en forma de un **Reference layout**.

| Tree               | Node                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------------ | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **SearchElements** | **CommonBlockRegions**   | Este nodo contiene elementos que corresponden a todos los campos de la Definición de Document. Las coordenadas de todas las regiones de bloques detectadas al aplicar los FlexiLayouts a cada documento en FlexiCapture se guardan en el proyecto de ABBYY FlexiLayout Studio. De forma predeterminada, las regiones con estas coordenadas se asignan a elementos que tienen el mismo nombre que los campos de la Definición de Document. Esto permite utilizarlas para especificar ubicaciones relativas de los elementos y crear elementos nuevos. |
| **SearchElements** | **CustomSearchElements** | Este nodo contiene elementos de ejemplo. Están deshabilitados de forma predeterminada para evitar interferencias cuando se aplica el FlexiLayout.<br /><br />**DataSetRequestSample** — Un ejemplo de solicitud al conjunto de datos de proveedores y unidades de negocio almacenado en la Definición de Document. Este conjunto de datos incluye identificadores de proveedores y unidades de negocio.                                                                                                                                              |

<div id="add-a-field-to-an-additional-flexilayout">
  ## Cómo agregar un campo a un FlexiLayout adicional
</div>

Para agregar un campo a un FlexiLayout adicional, cree un bloque para este campo y especifique su elemento de búsqueda.

Los campos de la Definición de Document deben tener nombres únicos. Esto significa que:

* Para definir la lógica de búsqueda de un campo, cree un bloque con un nombre único.
* Para cambiar la lógica de búsqueda de un campo que ya existe en la Definición de Document, cree un bloque con el mismo nombre.

<div id="add-pages-to-an-additional-flexilayout">
  ## Agregar páginas a un FlexiLayout adicional
</div>

Si desea probar en imágenes nuevas los cambios realizados en un FlexiLayout adicional, puede exportar sus lotes de FlexiCapture a un proyecto de facturas existente en ABBYY FlexiLayout Studio. Para exportar sus lotes, haga clic en **Herramientas → Exportar lote a FlexiLayout Studio → Agregar a un proyecto existente de FlexiLayout Studio...**.

* Solo puede exportar lotes de FlexiCapture a proyectos de ABBYY FlexiLayout Studio que se hayan creado seleccionando **Herramientas → Exportar lote a FlexiLayout Studio → Crear un nuevo proyecto de FlexiLayout Studio...**.
* Cuando exporta un lote de FlexiCapture a ABBYY FlexiLayout Studio, se crea un lote nuevo en ABBYY FlexiLayout Studio para ese lote.
* Si la nueva Definición de Document tiene más campos que la Definición de Document utilizada para el proyecto de ABBYY FlexiLayout Studio, el registro de exportación contiene una advertencia por cada campo adicional.
* Para que el programa exporte los campos adicionales, agregue para cada campo adicional un bloque con el mismo nombre en el nodo **CommonBlockRegions** del árbol **SearchElements**.

<div id="make-requests-to-data-sets-from-the-document-definition">
  ## Realizar solicitudes a conjuntos de datos desde la Definición de Document
</div>

Puede encontrar una solicitud de ejemplo en el elemento **DataSetRequestSample**. Este elemento está deshabilitado de forma predeterminada.

| Tipo                                                | Descripción                                                               |
| --------------------------------------------------- | ------------------------------------------------------------------------- |
| **NamedValue**                                      | Un valor con nombre.                                                      |
| *Constructor*                                       |                                                                           |
| `NamedValue( String, String )`                      |                                                                           |
| *Métodos*                                           |                                                                           |
| `String Name()`                                     | Devuelve el nombre de un valor con nombre.                                |
| `String Value()`                                    | Devuelve el valor de un valor con nombre.                                 |
| **NamedValueArray**                                 | Un array de valores con nombre.                                           |
| *Constructores*                                     |                                                                           |
| `NamedValueArray()`                                 |                                                                           |
| `NamedValueArray( NamedValue namedValue )`          |                                                                           |
| *Métodos*                                           |                                                                           |
| `Int Count()`                                       | Devuelve el número total de elementos del array.                          |
| `NamedValue GetAt( Int index )`                     | Devuelve el elemento con el número de índice especificado.                |
| `Void Add( NamedValue namedValue )`                 | Agrega un valor con nombre al array.                                      |
| `Void Add( NamedValueArray namedValueArray )`       | Agrega un array de valores con nombre a otro array de valores con nombre. |
| `Void InsertAt( Int index, NamedValue namedValue )` | Inserta el valor con nombre en la posición indicada por el índice.        |
| `Void DeleteAll()`                                  | Elimina todos los elementos de un array.                                  |
| `Void DeleteAt( Int index )`                        | Elimina el elemento en la posición indicada por el índice.                |
| `Int FindByName( String name )`                     | Devuelve la posición del valor con el nombre especificado.                |

<div id="functions">
  ### Funciones
</div>

Sintaxis:

* La ruta a la Definición de Document y el nombre del conjunto de datos se utilizan para acceder al conjunto de datos cuando se trabaja con un FlexiLayout en ABBYY FlexiLayout Studio.
* Después de agregar un FlexiLayout compilado a una Definición de Document en FlexiCapture, al acceder al conjunto de datos solo se utiliza su nombre.
* Formato de **connectionString**:

  ```
  "dbtype=FCDataset;fcTemplate=path_to_Document_Definition;datasetName=name_of_Data_Set;"
  ```

  **Nota:** Separe las partes de la ruta con barras invertidas dobles (`\\`).
* **searchFields** — array de nombres de columnas de las que se deben recuperar valores.
* **searchCriteria** — array de pares **columna-entrada**; devuelve todos los valores si está vacío.
  * Si una solicitud contiene varios valores para un campo, use el operador **OR**.
  * Si una solicitud contiene varios valores, cada uno correspondiente a un solo campo, use el operador **AND**.
  * Si una solicitud contiene varios valores para un campo y valores para varios campos, use el operador **OR** para distinguir los varios valores de un campo y el operador **AND** para combinar los valores de varios campos.

| Definición                                                                                                                                                                                                                            | Descripción                                                                                                                                                                                                                                                                                                                                        |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Logic TestAccessToFCDataSet( String connectionString )`                                                                                                                                                                              | Prueba la conexión con el conjunto de datos.                                                                                                                                                                                                                                                                                                       |
| `Logic TestFCDataSetSearchCriteria( String connectionString, StringArray searchFields, NamedValueArray searchCriteria )`                                                                                                              | Prueba las condiciones de búsqueda para el conjunto de datos.                                                                                                                                                                                                                                                                                      |
| `StringArray FieldNamesOfFCDataset( String connectionString )`                                                                                                                                                                        | Devuelve una lista de todos los campos del conjunto de datos, ordenados de forma ascendente por sus números de índice.                                                                                                                                                                                                                             |
| `StringArray FieldNamesOfFCDataset( String connectionString, StringArray searchFields )`                                                                                                                                              | Devuelve una lista de campos del conjunto de datos especificado, en orden ascendente de sus números de índice. Debe usarse junto con la función RecordOfFCDataset cuando haya columnas complejas.                                                                                                                                                  |
| `Int RecordCountOfFCDataset( String connectionString, StringArray searchFields, NamedValueArray searchCriteria )`                                                                                                                     | Devuelve el número de entradas del conjunto de datos especificadas en las condiciones de búsqueda. Se usa para averiguar cuántas entradas puede devolver la función RecordOfFCDataset.                                                                                                                                                             |
| `Void PrepareRecordsetOfFCDataset( String connectionString, StringArray searchFields, NamedValueArray searchCriteria, Int maxRecordsCount = DefaultMaxRecordsCount )`                                                                 | Prepara los datos para una consulta al conjunto de datos. Esto debe hacerse para cada nuevo conjunto de condiciones de búsqueda antes de llamar a la función RecordOfFCDataset.                                                                                                                                                                    |
| `StringArray RecordOfFCDataset( String connectionString, StringArray searchFields, NamedValueArray searchCriteria, Int rowIndex )`                                                                                                    | Devuelve un array de valores de la entrada con el número *rowIndex* de los resultados devueltos por una consulta al conjunto de datos. El número de valores es igual al número de campos pasados en searchFields (esto incluye el caso de columnas complejas).                                                                                     |
| `Quality ValidateByFCDataSet( String word, String connectionString, Int fieldIndex, NamedValueArray searchCriteria, Int maxErrors, Rational maxErrorsPart, Logic ignoreSpaces = true, Int maxRecordsCount = DefaultMaxRecordsCount )` | Devuelve la calidad de la cadena *word*. Acepta números de índice de campos. Puede obtener los números de índice indexando la salida de la función FieldNamesOfFCDataset.                                                                                                                                                                          |
| `Void SearchTextFromFCDataSet( String connectionString, Int fieldIndex, NamedValueArray searchCriteria, Int maxRecordsCount = DefaultMaxRecordsCount )`                                                                               | Se usa para especificar condiciones de búsqueda de palabras para la función texto estático. Cuando se llama a esta función, las condiciones de búsqueda existentes se reemplazan por otras nuevas. Acepta números de índice de campos. Puede obtener los números de índice indexando la salida de la función FieldNamesOfFCDataset.                |
| `Void RegularExpressionFromFCDataSet( String connectionString, Int fieldIndex, NamedValueArray searchCriteria, Int maxRecordsCount = DefaultMaxRecordsCount )`                                                                        | Se usa para especificar condiciones de búsqueda mediante expresiones regulares para la función CharString. Cuando se llama a esta función, las condiciones de búsqueda existentes se reemplazan por otras nuevas. Acepta números de índice de campos. Puede obtener los números de índice indexando la salida de la función FieldNamesOfFCDataset. |

<div id="search-for-rows-from-a-column-in-an-external-database-on-an-image">
  ### Buscar en una imagen filas de una columna de una base de datos externa
</div>

<Steps>
  <Step title="Listar las columnas">
    Use FieldNamesOfFCDataset para obtener una lista de columnas ordenadas de forma ascendente por sus números de índice.
  </Step>

  <Step title="Buscar el índice de la columna">
    Determine el número de índice de la columna en la que necesita buscar datos.
  </Step>

  <Step title="Crear el filtro">
    Cree un array de condiciones para filtrar datos del conjunto de datos.
  </Step>

  <Step title="Ejecutar la búsqueda">
    Pase los números de índice de la columna y las condiciones del filtro a SearchTextFromFCDataSet (o a RegularExpressionFromFCDataSet, si necesita usar expresiones regulares).
  </Step>
</Steps>

Este código se genera automáticamente cuando se exporta un lote reconocido desde FlexiCapture.

<div id="search-an-image-for-entries-from-multiple-columns">
  ### Buscar entradas de varias columnas en una imagen
</div>

Dado que los parámetros de búsqueda se sustituyen cada vez que se llama a la función **SearchTextFromFCDataSet**, llamarla repetidamente no produce ningún efecto. Como alternativa, obtenga cadenas de una base de datos externa y páselas a la función **SearchText**, que añade cada cadena a los parámetros de búsqueda existentes en lugar de sustituirlos.

<Steps>
  <Step title="Enumerar las columnas">
    Cree un array con los nombres de las columnas en las que necesita buscar datos.
  </Step>

  <Step title="Crear el filtro">
    Cree un array de condiciones de filtro para filtrar datos del conjunto de datos.
  </Step>

  <Step title="Contar las entradas">
    Determine el número de entradas que se devuelven mediante la función **RecordCountOfFCDataset**.
  </Step>

  <Step title="Preparar la consulta">
    Prepare los datos de la consulta mediante la función **PrepareRecordsetOfFCDataset**.
  </Step>

  <Step title="Leer cada registro">
    Recorra todos los registros y obtenga el array de cada registro mediante el método **RecordOfFCDataset**.
  </Step>

  <Step title="Pasar los valores a SearchText">
    Pase el valor de cada elemento del array a la función **SearchText**.
  </Step>
</Steps>

<div id="additional-considerations-for-complex-columns">
  ### Consideraciones adicionales sobre las columnas complejas
</div>

* La función **FieldNamesOfFCDataset** devuelve un array que contiene varias apariciones del nombre de la columna compleja. El número de apariciones es igual al número de instancias de columna en una base de datos externa codificada.

  *Ejemplo*: `{VendorId, VATID, Name, Name, Name, City}`. En este caso, la base de datos externa contiene tres columnas para la única columna compleja **Name** del conjunto de datos.
* Si **SearchCriteria** contiene una condición para un campo que corresponde a una columna compleja (como en el ejemplo anterior), esta condición se utiliza para comprobar todas esas instancias de columna.
* Si **searchFields** contiene una condición para un campo que corresponde a una columna compleja (como en el ejemplo anterior), el resultado contiene el array de valores de cada instancia de columna.

  Por ejemplo, si solicita lo siguiente para `{VendorId, VATID, Name, Name, Name, City}`:

  ```
  searchFields = { VATID, Name, City}, recibirá
  {VATID_value, Name_valueInColumn1, Name_valueInColumn2, Name_valueInColumn3, City_value}
  ```
* Puede obtener una lista de las columnas que se devuelven pasando el array **searchFields** a la función **FieldNamesOfFCDataset**.

<div id="make-a-request-to-an-xml-file-that-contains-flexilayout-settings">
  ## Haga una solicitud a un archivo XML que contenga la configuración de FlexiLayout
</div>

Puede realizar solicitudes a un archivo XML con la configuración de FlexiLayout mediante dos funciones estándar descritas en la documentación de ABBYY FlexiLayout Studio:

```
StringArray ReadFromXML(String filename, String xPathQuery)
String ReadSingleStringFromXML(String filename, String xPathQuery)
```

Para usar este archivo al trabajar con un FlexiLayout en ABBYY FlexiLayout Studio, colóquelo en la carpeta del proyecto o en una de sus subcarpetas. La ruta del archivo es relativa al archivo de proyecto de ABBYY FlexiLayout Studio.

Si carga un FlexiLayout compilado en una Definición de Document de FlexiCapture y lo usa como FlexiLayout adicional, el archivo XML se coloca en la carpeta **Templates** y puede editarlo. Cuando se aplica el FlexiLayout, el programa gestiona automáticamente el acceso a este archivo.
