From 18cf7a027b9c5955acf66164f14d3cd21dbfc471 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Mon, 25 Nov 2019 16:25:24 +0100
Subject: [PATCH 1/4] =?UTF-8?q?Unn=C3=B6tige=20Verzeichnisse=20ignorieren?=
=?UTF-8?q?=20lassen=20SQLite=20Datenbank=20angelegt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.gitignore | 2 ++
src/main/resources/Enigma/codebuch.sqlite | Bin 0 -> 24576 bytes
2 files changed, 2 insertions(+)
create mode 100644 .gitignore
create mode 100644 src/main/resources/Enigma/codebuch.sqlite
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..bba7b53
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+/target/
+/.idea/
diff --git a/src/main/resources/Enigma/codebuch.sqlite b/src/main/resources/Enigma/codebuch.sqlite
new file mode 100644
index 0000000000000000000000000000000000000000..7d4a703b04d15e43146dddaca53c1b8e3ea83877
GIT binary patch
literal 24576
zcmeI&&u-H&90zc_VXKm<EnHSj2;pO+S)jHWy&%EZ!YHZ=>mPL-P?V;oi<+cenjp3t
z><xIDy#+79bqDSoaI#KayE4R$m9Ldw68mRI@h7=ha&y1tgo1q-2A&nNGPz4ACC?cn
zgsjO}m2pQ#N`^YQmzSi_%bOdnYvfVE$;b{$cAaFuXTN6GGiRBz8%7`n0SG_<0uX=z
z1Rwwb2>gEnS%p5#S1R<h6IxwYBq!4z_Cz<b56xcR48769#+99hvE4FQYx_mbU<<ow
z1x<B&%<)4_Rqdfa4g*V8<~xrDGOdmR$FqWCHW0^LQ(IO)9>@HljL3CmQ^#^ogzs8?
z!R$jTxSDD>et#Sa*Ny!Cwd7t9`Muv}o1w4=A4Sl0{NA<EnobCP`o2Pm%!*IrBUdis
zOe+e9N!?sHYqPkpIbP!Zc&5|O`DAR;=R`^8<ED*i)6`xPn9+j7C49SH-ESMLTHiGe
z=1HexHFfCEWm!R{^|z_j{N^Tom%PYiW@B*_3EviTRb}Q=&m{}K<q0lF>R&c!I<M>W
z)JvW@t1w$j%{*~7H~DL-^_H<`H2&_-VHe-V4umKC@E`h*;<Y)=eIxQffdB*`009U<
z00Izz00bZa0SG|gb_hJCX`<#I+}|qlGA|XM@M4h{%Q8y5RN8sNcdPtmgTHF?*BxGK
z^47t{`v08d&Tq#A@s<#P00bZa0SG_<0uX=z1Rwwb2>e0d9#wR8c2mP-M7)<j-Ut%M
zii~)_KMDjO009U<00Izz00bZa0SG_<0!t#G$$8M+Pa+Q#2tWV=5P$##AOHafKmY;|
rfB*!RP(V>s73=>c{IHl31Rwwb2tWV=5P$##AOHafK;Vjiq7d~Lak5Y6
literal 0
HcmV?d00001
--
GitLab
From 542f774ceaf4ba26fa8f8fd7c11abebd6350adc7 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Mon, 25 Nov 2019 18:34:20 +0100
Subject: [PATCH 2/4] Morsecode Klasse fertig gestellt
---
src/main/java/Enigma/model/Morsecode.java | 166 +++++++++++++++++-----
1 file changed, 128 insertions(+), 38 deletions(-)
diff --git a/src/main/java/Enigma/model/Morsecode.java b/src/main/java/Enigma/model/Morsecode.java
index abb6a77..f8c759c 100644
--- a/src/main/java/Enigma/model/Morsecode.java
+++ b/src/main/java/Enigma/model/Morsecode.java
@@ -1,51 +1,141 @@
package Enigma.model;
-import java.util.TreeMap;
+import java.util.*;
+import java.util.Map.Entry;
+/**
+ * Diese Klasse definiert die Zugehörigkeit zwischen den Buchstaben A-Z und dem zugehörigen Morsecode.
+ * Die Funktionen sollen Texte von und zu Morsecode konvertieren.
+ */
public class Morsecode {
- TreeMap<String, String> codeMap = new TreeMap<>();
+ // Anlegen der codeMap als TreeMap
+ private TreeMap<String, String> codeMap = new TreeMap<>();
/**
- * Im Konstruktor werden alle Notwendigen Zeichen und deren zugehöriger Codes, der Treemap hinzugefügt.
+ * Im Konstruktor werden alle verfügbaren Buchstaben (A-Z) und deren zugehörigen
+ * Morsecodes, der codeMap hinzugefügt.
*/
public Morsecode() {
- codeMap.put("A", "10110");
- codeMap.put("B", "110101010");
- codeMap.put("C", "1101011010");
- codeMap.put("D", "1101010");
- codeMap.put("E", "10");
- codeMap.put("F", "101011010");
- codeMap.put("G", "11011010");
- codeMap.put("H", "10101010");
- codeMap.put("I", "1010");
- codeMap.put("J", "10110110110");
- codeMap.put("K", "11010110");
- codeMap.put("L", "101101010");
- codeMap.put("M", "110110");
- codeMap.put("N", "11010");
- codeMap.put("O", "110110110");
- codeMap.put("P", "1011011010");
- codeMap.put("Q", "11011010110");
- codeMap.put("R", "1011010");
- codeMap.put("S", "101010");
- codeMap.put("T", "110");
- codeMap.put("U", "1010110");
- codeMap.put("V", "101010110");
- codeMap.put("W", "10110110");
- codeMap.put("X", "1101010110");
- codeMap.put("Y", "11010110110");
- codeMap.put("Z", "1101101010");
- // KA - Spruchanfang
- codeMap.put("KA", "1101011010110");
- // AR - Spruchende
- codeMap.put("AR", "101101011010");
- // VE - Verstanden
- codeMap.put("VE", "10101011010");
- // SK - Verkehrsende
- codeMap.put("SK", "10101011010110");
+ this.codeMap.put("A", ".-");
+ this.codeMap.put("B", "-...");
+ this.codeMap.put("C", "-.-.");
+ this.codeMap.put("D", "-..");
+ this.codeMap.put("E", ".");
+ this.codeMap.put("F", "..-.");
+ this.codeMap.put("G", "--.");
+ this.codeMap.put("H", "....");
+ this.codeMap.put("I", "..");
+ this.codeMap.put("J", ".---");
+ this.codeMap.put("K", "-.-");
+ this.codeMap.put("L", ".-..");
+ this.codeMap.put("M", "--");
+ this.codeMap.put("N", "-.");
+ this.codeMap.put("O", "---");
+ this.codeMap.put("P", ".--.");
+ this.codeMap.put("Q", "--.-");
+ this.codeMap.put("R", ".-.");
+ this.codeMap.put("S", "...");
+ this.codeMap.put("T", "-");
+ this.codeMap.put("U", "..-");
+ this.codeMap.put("V", "...-");
+ this.codeMap.put("W", ".--");
+ this.codeMap.put("X", "-..-");
+ this.codeMap.put("Y", "-.--");
+ this.codeMap.put("Z", "--..");
}
- public void getCode(char sign) {
+ /**
+ * Diese Funktion überprüft ob das übergebene Buchstabe in der codeMap enthalten ist.
+ * Wenn es enthalten ist, wird der zugehörige Morsecode zurück gegeben, ansonsten null
+ *
+ * @param buchstabe : char : Zu übersetzender Buchstabe
+ * @return : String : Das zugehöriger Morsecode aus der codeMap
+ */
+ private String getMorsecode(char buchstabe) {
+ // Testen ob das Char in der codeMap enthalten ist. Wenn ja, raussuchen und zurück geben
+ return this.codeMap.getOrDefault(String.valueOf(buchstabe).toUpperCase(), null);
+ }
+
+ /**
+ * Der übergebene String wird in seine einzelnen Zeichen (char) zerlegt und an die Funktion getMorsecode
+ * übergeben und der zugehörige Morsecode raus gesucht.
+ * Mittels eines StringBuilders werden die Ergebnisse zu einem Rückgabe String zusammen gesetzt.
+ * Wenn kein zugehöriger Code in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
+ * Enigma nicht vorhanden war.
+ *
+ * @param input : String : Zu konventierender Text
+ * @return String : Die in Morsecode konvertierte Text
+ */
+ public String convertBuchstabeToMorsecode(String input) {
+ StringBuilder sb = new StringBuilder();
+ String morsecode;
+
+ // Durch alle char im übergebenen String loopen
+ for(int i = 0; i < input.length(); i++) {
+
+ // Wenn der char in der codeMap enthalten ist, an den Rückgabe String anheften, ansonsten nichts ignorieren.
+ morsecode = this.getMorsecode(input.charAt(i));
+ if(morsecode != null) {
+ sb.append(morsecode).append(' ');
+ }
+ }
+
+ // Gibt den konvertierten String zurück
+ return sb.toString();
+ }
+
+ /**
+ * Diese Funktion überprüft ob der übergebene Morsecode in der codeMap enthalten ist.
+ * Wenn er enthalten ist, wird der zugehörige Buchstabe zurück gegeben, ansonsten null
+ *
+ * @param morsecode : String : Der zu übersetzende Morsecode
+ * @return : String : Das zugehöriger Buchstaben aus der this.codeMap
+ */
+ private String getBuchstabe(String morsecode) {
+ // Initialisieren des Rückgabe Strings
+ // TODO: Darf bei der Initialisierung gleich einen Wert setzten lauf JAVA Konventionen?
+ String result = null;
+
+ // Loopt duch die Codemap und erstellt daraus ein Set
+ for(Entry<String, String> entry : this.codeMap.entrySet()) {
+ // Wenn Value dem Morsecode entspricht, haben wir unseren Buchstaben gefunden und setzen ihn als Result
+ if(entry.getValue().equals(morsecode)) {
+ result = entry.getKey();
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Der übergebene String wird in einen String Array zerlegt. Als Trennzeichen wird das Leerzeichen genutzt.
+ * Anschließend wird der Array durchlaufen und die Elemente an die Funktion getBuchstabe übergeben um den
+ * zugehörigen Buchstaben zu erhalten.
+ * Mittels eines StringBuilders werden die Ergebnisse zu einem Rückgabe String zusammen gesetzt.
+ * Wenn kein zugehöriger Buchstabe in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
+ * Enigma nicht vorhanden war.
+ *
+ * @param input : String : Zu konventierender Morsecode
+ * @return String : Der in Text konvertierte Morsecode
+ */
+ public String convertMorsecodeToBuchstabe(String input) {
+ StringBuilder sb = new StringBuilder();
+ String buchstabe;
+
+ String[] morsecodes = input.split(" ");
+
+
+ // Durch alle char im übergebenen String loopen
+ for(String morsecode : morsecodes) {
+
+ // Wenn der char in der codeMap enthalten ist, an den Rückgabe String anheften, ansonsten nichts ignorieren.
+ buchstabe = this.getBuchstabe(morsecode);
+ if(buchstabe != null) {
+ sb.append(buchstabe).append(' ');
+ }
+ }
+ // Gibt den konvertierten String zurück
+ return sb.toString();
}
}
--
GitLab
From 4c5001e06de6b5ab54de1e51452a4cd7d8349da0 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Mon, 25 Nov 2019 19:23:37 +0100
Subject: [PATCH 3/4] =?UTF-8?q?Dependencys=20f=C3=BCr=20MariaDB=20sowie=20?=
=?UTF-8?q?SQLite=20hinzugef=C3=BCgt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
pom.xml | 13 +++++++++++++
1 file changed, 13 insertions(+)
diff --git a/pom.xml b/pom.xml
index b5b6fd8..2f9c3e7 100644
--- a/pom.xml
+++ b/pom.xml
@@ -25,6 +25,19 @@
<artifactId>javafx-fxml</artifactId>
<version>${use.javafx.version}</version>
</dependency>
+ <!-- https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc -->
+ <dependency>
+ <groupId>org.xerial</groupId>
+ <artifactId>sqlite-jdbc</artifactId>
+ <version>3.28.0</version>
+ </dependency>
+ <!-- https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client -->
+ <dependency>
+ <groupId>org.mariadb.jdbc</groupId>
+ <artifactId>mariadb-java-client</artifactId>
+ <version>2.5.2</version>
+ </dependency>
+
</dependencies>
<build>
<plugins>
--
GitLab
From f49672e64564b860ffc6e5254e73d7328146b1f4 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Mon, 25 Nov 2019 21:20:57 +0100
Subject: [PATCH 4/4] =?UTF-8?q?-=20module-info.java=20gel=C3=B6scht,=20bra?=
=?UTF-8?q?uchen=20wir=20nicht=20-=20SQLite=20Anbindung=20fertig=20gestell?=
=?UTF-8?q?t=20-=20Codebuch=20Klasse=20geschrieben?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
src/main/java/Enigma/Main.java | 11 +-
src/main/java/Enigma/model/Codebuch.java | 166 ++++++++++++++++++
.../java/Enigma/model/DatenbankSqlite.java | 64 +++++++
src/main/java/module-info.java | 7 -
4 files changed, 238 insertions(+), 10 deletions(-)
create mode 100644 src/main/java/Enigma/model/Codebuch.java
create mode 100644 src/main/java/Enigma/model/DatenbankSqlite.java
delete mode 100644 src/main/java/module-info.java
diff --git a/src/main/java/Enigma/Main.java b/src/main/java/Enigma/Main.java
index 37c9833..6adb920 100644
--- a/src/main/java/Enigma/Main.java
+++ b/src/main/java/Enigma/Main.java
@@ -1,9 +1,14 @@
package Enigma;
+import Enigma.model.DatenbankSqlite;
+import Enigma.model.Morsecode;
+
+import java.sql.SQLException;
+
public class Main {
- public static void main(String[] args) {
- App.main(args);
- }
+ public static void main(String[] args) {
+ App.main(args);
+ }
}
diff --git a/src/main/java/Enigma/model/Codebuch.java b/src/main/java/Enigma/model/Codebuch.java
new file mode 100644
index 0000000..c32345e
--- /dev/null
+++ b/src/main/java/Enigma/model/Codebuch.java
@@ -0,0 +1,166 @@
+package Enigma.model;
+
+/**
+ * Das Codebuch war eines der essentiel wichtigen Sachen bei der Enigma.
+ * Jeder Enigma gehörte auch ein Codebuch bei, welches notwenidg war um die Nachrichten zu ver/entschlüsseln.
+ * Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
+ * mussten um die Texte zu ver/entschlüsseln.
+ * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walzen gesetzt und deren Grundeinstellung
+ * vorgenommen.
+ * Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
+ * festgelegt war.
+ *
+ * Dieses Codebuch Objekt enthält die Einstellungen eines Tages, welche mittels Getter und Setter
+ * verarbeitet werden können.
+ *
+ * Zusätzlich gibt es zu Debug Zwecken eine überschriebene toString Funktion welche das Objekt als String zurück
+ * geben kann.
+ */
+public class Codebuch {
+ private int tag;
+ private String[] Walzenlage = new String[3];
+ private String[] Ringstellung = new String[3];
+ private String[] Grundstellung = new String[3];
+ private String[] Steckverbindung = new String[10];
+
+ /**
+ * Gibt die aktuelle Instanz des Codebuches als String zurück.
+ * Hierbei werden der Tag die Walzenlagen, Ring/Grundstellung sowie die Steckverbindungen zurück gegeben.
+ *
+ * @return String : String des gesamten Objektes
+ */
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ boolean wlLoop = false;
+ boolean rsLoop = false;
+ boolean gsLoop = false;
+ boolean svLoop = false;
+
+ sb.append("Tag: ").append(this.getTag()).append("\n");
+
+ sb.append("Walzenlage: ");
+ for(String wl : this.getWalzenlage()) {
+ sb.append(wl).append(",");
+ wlLoop = true;
+ }
+ if(wlLoop) {
+ sb.setLength(sb.length() - 1);
+ }
+ sb.append("\n");
+
+ sb.append("Ringstellung: ");
+ for(String rs : this.getRingstellung()) {
+ sb.append(rs).append(",");
+ rsLoop = true;
+ }
+ if(rsLoop) {
+ sb.setLength(sb.length() - 1);
+ }
+ sb.append("\n");
+
+ sb.append("Grundstellung: ");
+ for (String gs : this.getGrundstellung()) {
+ sb.append(gs).append(",");
+ gsLoop = true;
+ }
+ if(gsLoop) {
+ sb.setLength(sb.length() - 1);
+ }
+ sb.append("\n");
+
+ sb.append("Steckverbindung: ");
+ for (String s : this.getSteckverbindung()) {
+ if (!s.isEmpty()) {
+ sb.append(s).append(",");
+ svLoop = true;
+ }
+ }
+ if(svLoop) {
+ sb.setLength(sb.length() - 1);
+ }
+ sb.append("\n");
+
+ return sb.toString();
+ }
+
+ /**
+ * Gibt den Tag dieser Instanz zurück
+ * @return int : Tag
+ */
+ public int getTag() {
+ return tag;
+ }
+
+ /**
+ * Gibt die Walzenlage dieser Instanz zurück
+ * @return String[] : Walzenlage
+ */
+ public String[] getWalzenlage() {
+ return Walzenlage;
+ }
+
+ /**
+ * Gibt die Ringstellung dieser Instanz zurück
+ * @return String[] : Ringstellung
+ */
+ public String[] getRingstellung() {
+ return Ringstellung;
+ }
+
+ /**
+ * Gibt die Grundstellung dieser Instanz zurück
+ * @return String[] : Grundstellung
+ */
+ public String[] getGrundstellung() {
+ return Grundstellung;
+ }
+
+ /**
+ * Gibt die Steckverbindung dieser Instanz zurück
+ * @return String[] : Steckverbindung
+ */
+ public String[] getSteckverbindung() {
+ return Steckverbindung;
+ }
+
+ /**
+ * Setzt den Tag dieser Instanz
+ * @param tag : int
+ */
+ public void setTag(int tag) {
+ this.tag = tag;
+ }
+
+ /**
+ * Setzt die Walzenlage dieser Instanz
+ * @param walzenlage : String[]
+ */
+ public void setWalzenlage(String[] walzenlage) {
+ Walzenlage = walzenlage;
+ }
+
+ /**
+ * Setzt die Ringstellung dieser Instanz
+ * @param ringstellung : String[]
+ */
+ public void setRingstellung(String[] ringstellung) {
+ Ringstellung = ringstellung;
+ }
+
+ /**
+ * Setzt die Grundstellung dieser Instanz
+ * @param grundstellung : String[]
+ */
+ public void setGrundstellung(String[] grundstellung) {
+ Grundstellung = grundstellung;
+ }
+
+ /**
+ * Setzt die Steckverbindung dieser Instanz
+ * @param steckverbindung : String[]
+ */
+ public void setSteckverbindung(String[] steckverbindung) {
+ Steckverbindung = steckverbindung;
+ }
+}
diff --git a/src/main/java/Enigma/model/DatenbankSqlite.java b/src/main/java/Enigma/model/DatenbankSqlite.java
new file mode 100644
index 0000000..6a203b5
--- /dev/null
+++ b/src/main/java/Enigma/model/DatenbankSqlite.java
@@ -0,0 +1,64 @@
+package Enigma.model;
+
+import java.sql.*;
+
+/**
+ * Dies ist die SQLite Datenbank Klasse
+ * In der SQLite Datei im Resources Ordner liegt das Codebuch welches benötigt wird um die
+ * Nachrichten mit der Enigma zu ver/entschlüsseln.
+ * Die Datenbank ist statisch und deshalb konnte sie im Resources Ordner hinterlegt werden.
+ * Für jeden Tag des Monats (1-31) ist ein eigener Eintrag enthalten welcher über die Funktion
+ * getCodebuch abgerufen werden kann.
+ * Zurückgegeben wird ein Array welcher in der getCodebuch Funktion genauer dokumentiert ist.
+ */
+public class DatenbankSqlite {
+
+ /**
+ * Verbindung zur SQLite Datenbank aufbauen.
+ * Die Datei liegt in den Resources und ändert sich nicht,
+ * weshalb der Pfad zu derselben fest hinterlegt ist.
+ *
+ * @return conn : Connection
+ */
+ private Connection connect() {
+
+ String url = "jdbc:sqlite::resource:Enigma/codebuch.sqlite";
+ Connection conn = null;
+
+ try {
+ conn = DriverManager.getConnection(url);
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ return conn;
+ }
+
+ /**
+ * Liest das Codebuch aus der SQLite Datenbank aus
+ * Dieser Funktion muss ein tag als int Wert übergeben werden.
+ * Anschließend wir eine Verbindung zur SQLite Datenbank aufgebaut und das Codebuch angefragt.
+ * Dieses wird in ein Object vom Type Codebuch gepackt und zurück gegeben.
+ *
+ * @param tag : int : Tag für welchen ein Codebuch benötigt wird.
+ * @return Codebuch : Codebuch Object mit dem Codebuch des angefragten Tages
+ */
+ public Codebuch getCodebuch(int tag) throws SQLException {
+ Codebuch cb = new Codebuch();
+
+ Connection conn = this.connect();
+ PreparedStatement pstm = conn.prepareStatement("SELECT * FROM table_codebuch WHERE Tag=? LIMIT 1");
+ pstm.setInt(1, tag);
+ ResultSet rs = pstm.executeQuery();
+
+ while (rs.next()) {
+ cb.setTag(rs.getInt("Tag"));
+ cb.setWalzenlage(rs.getString("Walzenlage").split(","));
+ cb.setRingstellung(rs.getString("Ringstellung").split(","));
+ cb.setGrundstellung(rs.getString("Grundstellung").split(","));
+ cb.setSteckverbindung(rs.getString("Steckverbindung").split(","));
+ }
+
+ return cb;
+ }
+}
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
deleted file mode 100644
index c9e95ca..0000000
--- a/src/main/java/module-info.java
+++ /dev/null
@@ -1,7 +0,0 @@
-module Projektarbeit {
- requires javafx.controls;
- requires javafx.fxml;
-
- opens Enigma to javafx.fxml;
- exports Enigma;
-}
\ No newline at end of file
--
GitLab