Merge branch 'master' into 'master'

Funkraum, Anpassungen auf Java Konventionen, Unit Tests

See merge request !9

pom.xml

@@ -31,13 +31,25 @@
             <artifactId>sqlite-jdbc</artifactId>
             <version>3.28.0</version>
         </dependency>
-        <!-- https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client -->
+        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
         <dependency>
-            <groupId>org.mariadb.jdbc</groupId>
-            <artifactId>mariadb-java-client</artifactId>
-            <version>2.5.2</version>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.10</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.json/json -->
+        <dependency>
+            <groupId>org.json</groupId>
+            <artifactId>json</artifactId>
+            <version>20190722</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/junit/junit -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
         </dependency>
-
     </dependencies>
     <build>
         <plugins>

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

@@ -18,10 +18,15 @@ package Enigma.model;
  */
 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];
+	private String[] Walzenlage;
+	private String[] Ringstellung;
+	private String[] Steckverbindung;
+
+	Codebuch() {
+		this.Walzenlage = new String[3];
+		this.Ringstellung = new String[3];
+		this.Steckverbindung = new String[10];
+	}
 
 	/**
 	 * Gibt die aktuelle Instanz des Codebuches als String zurück.
@@ -34,7 +39,6 @@ public class Codebuch {
 		StringBuilder sb = new StringBuilder();
 		boolean wlLoop = false;
 		boolean rsLoop = false;
-		boolean gsLoop = false;
 		boolean svLoop = false;
 
 		sb.append("Tag: ").append(this.getTag()).append("\n");
@@ -59,16 +63,6 @@ public class Codebuch {
 		}
 		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()) {
@@ -108,14 +102,6 @@ public class Codebuch {
 		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
@@ -148,14 +134,6 @@ public class Codebuch {
 		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[]

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

@@ -57,7 +57,6 @@ public class DatenbankSqlite {
 			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(","));
 		}
 

src/main/java/Enigma/model/Funkraum.java

+package Enigma.model;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpException;
+import org.apache.http.HttpResponse;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.message.BasicNameValuePair;
+import org.json.JSONObject;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Hier sitzt der Funker
+ * Der Funkraum kann Funksprüche empfangen und senden.
+ * Hierfür wird eine Verbindung zu einem externen Service aufgebaut.
+ * Dieser Servive erwartet die Nachrichten im JSON Format. Dazu wird ein k als Kenngruppe
+ * (Benutzername) übergeben und falls eine Nachricht gesendet werden soll, zusätzlich ein m mit der Nachricht.
+ * Beides wird als String gesendet.
+ */
+public class Funkraum {
+	/**
+	 * Zum Empfangen liefert der Server, anstatt der Kenngruppe (k) den Empfangstag der Nachricht mit damit man
+	 *  die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
+	 *  {'m': 'Hello world', 't': '26'}
+	 *
+	 * @param kenngruppe : String : Kenngruppe dieser Engiam
+	 * @return String[] : String Array wobei Index 0 dem Empfangstag entspricht und index 1 der empfangenen Nachricht
+	 * @throws IOException : Exception :  wenn keine Verbindung zum Funker aufgebaut werden konnte.
+	 */
+	public String[] empfangeFunkspruch(String kenngruppe) throws IOException {
+		String[] funkspruch = new String[2];
+
+		HttpClient httpclient = HttpClients.createDefault();
+		HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
+
+		// Anfrage Parameter und Encoding setzen
+		List<NameValuePair> params = new ArrayList<>(2);
+		params.add(new BasicNameValuePair("k", kenngruppe));
+		httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
+
+		// POST Request ausführen und Rückgabe verarbeiten
+		HttpResponse response = httpclient.execute(httppost);
+		HttpEntity entity = response.getEntity();
+
+		if (entity != null) {
+			BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
+			JSONObject result = new JSONObject(reader.readLine());
+
+			if(!result.getString("m").isEmpty()) {
+				funkspruch[0] = result.getString("t");
+				funkspruch[1] = result.getString("m");
+			}
+		}
+
+		return funkspruch;
+	}
+
+	/**
+	 * Dem Service senden wir unsere Nachricht als POST Parameter (m) und unsere Kenngruppe (k).
+	 * Dieser nimmt die Daten entgegeb und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
+	 * irgendwann, auf Anfrage, wieder abgerufen werden können.
+	 *
+	 *  Darauf antworter der Server dann mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
+	 *  {'result': 200}
+	 *
+	 *  Die 200 heißt hier das alles erfolgreich durchgeführt werden konnte. Steht hier etwas anderes, ist ein Fehler
+	 *  aufgetreten und die Anfrage war nicht erfolgreich.
+	 *  In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggF später erneut versucht.
+	 *
+	 * @param funkspruch : String : Der zu sendede Funkspruch
+	 * @param kenngruppe : String : Die Kenngruppe dieser Engima
+	 * @throws IOException : Exception : Funkspruch konnte nicht gesendet werden
+	 */
+	public void sendeFunkspruch(String funkspruch, String kenngruppe) throws HttpException, IOException {
+		HttpClient httpclient = HttpClients.createDefault();
+		HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
+
+		// Anfrage Parameter und Encoding setzen
+		List<NameValuePair> params = new ArrayList<>(2);
+		params.add(new BasicNameValuePair("k", kenngruppe));
+		params.add(new BasicNameValuePair("m", funkspruch));
+		httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
+
+		// POST Request ausführen und Rückgabe verarbeiten
+		HttpResponse response = httpclient.execute(httppost);
+		HttpEntity entity = response.getEntity();
+
+		if (entity != null) {
+			BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
+			JSONObject result = new JSONObject(reader.readLine());
+			if(result.getInt("result") != 200) {
+				throw new HttpException("Der andere Funker mag deine Nachricht nicht. Rüge ihn wenn du ihn wieder siehst...");
+			}
+		}
+
+	}
+}

src/test/java/Enigma/model/CodebuchTest.java

+package Enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+import java.sql.SQLException;
+
+public class CodebuchTest {
+
+	@Test
+	public void testToString() {
+		String expected = "Tag: 1\n" +
+				"Walzenlage: 1,3,2\n" +
+				"Ringstellung: 16,11,13\n" +
+				"Steckverbindung: CO,DI,FR,HU,JW,LS,TX\n";
+
+		try {
+			// Codebuch abrufen
+			Codebuch cb = new DatenbankSqlite().getCodebuch(1);
+			// Ausgabe auf der Konsole
+			String result = new DatenbankSqlite().getCodebuch(1).toString();
+			Assert.assertEquals(expected, result);
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void getTag() {
+		Codebuch cb = new Codebuch();
+		cb.setTag(1);
+		Assert.assertEquals(1, cb.getTag());
+	}
+}
\ No newline at end of file

src/test/java/Enigma/model/WalzeTest.java

+package Enigma.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class WalzeTest {
+
+	@Test
+	public void setzeNotch() {
+		/*Walze w = new Walze(1);
+		w.setzeNotch('G');
+		Assert.assertEquals('G', w.wlazenPosition());*/
+	}
+
+	@Test
+	public void dreheWalze() {
+		/*Walze w = new Walze(1);
+		w.setzeNotch('G');
+		w.dreheWalze();
+		Assert.assertEquals('H', w.wlazenPosition());*/
+	}
+
+	@Test
+	public void walzenPoition() {
+		/*Walze w = new Walze(1);
+		w.setzeNotch('G');
+		Assert.assertEquals('G', w.wlazenPosition());*/
+	}
+
+	@Test
+	public void codiere() {
+		/*Walze w = new Walze(1);
+		w.setzeNotch('A');
+		Assert.assertEquals('E', w.codiere('A'));*/
+	}
+
+	@Test
+	public void codiere2() {
+		/*Walze w = new Walze(1);
+		w.setzeNotch('A');
+		Assert.assertEquals('A', w.codiere('E'));*/
+	}
+}
\ No newline at end of file