diff --git a/pom.xml b/pom.xml
index b5b6fd8e2b51fd76224531dfc96c3f332219d47a..2f9c3e710d4477723661310f9d7d24e446d8a0e0 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>
diff --git a/src/main/java/Enigma/Main.java b/src/main/java/Enigma/Main.java
index 37c9833e5330d953580ce896ef61cfbb30be991e..6adb9204e8eda602b491142bacbe98185c6c0eaa 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 0000000000000000000000000000000000000000..c32345ed483066ea6daa01e4d0f9bc88776e49f0
--- /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 0000000000000000000000000000000000000000..6a203b58e38cca810c87d4ecf18838dd7c8168f1
--- /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/Enigma/model/Morsecode.java b/src/main/java/Enigma/model/Morsecode.java
index abb6a774452ea7e3a848da04aca1e62ef23d3aaa..f8c759cf70fd7d17b2024ce91077b5835c46c618 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();
}
}
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
deleted file mode 100644
index c9e95ca6609f106a0b33fb601d9ccb92414d4f49..0000000000000000000000000000000000000000
--- 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