Skip to content
Snippets Groups Projects
Commit 9753b190 authored by Dennis Eisold's avatar Dennis Eisold
Browse files

Merge branch 'master' into 'master'

Hardware Klasse, Unit Tests, Fixes für Walzen und Reflektor

See merge request alfatrainingkurse/java/enigma!19
parents 79db1cc2 9901c1b6
No related branches found
No related tags found
No related merge requests found
package Enigma;
import Enigma.model.Codebuch;
import Enigma.model.DatenbankSqlite;
import Enigma.model.Hardware;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
......@@ -7,6 +10,9 @@ import javafx.scene.Scene;
import javafx.stage.Stage;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Calendar;
import java.util.TimeZone;
/**
* JavaFX App
......@@ -14,13 +20,15 @@ import java.io.IOException;
public class App extends Application {
private static Scene scene;
private Codebuch cb;
private Hardware h;
@Override
public void start(Stage stage) throws IOException {
scene = new Scene(loadFXML("gui"));
stage.setScene(scene);
stage.show();
holeCodebuch();
}
static void setRoot(String fxml) throws IOException {
......@@ -36,4 +44,31 @@ public class App extends Application {
Application.launch();
}
public void holeCodebuch() {
Calendar calendar = Calendar.getInstance(TimeZone.getDefault());
try {
this.cb = new DatenbankSqlite().getCodebuch(Calendar.DATE);
} catch (SQLException ignored) { }
for(int i = 0; i < 3; i++) {
h.setWalzen(i + 1, Integer.parseInt(cb.getWalzenlage()[i]), cb.getRingstellung()[i].charAt(0));
}
/*Walze w1 = new Walze(3);
w1.setzeNotch(13);
Walze w2 = new Walze(5);
w2.setzeNotch(1);
Walze w3 = new Walze(1);
w3.setzeNotch(20);
Reflektor r = new Reflektor();
Steckbrett sb = new Steckbrett();
if(w1.dreheWalze()) {
if(w2.dreheWalze()) {
w3.dreheWalze();
}
}*/
}
}
\ No newline at end of file
package Enigma.model;
import org.apache.http.HttpException;
import java.io.IOException;
public class Hardware {
private Walze[] walzen;
private Steckbrett steckbrett;
private Reflektor reflektor;
private String nachricht;
private String kenngruppe;
public Hardware() {
this.walzen = new Walze[4];
}
/**
* Setzt eine Walze ein
*
* @param walze : int : Setzt die Walze mit der angegebenen Nummer ein
* @param walzenNr : int : Die Nummer der einzusetzenden Walze
*/
public void setzeWalzenNr(int walze, int walzenNr) {
}
/**
* Setzt den Notch der Walze
*
* @param walze : int : Position der Walze
* @param position : int : Umspringpunkt auf der Walze
*/
public void setzeRing(int walze, int position) {
}
/**
* Setzt den Startwert (position) der Walze (walze)
*
* @param walze
* @param buchstabe
*/
public void setzePosition(int walze, char buchstabe) {
}
// Befehl die Nachricht an den Funker zu übergeben
public void sendeNachricht() throws IOException, HttpException {
new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(this.nachricht), this.kenngruppe);
}
/**
* Gibt die letzte empfangene Nachricht zurück
* <p>
* String[0] = Die verschlüsselte Nachricht
* String[1] = Nachricht im Klartext
*/
public String[] empfangeNachricht() {
String[] result = new String[2];
return result;
}
/**
* Fügt die gedrückte Taste der Nachricht hinzu
*
* @param buchstabe char : Der zu verschlüsselnde Buchstabe
* @return char : Der verschlüsselte Buchstabe
*/
public char tippeBuchstabe(char buchstabe) {
buchstabe = this.steckbrett.codiere(buchstabe);
buchstabe = this.walzen[1].codiere(buchstabe);
buchstabe = this.walzen[2].codiere(buchstabe);
buchstabe = this.walzen[3].codiere(buchstabe);
buchstabe = this.reflektor.codiere(buchstabe);
buchstabe = this.walzen[3].codiere2(buchstabe);
buchstabe = this.walzen[2].codiere2(buchstabe);
buchstabe = this.walzen[1].codiere2(buchstabe);
buchstabe = this.steckbrett.codiere(buchstabe);
this.nachricht += buchstabe;
return buchstabe;
}
/**
* Nachricht entschlüsseln
*
* @param nachricht : String : Verschlüsselte Nachricht
* @return String : Die Klartext Nachricht
*/
private String decodiereNachricht(String nachricht) {
String result = "";
return result;
}
public Walze[] getWalzen() {
return this.walzen;
}
public void setWalzen(int walze, int position, int ringstellung) {
this.walzen[position] = new Walze(walze, ringstellung);
}
public Steckbrett getSteckbrett() {
return steckbrett;
}
public void setSteckbrett(Steckbrett steckbrett) {
this.steckbrett = steckbrett;
}
public Reflektor getReflektor() {
return reflektor;
}
public void setReflektor(Reflektor reflektor) {
this.reflektor = reflektor;
}
public String getKenngruppe() {
return kenngruppe;
}
public void setKenngruppe(String kenngruppe) {
this.kenngruppe = kenngruppe;
}
}
......@@ -93,7 +93,6 @@ public class Morsecode {
*/
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
......
package Enigma.model;
import java.time.Year;
/**
* Klasse Walze
*
* <p>
* Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
*
* <p>
* 1. Walzennummer (Die Walze enthält die 26 Buchstaben des Alphabeths und codiert diese.
* 5 verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabeths
* paarweise vertauschen)
*
* <p>
* 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
* den Drehzeitpunkt der linken Nachbarwalze)
*
*/
public class Walze {
/**
* Konstanten und Variablen der Klasse Walze
*
* buchstabe : Bestimmt den Buchstaben
* ringstellung : Bestimmt den Umspringpunkt der Walze
* walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird)
* iPositionBuchstabe : gibt die Position des Buchstabens auf dem Array der Walze wieder.
* iPositionBuchstabeRe : gibt die Position des codierten Buchstabens im Alphabet wieder.
* private Character[] walze : Character-Array der Walze
*/
private Character buchstabe;
private Character ringstellung;
private int walzennr;
private int iPositionBuchstabe;
private int iPositionBuchstabeRe;
private Character[] walze;
/**
* Gibt die Parameter der Walze mit
*
* @param walzennr : int : Nummer der gewaehlten Walze
* @param ringstellung : Character : Einstellung des Notch
*/
public Walze(int walzennr, Character ringstellung) {
this.walze = new Character[25];
this.walzennr = walzennr;
this.buchstabe = 'A';
this.ringstellung = ringstellung;
}
/**
* Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
*
* @return walze : Character[] : gibt die gewaehlte Walze zurueck
*/
private Character[] walzenNummer() {
/*Walze nach der Chiffrierung*/
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 (walzennr) {
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;
}
//walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
public int walzenPosition() {
/**
* Konstanten und Variablen der Klasse Walze
* <p>
* buchstabe : Bestimmt den Buchstaben
* ringstellung : Bestimmt den Umspringpunkt der Walze
* walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird)
* iPositionBuchstabe : gibt die Position des Buchstabens auf dem Array der Walze wieder.
* iPositionBuchstabeRe : gibt die Position des codierten Buchstabens im Alphabet wieder.
* private Character[] walze : Character-Array der Walze
*/
/*Alphawalze*/
private final static 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'};
private Character buchstabe;
private int ringstellung;
private int walzennr;
private int iPositionBuchstabe;
private int iPositionBuchstabeRe;
private Character[] walze;
/**
* Gibt die Parameter der Walze mit
*
* @param walzennr : int : Nummer der gewaehlten Walze
* @param ringstellung : Character : Einstellung des Notch
*/
public Walze(int walzennr, int ringstellung) {
this.walze = new Character[25];
this.walzennr = walzennr;
this.buchstabe = 'A';
this.iPositionBuchstabe = 0;
this.ringstellung = ringstellung;
}
/**
* Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
*
* @return walze : Character[] : gibt die gewaehlte Walze zurueck
*/
private Character[] walzenNummer() {
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 (this.walzennr) {
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;
}
//walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
public char walzenPosition() {
/*Alphabetswalze*/
Character[] walzeAlphabeth = {'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'};
/*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
for(int index = 0; index < walzeAlphabeth.length; index++) {
if(getBuchstabe().equals(walzeAlphabeth[index])) {
iPositionBuchstabe = index;
Character[] walzeAlphabeth = {'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'};
return walzeAlphabeth[iPositionBuchstabe];
}
//setzeNotch(int position) => Setze Startpunkt auf int Position des Buchstabens
// Setter für Ringstellung
/**
* @return ringstellung : Character : gibt die neue Ringstellung zurueck
*/
public int 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
*/
public void setRingstellung(int ringstellung) {
if (ringstellung > 0 && ringstellung <= 26) {
this.ringstellung = ringstellung;
} else {
this.ringstellung = 1;
}
}
//dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
public boolean dreheWalze() {
boolean checkRing;
if (iPositionBuchstabe == 25) {
iPositionBuchstabe = 0;
} else {
iPositionBuchstabe += 1;
}
if (iPositionBuchstabe == getRingstellung()) {
checkRing = true;
} else {
checkRing = false;
}
return checkRing;
}
//codiere(char buchstabe) return char => Gibt den verschlüsselten Buchstaben zurück
/**
* Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
* anhand der gewaehlten Walze.
*
* @param
* @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
*/
public char codiere(char buchstabe) {
for(int i = 0; i < walzeAlpha.length; i++) {
if(walzeAlpha[i].equals(buchstabe)) {
buchstabe = walzenNummer()[i];
break;
}
}
return iPositionBuchstabe;
}
//setzeNotch(int position) => Setze Startpunkt auf int Position des Buchstabens
// Setter für 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
*/
public void setRingstellung(Character ringstellung) {
if(Character.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
this.ringstellung = ringstellung;
} else {
this.ringstellung = '1';
}
}
/**
* @return ringstellung : Character : gibt die neue Ringstellung zurueck
*/
public Character getRingstellung() {
return ringstellung;
}
//dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
public boolean dreheWalze(){
boolean checkRing;
if(iPositionBuchstabe == 25) {
iPositionBuchstabe = 0;
} else {
iPositionBuchstabe += 1;
}
return buchstabe;
}
if (iPositionBuchstabe == getRingstellung()){
checkRing = true;
//codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
}else{
/**
* Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
* anhand der AlphaWalze.
*
* @param
* @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
*/
public char codiere2(char buchstabe) {
checkRing = false;
}
return checkRing;
}
//codiere(char buchstabe) return char => Gibt den verschlüsselten Buchstaben zurück
/**
* Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
* anhand der gewaehlten Walze.
*
* @param
* @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
*/
public Character codiere(Character buchstabe) {
setBuchstabe(buchstabe);
walzenPosition();
Character codierterBuchstabe = walzenNummer()[iPositionBuchstabe];
return codierterBuchstabe;
}
//codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
/**
* Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
* anhand der AlphaWalze.
*
* @param
* @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
*/
public Character codiere2(char buchstabe) {
/*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'};
setBuchstabe(buchstabe);
/*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
for(int index = 0; index < walzenNummer().length; index++) {
if(getBuchstabe().equals(walzenNummer()[index])) {
iPositionBuchstabeRe = index;
for(int i = 0; i < walzenNummer().length; i++) {
if(walzenNummer()[i].equals(buchstabe)) {
buchstabe = walzeAlpha[i];
break;
}
}
Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
return codierterBuchstabeRe;
}
return buchstabe;
}
//_________________________________________________________________________________________
/**
* @return buchstabe : Character : gibt den neuen Buchstaben zurueck
*/
public Character 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
*/
public void setBuchstabe(Character buchstabe) {
if(Character.isLetter(buchstabe)) {
this.buchstabe = Character.toUpperCase(buchstabe);
} else {
this.buchstabe = 'A';
}
}
//TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
/**
* Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
*
* @param walzennr : int : setzt die Walzennummer
*/
public void setWalzennr(int walzennr) {
if(walzennr > 0 && walzennr < 6) {
this.walzennr = walzennr;
} else {
System.err.println("Keine gültige Walzennummer");
}
}
/**
* @return buchstabe : Character : gibt den neuen Buchstaben zurueck
*/
public Character 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
*/
public void setBuchstabe(Character buchstabe) {
if (Character.isLetter(buchstabe)) {
this.buchstabe = Character.toUpperCase(buchstabe);
for(int i = 0; i < 25; i++) {
if(walzeAlpha[i].equals(buchstabe)) {
this.iPositionBuchstabe = i;
}
}
} else {
this.buchstabe = 'A';
}
}
//TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
/**
* Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
*
* @param walzennr : int : setzt die Walzennummer
*/
public void setWalzennr(int walzennr) {
if (walzennr > 0 && walzennr < 6) {
this.walzennr = walzennr;
} else {
System.err.println("Keine gültige Walzennummer");
}
}
}
......@@ -7,7 +7,6 @@ public class ReflektorTest {
@Test
public void codiere() {
/*
Reflektor r = new Reflektor();
Assert.assertEquals('E', r.codiere('A'));
......@@ -16,18 +15,15 @@ public class ReflektorTest {
Assert.assertEquals('O', r.codiere('Q'));
Assert.assertEquals('I', r.codiere('V'));
//Assert.assertNull(null, r.codiere(null));
*/
}
@Test
public void codiere2() {
/*
Reflektor r = new Reflektor();
Assert.assertEquals('A', r.codiere('E'));
Assert.assertEquals('D', r.codiere('Z'));
Assert.assertEquals('H', r.codiere('X'));
Assert.assertEquals('Q', r.codiere('O'));
Assert.assertEquals('V', r.codiere('I'));
*/
}
}
\ No newline at end of file
......@@ -9,28 +9,28 @@ public class SteckbrettTest {
@Test
public void setzeVertauschung() {
/*Steckbrett sb = new Steckbrett();
Steckbrett sb = new Steckbrett();
sb.setzeVertauschung('A', 'G');
sb.setzeVertauschung('C', 'H');
Assert.assertEquals('H', sb.codiere('C'));
Assert.assertEquals('G', sb.codiere('A'));*/
Assert.assertEquals('G', sb.codiere('A'));
}
@Test
public void codiere() {
/*Steckbrett sb = new Steckbrett();
Steckbrett sb = new Steckbrett();
sb.setzeVertauschung('A', 'G');
sb.setzeVertauschung('C', 'H');
Assert.assertEquals('H', sb.codiere('C'));
Assert.assertEquals('G', sb.codiere('A'));*/
Assert.assertEquals('G', sb.codiere('A'));
}
@Test
public void codiere2() {
/*Steckbrett sb = new Steckbrett();
Steckbrett sb = new Steckbrett();
sb.setzeVertauschung('A', 'G');
sb.setzeVertauschung('C', 'H');
Assert.assertEquals('C', sb.codiere2('H'));
Assert.assertEquals('A', sb.codiere2('G'));*/
Assert.assertEquals('A', sb.codiere2('G'));
}
}
\ No newline at end of file
......@@ -9,37 +9,37 @@ public class WalzeTest {
@Test
public void setzeNotch() {
/*Walze w = new Walze(1);
Walze w = new Walze(1);
w.setzeNotch('G');
Assert.assertEquals('G', w.wlazenPosition());*/
Assert.assertEquals('G', w.wlazenPosition());
}
@Test
public void dreheWalze() {
/*Walze w = new Walze(1);
Walze w = new Walze(1);
w.setzeNotch('G');
w.dreheWalze();
Assert.assertEquals('H', w.wlazenPosition());*/
Assert.assertEquals('H', w.wlazenPosition());
}
@Test
public void walzenPoition() {
/*Walze w = new Walze(1);
Walze w = new Walze(1);
w.setzeNotch('G');
Assert.assertEquals('G', w.wlazenPosition());*/
Assert.assertEquals('G', w.wlazenPosition());
}
@Test
public void codiere() {
/*Walze w = new Walze(1);
Walze w = new Walze(1);
w.setzeNotch('A');
Assert.assertEquals('E', w.codiere('A'));*/
Assert.assertEquals('E', w.codiere('A'));
}
@Test
public void codiere2() {
/*Walze w = new Walze(1);
Walze w = new Walze(1);
w.setzeNotch('A');
Assert.assertEquals('A', w.codiere('E'));*/
Assert.assertEquals('A', w.codiere('E'));
}
}
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment