OwnerJdbcDao.java 5.3 KB
Newer Older
1 2 3 4 5 6
package at.ac.tuwien.sepm.assignment.individual.persistence.impl;

import at.ac.tuwien.sepm.assignment.individual.entity.Owner;
import at.ac.tuwien.sepm.assignment.individual.exception.NotFoundException;
import at.ac.tuwien.sepm.assignment.individual.persistence.OwnerDao;
import java.lang.invoke.MethodHandles;
7
import java.sql.PreparedStatement;
8 9
import java.sql.ResultSet;
import java.sql.SQLException;
10
import java.sql.Types;
11
import java.time.LocalDateTime;
12 13 14 15
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
16 17
import org.springframework.dao.DataAccessException;
import org.springframework.dao.DataIntegrityViolationException;
18 19
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
20 21
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
import org.springframework.stereotype.Repository;

@Repository
public class OwnerJdbcDao implements OwnerDao {

    private static final String TABLE_NAME = "Owner";
    private static final Logger LOGGER = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
    private final JdbcTemplate jdbcTemplate;
    private final NamedParameterJdbcTemplate namedParameterJdbcTemplate;

    @Autowired
    public OwnerJdbcDao(JdbcTemplate jdbcTemplate, NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
    }

    @Override
    public Owner findOneById(Long id) {
        LOGGER.trace("Get owner with id {}", id);
        final String sql = "SELECT * FROM " + TABLE_NAME + " WHERE id=?";
        List<Owner> owners = jdbcTemplate.query(sql, new Object[] { id }, this::mapRow);

        if (owners.isEmpty()) throw new NotFoundException("Could not find owner with id " + id);

        return owners.get(0);
    }

49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
    @Override
    public Owner addOwner(Owner owner) {
        LOGGER.trace("Add owner {}", owner);
        final String sql = "INSERT INTO " + TABLE_NAME + "(name, created_at, updated_at) VALUES(?,?,?)";

        try {
            // Check if the constraints are violated
            this.validateOwner(owner);

            LocalDateTime currentTime = LocalDateTime.now();

            owner.setCreatedAt(currentTime);
            owner.setUpdatedAt(currentTime);

            // Create a key holder to get the key of the new record
            KeyHolder keyHolder = new GeneratedKeyHolder();

            int changes = jdbcTemplate.update(connection -> {
                PreparedStatement ps = connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);

                ps.setString(1, owner.getName());
                ps.setObject(2, owner.getCreatedAt());
                ps.setObject(3, owner.getUpdatedAt());
                return ps;
            }, keyHolder);

            if (changes == 0)
                throw new DataAccessException("Creating owner failed, no rows affected") {};

            owner.setId(((Number)keyHolder.getKeys().get("id")).longValue());

            return owner;

        } catch (DataAccessException e) {
            // We are doing this in order to not change the exception type
            throw new DataAccessException("Adding new records failed", e) {};
        }
    }

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
    @Override
    public Owner updateOwner(Owner owner) throws DataAccessException {
        LOGGER.trace("Update owner {}", owner.toString());
        String sql = "UPDATE " + TABLE_NAME + " SET name=?, updated_at=? WHERE id=?";

        try {
            if(owner.getId() == null || owner.getId() == 0)
                throw new DataIntegrityViolationException("Horse Id missing or 0");

            this.validateOwner(owner);

            Owner oldOwner = findOneById(owner.getId());

            LocalDateTime currentTime = LocalDateTime.now();

            owner.setUpdatedAt(currentTime);

            int changes = jdbcTemplate.update(connection -> {
                PreparedStatement ps = connection.prepareStatement(sql);

                ps.setString(1, owner.getName());
                ps.setObject(2, owner.getUpdatedAt());
                ps.setObject(3, owner.getId());
                return ps;
            });

            if (changes == 0)
                throw new DataAccessException("Updating owner failed, no rows affected") {};

            owner.setCreatedAt(oldOwner.getCreatedAt());

            return owner;
        } catch(DataAccessException e) {
            // We are doing this in order to not change the exception type
            throw new DataAccessException("Updating records failed", e) {};
        }
    }

126 127 128 129
    private void validateOwner(Owner owner) throws DataIntegrityViolationException {
        if(owner.getName() == null || owner.getName().isEmpty())
            throw new DataIntegrityViolationException("Required parameters for owner missing");
    }
130 131 132 133 134 135 136 137 138 139 140

    private Owner mapRow(ResultSet resultSet, int i) throws SQLException {
        final Owner owner = new Owner();
        owner.setId(resultSet.getLong("id"));
        owner.setName(resultSet.getString("name"));
        owner.setCreatedAt(resultSet.getTimestamp("created_at").toLocalDateTime());
        owner.setUpdatedAt(resultSet.getTimestamp("updated_at").toLocalDateTime());
        return owner;
    }

}