diff --git a/src/main/java/org/dbms/storageImpl/CarStorage.java b/src/main/java/org/dbms/storageImpl/CarStorage.java new file mode 100644 index 0000000..c1bb378 --- /dev/null +++ b/src/main/java/org/dbms/storageImpl/CarStorage.java @@ -0,0 +1,129 @@ +package org.dbms.storageImpl; + +import java.io.IOException; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.*; + +import org.dbms.models.Car; +import org.dbms.models.Parking; +import org.dbms.storageContracts.ICarStorage; +import org.dbms.storageContracts.IParkingStorage; +import org.springframework.stereotype.Component; + + +@Component +public class CarStorage implements ICarStorage { + + private final static String readRecords; + private final static String readRecordById; + private final static String insertRecord; + private final static String deleteRecord; + + static + { + readRecords = "SELECT id, model, year, cost, parkingId FROM cars"; + readRecordById = new StringBuilder() + .append("SELECT id, model, year, cost, parkingId FROM cars") + .append("\n") + .append("WHERE id = ?").toString(); + + insertRecord = "INSERT INTO cars (model, year, cost, parkingId) VALUES(?, ?, ?, ?)"; + deleteRecord = "DELETE FROM cars WHERE id = ?"; + } + + private final Connection connection; + private final IParkingStorage parkingStorage; + + public CarStorage(Connection connection, IParkingStorage parkingStorage) { + this.connection = connection; + this.parkingStorage = parkingStorage; + } + @Override + public List readAll() { + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecords); + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String model = resultSet.getString(2); + Date year = resultSet.getDate(3); + Double cost = resultSet.getDouble(4); + Long parkingId = resultSet.getLong(5); + + Parking p = parkingStorage.getElementById(parkingId); + + list.add(new Car(id, model, year, cost, p)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public Car getElementById(Long carId) { + Car res = null; + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecordById); + preparedStatement.setLong(1, carId); + + ResultSet resultSet = preparedStatement.executeQuery(); + if(!resultSet.next()) return null; + Long id = resultSet.getLong(1); + String model = resultSet.getString(2); + Date year = resultSet.getDate(3); + Double cost = resultSet.getDouble(4); + Long parkingId = resultSet.getLong(5); + + Parking p = parkingStorage.getElementById(parkingId); + + res = new Car(id, model, year, cost, p); + + resultSet.close(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + public void insert(Car car) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(insertRecord); + + preparedStatement.setString(1, car.getModel()); + preparedStatement.setDate(2, new java.sql.Date(car.getYear().getTime())); + preparedStatement.setDouble(3, car.getCost()); + preparedStatement.setLong(4, car.getParking().getId()); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + @Override + public void delete(Long carId) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(deleteRecord); + preparedStatement.setLong(1, carId); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/src/main/java/org/dbms/storageImpl/ClientStorage.java b/src/main/java/org/dbms/storageImpl/ClientStorage.java new file mode 100644 index 0000000..4e3f695 --- /dev/null +++ b/src/main/java/org/dbms/storageImpl/ClientStorage.java @@ -0,0 +1,179 @@ +package org.dbms.storageImpl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.*; + +import org.dbms.models.Client; +import org.dbms.models.Parking; +import org.dbms.storageContracts.IClientStorage; +import org.springframework.stereotype.Component; + + +@Component +public class ClientStorage implements IClientStorage { + + private final static String readRecords; + private final static String readRecordById; + private final static String readRecordByLogin; + private final static String insertRecord; + private final static String deleteRecord; + private final static String loginExistQuery; + + static + { + readRecords = "SELECT id, name, phone, login, password FROM clients"; + readRecordById = new StringBuilder() + .append("SELECT id, name, phone, login, password FROM clients") + .append("\n") + .append("WHERE id = ?").toString(); + readRecordByLogin = new StringBuilder() + .append("SELECT id, name, phone, login, password FROM clients") + .append("\n") + .append("WHERE login = ?").toString(); + insertRecord = "INSERT INTO clients (name, phone, login, password) VALUES(?, ?, ?, ?)"; + deleteRecord = "DELETE FROM clients WHERE id = ?"; + loginExistQuery = "SELECT id FROM clients WHERE login = ?"; + } + + private final Connection connection; + + public ClientStorage(Connection connection) { + this.connection = connection; + } + + + @Override + public List readAll() { + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecords); + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String name = resultSet.getString(2); + String phone = resultSet.getString(3); + String login = resultSet.getString(4); + String password = resultSet.getString(5); + + list.add(new Client(id, name, phone, login, password)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public Client getElementById(Long clientId) { + Client res = null; + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecordById); + preparedStatement.setLong(1, clientId); + + ResultSet resultSet = preparedStatement.executeQuery(); + + resultSet.next(); + Long id = resultSet.getLong(1); + String name = resultSet.getString(2); + String phone = resultSet.getString(3); + String login = resultSet.getString(4); + String password = resultSet.getString(5); + + res = new Client(id, name, phone, login, password); + + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + @Override + public void insert(Client client) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(insertRecord); + + preparedStatement.setString(1, client.getName()); + preparedStatement.setString(2, client.getPhone()); + preparedStatement.setString(3, client.getLogin()); + preparedStatement.setString(4, client.getPassword()); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + @Override + public void delete(Long clientId) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(deleteRecord); + preparedStatement.setLong(1, clientId); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + @Override + public Client getByLogin(String clientLogin) { + Client res = null; + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecordByLogin); + preparedStatement.setString(1, clientLogin); + + ResultSet resultSet = preparedStatement.executeQuery(); + + if(!resultSet.next()) return null; + + Long id = resultSet.getLong(1); + String name = resultSet.getString(2); + String phone = resultSet.getString(3); + String login = resultSet.getString(4); + String password = resultSet.getString(5); + + res = new Client(id, name, phone, login, password); + + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + @Override + public String getIdByLogin(String login) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(loginExistQuery); + preparedStatement.setString(1, login); + + ResultSet resultSet = preparedStatement.executeQuery(); + if(resultSet.next()) { + return resultSet.getInt(1) + ""; + } + + return null; + } catch (SQLException e) { + e.printStackTrace(); + } + + return null; + } +} \ No newline at end of file diff --git a/src/main/java/org/dbms/storageImpl/DriverStorage.java b/src/main/java/org/dbms/storageImpl/DriverStorage.java new file mode 100644 index 0000000..3facab4 --- /dev/null +++ b/src/main/java/org/dbms/storageImpl/DriverStorage.java @@ -0,0 +1,394 @@ +package org.dbms.storageImpl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.*; + +import org.dbms.models.Car; +import org.dbms.models.Client; +import org.dbms.models.Driver; +import org.dbms.models.Order; +import org.dbms.searchModels.DriverSearch; +import org.dbms.storageContracts.ICarStorage; +import org.dbms.storageContracts.IDriverStorage; +import org.springframework.stereotype.Component; + + +@Component +public class DriverStorage implements IDriverStorage { + + private final static String readRecords; + private final static String readPage; + private final static String readCount; + private final static String readFiltered; + private final static String readFilteredCount; + private final static String readRecordById; + private final static String insertRecord; + private final static String deleteRecord; + + static + { + readRecords = "SELECT id, name, licenseYear, carId FROM drivers"; + readCount = "SELECT COUNT(*) FROM drivers"; + readPage = new StringBuilder() + .append("SELECT id, name, licenseYear, carId FROM drivers") + .append("\n") + .append("ORDER BY id") + .append("\n") + .append("OFFSET ?") + .append("\n") + .append("LIMIT ?").toString(); + readRecordById = new StringBuilder() + .append("SELECT id, name, licenseYear, carId FROM drivers") + .append("\n") + .append("WHERE id = ?").toString(); + readFiltered = new StringBuilder() + .append("SELECT id, name, licenseYear, carId FROM drivers") + .append("\n") + .append("WHERE ").toString(); + readFilteredCount = new StringBuilder() + .append("SELECT COUNT(*) FROM drivers") + .append("\n") + .append("WHERE ").toString(); + insertRecord = "INSERT INTO drivers (name, licenseYear, carId) VALUES(?, ?, ?)"; + deleteRecord = "DELETE FROM drivers WHERE id = ?"; + } + + private final Connection connection; + private final ICarStorage carStorage; + + public DriverStorage(Connection connection, ICarStorage carStorage) { + this.connection = connection; + this.carStorage = carStorage; + } + + @Override + public List readAll() { + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecords); + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String name = resultSet.getString(2); + Date licenseYear = resultSet.getDate(3); + Long carId = resultSet.getLong(4); + + Car c = carStorage.getElementById(carId); + + list.add(new Driver(id, name, licenseYear, c)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public List readPage(int size, int page) { + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(readPage); + preparedStatement.setInt(1, page - 1); + preparedStatement.setInt(2, size); + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String name = resultSet.getString(2); + Date licenseYear = resultSet.getDate(3); + Long carId = resultSet.getLong(4); + + Car c = carStorage.getElementById(carId); + + list.add(new Driver(id, name, licenseYear, c)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + public int getCount() { + int res = 0; + try { + PreparedStatement preparedStatement = connection.prepareStatement(readCount); + + ResultSet resultSet = preparedStatement.executeQuery(); + + if (resultSet.next()) { + res = resultSet.getInt(1); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + @Override + public int getFilteredCount(DriverSearch filter) { + if(filter.expirienceTo == null && filter.expirienceFrom == null) return getCount(); + + StringBuilder query = new StringBuilder(readFilteredCount); + + boolean isFirst = true; + + if(filter.expirienceFrom != null) { + if(!isFirst) { + query.append(" AND "); + } + + query.append("EXTRACT(YEAR FROM age(NOW(), licenseYear)) >= ?"); + query.append("\n"); + isFirst = false; + } + + if(filter.expirienceTo != null) { + if(!isFirst) { + query.append(" AND "); + } + + query.append("EXTRACT(YEAR FROM age(NOW(), licenseYear)) <= ?"); + query.append("\n"); + } + + int res = 0; + try { + PreparedStatement preparedStatement = connection.prepareStatement(query.toString()); + + int index = 1; + + if(filter.expirienceFrom != null) { + preparedStatement.setInt(index++, filter.expirienceFrom); + } + + if(filter.expirienceTo != null) { + preparedStatement.setInt(index, filter.expirienceTo); + } + + ResultSet resultSet = preparedStatement.executeQuery(); + + if (resultSet.next()) { + res = resultSet.getInt(1); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + @Override + public List getFilteredList(DriverSearch filter) { + if(filter.expirienceTo == null && filter.expirienceFrom == null) return readAll(); + + StringBuilder query = new StringBuilder(readFiltered); + + boolean isFirst = true; + + if(filter.expirienceFrom != null) { + if(!isFirst) { + query.append(" AND "); + } + + query.append("EXTRACT(YEAR FROM age(NOW(), licenseYear)) >= ?"); + query.append("\n"); + isFirst = false; + } + + if(filter.expirienceTo != null) { + if(!isFirst) { + query.append(" AND "); + } + + query.append("EXTRACT(YEAR FROM age(NOW(), licenseYear)) <= ?"); + query.append("\n"); + } + + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(query.toString()); + + int index = 1; + + if(filter.expirienceFrom != null) { + preparedStatement.setInt(index++, filter.expirienceFrom); + } + + if(filter.expirienceTo != null) { + preparedStatement.setInt(index, filter.expirienceTo); + } + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String name = resultSet.getString(2); + Date licenseYear = resultSet.getDate(3); + Long carId = resultSet.getLong(4); + + Car c = carStorage.getElementById(carId); + + list.add(new Driver(id, name, licenseYear, c)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public List getFilteredPage(DriverSearch filter, int size, int page) { + if(filter.expirienceTo == null && filter.expirienceFrom == null) return readPage(size, page); + + StringBuilder query = new StringBuilder(readFiltered); + + boolean isFirst = true; + + if(filter.expirienceFrom != null) { + if(!isFirst) { + query.append(" AND "); + } + + query.append("EXTRACT(YEAR FROM age(NOW(), licenseYear)) >= ?"); + query.append("\n"); + isFirst = false; + } + + if(filter.expirienceTo != null) { + if(!isFirst) { + query.append(" AND "); + } + + query.append("EXTRACT(YEAR FROM age(NOW(), licenseYear)) <= ?"); + query.append("\n"); + } + + query.append("ORDER BY id"); + query.append("\n"); + query.append("OFFSET ?"); + query.append("LIMIT ?"); + + + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(query.toString()); + int index = 1; + + if(filter.expirienceFrom != null) { + preparedStatement.setInt(index++, filter.expirienceFrom); + } + + if(filter.expirienceTo != null) { + preparedStatement.setInt(index++, filter.expirienceTo); + } + + preparedStatement.setInt(index++, page - 1); + preparedStatement.setInt(index, size); + + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String name = resultSet.getString(2); + Date licenseYear = resultSet.getDate(3); + Long carId = resultSet.getLong(4); + + Car c = carStorage.getElementById(carId); + + list.add(new Driver(id, name, licenseYear, c)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public Driver getElementById(Long driverId) { + Driver res = null; + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecordById); + preparedStatement.setLong(1, driverId); + + ResultSet resultSet = preparedStatement.executeQuery(); + + resultSet.next(); + Long id = resultSet.getLong(1); + String name = resultSet.getString(2); + Date licenseYear = resultSet.getDate(3); + Long carId = resultSet.getLong(4); + + Car c = carStorage.getElementById(carId); + + res = new Driver(id, name, licenseYear, c); + + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + @Override + public void insert(Driver driver) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(insertRecord); + + preparedStatement.setString(1, driver.getName()); + preparedStatement.setDate(2, new java.sql.Date(driver.getLicenseYear().getTime())); + preparedStatement.setLong(3, driver.getCar().getId()); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + @Override + public void delete(Long driverId) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(deleteRecord); + preparedStatement.setLong(1, driverId); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file diff --git a/src/main/java/org/dbms/storageImpl/OrderStorage.java b/src/main/java/org/dbms/storageImpl/OrderStorage.java new file mode 100644 index 0000000..5e77799 --- /dev/null +++ b/src/main/java/org/dbms/storageImpl/OrderStorage.java @@ -0,0 +1,255 @@ +package org.dbms.storageImpl; + +import java.io.IOException; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.*; + +import org.dbms.models.*; +import org.dbms.storageContracts.IClientStorage; +import org.dbms.storageContracts.IDriverStorage; +import org.dbms.storageContracts.IOrderStorage; +import org.springframework.stereotype.Component; + + +@Component +public class OrderStorage implements IOrderStorage { + + private final static String readRecords; + private final static String readPage; + private final static String readCount; + private final static String readRecordById; + private final static String insertRecord; + private final static String deleteRecord; + private final static String readRecordByClientId; + + static + { + readRecords = "SELECT id, _from, _to, price, deliveryWeight, driverId, clientId FROM orders"; + readCount = "SELECT COUNT(*) FROM orders WHERE clientId = ?"; + readPage = new StringBuilder() + .append("SELECT id, _from, _to, price, deliveryWeight, driverId, clientId FROM orders") + .append("\n") + .append("WHERE clientId = ?") + .append("\n") + .append("ORDER BY id") + .append("\n") + .append("OFFSET ?") + .append("\n") + .append("LIMIT ?").toString(); + + readRecordById = new StringBuilder() + .append("SELECT id, _from, _to, price, deliveryWeight, driverId, clientId FROM orders") + .append("\n") + .append("WHERE id = ?").toString(); + readRecordByClientId = new StringBuilder() + .append("SELECT id, _from, _to, price, deliveryWeight, driverId, clientId FROM orders") + .append("\n") + .append("WHERE clientId = ?").toString(); + insertRecord = "INSERT INTO orders (_from, _to, price, deliveryWeight, driverId, clientId) VALUES(?, ?, ?, ?, ?, ?)"; + deleteRecord = "DELETE FROM orders WHERE id = ?"; + } + + private final Connection connection; + private final IDriverStorage driverStorage; + private final IClientStorage clientStorage; + + public OrderStorage(Connection connection, IDriverStorage driverStorage, IClientStorage clientStorage) { + this.connection = connection; + this.driverStorage = driverStorage; + this.clientStorage = clientStorage; + } + + @Override + public List readAll() { + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecords); + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String from = resultSet.getString(2); + String to = resultSet.getString(3); + Double price = resultSet.getDouble(4); + int deliveryWeight = resultSet.getInt(5); + Long driverId = resultSet.getLong(5); + Long clientId = resultSet.getLong(5); + + Driver d = driverStorage.getElementById(driverId); + Client c = clientStorage.getElementById(clientId); + + list.add(new Order(id, from, to, price, deliveryWeight, d, c)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public List readPageByClientId(int size, int page, Long cid) { + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(readPage); + + preparedStatement.setLong(1, cid); + preparedStatement.setInt(2, page - 1); + preparedStatement.setInt(3, size); + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String from = resultSet.getString(2); + String to = resultSet.getString(3); + Double price = resultSet.getDouble(4); + int deliveryWeight = resultSet.getInt(5); + Long driverId = resultSet.getLong(6); + Long clientId = resultSet.getLong(7); + + Driver d = driverStorage.getElementById(driverId); + Client c = clientStorage.getElementById(clientId); + + list.add(new Order(id, from, to, price, deliveryWeight, d, c)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public int getCountByClientId(Long clientId) { + int res = 0; + try { + PreparedStatement preparedStatement = connection.prepareStatement(readCount); + + preparedStatement.setLong(1, clientId); + ResultSet resultSet = preparedStatement.executeQuery(); + + if (resultSet.next()) { + res = resultSet.getInt(1); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + @Override + public Order getElementById(Long orderId) { + Order res = null; + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecordById); + preparedStatement.setLong(1, orderId); + + ResultSet resultSet = preparedStatement.executeQuery(); + + resultSet.next(); + Long id = resultSet.getLong(1); + String from = resultSet.getString(2); + String to = resultSet.getString(3); + Double price = resultSet.getDouble(4); + int deliveryWeight = resultSet.getInt(5); + Long driverId = resultSet.getLong(5); + Long clientId = resultSet.getLong(5); + + Driver d = driverStorage.getElementById(driverId); + Client c = clientStorage.getElementById(clientId); + + res = new Order(id, from, to, price, deliveryWeight, d, c); + + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + @Override + public List getOrdersByClientId(Long cid) { + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecordByClientId); + preparedStatement.setLong(1, cid); + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String from = resultSet.getString(2); + String to = resultSet.getString(3); + Double price = resultSet.getDouble(4); + int deliveryWeight = resultSet.getInt(5); + Long driverId = resultSet.getLong(6); + Long clientId = resultSet.getLong(7); + + Driver d = driverStorage.getElementById(driverId); + Client c = clientStorage.getElementById(clientId); + + list.add(new Order(id, from, to, price, deliveryWeight, d, c)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public void insert(Order order) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(insertRecord); + + preparedStatement.setString(1, order.getFrom()); + preparedStatement.setString(2, order.getTo()); + preparedStatement.setDouble(3, order.getPrice()); + preparedStatement.setInt(4, order.getDeliveryWeight()); + preparedStatement.setLong(5, order.getDriver().getId()); + preparedStatement.setLong(6, order.getClient().getId()); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + @Override + public void delete(Long orderId) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(deleteRecord); + preparedStatement.setLong(1, orderId); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + +} \ No newline at end of file diff --git a/src/main/java/org/dbms/storageImpl/ParkingStorage.java b/src/main/java/org/dbms/storageImpl/ParkingStorage.java new file mode 100644 index 0000000..938e8d4 --- /dev/null +++ b/src/main/java/org/dbms/storageImpl/ParkingStorage.java @@ -0,0 +1,119 @@ +package org.dbms.storageImpl; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.*; + +import org.dbms.models.Client; +import org.dbms.models.Parking; +import org.dbms.storageContracts.IParkingStorage; +import org.springframework.stereotype.Component; + + +@Component +public class ParkingStorage implements IParkingStorage { + + private final static String readRecords; + private final static String readRecordById; + private final static String insertRecord; + private final static String deleteRecord; + + static + { + readRecords = "SELECT id, address, capacity FROM parkings"; + readRecordById = new StringBuilder() + .append("SELECT id, address, capacity FROM parkings") + .append("\n") + .append("WHERE id = ?").toString(); + insertRecord = "INSERT INTO parkings (address, capacity) VALUES(?, ?)"; + deleteRecord = "DELETE FROM parkings WHERE id = ?"; + } + + + private final Connection connection; + + public ParkingStorage(Connection connection) { + this.connection = connection; + } + + @Override + public List readAll() { + ArrayList list = new ArrayList<>(); + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecords); + + ResultSet resultSet = preparedStatement.executeQuery(); + + list.ensureCapacity(resultSet.getFetchSize()); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String address = resultSet.getString(2); + int capacity = resultSet.getInt(3); + + list.add(new Parking(id, address, capacity)); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return list; + } + + @Override + public Parking getElementById(Long parkingId) { + Parking res = null; + try { + PreparedStatement preparedStatement = connection.prepareStatement(readRecordById); + preparedStatement.setLong(1, parkingId); + + ResultSet resultSet = preparedStatement.executeQuery(); + + while (resultSet.next()) { + Long id = resultSet.getLong(1); + String address = resultSet.getString(2); + int capacity = resultSet.getInt(3); + + res = new Parking(id, address, capacity); + } + resultSet.close(); + preparedStatement.close(); + + } catch (SQLException e) { + e.printStackTrace(); + } + return res; + } + + @Override + public void insert(Parking parking) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(insertRecord); + + preparedStatement.setString(1, parking.getAddress()); + preparedStatement.setInt(2, parking.getCapacity()); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + @Override + public void delete(Long parkingId) { + try { + PreparedStatement preparedStatement = connection.prepareStatement(deleteRecord); + preparedStatement.setLong(1, parkingId); + + preparedStatement.executeUpdate(); + preparedStatement.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } +} \ No newline at end of file