Merge branch 'master' into 'master'

Master

See merge request alfatrainingkurse/java/enigma!3

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>

src/main/java/Enigma/Main.java

 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);
+    }
 
 }

src/main/java/Enigma/model/Codebuch.java

+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;
+	}
+}

src/main/java/Enigma/model/DatenbankSqlite.java

+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;
+	}
+}

src/main/java/Enigma/model/Morsecode.java

 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();
 	}
 }

src/main/java/module-info.java

-module Projektarbeit {
-    requires javafx.controls;
-    requires javafx.fxml;
-
-    opens Enigma to javafx.fxml;
-    exports Enigma;
-}
\ No newline at end of file