Added RestServer + Added Create User (/users)

.gitignore

@@ -10,7 +10,7 @@
 # Mobile Tools for Java (J2ME)
 .mtj.tmp/
 
-# Package Files #
+# at.reisinger.Package Files #
 *.jar
 *.war
 *.nar
@@ -23,3 +23,4 @@
 hs_err_pid*
 .idea/compiler.xml
 *.lst
+.idea/

.idea/compiler.xml

@@ -7,6 +7,7 @@
         <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
         <outputRelativeToContentRoot value="true" />
         <module name="MTCG" />
+        <module name="code" />
       </profile>
     </annotationProcessing>
   </component>

README.md

@@ -1,2 +1,2 @@
 # SWE1-MTCG
-Monster Trading Card Game
+Monster Trading at.reisinger.Card Game

pom.xml

@@ -7,6 +7,18 @@
     <groupId>at.reisinger.mtcg</groupId>
     <artifactId>MTCG</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>11</source>
+                    <target>11</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
     <dependencies>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -24,6 +36,11 @@
             <artifactId>mockito-junit-jupiter</artifactId>
             <version>3.5.13</version>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.11.2</version>
+        </dependency>
     </dependencies>
 
 

src/main/java/DBConnection.java

@@ -1,68 +0,0 @@
-import java.util.ArrayList;
-
-/**
- * Stellt die Verbindung zur "Datenbank" her
- * Die "Datenbank" sind hier nur beispieldaten.
- */
-public class DBConnection {
-    private ArrayList<TradingDeal> tradingDeals;
-    private ArrayList<Package> packages;
-
-    /**
-     * Erstellt alle Beispieldaten und simuliert somit den
-     * Verbindungsaufbau zu einer DB
-     */
-    public DBConnection(){
-        Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
-        Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL);
-        Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER);
-        Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL);
-        Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER);
-        ArrayList<Card> deckArrList = new ArrayList<Card>();
-        ArrayList<Card> stackArrList = new ArrayList<Card>();
-        deckArrList.add(c1);
-        deckArrList.add(c2);
-        stackArrList.add(c3);
-        stackArrList.add(c4);
-        stackArrList.add(c5);
-        Cards deck = new Cards(deckArrList);
-        Cards stack = new Cards(stackArrList);
-        User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000));
-        this.tradingDeals = new ArrayList<TradingDeal>();
-        this.packages = new ArrayList<Package>();
-        this.tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
-        this.packages.add(new Package(stack, "Test Package", 100));
-    }
-
-    /**
-     * Holt alle verfügbaren TradingDeals
-     * @return Alle Trading Deals
-     */
-    public ArrayList<TradingDeal> getAllTradingDeals(){
-        return this.tradingDeals;
-    }
-
-    /**
-     * Holt alle verfügbaren Packages
-     * @return Alle Packages
-     */
-    public ArrayList<Package> getAllPackages(){
-        return this.packages;
-    }
-
-    /**
-     * Fügt einen neuen Tradingdeal zum Store hinzu
-     * @param tradingDeal Der neue Deal
-     */
-    public void addTradingDeal(TradingDeal tradingDeal){
-        this.tradingDeals.add(tradingDeal);
-    }
-
-//    /**
-//     * Fügt ein neues Package zu dem Store hinzu
-//     * @param packageDeal Das neue Package
-//     */
-//    public void addPackage(Package packageDeal){
-//        this.packages.add(packageDeal);
-//    }
-}

src/main/java/at/reisinger/Battle.java

@@ -1,2 +1,4 @@
+package at.reisinger;
+
 public class Battle {
 }

src/main/java/at/reisinger/Card.java

@@ -1,5 +1,7 @@
+package at.reisinger;
+
 /**
- * Object einer Card
+ * Object einer at.reisinger.Card
  */
 public class Card {
     private String name;
@@ -8,11 +10,11 @@ public class Card {
     private CardType cardType;
 
     /**
-     * Erstellt eine neue Card mit gegebenen Eigenschaften
+     * Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften
-     * @param name Name der Card
+     * @param name Name der at.reisinger.Card
-     * @param damage Damage den die Card macht
+     * @param damage Damage den die at.reisinger.Card macht
-     * @param elementTyp ElementType der Card
+     * @param elementTyp ElementType der at.reisinger.Card
-     * @param cardType CardType der Card
+     * @param cardType at.reisinger.CardType der at.reisinger.Card
      */
     public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) {
         this.name = name;
@@ -22,42 +24,42 @@ public class Card {
     }
 
     /**
-     * Holt den Namen der Card
+     * Holt den Namen der at.reisinger.Card
-     * @return Name der Card
+     * @return Name der at.reisinger.Card
      */
     public String getName() {
         return this.name;
     }
 
     /**
-     * Holt den Damage der Card
+     * Holt den Damage der at.reisinger.Card
-     * @return Damage der Card
+     * @return Damage der at.reisinger.Card
      */
     public double getDamage() {
         return this.damage;
     }
 
     /**
-     * Holt den ElementType der Card
+     * Holt den ElementType der at.reisinger.Card
-     * @return ElementType der Card
+     * @return ElementType der at.reisinger.Card
      */
     public ElementTyp getElementTyp() {
         return this.elementTyp;
     }
 
     /**
-     * Holt den CardType der Card
+     * Holt den at.reisinger.CardType der at.reisinger.Card
-     * @return CardType der Card
+     * @return at.reisinger.CardType der at.reisinger.Card
      */
     public CardType getCardType() {
         return this.cardType;
     }
 
     /**
-     * Berechnet die Wirksamkeit gegen eine Andere card. Die Card im Parameter wird angegriffen
+     * Berechnet die Wirksamkeit gegen eine Andere card. Die at.reisinger.Card im Parameter wird angegriffen
-     * @param toCeck Card gegen welche die Wirksamkeit geprüft werden soll
+     * @param toCeck at.reisinger.Card gegen welche die Wirksamkeit geprüft werden soll
      * @return Gibt die Wirksamkeit zurück
-     * @throws InternalError Wenn die Effectifeness von den 2 Cards nicht berechnet werden kann
+     * @throws InternalError Wenn die Effectifeness von den 2 at.reisinger.Cards nicht berechnet werden kann
      */
     public EffectivnessType getEffectivenessAgainst(Card toCeck) {
         if(toCeck.getCardType() == CardType.MONSTER){
@@ -75,19 +77,19 @@ public class Card {
                 return EffectivnessType.NOEFFECT;
             }
         }
-        throw new InternalError("Konnte die Effectiveness von den Cards nicht berechnen");
+        throw new InternalError("Konnte die Effectiveness von den at.reisinger.Cards nicht berechnen");
     }
 
     /**
-     * Setztden namen der Card
+     * Setztden namen der at.reisinger.Card
-     * @param neuerName Name der Card
+     * @param neuerName Name der at.reisinger.Card
      */
     public void setName(String neuerName) {
         this.name = neuerName;
     }
 
     /**
-     * Setzt den Damage der Card
+     * Setzt den Damage der at.reisinger.Card
      * @param damage Der Damage
      */
     public void setDamage(int damage) {
@@ -95,7 +97,7 @@ public class Card {
     }
 
     /**
-     * Setzt den ElementType der Card
+     * Setzt den ElementType der at.reisinger.Card
      * @param elementTyp Der ElementType
      */
     public void setElementType(ElementTyp elementTyp) {
@@ -104,7 +106,7 @@ public class Card {
 
     /**
      * Testet ob die beiden Karten gleich sind
-     * @param card Card die geprüft werden soll
+     * @param card at.reisinger.Card die geprüft werden soll
      * @return True wenn die Karten übereinstimmen
      */
     public boolean equals(Card card){

src/main/java/at/reisinger/CardType.java

@@ -1,3 +1,5 @@
+package at.reisinger;
+
 public enum CardType {
     MONSTER, SPELL
 }

src/main/java/at/reisinger/Cards.java

@@ -1,16 +1,17 @@
+package at.reisinger;
+
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
- * Verwaltet eine Liste vo Cards
+ * Verwaltet eine Liste vo at.reisinger.Cards
  */
 public class Cards {
     private ArrayList<Card> cards;
 
     /**
      * Erstellt ein nues obj mit gegebenen Karten
-     * @param cardsArrayList Die Cards zum erstellen des Obj
+     * @param cardsArrayList Die at.reisinger.Cards zum erstellen des Obj
      */
     public Cards(ArrayList<Card> cardsArrayList) {
         this.cards = cardsArrayList;
@@ -19,33 +20,33 @@ public class Cards {
 
 
     /**
-     * Fügt eine neue Card hinzu
+     * Fügt eine neue at.reisinger.Card hinzu
-     * @param newCard neue Card
+     * @param newCard neue at.reisinger.Card
      */
     public void addCard(Card newCard) {
         this.cards.add(newCard);
     }
 
     /**
-     * Holt alle Cards
+     * Holt alle at.reisinger.Cards
-     * @return Alle Cards
+     * @return Alle at.reisinger.Cards
      */
     public ArrayList<Card> getCards() {
         return this.cards;
     }
 
     /**
-     * Löscht die gegebene Card
+     * Löscht die gegebene at.reisinger.Card
-     * @param delCard Card zum löschen
+     * @param delCard at.reisinger.Card zum löschen
      */
     public void delCard(Card delCard) {
         this.cards.removeIf(obj -> obj.equals(delCard));
     }
 
     /**
-     * Prüft ob eine Card in den Cards vorhanden ist
+     * Prüft ob eine at.reisinger.Card in den at.reisinger.Cards vorhanden ist
-     * @param toCeck Card nach der in den Cards gesucht werden soll
+     * @param toCeck at.reisinger.Card nach der in den at.reisinger.Cards gesucht werden soll
-     * @return True wenn die Card in den Cards ist
+     * @return True wenn die at.reisinger.Card in den at.reisinger.Cards ist
      */
     public boolean containsCard(Card toCeck){
         AtomicBoolean returnval = new AtomicBoolean(false);
@@ -60,9 +61,9 @@ public class Cards {
     }
 
     /**
-     * Vergleicht 2 Cards Obj miteinander
+     * Vergleicht 2 at.reisinger.Cards Obj miteinander
-     * @param toCompare Cards zum vergleichen
+     * @param toCompare at.reisinger.Cards zum vergleichen
-     * @return True wenn es aus den selben Cards besteht
+     * @return True wenn es aus den selben at.reisinger.Cards besteht
      */
     public boolean equals(Cards toCompare){
         if (this.cards == null && toCompare.getCards() == null){

src/main/java/at/reisinger/Coins.java

@@ -1,3 +1,5 @@
+package at.reisinger;
+
 /**
  * Alle coins eines Users
  */
@@ -27,7 +29,7 @@ public class Coins {
      */
     public void addCoin(int coins) throws NegativAmountException{
         if(coins < 0) {
-            throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden");
+            throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden");
         }else {
             this.amount += coins;
         }
@@ -41,7 +43,7 @@ public class Coins {
      */
     public boolean removeCoin(int coins) throws NegativAmountException{
         if(coins < 0) {
-            throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden");
+            throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden");
         }else {
             this.amount -= coins;
             return true;
@@ -56,7 +58,7 @@ public class Coins {
      */
     public boolean changeCoinAmmount(int coins) throws NegativAmountException{
         if(coins < 0) {
-            throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden");
+            throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden");
         }else {
             this.amount = coins;
             return true;

src/main/java/at/reisinger/Credentials.java

@@ -1,11 +1,13 @@
+package at.reisinger;
+
 /**
- * User Login Daten
+ * at.reisinger.User Login Daten
  */
 public class Credentials {
     private String passwort, username;
 
     /**
-     * Startet einen neuen User mit folgenden Daten
+     * Startet einen neuen at.reisinger.User mit folgenden Daten
      * @param username Diesem Usernamen
      * @param passwort Diesem Passwort
      */
@@ -23,7 +25,7 @@ public class Credentials {
     }
 
 //    /**
-//     * Setzt das User Passwort
+//     * Setzt das at.reisinger.User Passwort
 //     * @param passwort Neues Passwort
 //     */
 //    public void setPasswort(String passwort) {

src/main/java/at/reisinger/DBConnection.java

@@ -0,0 +1,137 @@
+package at.reisinger;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+
+/**
+ * Stellt die Verbindung zur "Datenbank" her
+ * Die "Datenbank" sind hier nur beispieldaten.
+ */
+public class DBConnection {
+    private ArrayList<TradingDeal> tradingDeals;
+    private ArrayList<Package> packages;
+    private Connection c;
+    private Statement stmt;
+
+    private Connection con(){
+        this.c = null;
+        try {
+            Class.forName("org.postgresql.Driver");
+            this.c = DriverManager
+                    .getConnection("jdbc:postgresql://postgres.dergeorg.at:5432/mtcg",
+                            "user", "user");
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.err.println(e.getClass().getName()+": "+e.getMessage());
+            System.exit(0);
+        }
+        System.out.println("Opened database");
+        return c;
+    }
+
+    /**
+     * Erstellt alle Beispieldaten und simuliert somit den
+     * Verbindungsaufbau zu einer DB
+     */
+    public DBConnection(){
+        this.c = con();
+        System.out.println("Create Tables start");
+        try {
+            createTables();
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+        }
+        /*
+        Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
+        Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL);
+        Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER);
+        Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL);
+        Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER);
+        ArrayList<Card> deckArrList = new ArrayList<Card>();
+        ArrayList<Card> stackArrList = new ArrayList<Card>();
+        deckArrList.add(c1);
+        deckArrList.add(c2);
+        stackArrList.add(c3);
+        stackArrList.add(c4);
+        stackArrList.add(c5);
+        Cards deck = new Cards(deckArrList);
+        Cards stack = new Cards(stackArrList);
+        User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000));
+        this.tradingDeals = new ArrayList<TradingDeal>();
+        this.packages = new ArrayList<Package>();
+        this.tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
+        this.packages.add(new Package(stack, "Test at.reisinger.Package", 100));
+        */
+    }
+
+    private void createTables() throws SQLException {
+        this.c = con();
+        try{
+        stmt = this.c.createStatement();
+        String sql = "CREATE TABLE IF NOT EXISTS USERS " +
+                "(username       TEXT PRIMARY KEY     NOT NULL," +
+                " nachname           TEXT    NOT NULL, " +
+                " email            TEXT     NOT NULL, " +
+                " password        TEXT NOT NULL)";
+        stmt.executeUpdate(sql);
+        stmt.close();
+        this.c.close();
+        } catch ( Exception e ) {
+            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
+            System.exit(0);
+        }
+        System.out.println("User Table created");
+    }
+
+    public boolean addUser(String username, String password, String nachname, String email){
+        this.c = con();
+        try{
+            stmt = this.c.createStatement();
+            String sql = "INSERT INTO users (username, nachname, email, password) values (\'" + username +"\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\')";
+            System.out.println(sql);
+            stmt.executeUpdate(sql);
+            stmt.close();
+            this.c.close();
+        } catch ( Exception e ) {
+            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
+            return false;
+        }
+        System.out.println("User added");
+        return true;
+    }
+
+    /**
+     * Holt alle verfügbaren TradingDeals
+     * @return Alle Trading Deals
+     */
+    public ArrayList<TradingDeal> getAllTradingDeals(){
+        return this.tradingDeals;
+    }
+
+    /**
+     * Holt alle verfügbaren Packages
+     * @return Alle Packages
+     */
+    public ArrayList<Package> getAllPackages(){
+        return this.packages;
+    }
+
+    /**
+     * Fügt einen neuen Tradingdeal zum at.reisinger.Store hinzu
+     * @param tradingDeal Der neue Deal
+     */
+    public void addTradingDeal(TradingDeal tradingDeal){
+        this.tradingDeals.add(tradingDeal);
+    }
+
+//    /**
+//     * Fügt ein neues at.reisinger.Package zu dem at.reisinger.Store hinzu
+//     * @param packageDeal Das neue at.reisinger.Package
+//     */
+//    public void addPackage(at.reisinger.Package packageDeal){
+//        this.packages.add(packageDeal);
+//    }
+}

src/main/java/at/reisinger/EffectivnessType.java

@@ -1,3 +1,5 @@
+package at.reisinger;
+
 public enum EffectivnessType {
     EFFECTIVE,
     NOTEFFECTIVE,

src/main/java/at/reisinger/ElementTyp.java

@@ -1,3 +1,5 @@
+package at.reisinger;
+
 public enum ElementTyp {
     WATER, FIRE, NORMAL
 }

src/main/java/at/reisinger/MonsterCard.java

@@ -1,3 +1,5 @@
+package at.reisinger;
+
 public class MonsterCard extends Card{
     public MonsterCard(String name, double damage, ElementTyp elementTyp, CardType cardType) {
         super(name, damage, elementTyp, cardType);

src/main/java/at/reisinger/NegativAmountException.java

@@ -1,3 +1,5 @@
+package at.reisinger;
+
 /**
  * Wenn ein negativer wert eingegeben wird aber ein Positiver erwartet wird, dann kann diese Exception geworfen werden
  */

src/main/java/at/reisinger/Package.java

@@ -1,13 +1,15 @@
+package at.reisinger;
+
 /**
- * Package besteht aus 4 Karten. Ist eine Erweiterung der Cards, zeigt für 4 Cards den Preis und einen Packagenamen an
+ * at.reisinger.Package besteht aus 4 Karten. Ist eine Erweiterung der at.reisinger.Cards, zeigt für 4 at.reisinger.Cards den Preis und einen Packagenamen an
  */
 public class Package extends Cards{
     private String name;
     private int price;
 
     /**
-     * Erstellt ein neues Package mit den gegebenen Stats
+     * Erstellt ein neues at.reisinger.Package mit den gegebenen Stats
-     * @param stack Cards des Packages
+     * @param stack at.reisinger.Cards des Packages
      * @param name Name des Packages
      * @param price Price des Packages
      */

src/main/java/at/reisinger/SpellCard.java

@@ -1,3 +1,5 @@
+package at.reisinger;
+
 public class SpellCard extends Card{
     public SpellCard(String name, double damage, ElementTyp elementTyp, CardType cardType) {
         super(name, damage, elementTyp, cardType);

src/main/java/at/reisinger/Stack.java

@@ -1,12 +1,14 @@
+package at.reisinger;
+
 /**
- * Erweitert Cards insofern, dass es im Stack auch ein Deck gibt
+ * Erweitert at.reisinger.Cards insofern, dass es im at.reisinger.Stack auch ein Deck gibt
  */
 public class Stack extends Cards{
     private Cards deck;
 
     /**
-     * Erstellt einen neuen Stack aus den User Cards und seinem Deck
+     * Erstellt einen neuen at.reisinger.Stack aus den at.reisinger.User at.reisinger.Cards und seinem Deck
-     * @param cards Alle Cards des Users
+     * @param cards Alle at.reisinger.Cards des Users
      * @param deck Sein Deck
      */
     public Stack(Cards cards, Cards deck) {
@@ -15,7 +17,7 @@ public class Stack extends Cards{
     }
 
     /**
-     * Fügt ein neues Deck in den Stack ein
+     * Fügt ein neues Deck in den at.reisinger.Stack ein
      * @param newCards Gesamtes Deck
      */
     public void addDeck(Cards newCards) {
@@ -31,18 +33,18 @@ public class Stack extends Cards{
     }
 
     /**
-     * Löscht eine Card aus dem Deck
+     * Löscht eine at.reisinger.Card aus dem Deck
-     * @param toDel Card zum löschen
+     * @param toDel at.reisinger.Card zum löschen
      */
     public void delDeck(Card toDel) {
         this.deck.delCard(toDel);
     }
 
 //    /**
-//     * Fügt dem deck eine neue Card ein
+//     * Fügt dem deck eine neue at.reisinger.Card ein
-//     * @param toAdd Neue Card
+//     * @param toAdd Neue at.reisinger.Card
 //     */
-//    public void addDeckCard(Card toAdd){
+//    public void addDeckCard(at.reisinger.Card toAdd){
 //        this.deck.addCard(toAdd);
 //    }
 }

src/main/java/at/reisinger/Store.java

@@ -1,3 +1,5 @@
+package at.reisinger;
+
 import java.util.ArrayList;
 
 public interface Store {

src/main/java/at/reisinger/TradingDeal.java

@@ -1,23 +1,25 @@
+package at.reisinger;
+
 /**
  * Ein einzelner Trading deal wird hier verwaltet.
  */
 public class TradingDeal {
-    private User tradingUser;
+    //private User tradingUser;
     private Card cardToTrade;
     private ElementTyp requiredElementType;
     private double requiredMinDamage;
     private CardType requiredCardType;
 
     /**
-     * Ein TradingDeal wird  erstellt
+     * Ein at.reisinger.TradingDeal wird  erstellt
-     * @param user User des Deals
+     * @param user at.reisinger.User des Deals
-     * @param cardToTrade Card die getauscht werden soll
+     * @param cardToTrade at.reisinger.Card die getauscht werden soll
      * @param requiredElementType Req ElementType für den Tausch
      * @param requiredMinDamage Req min damage für den Tausch
-     * @param requiredCardType Req Card Type für den Tausch
+     * @param requiredCardType Req at.reisinger.Card Type für den Tausch
      */
     public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) {
-        this.tradingUser = user;
+        //this.tradingUser = user;
         this.cardToTrade = cardToTrade;
         this.requiredElementType = requiredElementType;
         this.requiredMinDamage = requiredMinDamage;
@@ -25,16 +27,16 @@ public class TradingDeal {
     }
 
     /**
-     * Holt den Trading User
+     * Holt den Trading at.reisinger.User
-     * @return User der den Trade erstellt hat
+     * @return at.reisinger.User der den Trade erstellt hat
-     */
+
     public User getTradingUser() {
         return this.tradingUser;
     }
-
+*/
     /**
-     * Card die getraded werden soll
+     * at.reisinger.Card die getraded werden soll
-     * @return Card die getradet werden soll
+     * @return at.reisinger.Card die getradet werden soll
      */
     public Card getCardToTrade() {
         return this.cardToTrade;
@@ -58,23 +60,23 @@ public class TradingDeal {
 
     /**
      * Hole req cardtype
-     * @return Req CardType
+     * @return Req at.reisinger.CardType
      */
     public CardType getRequiredCardType() {
         return this.requiredCardType;
     }
 
     /**
-     * Setzt den User des Trades
+     * Setzt den at.reisinger.User des Trades
-     * @param tradingUser User der Traded
+     * @param tradingUser at.reisinger.User der Traded
-     */
+
     public void setTradingUser(User tradingUser) {
         this.tradingUser = tradingUser;
     }
-
+*/
     /**
      * Setzt die Karte die Getradet werden soll
-     * @param cardToTrade Card zum tauschen
+     * @param cardToTrade at.reisinger.Card zum tauschen
      */
     public void setCardToTrade(Card cardToTrade) {
         this.cardToTrade = cardToTrade;
@@ -98,14 +100,14 @@ public class TradingDeal {
 
     /**
      * Setzt req cardType
-     * @param requiredCardType Der Req CardType
+     * @param requiredCardType Der Req at.reisinger.CardType
      */
     public void setRequiredCardType(CardType requiredCardType) {
         this.requiredCardType = requiredCardType;
     }
 
     /**
-     * Vom deal im Parameter wird die Card mit den Requirements von THIS verglichen
+     * Vom deal im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen
      * @param checkDeal Von diesem Deal wird die CardToTrade geprüft
      * @return True wenn der Deal passt
      */
@@ -114,8 +116,8 @@ public class TradingDeal {
     }
 
     /**
-     * Von der Card im Parameter wird die Card mit den Requirements von THIS verglichen
+     * Von der at.reisinger.Card im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen
-     * @param checkCard Card die mit dem Deal verglichen wird
+     * @param checkCard at.reisinger.Card die mit dem Deal verglichen wird
      * @return True wenn der Deal passt
      */
     public boolean cardOk(Card checkCard){

src/main/java/at/reisinger/User.java

@@ -1,17 +1,26 @@
+package at.reisinger;
+
+import com.fasterxml.jackson.annotation.*;
+
 import java.util.ArrayList;
 
 /**
- * User & Store Logik
+ * at.reisinger.User & at.reisinger.Store Logik
  */
+@JsonAutoDetect
 public class User implements Store{
+    @JsonProperty
     private String name, nachname, email;
+    @JsonProperty
     private Stack stack;
-    private DBConnection db;
+    //private DBConnection db;
+    @JsonProperty
     private Credentials credentials;
+    @JsonProperty
     private Coins coins;
 
     /**
-     * Erstellt einen neuen User
+     * Erstellt einen neuen at.reisinger.User
      * @param credentials Zugangsdaten des Users
      * @param name Name des Users
      * @param nachname Nachname des Users
@@ -19,28 +28,42 @@ public class User implements Store{
      * @param stack Alle Karten des Users
      * @param coins Alle Münzen des Users
      */
-    public User(Credentials credentials, String name, String nachname, String email, Stack stack, Coins coins) {
+    @JsonCreator
+    public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Stack stack,@JsonProperty Coins coins) {
         this.credentials = credentials;
         this.name = name;
         this.nachname = nachname;
         this.email = email;
         this.stack = stack;
         this.coins = coins;
-        //this.db = new DBConnection();
+        //this.db = new at.reisinger.DBConnection();
+    }
+
+    @JsonCreator
+    public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Coins coins) {
+        this.credentials = credentials;
+        this.name = name;
+        this.nachname = nachname;
+        this.email = email;
+        this.stack = null;
+        this.coins = coins;
+        //this.db = new at.reisinger.DBConnection();
     }
 
     /**
-     * Holt den Stack des Users
+     * Holt den at.reisinger.Stack des Users
-     * @return Stack des Users
+     * @return at.reisinger.Stack des Users
      */
+    @JsonGetter
     public Stack getStack() {
         return stack;
     }
 
     /**
-     * Setzt den Stack eines Users
+     * Setzt den at.reisinger.Stack eines Users
-     * @param stack Der neue Stack des Users
+     * @param stack Der neue at.reisinger.Stack des Users
      */
+    @JsonSetter
     public void setStack(Stack stack) {
         this.stack = stack;
     }
@@ -48,7 +71,8 @@ public class User implements Store{
     /**
      * Holt das DB Obj
      * @return Das DB Obj
-     */
+
+    @JsonGetter
     public DBConnection getDb() {
         return new DBConnection();
     }
@@ -56,63 +80,74 @@ public class User implements Store{
     /**
      * Setzt ein neues DB Obj
      * @param db Das neue DB Obj
-     */
+
+
+    @JsonSetter
     public void setDb(DBConnection db) {
         this.db = db;
     }
 
+    */
+
     /**
      * Holt die eindeutigen Logindaten des Users
      * @return Eindeutige Logindaten
      */
+    @JsonGetter
     public Credentials getCredentials() {
         return credentials;
     }
 
     /**
      * Setzt die eindeutigen Logindaten
-     * @param credentials Die neuen Credentials des Users
+     * @param credentials Die neuen at.reisinger.Credentials des Users
      */
+    @JsonSetter
     public void setCredentials(Credentials credentials) {
         this.credentials = credentials;
     }
 
     /**
-     * Holt alle Coins des Users
+     * Holt alle at.reisinger.Coins des Users
-     * @return Coins des Users
+     * @return at.reisinger.Coins des Users
      */
+    @JsonGetter
     public Coins getCoins() {
         return coins;
     }
 
     /**
-     * Setzt alle Coins des Users
+     * Setzt alle at.reisinger.Coins des Users
-     * @param coins Neue Coins des Users
+     * @param coins Neue at.reisinger.Coins des Users
      */
+    @JsonSetter
     public void setCoins(Coins coins) {
         this.coins = coins;
     }
 
     /**
-     * Get Name of User
+     * Get Name of at.reisinger.User
-     * @return Name of User
+     * @return Name of at.reisinger.User
      */
+    @JsonGetter
     public String getName() {
         return this.name;
     }
 
     /**
-     * Get Nachname of User
+     * Get Nachname of at.reisinger.User
-     * @return Nachname of User
+     * @return Nachname of at.reisinger.User
      */
+    @JsonGetter
     public String getNachname() {
         return this.nachname;
     }
 
     /**
-     * Email of User
+     * Email of at.reisinger.User
-     * @return Email of User
+     * @return Email of at.reisinger.User
      */
+    @JsonGetter
     public String getEmail() {
         return this.email;
     }
@@ -121,6 +156,7 @@ public class User implements Store{
      * Setzt den Namen des Users
      * @param name Neuer Name des Users
      */
+    @JsonSetter
     public void setName(String name) {
         this.name = name;
     }
@@ -129,6 +165,7 @@ public class User implements Store{
      * Setzt den Nachnamen
      * @param nachname Neuer Nachname
      */
+    @JsonSetter
     public void setNachname(String nachname) {
         this.nachname = nachname;
     }
@@ -137,27 +174,28 @@ public class User implements Store{
      * Setzt die Email des Users
      * @param email Neue Email des Users
      */
+    @JsonSetter
     public void setEmail(String email) {
         this.email = email;
     }
 
-    //Store Methoden
+    //at.reisinger.Store Methoden
 
     /**
-     * Kauft ein Package
+     * Kauft ein at.reisinger.Package
-     * @param mypackage Package welches gekauft werden soll
+     * @param mypackage at.reisinger.Package welches gekauft werden soll
-     * @return Alle Karten des neuen Package
+     * @return Alle Karten des neuen at.reisinger.Package
-     * @throws NegativAmountException Wenn ein negativer Preis im Package gesetzt wird.
+     * @throws NegativAmountException Wenn ein negativer Preis im at.reisinger.Package gesetzt wird.
      */
     public ArrayList<Card> buyPackage(Package mypackage) throws NegativAmountException {
-        ArrayList<Package> availablePackages = new DBConnection().getAllPackages();
+        //ArrayList<Package> availablePackages = new DBConnection().getAllPackages();
-        availablePackages.removeIf(obj -> obj.equals(mypackage));
+        //availablePackages.removeIf(obj -> obj.equals(mypackage));
         this.coins.removeCoin(mypackage.getPrice());
         return mypackage.getCards();
     }
 
     /**
-     * Fügt dem Store einen neuen Tradingdeal hinzu
+     * Fügt dem at.reisinger.Store einen neuen Tradingdeal hinzu
      * @param tradingDeal Der neue Tradingdeal
      */
     public void addTradingDeal(TradingDeal tradingDeal) {
@@ -174,8 +212,8 @@ public class User implements Store{
 
     /**
      * Startet ein Trading zw 2 TradingDeals
-     * @param myTradingDeal Wenn der Deal passt, wird diese Karte aus dem Stack entfernt
+     * @param myTradingDeal Wenn der Deal passt, wird diese Karte aus dem at.reisinger.Stack entfernt
-     * @param storeTradingDeal Wenn der Deal passt, wird diese Karte dem Stack hinzugefügt
+     * @param storeTradingDeal Wenn der Deal passt, wird diese Karte dem at.reisinger.Stack hinzugefügt
      * @return True wenn erfolgreich, False wenn die Deals nicht zusammenpassen
      */
     public boolean doTrading(TradingDeal myTradingDeal, TradingDeal storeTradingDeal) {
@@ -206,9 +244,9 @@ public class User implements Store{
     }
 
     /**
-     * Checkt ob es sich um den selben User handelt
+     * Checkt ob es sich um den selben at.reisinger.User handelt
-     * @param toCheck Mit diesem User wird verglichen
+     * @param toCheck Mit diesem at.reisinger.User wird verglichen
-     * @return True wenn es der selbe User ist
+     * @return True wenn es der selbe at.reisinger.User ist
      */
     public boolean equals(User toCheck){
         if (toCheck.getCredentials().getUsername() == this.credentials.getUsername() && toCheck.getCredentials().getPasswort() == this.credentials.getPasswort()){

src/main/java/at/reisinger/server/Main.java

@@ -0,0 +1,65 @@
+package at.reisinger.server;
+
+import at.reisinger.server.msg.MsgHandler;
+import at.reisinger.server.objects.Request;
+import at.reisinger.server.objects.Response;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * Grundlegende Server logic
+ * Vereint alle anderen Klassen
+ */
+public class Main {
+    static final int port = 80;
+    private Socket socket;
+    private int id;
+    private MsgHandler msgHandler;
+
+    /**
+     * Initial Start
+     * @param args Nicht Verwendet
+     */
+    public static void main(String[] args) {
+        System.out.println("Starte Server auf Port 80");
+        new Main(port);
+    }
+
+    /**
+     * Öffnet den Server Socket und akzepiert diesen
+     * @param port Port auf dem der Server läuft
+     */
+    public Main(int port){
+        ServerSocket serverSocket = null;
+        try {
+            serverSocket = new ServerSocket(port);
+
+            //this.msgHandler = new MsgHandler();
+            //this.id = 0;
+            while (true){
+                this.socket = serverSocket.accept();
+                requestResponding();
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Jeder Request durchläuft diese Funktion, reagiert auf requests
+     */
+    public void requestResponding(){
+        try{
+            System.out.println("Socket von Client #" + this.id + " wurde gestartet!");
+            Request rq = new Request(this.socket, this.id);
+            Response rp = new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), null, rq.getPayload());
+            //this.msgHandler = rp.getMsghandler();
+            this.socket.close();
+            System.out.println("Socket von Client #" + this.id + " wurde geschlossen!");
+        }catch (IOException e){
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/at/reisinger/server/helper/JsonHelper.java

@@ -0,0 +1,7 @@
+package at.reisinger.server.helper;
+
+public class JsonHelper {
+
+
+
+}

src/main/java/at/reisinger/server/msg/MsgHandler.java

@@ -0,0 +1,89 @@
+package at.reisinger.server.msg;
+
+import at.reisinger.server.objects.Msg;
+
+import java.util.HashMap;
+
+/**
+ * Der Speicher der Nachrichten
+ * Mit hilfe einer HashMap werden die MsgId und die Msg selbst gespeichert
+ * @author Georg Reisinger
+ */
+public class MsgHandler {
+    private HashMap<Integer , String> msgHashMap;
+    private int lastID;
+
+    /**
+     * Erstellt den MsgHandler mit standart Test Messages
+     */
+    public MsgHandler(){
+        msgHashMap = new HashMap<Integer, String>();
+        addMsg("Hallo");
+        addMsg("Wie");
+        addMsg("Geht");
+        addMsg("Es");
+        addMsg("Dir?");
+
+    }
+
+    /**
+     * Ermitelt die nächste freie Id
+     * @return Next ID
+     */
+    private int nextId(){
+        return this.lastID + 1;
+    }
+
+    /**
+     * Msg hinzufügen
+     * @param msg Message Text
+     */
+    public int addMsg(String msg){
+        int id = nextId();
+        msgHashMap.put(id, msg);
+        this.lastID = id;
+        return id;
+    }
+
+    /**
+     * Msg löschen
+     * @param id Message Id
+     */
+    public String delMsg(int id){
+        return msgHashMap.remove(id);
+    }
+
+    /**
+     * Msg bearbeiten
+     * @param id Message Id
+     * @param msg Message Text
+     */
+    public String editMsg(int id, String msg){
+        return msgHashMap.replace(id, msg);
+    }
+
+    /**
+     * Msg als Objekt holen
+     * @param id Message Id
+     * @return Message als Msg Objekt
+     */
+    public Msg getMsg(int id){
+        return new Msg(id, msgHashMap.get(id));
+    }
+
+    /**
+     * Alle Nachrichten werden in den Format Key, Value besorgt
+     * bsp: key: 1 value: Nachricht
+     * @return Alle nachrichten in einem String
+     */
+    public String getAllMsg(){
+        String returnStr = "";
+        // Print keys and values
+        for (Integer i : msgHashMap.keySet()) {
+            String item = "key: " + i + " value: " + msgHashMap.get(i) + "\n";
+            returnStr += item;
+        }
+        System.out.println(returnStr);
+        return returnStr;
+    }
+}

src/main/java/at/reisinger/server/objects/Msg.java

@@ -0,0 +1,37 @@
+package at.reisinger.server.objects;
+
+/**
+ * Message Objekt beinmhaltet die MsgId und die Msg selbst
+ * @author Georg Reisinger
+ */
+public class Msg {
+    private int id;
+    private String msg;
+
+    /**
+     * Erstellt eine Message
+     */
+    public Msg(int id, String msg){
+        this.id = id;
+        this.msg = msg;
+    }
+
+
+    /**
+     * get field
+     *
+     * @return id Message Id
+     */
+    public int getId() {
+        return this.id;
+    }
+
+    /**
+     * get field
+     *
+     * @return msg Message String
+     */
+    public String getMsg() {
+        return this.msg;
+    }
+}

src/main/java/at/reisinger/server/objects/Request.java

@@ -0,0 +1,110 @@
+package at.reisinger.server.objects;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Verarbeitet einen Request
+ * @author Georg Reisinger
+ */
+public class Request {
+
+    private final Socket socket;
+    private final int          id;
+    private PrintStream out;
+    private String       cmd;
+    private String       url;
+    private final StringBuilder rqBuilder;
+    private String payload;
+
+    /**
+     * Get Request
+     * @param socket Socket von dem der Request kommt
+     * @param id Thread ID
+     */
+    public Request(Socket socket, int id) throws IOException {
+        this.socket = socket;
+        this.rqBuilder = new StringBuilder();
+        this.id = id;
+        this.out = new PrintStream(this.socket.getOutputStream());
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+        String line = bufferedReader.readLine();
+        while (!line.isBlank()) {
+            rqBuilder.append(line + "\r\n");
+            line = bufferedReader.readLine();
+            System.out.println(line);
+        }
+        String request = rqBuilder.toString();
+        String[] requestsLines = request.split("\r\n");
+        String[] requestLine = requestsLines[0].split(" ");
+        String method = requestLine[0];
+        String path = requestLine[1];
+        String version = requestLine[2];
+        String host = requestsLines[1].split(" ")[1];
+
+        //code to read the post payload data
+        StringBuilder payload = new StringBuilder();
+        while(bufferedReader.ready()){
+            payload.append((char) bufferedReader.read());
+        }
+        System.out.println("Payload: " + payload.toString());
+        this.payload = payload.toString();
+
+        this.url = path;
+        this.cmd = method;
+
+        List<String> headers = new ArrayList<>();
+        for (int h = 2; h < requestsLines.length; h++) {
+            String header = requestsLines[h];
+            headers.add(header);
+        }
+
+        String accessLog = String.format("Client %s, method %s, path %s, version %s, host %s, headers %s",
+                socket.toString(), method, path, version, host, headers.toString());
+        System.out.println(accessLog);
+    }
+
+
+
+    /**
+     * Get PrintStream --> Output
+     *
+     * @return out PrintStream --> Output
+     */
+    public PrintStream getOut() {
+        return this.out;
+    }
+
+    /**
+     * Command wie GET, PUT, POST, DEL
+     *
+     * @return cmd als String
+     */
+    public String getCmd() {
+        return this.cmd;
+    }
+
+    /**
+     * Request url
+     *
+     * @return url als String
+     */
+    public String getUrl() {
+        return this.url;
+    }
+
+    /**
+     * Payload des Request
+     *
+     * @return payload als String
+     */
+    public String getPayload() {
+        return this.payload;
+    }
+
+}

src/main/java/at/reisinger/server/objects/Response.java

@@ -0,0 +1,192 @@
+package at.reisinger.server.objects;
+
+import at.reisinger.*;
+import at.reisinger.server.msg.MsgHandler;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.io.PrintStream;
+import java.util.Map;
+
+/**
+ * Erstellt und sendet eine Response anhand des Requests
+ * @author Georg Reisinger
+ */
+public class Response {
+
+    //private final Socket socket;
+    private final int          id;
+    private PrintStream out;
+    private String       cmd;
+    private String       url;
+    private String payload;
+    private MsgHandler msgHandler;
+    private StringBuilder rqBuilder;
+
+    /**
+     * Nimmt die Daten des requests und generiert eine Response
+     * @param id Thread Id
+     * @param url Request Url
+     * @param cmd Request CMD
+     * @param out out Print Stream
+     * @param msgHandler Der MsgHandler
+     * @param payload Payload des Requests
+     */
+    public Response(int id, String url, String cmd, PrintStream out, MsgHandler msgHandler, String payload){
+        this.id = id;
+        this.msgHandler = msgHandler;
+        this.url = url;
+        this.cmd = cmd;
+        this.out = out;
+        this.payload = payload;
+        this.rqBuilder = new StringBuilder();
+        System.out.println(cmd);
+        if (this.url != null) {
+            if (this.cmd.equals("GET")) {
+                getMethodes();
+            }else if (this.cmd.equals("POST")){
+                try {
+                    postMethodes();
+                } catch (JsonProcessingException e) {
+                    e.printStackTrace();
+                }
+            }else if (this.cmd.equals("PUT")){
+                putMethodes();
+            }else if (this.cmd.equals("DELETE")){
+                deleteMethodes();
+            }else{
+                sendError("405");
+            }
+        }
+    }
+
+    private void getMethodes(){
+        if (this.url.startsWith("/messages")) {
+            String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1);
+            System.out.println("Last Bit: " + lastBit);
+            if(lastBit.equals("messages")){
+                listAllMsg();
+            }else{
+                String message = msgHandler.getMsg(Integer.parseInt(lastBit)).getMsg();
+                if(message == null){
+                    sendError("404");
+                }else {
+                    sendResponse(message, "200");
+                }
+            }
+        } else if (this.url.startsWith("/")) {
+            startseite();
+        }
+    }
+
+    private void postMethodes() throws JsonProcessingException {
+        if (this.url.startsWith("/users")) {
+            //payload to map
+            ObjectMapper objectMapper = new ObjectMapper();
+            Map<String, Object> map = objectMapper.readValue(this.payload, new TypeReference<Map<String,Object>>(){});
+            String username = (String) map.get("Username");
+            String password = (String) map.get("Password");
+            User newUser = new User(new Credentials(username, password), username, username, "not implemented", new Coins(20));
+            System.out.println("CON DB");
+            DBConnection con = new DBConnection();
+            if(!con.addUser(username, password, username, "not implemented")){
+                sendError("500");
+            }
+
+            //User to json
+            objectMapper = new ObjectMapper();
+            String userJson = "";
+            if(newUser != null) {
+                try {
+                    userJson += objectMapper.writeValueAsString(newUser);
+                } catch (JsonProcessingException e) {
+                    userJson = "Error: JsonProcessingException -> " + e.getMessage();
+                }
+                sendResponse(userJson, "200");
+            }else{
+                sendError("500");
+            }
+        }else if (this.url.startsWith("/sessions")) {
+
+        }
+    }
+
+    private void putMethodes(){
+        if (this.url.startsWith("/messages")) {
+            String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1);
+            System.out.println("Last Bit: " + lastBit);
+            System.out.println("Payload" + this.payload);
+            String message = msgHandler.editMsg(Integer.parseInt(lastBit), this.payload);
+            if(message == null){
+                sendError("404");
+            }else {
+                sendResponse("","200");
+            }
+        }
+    }
+
+    private void deleteMethodes(){
+        if (this.url.startsWith("/messages")) {
+            String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1);
+            String message = msgHandler.delMsg(Integer.parseInt(lastBit));
+            if(message == null){
+                sendError("404");
+            }else {
+                sendResponse("", "200");
+            }
+        }
+    }
+
+
+    /**
+     * Sendet einen Error Response
+     * @param errorCode Der Error Code
+     */
+    private void sendError(String errorCode) {
+        out.print("HTTP/1.0 "+errorCode+"\r\n");
+        out.print("Server: Apache/0.8.4\r\n");
+        out.print("Content-Type: text/plain\r\n");
+        out.print("Content-Length: 1\r\n");
+        out.print("\r\n");
+        //out.print(responseText);
+    }
+
+    private void startseite() {
+        sendResponse("lists all messages:   GET    /messages<br>" +
+                "add message:          POST   /messages     (Payload: the message; Response an id like1)<br>" +
+                "show first message:   GET    /messages/1<br>" +
+                "show third message:   GET    /messages/3<br>" +
+                "update first message: PUT    /messages/1   (Payload: the message)<br>" +
+                "remove first message: DELETE /messages/1<br>", "200");
+    }
+
+    private void listAllMsg() {
+        sendResponse(msgHandler.getAllMsg(), "200");
+        //sendResponse("Test");
+    }
+
+    /**
+     * Sendet eine Response
+     * @param responseText Text der zu senden ist
+     * @param code Http code
+     */
+    private void sendResponse(String responseText, String code){
+        out.print("HTTP/1.0 "+code+"\r\n");
+        out.print("Server: Apache/0.8.4\r\n");
+        out.print("Content-Type: text/plain\r\n");
+        out.print("Content-Length: "+responseText.length()+"\r\n");
+        out.print("\r\n");
+        out.print(responseText);
+    }
+
+    /**
+     * Get Msg Handler
+     *
+     * @return msgHandler Handler der Nachrichten
+     */
+    public MsgHandler getMsghandler() {
+        return this.msgHandler;
+    }
+
+}

src/test/java/CardTest.java

@@ -1,3 +1,7 @@
+import at.reisinger.Card;
+import at.reisinger.CardType;
+import at.reisinger.EffectivnessType;
+import at.reisinger.ElementTyp;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;

src/test/java/CardsTest.java

@@ -1,3 +1,7 @@
+import at.reisinger.Card;
+import at.reisinger.CardType;
+import at.reisinger.Cards;
+import at.reisinger.ElementTyp;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import java.util.ArrayList;
@@ -6,7 +10,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class CardsTest {
-    private Cards  cards, cards2, cards3;
+    private Cards cards, cards2, cards3;
     private Card newCard, card, newerCard;
     private ArrayList<Card> cardsArrayList, cardsArrayList2, cardsArrayList3;
 

src/test/java/CoinsTest.java

@@ -1,3 +1,5 @@
+import at.reisinger.Coins;
+import at.reisinger.NegativAmountException;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -17,9 +19,9 @@ public class CoinsTest {
         try {
             Coins coin = new Coins(10);
             coin.addCoin(-10);
-            fail("Erwartet NegativAmountException - addCoin");
+            fail("Erwartet at.reisinger.NegativAmountException - addCoin");
         }catch (NegativAmountException negativAmountException) {
-            assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an Coins hinzugefügt werden"));
+            assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"));
         }
     }
 
@@ -28,9 +30,9 @@ public class CoinsTest {
         try {
             Coins coin = new Coins(10);
             coin.removeCoin(-10);
-            fail("Erwartet NegativAmountException - removeCoin");
+            fail("Erwartet at.reisinger.NegativAmountException - removeCoin");
         }catch (NegativAmountException negativAmountException) {
-            assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an Coins hinzugefügt werden"));
+            assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"));
         }
     }
 

src/test/java/PackageTest.java

@@ -1,3 +1,5 @@
+import at.reisinger.*;
+import at.reisinger.Package;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 

src/test/java/StackTest.java

@@ -1,3 +1,4 @@
+import at.reisinger.*;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 

src/test/java/StoreTest.java

@@ -1,3 +1,5 @@
+import at.reisinger.*;
+import at.reisinger.Package;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -17,7 +19,7 @@ public class StoreTest {
 
     @BeforeEach
     void setUp() {
-        //Stack
+        //at.reisinger.Stack
         card = new Card("Name", 100, ElementTyp.WATER, CardType.MONSTER);
         newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
         cardsArrayList = new ArrayList<Card>();
@@ -30,9 +32,9 @@ public class StoreTest {
         nochNewCards = new Cards(cardsArrayList3);
         stack = new Stack(cards, nochNewCards);
 
-        //Coins
+        //at.reisinger.Coins
         Coins coins = new Coins(10);
-        //User
+        //at.reisinger.User
         Credentials credentials = new Credentials("username", "passwort");
         user = new User(credentials, "name", "nachname", "email", stack, coins);
         userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", stack, coins);
@@ -66,9 +68,9 @@ public class StoreTest {
         Cards stack = new Cards(stackArrList);
         User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000));
         ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
-        ArrayList<Package> packages = new ArrayList<Package>();
+        ArrayList<Package> packages = new ArrayList<at.reisinger.Package>();
         tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
-        packages.add(new Package(stack, "Test Package", 100));
+        packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100));
 
 
         System.out.println(user.getTradingDeals().toString());
@@ -108,9 +110,9 @@ public class StoreTest {
         Cards stack = new Cards(stackArrList);
         User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000));
         ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
-        ArrayList<Package> packages = new ArrayList<Package>();
+        ArrayList<at.reisinger.Package> packages = new ArrayList<at.reisinger.Package>();
         tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
-        packages.add(new Package(stack, "Test Package", 100));
+        packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100));
 
         assertTrue(result.get(0).dealOk(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)));
     }

src/test/java/TradingDealTest.java

@@ -1,3 +1,4 @@
+import at.reisinger.*;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -17,7 +18,7 @@ public class TradingDealTest {
 
     @BeforeEach
     void setUp() {
-        //Stack
+        //at.reisinger.Stack
         card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
         newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
         cardsArrayList = new ArrayList<Card>();
@@ -30,9 +31,9 @@ public class TradingDealTest {
         nochNewCards = new Cards(cardsArrayList3);
         stack = new Stack(cards, nochNewCards);
 
-        //Coins
+        //at.reisinger.Coins
         Coins coins = new Coins(10);
-        //User
+        //at.reisinger.User
         Credentials credentials = new Credentials("username", "passwort");
         Credentials newCredentials = new Credentials("usernamenew", "passwortnew");
         user = new User(credentials, "name", "nachname", "email", stack, coins);
@@ -46,11 +47,14 @@ public class TradingDealTest {
         tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType);
     }
 
+    /*
     @Test
     void test_getTradingUser() {
         User result = tradingDeal.getTradingUser();
         assertTrue(result.equals(user));
     }
+    */
+
     @Test
     void test_getCardToTrade() {
         Card result = tradingDeal.getCardToTrade();
@@ -72,12 +76,15 @@ public class TradingDealTest {
         assertTrue(result==CardType.MONSTER);
     }
 
+    /*
     @Test
     void test_setTradingUser() {
         tradingDeal.setTradingUser(userNew);
         User result = tradingDeal.getTradingUser();
         assertTrue(result.equals(userNew));
     }
+    */
+
     @Test
     void test_setCardToTrade() {
         tradingDeal.setCardToTrade(newCard);

src/test/java/UserTest.java

@@ -1,3 +1,5 @@
+import at.reisinger.*;
+import at.reisinger.Package;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -13,11 +15,11 @@ public class UserTest {
     private ArrayList<Card> cardsArrayList, cardsArrayList2, cardsArrayList3;
     private Stack stack;
     private User user;
-    private Package myPackage;
+    private at.reisinger.Package myPackage;
 
     @BeforeEach
     void setUp() {
-        //Stack
+        //at.reisinger.Stack
         card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
         newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
         cardsArrayList = new ArrayList<Card>();
@@ -29,12 +31,12 @@ public class UserTest {
         newCards = new Cards(cardsArrayList2);
         nochNewCards = new Cards(cardsArrayList3);
         stack = new Stack(cards, nochNewCards);
-        //Package
+        //at.reisinger.Package
         myPackage = new Package(cards, "Name", 100);
 
-        //Coins
+        //at.reisinger.Coins
         Coins coins = new Coins(10);
-        //User
+        //at.reisinger.User
         Credentials credentials = new Credentials("username", "pw");
         user = new User(credentials, "name", "nachname", "email", stack, coins);
     }