Ajout du sevice algoTheses (anciennement algoSudoc)

src/main/java/fr/abes/theses/export/controller/OutilsController.java

@@ -0,0 +1,48 @@
+package fr.abes.theses.export.controller;
+
+import fr.abes.theses.export.service.DbRequest;
+import io.swagger.v3.oas.annotations.Parameter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+@Slf4j
+@RestController
+@RequestMapping("/api/v1/outils/")
+public class OutilsController {
+
+    @Autowired
+    DbRequest dbRequest;
+
+//    @GetMapping(value = "algoTheses",produces = "application/vnd.ms-excel")
+    @GetMapping(value = "algoTheses")
+    public ResponseEntity algoTheses(
+            @RequestParam @Parameter(name = "etat", description = "Code du problème, multivalué possible", example = "52") Optional<List<Integer>> etat,
+            @RequestParam @Parameter(name = "type", description = "Type d'intervention, multivalué possible", example = "amelioration") Optional<List<String>> type,
+            @RequestParam @Parameter(name = "codeetab", description = "Code de l'établissement", example = "NICE") Optional<List<String>> codeEtab,
+            @RequestParam @Parameter(name = "nnt", description = "Numéro national de thèse", example = "2020MONT1234") Optional<List<String>> nnt,
+            @RequestParam @Parameter(name = "ppn", description = "Identifiant de la notice", example = "236863509") Optional<List<String>> ppn,
+            @RequestParam @Parameter(name = "utilisateur", description = "Type d'utilisateur", example = "reseau") Optional<List<String>> utilisateur,
+            @RequestParam @Parameter(name = "rcr", description = "Identifiant de la bibliothèque", example = "751052105") Optional<List<String>> rcr,
+            @RequestParam @Parameter(name = "sort", description = "Ordre de tri avec noms du (ou des) champ(s)", example = "type,codeEtab,ppn") Optional<List<String>> sort,
+            @RequestParam @Parameter(name = "annee", description = "Année de soutenance", example = "1985") Optional<String> annee,
+            @RequestParam @Parameter(name = "rownum", description = "Nombre de lignes à renvoyer", example = "1000") Optional<String> rownum
+            ) {
+        return new ResponseEntity<>(dbRequest.getDiagnosticAlgoTheses(
+                etat,
+                type,
+                codeEtab,
+                nnt,
+                ppn,
+                utilisateur,
+                rcr,
+                sort,
+                annee,
+                rownum), HttpStatus.OK);
+    }
+}

src/main/java/fr/abes/theses/export/model/Diagnostic.java

@@ -0,0 +1,24 @@
+package fr.abes.theses.export.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+@AllArgsConstructor
+@Getter
+@Setter
+public class Diagnostic {
+
+    private Integer etat;
+    private String type;
+    private String codeEtab;
+    private String nnt;
+    private String ppn;
+    private String utilisateur;
+    private String rcr;
+    private String annee;
+    private String gravite;
+    private String libelle;
+    private String consigne;
+
+}

src/main/java/fr/abes/theses/export/service/DbConfig.java

@@ -7,30 +7,51 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
+import org.springframework.jdbc.core.JdbcTemplate;
 
 import javax.sql.DataSource;
 
 @Configuration
 public class DbConfig {
 
     @Bean
-    @Primary
-    public DataSourceProperties dataSourceProperties() {
+    @ConfigurationProperties("spring.theses.datasource")
+    public DataSourceProperties dataSourceThesesProperties() {
         return new DataSourceProperties();
     }
 
-    // ci-dessous : obligation d'utiliser une OracleDataSource sinon impossible
-    // de caster le ResultSet Hikari en ResulSet Oracle dans le TheseRowMapper
-    // et donc impossible d'utiliser le getOpaque (spécifique à OracleResultSet)
-    // pour récuperer le XMLType
-
     @Bean
     @Primary
-    @ConfigurationProperties("spring.db.datasource")
-    public DataSource dataSourceLecture() {
+    public DataSource dataSourceTheses() {
 
-        return DataSourceBuilder.create().url(dataSourceProperties().getUrl())
-                .username(dataSourceProperties().getUsername()).password(dataSourceProperties().getPassword())
+        return DataSourceBuilder.create().url(dataSourceThesesProperties().getUrl())
+                .username(dataSourceThesesProperties().getUsername()).password(dataSourceThesesProperties().getPassword())
                 .type(OracleDataSource.class).build();
     }
+
+
+    @Bean
+    @ConfigurationProperties("spring.basexml.datasource")
+    public DataSourceProperties dataSourceBaseXmlProperties() {
+        return new DataSourceProperties();
+    }
+
+    @Bean
+    public DataSource dataSourceBaseXml() {
+
+        return DataSourceBuilder.create().url(dataSourceBaseXmlProperties().getUrl())
+                .username(dataSourceBaseXmlProperties().getUsername()).password(dataSourceBaseXmlProperties().getPassword())
+                .type(OracleDataSource.class).build();
+    }
+
+    @Bean
+    public JdbcTemplate jdbcTemplateTheses() {
+        return new JdbcTemplate(dataSourceTheses());
+    }
+
+    @Bean
+    public JdbcTemplate jdbcTemplateBaseXml() {
+        return new JdbcTemplate(dataSourceBaseXml());
+    }
+
 }

src/main/java/fr/abes/theses/export/service/DbRequest.java

@@ -1,18 +1,141 @@
 package fr.abes.theses.export.service;
 
-import org.springframework.beans.factory.annotation.Autowired;
+import fr.abes.theses.export.model.Diagnostic;
+import org.springframework.context.annotation.Configuration;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Component;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
 @Component
+@Configuration
 public class DbRequest {
 
-    @Autowired
-    private JdbcTemplate jdbcTemplate;
+    private final JdbcTemplate jdbcTemplateTheses;
+    private final JdbcTemplate jdbcTemplateBaseXml;
+    public DbRequest(JdbcTemplate jdbcTemplateTheses,
+                     JdbcTemplate jdbcTemplateBaseXml) {
+        this.jdbcTemplateTheses = jdbcTemplateTheses;
+        this.jdbcTemplateBaseXml = jdbcTemplateBaseXml;
+    }
 
     public String findTefByNntOrNumsujet (String nntOrNumsujet) {
 
+
         String sql = "select d.doc from PORTAIL.document d where d.nnt=? or d.numsujet=?";
-        return jdbcTemplate.queryForObject(sql, new TefMapper(), nntOrNumsujet,nntOrNumsujet);
+        return jdbcTemplateTheses.queryForObject(sql, new TefMapper(), nntOrNumsujet,nntOrNumsujet);
+    }
+
+    public List<Diagnostic> getDiagnosticAlgoTheses (Optional<List<Integer>> etats,
+                                               Optional<List<String>> types,
+                                               Optional<List<String>> codeEtab,
+                                               Optional<List<String>> nnt,
+                                               Optional<List<String>> ppn,
+                                               Optional<List<String>> utilisateur,
+                                               Optional<List<String>> rcr,
+                                               Optional<List<String>> sort,
+                                               Optional<String> annee,
+                                               Optional<String> rownum) {
+
+
+        StringBuilder sql = new StringBuilder("SELECT etat, type, codeetab, nnt, ppn, utilisateur, rcr, annee, gravite, libelle, consigne " +
+                "FROM theses_algo WHERE 1=1");
+
+        List<Object> params = new ArrayList<>();
+
+        ajouteParamIntegerDansRequete(sql, params, "etat",etats);
+        ajouteParamStringDansRequete(sql, params, "type", types);
+        ajouteParamStringDansRequete(sql, params, "codeetab", codeEtab);
+        ajouteParamStringDansRequete(sql, params, "nnt", nnt);
+        ajouteParamStringDansRequete(sql, params, "ppn", ppn);
+        ajouteParamStringDansRequete(sql, params, "utilisateur", utilisateur);
+        ajouteParamStringDansRequete(sql, params, "rcr", rcr);
+        ajouteRownum(sql, params, rownum);
+        ajouteAnneeDansRequete(sql, params, annee);
+        ajouteOrdre(sql, sort);
+
+        return jdbcTemplateBaseXml.query(sql.toString(), params.toArray(), (rs, rowNum) ->
+                new Diagnostic(
+                        rs.getInt("etat"),
+                        rs.getString("type"),
+                        rs.getString("codeetab"),
+                        rs.getString("nnt"),
+                        rs.getString("ppn"),
+                        rs.getString("utilisateur"),
+                        rs.getString("rcr"),
+                        rs.getString("annee"),
+                        rs.getString("gravite"),
+                        rs.getString("libelle"),
+                        rs.getString("consigne")
+                )
+        );
+    }
+
+    private void ajouteParamIntegerDansRequete (StringBuilder sql, List<Object> paramsRequete, String nomParam, Optional<List<Integer>> params) {
+
+        if (params.isPresent()) {
+
+            String inClause = params.get().stream()
+                    .map(type -> nomParam + " = ?")
+                    .collect(Collectors.joining(" OR "));
+            sql.append(" AND (" + inClause + ")");
+            paramsRequete.addAll(params.get());
+        }
+    }
+    private void ajouteParamStringDansRequete (StringBuilder sql, List<Object> paramsRequete, String nomParam, Optional<List<String>> params) {
+
+        if (params.isPresent()) {
+
+            String clause = params.get().stream()
+                    .map(type -> nomParam + " = ?")
+                    .collect(Collectors.joining(" OR "));
+            sql.append(" AND (" + clause + ")");
+            paramsRequete.addAll(params.get());
+        }
+    }
+
+    private void ajouteAnneeDansRequete (StringBuilder sql, List<Object> paramsRequete, Optional<String> annee) {
+
+        if (annee.isPresent() && annee.get().matches("\\d{4}")) {
+
+            sql.append(" AND annee >= ?");
+            paramsRequete.add(annee.get());
+        }
+    }
+    private void ajouteRownum (StringBuilder sql, List<Object> paramsRequete, Optional<String> rownum) {
+
+        if (rownum.isPresent() && Integer.parseInt(rownum.get()) > 0 && Integer.parseInt(rownum.get()) < 100000) {
+                sql.append(" AND rownum <= ?");
+                paramsRequete.add(rownum.get());
+            }
+        else {
+            sql.append(" AND rownum <= 100");
+        }
+    }
+
+    private void ajouteOrdre (StringBuilder sql, Optional<List<String>> sort) {
+
+        List<String> validColumns = Arrays.asList("etat", "type", "codeetab", "nnt", "ppn", "utilisateur", "rcr", "annee", "gravite", "libelle", "consigne");  // Ajouter toutes les colonnes valides
+
+        if (sort.isPresent() && !sort.get().isEmpty()) {
+
+            String orderClause = sort.get().stream()
+                    .map(value -> {
+                        String column = value.trim();
+
+                        if (!validColumns.contains(column)) {
+                            throw new IllegalArgumentException("Colonne non valide pour le tri : " + column);
+                        }
+
+                        return column + " ASC";
+                    })
+                    .collect(Collectors.joining(", "));
+
+            sql.append(" ORDER BY " + orderClause);
+        }
     }
 }

src/main/resources/application.properties

@@ -1,13 +1,20 @@
 server.port=
 
-# oracle
-spring.datasource.driverClassName=oracle.jdbc.driver.OracleDriver
-spring.datasource.url=
-spring.datasource.username=
-spring.datasource.password=
-spring.datasource.hikari.minimumIdle=3
-spring.datasource.hikari.maximumPoolSize=15
-spring.datasource.hikari.readOnly=true
+spring.theses.datasource.driverClassName=oracle.jdbc.driver.OracleDriver
+spring.theses.datasource.url=
+spring.theses.datasource.username=
+spring.theses.datasource.password=
+spring.theses.datasource.hikari.minimumIdle=3
+spring.theses.datasource.hikari.maximumPoolSize=15
+spring.theses.datasource.hikari.readOnly=true
+
+spring.basexml.datasource.driverClassName=oracle.jdbc.driver.OracleDriver
+spring.basexml.datasource.url=
+spring.basexml.datasource.username=
+spring.basexml.datasource.password=
+spring.basexml.datasource.hikari.minimumIdle=3
+spring.basexml.datasource.hikari.maximumPoolSize=15
+spring.basexml.datasource.hikari.readOnly=true
 
 path.xsls=