Aplikacja "waluty"

pom.xml

@@ -27,6 +27,12 @@
             <version>3.49.1.0</version>
             <scope>runtime</scope>
         </dependency>
+        <dependency>
+            <groupId>org.eclipse.parsson</groupId>
+            <artifactId>jakarta.json</artifactId>
+            <version>1.1.7</version>
+            <!-- starsza wersja: org.glassfish:jakarta.json:2.0.1 -->
+        </dependency>
     </dependencies>
 
 </project>
\ No newline at end of file

src/main/java/bazy/postgresql/P07_GenerowaneId.java

@@ -28,7 +28,7 @@ public class P07_GenerowaneId {
         try(Connection c = DriverManager.getConnection(Ustawienia.URL, Ustawienia.USER, Ustawienia.PASSWD);
          PreparedStatement stmt = c.prepareStatement(sql, polaGenerowane)) {
 
-         stmt.setString(1, "Nowa z " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:SS")));
+         stmt.setString(1, "Nowa z " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
          stmt.setString(2, "01-321");
          stmt.setString(3, "Warszawa");
          stmt.setString(4, "US");

src/main/java/bazy/postgresql/P08a_ModyfikacjaPoprzezWynik.java

@@ -13,10 +13,8 @@ public class P08a_ModyfikacjaPoprzezWynik {
 
         final String sql = "SELECT * FROM departments WHERE department_id < ? ORDER BY department_id";
         try(Connection c = DriverManager.getConnection(Ustawienia.URL, Ustawienia.USER, Ustawienia.PASSWD)) {
-            
             try(PreparedStatement stmt = c.prepareStatement(sql,
                     ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE)) {
-
                 stmt.setInt(1, limit);
                 try(ResultSet rs = stmt.executeQuery()) {
                 	System.out.println("Nazwa kursora: " + rs.getCursorName());

src/main/java/bazy/postgresql/P09_DowolnaKolejnoscResultSet.java

@@ -63,7 +63,6 @@ public class P09_DowolnaKolejnoscResultSet {
                                 nazwisko = rs.getString(3);
                                 System.out.printf("         ... a następny ma na nazwisko %s\n", nazwisko);
                             }
-                            
                         } else {
                             System.out.printf("\npoz %3d - nie ma takiej pozycji\n", poz);
                         }

src/main/java/bazy/postgresql/P11_Metadane.java

@@ -19,6 +19,7 @@ public class P11_Metadane {
             System.out.println(dbMetaData.getDatabaseProductName());
             System.out.println(dbMetaData.getDatabaseMajorVersion()
                     + "." + dbMetaData.getDatabaseMinorVersion());
+            System.out.printf("maxStatements: " + dbMetaData.getMaxStatements());
             System.out.println();
             
             try(ResultSet tables = dbMetaData.getTables(null, "public", null, null)) {

src/main/java/bazy/postgresql/P12_MultiResult.java

@@ -12,10 +12,11 @@ public class P12_MultiResult {
         try (Connection c = DriverManager.getConnection(Ustawienia.URL, Ustawienia.USER, Ustawienia.PASSWD)) {
             try (Statement stmt = c.createStatement()) {
                 // Kilka zapytań w jednym stringu
-                String sql = "SELECT * FROM countries;"
-                        + " SELECT * FROM jobs;"
-                        + " SELECT first_name, last_name FROM employees";
-
+                String sql = """
+                        SELECT * FROM countries;
+                        SELECT * FROM jobs;"
+                        SELECT first_name, last_name FROM employees
+                        """;
                 if(stmt.execute(sql)) // jeśli jest pierwszy ResultSet
                 do {
                     try (ResultSet rs = stmt.getResultSet()) {

src/main/java/bazy/postgresql/P13a_Blob_Create.java

@@ -12,7 +12,7 @@ public class P13a_Blob_Create {
 
 	public static void main(String[] args) {
 		final String sql = """
-					DROP TABLE IF EXISTS photos; 
+					DROP TABLE IF EXISTS photos;
 				    CREATE TABLE photos(
 				        photo_id SERIAL PRIMARY KEY,
 				        file_name VARCHAR(60) NOT NULL,

src/main/java/waluty/BladAplikacji.java

+package waluty;
+
+public class BladAplikacji extends Exception {
+
+	public BladAplikacji() {
+		super();
+	}
+
+	public BladAplikacji(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+	public BladAplikacji(String message) {
+		super(message);
+	}
+
+	public BladAplikacji(Throwable cause) {
+		super(cause);
+	}
+
+}

src/main/java/waluty/DrukujWaluty.java

+package waluty;
+
+public class DrukujWaluty {
+
+    public static void main(String[] args) {
+        // Pobieranie pobieranie = new PobieranieXML();
+        Pobieranie pobieranie = new PobieranieJSON();
+        // Pobieranie pobieranie = Pobieranie.utworz("XML");
+        // Pobieranie pobieranie = Pobieranie.utworz("JSON");
+        try {
+            TabelaWalut tabelaWalut = pobieranie.pobierzBiezaceKursy();
+            System.out.println(tabelaWalut);
+            for(Waluta waluta : tabelaWalut.getRates()) {
+                System.out.println(waluta);
+            }
+        } catch (BladAplikacji e) {
+            e.printStackTrace();
+        }
+    }
+
+}

src/main/java/waluty/Pobieranie.java

+package waluty;
+
+import java.time.LocalDate;
+
+public abstract class Pobieranie {
+
+    protected static final String ADRES_BAZOWY = "https://api.nbp.pl/api/exchangerates/tables";
+
+    public abstract TabelaWalut pobierzBiezaceKursy() throws BladAplikacji;
+
+    public abstract TabelaWalut pobierzArchiwalneKursy(String data) throws BladAplikacji;
+
+    // Jeśli jakaś część implementacji jest wpólna dla wszystkich podklas,
+    // to można umieścić ja w klasie abstrakcyjnej
+    public TabelaWalut pobierzArchiwalneKursy(LocalDate data) throws BladAplikacji {
+        return pobierzArchiwalneKursy(data.toString());
+    }
+
+    // fabryka nowych obiektów
+    public static Pobieranie utworz(String format) {
+        return switch(format.toUpperCase()) {
+            case "XML" -> new PobieranieXML();
+            case "JSON" -> new PobieranieJSON();
+            default -> throw new IllegalArgumentException("Nieznany format " + format);
+        };
+    }
+
+}

src/main/java/waluty/PobieranieJSON.java

+package waluty;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.time.LocalDate;
+
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+import jakarta.json.JsonValue;
+
+public class PobieranieJSON extends Pobieranie {
+
+	public TabelaWalut pobierzBiezaceKursy() throws BladAplikacji {
+		String adres = ADRES_BAZOWY + "/A?format=json";
+		return pobierzZAdresu(adres);
+	}
+
+	public TabelaWalut pobierzArchiwalneKursy(String data) throws BladAplikacji {
+        return pobierzZAdresu(ADRES_BAZOWY + "/A/" + data + "?format=json");
+    }
+
+	private TabelaWalut pobierzZAdresu(String adres) throws BladAplikacji {
+		try(HttpClient httpClient = HttpClient.newHttpClient()) {
+			URI uri = new URI(adres);
+			HttpRequest request = HttpRequest.newBuilder(uri).build();
+			HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());
+			if(response.statusCode() != 200) {
+				throw new BladAplikacji("Zapytanie HTTP zwróciło " + response.statusCode());
+			}
+			// dane odebrane z sieci "parsujemy" jako JSON
+			try(JsonReader reader = Json.createReader(response.body())) {
+				JsonArray array = reader.readArray();
+				JsonObject tabela = array.getJsonObject(0);
+				String no = tabela.getString("no");
+				LocalDate effectiveDate = LocalDate.parse(tabela.getString("effectiveDate"));
+				TabelaWalut tabelaWalut = new TabelaWalut(no, effectiveDate);
+
+				JsonArray rates = tabela.getJsonArray("rates");
+				for(JsonValue rate : rates) {
+					JsonObject rateObj = rate.asJsonObject();
+					Waluta waluta = new Waluta(rateObj.getString("code"),
+							rateObj.getString("currency"),
+							rateObj.getJsonNumber("mid").bigDecimalValue());
+					tabelaWalut.addRate(waluta);
+				}
+				return tabelaWalut;
+			}
+		} catch (URISyntaxException | IOException | InterruptedException e) {
+			throw new BladAplikacji(e);
+		}
+	}
+
+}

src/main/java/waluty/PobieranieXML.java

+package waluty;
+
+import java.io.InputStream;
+import java.math.BigDecimal;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public class PobieranieXML extends Pobieranie {
+    private HttpClient httpClient = HttpClient.newHttpClient();
+    private DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+    private XPathFactory xpf = XPathFactory.newInstance();
+
+    @Override
+    public TabelaWalut pobierzBiezaceKursy() throws BladAplikacji {
+        return pobierzZAdresu(ADRES_BAZOWY + "/A" + "?format=xml");
+    }
+
+    @Override
+    public TabelaWalut pobierzArchiwalneKursy(String data) throws BladAplikacji {
+        return pobierzZAdresu(ADRES_BAZOWY + "/A/" + data + "?format=xml");
+    }
+
+    private TabelaWalut pobierzZAdresu(String adres) throws BladAplikacji {
+        try {
+            URI uri = new URI(adres);
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());
+            if(response.statusCode() != 200) {
+                throw new BladAplikacji("Brak danych w odpowiedzi HTTP, kod " + response.statusCode());
+            }
+            DocumentBuilder builder = dbf.newDocumentBuilder();
+            Document document = builder.parse(response.body());
+            return tabelaZXML(document);
+        } catch(BladAplikacji e) {
+            throw e;
+        } catch(Exception e) {
+            throw new BladAplikacji("Błąd podczas pobierania XML: " + e.getMessage(), e);
+        }
+    }
+
+    private TabelaWalut tabelaZXML(Document document) throws XPathExpressionException {
+        XPath xpath = xpf.newXPath();
+
+//        String no = xpath.evaluate("/ArrayOfExchangeRatesTable/ExchangeRatesTable/No", document);
+//        String date = xpath.evaluate("/ArrayOfExchangeRatesTable/ExchangeRatesTable/EffectiveDate", document);
+        String no = xpath.evaluate("//No", document);
+        String date = xpath.evaluate("//EffectiveDate", document);
+        TabelaWalut tabela = new TabelaWalut(no, date);
+
+        NodeList rates = (NodeList) xpath.evaluate("//Rate", document, XPathConstants.NODESET);
+        final int length = rates.getLength();
+        for(int i = 0; i < length; i++) {
+            Node rate = rates.item(i);
+            String currency = xpath.evaluate("Currency", rate);
+            String code = xpath.evaluate("Code", rate);
+            BigDecimal mid = new BigDecimal(xpath.evaluate("Mid", rate));
+            Waluta waluta = new Waluta(code, currency, mid);
+            tabela.addRate(waluta);
+        }
+        return tabela;
+    }
+
+}

src/main/java/waluty/PrzelicznikKonsolowy.java

+
+package waluty;
+
+import java.math.BigDecimal;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.Scanner;
+
+public class PrzelicznikKonsolowy {
+    private Scanner scanner;
+    private Pobieranie pobieranie;
+
+    public PrzelicznikKonsolowy() {
+        scanner = new Scanner(System.in);
+        scanner.useLocale(Locale.US);
+    }
+
+    public static void main(String[] args) {
+        new PrzelicznikKonsolowy().run();
+    }
+
+    public void run() {
+        System.out.println("Wybierz format danych: XML / JSON");
+        String format = scanner.nextLine().trim().toUpperCase();
+        switch(format) {
+            case "XML" -> pobieranie = new PobieranieXML();
+            case "", "JSON" -> pobieranie = new PobieranieJSON();
+            default -> {
+                System.out.println("Nieznany format, kończę program.");
+                return;
+            }
+        }
+
+        program: while(true) {
+            System.out.println("\nWpisz datę w formacie YYYY-MM-DD lub naciśnij ENTER, aby pobrać bieżące kursy.");
+            System.out.println("Możesz też wpisać Q , aby zakończyć program");
+            String data = scanner.nextLine();
+            try {
+                TabelaWalut tabela;
+                switch(data) {
+                    case "q", "Q" -> {break program;}
+                    case "" -> tabela = pobieranie.pobierzBiezaceKursy();
+                    default -> tabela = pobieranie.pobierzArchiwalneKursy(data);
+                }
+                dzialajDlaWybranejTabeli(tabela);
+            } catch(BladAplikacji e) {
+                System.out.println("Wyjątek! " + e.getMessage());
+            }
+        }
+        System.out.println("Koniec programu");
+    }
+
+    private void dzialajDlaWybranejTabeli(TabelaWalut tabela) {
+        System.out.println(tabela);
+
+        while(true) {
+            System.out.println("\nPodaj kod waluty, lub Q aby zakończyć pracę z bieżącą tabelą");
+            String code = scanner.nextLine().toUpperCase();
+            if("Q".equals(code)) {
+                break;
+            }
+            Optional<Waluta> found = tabela.findByCode(code);
+            if(found.isEmpty()) {
+                System.out.println("Nie ma waluty o kodzie " + code);
+                continue;
+            }
+            dzialajDlaWybranejWaluty(found.get());
+        }
+    }
+
+    private void dzialajDlaWybranejWaluty(Waluta waluta) {
+        System.out.println("Wybrana waluta: " + waluta.getCode() + " (" + waluta.getCurrency() + ")" + ", kurs " + waluta.getMid());
+        while(true) {
+            System.out.println("\nPodaj kwotę do przeliczenia. 0 oznacza koniec:");
+            BigDecimal kwota = scanner.nextBigDecimal();
+            scanner.nextLine();
+            if(kwota.compareTo(BigDecimal.ZERO) == 0) {
+                break;
+            }
+            BigDecimal wynikWaluta = waluta.przeliczNaWalute(kwota);
+            BigDecimal wynikPLN = waluta.przeliczNaZlote(kwota);
+
+            System.out.println(kwota + " " + waluta.getCode() + " = " + wynikPLN + " PLN");
+            System.out.println(kwota + " PLN = " + wynikWaluta + " " + waluta.getCode());
+        }
+    }
+
+}

src/main/java/waluty/TabelaWalut.java

+package waluty;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+public class TabelaWalut {
+	private final String no;
+	private final LocalDate effectiveDate;
+	private final List<Waluta> rates = new ArrayList<>();
+
+	public TabelaWalut(String no, LocalDate effectiveDate) {
+		this.no = no;
+		this.effectiveDate = effectiveDate;
+	}
+
+    public TabelaWalut(String no, String effectiveDate) {
+        this(no, LocalDate.parse(effectiveDate));
+    }
+
+    public void addRate(Waluta waluta) {
+        rates.add(waluta);
+    }
+
+    public String getNo() {
+        return no;
+    }
+
+    public LocalDate getEffectiveDate() {
+        return effectiveDate;
+    }
+
+    public List<Waluta> getRates() {
+        // dostęp tylko do odczytu
+        return Collections.unmodifiableList(rates);
+    }
+
+    @Override
+    public String toString() {
+        return "Tabela nr " + no + " z dnia " + effectiveDate + ", " + rates.size() + " walut";
+    }
+
+    public Optional<Waluta> findByCode(String code) {
+        for(Waluta waluta : rates) {
+            if(waluta.getCode().equals(code) ) {
+                return Optional.of(waluta);
+            }
+        }
+        return Optional.empty();
+    }
+
+    public String[] codes() {
+        return rates.stream()
+        		.map(Waluta::getCode)
+        		.toArray(String[]::new);
+    }
+
+}

src/main/java/waluty/Waluta.java

+package waluty;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class Waluta {
+	private final String code;
+	private final String currency;
+	private final BigDecimal mid;
+
+	public Waluta(String code, String currency, BigDecimal mid) {
+		this.code = code;
+		this.currency = currency;
+		this.mid = mid;
+	}
+
+	public String getCode() {
+		return code;
+	}
+
+	public String getCurrency() {
+		return currency;
+	}
+
+	public BigDecimal getMid() {
+		return mid;
+	}
+
+	@Override
+	public String toString() {
+		return code + " (" + currency + "): " + mid;
+	}
+
+	public BigDecimal przeliczNaZlote(BigDecimal kwota) {
+		return kwota.multiply(mid).setScale(2, RoundingMode.HALF_EVEN);
+	}
+
+	public BigDecimal przeliczNaWalute(BigDecimal kwota) {
+		return kwota.divide(mid, 2, RoundingMode.HALF_EVEN);
+	}
+
+}

src/main/java/waluty/linki_nbp.txt

+https://api.nbp.pl/
+
+https://api.nbp.pl/api/exchangerates/tables/A/
+
+https://api.nbp.pl/api/exchangerates/tables/B/
+https://api.nbp.pl/api/exchangerates/tables/C/
+
+https://api.nbp.pl/api/exchangerates/tables/A/2020-02-05
+
+https://api.nbp.pl/api/exchangerates/tables/A/?format=xml
+
+https://api.nbp.pl/api/exchangerates/tables/A/?format=json