Consommer les services


    Le client Java permet d’interagir avec FlowerDocs Core à travers les web services exposés.

    Cette documentation s’appuie sur l’utilisation de Maven et Spring Boot 2.3.0.RELEASE.

    Core Services

    Services Javadoc

    Set-up

    Maven

    Les librairies nécessaires à ce client Java sont publiées dans l’Artifactory Arondor. Si vous n’avez pas encore de compte d’accès, demandez en un !

    Afin d’utiliser le client Java dans un projet Maven, commencez par ajouter la dépendance suivante :

    <dependency>
        <groupId>com.flower.docs.core</groupId>
        <artifactId>flower-docs-starter-client</artifactId>
        <version>2.5.0</version>
    </dependency>

    Cette dépendance tire les dépendances nécessaires pour démarrer un projet de client FlowerDocs.

    Application Spring Boot

    Pour définir votre application Spring Boot comme étant un client FlowerDocs, ajouter l’annotation @FlowerDocsClient sur la classe principale tel que :

    @SpringBootApplication
    @FlowerDocsClient
    public class SampleClient
    {
        public static void main(String[] args)
        {
            SpringApplication.run(SampleClient.class, args);
        }
    }

    Cette annotation permet d’initialiser la configuration requise à l’initialisation d’un client FlowerDocs. Pour que le client démarre, il est nécessaire de définir de la propriété ws.url dans le fichier application.properties avec l’URL d’accès aux web services exposés par FlowerDocs.

    Authentification

    Les appels effectués auprès de FlowerDocs Core nécessitent que les requêtes soient authentifiées. Une requête peut être authentifiée en fournissant un jeton utilisateur propre à FlowerDocs.

    Compte de service

    Le développement d’une application qui interagit avec FlowerDocs requiert généralement l’utilisation d’un compte de service utilisé pour effectuer les opérations auprès de FlowerDocs Core.

    Pour cela, le client Java fournit une classe utilitaire permettant de simplifier la gestion de l’authentification.

    @Autowired
    private Authenticator authenticator;
    ...
    authenticator.authenticate("scopeId"); 

    La configuration du compte utilisé se fait à travers les propriétés :

    flower.user=<identifiant de l'utilisateur>
    flower.password=<mot de passe>

    Ces propriétés peuvent être soit passées dans le fichier de configuration Spring application.properties soit en tant que propriétés de la JVM.

    Génération d’un token

    Un jeton utilisateur peut également être généré dynamiquement à l’aide du service AuthenticationService qui expose la méthode login :

    @Autowired
    AuthenticationService service;
    ...
    ContextHelper.setScope(new Id("GEC"));
    Token token = service.login("user","password");

    Développement

    Accès aux services

    L’accès aux services FlowerDocs s’appuie sur le contexte Spring. Pour récupérer une instance de service, il suffit d’utiliser l’annotation @Autowired.

    Par exemple, pour accéder au service de gestion de documents :

    @Autowired
    private DocumentService documentService;

    Gestion des logs

    Les APIs FlowerDocs s’appuient sur la couche d’abstraction de framework de log SLF4J. Ce framework permet de s’abstraire du framework de log utilisé. Par défaut, l’implémentation utilisée est Logback.


    Pour instancier un logger, il suffit de :

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    ...
    private static final Logger LOGGER = LoggerFactory.getLogger(SampleClient.class);
    ...
    LOGGER.info("Found {} documents", response.getFound());


    La configuration des niveaux de log est identidique à celle de FlowerDocs : Logs

    Les WSDL définissent le contrat de service des web services SOAP exposés par FlowerDocs Core.

    Ils sont exposés par chaque FlowerDocs Core sous le chemin /services et publiés en ligne ici.

    Authentification

    Les requêtes SOAP nécessitent d’être authentifiées pour être acceptées par FlowerDocs Core. Pour cela, il est nécessaire de fournir un jeton utilisateur sous la forme d’un en-tête de l’enveloppe SOAP.

    Génération d’un jeton

    Le jeton à fournir peut être généré à l’aide du service AuthenticationWSService qui expose l’opération login :

    POST /core/services/authentication

    <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:aut="http://flower.com/docs/ws/api/authentication">
       <soapenv:Header/>
       <soapenv:Body>
          <aut:loginRequest>
             <aut:scope>{{scope}}</aut:scope>
             <aut:user>{{user}}</aut:user>
             <aut:password>{{password}}</aut:password>
          </aut:loginRequest>
       </soapenv:Body>
    </soapenv:Envelope>

    Fournir le jeton

    Pour authentifier un client, le jeton doit être fourni à chaque requête. Il doit être fourni sous la forme d’un en-tête SOAP sous le namespace flower :

    <soapenv:Header>	
        <flower:token>{{token}}</flower:token>
    <soapenv:Header>

    Le namespace flower peut être défini en ajoutant la définition du préfixe xmlns:flower="flower" comme attribut du noeud soapenv:Envelope.

    La documentation de cette API est fournie à travers Swagger exposé par FlowerDocs Core sous le chemin /swagger-ui.html ou en ligne ici.