# Uses of Class
fr.gouv.vitam.common.exception.InvalidParseOperationException

Packages that use InvalidParseOperationException
Package
Description
fr.gouv.vitam.access.external.client
Provides
fr.gouv.vitam.access.external.rest
Provides the web server application for the Access External module and the rest resources it uses.
fr.gouv.vitam.access.internal.api
Provides module and resource interfaces and a binary data POJO for the Access Internal module.
fr.gouv.vitam.access.internal.client
Provides access internal client interface, factory and implementations.
fr.gouv.vitam.access.internal.core
Provides core implementation for the Access Internal module.
fr.gouv.vitam.batch.report.rest.service
fr.gouv.vitam.collect.internal.core.helpers.handlers
fr.gouv.vitam.collect.internal.core.repository
fr.gouv.vitam.collect.internal.core.service
fr.gouv.vitam.common
General utility classes as FileUtil, SystemPropertyUtil and UUID support
fr.gouv.vitam.common.client
Basic Vitam Client Common interfaces
fr.gouv.vitam.common.database.builder.request
Provides an abstract request class
fr.gouv.vitam.common.database.builder.request.configuration
Provides configuration classes containing GlobalDatas and ParserTokens
fr.gouv.vitam.common.database.builder.request.multiple
Provides database builders for multiple query requests
fr.gouv.vitam.common.database.builder.request.single
Provides database builders for single query requests
fr.gouv.vitam.common.database.parser.facet
Provides facets to be used within the Vitam DSL
fr.gouv.vitam.common.database.parser.query
Provides queries to be used within the Vitam DSL
fr.gouv.vitam.common.database.parser.query.action
Provides actions to be used within the Vitam DSL
fr.gouv.vitam.common.database.parser.request
Provides a global and an abstract parser in order to parse requests
fr.gouv.vitam.common.database.parser.request.adapter
Provides database parser adapters for request
fr.gouv.vitam.common.database.parser.request.multiple
Provides database parsers for multiple query requests
fr.gouv.vitam.common.database.parser.request.single
Provides database parsers for single query requests
fr.gouv.vitam.common.database.server
Database server package in vitam
fr.gouv.vitam.common.database.server.mongodb
MongoDB server package in Vitam
fr.gouv.vitam.common.database.translators.elasticsearch
Provides translators for Elasticsearch
fr.gouv.vitam.common.database.translators.mongodb
Provides translators for MongoDB
fr.gouv.vitam.common.database.utils
fr.gouv.vitam.common.error
Contains
- services codes and their name
- domains codes and their name
- public Vitam codes
fr.gouv.vitam.common.external.client
Contains generic VitamClient and associated basic implementation used as base for every specific client module.
fr.gouv.vitam.common.json
Json support
fr.gouv.vitam.common.model
This package contains simple POJOs and DTOs that may be shared commonly by all vitam internal components
fr.gouv.vitam.common.security
Security package for Vitam
fr.gouv.vitam.common.server.application.resources
Standard Vitam Application Standard Resources
fr.gouv.vitam.functional.administration.client
Provides Functional administration client interface, factory and implementations.
fr.gouv.vitam.functional.administration.common
Provides common classes for the Functional Administration module.
fr.gouv.vitam.functional.administration.common.utils
fr.gouv.vitam.functional.administration.core.accession.register
fr.gouv.vitam.functional.administration.core.archiveunitprofiles
fr.gouv.vitam.functional.administration.core.archiveunitprofilesSchema
fr.gouv.vitam.functional.administration.core.audit
fr.gouv.vitam.functional.administration.core.backup
fr.gouv.vitam.functional.administration.core.context
fr.gouv.vitam.functional.administration.core.contract
fr.gouv.vitam.functional.administration.core.griffin
fr.gouv.vitam.functional.administration.core.ontologies
fr.gouv.vitam.functional.administration.core.profile
fr.gouv.vitam.functional.administration.core.rules
fr.gouv.vitam.functional.administration.core.schema
fr.gouv.vitam.functional.administration.core.security.profile
fr.gouv.vitam.functionaltest.cucumber.step
fr.gouv.vitam.ihmdemo.common.pagination
Provides IHM Demo Pagination Common classes
fr.gouv.vitam.ihmdemo.core
Provides IHM core classes
fr.gouv.vitam.ingest.internal.client
Provides Ingest Internal Client interface, configuration, factory and implementations.
fr.gouv.vitam.logbook.administration.core
Provides the core classes for the Logbook Administration module
fr.gouv.vitam.logbook.common.traceability
fr.gouv.vitam.logbook.lifecycles.api
Provides API classes for the Logbook Lifecycles module
fr.gouv.vitam.logbook.lifecycles.client
Provides Logbook Lifecycles client interface, factory and implementations.
fr.gouv.vitam.logbook.lifecycles.core
Provides core implementation for the Logbook Lifecycles module.
fr.gouv.vitam.logbook.operations.api
Provides API classes for the Logbook Operations module
fr.gouv.vitam.logbook.operations.client
Provides Logbook Operations client interface, factory and implementations.
fr.gouv.vitam.logbook.operations.core
Provides core implementation for the Logbook Operations module.
fr.gouv.vitam.metadata.client
Provides Metadata client interface, factory and implementations.
fr.gouv.vitam.metadata.common.bulkatomicupdate
fr.gouv.vitam.metadata.core
Provides
fr.gouv.vitam.metadata.core.database.collections
Provides
fr.gouv.vitam.metadata.core.graph
fr.gouv.vitam.metadata.core.reconstruction.model
fr.gouv.vitam.metadata.core.rules
fr.gouv.vitam.metadata.core.utils
Provides utility classes for the Metadata module
fr.gouv.vitam.processing.data.core.management
fr.gouv.vitam.security.internal.common.service
fr.gouv.vitam.security.internal.rest.repository
Provides core classes of functional administration rules module
fr.gouv.vitam.security.internal.rest.resource
Provides core classes of functional administration rules module
fr.gouv.vitam.security.internal.rest.service
Provides core classes of functional administration rules module
fr.gouv.vitam.storage.driver
Provides interface describing how drivers should be implemented for the Storage driver module
fr.gouv.vitam.storage.engine.client
Provides Storage Engine client interface, factory and implementations.
fr.gouv.vitam.storage.engine.server.distribution.impl.bulk
fr.gouv.vitam.storage.engine.server.storagetraceability
fr.gouv.vitam.storage.offers.workspace.driver
Provides implementation of the driver for the Workspace Driver module.
fr.gouv.vitam.worker.core.handler
Provides Handler classes for the Worker Core module
fr.gouv.vitam.worker.core.plugin
Plugin package in worker module
fr.gouv.vitam.worker.core.plugin.common
fr.gouv.vitam.worker.core.plugin.evidence
fr.gouv.vitam.worker.core.plugin.lfc_traceability
fr.gouv.vitam.worker.core.plugin.preservation
fr.gouv.vitam.worker.core.plugin.purge
fr.gouv.vitam.worker.core.plugin.reclassification.dsl
fr.gouv.vitam.worker.core.plugin.reclassification.utils

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.access.external.client

  Methods in fr.gouv.vitam.access.external.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponse`
  AdminExternalClient.`checkTraceabilityOperation(VitamContext vitamContext, com.fasterxml.jackson.databind.JsonNode query)`
  Deprecated.
  `RequestResponse`
  AdminExternalClientMock.`checkTraceabilityOperation(VitamContext vitamContext, com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AdminExternalClient.`checkTraceabilityOperations(VitamContext vitamContext, com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AdminExternalClientMock.`checkTraceabilityOperations(VitamContext vitamContext, com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse`
  AdminExternalClient.`createAccessContracts(VitamContext vitamContext, InputStream accessContracts)`
  create a set of access contracts after passing the validation steps.
  `RequestResponse`
  AdminExternalClientMock.`createAccessContracts(VitamContext vitamContext, InputStream accessContracts)`
  `RequestResponse`
  AdminExternalClientRest.`createAccessContracts(VitamContext vitamContext, InputStream accessContracts)`
  `RequestResponse`
  AdminExternalClient.`createAgencies(VitamContext vitamContext, InputStream agencies, String filename)`
  create a set of agencies
  `RequestResponse`
  AdminExternalClientMock.`createAgencies(VitamContext vitamContext, InputStream agencies, String filename)`
  `RequestResponse`
  AdminExternalClient.`createArchiveUnitProfile(VitamContext vitamContext, InputStream profiles)`
  Create a ArchiveUnitProfile after passing the validation steps.
  `RequestResponse`
  AdminExternalClientRest.`createArchiveUnitProfile(VitamContext vitamContext, InputStream archiveUnitProfiles)`
  `RequestResponse`
  AdminExternalClient.`createContexts(VitamContext vitamContext, InputStream contexts)`
  create a set of contexts
  `RequestResponse`
  AdminExternalClientMock.`createContexts(VitamContext vitamContext, InputStream contexts)`
  `RequestResponse`
  AdminExternalClientRest.`createContexts(VitamContext vitamContext, InputStream contexts)`
  `RequestResponse`
  AdminExternalClient.`createFormats(VitamContext vitamContext, InputStream formats, String filename)`
  create a set of formats
  `RequestResponse`
  AdminExternalClientMock.`createFormats(VitamContext vitamContext, InputStream formats, String filename)`
  `RequestResponse`
  AdminExternalClient.`createIngestContracts(VitamContext vitamContext, InputStream ingestContracts)`
  create a set of ingest contracts after passing the validation steps.
  `RequestResponse`
  AdminExternalClientMock.`createIngestContracts(VitamContext vitamContext, InputStream ingestContracts)`
  `RequestResponse`
  AdminExternalClientRest.`createIngestContracts(VitamContext vitamContext, InputStream ingestContracts)`
  `RequestResponse`
  AdminExternalClient.`createManagementContracts(VitamContext vitamContext, InputStream accessContracts)`
  create a set of access contracts after passing the validation steps.
  `RequestResponse`
  AdminExternalClientMock.`createManagementContracts(VitamContext vitamContext, InputStream managementContracts)`
  `RequestResponse`
  AdminExternalClientRest.`createManagementContracts(VitamContext vitamContext, InputStream managementContracts)`
  `RequestResponse`
  AdminExternalClient.`createProfileFile(VitamContext vitamContext, String profileMetadataId, InputStream profile)`
  Save profile file (xsd, rng, ...) corresponding to the profile metadata.
  `RequestResponse`
  AdminExternalClientMock.`createProfileFile(VitamContext vitamContext, String profileMetadataId, InputStream profile)`
  `RequestResponse`
  AdminExternalClientRest.`createProfileFile(VitamContext vitamContext, String profileMetadataId, InputStream profile)`
  `RequestResponse`
  AdminExternalClient.`createProfiles(VitamContext vitamContext, InputStream profiles)`
  Create a profile metadata after passing the validation steps.
  `RequestResponse`
  AdminExternalClientMock.`createProfiles(VitamContext vitamContext, InputStream profiles)`
  `RequestResponse`
  AdminExternalClientRest.`createProfiles(VitamContext vitamContext, InputStream profiles)`
  `RequestResponse`
  AdminExternalClient.`createRules(VitamContext vitamContext, InputStream rules, String filename)`
  create a set of rules
  `RequestResponse`
  AdminExternalClientMock.`createRules(VitamContext vitamContext, InputStream rules, String filename)`
  `RequestResponse`
  AdminExternalClient.`createSecurityProfiles(VitamContext vitamContext, InputStream securityProfiles, String filename)`
  create a set of security profiles
  `RequestResponse`
  AdminExternalClientMock.`createSecurityProfiles(VitamContext vitamContext, InputStream securityProfiles, String filename)`
  `RequestResponse<Void>`
  AdminExternalClient.`deleteUnitExternalSchemas(VitamContext vitamContext, List<String> externalSchemaPaths)`
  Delete unit external schema
  `RequestResponse<Void>`
  AdminExternalClientMock.`deleteUnitExternalSchemas(VitamContext vitamContext, List<String> externalSchemaPaths)`
  `RequestResponse<Void>`
  AdminExternalClientRest.`deleteUnitExternalSchemas(VitamContext vitamContext, List<String> externalSchemaPaths)`
  `RequestResponse`
  AdminExternalClient.`getAccessionRegisterDetail(VitamContext vitamContext, String id, com.fasterxml.jackson.databind.JsonNode query)`
  Get the accession register details matching the given query
  `RequestResponse`
  AdminExternalClientMock.`getAccessionRegisterDetail(VitamContext vitamContext, String id, com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse`
  AdminExternalClientRest.`getAccessionRegisterDetail(VitamContext vitamContext, String id, com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse`
  AdminExternalClient.`importOntologies(boolean forceUpdate, VitamContext vitamContext, InputStream ontologies)`
  Import a set of ontologies metadata.
  `RequestResponse`
  AdminExternalClientMock.`importOntologies(boolean forceUpdate, VitamContext vitamContext, InputStream profiles)`
  `RequestResponse`
  AdminExternalClientRest.`importOntologies(boolean forceUpdate, VitamContext vitamContext, InputStream ontologies)`
  `RequestResponse<Void>`
  AdminExternalClient.`importUnitExternalSchema(VitamContext vitamContext, InputStream externalSchema)`
  Import unit external schema
  `RequestResponse`
  AdminExternalClient.`updateAccessContract(VitamContext vitamContext, String accessContractId, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update the given access contract by query dsl
  `RequestResponse`
  AdminExternalClientMock.`updateAccessContract(VitamContext vitamContext, String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse`
  AdminExternalClient.`updateArchiveUnitProfile(VitamContext vitamContext, String archiveUnitprofileId, com.fasterxml.jackson.databind.JsonNode queryDSL)`
  Update the given archive unit profile by query DSL
  `RequestResponse`
  AdminExternalClientMock.`updateArchiveUnitProfile(VitamContext vitamContext, String archiveUnitprofileId, com.fasterxml.jackson.databind.JsonNode queryDSL)`
  `RequestResponse`
  AdminExternalClientRest.`updateArchiveUnitProfile(VitamContext vitamContext, String archiveUnitprofileId, com.fasterxml.jackson.databind.JsonNode queryDSL)`
  `RequestResponse`
  AdminExternalClient.`updateContext(VitamContext vitamContext, String contextId, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update the context by query dsl
  `RequestResponse`
  AdminExternalClientMock.`updateContext(VitamContext vitamContext, String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse`
  AdminExternalClient.`updateIngestContract(VitamContext vitamContext, String ingestContractId, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update the given ingest contract by query dsl
  `RequestResponse`
  AdminExternalClientMock.`updateIngestContract(VitamContext vitamContext, String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse`
  AdminExternalClientRest.`updateIngestContract(VitamContext vitamContext, String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse`
  AdminExternalClient.`updateManagementContract(VitamContext vitamContext, String managementContractId, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update the given management contract by query dsl
  `RequestResponse`
  AdminExternalClientMock.`updateManagementContract(VitamContext vitamContext, String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.access.external.rest

  Methods in fr.gouv.vitam.access.external.rest that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `jakarta.ws.rs.core.Response`
  AccessExternalResource.`getDataObjectByObjectPersistentIdentifier(jakarta.ws.rs.core.HttpHeaders headers, String persistentIdentifier)`
  The caller is responsible to close the Response after consuming the inputStream.
  `jakarta.ws.rs.core.Response`
  AdminManagementExternalResource.`updateContext(String identifier, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update context
  `jakarta.ws.rs.core.Response`
  AdminManagementExternalResource.`updateProfile(String identifier, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update profile

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.access.internal.api

  Methods in fr.gouv.vitam.access.internal.api that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  AccessInternalModule.`checkClassificationLevel(com.fasterxml.jackson.databind.JsonNode query)`
  check ClassificationLevel in update Unit
  `Optional<AccessRequestReference>`
  AccessInternalModule.`createObjectAccessRequestIfRequired(String idObjectGroup, String qualifier, int version)`
  `jakarta.ws.rs.core.Response`
  AccessInternalModule.`getObjectByUnitPersistentIdentifier(String persistentIdentifier, String qualifier, Integer version)`
  `jakarta.ws.rs.core.Response`
  AccessInternalModule.`getOneObjectFromObjectGroup(String idObjectGroup, String qualifier, int version, String idUnit)`
  Retrieve an object as InputStream based on the associated ObjectGroupId and qualifier + version requested
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModule.`selectObjectGroupById(com.fasterxml.jackson.databind.JsonNode queryJson, String idObjectGroup)`
  Retrieve an ObjectGroup by its id with results fields filtered based on given query
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModule.`selectObjects(com.fasterxml.jackson.databind.JsonNode queryJson)`
  select Objects Group based on DSL query
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModule.`selectPurgedPersistentIdentifier(String persistentIdentifier, PurgedCollectionType type)`
  select purged persistent identifier
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModule.`selectUnit(com.fasterxml.jackson.databind.JsonNode queryJson)`
  select Unit
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModule.`selectUnitbyId(com.fasterxml.jackson.databind.JsonNode queryJson, String idUnit)`
  select Unit by id
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModule.`selectUnitsWithInheritedRules(com.fasterxml.jackson.databind.JsonNode jsonQuery)`
  Select units by DSL and computes inherited rules for matching units
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModule.`updateUnitById(com.fasterxml.jackson.databind.JsonNode queryJson, String idUnit, String requestId)`
  update Unit by id

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.access.internal.client

  Methods in fr.gouv.vitam.access.internal.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`bulkAtomicUpdateUnits(com.fasterxml.jackson.databind.JsonNode updateQueries)`
  Bulk atomic update of archive units with dsl query.
  `jakarta.ws.rs.core.Response`
  AccessInternalClient.`downloadAccessLogFile(com.fasterxml.jackson.databind.JsonNode params)`
  Get Zipped AccessLog files as Stream
  `jakarta.ws.rs.core.Response`
  AccessInternalClient.`downloadTraceabilityFile(String operationId)`
  `jakarta.ws.rs.core.Response`
  AccessInternalClient.`getObject(String objectGroupId, String usage, int version, String unitId)`
  Retrieve an Object data as an input stream
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`linkedCheckTraceability(com.fasterxml.jackson.databind.JsonNode query)`
  Linked check traceability
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`revertUnits(RevertUpdateOptions revertUpdateOptions)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectObjectbyId(com.fasterxml.jackson.databind.JsonNode selectObjectQuery, String objectId)`
  Retrieve an ObjectGroup as Json data based on the provided ObjectGroup id
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectObjectGroupLifeCycleById(String idObject, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  selectObjectGroupLifeCycleById
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectObjects(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Select Objects group based on DSL query
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectObjectsByObjectPersistentIdentifier(String persistentIdentifier, com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Select Objects by persistent identifier
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectOperation(com.fasterxml.jackson.databind.JsonNode select, boolean isSliced, boolean isCrossTenant)`
  selectOperation
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectOperationById(String processId)`
  selectOperationbyId
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectOperationById(String processId, com.fasterxml.jackson.databind.JsonNode queryDsl, boolean isSliced, boolean isCrossTenant)`
  selectOperationbyId
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectUnitbyId(com.fasterxml.jackson.databind.JsonNode sqlQuery, String id)`
  select Unit By Id
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectUnitLifeCycleById(String idUnit, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  selectUnitLifeCycleById
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectUnits(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Select Units
  `jakarta.ws.rs.core.Response`
  AccessInternalClient.`selectUnitsByUnitPersistentIdentifier(String persistentIdentifier, com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Select Units by persistent identifier
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`selectUnitsWithInheritedRules(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Select units with inherited rules by select query (DSL)
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`updateUnitbyId(com.fasterxml.jackson.databind.JsonNode updateQuery, String unitId)`
  update Unit By Id
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`updateUnits(com.fasterxml.jackson.databind.JsonNode updateQuery)`
  Mass update of archive units with dsl query.
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AccessInternalClient.`updateUnitsRules(MassUpdateUnitRuleRequest massUpdateUnitRuleRequest)`
  Mass update of archive units rules.

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.access.internal.core

  Methods in fr.gouv.vitam.access.internal.core that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  AccessInternalModuleImpl.`checkClassificationLevel(com.fasterxml.jackson.databind.JsonNode query)`
  `Optional<AccessRequestReference>`
  AccessInternalModuleImpl.`createObjectAccessRequestIfRequired(String idObjectGroup, String qualifier, int version)`
  `jakarta.ws.rs.core.Response`
  AccessInternalModuleImpl.`getOneObjectFromObjectGroup(String idObjectGroup, String qualifier, int version, String idUnit)`
  `static com.fasterxml.jackson.databind.JsonNode`
  DslParserHelper.`getValueForUpdateDsl(com.fasterxml.jackson.databind.JsonNode query, String fieldName)`
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModuleImpl.`selectObjectGroupById(com.fasterxml.jackson.databind.JsonNode jsonQuery, String idObjectGroup)`
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModuleImpl.`selectObjects(com.fasterxml.jackson.databind.JsonNode jsonQuery)`
  select Object
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModuleImpl.`selectPurgedPersistentIdentifier(String persistentIdentifier, PurgedCollectionType type)`
  select purged persistent identifiers
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModuleImpl.`selectUnit(com.fasterxml.jackson.databind.JsonNode jsonQuery)`
  select Unit
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModuleImpl.`selectUnitbyId(com.fasterxml.jackson.databind.JsonNode jsonQuery, String idUnit)`
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModuleImpl.`selectUnitsWithInheritedRules(com.fasterxml.jackson.databind.JsonNode jsonQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  AccessInternalModuleImpl.`updateUnitById(com.fasterxml.jackson.databind.JsonNode queryJson, String idUnit, String requestId)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.batch.report.rest.service

  Methods in fr.gouv.vitam.batch.report.rest.service that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  BatchReportServiceImpl.`exportPurgeAccessionRegister(String processId, String filename, int tenantId)`
  `List<DeleteGotVersionsComputedDetails>`
  BatchReportServiceImpl.`readDeletedGotVersionsComputedDetailsFromReport(String processId, int tenantId)`
  `void`
  BatchReportServiceImpl.`storeFileToWorkspace(Report reportInfo)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.collect.internal.core.helpers.handlers

  Methods in fr.gouv.vitam.collect.internal.core.helpers.handlers that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static UpdateMultiQuery`
  QueryHandler.`getQualifiersAddMultiQuery(DbObjectGroupModel objectGroupModel, DataObjectVersionType usage, int version, ObjectDto objectDto)`
  `static UpdateMultiQuery`
  QueryHandler.`getQualifiersUpdateMultiQuery(DbQualifiersModel qualifierModelToUpdate, DataObjectVersionType usage, int version, List<DbQualifiersModel> qualifiers, ObjectDto objectDto, int nbc)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.collect.internal.core.repository

  Methods in fr.gouv.vitam.collect.internal.core.repository that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `com.fasterxml.jackson.databind.JsonNode`
  MetadataRepository.`selectUnitsWithInheritedRules(com.fasterxml.jackson.databind.JsonNode jsonQuery, String transactionId)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.collect.internal.core.service

  Methods in fr.gouv.vitam.collect.internal.core.service that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `com.fasterxml.jackson.databind.JsonNode`
  MetadataService.`saveArchiveUnit(com.fasterxml.jackson.databind.JsonNode unit, TransactionModel transactionModel)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetadataService.`selectUnitsWithInheritedRules(String transactionId, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `jakarta.ws.rs.core.Response`
  TransactionService.`startDeletionWorkflow(String transactionId, DeletionRequestBody deletionRequestBody, Contexts deletionWorkflowContext)`
  `jakarta.ws.rs.core.Response`
  TransactionService.`startEliminationActionWorkflow(String transactionId, EliminationRequestBody eliminationRequestBody, Contexts eliminationWorkflowContext)`
  `String`
  TransactionService.`uploadSipOnTransaction(String transactionId, String contentType, InputStream uploadedInputStream)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common

  Methods in fr.gouv.vitam.common that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static String`
  StringUtils.`checkSanityString(String value)`
  Check external argument to avoid Path Traversal attack
  `static void`
  StringUtils.`checkSanityString(String... strings)`
  Check external argument

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.client

  Methods in fr.gouv.vitam.common.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static RequestResponse`
  ClientMockResultHelper.`checkOperationTraceability()`
  `static RequestResponse`
  ClientMockResultHelper.`createResponse(String s)`
  `static RequestResponse`
  ClientMockResultHelper.`createResponse(String s, int statuscode, Class clazz)`
  `static <T> RequestResponse<T>`
  ClientMockResultHelper.`createResponse(String s, Class<T> clasz)`
  `static <T> RequestResponse<T>`
  ClientMockResultHelper.`createResponse(List<T> entries)`
  `static RequestResponse`
  ClientMockResultHelper.`getAccessContractOrDefault(String identifier)`
  `static RequestResponse`
  ClientMockResultHelper.`getAccessionRegisterDetail()`
  `static RequestResponse`
  ClientMockResultHelper.`getAccessionRegisterSummary()`
  `static RequestResponse`
  ClientMockResultHelper.`getAgenciesList()`
  `static RequestResponse`
  ClientMockResultHelper.`getAgency()`
  `static RequestResponse`
  ClientMockResultHelper.`getArchiveUnitProfiles(int statusCode)`
  method to get mocked archive unit profiles with the givel status code
  `static RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  ClientMockResultHelper.`getArchiveUnitRawResult()`
  `static RequestResponse`
  ClientMockResultHelper.`getArchiveUnitResult()`
  `static RequestResponse`
  ClientMockResultHelper.`getContexts(int statusCode)`
  `static RequestResponse`
  ClientMockResultHelper.`getDipInfo()`
  `static RequestResponse`
  ClientMockResultHelper.`getEmptyResult()`
  `static RequestResponse`
  ClientMockResultHelper.`getFormat()`
  `static RequestResponse`
  ClientMockResultHelper.`getFormatList()`
  `static RequestResponse<IngestContractModel>`
  ClientMockResultHelper.`getIngestContracts()`
  `static ItemStatus`
  ClientMockResultHelper.`getItemStatus(String id)`
  `static com.fasterxml.jackson.databind.JsonNode`
  ClientMockResultHelper.`getLogbookLifecycle()`
  `static com.fasterxml.jackson.databind.JsonNode`
  ClientMockResultHelper.`getLogbookOperation()`
  `static com.fasterxml.jackson.databind.JsonNode`
  ClientMockResultHelper.`getLogbookOperationWithObId()`
  `static RequestResponse`
  ClientMockResultHelper.`getLogbookRequestResponse()`
  `static RequestResponse`
  ClientMockResultHelper.`getLogbookRequestResponseWithObId()`
  `static com.fasterxml.jackson.databind.JsonNode`
  ClientMockResultHelper.`getLogbookResults()`
  `static RequestResponse`
  ClientMockResultHelper.`getLogbooksRequestResponse()`
  `static RequestResponse`
  ClientMockResultHelper.`getManagementContracts()`
  `static RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  ClientMockResultHelper.`getMetaDataResult()`
  `static RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  ClientMockResultHelper.`getObjectGroupRawResult()`
  `static RequestResponse`
  ClientMockResultHelper.`getOntologies(int statusCode)`
  method to get mocked ontologies with the given status code
  `static RequestResponse`
  ClientMockResultHelper.`getOperationTraceabilityDetails()`
  `static RequestResponse`
  ClientMockResultHelper.`getProfiles(int statusCode)`
  `static RequestResponse`
  ClientMockResultHelper.`getRule()`
  `static RequestResponse`
  ClientMockResultHelper.`getRuleList()`
  `static RequestResponse`
  ClientMockResultHelper.`getRuleList(String ruleId)`
  `static RequestResponse`
  ClientMockResultHelper.`getSecurityProfiles()`
  `static RequestResponse`
  ClientMockResultHelper.`getTraceabilityOperationMock()`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.builder.request

  Methods in fr.gouv.vitam.common.database.builder.request that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `final AbstractRequest`
  AbstractRequest.`addHintFilter(String... hints)`
  `final AbstractRequest`
  AbstractRequest.`parseFilter(String filter)`
  `protected final AbstractRequest`
  AbstractRequest.`selectAddOrderByAscFilter(String... variableNames)`
  `protected final AbstractRequest`
  AbstractRequest.`selectAddOrderByDescFilter(String... variableNames)`
  `protected final AbstractRequest`
  AbstractRequest.`selectAddOrderByFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `protected final AbstractRequest`
  AbstractRequest.`selectAddUnusedProjection(String... variableNames)`
  `protected final AbstractRequest`
  AbstractRequest.`selectAddUsedProjection(String... variableNames)`
  `protected final AbstractRequest`
  AbstractRequest.`selectParseLimitFilter(String filter)`
  `protected final AbstractRequest`
  AbstractRequest.`selectParseOrderByFilter(String filter)`
  `protected final AbstractRequest`
  AbstractRequest.`selectParseProjection(String projection)`
  `protected final AbstractRequest`
  AbstractRequest.`selectSetFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `protected AbstractRequest`
  AbstractRequest.`selectSetProjection(com.fasterxml.jackson.databind.JsonNode projectionContent)`
  `AbstractRequest`
  AbstractRequest.`setFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.builder.request.configuration

  Methods in fr.gouv.vitam.common.database.builder.request.configuration that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `protected static final void`
  GlobalDatas.`sanityCheck(String arg, int size)`
  Check the String if conforms to sanity check
  `static final void`
  GlobalDatas.`sanityParameterCheck(String arg)`
  Check the String if conforms to sanity check for small parameters
  `static final void`
  GlobalDatas.`sanityParametersCheck(String arg, int multipleParams)`
  Check the String if conforms to sanity check for small parameters
  `static final void`
  GlobalDatas.`sanityValueCheck(String arg)`
  Check the String if conforms to sanity check
  `static final void`
  GlobalDatas.`sanityValueCheck(List<?> arg)`
  Check the List of arguments if conforms to sanity check
  `static final void`
  GlobalDatas.`sanityVariableNameCheck(String arg)`
  Check the Variable name if conforms to sanity check

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.builder.request.multiple

  Methods in fr.gouv.vitam.common.database.builder.request.multiple that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `final SelectMultiQuery`
  SelectMultiQuery.`addOrderByAscFilter(String... variableNames)`
  `final SelectMultiQuery`
  SelectMultiQuery.`addOrderByDescFilter(String... variableNames)`
  `final SelectMultiQuery`
  SelectMultiQuery.`addOrderByFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final RequestMultiple`
  RequestMultiple.`addRoots(String... roots)`
  `final SelectMultiQuery`
  SelectMultiQuery.`addUnusedProjection(String... variableNames)`
  `final SelectMultiQuery`
  SelectMultiQuery.`addUsedProjection(String... variableNames)`
  `final InsertMultiQuery`
  InsertMultiQuery.`parseData(String data)`
  `final SelectMultiQuery`
  SelectMultiQuery.`parseLimitFilter(String filter)`
  `final SelectMultiQuery`
  SelectMultiQuery.`parseOrderByFilter(String filter)`
  `final SelectMultiQuery`
  SelectMultiQuery.`parseProjection(String projection)`
  `final RequestMultiple`
  RequestMultiple.`parseRoots(String roots)`
  `protected final SelectMultiQuery`
  SelectMultiQuery.`selectSetProjection(com.fasterxml.jackson.databind.JsonNode projectionContent)`
  `final InsertMultiQuery`
  InsertMultiQuery.`setData(com.fasterxml.jackson.databind.JsonNode dataContent)`
  `final DeleteMultiQuery`
  DeleteMultiQuery.`setFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final InsertMultiQuery`
  InsertMultiQuery.`setFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final SelectMultiQuery`
  SelectMultiQuery.`setFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final UpdateMultiQuery`
  UpdateMultiQuery.`setFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final SelectMultiQuery`
  SelectMultiQuery.`setProjection(com.fasterxml.jackson.databind.JsonNode projectionContent)`
  `final SelectMultiQuery`
  SelectMultiQuery.`setUsageProjection(com.fasterxml.jackson.databind.JsonNode projectionContent)`
  `final SelectMultiQuery`
  SelectMultiQuery.`setUsageProjection(String usage)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.builder.request.single

  Methods in fr.gouv.vitam.common.database.builder.request.single that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `final Select`
  Select.`addOrderByAscFilter(String... variableNames)`
  `final Select`
  Select.`addOrderByDescFilter(String... variableNames)`
  `final Select`
  Select.`addOrderByFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final Select`
  Select.`addUnusedProjection(String... variableNames)`
  `final Select`
  Select.`addUsedProjection(String... variableNames)`
  `final Insert`
  Insert.`parseData(String data)`
  `final Select`
  Select.`parseLimitFilter(String filter)`
  `final Select`
  Select.`parseOrderByFilter(String filter)`
  `final Select`
  Select.`parseProjection(String projection)`
  `final Insert`
  Insert.`setData(com.fasterxml.jackson.databind.JsonNode dataContent)`
  `final Delete`
  Delete.`setFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final Select`
  Select.`setFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final Update`
  Update.`setFilter(com.fasterxml.jackson.databind.JsonNode filterContent)`
  `final Select`
  Select.`setProjection(com.fasterxml.jackson.databind.JsonNode projectionContent)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.parser.facet

  Methods in fr.gouv.vitam.common.database.parser.facet that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static final Facet`
  FacetParserHelper.`cardinality(com.fasterxml.jackson.databind.JsonNode facet, VarNameAdapter adapter)`
  Transform facet jsonNode in cardinality Facet object
  `static final Facet`
  FacetParserHelper.`count(com.fasterxml.jackson.databind.JsonNode facet, VarNameAdapter adapter)`
  Transform facet jsonNode in count Facet object
  `static final Facet`
  FacetParserHelper.`dateRange(com.fasterxml.jackson.databind.JsonNode facet, VarNameAdapter adapter)`
  Transform facet jsonNode into a dateRange Facet object
  `static final Facet`
  FacetParserHelper.`filters(com.fasterxml.jackson.databind.JsonNode facet, VarNameAdapter adapter)`
  Transform facet jsonNode in filters Facet object
  `static final Facet`
  FacetParserHelper.`sum(com.fasterxml.jackson.databind.JsonNode facet, VarNameAdapter adapter)`
  Transform facet jsonNode in sum Facet object
  `static final Facet`
  FacetParserHelper.`terms(com.fasterxml.jackson.databind.JsonNode facet, VarNameAdapter adapter)`
  Transform facet jsonNode in terms Facet object

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.parser.query

  Methods in fr.gouv.vitam.common.database.parser.query that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static final Query[]`
  QueryParserHelper.`analyzeArrayCommand(BuilderToken.QUERY query, com.fasterxml.jackson.databind.JsonNode commands, VarNameAdapter adapter)`
  Analyze an array of commands
  `static final CompareQuery`
  QueryParserHelper.`eq(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final ExistsQuery`
  QueryParserHelper.`exists(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final MltQuery`
  QueryParserHelper.`flt(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final BuilderToken.QUERY`
  QueryParserHelper.`getRequestId(String queryroot)`
  Compute the QUERY from command
  `static final CompareQuery`
  QueryParserHelper.`gt(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final CompareQuery`
  QueryParserHelper.`gte(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final InQuery`
  QueryParserHelper.`in(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final ExistsQuery`
  QueryParserHelper.`isNull(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final CompareQuery`
  QueryParserHelper.`lt(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final CompareQuery`
  QueryParserHelper.`lte(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final MatchQuery`
  QueryParserHelper.`match(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final MatchQuery`
  QueryParserHelper.`matchAll(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final MatchQuery`
  QueryParserHelper.`matchPhrase(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final MatchQuery`
  QueryParserHelper.`matchPhrasePrefix(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final ExistsQuery`
  QueryParserHelper.`missing(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final MltQuery`
  QueryParserHelper.`mlt(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final CompareQuery`
  QueryParserHelper.`ne(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final SearchQuery`
  QueryParserHelper.`nestedSearch(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final InQuery`
  QueryParserHelper.`nin(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final Query`
  QueryParserHelper.`query(String refCommand, com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  Transform command to query
  `static final RangeQuery`
  QueryParserHelper.`range(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final SearchQuery`
  QueryParserHelper.`regex(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final SearchQuery`
  QueryParserHelper.`search(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final CompareQuery`
  QueryParserHelper.`size(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final TermQuery`
  QueryParserHelper.`term(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  `static final WildcardQuery`
  QueryParserHelper.`wildcard(com.fasterxml.jackson.databind.JsonNode command, VarNameAdapter adapter)`
  Constructors in fr.gouv.vitam.common.database.parser.query that throw InvalidParseOperationException
  Modifier
  Constructor
  Description
  ``
  `CompareQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `ExistsQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `InQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `MatchQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `MltQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `RangeQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `SearchQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `TermQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `WildcardQuery(BuilderToken.QUERY req, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.parser.query.action

  Methods in fr.gouv.vitam.common.database.parser.query.action that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static final AddAction`
  UpdateActionParserHelper.`add(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final IncAction`
  UpdateActionParserHelper.`inc(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final MaxAction`
  UpdateActionParserHelper.`max(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final MinAction`
  UpdateActionParserHelper.`min(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final PopAction`
  UpdateActionParserHelper.`pop(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final PullAction`
  UpdateActionParserHelper.`pull(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final PushAction`
  UpdateActionParserHelper.`push(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final RenameAction`
  UpdateActionParserHelper.`rename(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final SetAction`
  UpdateActionParserHelper.`set(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final SetregexAction`
  UpdateActionParserHelper.`setregex(com.fasterxml.jackson.databind.JsonNode data, VarNameAdapter adapter)`
  `static final UnsetAction`
  UpdateActionParserHelper.`unset(com.fasterxml.jackson.databind.JsonNode array, VarNameAdapter adapter)`
  Constructors in fr.gouv.vitam.common.database.parser.query.action that throw InvalidParseOperationException
  Modifier
  Constructor
  Description
  ``
  `AddAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `IncAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `MaxAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `MinAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `PopAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `PullAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `PushAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `RenameAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `SetAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  For Parsing
  ``
  `SetregexAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.JsonNode request, VarNameAdapter adapter)`
  parsing
  ``
  `UnsetAction(BuilderToken.UPDATEACTION action, com.fasterxml.jackson.databind.node.ArrayNode request, VarNameAdapter adapter)`
  For Parsing

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.parser.request

  Methods in fr.gouv.vitam.common.database.parser.request that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `protected Query`
  AbstractParser.`analyzeOneCommand(String refCommand, com.fasterxml.jackson.databind.JsonNode command)`
  `protected Facet`
  AbstractParser.`analyzeOneFacet(com.fasterxml.jackson.databind.JsonNode facet, BuilderToken.FACET facetCommand)`
  Generate a Facet from a Json + command
  `static final com.fasterxml.jackson.databind.node.ArrayNode`
  GlobalDatasParser.`getArray(com.fasterxml.jackson.databind.JsonNode value)`
  `static final Object`
  GlobalDatasParser.`getValue(com.fasterxml.jackson.databind.JsonNode value)`
  `abstract void`
  AbstractParser.`parse(com.fasterxml.jackson.databind.JsonNode jsonRequest)`
  `protected void`
  AbstractParser.`parseJson(com.fasterxml.jackson.databind.JsonNode jsonRequest)`
  `protected void`
  AbstractParser.`parseOrderByFilter(com.fasterxml.jackson.databind.JsonNode filterNode)`
  `static final void`
  GlobalDatasParser.`sanityRequestCheck(String arg)`
  Check the Request if conforms to sanity check

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.parser.request.adapter

  Methods in fr.gouv.vitam.common.database.parser.request.adapter that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  VarNameAdapter.`checkNoParameter(com.fasterxml.jackson.databind.JsonNode request)`
  Check if no arguments is using any fix '#' Parameter
  `com.fasterxml.jackson.databind.JsonNode`
  VarNameInsertAdapter.`getFixedVarNameJsonNode(com.fasterxml.jackson.databind.JsonNode rootNode)`
  Check for Insert from Builder
  `String`
  SingleVarNameAdapter.`getVariableName(String name)`
  Return the given MongoDb Variable name
  `String`
  VarNameAdapter.`getVariableName(String name)`
  Return null
  `String`
  VarNameInsertAdapter.`getVariableName(String name)`
  `String`
  VarNameUpdateAdapter.`getVariableName(String name)`
  `void`
  VarNameAdapter.`setVar(BuilderToken.QUERY req, com.fasterxml.jackson.databind.node.ObjectNode currentObject, com.fasterxml.jackson.databind.JsonNode request)`
  Set simple Var (no value)
  `void`
  VarNameAdapter.`setVarArray(com.fasterxml.jackson.databind.node.ArrayNode array)`
  Set an array of Var (no Value)
  `void`
  VarNameAdapter.`setVarsValue(com.fasterxml.jackson.databind.node.ObjectNode currentObject, com.fasterxml.jackson.databind.JsonNode request)`
  Set Vars = Value (Json)

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.parser.request.multiple

  Methods in fr.gouv.vitam.common.database.parser.request.multiple that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `protected void`
  UpdateParserMultiple.`actionParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  {$"action" : args, ...}
  `protected Action`
  UpdateParserMultiple.`analyseOneAction(String refCommand, com.fasterxml.jackson.databind.JsonNode command)`
  `protected Facet`
  SelectParserMultiple.`analyzeOneFacet(com.fasterxml.jackson.databind.JsonNode facet, BuilderToken.FACET facetCommand)`
  Generate a Facet from a Json + command
  `protected void`
  RequestParserMultiple.`analyzeRootQuery(com.fasterxml.jackson.databind.JsonNode command)`
  { expression, $exactdepth : exactdepth, $depth : /- depth }, $exactdepth and $depth being optional (mutual exclusive)
  `protected void`
  InsertParserMultiple.`dataParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  {$data : { field: value, ...
  `protected void`
  SelectParserMultiple.`facetsParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  Parse facets
  `protected void`
  RequestParserMultiple.`filterParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  Filter part
  `static final BuilderToken.FACET`
  SelectParserMultiple.`getFacetCommand(com.fasterxml.jackson.databind.JsonNode facet)`
  Get the facet command
  `static RequestParserMultiple`
  RequestParserHelper.`getParser(com.fasterxml.jackson.databind.JsonNode jsonRequest)`
  Create one Parser for Internal API according to:
  InsertParser if { $roots: root, $query : query, $filter : filter, $data : data}
  UpdateParser if { $roots: root, $query : query, $filter : filter, $action : action }
  SelectParser if { $roots: roots, $query : query, $filter : filter, $projection : projection }
  DeleteParser if { $roots: roots, $query : query, $filter : multi }
  `static RequestParserMultiple`
  RequestParserHelper.`getParser(com.fasterxml.jackson.databind.JsonNode jsonRequest, VarNameAdapter varNameAdapter)`
  Create one Parser for Metadata according to:
  InsertParser if { $roots: root, $query : query, $filter : filter, $data : data}
  UpdateParser if { $roots: root, $query : query, $filter : filter, $action : action }
  SelectParser if { $roots: roots, $query : query, $filter : filter, $projection : projection }
  DeleteParser if { $roots: roots, $query : query, $filter : multi }
  `protected static final BuilderToken.UPDATEACTION`
  UpdateParserMultiple.`getUpdateActionId(String actionroot)`
  Compute the QUERY from command
  `void`
  DeleteParserMultiple.`parse(com.fasterxml.jackson.databind.JsonNode request)`
  `void`
  InsertParserMultiple.`parse(com.fasterxml.jackson.databind.JsonNode request)`
  `void`
  SelectParserMultiple.`parse(com.fasterxml.jackson.databind.JsonNode request)`
  `void`
  UpdateParserMultiple.`parse(com.fasterxml.jackson.databind.JsonNode request)`
  `protected void`
  RequestParserMultiple.`parseJson(com.fasterxml.jackson.databind.JsonNode jsonRequest)`
  `protected void`
  RequestParserMultiple.`parseQueryOnly(String query)`
  `void`
  SelectParserMultiple.`parseQueryOnly(String query)`
  `protected void`
  SelectParserMultiple.`parseTrackTotalHits(com.fasterxml.jackson.databind.JsonNode rootNode)`
  `protected void`
  SelectParserMultiple.`projectionParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  $fields : {name1 : 0/1, name2 : 0/1, ...}, $usage : contractId
  `protected void`
  RequestParserMultiple.`queryParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  [ query, query ] or { query } if one level only
  `protected void`
  RequestParserMultiple.`rootParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  Will be used as extra arguments in the first query
  `protected void`
  UpdateParserMultiple.`setregexParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  `protected void`
  SelectParserMultiple.`thresholdParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  {$"threshold" : arg}
  `protected void`
  UpdateParserMultiple.`thresholdParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  {$"threshold" : arg}

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.parser.request.single

  Methods in fr.gouv.vitam.common.database.parser.request.single that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `protected void`
  UpdateParserSingle.`actionParse(com.fasterxml.jackson.databind.JsonNode actionNode)`
  {$"action" : args, ...}
  `void`
  RequestParserSingle.`addCondition(Query condition)`
  Allow to add one condition to the current parsed Request Example:
  `void`
  SelectParserSingle.`addProjection(com.fasterxml.jackson.databind.node.ObjectNode slice, com.fasterxml.jackson.databind.node.ObjectNode allFields)`
  Add the new Projection slice to the current Projection.
  `protected Action`
  UpdateParserSingle.`analyseOneAction(String refCommand, com.fasterxml.jackson.databind.JsonNode command)`
  `protected void`
  RequestParserSingle.`analyzeRootQuery(com.fasterxml.jackson.databind.JsonNode command)`
  { expression }
  `protected void`
  InsertParserSingle.`dataParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  {$data : [{ field: value, ...
  `protected void`
  SelectParserSingle.`facetsParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  Parse facets
  `protected void`
  RequestParserSingle.`filterParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  Filter part
  `static final BuilderToken.FACET`
  SelectParserSingle.`getFacetCommand(com.fasterxml.jackson.databind.JsonNode facet)`
  Get the facet command
  `static RequestParserSingle`
  RequestParserHelperSingle.`getParser(com.fasterxml.jackson.databind.JsonNode jsonRequest)`
  Create one Parser for Internal API according to:
  InsertParser if { $query : query, $filter : filter, $data : data}
  UpdateParser if { $query : query, $filter : filter, $action : action }
  SelectParser if { $query : query, $filter : filter, $projection : projection }
  DeleteParser if { $query : query, $filter : multi }
  `static RequestParserSingle`
  RequestParserHelperSingle.`getParser(com.fasterxml.jackson.databind.JsonNode jsonRequest, VarNameAdapter varNameAdapter)`
  Create one Parser for Masterdata according to:
  InsertParser if { $query : query, $filter : filter, $data : data}
  UpdateParser if { $query : query, $filter : filter, $action : action }
  SelectParser if { $query : query, $filter : filter, $projection : projection }
  DeleteParser if { $query : query, $filter : multi }
  `protected static final BuilderToken.UPDATEACTION`
  UpdateParserSingle.`getUpdateActionId(String actionroot)`
  Compute the QUERY from command
  `void`
  DeleteParserSingle.`parse(com.fasterxml.jackson.databind.JsonNode request)`
  `void`
  InsertParserSingle.`parse(com.fasterxml.jackson.databind.JsonNode request)`
  `void`
  SelectParserSingle.`parse(com.fasterxml.jackson.databind.JsonNode request)`
  `void`
  UpdateParserSingle.`parse(com.fasterxml.jackson.databind.JsonNode request)`
  `protected void`
  RequestParserSingle.`parseJson(com.fasterxml.jackson.databind.JsonNode jsonRequest)`
  `protected void`
  RequestParserSingle.`parseQueryOnly(String query)`
  `void`
  SelectParserSingle.`parseQueryOnly(String query)`
  `void`
  SelectParserSingle.`projectionParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  $fields : {name1 : 0/1, name2 : 0/1, ...}, $usage : contractId
  `protected void`
  RequestParserSingle.`queryParse(com.fasterxml.jackson.databind.JsonNode rootNode)`
  { query } if one level only

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.server

  Methods in fr.gouv.vitam.common.database.server that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `DbRequestResult`
  DbRequestSingle.`execute(Delete request)`
  `DbRequestResult`
  DbRequestSingle.`execute(Insert request, Integer version, DocumentValidator documentValidator)`
  `DbRequestResult`
  DbRequestSingle.`execute(Select request)`
  `DbRequestResult`
  DbRequestSingle.`execute(Update request, DocumentValidator documentValidator)`
  `DbRequestResult`
  DbRequestSingle.`executeQueryWithoutRestrictionOnCurrentTenant(Select request)`
  `<T extends VitamDocument<T>, V>
  List<V>`
  DbRequestResult.`getDocuments(Class<T> cls, Class<V> clsFromJson)`
  Return directly the clsFomJson items list
  `<T extends VitamDocument<T>, V>
  RequestResponseOK<V>`
  DbRequestResult.`getRequestResponseOK(com.fasterxml.jackson.databind.JsonNode query, Class<T> cls, Class<V> clsFromJson)`
  Return directly a RequestResponseOk from result using clsFromJson class
  `com.fasterxml.jackson.databind.JsonNode`
  MongoDbInMemory.`getUpdateJson(com.fasterxml.jackson.databind.JsonNode request, boolean isMultiple, VarNameAdapter varNameAdapter)`
  Update the originalDocument with the given request.
  `com.fasterxml.jackson.databind.JsonNode`
  MongoDbInMemory.`getUpdateJson(AbstractParser<?> requestParser)`
  Update the originalDocument with the given parser (containing the request)
  `com.fasterxml.jackson.databind.JsonNode`
  MongoDbInMemory.`getUpdateJsonForRule(RuleActions ruleActions, Map<String,DurationData> bindRuleToDuration)`
  Update the originalDocument with the given ruleActions
  `static <T extends VitamDocument<?>>
  com.mongodb.client.MongoCursor<T>`
  DbRequestHelper.`selectMongoDbExecuteThroughFakeMongoCursor(VitamCollection<T> collection, RequestParserSingle parser, List<String> list, List<Double> scores)`
  Private method for select using MongoDb from Elasticsearch result

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.server.mongodb

  Methods in fr.gouv.vitam.common.database.server.mongodb that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static com.fasterxml.jackson.databind.JsonNode`
  BsonHelper.`fromDocumentToJsonNode(org.bson.Document object)`
  Convert bson document to JsonNode
  `static <T> T`
  BsonHelper.`fromDocumentToObject(org.bson.Document document, com.fasterxml.jackson.core.type.TypeReference<T> typeReference)`
  Convert bson document to object
  `static <T> T`
  BsonHelper.`fromDocumentToObject(org.bson.Document document, Class<T> clasz)`
  Convert bson document to object

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.translators.elasticsearch

  Methods in fr.gouv.vitam.common.database.translators.elasticsearch that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static co.elastic.clients.elasticsearch._types.query_dsl.Query`
  QueryToElasticsearch.`getCommand(Query query, VarNameAdapter adapter, DynamicParserTokens parserTokens)`
  `static Map<String,co.elastic.clients.elasticsearch._types.aggregations.Aggregation>`
  QueryToElasticsearch.`getFacets(AbstractParser<?> requestParser, DynamicParserTokens parserTokens)`
  Create ES facets from request parser
  `co.elastic.clients.elasticsearch._types.query_dsl.Query`
  RequestToElasticsearch.`getNthQueries(int nth, VarNameAdapter adapter, DynamicParserTokens parserTokens)`
  find(query)

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.translators.mongodb

  Methods in fr.gouv.vitam.common.database.translators.mongodb that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static org.bson.conversions.Bson`
  QueryToMongodb.`getCommand(Query query)`
  `org.bson.Document`
  InsertToMongodb.`getFinalData()`
  insertOne(data)
  `org.bson.conversions.Bson`
  SelectToMongodb.`getFinalProjection()`
  FindIterable.projection(projection)
  `org.bson.conversions.Bson`
  RequestToMongodb.`getInitialRoots(String field)`
  Additional filter to first request
  `org.bson.conversions.Bson`
  RequestToMongodb.`getNthQueries(int nth)`
  find(query)

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.database.utils

  Methods in fr.gouv.vitam.common.database.utils that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static com.fasterxml.jackson.databind.JsonNode`
  AccessContractRestrictionHelper.`applyAccessContractExceptRuleRestrictionsForObjectGroupForSelect(com.fasterxml.jackson.databind.JsonNode queryDsl, AccessContractModel accessContract)`
  SELECT - OBJECT GROUP (without rule restriction): Apply access contract restriction except rule restrictions for object group for select request
  `static com.fasterxml.jackson.databind.JsonNode`
  AccessContractRestrictionHelper.`applyAccessContractRestrictionForObjectGroupForSelect(com.fasterxml.jackson.databind.JsonNode queryDsl, AccessContractModel accessContract)`
  SELECT - OBJECT GROUP: Apply access contract restriction for object group for select request
  `static com.fasterxml.jackson.databind.JsonNode`
  AccessContractRestrictionHelper.`applyAccessContractRestrictionForUnitForSelect(com.fasterxml.jackson.databind.JsonNode queryDsl, AccessContractModel accessContract)`
  SELECT - UNIT: Apply access contract restriction for archive unit for select request
  `static com.fasterxml.jackson.databind.JsonNode`
  AccessContractRestrictionHelper.`applyAccessContractRestrictionForUnitForUpdate(com.fasterxml.jackson.databind.JsonNode queryDsl, AccessContractModel accessContract)`
  UPDATE - UNIT: Apply access contract restriction for archive unit for update request

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.error

  Methods in fr.gouv.vitam.common.error that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static VitamError<com.fasterxml.jackson.databind.JsonNode>`
  VitamError.`getFromJsonNode(com.fasterxml.jackson.databind.JsonNode node)`
  `static <T> VitamError<T>`
  VitamError.`getFromJsonNode(com.fasterxml.jackson.databind.JsonNode node, Class<T> clasz)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.external.client

  Methods in fr.gouv.vitam.common.external.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  ClientMockResultHelper.`checkOperationTraceability()`
  `static RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  ClientMockResultHelper.`createReponse(String s)`
  `static RequestResponse`
  ClientMockResultHelper.`createReponse(String s, int statuscode)`
  `static RequestResponse`
  ClientMockResultHelper.`getAccessionRegisterDetail()`
  `static RequestResponse`
  ClientMockResultHelper.`getArchiveUnitResult()`
  `static ItemStatus`
  ClientMockResultHelper.`getItemStatus(String id)`
  `static com.fasterxml.jackson.databind.JsonNode`
  ClientMockResultHelper.`getLogbookResults()`
  Deprecated.
  `static RequestResponse`
  ClientMockResultHelper.`getLogbooksRequestResponseJsonNode()`
  Deprecated.
  `static com.fasterxml.jackson.databind.JsonNode`
  ClientMockResultHelper.`getMetaDataResult()`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.json

  Methods in fr.gouv.vitam.common.json that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static Map.Entry<String,com.fasterxml.jackson.databind.JsonNode>`
  JsonHandler.`checkLaxUnicity(String nodeName, com.fasterxml.jackson.databind.JsonNode node)`
  node should have only one property ; simple value is allowed
  `static Map.Entry<String,com.fasterxml.jackson.databind.JsonNode>`
  JsonHandler.`checkUnicity(String nodeName, com.fasterxml.jackson.databind.JsonNode node)`
  node should have only one property
  `static List<String>`
  SchemaValidationUtils.`extractFieldsFromSchema(String schemaJsonAsString)`
  Get fields list declared in schema.
  `static byte[]`
  JsonHandler.`fromPojoToBytes(Object value)`
  `String`
  AbstractJsonType.`generateJsonString()`
  `static com.fasterxml.jackson.databind.JsonNode`
  JsonHandler.`getFromBytes(byte[] value)`
  `static com.fasterxml.jackson.databind.JsonNode`
  JsonHandler.`getFromFile(File file)`
  `static <T> T`
  JsonHandler.`getFromFile(File file, Class<T> clasz)`
  `static <T> T`
  JsonHandler.`getFromFileAsTypeReference(File file, com.fasterxml.jackson.core.type.TypeReference<T> valueTypeRef)`
  `static <T> T`
  JsonHandler.`getFromFileLowerCamelCase(File file, Class<T> clasz)`
  `static com.fasterxml.jackson.databind.JsonNode`
  JsonHandler.`getFromInputStream(InputStream stream)`
  getFromInputStream, get JsonNode from stream
  `static com.fasterxml.jackson.databind.JsonNode`
  JsonHandler.`getFromInputStream(InputStream stream1, InputStream stream2)`
  getFromInputStream, get merged JsonNode from streams
  `static <T> T`
  JsonHandler.`getFromInputStream(InputStream inputStream, Class<T> clasz)`
  `static <T> T`
  JsonHandler.`getFromInputStream(InputStream inputStream, Class<T> clasz, Class<?>... parameterClazz)`
  `static <T> T`
  JsonHandler.`getFromInputStreamAsTypeReference(InputStream inputStream, com.fasterxml.jackson.core.type.TypeReference<T> clasz)`
  `static <T> T`
  JsonHandler.`getFromInputStreamLowerCamelCase(InputStream inputStream, com.fasterxml.jackson.core.type.TypeReference<T> typeReference)`
  `static <T> T`
  JsonHandler.`getFromJsonNode(com.fasterxml.jackson.databind.JsonNode jsonNode, com.fasterxml.jackson.core.type.TypeReference<T> clazz)`
  `static <T> T`
  JsonHandler.`getFromJsonNode(com.fasterxml.jackson.databind.JsonNode jsonNode, Class<?> clasz, Class<?> parameterClazz)`
  `static <T> T`
  JsonHandler.`getFromJsonNode(com.fasterxml.jackson.databind.JsonNode jsonNode, Class<T> clazz)`
  `static <T> List<T>`
  JsonHandler.`getFromJsonNodeList(List<com.fasterxml.jackson.databind.JsonNode> jsonNodes, com.fasterxml.jackson.core.type.TypeReference<T> clazz)`
  `static <T> List<T>`
  JsonHandler.`getFromJsonNodeList(List<com.fasterxml.jackson.databind.JsonNode> jsonNodes, Class<T> clazz)`
  `static <T> T`
  JsonHandler.`getFromJsonNodeLowerCamelCase(com.fasterxml.jackson.databind.JsonNode jsonNode, Class<T> clasz)`
  `static com.fasterxml.jackson.databind.JsonNode`
  JsonHandler.`getFromReader(Reader reader)`
  `static <T> T`
  JsonHandler.`getFromStrictJsonNode(com.fasterxml.jackson.databind.JsonNode jsonNode, com.fasterxml.jackson.core.type.TypeReference<T> clazz)`
  `static com.fasterxml.jackson.databind.JsonNode`
  JsonHandler.`getFromString(String value)`
  `static <T> T`
  JsonHandler.`getFromString(String value, Class<?> clasz, Class<?> parameterClazz)`
  `static <T> T`
  JsonHandler.`getFromString(String value, Class<T> clasz)`
  `static <T> T`
  JsonHandler.`getFromStringAsTypeReference(String value, com.fasterxml.jackson.core.type.TypeReference<T> clasz)`
  `static <T> T`
  JsonHandler.`getFromStringLowerCamelCase(String value, Class<T> clasz)`
  `static Map<String,Object>`
  JsonHandler.`getMapFromInputStream(InputStream inputStream)`
  `static <T> Map<String,T>`
  JsonHandler.`getMapFromInputStream(InputStream inputStream, Class<T> parameterClazz)`
  transform an inputStream into a map of template class
  `static Map<String,Object>`
  JsonHandler.`getMapFromString(String value)`
  `static Map<String,String>`
  JsonHandler.`getMapStringFromString(String value)`
  `static boolean`
  JsonHandler.`isEmpty(String jsonString)`
  Check json string is empty
  `static AbstractJsonType`
  AbstractJsonType.`readJsonFile(File file)`
  `static AbstractJsonType`
  AbstractJsonType.`readJsonString(String data)`
  `static void`
  JsonHandler.`setNodeInPath(com.fasterxml.jackson.databind.node.ObjectNode node, String nodePath, com.fasterxml.jackson.databind.JsonNode value, boolean canCreate)`
  Set a value in a node defined by the given path.
  `static com.fasterxml.jackson.databind.JsonNode`
  JsonHandler.`toJsonNode(Object object)`
  `static void`
  JsonHandler.`validate(String value)`
  `static void`
  JsonHandler.`writeAsFile(Object object, File file)`
  `static void`
  JsonHandler.`writeAsOutputStream(Object object, OutputStream outputStream)`
  `static String`
  JsonHandler.`writeAsString(Object object)`
  `void`
  AbstractJsonType.`writeJsonToFile(File file)`
  `static InputStream`
  JsonHandler.`writeToInpustream(Object object)`
  `static byte[]`
  JsonHandler.`writeValueAsBytes(com.fasterxml.jackson.databind.JsonNode json)`
  writeValueAsBytes, from Json to byte[]

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.model

  Methods in fr.gouv.vitam.common.model that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static RequestResponseOK<com.fasterxml.jackson.databind.JsonNode>`
  RequestResponseOK.`getFromJsonNode(com.fasterxml.jackson.databind.JsonNode node)`
  `static <T> RequestResponseOK<T>`
  RequestResponseOK.`getFromJsonNode(com.fasterxml.jackson.databind.JsonNode node, Class<T> clazz)`
  `List<com.fasterxml.jackson.databind.JsonNode>`
  RequestResponseOK.`getResultsAsJsonNodes()`
  `static RequestResponseOK<com.fasterxml.jackson.databind.JsonNode>`
  RequestResponse.`parseRequestResponseOk(jakarta.ws.rs.core.Response response)`
  `static <T> RequestResponseOK<T>`
  RequestResponse.`parseRequestResponseOk(jakarta.ws.rs.core.Response response, Class<T> clasz)`
  `static VitamError<com.fasterxml.jackson.databind.JsonNode>`
  RequestResponse.`parseVitamError(jakarta.ws.rs.core.Response response)`
  `static <T> VitamError<T>`
  RequestResponse.`parseVitamError(jakarta.ws.rs.core.Response response, Class<T> clasz)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.security

  Methods in fr.gouv.vitam.common.security that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static void`
  SanityChecker.`checkHeaders(jakarta.ws.rs.core.HttpHeaders headers)`
  checkHeaders : Check sanity of Headers: no javascript/xml tag, neither html tag
  `static void`
  SanityChecker.`checkHeadersMap(jakarta.ws.rs.core.MultivaluedMap<String,String> requestHeaders)`
  Checks sanity of Headers: no javascript/xml tag, neither html tag
  `static void`
  SanityChecker.`checkHTMLFile(File file)`
  checkHTMLFile : Check if the file contains HTML content
  `static void`
  SanityChecker.`checkJsonAll(com.fasterxml.jackson.databind.JsonNode json)`
  checkJsonAll : Check sanity of json : size, invalid tag
  `static void`
  SanityChecker.`checkJsonAll(String json)`
  checkJsonAll : Check sanity of json : size, invalid tag
  `static void`
  SanityChecker.`checkJsonFile(File jsonlFile)`
  `static void`
  SanityChecker.`checkJsonLines(File jsonlFile)`
  `protected static void`
  SanityChecker.`checkJsonSanity(com.fasterxml.jackson.databind.JsonNode json)`
  checkJsonSanity : check sanity of json and find invalid key
  `static void`
  SanityChecker.`checkParameter(String... params)`
  checkParameter : Check sanity of String: no javascript/xml tag, neither html tag
  `static void`
  SanityChecker.`checkUriParametersMap(jakarta.ws.rs.core.MultivaluedMap<String,String> uriParameters)`
  Checks sanity of Headers: no javascript/xml tag, neither html tag
  `static void`
  SanityChecker.`checkXmlAll(File xmlFile)`
  checkXMLAll : check xml sanity all aspect : size, tag size, invalid tag
  `protected static void`
  SanityChecker.`checkXmlSanityFileSize(File xmlFile)`
  CheckXMLSanityFileSize : check size of xml file
  `protected static void`
  SanityChecker.`checkXmlSanityTags(File xmlFile)`
  CheckXMLSanityTags : check invalid tag contains of a xml file
  `protected static void`
  SanityChecker.`checkXmlSanityTagValueSize(File xmlFile)`
  check XML Sanity Tag and Value Size
  `static String`
  SanityChecker.`sanitizeJson(com.fasterxml.jackson.databind.JsonNode json)`
  Sabitize the json

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.common.server.application.resources

  Methods in fr.gouv.vitam.common.server.application.resources that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `com.fasterxml.jackson.databind.node.ObjectNode`
  BasicVitamStatusServiceImpl.`getAdminStatus()`
  `com.fasterxml.jackson.databind.node.ObjectNode`
  VitamStatusService.`getAdminStatus()`
  getAdminStatus return the overall status of this component with the constraint delay of less than 10ms and shall return by default empty JsonNode.

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.client

  Methods in fr.gouv.vitam.functional.administration.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponse<AccessionRegisterSymbolic>`
  AdminManagementClient.`createAccessionRegisterSymbolic(List<Integer> tenants)`
  Creates and return the accession register symbolic.
  `RequestResponse`
  AdminManagementClient.`createArchiveUnitProfiles(List<ArchiveUnitProfileModel> archiveUnitProfileModelList)`
  Import a set of archive unit profile metadata.
  `RequestResponse`
  AdminManagementClientMock.`createArchiveUnitProfiles(List<ArchiveUnitProfileModel> archiveUnitProfileModelList)`
  `RequestResponse`
  AdminManagementClient.`createProfiles(List<ProfileModel> profileModelList)`
  Import a set of profile If all the profiles are valid, they will be stored in the collection and indexed The input is invalid in the following situations : The json is invalid The json contains 2 ore many profile having the same name One or more mandatory field is missing A field has an invalid format One or many profiles already exist in the database
  `RequestResponse`
  AdminManagementClientMock.`createProfiles(List<ProfileModel> profileModelList)`
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClient.`deleteUnitExternalSchemas(List<String> paths)`
  Delete one or more external schemas by path(s)
  `RequestResponse<AccessContractModel>`
  AdminManagementClient.`findAccessContracts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Find access contracts By id mongo By the name By comlexe criteria
  `RequestResponse`
  AdminManagementClientMock.`findAccessContracts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<AccessContractModel>`
  AdminManagementClient.`findAccessContractsByID(String documentId)`
  `RequestResponse`
  AdminManagementClientMock.`findAccessContractsByID(String documentId)`
  `RequestResponse<ArchiveUnitProfileModel>`
  AdminManagementClient.`findArchiveUnitProfiles(com.fasterxml.jackson.databind.JsonNode query)`
  Find profiles according to the given json query (we can also use this method to find profile by identifier)
  `RequestResponse<ArchiveUnitProfileModel>`
  AdminManagementClientMock.`findArchiveUnitProfiles(com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<ArchiveUnitProfileModel>`
  AdminManagementClient.`findArchiveUnitProfilesByID(String id)`
  Find archive unit profile by technical id (id generated by the database)
  `RequestResponse<ArchiveUnitProfileModel>`
  AdminManagementClientMock.`findArchiveUnitProfilesByID(String requestedId)`
  `RequestResponse<ContextModel>`
  AdminManagementClient.`findContextById(String id)`
  Find context by id
  `RequestResponse<ContextModel>`
  AdminManagementClientMock.`findContextById(String id)`
  `RequestResponse<ContextModel>`
  AdminManagementClient.`findContexts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Find contexts
  `RequestResponse<ContextModel>`
  AdminManagementClientMock.`findContexts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<GriffinModel>`
  AdminManagementClient.`findGriffin(com.fasterxml.jackson.databind.JsonNode dslQuery)`
  `RequestResponse<GriffinModel>`
  AdminManagementClient.`findGriffinByID(String id)`
  `RequestResponse<GriffinModel>`
  AdminManagementClientMock.`findGriffinByID(String id)`
  `RequestResponse<IngestContractModel>`
  AdminManagementClient.`findIngestContracts(com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<IngestContractModel>`
  AdminManagementClientMock.`findIngestContracts(com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<IngestContractModel>`
  AdminManagementClient.`findIngestContractsByID(String id)`
  `RequestResponse<IngestContractModel>`
  AdminManagementClientMock.`findIngestContractsByID(String id)`
  `RequestResponse<ManagementContractModel>`
  AdminManagementClient.`findManagementContracts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Find management contracts By id mongo By the name By comlexe criteria
  `RequestResponse`
  AdminManagementClientMock.`findManagementContracts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<ManagementContractModel>`
  AdminManagementClient.`findManagementContractsByID(String documentId)`
  `RequestResponse`
  AdminManagementClientMock.`findManagementContractsByID(String documentId)`
  `RequestResponse<OntologyModel>`
  AdminManagementClient.`findOntologies(com.fasterxml.jackson.databind.JsonNode query)`
  Find ontologies according to the given json query (we can also use this method to find ontology by identifier)
  `RequestResponse<OntologyModel>`
  AdminManagementClientMock.`findOntologies(com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<OntologyModel>`
  AdminManagementClient.`findOntologyByID(String id)`
  Find the ontology by technical id (id generated by the database)
  `RequestResponse<OntologyModel>`
  AdminManagementClientMock.`findOntologyByID(String requestedId)`
  `RequestResponse<PreservationScenarioModel>`
  AdminManagementClient.`findPreservation(com.fasterxml.jackson.databind.JsonNode dslQuery)`
  `RequestResponse<PreservationScenarioModel>`
  AdminManagementClientMock.`findPreservation(com.fasterxml.jackson.databind.JsonNode dslQuery)`
  `RequestResponse<PreservationScenarioModel>`
  AdminManagementClient.`findPreservationByID(String id)`
  `RequestResponse<PreservationScenarioModel>`
  AdminManagementClientMock.`findPreservationByID(String id)`
  `RequestResponse<ProfileModel>`
  AdminManagementClient.`findProfiles(com.fasterxml.jackson.databind.JsonNode query)`
  Find profiles according to the given query string (we can also use this method to find profile by identifier)
  `RequestResponse<ProfileModel>`
  AdminManagementClientMock.`findProfiles(com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<ProfileModel>`
  AdminManagementClient.`findProfilesByID(String id)`
  Find profile by id (id generated by the database)
  `RequestResponse<ProfileModel>`
  AdminManagementClientMock.`findProfilesByID(String id)`
  `RequestResponse<SecurityProfileModel>`
  AdminManagementClient.`findSecurityProfileByIdentifier(String identifier)`
  Find a security profile by identifier
  `RequestResponse`
  AdminManagementClientMock.`findSecurityProfileByIdentifier(String identifier)`
  `RequestResponse<SecurityProfileModel>`
  AdminManagementClient.`findSecurityProfiles(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Find security profiles by DSL query By internal id By identifier By name By comlexe criteria
  `RequestResponse`
  AdminManagementClientMock.`findSecurityProfiles(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<AccessionRegisterSummaryModel>`
  AdminManagementClient.`getAccessionRegister(com.fasterxml.jackson.databind.JsonNode query)`
  Get the accession register summary matching the given query
  `RequestResponse`
  AdminManagementClientMock.`getAccessionRegister(com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<AccessionRegisterDetailModel>`
  AdminManagementClient.`getAccessionRegisterDetail(com.fasterxml.jackson.databind.JsonNode query)`
  Get the accession register details matching the given query
  `RequestResponse<AccessionRegisterDetailModel>`
  AdminManagementClient.`getAccessionRegisterDetail(String originatingAgency, com.fasterxml.jackson.databind.JsonNode query)`
  Get the accession register details matching the given query for the specified contract
  `RequestResponse`
  AdminManagementClientMock.`getAccessionRegisterDetail(String originatingAgency, com.fasterxml.jackson.databind.JsonNode query)`
  `com.fasterxml.jackson.databind.JsonNode`
  AdminManagementClient.`getAgencies(com.fasterxml.jackson.databind.JsonNode query)`
  List the agencies that match the query
  `com.fasterxml.jackson.databind.JsonNode`
  AdminManagementClientMock.`getAgencies(com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<AgenciesModel>`
  AdminManagementClient.`getAgencyById(String id)`
  `RequestResponse<AgenciesModel>`
  AdminManagementClientMock.`getAgencyById(String id)`
  `com.fasterxml.jackson.databind.JsonNode`
  AdminManagementClient.`getFormatByID(String id)`
  `com.fasterxml.jackson.databind.JsonNode`
  AdminManagementClientMock.`getFormatByID(String id)`
  `RequestResponse<FileFormatModel>`
  AdminManagementClient.`getFormats(com.fasterxml.jackson.databind.JsonNode query)`
  `RequestResponse<FileFormatModel>`
  AdminManagementClientMock.`getFormats(com.fasterxml.jackson.databind.JsonNode query)`
  `com.fasterxml.jackson.databind.JsonNode`
  AdminManagementClient.`getRuleByID(String id)`
  `com.fasterxml.jackson.databind.JsonNode`
  AdminManagementClientMock.`getRuleByID(String id)`
  `com.fasterxml.jackson.databind.JsonNode`
  AdminManagementClient.`getRules(com.fasterxml.jackson.databind.JsonNode query)`
  List the rules that match the query
  `com.fasterxml.jackson.databind.JsonNode`
  AdminManagementClientMock.`getRules(com.fasterxml.jackson.databind.JsonNode query)`
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClient.`importAccessContracts(List<AccessContractModel> accessContractModelList)`
  Import a set of access contracts after passing the validation steps If all the contracts are valid, they are stored in the collection and indexed The input is invalid in the following situations : The json is invalid The json have an id already set The json contains 2 ore many contracts having the same name One or more mandatory field is missing A field has an invalid format One or many contracts Already exist in the database
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClientMock.`importAccessContracts(List<AccessContractModel> accessContractModelList)`
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClient.`importIngestContracts(List<IngestContractModel> ingestContractModelList)`
  Import a set of ingest contracts after passing the validation steps If all the contracts are valid, they are stored in the collection and indexed The input is invalid in the following situations : The json is invalid The json contains 2 ore many contracts having the same name One or more mandatory field is missing A field has an invalid format One or many contracts elready exist in the database
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClient.`importManagementContracts(List<ManagementContractModel> managementContractModelList)`
  Import a set of management contracts after passing the validation steps If all the contracts are valid, they are stored in the collection and indexed The input is invalid in the following situations : The json is invalid The json have an id already set The json contains 2 ore many contracts having the same name One or more mandatory field is missing A field has an invalid format One or many contracts Already exist in the database One or many storage strategies are invalid
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClientMock.`importManagementContracts(List<ManagementContractModel> accessContractModelList)`
  `RequestResponse`
  AdminManagementClient.`importOntologies(boolean forceUpdate, List<OntologyModel> ontologyModelList)`
  Import a set of ontologies metadata.
  `RequestResponse`
  AdminManagementClientMock.`importOntologies(boolean forceUpdate, List<OntologyModel> ontologyModelList)`
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClient.`importSecurityProfiles(List<SecurityProfileModel> securityProfileModelList)`
  Import a set of security profiles after passing the validation steps.
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClientMock.`importSecurityProfiles(List<SecurityProfileModel> securityProfileModelList)`
  `jakarta.ws.rs.core.Response.Status`
  AdminManagementClient.`importUnitExternalSchema(List<SchemaInputModel> externalSchemaInputList)`
  Import a set of external unit schema.
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  AdminManagementClient.`launchRuleAudit(List<Integer> tenants)`
  launch audit for rule management
  `RequestResponse<Boolean>`
  AdminManagementClient.`securityProfileIsUsedInContexts(String securityProfileId)`
  Find if security profile is used in contexts
  `RequestResponse<Boolean>`
  AdminManagementClientMock.`securityProfileIsUsedInContexts(String securityProfileId)`
  `RequestResponse<AccessContractModel>`
  AdminManagementClient.`updateAccessContract(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update AccessContract to mongo
  `RequestResponse<AccessContractModel>`
  AdminManagementClientMock.`updateAccessContract(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<ArchiveUnitProfileModel>`
  AdminManagementClient.`updateArchiveUnitProfile(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update a profile
  `RequestResponse<ArchiveUnitProfileModel>`
  AdminManagementClientMock.`updateArchiveUnitProfile(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<ContextModel>`
  AdminManagementClient.`updateContext(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update context to mongo
  `RequestResponse<ContextModel>`
  AdminManagementClientMock.`updateContext(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<IngestContractModel>`
  AdminManagementClient.`updateIngestContract(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update IngestContract to mongo
  `RequestResponse<IngestContractModel>`
  AdminManagementClientMock.`updateIngestContract(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<ManagementContractModel>`
  AdminManagementClient.`updateManagementContract(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update ManagementContract to mongo
  `RequestResponse<ManagementContractModel>`
  AdminManagementClientMock.`updateManagementContract(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<ProfileModel>`
  AdminManagementClient.`updateProfile(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Update a profile
  `RequestResponse<ProfileModel>`
  AdminManagementClientMock.`updateProfile(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<SecurityProfileModel>`
  AdminManagementClient.`updateSecurityProfile(String identifier, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Updates a security context
  `RequestResponse<SecurityProfileModel>`
  AdminManagementClientMock.`updateSecurityProfile(String identifier, com.fasterxml.jackson.databind.JsonNode queryDsl)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.common

  Methods in fr.gouv.vitam.functional.administration.common that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static void`
  ReferentialFileUtils.`addFilenameInLogbookOperation(String filename, LogbookOperationParameters logbookParameters)`
  Add into a logbookOperation's evDetdata the filename information.

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.common.utils

  Methods in fr.gouv.vitam.functional.administration.common.utils that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static String`
  ArchiveUnitUpdateUtils.`getDiffMessageFor(com.fasterxml.jackson.databind.JsonNode diff, String unitId)`
  Common method to get the diff message

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.accession.register

  Methods in fr.gouv.vitam.functional.administration.core.accession.register that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponseOK<AccessionRegisterSymbolicModel>`
  ReferentialAccessionRegisterImpl.`findAccessionRegisterSymbolic(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Find the accession register symbolic filtered by the query dsl, if an empty query dsl is provided, the last 20 accession register symbolics will be returned.

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.archiveunitprofiles

  Methods in fr.gouv.vitam.functional.administration.core.archiveunitprofiles that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponseOK<ArchiveUnitProfileModel>`
  ArchiveUnitProfileService.`findArchiveUnitProfiles(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  find archive unit profiles by QueryDsl
  `RequestResponseOK<ArchiveUnitProfileModel>`
  ArchiveUnitProfileServiceImpl.`findArchiveUnitProfiles(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `ArchiveUnitProfileModel`
  ArchiveUnitProfileServiceImpl.`findByIdentifier(String id)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.archiveunitprofilesSchema

  Methods in fr.gouv.vitam.functional.administration.core.archiveunitprofilesSchema that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `List<CombinedSchemaModel>`
  ArchiveUnitProfileSchemaServiceImpl.`getCombinedSchemaModels(ArchiveUnitProfileModel profile, List<SchemaResponse> schemas)`
  `List<CombinedSchemaModel>`
  ArchiveUnitProfileSchemaService.`getCombinedSchemaModelsById(String identifier)`
  find archive unit profiles by QueryDsl
  `List<CombinedSchemaModel>`
  ArchiveUnitProfileSchemaServiceImpl.`getCombinedSchemaModelsById(String identifier)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.audit

  Methods in fr.gouv.vitam.functional.administration.core.audit that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  ReferentialAuditService.`runAudit(String collectionName, int tenant)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.backup

  Methods in fr.gouv.vitam.functional.administration.core.backup that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `com.fasterxml.jackson.databind.node.ArrayNode`
  FunctionalBackupService.`getCollectionInJson(com.mongodb.client.MongoCursor<org.bson.Document> mongoCursor)`
  transfer the collection to json
  `com.fasterxml.jackson.databind.node.ArrayNode`
  FunctionalBackupService.`getCollectionInJson(FunctionalAdminCollections collections, int tenant)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.context

  Methods in fr.gouv.vitam.functional.administration.core.context that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `DbRequestResult`
  ContextService.`findContexts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  Search for contexts
  `ContextModel`
  ContextService.`findOneContextById(String id)`
  Find a context by its id
  `ContextModel`
  ContextServiceImpl.`findOneContextById(String id)`
  `boolean`
  ContextService.`securityProfileIsUsedInContexts(String securityProfileId)`
  `boolean`
  ContextServiceImpl.`securityProfileIsUsedInContexts(String securityProfileId)`
  `List<ContextValidator.ContextRejectionCause>`
  ContextValidator.`validate(ContextModel context)`
  Validate a context object

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.contract

  Methods in fr.gouv.vitam.functional.administration.core.contract that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `AccessContractModel`
  AccessContractImpl.`findByIdentifier(String identifier)`
  `static DbRequestResult`
  ContractHelper.`findByIdentifier(String identifier, FunctionalAdminCollections collection, MongoDbAccessReferential mongoAccess)`
  Find contracts by idenfier
  `T`
  ContractService.`findByIdentifier(String identifier)`
  Find contract by identifier
  `IngestContractModel`
  IngestContractImpl.`findByIdentifier(String identifier)`
  `ManagementContractModel`
  ManagementContractImpl.`findByIdentifier(String identifier)`
  `RequestResponseOK<AccessContractModel>`
  AccessContractImpl.`findContracts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponseOK<T>`
  ContractService.`findContracts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  find contract by QueryDsl
  `RequestResponseOK<IngestContractModel>`
  IngestContractImpl.`findContracts(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponseOK<ManagementContractModel>`
  ManagementContractImpl.`findContracts(com.fasterxml.jackson.databind.JsonNode queryDsl)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.griffin

  Methods in fr.gouv.vitam.functional.administration.core.griffin that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponse<GriffinModel>`
  GriffinService.`findGriffin(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponse<PreservationScenarioModel>`
  PreservationScenarioService.`findPreservationScenario(com.fasterxml.jackson.databind.JsonNode queryDsl)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.ontologies

  Methods in fr.gouv.vitam.functional.administration.core.ontologies that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponseOK<OntologyModel>`
  OntologyService.`findOntologies(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  find an ontology by QueryDsl
  `RequestResponseOK<OntologyModel>`
  OntologyServiceImpl.`findOntologies(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  `RequestResponseOK<OntologyModel>`
  OntologyService.`findOntologiesForCache(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  find an ontology by QueryDsl (find directly in db)
  `RequestResponseOK<OntologyModel>`
  OntologyServiceImpl.`findOntologiesForCache(com.fasterxml.jackson.databind.JsonNode queryDsl)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.profile

  Methods in fr.gouv.vitam.functional.administration.core.profile that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `jakarta.ws.rs.core.Response`
  ProfileService.`downloadProfileFile(String profileIdentifier)`
  download file corresponding to profileIdentifier
  `jakarta.ws.rs.core.Response`
  ProfileServiceImpl.`downloadProfileFile(String profileIdentifier)`
  `ProfileModel`
  ProfileService.`findByIdentifier(String identifier)`
  Find profile by identifier
  `ProfileModel`
  ProfileServiceImpl.`findByIdentifier(String identifier)`
  `RequestResponseOK<ProfileModel>`
  ProfileService.`findProfiles(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  find Profile by QueryDsl
  `RequestResponseOK<ProfileModel>`
  ProfileServiceImpl.`findProfiles(com.fasterxml.jackson.databind.JsonNode queryDsl)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.rules

  Methods in fr.gouv.vitam.functional.administration.core.rules that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  RulesManagerFileImpl.`importFile(InputStream rulesFileStream, String filename)`
  `Map<String,FileRulesModel>`
  RulesManagerFileImpl.`processRuleParsing(File file, String filename, GUID eip)`
  `void`
  LogbookRuleImportManager.`updateStpImportRulesLogbookOperation(GUID eip, StatusCode status, String filename)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.schema

  Methods in fr.gouv.vitam.functional.administration.core.schema that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `List<SchemaResponse>`
  SchemaService.`findObjectGroupInternalSchema()`
  Retrieve Object group schema list
  `List<SchemaResponse>`
  SchemaService.`findUnitInternalSchema()`
  Retrieve the schema list for unit collection
  `List<SchemaResponse>`
  SchemaService.`findUnitSchema()`
  Retrieve internal and external schema list

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functional.administration.core.security.profile

  Methods in fr.gouv.vitam.functional.administration.core.security.profile that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `Optional<SecurityProfileModel>`
  SecurityProfileService.`findOneByIdentifier(String identifier)`
  `RequestResponseOK<SecurityProfileModel>`
  SecurityProfileService.`findSecurityProfiles(com.fasterxml.jackson.databind.JsonNode queryDsl)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.functionaltest.cucumber.step

  Methods in fr.gouv.vitam.functionaltest.cucumber.step that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  CollectStep.`checkOperationProject(String action)`
  Check result of action
  `void`
  ArchiveUnitProfileStep.`create_profile()`
  `void`
  ProfileStep.`create_profile()`
  `void`
  ProfileStep.`create_profile_ignoring_failure()`
  `void`
  ProfileStep.`create_profile_with_expected_failure()`
  `void`
  ContextStep.`fail_upload_context()`
  `void`
  SecurityProfileStep.`fail_upload_security_profile()`
  `void`
  ContextStep.`find_a_context_id(String name)`
  `void`
  OntologyStep.`forceImportOntology()`
  `void`
  SecurityProfileStep.`has_full_access()`
  `void`
  SecurityProfileStep.`has_not_permission(String permission)`
  `void`
  SecurityProfileStep.`has_permission(String permission)`
  `void`
  ProfileStep.`import_profile()`
  `void`
  ProfileStep.`import_profile_ignoring_failure()`
  `void`
  ProfileStep.`import_profile_with_expected_failure()`
  `void`
  SchemaStep.`importExternalSchema()`
  `void`
  OntologyStep.`importOntology()`
  `void`
  SchemaStep.`schema_should_be_deleted(String path)`
  `void`
  AgenciesStep.`search_contracts(String name)`
  `void`
  ContractsStep.`search_contracts(String type, String name)`
  `void`
  ArchiveUnitProfileStep.`search_profiles(String name)`
  `void`
  ProfileStep.`search_profiles(String name)`
  `void`
  PreservationStep.`searchGriffinById(String identifier)`
  `void`
  ContextStep.`success_upload_context()`
  `void`
  SecurityProfileStep.`success_upload_security_profile()`
  `void`
  LogbookStep.`the_final_logbook_event_has_message(String field, String message)`
  `void`
  LogbookCheckConsistencyStep.`the_logbook_consistency_check_report_does_not_contain_errors()`
  `void`
  LogbookStep.`the_results_are(String eventName, String eventResults)`
  check if the outcome detail is valid for an event type according to logbook
  `void`
  LogbookStep.`the_status_are(String eventNamesStr, String eventStatus)`
  check if the status is valid for a list of event type according to logbook
  `void`
  ContractsStep.`update_access_contract(Integer statusCode)`
  `void`
  ContextStep.`update_context_by_identifier_query(String contextIdentifier, Integer status)`
  `void`
  ContextStep.`update_context_by_name_query(String name, Integer status)`
  `void`
  ContractsStep.`update_contract_by_query(String type, String queryFilename, Integer statusCode)`
  `void`
  SecurityProfileStep.`update_security_profile_by_query(String queryFilename, Integer statusCode)`
  `static void`
  ContractsStep.`updateContext(AdminExternalClient adminExternalClient, String applicationSessionId, String contextIdentifier, List<PermissionModel> permissions, Boolean expectedSuccessStatus)`
  `void`
  PreservationStep.`verifyBinaryIfNotGenerated(String qualifierParam)`
  `void`
  PreservationStep.`verifyIfTypeBinaryHasBeenGenerated(String qualifierParam, String type)`
  Constructors in fr.gouv.vitam.functionaltest.cucumber.step that throw InvalidParseOperationException
  Modifier
  Constructor
  Description
  ``
  `StorageStep(World world)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.ihmdemo.common.pagination

  Methods in fr.gouv.vitam.ihmdemo.common.pagination that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `com.fasterxml.jackson.databind.JsonNode`
  PaginationHelper.`paginate(com.fasterxml.jackson.databind.node.ObjectNode result, OffsetBasedPagination pagination)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.ihmdemo.core

  Methods in fr.gouv.vitam.ihmdemo.core that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  UserInterfaceTransactionManager.`checkTraceabilityOperation(com.fasterxml.jackson.databind.JsonNode query, VitamContext context)`
  Starts a Verification process based on a given DSLQuery
  `com.fasterxml.jackson.databind.JsonNode`
  DslQueryHelper.`createGetByIdDSLSelectMultipleQuery(Map<String,String> projectionCriteriaMap)`
  Create GetById Select Multiple Query Dsl request that contains only projection.
  `com.fasterxml.jackson.databind.JsonNode`
  DslQueryHelper.`createSelectDSLQuery(Map<String,String> searchCriteriaMap)`
  `com.fasterxml.jackson.databind.JsonNode`
  DslQueryHelper.`createSelectElasticsearchDSLQuery(Map<String,Object> searchCriteriaMap)`
  `com.fasterxml.jackson.databind.JsonNode`
  DslQueryHelper.`createSingleQueryDSL(Map<String,Object> searchCriteriaMap)`
  generate the DSL query after receiving the search criteria
  `com.fasterxml.jackson.databind.JsonNode`
  DslQueryHelper.`createUpdateByIdDSLQuery(Map<String,com.fasterxml.jackson.databind.JsonNode> searchCriteriaMap, Map<String,com.fasterxml.jackson.databind.JsonNode> updateRules)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  UserInterfaceTransactionManager.`findAccessionRegisterDetail(String originatingAgency, String options, VitamContext context)`
  `RequestResponse<AccessionRegisterSummaryModel>`
  UserInterfaceTransactionManager.`findAccessionRegisterSummary(String options, VitamContext context)`
  `RequestResponse<AccessionRegisterSymbolicModel>`
  UserInterfaceTransactionManager.`findAccessionRegisterSymbolic(String options, VitamContext context)`
  `UpdateMultiQuery`
  DslQueryHelper.`getFullMetadataActionQuery(com.fasterxml.jackson.databind.JsonNode metadataModifications)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.ingest.internal.client

  Methods in fr.gouv.vitam.ingest.internal.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `jakarta.ws.rs.core.Response`
  IngestInternalClient.`downloadObjectAsync(String objectId, IngestCollection type)`
  Download object stored by ingest operation

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.logbook.administration.core

  Methods in fr.gouv.vitam.logbook.administration.core that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `String`
  LogbookOperationTraceabilityHelper.`getPreviousMonthStartDate()`
  `byte[]`
  LogbookOperationTraceabilityHelper.`getPreviousMonthTimestampToken()`
  `String`
  LogbookOperationTraceabilityHelper.`getPreviousStartDate()`
  `byte[]`
  LogbookOperationTraceabilityHelper.`getPreviousTimestampToken()`
  `String`
  LogbookOperationTraceabilityHelper.`getPreviousYearStartDate()`
  `byte[]`
  LogbookOperationTraceabilityHelper.`getPreviousYearTimestampToken()`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.logbook.common.traceability

  Methods in fr.gouv.vitam.logbook.common.traceability that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `String`
  LogbookTraceabilityHelper.`getPreviousMonthStartDate()`
  Get the first traceability (in logbook) one month before the given currentDate and return the startDate of the entry
  `byte[]`
  LogbookTraceabilityHelper.`getPreviousMonthTimestampToken()`
  Get the first traceability (in logbook) one month before the given currentDate and return the timestampToken of the entry
  `String`
  LogbookTraceabilityHelper.`getPreviousStartDate()`
  Get the last traceability (in logbook) event and return the startDate of the entry
  `byte[]`
  LogbookTraceabilityHelper.`getPreviousTimestampToken()`
  Get the last traceability (in logbook) event and return the timestampToken of the entry
  `String`
  LogbookTraceabilityHelper.`getPreviousYearStartDate()`
  Get the first traceability (in logbook) one year before the given currentDate and return the startDate of the entry
  `byte[]`
  LogbookTraceabilityHelper.`getPreviousYearTimestampToken()`
  Get the first traceability (in logbook) one year before the given currentDate and return the timestampToken of the entry

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.logbook.lifecycles.api

  Methods in fr.gouv.vitam.logbook.lifecycles.api that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCycles.`getRawObjectGroupLifeCycleById(String id)`
  returns the raw version of object group life cycle
  `List<com.fasterxml.jackson.databind.JsonNode>`
  LogbookLifeCycles.`getRawObjectGroupLifeCycleByIds(List<String> ids)`
  returns the raw version of object group life cycle
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCycles.`getRawUnitLifeCycleById(String id)`
  returns the raw version of unit life cycle
  `List<com.fasterxml.jackson.databind.JsonNode>`
  LogbookLifeCycles.`getRawUnitLifeCycleByIds(List<String> ids)`
  returns the raw version of unit life cycle
  `LogbookLifeCycle<?>`
  LogbookLifeCycles.`selectLifeCycleById(String lifecycleId, com.fasterxml.jackson.databind.JsonNode queryDsl, boolean sliced, LogbookCollections collection)`
  Selects life cycle entry
  `List<LogbookLifeCycle<?>>`
  LogbookLifeCycles.`selectLifeCycles(com.fasterxml.jackson.databind.JsonNode select, boolean sliced, LogbookCollections collection)`
  Selects life cycle entries

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.logbook.lifecycles.client

  Methods in fr.gouv.vitam.logbook.lifecycles.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `InputStream`
  LogbookLifeCyclesClient.`exportRawObjectGroupLifecyclesByLastPersistedDate(LocalDateTime startDate, LocalDateTime endDate, int maxEntries)`
  Exports raw object group lifecycles by last persisted date range Warning: If maxEntries limit reached, lifecycles with exact same last persisted date will also be exported.
  `InputStream`
  LogbookLifeCyclesClient.`exportRawUnitLifecyclesByLastPersistedDate(LocalDateTime startDate, LocalDateTime endDate, int maxEntries)`
  Exports raw unit lifecycles by last persisted date range.
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`getRawObjectGroupLifeCycleById(String id)`
  returns the raw object group life cycle
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`getRawUnitLifeCycleById(String id)`
  returns the raw unit life cycle
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`selectObjectGroupLifeCycle(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  returns the object group life cycles
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`selectObjectGroupLifeCycle(com.fasterxml.jackson.databind.JsonNode queryDsl, LifeCycleStatusCode lifeCycleStatus)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`selectObjectGroupLifeCycleById(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  returns the object group life cycle
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`selectObjectGroupLifeCycleById(String id, com.fasterxml.jackson.databind.JsonNode queryDsl, LifeCycleStatusCode lifeCycleStatus)`
  returns the object group life cycle
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`selectUnitLifeCycle(com.fasterxml.jackson.databind.JsonNode queryDsl)`
  returns the unit life cycle
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`selectUnitLifeCycleById(String id, com.fasterxml.jackson.databind.JsonNode queryDsl)`
  returns the unit life cycle
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesClient.`selectUnitLifeCycleById(String id, com.fasterxml.jackson.databind.JsonNode queryDsl, LifeCycleStatusCode lifeCycleStatus)`
  returns the unit life cycle in progress

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.logbook.lifecycles.core

  Methods in fr.gouv.vitam.logbook.lifecycles.core that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesImpl.`getRawObjectGroupLifeCycleById(String id)`
  `List<com.fasterxml.jackson.databind.JsonNode>`
  LogbookLifeCyclesImpl.`getRawObjectGroupLifeCycleByIds(List<String> ids)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookLifeCyclesImpl.`getRawUnitLifeCycleById(String id)`
  `List<com.fasterxml.jackson.databind.JsonNode>`
  LogbookLifeCyclesImpl.`getRawUnitLifeCycleByIds(List<String> ids)`
  `LogbookLifeCycle<?>`
  LogbookLifeCyclesImpl.`selectLifeCycleById(String lifecycleId, com.fasterxml.jackson.databind.JsonNode queryDsl, boolean sliced, LogbookCollections collection)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.logbook.operations.api

  Methods in fr.gouv.vitam.logbook.operations.api that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `Optional<LogbookOperation>`
  LogbookOperations.`findLastOperationByType(String operationType)`
  FInd last event of last operation by type
  `LogbookOperation`
  LogbookOperations.`findLastTraceabilityOperationOK()`
  Find last successful traceability operation
  `List<LogbookOperation>`
  LogbookOperations.`selectOperations(com.fasterxml.jackson.databind.JsonNode select)`
  Select logbook operation entries
  `com.mongodb.client.MongoCursor<LogbookOperation>`
  LogbookOperations.`selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate, LocalDateTime endDate)`
  Select all logbook operations entries persisted within provided interval

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.logbook.operations.client

  Methods in fr.gouv.vitam.logbook.operations.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `LifecycleTraceabilityStatus`
  LogbookOperationsClient.`checkLifecycleTraceabilityWorkflowStatus(String processId)`
  Check life cycle traceability status (unit / got)
  `ReindexationResult`
  LogbookOperationsClient.`reindex(IndexParameters indexParam)`
  Reindex a collection with parameters
  `ReindexationResult`
  LogbookOperationsClientMock.`reindex(IndexParameters indexParam)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookOperationsClient.`selectOperation(com.fasterxml.jackson.databind.JsonNode select)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookOperationsClient.`selectOperation(com.fasterxml.jackson.databind.JsonNode select, boolean isSliced, boolean isCrossTenant)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookOperationsClientMock.`selectOperation(com.fasterxml.jackson.databind.JsonNode select)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookOperationsClientMock.`selectOperation(com.fasterxml.jackson.databind.JsonNode select, boolean isSliced, boolean isCrossTenant)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookOperationsClient.`selectOperationById(String id)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookOperationsClient.`selectOperationById(String processId, com.fasterxml.jackson.databind.JsonNode query, boolean isSliced, boolean isCrossTenant)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookOperationsClientMock.`selectOperationById(String id)`
  `com.fasterxml.jackson.databind.JsonNode`
  LogbookOperationsClientMock.`selectOperationById(String processId, com.fasterxml.jackson.databind.JsonNode query, boolean isSliced, boolean isCrossTenant)`
  `SwitchIndexResult`
  LogbookOperationsClient.`switchIndexes(SwitchIndexParameters switchIndexParam)`
  Switch indexes
  `SwitchIndexResult`
  LogbookOperationsClientMock.`switchIndexes(SwitchIndexParameters switchIndexParam)`
  `RequestResponseOK<TenantLogbookOperationTraceabilityResult>`
  LogbookOperationsClient.`traceability(List<Integer> tenants)`
  Call traceability logbook operation for requested tenants
  `RequestResponseOK<String>`
  LogbookOperationsClient.`traceabilityLfcObjectGroup()`
  Starts Object Group logbook lifecycle traceability
  `RequestResponseOK<String>`
  LogbookOperationsClient.`traceabilityLfcUnit()`
  Starts Unit logbook lifecycle traceability

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.logbook.operations.core

  Methods in fr.gouv.vitam.logbook.operations.core that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `Optional<LogbookOperation>`
  AlertLogbookOperationsDecorator.`findLastOperationByType(String operationType)`
  `Optional<LogbookOperation>`
  LogbookOperationsImpl.`findLastOperationByType(String operationType)`
  `LogbookOperation`
  LogbookOperationsDecorator.`findLastTraceabilityOperationOK()`
  `LogbookOperation`
  LogbookOperationsImpl.`findLastTraceabilityOperationOK()`
  `List<LogbookOperation>`
  AlertLogbookOperationsDecorator.`selectOperations(com.fasterxml.jackson.databind.JsonNode select)`
  `com.mongodb.client.MongoCursor<LogbookOperation>`
  LogbookOperationsDecorator.`selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate, LocalDateTime endDate)`
  `com.mongodb.client.MongoCursor<LogbookOperation>`
  LogbookOperationsImpl.`selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate, LocalDateTime endDate)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.metadata.client

  Methods in fr.gouv.vitam.metadata.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClient.`atomicUpdateBulk(List<com.fasterxml.jackson.databind.JsonNode> updateQueries)`
  Bulk Update units by a list of update query (DSL)
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClientMock.`atomicUpdateBulk(List<com.fasterxml.jackson.databind.JsonNode> updateQueries)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClientRest.`atomicUpdateBulk(List<com.fasterxml.jackson.databind.JsonNode> updateQueries)`
  `void`
  MetaDataClient.`deleteObjectGroupBulk(Collection<String> listIds)`
  Delete Object Group Bulk
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`getPurgedPersistentIdentifiers(String persistentIdentifier, PurgedCollectionType type)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`getPurgedPersistentIdentifiers(String persistentIdentifier, PurgedCollectionType type)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`getPurgedPersistentIdentifiers(String persistentIdentifier, PurgedCollectionType type)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`insertObjectGroup(com.fasterxml.jackson.databind.JsonNode insertQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`insertObjectGroup(com.fasterxml.jackson.databind.JsonNode insertQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`insertObjectGroup(com.fasterxml.jackson.databind.JsonNode insertQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`insertObjectGroups(List<com.fasterxml.jackson.databind.JsonNode> insertQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`insertObjectGroups(List<com.fasterxml.jackson.databind.JsonNode> insertQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`insertObjectGroups(List<com.fasterxml.jackson.databind.JsonNode> insertQueries)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`insertUnitBulk(BulkUnitInsertRequest request)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`insertUnitBulk(BulkUnitInsertRequest request)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`insertUnitBulk(BulkUnitInsertRequest request)`
  `jakarta.ws.rs.core.Response`
  MetaDataClient.`processObsoleteComputedInheritedRules()`
  API to process obsolete compute inherited rules service for metadatas.
  `jakarta.ws.rs.core.Response`
  MetaDataClientRest.`processObsoleteComputedInheritedRules()`
  `jakarta.ws.rs.core.Response`
  MetaDataClient.`purgeExpiredDipFiles()`
  API to process purge expired DIP files service for metadatas.
  `jakarta.ws.rs.core.Response`
  MetaDataClientRest.`purgeExpiredDipFiles()`
  `jakarta.ws.rs.core.Response`
  MetaDataClient.`purgeExpiredTransfersSIPFiles()`
  API to process purge expired tranfering SIP files service for metadatas.
  `jakarta.ws.rs.core.Response`
  MetaDataClientRest.`purgeExpiredTransfersSIPFiles()`
  `List<ReconstructionResponseItem>`
  MetaDataClient.`reconstructCollection(List<ReconstructionRequestItem> reconstructionItems)`
  API to access and launch the Vitam reconstruction service for metadatas.
  `List<ReconstructionResponseItem>`
  MetaDataClientRest.`reconstructCollection(List<ReconstructionRequestItem> reconstructionItems)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClient.`reconstructPersistentIdentifiers(PersistentIdentifierReconstructionRequest requestItem)`
  Reconstruct Persistent Identifiers
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClientRest.`reconstructPersistentIdentifiers(PersistentIdentifierReconstructionRequest requestItem)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`reindex(IndexParameters indexParam)`
  Reindex a collection with parameters
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`reindex(IndexParameters indexParam)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`reindex(IndexParameters indexParam)`
  `jakarta.ws.rs.core.Response`
  MetaDataClient.`runAuditDataConsistencyMongoEs()`
  API to process audit data consistency Mongo and ES service for metadatas.
  `jakarta.ws.rs.core.Response`
  MetaDataClientRest.`runAuditDataConsistencyMongoEs()`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`selectObjectGroups(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Search objectgroups by select query (DSL)
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`selectObjectGroups(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`selectObjectGroups(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`selectObjectGrouptbyId(com.fasterxml.jackson.databind.JsonNode selectQuery, String objectGroupId)`
  Search Object Group by query (DSL) and path objectGroup id
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`selectObjectGrouptbyId(com.fasterxml.jackson.databind.JsonNode selectQuery, String objectGroupId)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`selectObjectGrouptbyId(com.fasterxml.jackson.databind.JsonNode selectQuery, String objectGroupId)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`selectUnitbyId(com.fasterxml.jackson.databind.JsonNode selectQuery, String unitId)`
  Search units by query (DSL) and path unit id
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`selectUnitbyId(com.fasterxml.jackson.databind.JsonNode selectQuery, String unitId)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`selectUnitbyId(com.fasterxml.jackson.databind.JsonNode selectQuery, String unitId)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`selectUnits(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Search units by select query (DSL)
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`selectUnits(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`selectUnits(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  `List<RequestResponseOK<com.fasterxml.jackson.databind.JsonNode>>`
  MetaDataClient.`selectUnitsBulk(List<com.fasterxml.jackson.databind.JsonNode> selectQueryBulk)`
  Bulk Search units by a list of select query (DSL)
  `List<RequestResponseOK<com.fasterxml.jackson.databind.JsonNode>>`
  MetaDataClientMock.`selectUnitsBulk(List<com.fasterxml.jackson.databind.JsonNode> selectQueryBulk)`
  `List<RequestResponseOK<com.fasterxml.jackson.databind.JsonNode>>`
  MetaDataClientRest.`selectUnitsBulk(List<com.fasterxml.jackson.databind.JsonNode> selectQueryBulk)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`selectUnitsWithInheritedRules(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Select units with inherited rules by select query (DSL)
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`selectUnitsWithInheritedRules(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  `jakarta.ws.rs.core.Response`
  MetaDataClient.`storeGraph()`
  API to access and launch the Vitam store graph service for metadatas.
  `jakarta.ws.rs.core.Response`
  MetaDataClientRest.`storeGraph()`
  `SwitchIndexResult`
  MetaDataClient.`switchIndexes(SwitchIndexParameters switchIndexParam)`
  Switch indexes
  `SwitchIndexResult`
  MetaDataClientMock.`switchIndexes(SwitchIndexParameters switchIndexParam)`
  `SwitchIndexResult`
  MetaDataClientRest.`switchIndexes(SwitchIndexParameters switchIndexParam)`
  `void`
  MetaDataClient.`updateObjectGroupById(com.fasterxml.jackson.databind.JsonNode updateQuery, String objectGroupId)`
  Update ObjectGroup
  `void`
  MetaDataClientRest.`updateObjectGroupById(com.fasterxml.jackson.databind.JsonNode queryUpdate, String objectGroupId)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClient.`updateUnitBulk(com.fasterxml.jackson.databind.JsonNode updateQuery)`
  Update units Bulk.
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClientMock.`updateUnitBulk(com.fasterxml.jackson.databind.JsonNode updateQuery)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClientRest.`updateUnitBulk(com.fasterxml.jackson.databind.JsonNode updateQuery)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClient.`updateUnitById(com.fasterxml.jackson.databind.JsonNode updateQuery, String unitId)`
  Update units by query (DSL) and path unit id
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientMock.`updateUnitById(com.fasterxml.jackson.databind.JsonNode updateQuery, String unitId)`
  `com.fasterxml.jackson.databind.JsonNode`
  MetaDataClientRest.`updateUnitById(com.fasterxml.jackson.databind.JsonNode updateQuery, String unitId)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClient.`updateUnitsRulesBulk(List<String> unitsIds, RuleActions actions, Map<String,DurationData> rulesToDurationData)`
  Update units rules Bulk.
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClientMock.`updateUnitsRulesBulk(List<String> unitsIds, RuleActions actions, Map<String,DurationData> rulesToDurationData)`
  `RequestResponse<com.fasterxml.jackson.databind.JsonNode>`
  MetaDataClientRest.`updateUnitsRulesBulk(List<String> unitsIds, RuleActions actions, Map<String,DurationData> rulesToDurationData)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.metadata.common.bulkatomicupdate

  Methods in fr.gouv.vitam.metadata.common.bulkatomicupdate that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `com.fasterxml.jackson.databind.JsonNode`
  QueryRestrictionConverter.`convert(com.fasterxml.jackson.databind.JsonNode query)`
  `void`
  BulkSelectQueryParallelProcessor.`processQueries(Iterator<com.fasterxml.jackson.databind.JsonNode> queryIterator)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.metadata.core

  Methods in fr.gouv.vitam.metadata.core that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  MetaDataImpl.`insertObjectGroup(com.fasterxml.jackson.databind.JsonNode objectGroupRequest)`
  `void`
  MetaDataImpl.`insertObjectGroups(List<com.fasterxml.jackson.databind.JsonNode> objectGroupRequest)`
  `void`
  MetaDataImpl.`insertUnits(List<com.fasterxml.jackson.databind.JsonNode> unitRequest)`
  `MetadataResult`
  MetaDataImpl.`selectObjectGroupById(com.fasterxml.jackson.databind.JsonNode selectQuery, String objectGroupId)`
  `MetadataResult`
  MetaDataImpl.`selectObjectGroupsByQuery(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  `MetadataResult`
  MetaDataImpl.`selectUnitsById(com.fasterxml.jackson.databind.JsonNode selectQuery, String unitId)`
  `MetadataResult`
  MetaDataImpl.`selectUnitsByQuery(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  `void`
  MetaDataImpl.`updateObjectGroupId(com.fasterxml.jackson.databind.JsonNode updateQuery, String objectId, boolean forceUpdate, boolean withRefreshIndex)`
  `UpdateUnit`
  MetaDataImpl.`updateUnitById(com.fasterxml.jackson.databind.JsonNode updateQuery, String unitId, boolean forceUpdate, boolean withRefreshIndex)`
  `List<UpdateUnit>`
  MetaDataImpl.`updateUnits(List<RequestById> bulkRequests, boolean forceUpdate, boolean withRefreshIndex)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.metadata.core.database.collections

  Methods in fr.gouv.vitam.metadata.core.database.collections that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `protected Result<MetadataDocument<?>>`
  DbRequest.`exactDepthUnitQuery(Query realQuery, Result<MetadataDocument<?>> previous, int exactDepth, Integer tenantId, List<co.elastic.clients.elasticsearch._types.SortOptions> sorts, int offset, int limit, Map<String,co.elastic.clients.elasticsearch._types.aggregations.Aggregation> facets, String scrollId, Integer scrollTimeout, DynamicParserTokens parserTokens, boolean trackTotalHits)`
  Execute one Unit Query using exact Depth
  `void`
  DbRequest.`execInsertObjectGroupRequests(List<InsertParserMultiple> requestParsers)`
  Inserts an object group
  `Result<MetadataDocument<?>>`
  DbRequest.`execRequest(RequestParserMultiple requestParser, List<OntologyModel> ontologies)`
  The request should be already analyzed.
  `UpdatedDocument`
  DbRequest.`execRuleRequest(String documentId, RuleActions ruleActions, Map<String,DurationData> bindRuleToDuration, OntologyValidator ontologyValidator, UnitValidator unitValidator, List<OntologyModel> ontologyModels)`
  Execute rule action on unit
  `List<UpdatedDocument>`
  DbRequest.`execUpdateRequest(List<RequestById> bulkRequests, MetadataCollections metadataCollection, OntologyValidator ontologyValidator, UnitValidator unitValidator, List<OntologyModel> ontologyModels, boolean forceUpdate, boolean refreshElasticIndexPostBulkIndexing)`
  `protected Result<MetadataDocument<?>>`
  DbRequest.`executeQuery(RequestParserMultiple requestParser, RequestToAbstract requestToMongodb, int rank, Result<MetadataDocument<?>> previous, DynamicParserTokens parserTokens)`
  Execute one request
  `com.fasterxml.jackson.databind.JsonNode`
  MetadataRepositoryService.`getDocumentById(MetadataCollections collection, String id, Integer tenant)`
  Retrieve document by its ID in a given collection filtered by a tenant in mongo
  `List<com.fasterxml.jackson.databind.JsonNode>`
  MetadataRepositoryService.`getDocumentsByIds(MetadataCollections collection, Collection<String> ids, Integer tenant)`
  Retrieve document by its ID in a given collection filtered by a tenant in mongo
  `List<T>`
  Result.`getListFiltered()`
  `String`
  MongoDbVarNameAdapter.`getVariableName(String name)`
  `protected Result<MetadataDocument<?>>`
  DbRequest.`lastSelectFilterProjection(SelectToMongodb requestToMongodb, Result<MetadataDocument<?>> last, boolean checkConsistency)`
  Finalize the queries with last True Select
  `protected Result<MetadataDocument<?>>`
  DbRequest.`objectGroupQuery(Query realQuery, Result<MetadataDocument<?>> previous, Integer tenantId, List<co.elastic.clients.elasticsearch._types.SortOptions> sorts, int offset, int limit, String scrollId, Integer scrollTimeout, Map<String,co.elastic.clients.elasticsearch._types.aggregations.Aggregation> facets, DynamicParserTokens parserTokens, boolean trackTotalHits)`
  Execute one relative Depth ObjectGroup Query
  `protected Result<MetadataDocument<?>>`
  DbRequest.`relativeDepthUnitQuery(Query realQuery, Result<MetadataDocument<?>> previous, int relativeDepth, Integer tenantId, List<co.elastic.clients.elasticsearch._types.SortOptions> sorts, int offset, int limit, Map<String,co.elastic.clients.elasticsearch._types.aggregations.Aggregation> facets, String scrollId, Integer scrollTimeout, DynamicParserTokens parserTokens, boolean trackTotalHits)`
  Execute one relative Depth Unit Query
  `protected Result<MetadataDocument<?>>`
  DbRequest.`sameDepthUnitQuery(Query realQuery, Result<MetadataDocument<?>> previous, Integer tenantId, List<co.elastic.clients.elasticsearch._types.SortOptions> sorts, int offset, int limit, Map<String,co.elastic.clients.elasticsearch._types.aggregations.Aggregation> facets, String scrollId, Integer scrollTimeout, DynamicParserTokens parserTokens, boolean trackTotalHits)`
  Execute one relative Depth Unit Query

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.metadata.core.graph

  Methods in fr.gouv.vitam.metadata.core.graph that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  ReclassificationDistributionService.`exportReclassificationChildNodes(Set<String> unitIds, String unitsToUpdateJsonLineFileName, String objectGroupsToUpdateJsonLineFileName)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.metadata.core.reconstruction.model

  Methods in fr.gouv.vitam.metadata.core.reconstruction.model that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static PurgedPersistentIdentifier`
  PurgedPersistentIdentifier.`fromDocument(org.bson.Document document)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.metadata.core.rules

  Methods in fr.gouv.vitam.metadata.core.rules that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `MetadataResult`
  MetadataRuleService.`selectUnitsWithInheritedRules(com.fasterxml.jackson.databind.JsonNode selectQuery)`
  Select units by DSL and computes inherited rules for matching units

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.metadata.core.utils

  Methods in fr.gouv.vitam.metadata.core.utils that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `static com.fasterxml.jackson.databind.node.ArrayNode`
  MetadataJsonResponseUtils.`populateJSONObjectResponse(Result result, RequestParserMultiple selectRequest)`
  create Json response

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.processing.data.core.management

  Methods in fr.gouv.vitam.processing.data.core.management that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `Optional<DistributorIndex>`
  ProcessDataManagement.`getDistributorIndex(String fileName)`
  `Optional<DistributorIndex>`
  WorkspaceProcessDataManagement.`getDistributorIndex(String fileName)`
  `ProcessWorkflow`
  ProcessDataManagement.`getProcessWorkflow(String folderName, String asyncId)`
  Retrieve a workflow instance on process container
  `ProcessWorkflow`
  WorkspaceProcessDataManagement.`getProcessWorkflow(String folderName, String asyncId)`
  `void`
  ProcessDataManagement.`persistDistributorIndex(String fileName, DistributorIndex distributorIndex)`
  `void`
  WorkspaceProcessDataManagement.`persistDistributorIndex(String fileName, DistributorIndex distributorIndex)`
  `void`
  ProcessDataManagement.`persistProcessWorkflow(String folderName, ProcessWorkflow processWorkflow)`
  Put process workflow instance in workspace
  `void`
  WorkspaceProcessDataManagement.`persistProcessWorkflow(String folderName, ProcessWorkflow processWorkflow)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.security.internal.common.service

  Methods in fr.gouv.vitam.security.internal.common.service that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  CRLService.`checkIdentityWithCRL(byte[] crlCert)`
  Check all identity and personal certificates against given CRL

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.security.internal.rest.repository

  Methods in fr.gouv.vitam.security.internal.rest.repository that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  IdentityRepository.`createIdentity(IdentityModel identityModel)`
  create a certificate with contextId and many information
  `void`
  PersonalRepository.`createPersonalCertificate(PersonalCertificateModel personalCertificateModel)`
  create a personal certificate
  `List<? extends CertificateBaseModel>`
  CertificateRepository.`findAll()`
  `List<IdentityModel>`
  IdentityRepository.`findAll()`
  `List<PersonalCertificateModel>`
  PersonalRepository.`findAll()`
  `com.mongodb.client.FindIterable<org.bson.Document>`
  CertificateCRLCheckStateUpdater.`findCertificate(String issuerDN, CertificateStatus certificateStatus)`
  return list of certificate filtered by issuerDN and certificateStatus
  `com.mongodb.client.FindIterable<org.bson.Document>`
  PersonalRepository.`findCertificate(String issuerDN, CertificateStatus certificateStatus)`
  return list of certificate filtered by issuerDN and certificateStatus
  `Optional<IdentityModel>`
  IdentityRepository.`findIdentity(String subjectDN, String serialNumber)`
  return certificate according to subjectDN and serilanumber
  `Optional<PersonalCertificateModel>`
  PersonalRepository.`findPersonalCertificateByHash(String hash)`
  return certificate by hash

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.security.internal.rest.resource

  Methods in fr.gouv.vitam.security.internal.rest.resource that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `jakarta.ws.rs.core.Response`
  CertificateResource.`checkCertificatesExpiration()`
  `void`
  AdminCRLResource.`checkIdentityWithCRL(byte[] crlCertificate)`
  `void`
  PersonalCertificateResource.`checkPersonalCertificate(byte[] certificate, String permission)`
  Check personal certificate
  `jakarta.ws.rs.core.Response`
  AdminIdentityResource.`createIdentity(IdentityInsertModel identityInsertModel, jakarta.ws.rs.core.UriInfo uri)`
  `void`
  AdminPersonalCertificateResource.`createIfNotPresent(byte[] certificate)`
  `IdentityModel`
  IdentityResource.`findIdentityByCertificate(byte[] certificate)`
  `IdentityModel`
  AdminIdentityResource.`linkContextToIdentity(IdentityInsertModel identityInsertModel, jakarta.ws.rs.core.UriInfo uri)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.security.internal.rest.service

  Methods in fr.gouv.vitam.security.internal.rest.service that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  SecurityService.`checkCertificates()`
  `void`
  CRLServiceImpl.`checkIdentityWithCRL(byte[] crlCert)`
  Check all identity and personal certificates against given CRL
  `void`
  PersonalCertificateService.`checkPersonalCertificateExistence(byte[] certificate, String permission)`
  Checks if the personal certificate if valid.
  `void`
  IdentityService.`createIdentity(IdentityInsertModel identityInsertModel)`
  create certificate
  `void`
  PersonalCertificateService.`createPersonalCertificateIfNotPresent(byte[] certificate)`
  Create certificate if not present in DB.
  `List<IdentityModel>`
  IdentityService.`findAllIdentities()`
  `List<PersonalCertificateModel>`
  PersonalCertificateService.`findAllPersonalCertificates()`
  `Optional<IdentityModel>`
  IdentityService.`findIdentity(byte[] certificate)`
  `Optional<IdentityModel>`
  IdentityService.`linkContextToIdentity(IdentityInsertModel identityInsertModel)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.storage.driver

  Methods in fr.gouv.vitam.storage.driver that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `StorageBulkMetadataResult`
  Connection.`getBulkMetadata(StorageGetBulkMetadataRequest request)`
  Bulk get metadata of objects

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.storage.engine.client

  Methods in fr.gouv.vitam.storage.engine.client that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `RequestResponseOK`
  StorageClient.`copyObjectFromOfferToOffer(String objectId, DataCategory category, String source, String destination, String strategyId)`
  `RequestResponseOK`
  StorageClientMock.`copyObjectFromOfferToOffer(String objectId, DataCategory category, String source, String destination, String strategyId)`
  `RequestResponseOK`
  StorageClient.`create(String strategyId, String objectId, DataCategory category, InputStream inputStream, Long inputStreamSize, List<String> offerIds)`
  `RequestResponseOK`
  StorageClientMock.`create(String strategyId, String objectId, DataCategory category, InputStream inputStream, Long inputStreamSize, List<String> offerIds)`
  `RequestResponseOK<StorageLogBackupResult>`
  StorageClient.`storageAccessLogBackup(List<Integer> tenants)`
  Call storage accesslog backup operation.
  `RequestResponseOK<StorageLogBackupResult>`
  StorageClient.`storageLogBackup(List<Integer> tenants)`
  Call storage log backup operation.
  `RequestResponseOK<StorageLogTraceabilityResult>`
  StorageClient.`storageLogTraceability(List<Integer> tenants)`
  Call storage log traceability operation.

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.storage.engine.server.distribution.impl.bulk

  Methods in fr.gouv.vitam.storage.engine.server.distribution.impl.bulk that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `List<ObjectInfo>`
  MultiplexedStreamObjectInfoListenerThread.`call()`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.storage.engine.server.storagetraceability

  Methods in fr.gouv.vitam.storage.engine.server.storagetraceability that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `String`
  LogbookStorageTraceabilityHelper.`getPreviousStartDate()`
  `byte[]`
  LogbookStorageTraceabilityHelper.`getPreviousTimestampToken()`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.storage.offers.workspace.driver

  Methods in fr.gouv.vitam.storage.offers.workspace.driver that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `StorageBulkMetadataResult`
  ConnectionImpl.`getBulkMetadata(StorageGetBulkMetadataRequest request)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.handler

  Methods in fr.gouv.vitam.worker.core.handler that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `void`
  PersistentIdentifierGenerationService.`fillArkPersistentIdentifier(PersistentIdentifierPolicy policy, com.fasterxml.jackson.databind.JsonNode qualifierToUpdate)`
  Fill generated persistent identifier on objects according to management contract settings
  `void`
  PersistentIdentifierGenerationService.`handlePersistentIdentifierForGot(Map<String,List<com.fasterxml.jackson.databind.JsonNode>> objectsByQualifierMap, ManagementContractModel managementContractModel, PersistentIdentifierPolicyTypeEnum persistentIdentifierType)`
  Service to fill generated persistent identifiers and management contract id on objects
  `protected abstract void`
  AbstractAccessionRegisterAction.`prepareAccessionRegisterInformation(WorkerParameters params, HandlerIO handler, AbstractAccessionRegisterAction.AccessionRegisterInfo accessionRegisterInfo)`
  `protected void`
  IngestAccessionRegisterActionHandler.`prepareAccessionRegisterInformation(WorkerParameters params, HandlerIO handler, AbstractAccessionRegisterAction.AccessionRegisterInfo accessionRegisterInfo)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.plugin

  Methods in fr.gouv.vitam.worker.core.plugin that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `protected Report`
  GenericReportGenerationHandler.`generateReport(WorkerParameters param, LogbookOperation logbook)`
  `protected OperationSummary`
  GenericReportGenerationHandler.`getOperationSummary(LogbookOperation logbook, String processId)`
  `void`
  PluginLoader.`loadConfiguration()`
  load the configuration file containing the list of plugins.

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.plugin.common

  Methods in fr.gouv.vitam.worker.core.plugin.common that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `SelectMultiQuery`
  CheckDistributionThresholdBase.`getSelectCountFromQuery(RequestMultiple multiQuery)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.plugin.evidence

  Methods in fr.gouv.vitam.worker.core.plugin.evidence that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `List<IdentifierType>`
  DataRectificationService.`correctObjectGroups(EvidenceAuditReportLine line, String containerName)`
  `Optional<IdentifierType>`
  DataRectificationService.`correctUnits(EvidenceAuditReportLine line, String containerName)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.plugin.lfc_traceability

  Methods in fr.gouv.vitam.worker.core.plugin.lfc_traceability that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `protected abstract InputStream`
  PrepareLfcTraceabilityActionPlugin.`exportRawLifecyclesByLastPersistedDate(LogbookLifeCyclesClientFactory logbookLifeCyclesClientFactory, LocalDateTime selectionStartDate, LocalDateTime selectionEndDate, int lifecycleTraceabilityMaxEntries)`
  `protected InputStream`
  PrepareObjectGroupLfcTraceabilityActionPlugin.`exportRawLifecyclesByLastPersistedDate(LogbookLifeCyclesClientFactory logbookLifeCyclesClientFactory, LocalDateTime startDate, LocalDateTime endDate, int maxEntries)`
  `protected InputStream`
  PrepareUnitLfcTraceabilityActionPlugin.`exportRawLifecyclesByLastPersistedDate(LogbookLifeCyclesClientFactory logbookLifeCyclesClientFactory, LocalDateTime startDate, LocalDateTime endDate, int maxEntries)`
  `String`
  LogbookLifeCycleTraceabilityHelper.`getPreviousMonthStartDate()`
  `byte[]`
  LogbookLifeCycleTraceabilityHelper.`getPreviousMonthTimestampToken()`
  `String`
  LogbookLifeCycleTraceabilityHelper.`getPreviousStartDate()`
  `byte[]`
  LogbookLifeCycleTraceabilityHelper.`getPreviousTimestampToken()`
  `String`
  LogbookLifeCycleTraceabilityHelper.`getPreviousYearStartDate()`
  `byte[]`
  LogbookLifeCycleTraceabilityHelper.`getPreviousYearTimestampToken()`
  `protected StatusCode`
  PrepareLfcTraceabilityActionPlugin.`selectAndExportLifecyclesWithMetadata(int temporizationDelayInSeconds, int lifecycleTraceabilityMaxEntries, String eventType, HandlerIO handlerIO)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.plugin.preservation

  Methods in fr.gouv.vitam.worker.core.plugin.preservation that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `protected void`
  PreservationAccessionRegisterActionHandler.`prepareAccessionRegisterInformation(WorkerParameters params, HandlerIO handler, AbstractAccessionRegisterAction.AccessionRegisterInfo accessionRegisterInfo)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.plugin.purge

  Methods in fr.gouv.vitam.worker.core.plugin.purge that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `abstract void`
  CommonPurgeDeleteService.`deleteObjectGroups(List<PurgeObjectGroupParams> objectGroupParams, HandlerIO handler)`
  `void`
  PurgeDeleteCollectService.`deleteObjectGroups(List<PurgeObjectGroupParams> objectGroupParams, HandlerIO handler)`
  `void`
  PurgeDeleteService.`deleteObjectGroups(List<PurgeObjectGroupParams> objectGroupParams, HandlerIO handler)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.plugin.reclassification.dsl

  Methods in fr.gouv.vitam.worker.core.plugin.reclassification.dsl that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `ParsedReclassificationDslRequest`
  ReclassificationRequestDslParser.`parseReclassificationRequest(com.fasterxml.jackson.databind.JsonNode reclassificationDslJson)`

- ## Uses of InvalidParseOperationException in fr.gouv.vitam.worker.core.plugin.reclassification.utils

  Methods in fr.gouv.vitam.worker.core.plugin.reclassification.utils that throw InvalidParseOperationException
  Modifier and Type
  Method
  Description
  `Map<String,InheritedRuleCategoryResponseModel>`
  UnitGraphInfoLoader.`loadInheritedHoldRules(MetaDataClient metaDataClient, Set<String> unitsIdToRearrange)`
  `Map<String,UnitGraphInfo>`
  UnitGraphInfoLoader.`selectAllUnitGraphByIds(MetaDataClient metaDataClient, Set<String> unitIds)`
  Load unit graph with all parents recursively.
  `Set<String>`
  UnitGraphInfoLoader.`selectUnitsByIdsAndAccessContract(MetaDataClient metaDataClient, Set<String> unitIds, AccessContractModel accessContractModel)`
  Find unit ids accessible through the access contract
  `Set<String>`
  UnitGraphInfoLoader.`selectUnitsByIdsAndTransaction(MetaDataClient metaDataClient, Set<String> unitIds, String transactionId)`
  Find unit ids accessible in a collect transaction
  `Set<String>`
  UnitGraphInfoLoader.`selectUnitsByQueryDslAndAccessContract(MetaDataClient metaDataClient, SelectMultiQuery select, AccessContractModel accessContractModel)`
  Find unit ids by dsl accessible through the access contract
  `Set<String>`
  UnitGraphInfoLoader.`selectUnitsByQueryDslAndTransaction(MetaDataClient metaDataClient, SelectMultiQuery select, String transactionId)`
  Find unit ids by dsl accessible in a collect transaction