@cerema/cadriciel 1.0.8 → 1.1.1

package/aaaa/api/aaaa-metier/src/main/java/fr/cerema/dsi/aaaa/services/impl/UserServiceImpl.java

@@ -0,0 +1,75 @@
+package fr.cerema.dsi.aaaa.services.impl;
+
+import fr.cerema.dsi.commons.exceptions.UserNotFoundException;
+import fr.cerema.dsi.commons.security.UserSecurityServiceUtil;
+import fr.cerema.dsi.commons.services.GenericServiceImpl;
+import fr.cerema.dsi.aaaa.entities.User;
+import fr.cerema.dsi.aaaa.enums.Role;
+import fr.cerema.dsi.aaaa.repositories.UserRepository;
+import fr.cerema.dsi.aaaa.services.ProfilService;
+import fr.cerema.dsi.aaaa.services.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service("userService")
+@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
+public class UserServiceImpl extends GenericServiceImpl<User, Long> implements UserService {
+
+  private final ProfilService profilService;
+
+  private final UserRepository userRepository;
+
+  public UserServiceImpl(UserRepository userRepository, ProfilService profilService) {
+    this.userRepository = userRepository;
+    this.profilService = profilService;
+  }
+
+
+  @Override
+  public Optional<User> findByEmail(String email) {
+    return this.userRepository.findByEmailIgnoreCase(email);
+  }
+
+  @Override
+  public Optional<User> findByOrionId(String orionId) {
+    return this.userRepository.findByOrionId(orionId);
+  }
+
+  @Override
+  public void deleteUtilisateur(String mail) {
+    Optional<User> user = this.findByEmail(mail);
+    if (user.isPresent()) {
+      this.deleteById(user.get().getId());
+    } else {
+      throw new ResponseStatusException(HttpStatus.NOT_FOUND,
+        "L'utilisateur n'est pas présent dans la liste blanche");
+    }
+  }
+
+  @Override
+  public User saveUser(User user) {
+    return this.userRepository.save(user);
+  }
+
+  @Override
+  public Optional<User> getCurrentUser() {
+    Optional<String> login = UserSecurityServiceUtil.getCurrentUserLogin();
+    if (login.isPresent()) {
+      return this.userRepository.findByEmailIgnoreCase(login.get());
+    }
+    throw new UserNotFoundException("Pas d'utilisateur authentifié trouvé");
+  }
+
+  @Override
+  public List<User> findAllAdmin§§projectNS§§() {
+    return this.userRepository.findAllByRole(Role.ADMIN);
+  }
+
+
+}

package/aaaa/api/aaaa-metier/src/main/java/fr/cerema/dsi/commons/security/UserSecurityServiceUtil.java

@@ -0,0 +1,30 @@
+package fr.cerema.dsi.commons.security;
+
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+public class UserSecurityServiceUtil {
+
+  public static Optional<String> getCurrentUserLogin() {
+    SecurityContext securityContext = SecurityContextHolder.getContext();
+    return Optional.ofNullable(extractPrincipal(securityContext.getAuthentication()));
+  }
+
+  private static String extractPrincipal(Authentication authentication) {
+    if (authentication == null) {
+      return null;
+    } else if (authentication.getPrincipal() instanceof UserDetails) {
+      UserDetails springSecurityUser = (UserDetails) authentication.getPrincipal();
+      return springSecurityUser.getUsername();
+    } else if (authentication.getPrincipal() instanceof String) {
+      return (String) authentication.getPrincipal();
+    }
+    return null;
+  }
+}

package/aaaa/api/aaaa-metier/src/main/java/fr/cerema/dsi/commons/services/GenericService.java

@@ -0,0 +1,30 @@
+package fr.cerema.dsi.commons.services;
+
+import fr.cerema.dsi.commons.entities.GenericEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.Serializable;
+import java.util.List;
+
+@Service
+@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
+public interface GenericService<T extends GenericEntity, ID extends Serializable> {
+
+  List<T> findAll();
+
+  T getOne(ID id);
+
+  T findById(ID id);
+
+  @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
+  T create(T entity);
+
+
+  @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
+  void deleteById(ID id);
+
+  @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
+  T save(T entity);
+}

package/aaaa/api/aaaa-metier/src/main/java/fr/cerema/dsi/commons/services/GenericServiceImpl.java

@@ -0,0 +1,62 @@
+package fr.cerema.dsi.commons.services;
+
+
+import fr.cerema.dsi.commons.entities.GenericEntity;
+import fr.cerema.dsi.commons.exceptions.EntityNotFoundException;
+import fr.cerema.dsi.commons.repositories.GenericRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.Serializable;
+import java.util.List;
+
+@Service
+@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
+public abstract class GenericServiceImpl<T extends GenericEntity, ID extends Serializable> implements
+  GenericService<T, ID> {
+
+  protected static Logger logger;
+
+  public GenericServiceImpl() {
+    logger = LoggerFactory.getLogger(this.getClass().getCanonicalName());
+  }
+
+  @Autowired
+  protected GenericRepository<T, ID> repository;
+
+  public List<T> findAll() {
+    return repository.findAll();
+  }
+
+  public T getOne(ID primaryKey) {
+    return repository.getOne(primaryKey);
+  }
+
+  public T findById(ID id) {
+    return repository.findById(id)
+      .orElseGet(() -> {
+        throw new EntityNotFoundException(
+          "L'entité d'identifiant {" + id + "} n'a pas été trouvée");
+      });
+  }
+
+  @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
+  public T create(T entity) {
+    return repository.save(entity);
+  }
+
+
+  @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
+  public void deleteById(ID id) {
+    repository.deleteById(id);
+  }
+
+  @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
+  public T save(T entity) {
+    return this.repository.save(entity);
+  }
+}

package/aaaa/api/aaaa-metier/src/test/java/fr/cerema/dsi/aaaa/services/UserServiceImplTest.java

@@ -0,0 +1,60 @@
+package fr.cerema.dsi.aaaa.services;
+
+import fr.cerema.dsi.commons.exceptions.UserNotFoundException;
+import fr.cerema.dsi.aaaa.entities.User;
+import fr.cerema.dsi.aaaa.enums.Role;
+import fr.cerema.dsi.aaaa.repositories.UserRepository;
+import fr.cerema.dsi.aaaa.services.impl.UserServiceImpl;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.BDDMockito.given;
+
+@ExtendWith(MockitoExtension.class)
+public class UserServiceImplTest {
+
+  @Mock
+  private ProfilService profilService;
+
+  @Mock
+  private UserRepository userRepository;
+
+  @InjectMocks
+  private UserServiceImpl userService;
+
+  private List<User> userList;
+
+  @BeforeEach
+  public void setup() {
+    userList = new ArrayList<>();
+    User user = new User();
+    user.setId(1L);
+    userList.add(user);
+  }
+
+  @Test
+  public void shouldThrowExceptionWhenUserIsNotFound() {
+
+    Assertions.assertThrows(UserNotFoundException.class, () -> userService.getCurrentUser(),
+      "Pas d'utilisateur authentifié trouvé");
+  }
+
+  @Test
+  public void shouldfindAllAdmin§§projectNS§§() {
+    given(userRepository.findAllByRole(Role.ADMIN)).willReturn(
+      userList);
+
+    List<User> resultat = this.userService.findAllAdmin§§projectNS§§();
+
+    Assertions.assertEquals(1, resultat.size());
+  }
+
+}

package/aaaa/api/aaaa-persistance/pom.xml

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>fr.cerema.dsi</groupId>
+    <artifactId>aaaa-back</artifactId>
+    <version>0.0.1</version>
+  </parent>
+  <packaging>jar</packaging>
+
+  <artifactId>aaaa-persistance</artifactId>
+
+  <!-- Dépendances spécifiques à ce module -->
+  <dependencies>
+
+    <!-- Dépendances avec les autres modules -->
+    <dependency>
+      <groupId>${project.groupId}</groupId>
+      <artifactId>aaaa-transverse</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+<!--    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-context</artifactId>
+      <version>5.2.6.RELEASE</version>
+    </dependency>-->
+
+
+    <!-- Dépendance data-jpa -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-data-jpa</artifactId>
+    </dependency>
+
+    <!--    <dependency>
+          <groupId>com.oracle.ojdbc</groupId>
+          <artifactId>ojdbc10</artifactId>
+          <version>19.3.0.0</version>
+          <scope>runtime</scope>
+        </dependency>-->
+
+    <dependency>
+      <groupId>org.postgresql</groupId>
+      <artifactId>postgresql</artifactId>
+      <version>42.2.16</version>
+      <scope>runtime</scope>
+    </dependency>
+
+    <!--    <dependency>
+          <groupId>com.h2database</groupId>
+          <artifactId>h2</artifactId>
+          <scope>runtime</scope>
+        </dependency>-->
+
+    <!--    <dependency>-->
+    <!--      <groupId>org.hibernate</groupId>-->
+    <!--      <artifactId>hibernate-ehcache</artifactId>-->
+    <!--      <version>${hibernate.version}</version>-->
+    <!--    </dependency>-->
+
+    <dependency>
+      <groupId>org.hibernate</groupId>
+      <artifactId>hibernate-spatial</artifactId>
+      <version>${hibernate.version}</version>
+    </dependency>
+
+  </dependencies>
+
+</project>

package/aaaa/api/aaaa-persistance/src/main/java/fr/cerema/dsi/aaaa/repositories/ProfilRepository.java

@@ -0,0 +1,18 @@
+package fr.cerema.dsi.aaaa.repositories;
+
+import fr.cerema.dsi.commons.repositories.GenericRepository;
+import fr.cerema.dsi.aaaa.entities.Profil;
+import fr.cerema.dsi.aaaa.enums.Role;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ProfilRepository extends GenericRepository<Profil, Long> {
+
+  @Query(value = "select p.profilutilisateur from {h-schema}users as u join {h-schema}profil as p on p.utilisateurid = u.id where lower(u.email) = lower(:username)", nativeQuery = true)
+  List<Role> findAllCurrentRolesByUsername(@Param("username") String username);
+
+}

package/aaaa/api/aaaa-persistance/src/main/java/fr/cerema/dsi/aaaa/repositories/UserRepository.java

@@ -0,0 +1,28 @@
+package fr.cerema.dsi.aaaa.repositories;
+
+import fr.cerema.dsi.commons.repositories.GenericRepository;
+import fr.cerema.dsi.aaaa.entities.User;
+import fr.cerema.dsi.aaaa.enums.Role;
+import org.springframework.data.jpa.repository.EntityGraph;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+@Transactional(propagation = Propagation.MANDATORY)
+public interface UserRepository extends GenericRepository<User, Long> {
+
+  @EntityGraph(attributePaths = "profilSet")
+  Optional<User> findByEmailIgnoreCase(String email);
+
+  Optional<User> findByOrionId(String orionId);
+
+  @Query(value = "SELECT DISTINCT u FROM User u JOIN u.profilSet p WHERE p.profilUtilisateur = :role")
+  List<User> findAllByRole(@Param("role") Role role);
+
+}

package/aaaa/api/aaaa-persistance/src/main/java/fr/cerema/dsi/commons/repositories/AbstractDao.java

@@ -0,0 +1,118 @@
+/**
+ *
+ * © Cerema/DSI 2015
+ * Contributeurs:
+ * Raphaël Roulet raphael.roulet@cerema.fr
+ * Alain Charles alain.charles@cerema.fr
+ *
+ * Ce logiciel est un programme informatique servant à cartographier et analyser
+ * les compétences collectives disponibles au Cerema. *
+ * Ce logiciel est régi par la licence CeCILL soumise au droit français et
+ * respectant les principes de diffusion des logiciels libres. Vous pouvez
+ * utiliser, modifier et/ou redistribuer ce programme sous les conditions de la
+ * licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA sur le site
+ * "http://www.cecill.info".
+ *
+ * En contrepartie de l'accessibilité au code source et des droits de copie, de
+ * modification et de redistribution accordés par cette licence, il n'est offert
+ * aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons, seule une
+ * responsabilité restreinte pèse sur l'auteur du programme, le titulaire des
+ * droits patrimoniaux et les concédants successifs.
+ *
+ * A cet égard l'attention de l'utilisateur est attirée sur les risques associés
+ * au chargement, à l'utilisation, à la modification et/ou au développement et à
+ * la reproduction du logiciel par l'utilisateur étant donné sa spécificité de
+ * logiciel libre, qui peut le rendre complexe à manipuler et qui le réserve
+ * donc à des développeurs et des professionnels avertis possédant des
+ * connaissances informatiques approfondies. Les utilisateurs sont donc invités
+ * à charger et tester l'adéquation du logiciel à leurs besoins dans des
+ * conditions permettant d'assurer la sécurité de leurs systèmes et ou de leurs
+ * données et, plus généralement, à l'utiliser et l'exploiter dans les mêmes
+ * conditions de sécurité. *
+ * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris
+ * connaissance de la licence CeCILL, et que vous en avez accepté les termes.
+ *
+ */
+package fr.cerema.dsi.commons.repositories;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.Query;
+import jakarta.persistence.criteria.CriteriaQuery;
+import jakarta.persistence.criteria.Root;
+
+import java.util.List;
+
+/**
+ *
+ * @author Raphaël Roulet raphael.roulet@cerema.fr
+ */
+public abstract class AbstractDao<T> implements IAbstractDao<T> {
+
+    private Class<T> entityClass;
+
+    public AbstractDao() {
+    }
+
+    public AbstractDao(Class<T> entityClass) {
+        this.entityClass = entityClass;
+    }
+
+    protected abstract EntityManager getEntityManager();
+
+    public void create(T entity) {
+        getEntityManager().persist(entity);
+    }
+
+    public T edit(T entity) {
+        return getEntityManager().merge(entity);
+    }
+
+    public void remove(T entity)  {
+            getEntityManager().remove(getEntityManager().merge(entity));
+    }
+
+    public T refresh(T entity) {
+        if (getEntityManager().contains(entity)) {
+            getEntityManager().refresh(entity);
+        }
+        return entity;
+    }
+
+    public void flush() {
+        getEntityManager().flush();
+    }
+
+    public T find(Object id) {
+        return getEntityManager().find(entityClass, id);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public List<T> findAll() {
+      CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
+        cq.select(cq.from(entityClass));
+        return getEntityManager().createQuery(cq).getResultList();
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public List<T> findRange(int[] range) {
+      CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
+        cq.select(cq.from(entityClass));
+      Query q = getEntityManager().createQuery(cq);
+        q.setMaxResults(range[1] - range[0] + 1);
+        q.setFirstResult(range[0]);
+        return q.getResultList();
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public int count() {
+      CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery();
+      Root<T> rt = cq.from(entityClass);
+      cq.select(getEntityManager().getCriteriaBuilder().count(rt));
+      Query q = getEntityManager().createQuery(cq);
+      return ((Long) q.getSingleResult()).intValue();
+    }
+
+    public void clearL2Cache() {
+        getEntityManager().getEntityManagerFactory().getCache().evictAll();
+    }
+}

package/aaaa/api/aaaa-persistance/src/main/java/fr/cerema/dsi/commons/repositories/GenericRepository.java

@@ -0,0 +1,101 @@
+package fr.cerema.dsi.commons.repositories;
+
+import fr.cerema.dsi.commons.entities.GenericEntity;
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.repository.NoRepositoryBean;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Optional;
+
+@NoRepositoryBean
+@Transactional(propagation = Propagation.MANDATORY, readOnly = true)
+public interface GenericRepository<T extends GenericEntity, ID extends Serializable>
+        extends JpaRepository<T, ID>
+
+/* Afin que la propagation MANDATORY d'applique à toutes les méthodes existantes dans le JpaRepository,
+    Il est nécessaire de les redéclarer ici. Sinon, le comportement pat défaut de JpaRepository s'applique, et ce n'est pas mandatory.
+*/ {
+
+
+    @Override
+    List<T> findAll();
+
+    @Override
+    List<T> findAll(Sort sort);
+
+    @Override
+    List<T> findAllById(Iterable<ID> primaryKeys);
+
+    @Override
+    <S extends T> List<S> saveAll(Iterable<S> entities);
+
+    @Override
+    void flush();
+
+    @Override
+    @Transactional(propagation = Propagation.MANDATORY, readOnly = false)
+    <S extends T> S saveAndFlush(S entity);
+
+    @Override
+    void deleteInBatch(Iterable<T> entities);
+
+    @Override
+    void deleteAllInBatch();
+
+    @Override
+    T getOne(ID primaryKey);
+
+    @Override
+    <S extends T> List<S> findAll(Example<S> example);
+
+    @Override
+    <S extends T> List<S> findAll(Example<S> example, Sort tri);
+
+    @Override
+    Page<T> findAll(Pageable pageable);
+
+    @Override
+    <S extends T> Optional<S> findOne(Example<S> example);
+
+    @Override
+    <S extends T> Page<S> findAll(Example<S> example, Pageable pageable);
+
+    @Override
+    <S extends T> long count(Example<S> example);
+
+    @Override
+    <S extends T> boolean exists(Example<S> example);
+
+    @Override
+    @Transactional(propagation = Propagation.MANDATORY, readOnly = false)
+    <S extends T> S save(S entity);
+
+    @Override
+    Optional<T> findById(ID primaryKey);
+
+    @Override
+    boolean existsById(ID primaryKey);
+
+    @Override
+    long count();
+
+    @Override
+    void deleteById(ID primaryKey);
+
+    @Override
+    void delete(T entity);
+
+    @Override
+    void deleteAll(Iterable<? extends T> entities);
+
+    @Override
+    void deleteAll();
+}
+

package/aaaa/api/aaaa-persistance/src/main/java/fr/cerema/dsi/commons/repositories/IAbstractDao.java

@@ -0,0 +1,66 @@
+/**
+ *
+ * © Cerema/DSI 2015
+ * Contributeurs:
+ * Raphaël Roulet raphael.roulet@cerema.fr
+ * Alain Charles  alain.charles@cerema.fr
+ *
+ * Ce logiciel est un programme informatique servant à cartographier et analyser
+ * les compétences collectives disponibles au Cerema.  *
+ * Ce logiciel est régi par la licence CeCILL soumise au droit français et
+ * respectant les principes de diffusion des logiciels libres. Vous pouvez
+ * utiliser, modifier et/ou redistribuer ce programme sous les conditions de la
+ * licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA sur le site
+ * "http://www.cecill.info".
+ *
+ * En contrepartie de l'accessibilité au code source et des droits de copie, de
+ * modification et de redistribution accordés par cette licence, il n'est offert
+ * aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons, seule une
+ * responsabilité restreinte pèse sur l'auteur du programme, le titulaire des
+ * droits patrimoniaux et les concédants successifs.
+ *
+ * A cet égard l'attention de l'utilisateur est attirée sur les risques associés
+ * au chargement, à l'utilisation, à la modification et/ou au développement et à
+ * la reproduction du logiciel par l'utilisateur étant donné sa spécificité de
+ * logiciel libre, qui peut le rendre complexe à manipuler et qui le réserve
+ * donc à des développeurs et des professionnels avertis possédant des
+ * connaissances informatiques approfondies. Les utilisateurs sont donc invités
+ * à charger et tester l'adéquation du logiciel à leurs besoins dans des
+ * conditions permettant d'assurer la sécurité de leurs systèmes et ou de leurs
+ * données et, plus généralement, à l'utiliser et l'exploiter dans les mêmes
+ * conditions de sécurité.  *
+ * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris
+ * connaissance de la licence CeCILL, et que vous en avez accepté les termes.
+ *
+ */
+package fr.cerema.dsi.commons.repositories;
+
+import java.util.List;
+
+/**
+ *
+ * @author acharles
+ */
+public interface IAbstractDao<T> {
+
+    public void create(T entity);
+
+    public T edit(T entity);
+
+    public void remove(T entity);
+
+    public T refresh(T entity);
+
+    public void flush();
+
+    public T find(Object id);
+
+    public List<T> findAll();
+
+    public List<T> findRange(int[] range);
+
+    public int count();
+
+    public void clearL2Cache();
+
+}