Saltar al contenido principal

Uso de la búsqueda avanzada desde la API

Víctor Sánchez
  • Actualización

La búsqueda avanzada de Athento permite realizar filtros de búsqueda de manera dinámica. Estas búsquedas aplican directamente sobre el Athento Search Engine configurado en la instancia y ofrecerá los resultados acorde a los filtros aplicados.

Untitled_Diagram_drawio_pdf.png

A continuación se describe de manera general el uso de los paquetes más importantes.

 

Aquí encontramos cada uno de los distintos motores de búsqueda añadidos a Athento, todos tienen un estructura idéntica y están compuestos por dos clases inseparables:

  • Search Engine: Define la funcionalidad del motor de búsqueda.
  • Filters: define los distintos filtros que pueden ser invocados desde el motor.

Búsqueda

Athento permite realizar búsquedas complejas sobre los ficheros que se encuentran en la plataforma. Para realizar dichas búsquedas, es necesario definir una estructura de grupos y reglas, las cuales definirán el filtro que se aplicará sobre un conjunto de ficheros.

Las búsquedas pueden realizarse sobre los documentos eliminados o no eliminados usando, para la búsqueda sobre los eliminados, la cláusula ecm:isTrashed con valor true ó 1. En la instanciación del motor de búsqueda será necesario indicar el atributo (opcional con valor por defecto a False) removed encargado de discriminar internamente.

 

Ejecución

from search.searchengine.elasticsearch.advanced_search import ElasticsearchSearchEngine

user = User.objects.get(username="<username>")
engine = ElasticsearchSearchEngine(removed=False)
filters = { ... }
engine.advanced_search(user, filters)

 

Filtros

La estructura de los filtros es la misma que se aplica en la búsqueda usando el ORM de Django. Esta estructura es transformada al lenguaje que es usado por Elasticsearch.

La estructura de un filtro se compone de grupos de reglas unificado por una conjunción y reglas.

{
   "AND": [ # Grupo inicial A (Conjunto de reglas unidas por la conjuncion "AND")
      { # Regla A1 en grupo A
         "type": "serie", 
            "schema": {
                "value": ["123-123-213", "321-321-321"]
            }
      },
      { # Regla A2 en grupo A
         "type": "doctype", 
            "schema": {
                "value": ["123-123-123", "321-321-321"]
            } 
      },
      { # Regla A3 en grupo A (otro grupo, B)
         "AND": [ # Grupo B (Conjunto de reglas unidas por la conjunción "AND")
            { # Regla B1
               "type": "metadata", 
                    "schema": {
                        "uuid": "123-123-123", 
                        "value": ["myValueA", "myValueB"], 
                        "lookup_type": "contains", 
                        "negate": False
                    }
            },
            { # Regla B2
               "type": "metadata", 
                    "schema": {
                        "uuid": "321-321-321", 
                        "value": ["myValue2A", "myValue2B"], 
                        "lookup_type": "contains", 
                        "negate": False
                    }
            },
            { # Regla B3 en grupo B
               "OR": [ # Grupo C (Conjunto de reglas unidas por la conjunción "OR")
                  { # Regla C1
                     "type": "metadata", 
                            "schema": {
                                "uuid": "111-111-111", 
                                "value": ["myValue111A", "myValue111B"], 
                                "lookup_type": "contains", 
                                "negate": False
                            }
                  }, 
                  { # Regla C2
                     "type": "metadata", 
                            "schema": {
                                "uuid": "222-222-222", 
                                "value": ["myValue222A", "myValue222B"], 
                                "lookup_type": "contains", 
                                "negate": False
                            }
                  }
               ]
            }
         ]
      }
   ]
}

 

Grupos


Los grupos son un conjunto de reglas unidas por una conjunción. Las conjunciones pueden ser AND ó OR.

En el ejemplo de filtro anterior, podemos encontrar tres grupos (A, B y C).

Grupo A:

Es el grupo inicial que contiene todas las reglas. Siempre que existan más de una regla, se aplicará un grupo.

Grupo B:

El grupo B es un conjunto de reglas AND, el cual también contiene una regla que es el Grupo C.

{
"AND": [ # Grupo B (Conjunto de reglas unidas por la conjunción "AND")
    { # Regla B1
        "type": "metadata", 
        "schema": {
            "uuid": "123-123-123", 
            "value": ["myValueA", "myValueB"], 
            "lookup_type": "contains", 
            "negate": False
        }
    },
    { # Regla B2
        "type": "metadata", 
        "schema": {
            "uuid": "321-321-321", 
            "value": ["myValue2A", "myValue2B"], 
            "lookup_type": "contains", 
            "negate": False
        }
    },
    { # Regla B3 en grupo B
        "OR": [ # Grupo C (Conjunto de reglas unidas por la conjunción "OR")
            { # Regla C1
                "type": "metadata", 
                "schema": {
                    "uuid": "111-111-111", 
                    "value": ["myValue111A", "myValue111B"], 
                    "lookup_type": "contains", 
                    "negate": False
                }
            }, 
            { # Regla C2
                "type": "metadata", 
                "schema": {
                    "uuid": "222-222-222", 
                    "value": ["myValue222A", "myValue222B"],
                    "lookup_type": "contains",
                    "negate": False
                }
            }
        ]
    }
]
}



Grupo C:

El grupo C es un conjunto de reglas OR:

{
    "OR": [ # Grupo C (Conjunto de reglas unidas por la conjunción "OR")
        { # Regla C1
            "type": "metadato", 
            "schema": {
                "uuid": "111-111-111", 
                "value": ["myValue111A", "myValue111B"], 
                "lookup_type": "contains", 
                "negate": False
            }
        }, 
        { # Regla C2
            "type": "metadato", 
            "schema": {
                "uuid": "222-222-222",
                "value": ["myValue222A", "myValue222B"],
                "lookup_type": "contains",
                "negate": False
            }
        }
    ]
}


Reglas

Una regla es un diccionario clave/valor, el cual se usará para definir el filtro. Existen muchos tipos de reglas con diferentes configuraciones:

Filtros ORM


Filtar por serie

El filtro por series permite filtrar por una serie o múltiples.

{
    "type": "serie", 
    "schema": {
        "value": ["123-123-213", "321-321-321"]
    }
}

Donde:

Clave Valor
type serie
schema[value] Lista de UUIDs, tanto para un UUID o múltiples. En el caso de múltiple, se aplicará un OR


Ejemplos:

{
    "type": "serie", 
    "schema": {
        "value": ["87c217f9-03b4-499b-979f-e56f0b228b7c"]
    }
}

{
    "type": "serie", 
    "schema": {
        "value": ["87c217f9-03b4-499b-979f-e56f0b228b7c", "656ccfc3-cd14-422b-9a61-ac051e740824"]
    }
}

 


Filtar por tipo documental

El filtro por tipo documental permite filtrar por un tipo documental o múltiples.

{
    "type": "doctype", 
    "schema": {
        "value": ["123-123-123", "321-321-321"]
    }
}

Donde:

Clave Valor
type doctype
schema[value] Lista de UUIDs, tanto para un UUID o múltiples. En el caso de múltiple, se aplicará un OR


Ejemplos:

{"type": "doctype", "schema": {"value": ["8a066e45-da4f-45fc-9bf0-9686f616ea5f"]}}

{
    "type": "doctype", 
        "schema": {
        "value": ["8a066e45-da4f-45fc-9bf0-9686f616ea5f", "9686f616ea5f-da4f-45fc-9bf0-9686f616ea5f-8a066e45"]
    }
}



Filtar por UUID

El filtro por UUID, permite filtrar directamente por el UUID de un documento o múltiples.

{
    "type": "uuid", 
    "schema": {
        "value": ["f9f343d2-d419-4819-906f-03d7acdc3695"]
    }
}

Donde:

Clave Valor
type uuid
schema[value] Lista de UUIDs, tanto para un UUID o múltiples. En el caso de múltiple, se aplicará un OR


Ejemplos:

{
    "type": "uuid", 
    "schema": {
        "value": ["f9f343d2-d419-4819-906f-03d7acdc3695"]
    }
}

{
    "type": "uuid", 
    "schema": {
        "value": ["f9f343d2-d419-4819-906f-03d7acdc3695", "9467552f-affb-473c-99d9-348ee0a6cecb"]
    }
}


Filtar por autor

El filtro por Autor, permite filtrar directamente por el `uuid` de un usuario o múltiples.

{
    "type": "author", 
    "schema": {
        "value": ["user1-uuid", "user2-uuid"]
    }
}


Donde:

Clave Valor
type author
schema[value] Lista de UUIDs, tanto para un UUID o múltiples. En el caso de múltiple, se aplicará un OR


Ejemplos:

{
    "type": "author", 
    "schema": {
        "value": ["123-321-123"]
    }
}

{
    "type": "author", 
    "schema": {
        "value": ["123-321-123, 345-543-345"]
    }
}



Filtar por estado del documento

El filtro por estado de un documento, permite filtrar directamente por uno o múltiples.

{
    "type": "state", 
    "schema": {
        "value": ["pending"]
    }
}

 

Filtros adicionales existentes:

  • Nombre del fichero
  • Ciclo de vida del documento (type: lifecycle_state)
  • Fecha de creación (type: creation_date)
  • Fecha de modificación (type: modification_date)
  • Texto global
  • Número de páginas
  • Metadatos

 

Uso de fechas en los filtros

El filtro por fecha de creación, permite filtras usando un operador, una expresión o un valor (fecha).

Uso de operador

{
    "type": "creation_date", 
    "schema": {
        "value": "22-4-2020", "condition": "<"
    }
}


Donde:

Clave Valor
type creation_date
schema[value] Fecha por la que filtrar
schema[condition] Operador que se aplicará para realizar el filtro (`'<', '<=', '==', 'LIKE', '>=', '>'`)

 

Uso de palabra clave en condición


Ejemplo:

{
    "type": "creation_date", 
    "schema": {
        "condition": "last_day", 
        "value": 2
    }
}


Donde:

Clave Valor
type creation_date
schema[value] Valor restante como delta que se aplicará en los casos de `last_*` (`'last_month', 'last_year', 'last_day'`)
schema[condition] Expresión por la cual filtrar ( `'current_month', 'current_year', 'current_day', 'last_month', 'last_year', 'last_day'` )



Rango

{
    "type": "creation_date", 
    "schema":{
        "condition": "range", 
        "start_date": "21-04-2020", 
        "end_date": "23-04-2020"
    }
}

Donde:

Clave Valor
type creation_date
schema[start_date] Fecha de inicio en el rango
schema[end_date] Fecha de fin en el rango
schema[condition] range



Filtrar por número de páginas

El filtro por número de páginas, permite filtrar directamente por el número o por un rango.

{
    "type": "num_pages", 
    "schema": {
        "condition": ">", 
        "value": 10
    }
}



Filtrar por nombre del fichero

El filtro por el nombre de fichero, permite filtrar por contenido del nombre, exacto, insensitivo, etc.

{
    "type": "filename", 
    "schema": {
        "value": "Mi fichero", 
        "lookup_type": "contains"
    }
}


Donde:

Clave Valor
type filename
schema[value] Valor por el cual buscar
schema[lookup_type] Forma con la cual se buscará en la cadena (`'exact', 'iexact', 'contains', 'icontains', 'startswith', 'istartswith', 'endswith', 'iendswith'`)



Filtrar globalmente

El filtro global, permite realizar una búsqueda global, que es una búsqueda en filename o valor de metadato (texto).

{
    "type": "text", 
    "schema": {
        "value": "Campo1"
    }
}



Filtrar por metadatos

El filtrado por metadato, nos permite filtrar por el valor que contiene un metadato. Los metadatos pueden ser de diferente tipo. Por lo tanto existen múltiples formas de filtrado.

El metadato tiene o no valor

Nos permite filtrar por metadatos con valor o sin valor.

{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "value": ""
    }
}


Donde:

Clave Valor
type metadata
schema[value] "" (string vacio) para filtar por metadatos sin valor
schema[uuid] UUID del tipo de metadato que define el metadato



Metadato de tipo texto

Filtrar por el valor de un metadato de tipo texto.

{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "value": ["myValueA", "myValueB"], 
        "lookup_type": "contains"
    }
}


Donde:

Clave Valor
type metadata
schema[value] "" (string vacio) para filtar por metadatos sin valor
schema[uuid] UUID del tipo de metadato que define el metadato
schema[lookup_type] Forma con la cual se buscará en la cadena (`'exact', 'iexact', 'contains', 'icontains', 'startswith', 'istartswith', 'endswith', 'iendswith'`)


Ejemplo:

{
    "type": "metadata", 
    "schema": {
        "uuid": "df8a0cf4-3a47-4649-a2d4-aaaded3af6e8", 
        "value": ["Campo11"], 
        "lookup_type": "exact"
    }
}



Metadato de tipo fecha

El filtro por metadato de tipo fecha, permite filtrar usando un operador, una expresion o un valor (fecha).

Ejemplos:

{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "condition": ">=", 
        "value": "23-04-2020"
    }
}
{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "condition": "last_day", 
        "value": 1
    }
}
{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "condition": "range", 
        "start_date": "23-04-2020", 
        "end_date": "25-04-2020"
    }
}



Metadato de tipo fichero

Permite filtrar metadatos de tipo fichero, por el valor de un UUID de ficheros.

{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "value": ["111-222-333"]
    }
}

 


Metadato de tipo choice ó multichoice

Este filtro permite filtrar por el valor de un metadato de tipo choice ó multichoice.

{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "value": ["01", "02"], 
        "lookup_type": "exact"
    }
}



Además para los metadatos de tipo choice y multichoice, de subtipo users, groups y dictionary_term, se permite poner también como "value" en el filtro, el valor de los uuids de los objetos por los que se quiere filtrar. Por ejemplo:

{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "value": [<uuid_user_a>, <uuid_user_b>], 
        "lookup_type": "exact"
    }
}


Donde "uuid_user_a" y "uuid_user_b" serían los uuids de los usuarios por los cuáles queremos realizar el filtrado.

 


Metadato de tipo usuario

Permite filtrar por los metadatos que son de tipo usuario.

{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "value": ["username1", "username2"]
    }
}



Metadato de tipo number

Permite filtrar por los metadatos de tipo number.

{
    "type": "metadata", 
    "schema": {
        "uuid": "123-123-123", 
        "value": 1000, 
        "condition": ">="
    }
}




Artículos relacionados

Comentarios

0 comentarios

Inicie sesión para dejar un comentario.