Rechercher un composant

Construisez vos requêtes de recherche

Les requêtes de recherche permettent de rechercher des composants stockés dans FlowerDocs en fonction de différents critères. Ces requêtes de recherche sont composées de la façon suivante :

Les différentes clauses

Clause Select

La selectClause permet de définir les champs à remonter. Elle est constituée d’une liste de valeurs fields.

Clauses Filter

Les filterClauses permettent de définir des filtres à appliquer sur la recherche. Une filterClause est composée de la façon suivante :

  • criteria : les critères de ce filtre
  • filterClauses : les sous-filtres

Une clause Filter va pouvoir en contenir une ou plusieurs autres afin de pouvoir effectuer des requêtes complexes avec des opérateurs logiques ET et OU. Pour cela, il existe deux types de clause Filter :

  • AndClause : Clause ET, un opérateur logique ET est appliqué entre ses critères et ses sous-clauses
  • OrClause : Clause OU, un opérateur logique OU est appliqué entre ses critères et ses sous-clauses

Clauses Order

Les orderClauses permettent de définir l’ordre dans lequel les résultats seront remontés. Elles sont composées de la façon suivante :

  • name : le nom du critère sur lequel trier
  • type : le type du critère
  • ascending : tri par ordre croissant ou non

Pagination des résultats

  • start : Définit le début de la page de recherche
  • max : Définit le nombre maximum de résultats à retourner


La recherche renvoie un maximum de 10 000 résultats, une erreur est générée en paginant au delà de cette limite.

Exemples

Les exemples ci-dessous indiquent comment effectuer une recherche de document ayant un nom contenant la chaîne de caractères facture.


Dans les critères de recherche, l’opérateur CONTAINS n’est pas sensible à la casse (ne fait pas de distinction entre les majuscules et les minuscules), contrairement aux opérateurs EQUALS_TO et DIFFERENT. Donc l’exemple ci-dessus remontera les documents dont le nom contient : “facture”, mais aussi “FACTURE”, “Facture” …

Clause Select et tri

Cet exemple montre comment sélectionner des champs spécifiques et trier les résultats. Ici nous recherchons les documents de classe Invoice, en ne remontant que le nom, l’identifiant de classe et la date de création, triés du plus récent au plus ancien.


# <CORE_HOST>  URL de base de FlowerDocs Core
# <TOKEN>      jeton d'authentification

curl -X POST "<CORE_HOST>/rest/documents/search" \
  -H "token: <TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "selectClause": {
        "fields": ["name", "classid", "creationDate"]
    },
    "filterClauses": [
        {
            "criteria": [
                {
                    "name": "classid",
                    "operator": "EQUALS_TO",
                    "type": "STRING",
                    "values": ["Invoice"]
                }
            ]
        }
    ],
    "orderClauses": [
        {
            "name": "creationDate",
            "type": "TIMESTAMP",
            "ascending": false
        }
    ],
    "start": 0,
    "max": 20
}'


@Autowired
private DocumentService documentService;

public void search() throws FunctionalException, TechnicalException
{
    Criterion criterion = CriterionBuilder.field(CLASSID).operator(EQUALS_TO).value("Invoice").build();
    FilterClause filter = FilterClauseBuilder.init().criterion(criterion).build();
    OrderClause order = new OrderClause("creationDate", TIMESTAMP, false);
    SearchRequest request = SearchRequestBuilder.init()
        .display("name", "classid", "creationDate")
        .filter(filter)
        .order(order)
        .max(20)
        .build();
    SearchResponse response = documentService.search(request);
}

Critères multiples (ET)

Lorsqu’une clause de filtre contient plusieurs critères, ils sont combinés avec un opérateur ET. Cet exemple recherche les documents de classe Invoice dont le tag B_ClientName contient “Dupont”.


# <CORE_HOST>  URL de base de FlowerDocs Core
# <TOKEN>      jeton d'authentification

curl -X POST "<CORE_HOST>/rest/documents/search" \
  -H "token: <TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "filterClauses": [
        {
            "criteria": [
                {
                    "name": "classid",
                    "operator": "EQUALS_TO",
                    "type": "STRING",
                    "values": ["Invoice"]
                },
                {
                    "name": "B_ClientName",
                    "operator": "CONTAINS",
                    "type": "STRING",
                    "values": ["Dupont"]
                }
            ]
        }
    ],
    "max": 10
}'


@Autowired
private DocumentService documentService;

public void search() throws FunctionalException, TechnicalException
{
    Criterion classCriterion = CriterionBuilder.field(CLASSID).operator(EQUALS_TO).value("Invoice").build();
    Criterion tagCriterion = CriterionBuilder.name("B_ClientName").operator(CONTAINS).value("Dupont").build();
    FilterClause filter = FilterClauseBuilder.and()
        .criterion(classCriterion)
        .criterion(tagCriterion)
        .build();
    SearchRequest request = SearchRequestBuilder.init().filter(filter).max(10).build();
    SearchResponse response = documentService.search(request);
}

Recherche par plage de dates (BETWEEN)

Utilisez l’opérateur BETWEEN avec le type TIMESTAMP pour rechercher dans une plage de dates. Les valeurs sont des timestamps epoch en millisecondes. Cet exemple recherche les documents créés durant l’année 2024.


# <CORE_HOST>  URL de base de FlowerDocs Core
# <TOKEN>      jeton d'authentification

# Valeurs de dates en millisecondes epoch :
#   1704067200000 = 2024-01-01T0000Z
#   1735689600000 = 2025-01-01T0000Z

curl -X POST "<CORE_HOST>/rest/documents/search" \
  -H "token: <TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "filterClauses": [
        {
            "criteria": [
                {
                    "name": "creationDate",
                    "operator": "BETWEEN",
                    "type": "TIMESTAMP",
                    "values": ["1704067200000", "1735689600000"]
                }
            ]
        }
    ],
    "max": 50
}'


@Autowired
private DocumentService documentService;

public void search() throws FunctionalException, TechnicalException, ParseException
{
    Date startDate = new SimpleDateFormat("yyyy-MM-dd").parse("2024-01-01");
    Date endDate = new SimpleDateFormat("yyyy-MM-dd").parse("2025-01-01");
    Criterion criterion = CriterionBuilder.field(CREATION_DATE)
        .operator(BETWEEN).type(TIMESTAMP)
        .value(startDate).value(endDate)
        .build();
    FilterClause filter = FilterClauseBuilder.init().criterion(criterion).build();
    SearchRequest request = SearchRequestBuilder.init().filter(filter).max(50).build();
    SearchResponse response = documentService.search(request);
}

Logique OU

Pour rechercher des documents correspondant à une condition OU une autre, utilisez une OrClause. Le champ type doit être défini explicitement pour indiquer la logique OU. Cet exemple recherche les documents dont la classe est soit Invoice soit Contract.


# <CORE_HOST>  URL de base de FlowerDocs Core
# <TOKEN>      jeton d'authentification

curl -X POST "<CORE_HOST>/rest/documents/search" \
  -H "token: <TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "filterClauses": [
        {
            "type": "com.flower.docs.domain.search.OrClause",
            "clauses": [
                {
                    "type": "com.flower.docs.domain.search.AndClause",
                    "criteria": [
                        {
                            "name": "classid",
                            "operator": "EQUALS_TO",
                            "type": "STRING",
                            "values": ["Invoice"]
                        }
                    ]
                },
                {
                    "type": "com.flower.docs.domain.search.AndClause",
                    "criteria": [
                        {
                            "name": "classid",
                            "operator": "EQUALS_TO",
                            "type": "STRING",
                            "values": ["Contract"]
                        }
                    ]
                }
            ]
        }
    ],
    "max": 10
}'


@Autowired
private DocumentService documentService;

public void search() throws FunctionalException, TechnicalException
{
    Criterion invoiceCrit = CriterionBuilder.field(CLASSID).operator(EQUALS_TO).value("Invoice").build();
    Criterion contractCrit = CriterionBuilder.field(CLASSID).operator(EQUALS_TO).value("Contract").build();
    FilterClause invoiceClause = FilterClauseBuilder.and().criterion(invoiceCrit).build();
    FilterClause contractClause = FilterClauseBuilder.and().criterion(contractCrit).build();
    FilterClause orClause = FilterClauseBuilder.or()
        .filter(invoiceClause)
        .filter(contractClause)
        .build();
    SearchRequest request = SearchRequestBuilder.init().filter(orClause).max(10).build();
    SearchResponse response = documentService.search(request);
}

Combinaison ET + OU

Plusieurs filterClauses au niveau racine sont combinées avec un ET. Cet exemple recherche les documents Invoice créés en 2024, dont le nom de client est soit “Dupont” soit “Martin”. La première clause de filtre gère les conditions ET (classe + date), tandis que la seconde utilise une clause OU pour les noms de client.


# <CORE_HOST>  URL de base de FlowerDocs Core
# <TOKEN>      jeton d'authentification

curl -X POST "<CORE_HOST>/rest/documents/search" \
  -H "token: <TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "filterClauses": [
        {
            "criteria": [
                {
                    "name": "classid",
                    "operator": "EQUALS_TO",
                    "type": "STRING",
                    "values": ["Invoice"]
                },
                {
                    "name": "creationDate",
                    "operator": "BETWEEN",
                    "type": "TIMESTAMP",
                    "values": ["1704067200000", "1735689600000"]
                }
            ]
        },
        {
            "type": "com.flower.docs.domain.search.OrClause",
            "clauses": [
                {
                    "type": "com.flower.docs.domain.search.AndClause",
                    "criteria": [
                        {
                            "name": "B_ClientName",
                            "operator": "EQUALS_TO",
                            "type": "STRING",
                            "values": ["Dupont"]
                        }
                    ]
                },
                {
                    "type": "com.flower.docs.domain.search.AndClause",
                    "criteria": [
                        {
                            "name": "B_ClientName",
                            "operator": "EQUALS_TO",
                            "type": "STRING",
                            "values": ["Martin"]
                        }
                    ]
                }
            ]
        }
    ],
    "max": 10
}'


@Autowired
private DocumentService documentService;

public void search() throws FunctionalException, TechnicalException, ParseException
{
    Date startDate = new SimpleDateFormat("yyyy-MM-dd").parse("2024-01-01");
    Date endDate = new SimpleDateFormat("yyyy-MM-dd").parse("2025-01-01");

    Criterion classCrit = CriterionBuilder.field(CLASSID).operator(EQUALS_TO).value("Invoice").build();
    Criterion dateCrit = CriterionBuilder.field(CREATION_DATE).operator(BETWEEN).type(TIMESTAMP)
        .value(startDate).value(endDate).build();
    FilterClause andClause = FilterClauseBuilder.and()
        .criterion(classCrit).criterion(dateCrit).build();

    Criterion dupontCrit = CriterionBuilder.name("B_ClientName").operator(EQUALS_TO).value("Dupont").build();
    Criterion martinCrit = CriterionBuilder.name("B_ClientName").operator(EQUALS_TO).value("Martin").build();
    FilterClause orClause = FilterClauseBuilder.or()
        .filter(FilterClauseBuilder.and().criterion(dupontCrit).build())
        .filter(FilterClauseBuilder.and().criterion(martinCrit).build())
        .build();

    SearchRequest request = SearchRequestBuilder.init()
        .filter(andClause).filter(orClause).max(10).build();
    SearchResponse response = documentService.search(request);
}

Rechercher d’autres types de composants

Le même modèle de recherche s’applique aux dossiers, tâches et dossiers virtuels — seul le endpoint change.


# <CORE_HOST>  URL de base de FlowerDocs Core
# <TOKEN>      jeton d'authentification

# Rechercher des dossiers de classe "Project"
curl -X POST "<CORE_HOST>/rest/folders/search" \
  -H "token: <TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "filterClauses": [
        {
            "criteria": [
                {
                    "name": "classid",
                    "operator": "EQUALS_TO",
                    "type": "STRING",
                    "values": ["Project"]
                }
            ]
        }
    ],
    "max": 10
}'


# <CORE_HOST>  URL de base de FlowerDocs Core
# <TOKEN>      jeton d'authentification

# Rechercher des tâches assignées à un utilisateur
curl -X POST "<CORE_HOST>/rest/tasks/search" \
  -H "token: <TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "filterClauses": [
        {
            "criteria": [
                {
                    "name": "assignee",
                    "operator": "EQUALS_TO",
                    "type": "STRING",
                    "values": ["jdoe"]
                }
            ]
        }
    ],
    "max": 10
}'

Ces différents exemples peuvent être adaptés pour chaque catégorie de composant.