Merge branch 'master' of https://www.gitrepo.de/alfatrainingkurse/java/enigma

 Conflicts:
	src/main/java/Enigma/Main.java

src/main/java/Enigma/Main.java

 package Enigma;
 
-import Enigma.model.Funkraum;
+import Enigma.model.Codebuch;
+import Enigma.model.DatenbankSqlite;
+import Enigma.model.Morsecode;
 
-import java.io.IOException;
+import java.sql.SQLException;
 
 public class Main {
 
-    public static void main(String[] args) {
-        Funkraum fr = new Funkraum();
-        try {
-            fr.sendeFunkspruch("Testen wir doch mal das ganze", "deisold");
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        try {
-            String[] funkspruch = fr.empfangeFunkspruch("deisold");
-            System.out.println("Empfangen: " + funkspruch[0]);
-            System.out.println("Nachricht: " + funkspruch[1]);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
+    public static void main(String[] args) throws SQLException {
         App.main(args);
     }
-
 }

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

@@ -5,7 +5,7 @@ package Enigma.model;
  * 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
+ * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze 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.

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

 package Enigma.model;
 
+import javax.swing.text.html.HTML;
 import java.sql.*;
+import java.util.Random;
 
 /**
  * Dies ist die SQLite Datenbank Klasse
@@ -60,4 +62,89 @@ public class DatenbankSqlite {
 
 		return cb;
 	}
+
+	//region Random New Codebuch generieren
+	/*
+	*//**
+	 * Setzt zufällige Codebuch Einträge in die SQLite Datenbank
+	 * Tag => int
+	 * Walzenlage => String w1,w2,w3
+	 * Ringstellung => String r1,r2,r3
+	 * Steckverbindungen => s0,s1,s2,s3,s4,s5,s6,s7,s8,s9
+	 *//*
+	public void autoGenCodebuch() throws SQLException {
+
+		Connection conn = connect();
+		conn.setAutoCommit(false);
+		PreparedStatement pstmtInsert = conn.prepareStatement("INSERT INTO table_codebuch (Tag, Walzenlage, Ringstellung, Steckverbindung) VALUES (?, ?, ?, ?);");
+		for (int i = 3; i < 32; i++) {
+			pstmtInsert.setInt(1, i);
+			pstmtInsert.setString(2, walzenlage());
+			pstmtInsert.setString(3, ringstellung());
+			pstmtInsert.setString(4, steckverbindung());
+			pstmtInsert.executeUpdate();
+		}
+
+		conn.commit();
+	}
+
+	*//**
+	 * Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 5)
+	 * die Zahlen sind durch Komma getrennt
+	 * @return String => walzenlage mit drei Kommaseparierten Zufallszahlen zwischen 1 und 5
+	 *//*
+	private static String walzenlage(){
+		String walzenlage;
+		Random random = new Random();
+		int[] w = new int[3];
+		for (int i = 0; i < 3; i++) {
+
+			w[i] = (random.nextInt(5))+1;
+			if (i==1&&w[0]==w[i])w[i]=(random.nextInt(5))+1;
+			if ((i==2&&w[0]==w[2])||(i==2&&w[1]==w[i]))w[i]=(random.nextInt(5))+1;
+		}
+		walzenlage= w[0]+","+w[1]+","+w[2];
+		return walzenlage;
+	}
+
+	*//**
+	 * Generiert einen String aus 3 Zufalls-Zahlen(zwischen 1 und 26)
+	 * die Zahlen sind durch Komma getrennt
+	 * @return String => ringstellung mit drei Kommaseparierten Zufallszahlen zwischen 1 und 26
+	 *//*
+	private static String ringstellung(){
+		String ringstellung;
+		Random random = new Random();
+		int[] w = new int[3];
+		for (int i = 0; i < 3; i++) {
+			w[i] = (random.nextInt(26))+1;
+		}
+		ringstellung= w[0]+","+w[1]+","+w[2];
+		return ringstellung;
+	}
+
+	*//**
+	 * Generiert einen String aus 10 * 2 unterschiedlichen Großbuchstaben
+	 * @return  String => 10 Buchstabenkombinationen mit Komma getrennt
+	 *//*
+	private static String steckverbindung(){
+		Random rnd = new Random();
+		String steckverbindung="";
+		char[] c = new char[2];
+		for (int i = 0; i < 10; i++) {
+			for (int j = 0; j < 2; j++) {
+				c[j]= (char) (rnd.nextInt(26) + 'A');
+				if (j==1) {
+					while (c[0] == c[j]) {
+						c[j] = (char) (rnd.nextInt(26) + 'A');
+					}
+				}
+			}
+			System.out.println(c[0]+" / "+c[1]);
+			steckverbindung+= ((""+c[0]) + (""+c[1]) +",");
+		}
+		steckverbindung= (String) steckverbindung.subSequence(0,steckverbindung.lastIndexOf(","));
+		return steckverbindung;
+	}*/
+	//endregion
 }

src/main/java/Enigma/model/Walze.java

+package Enigma.model;
+
+public class Walze {
+
+    Character buchstabe = null;
+    Character ringstellung = null;
+    int walzennr = 0;
+    int iPositionBuchstabe = 0;
+    int iPositionBuchstabeRe = 0;
+    Character[] walze = new Character[25];
+
+    /**
+     * Gibt die Parameter der Walze mit
+     *
+     * @param walzennr : int : Nummer der gewaehlten Walze
+     * @param buchstabe : Character : Grundeinstellung der Walze
+     * @param ringstellung : Character : Einstellung des Notch
+     */
+    public Walze(int walzennr, Character buchstabe, Character ringstellung) {
+        this.walzennr = walzennr;
+        this.buchstabe = buchstabe;
+        this.ringstellung = ringstellung;
+    }
+
+    /**
+     * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
+     */
+    public char getBuchstabe() {
+        return buchstabe;
+    }
+
+    /**
+     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+     * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
+     *
+     * @param buchstabe : Character : Grundeinstellung der Walze
+     */
+    private void setBuchstabe(Character buchstabe) {
+        this.buchstabe.toUpperCase(buchstabe);
+
+        if(buchstabe.isLetter(buchstabe)) {
+            this.buchstabe = buchstabe;
+        } else {
+            this.buchstabe = 'A';
+        }
+
+    }
+
+    /**
+     * @return ringstellung : Character : gibt die neue Ringstellung zurueck
+     */
+    public char getRingstellung() {
+        return ringstellung;
+    }
+
+
+    /**
+     * Gibt die Initiale Ringstellung der Walze an.
+     * Es sind nur Zahlen von 1 - 26 zugelassen.
+     * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
+     *
+     * @param ringstellung : Character : Punkt an dem die Walze umspringt
+     */
+    private void setRingstellung(Character ringstellung) {
+
+        if(buchstabe.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
+            this.ringstellung = ringstellung;
+        } else {
+            this.ringstellung = '1';
+        }
+    }
+
+    /**
+     * @return walzennr : int : gibt die Walzennummer zurueck
+     */
+    public int getWalzennr() {
+        return walzennr;
+    }
+
+    /**
+     * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
+     *
+     * @param walzennr : int : setzt die Walzennummer
+     */
+    private void setWalzennr(int walzennr) {
+        if(walzennr > 0 && walzennr < 6) {
+            this.walzennr = walzennr;
+        } else {
+            System.err.println("Keine gültige Walzennummer");
+        }
+    }
+
+    /**
+     * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
+     *
+     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+     */
+    private Character[] walzenNummer() {
+
+        //Walze nach der Cheffrierung
+        Character[] walzeEins = {'E','K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+        Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+        Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+        Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
+        Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
+
+        switch (getWalzennr()) {
+            case 1:
+                walze = walzeEins;
+                break;
+            case 2:
+                walze = walzeZwei;
+                break;
+            case 3:
+                walze = walzeDrei;
+                break;
+            case 4:
+                walze = walzeVier;
+                break;
+            case 5:
+                walze = walzeFuenf;
+                break;
+        }
+
+        return walze;
+    }
+
+    /**
+     * Ermittelt die Position des Buchstaben auf der Alphabetswalze, um die Position mit
+     * der Cheffrierung auf der gewaehlten Walze abgleichen zu koennen.
+     *
+     * @return iPositionBuchstabe : int : Position des Buchstaben im Array
+     */
+    public int positionBuchstabe() {
+
+        //Alphabetswalze
+        Character[] walzeAlpha = {'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
+        int index = 0;
+
+        //Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze
+        for(index = 0; index < walzeAlpha.length; index++) {
+            if(buchstabe.equals(walzeAlpha[index])) {
+                iPositionBuchstabe = index;
+                break;
+            }
+        }
+
+        return iPositionBuchstabe;
+    }
+
+
+    /**
+     * Cheffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
+     * anhand der gewaehlten Walze.
+     *
+     * @param iPositionBuchstabe : int : Position des zu cheffrierenden Buchstabens
+     * @param walze : Character[] : ausgewaehlte Walze
+     * @return cheffrierterBuchstabe : Character : cheffrierter Buchstabe
+     */
+    public Character codierterBuchstabe(int iPositionBuchstabe, Character[] walze) {
+        Character codierterBuchstabe = walze[iPositionBuchstabe];
+        return codierterBuchstabe;
+    }
+
+
+    /**
+     * Nimmt die Startposition, die aus der Walzeneinstellung geholt wird und
+     * erhoeht sie um eins.
+     * Die Variable wird ueberschrieben und zaehlt von nun an die Position mit.
+     * Ab Position 25 wird wieder bei 0 angefangen.
+     *
+     * @param iPositionBuchstabe : int : alte Position der Walze
+     * @return iPositionBuchstabe : int : neue Position der Walze
+     */
+    public int vorstellenDerWalze(int iPositionBuchstabe) {
+
+        if(iPositionBuchstabe == 25) {
+            iPositionBuchstabe = 0;
+        } else {
+            iPositionBuchstabe += 1;
+        }
+
+        return iPositionBuchstabe;
+    }
+
+    /**
+     * Ermittelt die Position des Buchstaben auf der gewaehlten Walze, um die Position mit
+     * der Cheffrierung auf der AlphaWalze abgleichen zu koennen.
+     *
+     * @param walzennr : int : gibt die gewaehlte Walze zurueck
+     * @return iPositionBuchstabeRe : int : Position des Buchstaben im Array
+     */
+    public int positionBuchstabeReverse(int walzennr) {
+
+        int index = 0;
+
+        //Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze
+        for(index = 0; index < walze.length; index++) {
+            if(buchstabe.equals(walze[index])) {
+                iPositionBuchstabeRe = index;
+                break;
+            }
+        }
+        return iPositionBuchstabeRe;
+    }
+
+    /**
+     * Cheffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
+     * anhand der AlphaWalze.
+     *
+     * @param iPositionBuchstabeRe : int : Position des zu cheffrierenden Buchstabens
+     * @return codierterBuchstabeRe : Character : cheffrierter Buchstabe
+     */
+    public Character codierterBuchstabeReverse(int iPositionBuchstabeRe) {
+        //Alphawalze
+        Character[] walzeAlpha = {'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
+        Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
+        return codierterBuchstabeRe;
+    }
+
+}