コード例 #1
1
  /**
   * Trouve tous les prets.
   *
   * @return La liste des prets; une liste vide sinon
   * @throws DAOException S'il y a une erreur avec la base de données
   */
  public List<PretDTO> getAll() throws DAOException {

    List<PretDTO> listeDTO = Collections.EMPTY_LIST;

    PretDTO pretDTO = null;
    try (PreparedStatement getAllPreparedStatement =
            getConnection().prepareStatement(PretDAO.GET_ALL_REQUEST);
        ResultSet resultSet = getAllPreparedStatement.executeQuery(); ) {

      if (resultSet.next()) {
        listeDTO = new ArrayList<>();
        do {
          pretDTO = new PretDTO();
          pretDTO.setIdPret(resultSet.getInt(1));
          pretDTO.getMembreDTO().setIdMembre(resultSet.getInt(2));
          pretDTO.getLivreDTO().setIdLivre(resultSet.getInt(3));
          pretDTO.setDatePret(resultSet.getTimestamp(4));
          pretDTO.setDateRetour(resultSet.getTimestamp(5));
          listeDTO.add(pretDTO);
        } while (resultSet.next());
      }

    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
    return listeDTO;
  }
コード例 #2
0
  /** {@inheritDoc} */
  @Override
  public void delete(Connexion connexion, DTO dto)
      throws InvalidHibernateSessionException, InvalidDTOException, InvalidDTOClassException,
          DAOException {

    if (connexion == null) {
      throw new InvalidHibernateSessionException("La connexion ne peut être null");
    }
    if (dto == null) {
      throw new InvalidDTOException("Le DTO ne peut être null");
    }
    if (!dto.getClass().equals(getDtoClass())) {
      throw new InvalidDTOClassException("Le DTO doit être un " + getDtoClass().getName());
    }
    final PretDTO pretDTO = (PretDTO) dto;
    try (PreparedStatement deletePreparedStatement =
        connexion.getConnection().prepareStatement(PretDAO.DELETE_REQUEST)) {

      deletePreparedStatement.setString(1, pretDTO.getIdPret());

      deletePreparedStatement.executeUpdate();
    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
  }
コード例 #3
0
  /** {@inheritDoc} */
  @Override
  public void add(Connexion connexion, DTO dto)
      throws InvalidHibernateSessionException, InvalidDTOException, InvalidDTOClassException,
          DAOException {

    if (connexion == null) {
      throw new InvalidHibernateSessionException("La connexion ne peut être null");
    }
    if (dto == null) {
      throw new InvalidDTOException("Le DTO ne peut être null");
    }
    if (!dto.getClass().equals(getDtoClass())) {
      throw new InvalidDTOClassException("Le DTO doit être un " + getDtoClass().getName());
    }
    final PretDTO pretDTO = (PretDTO) dto;
    try (PreparedStatement addPreparedStatement =
        connexion.getConnection().prepareStatement(PretDAO.ADD_REQUEST)) {

      addPreparedStatement.setString(1, pretDTO.getMembreDTO().getIdMembre());
      addPreparedStatement.setString(2, pretDTO.getLivreDTO().getIdLivre());
      addPreparedStatement.setTimestamp(3, pretDTO.getDatePret());
      addPreparedStatement.setTimestamp(4, pretDTO.getDateRetour());

      addPreparedStatement.executeUpdate();
    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
  }
コード例 #4
0
  /** {@inheritDoc} */
  @Override
  public void add(Connexion connexion, DTO dto)
      throws DAOException, InvalidHibernateSessionException, InvalidDTOException,
          InvalidDTOClassException {
    if (connexion == null) {
      throw new InvalidHibernateSessionException("La connexion ne peut être null");
    }
    if (dto == null) {
      throw new InvalidDTOException("Le DTO ne peut être null");
    }
    if (!dto.getClass().equals(getDtoClass())) {
      throw new InvalidDTOClassException(
          "Le DTO doit être de la classe " + getDtoClass().getName());
    }
    PretDTO pretDTO = (PretDTO) dto;

    try (PreparedStatement statementAdd =
        (connexion.getConnection().prepareStatement(PretDAO.ADD_REQUEST))) {

      statementAdd.setString(1, pretDTO.getMembreDTO().getIdMembre());
      statementAdd.setString(2, pretDTO.getLivreDTO().getIdLivre());
      statementAdd.setTimestamp(3, pretDTO.getDatePret());
      statementAdd.executeUpdate();

    } catch (SQLException sqlException) {
      throw new DAOException(
          Integer.toString(sqlException.getErrorCode()) + " " + sqlException.getMessage(),
          sqlException);
    }
  }
コード例 #5
0
  /**
   * Ajoute un nouveau pret.
   *
   * @param pretDTO Le pret à ajouter
   * @throws DAOException S'il y a une erreur avec la base de données
   */
  public void add(PretDTO pretDTO) throws DAOException {
    try (PreparedStatement addPreparedStatement =
        getConnection().prepareStatement(PretDAO.ADD_REQUEST)) {

      addPreparedStatement.setInt(1, pretDTO.getMembreDTO().getIdMembre());
      addPreparedStatement.setInt(2, pretDTO.getLivreDTO().getIdLivre());
      addPreparedStatement.setTimestamp(3, pretDTO.getDatePret());
      addPreparedStatement.setTimestamp(4, pretDTO.getDateRetour());

      addPreparedStatement.executeUpdate();
    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
  }
コード例 #6
0
 /** {@inheritDoc} */
 @Override
 public boolean equals(Object obj) {
   boolean equals = this == obj;
   if (!equals) {
     equals = obj != null && obj instanceof PretDTO;
     if (equals) {
       PretDTO pretDTO = (PretDTO) obj;
       EqualsBuilder equalsBuilder = new EqualsBuilder();
       equalsBuilder.appendSuper(super.equals(pretDTO));
       equalsBuilder.append(getIdPret(), pretDTO.getIdPret());
       equals = equalsBuilder.isEquals();
     }
   }
   return equals;
 }
コード例 #7
0
  /**
   * Met à jour un pret.
   *
   * @param pretDTO Le pret à mettre à jour
   * @return Le nombre de lignes affectées par la modification
   * @throws DAOException S'il y a une erreur dans la base de données
   */
  public int update(PretDTO pretDTO) throws DAOException {
    int result = 0;
    try (PreparedStatement updatePreparedStatement =
        getConnection().prepareStatement(PretDAO.UPDATE_REQUEST)) {

      updatePreparedStatement.setInt(1, pretDTO.getMembreDTO().getIdMembre());
      updatePreparedStatement.setInt(2, pretDTO.getLivreDTO().getIdLivre());
      updatePreparedStatement.setTimestamp(3, pretDTO.getDatePret());
      updatePreparedStatement.setTimestamp(4, pretDTO.getDateRetour());
      updatePreparedStatement.setInt(5, pretDTO.getIdPret());

      result = updatePreparedStatement.executeUpdate();
    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }

    return result;
  }
コード例 #8
0
  /**
   * Supprime un pret.
   *
   * @param pretDTO Le pret à supprimer
   * @throws DAOException S'il y a une erreur dans la base de données
   */
  public void delete(PretDTO pretDTO) throws DAOException {
    try (PreparedStatement deletePreparedStatement =
        getConnection().prepareStatement(PretDAO.DELETE_REQUEST)) {

      deletePreparedStatement.setInt(1, pretDTO.getIdPret());

      deletePreparedStatement.executeUpdate();
    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
  }
コード例 #9
0
  /**
   * Trouve les prêts non terminés à partir d'une date de retour.
   *
   * @param dateRetour La date de retour à utiliser
   * @return La liste des prets correspondants; une liste vide sinon
   * @throws DAOException S'il y a une erreur avec la base de données
   */
  public List<PretDTO> findByDateRetour(Timestamp dateRetour) throws DAOException {

    List<PretDTO> listePrets = Collections.EMPTY_LIST;
    PretDTO pretDTO = null;

    try (PreparedStatement findByDateRetourPreparedStatement =
        getConnection().prepareStatement(PretDAO.FIND_BY_DATE_RETOUR); ) {
      findByDateRetourPreparedStatement.setTimestamp(1, dateRetour);
      try (ResultSet resultSet = findByDateRetourPreparedStatement.executeQuery(); ) {
        if (resultSet.next()) {
          listePrets = new ArrayList<>();
          do {
            pretDTO = new PretDTO();
            pretDTO.setIdPret(resultSet.getInt(1));
            final MembreDTO membreDTO = new MembreDTO();
            membreDTO.setIdMembre(resultSet.getInt(2));
            pretDTO.setMembreDTO(membreDTO);
            // pretDTO.getMembreDTO().setIdMembre(resultSet.getInt(2));
            final LivreDTO livreDTO = new LivreDTO();
            livreDTO.setIdLivre(resultSet.getInt(3));
            pretDTO.setLivreDTO(livreDTO);
            // pretDTO.getLivreDTO().setIdLivre(resultSet.getInt(3));
            pretDTO.setDatePret(resultSet.getTimestamp(4));
            pretDTO.setDateRetour(resultSet.getTimestamp(5));
            listePrets.add(pretDTO);
          } while (resultSet.next());
        }
      }
    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
    return listePrets;
  }
コード例 #10
0
  /**
   * Lit un pret.
   *
   * @param idPret L'ID du pret à lire
   * @return Le pret lu
   * @throws DAOException S'il y a une erreur dans la base de données
   */
  public PretDTO read(int idPret) throws DAOException {

    PretDTO pretDTO = null;

    try (PreparedStatement readPreparedStatement =
        getConnection().prepareStatement(PretDAO.READ_REQUEST)) {
      readPreparedStatement.setInt(1, idPret);
      try (ResultSet resultSet = readPreparedStatement.executeQuery()) {
        if (resultSet.next()) {

          pretDTO = new PretDTO();
          pretDTO.setIdPret(resultSet.getInt(1));

          final MembreDTO membreDTO = new MembreDTO();
          membreDTO.setIdMembre(resultSet.getInt(2));
          pretDTO.setMembreDTO(membreDTO);

          final LivreDTO livreDTO = new LivreDTO();
          livreDTO.setIdLivre(resultSet.getInt(3));
          pretDTO.setLivreDTO(livreDTO);

          pretDTO.setDatePret(resultSet.getTimestamp(4));
          pretDTO.setDateRetour(resultSet.getTimestamp(5));
        }
      }

    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
    return pretDTO;
  }
コード例 #11
0
  /** {@inheritDoc} */
  @Override
  public List<PretDTO> getAll(Connexion connexion, String sortByPropertyName)
      throws InvalidHibernateSessionException, InvalidSortByPropertyException, DAOException {

    if (connexion == null) {
      throw new InvalidHibernateSessionException("La connexion ne peut être null");
    }
    if (sortByPropertyName == null) {
      throw new InvalidSortByPropertyException(
          "La propriété utilisée pour classer les prets ne peut être null");
    }

    List<PretDTO> listeDTO = Collections.EMPTY_LIST;
    try (PreparedStatement getAllPreparedStatement =
            connexion.getConnection().prepareStatement(PretDAO.GET_ALL_REQUEST);
        ResultSet resultSet = getAllPreparedStatement.executeQuery(); ) {
      PretDTO pretDTO = null;
      if (resultSet.next()) {
        listeDTO = new ArrayList<>();
        do {
          pretDTO = new PretDTO();
          pretDTO.setIdPret(resultSet.getString(1));
          pretDTO.getMembreDTO().setIdMembre(resultSet.getString(2));
          pretDTO.getLivreDTO().setIdLivre(resultSet.getString(3));
          pretDTO.setDatePret(resultSet.getTimestamp(4));
          pretDTO.setDateRetour(resultSet.getTimestamp(5));
          listeDTO.add(pretDTO);
        } while (resultSet.next());
      }

    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
    return listeDTO;
  }
コード例 #12
0
  /** {@inheritDoc} */
  @Override
  public List<PretDTO> getAll(Connexion connexion, String sortByPropertyName)
      throws DAOException, InvalidHibernateSessionException, InvalidSortByPropertyException {
    if (connexion == null) {
      throw new InvalidHibernateSessionException("La connexion ne peut être null");
    }
    if (sortByPropertyName == null) {
      throw new InvalidSortByPropertyException("La propriété ne peut être null");
    }
    List<PretDTO> prets = Collections.<PretDTO>emptyList();

    try (PreparedStatement statementGetAllLivres =
        (connexion.getConnection().prepareStatement(PretDAO.GET_ALL_REQUEST))) {
      try (ResultSet resultSet = statementGetAllLivres.executeQuery()) {
        PretDTO pretDTO = null;
        if (resultSet.next()) {
          prets = new ArrayList<>();
          do {

            pretDTO = new PretDTO();
            pretDTO.setIdPret(resultSet.getString(1));

            MembreDTO membre = new MembreDTO();
            membre.setIdMembre(resultSet.getString(2));

            LivreDTO livre = new LivreDTO();
            livre.setIdLivre(resultSet.getString(3));

            pretDTO.setMembreDTO(membre);
            pretDTO.setLivreDTO(livre);
            pretDTO.setDatePret(resultSet.getTimestamp(4));
            pretDTO.setDateRetour(resultSet.getTimestamp(5));

            prets.add(pretDTO);

          } while (resultSet.next());
        }
        return prets;
      } catch (SQLException sqlException) {
        throw new DAOException(
            Integer.toString(sqlException.getErrorCode()) + " " + sqlException.getMessage(),
            sqlException);
      }
    } catch (SQLException sqlException) {
      throw new DAOException(
          Integer.toString(sqlException.getErrorCode()) + " " + sqlException.getMessage(),
          sqlException);
    }
  }
コード例 #13
0
  /** {@inheritDoc} */
  @Override
  public List<PretDTO> findByDatePret(
      Connexion connexion, Timestamp datePret, String sortByPropertyName)
      throws DAOException, InvalidHibernateSessionException, InvalidCriterionException,
          InvalidSortByPropertyException {
    if (connexion == null) {
      throw new InvalidHibernateSessionException("La connexion ne peut être null");
    }
    if (datePret == null) {
      throw new InvalidCriterionException("La date de pret ne peut être null");
    }
    if (sortByPropertyName == null) {
      throw new InvalidSortByPropertyException("La propriété ne peut être null");
    }
    List<PretDTO> pret = Collections.<PretDTO>emptyList();
    try (
    // TODO passer d'un timestamp exact à une date???
    PreparedStatement stmtGetPretsByMembre =
        (connexion.getConnection().prepareStatement(PretDAO.FIND_BY_DATE_PRET)); ) {
      stmtGetPretsByMembre.setTimestamp(1, datePret);
      try (ResultSet rset = stmtGetPretsByMembre.executeQuery()) {

        pret = new ArrayList<>();

        while (rset.next()) {

          PretDTO tempPret = new PretDTO();
          tempPret.setIdPret(rset.getString(1));

          MembreDTO membre = new MembreDTO();
          membre.setIdMembre(rset.getString(2));

          LivreDTO livre = new LivreDTO();
          livre.setIdLivre(rset.getString(3));

          tempPret.setMembreDTO(membre);
          tempPret.setLivreDTO(livre);
          tempPret.setDatePret(rset.getTimestamp(4));
          tempPret.setDateRetour(rset.getTimestamp(5));
        }
      }
    } catch (SQLException sqlException) {
      throw new DAOException(
          Integer.toString(sqlException.getErrorCode()) + " " + sqlException.getMessage(),
          sqlException);
    }
    return pret;
  }
コード例 #14
0
  /** {@inheritDoc} */
  @Override
  public List<PretDTO> findByDateRetour(
      Connexion connexion, Timestamp dateRetour, String sortByPropertyName)
      throws InvalidHibernateSessionException, InvalidCriterionException,
          InvalidSortByPropertyException, DAOException {

    if (connexion == null) {
      throw new InvalidHibernateSessionException("La connexion ne peut être null");
    }
    if (dateRetour == null) {
      throw new InvalidCriterionException("La dateRetour ne peut être null");
    }
    if (sortByPropertyName == null) {
      throw new InvalidSortByPropertyException(
          "La propriété utilisée pour classer les prets ne peut être null");
    }

    List<PretDTO> listePrets = Collections.EMPTY_LIST;
    PretDTO pretDTO = null;

    try (PreparedStatement findByDateRetourPreparedStatement =
        connexion.getConnection().prepareStatement(PretDAO.FIND_BY_DATE_RETOUR); ) {
      findByDateRetourPreparedStatement.setTimestamp(1, dateRetour);
      try (ResultSet resultSet = findByDateRetourPreparedStatement.executeQuery(); ) {
        if (resultSet.next()) {
          listePrets = new ArrayList<>();
          do {
            pretDTO = new PretDTO();
            pretDTO.setIdPret(resultSet.getString(1));
            final MembreDTO membreDTO = new MembreDTO();
            membreDTO.setIdMembre(resultSet.getString(2));
            pretDTO.setMembreDTO(membreDTO);
            final LivreDTO livreDTO = new LivreDTO();
            livreDTO.setIdLivre(resultSet.getString(3));
            pretDTO.setLivreDTO(livreDTO);
            pretDTO.setDatePret(resultSet.getTimestamp(4));
            pretDTO.setDateRetour(resultSet.getTimestamp(5));
            listePrets.add(pretDTO);
          } while (resultSet.next());
        }
      }
    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
    return listePrets;
  }
コード例 #15
0
  /** {@inheritDoc} */
  @Override
  public PretDTO get(Connexion connexion, Serializable primaryKey)
      throws InvalidHibernateSessionException, InvalidPrimaryKeyException, DAOException {

    PretDTO pretDTO = null;

    if (connexion == null) {
      throw new InvalidHibernateSessionException("La connexion ne peut être null");
    }
    if (primaryKey == null) {
      throw new InvalidPrimaryKeyException("Le DTO ne peut être null");
    }

    final String idMembre = (String) primaryKey;
    try (PreparedStatement readPreparedStatement =
        connexion.getConnection().prepareStatement(PretDAO.READ_REQUEST)) {
      readPreparedStatement.setString(1, idMembre);
      try (ResultSet resultSet = readPreparedStatement.executeQuery()) {
        if (resultSet.next()) {

          pretDTO = new PretDTO();
          pretDTO.setIdPret(resultSet.getString(1));

          final MembreDTO membreDTO = new MembreDTO();
          membreDTO.setIdMembre(resultSet.getString(2));
          pretDTO.setMembreDTO(membreDTO);

          final LivreDTO livreDTO = new LivreDTO();
          livreDTO.setIdLivre(resultSet.getString(3));
          pretDTO.setLivreDTO(livreDTO);

          pretDTO.setDatePret(resultSet.getTimestamp(4));
          pretDTO.setDateRetour(resultSet.getTimestamp(5));
        }
      }

    } catch (final SQLException sqlException) {
      throw new DAOException(sqlException);
    }
    return pretDTO;
  }
コード例 #16
0
  /** {@inheritDoc} */
  @Override
  public PretDTO get(Connexion connexion, Serializable primaryKey)
      throws DAOException, InvalidHibernateSessionException, InvalidPrimaryKeyException {
    if (connexion == null) {
      throw new InvalidHibernateSessionException();
    }
    if (primaryKey == null) {
      throw new InvalidPrimaryKeyException();
    }
    String idPret = (String) primaryKey;
    PretDTO tempPret = null;
    try (PreparedStatement statementRead =
        (connexion.getConnection().prepareStatement(PretDAO.READ_REQUEST))) {
      statementRead.setString(1, idPret);

      try (ResultSet rset = statementRead.executeQuery()) {
        if (rset.next()) {

          tempPret = new PretDTO();
          tempPret.setIdPret(rset.getString(1));
          MembreDTO membre = new MembreDTO();
          membre.setIdMembre(rset.getString(2));
          tempPret.setMembreDTO(membre);
          LivreDTO livre = new LivreDTO();
          livre.setIdLivre(rset.getString(3));
          tempPret.setLivreDTO(livre);
          tempPret.setDatePret(rset.getTimestamp(4));
          tempPret.setDateRetour(rset.getTimestamp(5));
          rset.close();
        }
      }
    } catch (SQLException sqlException) {
      throw new DAOException(
          Integer.toString(sqlException.getErrorCode()) + " " + sqlException.getMessage(),
          sqlException);
    }
    return tempPret;
  }