Create Package (/packages)

.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/Card.java

@@ -1,118 +0,0 @@
-/**
- * Object einer Card
- */
-public class Card {
-    private String name;
-    private double damage;
-    private ElementTyp elementTyp;
-    private CardType cardType;
-
-    /**
-     * Erstellt eine neue Card mit gegebenen Eigenschaften
-     * @param name Name der Card
-     * @param damage Damage den die Card macht
-     * @param elementTyp ElementType der Card
-     * @param cardType CardType der Card
-     */
-    public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) {
-        this.name = name;
-        this.damage = damage;
-        this.elementTyp = elementTyp;
-        this.cardType = cardType;
-    }
-
-    /**
-     * Holt den Namen der Card
-     * @return Name der Card
-     */
-    public String getName() {
-        return this.name;
-    }
-
-    /**
-     * Holt den Damage der Card
-     * @return Damage der Card
-     */
-    public double getDamage() {
-        return this.damage;
-    }
-
-    /**
-     * Holt den ElementType der Card
-     * @return ElementType der Card
-     */
-    public ElementTyp getElementTyp() {
-        return this.elementTyp;
-    }
-
-    /**
-     * Holt den CardType der Card
-     * @return CardType der Card
-     */
-    public CardType getCardType() {
-        return this.cardType;
-    }
-
-    /**
-     * Berechnet die Wirksamkeit gegen eine Andere card. Die Card im Parameter wird angegriffen
-     * @param toCeck 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
-     */
-    public EffectivnessType getEffectivenessAgainst(Card toCeck) {
-        if(toCeck.getCardType() == CardType.MONSTER){
-            if(this.cardType == CardType.MONSTER){
-                return EffectivnessType.NOEFFECT;
-            }else if (this.cardType == CardType.SPELL){
-
-            }
-        }else if (toCeck.getCardType() == CardType.SPELL){
-            if ((toCeck.getElementTyp() == ElementTyp.FIRE && this.elementTyp == ElementTyp.WATER) || (toCeck.getElementTyp() == ElementTyp.NORMAL && this.elementTyp == ElementTyp.FIRE) || (toCeck.getElementTyp() == ElementTyp.WATER && this.elementTyp == ElementTyp.NORMAL)){
-                return EffectivnessType.EFFECTIVE;
-            }else if (this.elementTyp == ElementTyp.FIRE && toCeck.getElementTyp() == ElementTyp.WATER){
-                return EffectivnessType.NOTEFFECTIVE;
-            }else if ((toCeck.getElementTyp() == ElementTyp.NORMAL && this.cardType == CardType.MONSTER && this.elementTyp == ElementTyp.NORMAL)){
-                return EffectivnessType.NOEFFECT;
-            }
-        }
-        throw new InternalError("Konnte die Effectiveness von den Cards nicht berechnen");
-    }
-
-    /**
-     * Setztden namen der Card
-     * @param neuerName Name der Card
-     */
-    public void setName(String neuerName) {
-        this.name = name;
-    }
-
-    /**
-     * Setzt den Damage der Card
-     * @param damage Der Damage
-     */
-    public void setDamage(int damage) {
-        this.damage = damage;
-    }
-
-    /**
-     * Setzt den ElementType der Card
-     * @param elementTyp Der ElementType
-     */
-    public void setElementType(ElementTyp elementTyp) {
-        this.elementTyp = elementTyp;
-    }
-
-    /**
-     * Testet ob die beiden Karten gleich sind
-     * @param card Card die geprüft werden soll
-     * @return True wenn die Karten übereinstimmen
-     */
-    public boolean equals(Card card){
-        if(card == null) return false;
-        if(this.name == card.getName() && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage()){
-            return true;
-        }else {
-            return false;
-        }
-    }
-}

src/main/java/CardType.java

@@ -1,3 +0,0 @@
-public enum CardType {
-    MONSTER, SPELL
-}

src/main/java/Cards.java

@@ -1,78 +0,0 @@
-import java.util.ArrayList;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * Verwaltet eine Liste vo Cards
- */
-public class Cards {
-    private ArrayList<Card> cards;
-
-    /**
-     * Erstellt ein nues obj mit gegebenen Karten
-     * @param cardsArrayList Die Cards zum erstellen des Obj
-     */
-    public Cards(ArrayList<Card> cardsArrayList) {
-        this.cards = cardsArrayList;
-    }
-
-    /**
-     * Erstellt ein neues Obj ohne Cards
-     */
-    public Cards() {
-
-    }
-
-    /**
-     * Fügt eine neue Card hinzu
-     * @param newCard neue Card
-     */
-    public void addCard(Card newCard) {
-        this.cards.add(newCard);
-    }
-
-    /**
-     * Holt alle Cards
-     * @return Alle Cards
-     */
-    public ArrayList<Card> getCards() {
-        return this.cards;
-    }
-
-    /**
-     * Löscht die gegebene Card
-     * @param delCard 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
-     * @param toCeck Card nach der in den Cards gesucht werden soll
-     * @return True wenn die Card in den Cards ist
-     */
-    public boolean containsCard(Card toCeck){
-        AtomicBoolean returnval = new AtomicBoolean(false);
-        this.cards.forEach(item -> {
-            if(item.getElementTyp().equals(toCeck.getElementTyp()) && item.getCardType().equals(toCeck.getCardType()) && item.getName().equals(toCeck.getName()) && item.getDamage() == toCeck.getDamage()){
-                returnval.set(true);
-            }
-        });
-        return returnval.get();
-    }
-
-    /**
-     * Vergleicht 2 Cards Obj miteinander
-     * @param toCompare Cards zum vergleichen
-     * @return True wenn es aus den selben Cards besteht
-     */
-    public boolean equals(Cards toCompare){
-        AtomicBoolean returnval = new AtomicBoolean(false);
-        this.cards.forEach(item -> {
-            if(toCompare.containsCard(item)){
-                returnval.set(true);
-            }
-        });
-        return returnval.get();
-    }
-}

src/main/java/DBConnection.java

@@ -1,64 +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);
-        Cards deck = new Cards();
-        Cards stack = new Cards();
-        deck.addCard(c1);
-        deck.addCard(c2);
-        stack.addCard(c3);
-        stack.addCard(c4);
-        stack.addCard(c5);
-        User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000));
-        this.tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.SPELL));
-        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/ElementTyp.java

@@ -1,3 +0,0 @@
-public enum ElementTyp {
-    WATER, FIRE, NORMAL
-}

src/main/java/Stack.java

@@ -1,48 +0,0 @@
-/**
- * Erweitert Cards insofern, dass es im Stack auch ein Deck gibt
- */
-public class Stack extends Cards{
-    private Cards deck;
-
-    /**
-     * Erstellt einen neuen Stack aus den User Cards und seinem Deck
-     * @param cards Alle Cards des Users
-     * @param deck Sein Deck
-     */
-    public Stack(Cards cards, Cards deck) {
-        super(cards.getCards());
-        this.deck = deck;
-    }
-
-    /**
-     * Fügt ein neues Deck in den Stack ein
-     * @param newCards Gesamtes Deck
-     */
-    public void addDeck(Cards newCards) {
-        this.deck = newCards;
-    }
-
-    /**
-     * Holt das gesamte Deck
-     * @return Gesamtes Deck
-     */
-    public Cards getDeck() {
-        return this.deck;
-    }
-
-    /**
-     * Löscht eine Card aus dem Deck
-     * @param toDel Card zum löschen
-     */
-    public void delDeck(Card toDel) {
-        this.deck.delCard(toDel);
-    }
-
-    /**
-     * Fügt dem deck eine neue Card ein
-     * @param toAdd Neue Card
-     */
-    public void addDeckCard(Card toAdd){
-        this.deck.addCard(toAdd);
-    }
-}

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

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

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

@@ -0,0 +1,206 @@
+package at.reisinger;
+
+import com.fasterxml.jackson.annotation.*;
+
+/**
+ * Object einer at.reisinger.Card
+ */
+@JsonAutoDetect
+public class Card {
+    @JsonProperty
+    private String name;
+    @JsonProperty
+    private double damage;
+    @JsonProperty
+    private ElementTyp elementTyp;
+    @JsonProperty
+    private CardType cardType;
+
+    /**
+     * Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften
+     * @param name Name der at.reisinger.Card
+     * @param damage Damage den die at.reisinger.Card macht
+     * @param elementTyp ElementType der at.reisinger.Card
+     * @param cardType at.reisinger.CardType der at.reisinger.Card
+     */
+    public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) {
+        this.name = name;
+        this.damage = damage;
+        this.elementTyp = elementTyp;
+        this.cardType = cardType;
+    }
+
+    /**
+     * Erstellt eine neue Card mit, anhand des cardNamen werden der ElementType und der CardType automatisch bestimmt
+     * @param name Name der Card (ID)
+     * @param elementCardTyp ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
+     *                       Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
+     * @param damage Damage der Card
+     */
+    @JsonCreator
+    public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){
+        ElementTyp tmpElement = stringToElementType(elementCardTyp);
+        if(tmpElement == null){
+            tmpElement = ElementTyp.UNDEF;
+        }
+        CardType tmpCard = stringToCardType(elementCardTyp);
+        if(tmpCard == null){
+            tmpCard = CardType.UNDEF;
+        }
+        this.name = name;
+        this.damage = damage;
+        this.elementTyp = tmpElement;
+        this.cardType = tmpCard;
+    }
+
+    /**
+     * Wenn ein String als ElementType vorhanden ist, dann gibt er den passenden ElementType zurück
+     * @param elementTypeString elementType als String
+     * @return Passender Element Type oder null falls nicht gefunden
+     */
+    private ElementTyp stringToElementType(String elementTypeString){
+        for (ElementTyp e : ElementTyp.values()) {
+            System.out.println(e.toString().toLowerCase());
+            System.out.println(elementTypeString.toLowerCase().contains(e.name().toLowerCase()));
+            if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) {
+                System.out.println("\n\n\n");
+                System.out.println("####Element####, me.name() : elementTypeString");
+                System.out.println(e.name().toLowerCase());
+                System.out.print(" : ");
+                System.out.println(elementTypeString.toLowerCase());
+                System.out.println("\n\n\n");
+                return e;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Wenn ein String als cardType vorhanden ist, dann gibt er den passenden cardType zurück
+     * @param cardTypeString cardType als String
+     * @return Passender Card Type oder null falls nicht gefunden
+     */
+    private CardType stringToCardType(String cardTypeString){
+        System.out.println("\n\n\n");
+        System.out.println("###CARD###, me.name() : cardTypeString\n");
+        for (CardType me : CardType.values()) {
+            System.out.println("\n\n\n");
+            System.out.print(me.name().toLowerCase());
+            System.out.print(" : ");
+            System.out.println(cardTypeString.toLowerCase());
+            System.out.println("\n\n\n");
+            if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
+                System.out.println("\n\n\n");
+                System.out.print(me.name().toLowerCase());
+                System.out.print(" : ");
+                System.out.println(cardTypeString.toLowerCase());
+                System.out.println("\n\n\n");
+                return me;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Holt den Namen der at.reisinger.Card
+     * @return Name der at.reisinger.Card
+     */
+    @JsonGetter
+    public String getName() {
+        return this.name;
+    }
+
+    /**
+     * Holt den Damage der at.reisinger.Card
+     * @return Damage der at.reisinger.Card
+     */
+    @JsonGetter
+    public double getDamage() {
+        return this.damage;
+    }
+
+    /**
+     * Holt den ElementType der at.reisinger.Card
+     * @return ElementType der at.reisinger.Card
+     */
+    @JsonGetter
+    public ElementTyp getElementTyp() {
+        return this.elementTyp;
+    }
+
+    /**
+     * Holt den at.reisinger.CardType der at.reisinger.Card
+     * @return at.reisinger.CardType der at.reisinger.Card
+     */
+    @JsonGetter
+    public CardType getCardType() {
+        return this.cardType;
+    }
+
+    /**
+     * Berechnet die Wirksamkeit gegen eine Andere card. Die at.reisinger.Card im Parameter wird angegriffen
+     * @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 at.reisinger.Cards nicht berechnet werden kann
+     */
+    @JsonGetter
+    public EffectivnessType getEffectivenessAgainst(Card toCeck) {
+        if(toCeck.getCardType() == CardType.MONSTER){
+            if(this.cardType == CardType.MONSTER){
+                return EffectivnessType.NOEFFECT;
+            }else if (this.cardType == CardType.SPELL){
+
+            }
+        }else if (toCeck.getCardType() == CardType.SPELL){
+            if ((toCeck.getElementTyp() == ElementTyp.FIRE && this.elementTyp == ElementTyp.WATER) || (toCeck.getElementTyp() == ElementTyp.NORMAL && this.elementTyp == ElementTyp.FIRE) || (toCeck.getElementTyp() == ElementTyp.WATER && this.elementTyp == ElementTyp.NORMAL)){
+                return EffectivnessType.EFFECTIVE;
+            }else if (this.elementTyp == ElementTyp.FIRE && toCeck.getElementTyp() == ElementTyp.WATER){
+                return EffectivnessType.NOTEFFECTIVE;
+            }else if ((toCeck.getElementTyp() == ElementTyp.NORMAL && this.cardType == CardType.MONSTER && this.elementTyp == ElementTyp.NORMAL)){
+                return EffectivnessType.NOEFFECT;
+            }
+        }
+        throw new InternalError("Konnte die Effectiveness von den at.reisinger.Cards nicht berechnen");
+    }
+
+    /**
+     * Setztden namen der at.reisinger.Card
+     * @param neuerName Name der at.reisinger.Card
+     */
+    @JsonSetter
+    public void setName(String neuerName) {
+        this.name = neuerName;
+    }
+
+    /**
+     * Setzt den Damage der at.reisinger.Card
+     * @param damage Der Damage
+     */
+    @JsonSetter
+    public void setDamage(int damage) {
+        this.damage = damage;
+    }
+
+    /**
+     * Setzt den ElementType der at.reisinger.Card
+     * @param elementTyp Der ElementType
+     */
+    @JsonSetter
+    public void setElementType(ElementTyp elementTyp) {
+        this.elementTyp = elementTyp;
+    }
+
+    /**
+     * Testet ob die beiden Karten gleich sind
+     * @param card at.reisinger.Card die geprüft werden soll
+     * @return True wenn die Karten übereinstimmen
+     */
+    public boolean equals(Card card){
+        if(card == null) return false;
+        if(this.name == card.getName() && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage()){
+            return true;
+        }else {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+package at.reisinger;
+
+public enum CardType {
+    MONSTER, SPELL, UNDEF, GOBLIN, TROLL, ELF, KNIGHT
+}

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

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

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
      */
@@ -22,13 +24,13 @@ public class Credentials {
         return passwort;
     }
 
-    /**
-     * Setzt das User Passwort
-     * @param passwort Neues Passwort
-     */
-    public void setPasswort(String passwort) {
-        this.passwort = passwort;
-    }
+//    /**
+//     * Setzt das at.reisinger.User Passwort
+//     * @param passwort Neues Passwort
+//     */
+//    public void setPasswort(String passwort) {
+//        this.passwort = passwort;
+//    }
 
     /**
      * Holt den Usernamen des Users
@@ -38,11 +40,11 @@ public class Credentials {
         return username;
     }
 
-    /**
-     * Setzt einen neuen Usernamen
-     * @param username Neuer Username
-     */
-    public void setUsername(String username) {
-        this.username = username;
-    }
+//    /**
+//     * Setzt einen neuen Usernamen
+//     * @param username Neuer Username
+//     */
+//    public void setUsername(String username) {
+//        this.username = username;
+//    }
 }

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

@@ -0,0 +1,311 @@
+package at.reisinger;
+
+import java.sql.*;
+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);
+        }
+        return c;
+    }
+
+    /**
+     * Erstellt alle Beispieldaten und simuliert somit den
+     * Verbindungsaufbau zu einer DB
+     */
+    public DBConnection() {
+        this.c = con();
+    }
+
+    /**
+     * Erstellt alle Tabellen die für den Betrieb der Software bennötigt werden
+     *
+     * @throws SQLException
+     */
+    public void init() {
+        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");
+
+        this.c = con();
+        try {
+            stmt = this.c.createStatement();
+            String sql = "CREATE TABLE IF NOT EXISTS CARD(NAME TEXT not null,DAMAGE FLOAT not null,ELEMENTTYP TEXT not null,CARDTYPE TEXT not null, PRIMARY KEY (\"name\"));";
+            stmt.executeUpdate(sql);
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            System.exit(0);
+        }
+        this.c = con();
+        try {
+            stmt = this.c.createStatement();
+            String sql = "create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);";
+            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("Card Table created");
+
+        this.c = con();
+        try {
+            stmt = this.c.createStatement();
+            String sql = "create table IF NOT EXISTS package" +
+                    "(" +
+                    "    \"ID\" varchar(255) not null," +
+                    "    name varchar(255) not null" +
+                    "        constraint name" +
+                    "            references card," +
+                    "    i    serial       not null" +
+                    "        constraint package_i" +
+                    "            primary key" +
+                    ");";
+            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("Package Table created");
+    }
+
+    /**
+     * Überprüft anhand des Namen der Karte, ob es schon eine solche Karte gibt
+     *
+     * @param name Name der zu prüfen ist
+     * @return True falls die Karte bereits existiert
+     */
+    public boolean cardExists(String name) {
+        this.c = con();
+        int count = 0;
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select count(*) from card where name = \'" + name + "\';");
+            while (rs.next()) {
+                count = rs.getInt("count");
+                System.out.println("Count: ");
+                System.out.print(count);
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            System.exit(0);
+        }
+        if (count == 1) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Fügt eine Karte der DB hinzu
+     * @param card Card die hinzugefügt werden soll
+     * @return true bei erfolg, false bei error
+     */
+    public boolean addCard(Card card) {
+        this.c = con();
+        try{
+            stmt = this.c.createStatement();
+            String sql = "insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values (\'" + card.getName() +"\',\'" + card.getDamage() + "\',\'" + card.getElementTyp().name() + "\',\'" + card.getCardType().name() + "\')";
+            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("Card added");
+        return true;
+    }
+
+    /**
+     * Ermittelt die nächste Package ID
+     * @return Die Nächste Package id, wenn 0, dann ist ein error
+     */
+    public int nextPackageId(){
+        this.c = con();
+        String id = "";
+        try{
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery( "select max(\"ID\") from package;");
+            while ( rs.next() ) {
+                id = rs.getString("max");
+            }
+            if (id == null){
+                id = "0";
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch ( Exception e ) {
+            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
+            return 0;
+        }
+        System.out.println("Package Next id is: ");
+        System.out.print(id);
+        return Integer.parseInt(id) + 1;
+    }
+
+    /**
+     * Fügt eine Package der DB hinzu,
+     * wenn eine Karte aus dem Package noch nicht in der Db ist,
+     * dann wird es automatisch hinzugefuegt
+     * @param pack Pack welches hinzugefügt werden soll
+     * @return True bei erfolg, false bei fehler
+     */
+    public boolean addPackage(Package pack) {
+        for (Card ca : pack.getCards()) {
+            if (!cardExists(ca.getName())) {
+                if(!addCard(ca)){
+                    return false;
+                }
+            }
+            this.c = con();
+            try {
+                stmt = this.c.createStatement();
+                String sql = "INSERT INTO package (\"ID\", \"name\") values (\'" + pack.getName() + "\',\'" + ca.getName() + "\');";
+                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("Card zu Package hinzugefügt");
+        }
+        return true;
+    }
+
+    /**
+     * Fügt einen User der DB hinzu
+     * @param username Username des Users
+     * @param password Passwort des Users
+     * @param nachname nachname des Users
+     * @param email Email des Users
+     * @return True wenn alles erfolgreich war, false wenn es nicht erfolgreich war
+     */
+    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;
+    }
+
+    /**
+     * Sucht einen User anhand des Usernamens.
+     * Gibt ein User Objekt zurück
+     * @param uname Username der zu suchen ist
+     * @return User als User Objekt
+     * @throws SQLException Fehler bei der Suche in der DB
+     */
+    public User getUser(String uname) throws SQLException {
+        this.c = con();
+        String username="", password="", email ="", nachname = "";
+        try{
+        stmt = this.c.createStatement();
+        ResultSet rs = stmt.executeQuery( "SELECT * FROM users where username = \'" + uname + "\';" );
+        while ( rs.next() ) {
+            username = rs.getString("username");
+            nachname = rs.getString("nachname");
+            email = rs.getString("email");
+            password = rs.getString("password");
+            System.out.println( "username = " + username );
+            System.out.println( "nachname = " + nachname );
+            System.out.println( "email = " + email );
+            System.out.println( "password = " + password );
+            System.out.println();
+        }
+        rs.close();
+        stmt.close();
+        this.c.close();
+        } catch ( Exception e ) {
+            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
+            System.exit(0);
+        }
+          System.out.println("Operation done successfully");
+        return new User(new Credentials(username, password), username, username, email, new Coins(20));
+    }
+    /**
+     * 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

@@ -0,0 +1,5 @@
+package at.reisinger;
+
+public enum ElementTyp {
+    WATER, FIRE, NORMAL, UNDEF, REGULAR, GOBLIN, KNIGHT
+}

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,17 +1,25 @@
+package at.reisinger;
+
+import com.fasterxml.jackson.annotation.*;
+
 /**
- * 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
  */
+@JsonAutoDetect
 public class Package extends Cards{
+    @JsonProperty
     private String name;
+    @JsonProperty
     private int price;
 
     /**
-     * Erstellt ein neues Package mit den gegebenen Stats
-     * @param stack Cards des Packages
+     * Erstellt ein neues at.reisinger.Package mit den gegebenen Stats
+     * @param stack at.reisinger.Cards des Packages
      * @param name Name des Packages
      * @param price Price des Packages
      */
-    public Package(Cards stack, String name, int price) {
+    @JsonCreator
+    public Package(@JsonProperty Cards stack,@JsonProperty String name,@JsonProperty int price) {
         super(stack.getCards());
         this.name = name;
         this.price = price;
@@ -21,6 +29,7 @@ public class Package extends Cards{
      * Holt den namen des Packages
      * @return Name des Packages
      */
+    @JsonGetter
     public String getName() {
         return this.name;
     }
@@ -29,6 +38,7 @@ public class Package extends Cards{
      * Holt den Preis des Packages
      * @return Preis des Packages
      */
+    @JsonGetter
     public int getPrice() {
         return this.price;
     }
@@ -37,6 +47,7 @@ public class Package extends Cards{
      * Setzt den Namen des Packages
      * @param neuName Neuer name des Packages
      */
+    @JsonSetter
     public void setName(String neuName) {
         this.name = neuName;
     }

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

@@ -0,0 +1,50 @@
+package at.reisinger;
+
+/**
+ * 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 at.reisinger.Stack aus den at.reisinger.User at.reisinger.Cards und seinem Deck
+     * @param cards Alle at.reisinger.Cards des Users
+     * @param deck Sein Deck
+     */
+    public Stack(Cards cards, Cards deck) {
+        super(cards.getCards());
+        this.deck = deck;
+    }
+
+    /**
+     * Fügt ein neues Deck in den at.reisinger.Stack ein
+     * @param newCards Gesamtes Deck
+     */
+    public void addDeck(Cards newCards) {
+        this.deck = newCards;
+    }
+
+    /**
+     * Holt das gesamte Deck
+     * @return Gesamtes Deck
+     */
+    public Cards getDeck() {
+        return this.deck;
+    }
+
+    /**
+     * Löscht eine at.reisinger.Card aus dem Deck
+     * @param toDel at.reisinger.Card zum löschen
+     */
+    public void delDeck(Card toDel) {
+        this.deck.delCard(toDel);
+    }
+
+//    /**
+//     * Fügt dem deck eine neue at.reisinger.Card ein
+//     * @param toAdd Neue at.reisinger.Card
+//     */
+//    public void addDeckCard(at.reisinger.Card toAdd){
+//        this.deck.addCard(toAdd);
+//    }
+}

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

@@ -1,7 +1,9 @@
+package at.reisinger;
+
 import java.util.ArrayList;
 
 public interface Store {
-    DBConnection db = new DBConnection();
+    //DBConnection db = new DBConnection();
 
     void addTradingDeal(TradingDeal tradingDeal);
 

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
-     * @param user User des Deals
-     * @param cardToTrade Card die getauscht werden soll
+     * Ein at.reisinger.TradingDeal wird  erstellt
+     * @param user at.reisinger.User des Deals
+     * @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
-     * @return User der den Trade erstellt hat
-     */
+     * Holt den Trading at.reisinger.User
+     * @return at.reisinger.User der den Trade erstellt hat
+
     public User getTradingUser() {
         return this.tradingUser;
     }
-
+*/
     /**
-     * Card die getraded werden soll
-     * @return Card die getradet werden soll
+     * at.reisinger.Card die getraded 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
-     * @param tradingUser User der Traded
-     */
+     * Setzt den at.reisinger.User des Trades
+     * @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,14 +116,27 @@ public class TradingDeal {
     }
 
     /**
-     * Von der Card im Parameter wird die Card mit den Requirements von THIS verglichen
-     * @param checkCard Card die mit dem Deal verglichen wird
+     * Von der at.reisinger.Card im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen
+     * @param checkCard at.reisinger.Card die mit dem Deal verglichen wird
      * @return True wenn der Deal passt
      */
     public boolean cardOk(Card checkCard){
+        System.out.println(checkCard.getCardType().equals(this.requiredCardType));
+        System.out.println(checkCard.getCardType().toString());
+        System.out.println(this.requiredCardType.toString());
+        System.out.println(" ");
+        System.out.println(checkCard.getElementTyp().equals(this.requiredElementType));
+        System.out.println(checkCard.getElementTyp().toString());
+        System.out.println(this.requiredElementType);
+        System.out.println(" ");
+        System.out.println(checkCard.getDamage() >= this.requiredMinDamage);
+        System.out.println(checkCard.getDamage());
+        System.out.println(this.requiredMinDamage);
         if(checkCard.getCardType().equals(this.requiredCardType) && checkCard.getElementTyp().equals(this.requiredElementType) && checkCard.getDamage() >= this.requiredMinDamage){
+            System.out.println("Da simma true");
             return true;
         }else {
+            System.out.println("da simma false");
             return false;
         }
     }

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

@@ -1,46 +1,71 @@
+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
      * @param email Email des Users
      * @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
-     * @return Stack des Users
-     */
+     * Holt den at.reisinger.Stack des Users
+     * @return at.reisinger.Stack des Users
+
+    @JsonGetter
     public Stack getStack() {
         return stack;
     }
 
     /**
-     * Setzt den Stack eines Users
-     * @param stack Der neue Stack des Users
-     */
+     * Setzt den at.reisinger.Stack eines Users
+     * @param stack Der neue at.reisinger.Stack des Users
+
+    @JsonSetter
     public void setStack(Stack stack) {
         this.stack = stack;
     }
@@ -48,71 +73,83 @@ public class User implements Store{
     /**
      * Holt das DB Obj
      * @return Das DB Obj
-     */
+
+    @JsonGetter
     public DBConnection getDb() {
-        return db;
+        return new DBConnection();
     }
 
     /**
      * 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
-     * @return Coins des Users
+     * Holt alle at.reisinger.Coins des Users
+     * @return at.reisinger.Coins des Users
      */
+    @JsonGetter
     public Coins getCoins() {
         return coins;
     }
 
     /**
-     * Setzt alle Coins des Users
-     * @param coins Neue Coins des Users
+     * Setzt alle at.reisinger.Coins des Users
+     * @param coins Neue at.reisinger.Coins des Users
      */
+    @JsonSetter
     public void setCoins(Coins coins) {
         this.coins = coins;
     }
 
     /**
-     * Get Name of User
-     * @return Name of User
+     * Get Name of at.reisinger.User
+     * @return Name of at.reisinger.User
      */
+    @JsonGetter
     public String getName() {
         return this.name;
     }
 
     /**
-     * Get Nachname of User
-     * @return Nachname of User
+     * Get Nachname of at.reisinger.User
+     * @return Nachname of at.reisinger.User
      */
+    @JsonGetter
     public String getNachname() {
         return this.nachname;
     }
 
     /**
-     * Email of User
-     * @return Email of User
+     * Email of at.reisinger.User
+     * @return Email of at.reisinger.User
      */
+    @JsonGetter
     public String getEmail() {
         return this.email;
     }
@@ -121,6 +158,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 +167,7 @@ public class User implements Store{
      * Setzt den Nachnamen
      * @param nachname Neuer Nachname
      */
+    @JsonSetter
     public void setNachname(String nachname) {
         this.nachname = nachname;
     }
@@ -137,31 +176,32 @@ 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
-     * @param mypackage Package welches gekauft werden soll
-     * @return Alle Karten des neuen Package
-     * @throws NegativAmountException Wenn ein negativer Preis im Package gesetzt wird.
+     * Kauft ein at.reisinger.Package
+     * @param mypackage at.reisinger.Package welches gekauft werden soll
+     * @return Alle Karten des neuen at.reisinger.Package
+     * @throws NegativAmountException Wenn ein negativer Preis im at.reisinger.Package gesetzt wird.
      */
     public ArrayList<Card> buyPackage(Package mypackage) throws NegativAmountException {
-        ArrayList<Package> availablePackages = db.getAllPackages();
-        availablePackages.removeIf(obj -> obj.equals(mypackage));
+        //ArrayList<Package> availablePackages = new DBConnection().getAllPackages();
+        //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) {
-        db.addTradingDeal(tradingDeal);
+        new DBConnection().addTradingDeal(tradingDeal);
     }
 
     /**
@@ -169,22 +209,29 @@ public class User implements Store{
      * @return Alle verfügbaren Deals
      */
     public ArrayList<TradingDeal> getTradingDeals() {
-        return db.getAllTradingDeals();
+        return new DBConnection().getAllTradingDeals();
+    }
+
+    @Override
+    public boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2) {
+        return false;
     }
 
     /**
      * Startet ein Trading zw 2 TradingDeals
-     * @param myTradingDeal Wenn der Deal passt, wird diese Karte aus dem Stack entfernt
-     * @param storeTradingDeal Wenn der Deal passt, wird diese Karte dem Stack hinzugefügt
+     * @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 at.reisinger.Stack hinzugefügt
      * @return True wenn erfolgreich, False wenn die Deals nicht zusammenpassen
-     */
+
     public boolean doTrading(TradingDeal myTradingDeal, TradingDeal storeTradingDeal) {
         if (storeTradingDeal.dealOk(myTradingDeal)){
             stack.delCard(myTradingDeal.getCardToTrade());
             stack.addCard(storeTradingDeal.getCardToTrade());
+            return true;
         }
         return false;
     }
+    */
 
     /**
      * Gibt alle Möglichen Trading Deals zurück
@@ -193,10 +240,11 @@ public class User implements Store{
      */
     @Override
     public ArrayList<TradingDeal> getPossibleTradingDeals(Card toTrade) {
-        ArrayList<TradingDeal> storeList = db.getAllTradingDeals();
+        ArrayList<TradingDeal> storeList = new DBConnection().getAllTradingDeals();
         ArrayList<TradingDeal> possible = new ArrayList<TradingDeal>();
         storeList.forEach(item -> {
             if(item.cardOk(toTrade)){
+                System.out.println("ADDED ein item");
                 possible.add(item);
             }
         });
@@ -204,9 +252,9 @@ public class User implements Store{
     }
 
     /**
-     * Checkt ob es sich um den selben User handelt
-     * @param toCheck Mit diesem User wird verglichen
-     * @return True wenn es der selbe User ist
+     * Checkt ob es sich um den selben at.reisinger.User handelt
+     * @param toCheck Mit diesem at.reisinger.User wird verglichen
+     * @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,69 @@
+package at.reisinger.server;
+
+import at.reisinger.DBConnection;
+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("DB init");
+        new DBConnection().init();
+        System.out.println("\n\nStarte Server auf Port " + port + "\n\n");
+        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(), rq.getAuthString(), 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,124 @@
+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;
+    private String authString;
+
+    /**
+     * 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);
+        }
+
+        int authIndex = headers.toString().indexOf("Authorization");
+        String authString = headers.toString().substring(authIndex + 21);
+        int authIndexEnd = authString.indexOf(',');
+        authString = authString.substring(0, authIndexEnd);
+
+        this.authString = authString;
+
+        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);
+    }
+
+    /**
+     * Auth Header
+     * @return get Auth Header
+     */
+    public String getAuthString() {
+        return authString;
+    }
+
+    /**
+     * 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,289 @@
+package at.reisinger.server.objects;
+
+import at.reisinger.*;
+import at.reisinger.Package;
+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.io.UnsupportedEncodingException;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+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 String authString;
+    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 authString Der MsgHandler
+     * @param payload Payload des Requests
+     */
+    public Response(int id, String url, String cmd, PrintStream out, String authString, String payload){
+        this.id = id;
+        this.authString = authString;
+        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();
+        }
+    }
+
+    /**
+     * Vergleicht das angegebene PW mit dem gespeicherten PW, True wenn richtig
+     * @param username User aus DB
+     * @param password PW zu User aus DB
+     * @param compareTo Base64 String von Basic Auth
+     * @return True if Login is correct, false if incorrect
+     */
+    private boolean basicAuth(String username, String password, String compareTo){
+        String authStringEnc = basicAuthBase64(username, password);
+        if (compareTo.equals(authStringEnc)){
+            return true;
+        }
+        return false;
+    }
+
+    private String basicAuthBase64(String username, String password){
+        String authString = username + ":" + password;
+        //System.out.println("auth string: " + authString);
+        byte[] authEncBytes = Base64.getEncoder().encode(authString.getBytes());
+        String authStringEnc = new String(authEncBytes);
+        //System.out.println("Base64 encoded auth string: " + authStringEnc);
+        return authStringEnc;
+    }
+
+    private String basicAuthGetUsername(String authString) throws UnsupportedEncodingException {
+        String[] values;
+        if (authString != null) {
+            System.out.println("1");
+            byte[] credDecoded = Base64.getDecoder().decode(authString);
+            System.out.println("2");
+            String credentials = new String(credDecoded);
+            System.out.println("credentials:   ");
+            System.out.println(credentials);
+            // credentials = username:password
+            values = credentials.split(":", 2);
+        }else{
+            values = null;
+        }
+        return values[0];
+    }
+
+    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("409");
+            }
+
+            //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, "201");
+            }else{
+                sendError("500");
+            }
+        }else if (this.url.startsWith("/sessions")) {
+            //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 user = null;
+
+            DBConnection con = new DBConnection();
+            try {
+                user = con.getUser(username);
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+            }
+
+            String authString = basicAuthBase64(user.getCredentials().getUsername(), user.getCredentials().getPasswort());
+            if(basicAuth(username, password, authString)){
+                sendResponse(authString, "200");
+            }else{
+                sendError("401");
+            }
+        }else if (this.url.startsWith("/packages")) {
+            if(basicAuth("admin", "admin", this.authString)){
+                System.out.println("1");
+                ObjectMapper objectMapper = new ObjectMapper();
+                System.out.println("2");
+                ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<ArrayList<Card>>(){});
+                System.out.println("List cards");
+                System.out.println(listCards.toString());
+                Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId()+"", 5);
+                System.out.println("3");
+                if(!new DBConnection().addPackage(packageCards)){
+                    sendError("500");
+                }else{
+                    //Package to json
+                    objectMapper = new ObjectMapper();
+                    String packageJson = "";
+                    if(packageCards != null) {
+                        try {
+                            packageJson += objectMapper.writeValueAsString(packageCards);
+                        } catch (JsonProcessingException e) {
+                            packageJson = "Error: JsonProcessingException -> " + e.getMessage();
+                        }
+                        sendResponse(packageJson, "201");
+                    }else{
+                        sendError("500");
+                    }
+                }
+            }else{
+                sendError("401");
+            }
+        }
+    }
+
+    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;
@@ -18,20 +22,20 @@ public class CardTest {
     public void test_getElementType() {
         Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
         ElementTyp elementTyp = card.getElementTyp();
-        assertTrue(elementTyp != ElementTyp.WATER);
+        assertTrue(elementTyp == ElementTyp.WATER);
     }
     @Test
     public void test_getCardType() {
         Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL);
         CardType cardType = card.getCardType();
-        assertTrue(cardType != CardType.SPELL);
+        assertTrue(cardType == CardType.SPELL);
     }
     @Test
     public void test_getEffectivenessAgainst() {
         Card card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
         Card card2 = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
         EffectivnessType effectivnessType = card.getEffectivenessAgainst(card2);
-        assertTrue(effectivnessType != EffectivnessType.NOEFFECT);
+        assertTrue(effectivnessType == EffectivnessType.NOEFFECT);
     }
     @Test
     public void test_setName() {

src/test/java/CardsTest.java

@@ -1,39 +1,71 @@
+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;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class CardsTest {
-    private Cards newCards, cards, nochNewCards;
-    private Card newCard, card;
+    private Cards cards, cards2, cards3;
+    private Card newCard, card, newerCard;
     private ArrayList<Card> cardsArrayList, cardsArrayList2, cardsArrayList3;
-    private Stack stack;
 
     @BeforeEach
     void setUp() {
         card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
         newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL);
+        newerCard = new Card("NameNewerer", 100, ElementTyp.FIRE, CardType.MONSTER);
         cardsArrayList = new ArrayList<Card>();
         cardsArrayList2 = new ArrayList<Card>();
         cardsArrayList3 = new ArrayList<Card>();
         cardsArrayList.add(card);
         cardsArrayList2.add(newCard);
         cardsArrayList2.add(card);
+        cardsArrayList3.add(newerCard);
         cards = new Cards(cardsArrayList);
-        newCards = new Cards(cardsArrayList2);
-        nochNewCards = new Cards(cardsArrayList3);
-        stack = new Stack(cards, nochNewCards);
+        cards2 = new Cards(cardsArrayList2);
+        cards3 = new Cards(cardsArrayList3);
     }
     @Test
     void test_addCard() {
+        System.out.println(cards.getCards().toString());
         cards.addCard(newCard);
-        assertTrue(cards.getCards().equals(cardsArrayList2));
+        System.out.println(cards.getCards().toString());
+        System.out.println(cards2.getCards().toString());
+        assertTrue(cards.equals(cards2));
     }
+
+    @Test
+    void test_addCard2() {
+        cards.addCard(newCard);
+        assertFalse(cards.equals(cards3));
+    }
+
+    @Test
+    void test_equals() {
+        assertFalse(cards.equals(cards2));
+    }
+
+    @Test
+    void test_contains() {
+        assertTrue(cards2.containsCard(card));
+    }
+
+    @Test
+    void test_contains2() {
+        assertFalse(cards.containsCard(newCard));
+    }
+
     @Test
     void test_delCard() {
         cards.addCard(newCard);
+
         cards.delCard(newCard);
+
         assertTrue(cards.getCards().equals(cardsArrayList));
     }
     @Test

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;
 
@@ -42,6 +43,6 @@ public class StackTest {
     @Test
     void test_getDeck() {
         Cards result = stack.getDeck();
-        assertTrue(result.equals(cards));
+        assertTrue(result.equals(nochNewCards));
     }
 }

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,8 +19,8 @@ public class StoreTest {
 
     @BeforeEach
     void setUp() {
-        //Stack
-        card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER);
+        //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>();
         cardsArrayList2 = new ArrayList<Card>();
@@ -30,12 +32,12 @@ 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);
+        user = new User(credentials, "name", "nachname", "email", coins);
+        userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", coins);
 
         //Trading Deal
         Card cardToTrade = card;
@@ -48,28 +50,41 @@ public class StoreTest {
 
     @Test
     void test_addTradingDeal() {
-        user.addTradingDeal(tradingDeal);
-        ArrayList<TradingDeal> expected = new ArrayList<TradingDeal>();
-        expected.add(tradingDeal);
+
+
         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);
-        Cards deck = new Cards();
-        Cards stack = new Cards();
-        deck.addCard(c1);
-        deck.addCard(c2);
-        stack.addCard(c3);
-        stack.addCard(c4);
-        stack.addCard(c5);
-        TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL);
-        expected.add(vonDB);
-        assertTrue(user.getTradingDeals().equals(expected));
+        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 Coins(1000));
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        ArrayList<Package> packages = new ArrayList<at.reisinger.Package>();
+        tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
+        packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100));
+
+
+        System.out.println(user.getTradingDeals().toString());
+
+        user.addTradingDeal(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
+        System.out.println(user.getTradingDeals().toString());
+
+
+        System.out.println(tradingDeals.toString());
+        assertTrue(user.getTradingDeals().get(0).dealOk(tradingDeals.get(0)));
     }
     @Test
     void test_doTrade() {
-        Card cardtest = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
+        Card cardtest = new Card("Name", 100, ElementTyp.FIRE, CardType.MONSTER);
         TradingDeal tradingDealtest = new TradingDeal(user, cardtest, ElementTyp.WATER, 100, CardType.MONSTER);
         boolean result = user.doTrading(tradingDeal, tradingDealtest);
         assertTrue(result);
@@ -78,27 +93,33 @@ public class StoreTest {
     void test_getTradingDeals() {
         ArrayList<TradingDeal> result = user.getTradingDeals();
         ArrayList<TradingDeal> expected = new ArrayList<TradingDeal>();
+
         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);
-        Cards deck = new Cards();
-        Cards stack = new Cards();
-        deck.addCard(c1);
-        deck.addCard(c2);
-        stack.addCard(c3);
-        stack.addCard(c4);
-        stack.addCard(c5);
-        TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL);
-        expected.add(vonDB);
-        expected.add(tradingDeal);
-        assertTrue(result.equals(expected));
+        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 Coins(1000));
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        ArrayList<at.reisinger.Package> packages = new ArrayList<at.reisinger.Package>();
+        tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
+        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)));
     }
 
     @Test
     void test_getPossibleTradingDeals() {
-        Card testCard = new Card("Test", 15, ElementTyp.FIRE, CardType.SPELL);
+        Card testCard = new Card("Test", 10, ElementTyp.FIRE, CardType.MONSTER);
         ArrayList<TradingDeal> result = user.getPossibleTradingDeals(testCard);
         ArrayList<TradingDeal> expected = new ArrayList<TradingDeal>();
         Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
@@ -106,15 +127,19 @@ public class StoreTest {
         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);
-        Cards deck = new Cards();
-        Cards stack = new Cards();
-        deck.addCard(c1);
-        deck.addCard(c2);
-        stack.addCard(c3);
-        stack.addCard(c4);
-        stack.addCard(c5);
-        TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL);
+        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);
+        TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "DerName", "Nachname", "Email", new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL);
         expected.add(vonDB);
-        assertTrue(result.equals(expected));
+        System.out.println(result.get(0).getCardToTrade().getName());
+        System.out.println(expected.get(0).getCardToTrade().getName());
+        assertTrue(result.get(0).getCardToTrade().equals(expected.get(0).getCardToTrade()));
     }
 }

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,13 +31,13 @@ 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);
-        userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", stack, coins);
+        user = new User(credentials, "name", "nachname", "email", coins);
+        userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", coins);
 
         //Trading Deal
         Card cardToTrade = card;
@@ -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,29 +31,29 @@ 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);
+        user = new User(credentials, "name", "nachname", "email", coins);
     }
     @Test
     public void test_getName() {
         String result = user.getName();
-        assertTrue(result != "name");
+        assertTrue(result.equals("name"));
     }
     @Test
     public void test_getNachname() {
         String result = user.getNachname();
-        assertTrue(result != "nachname");
+        assertTrue(result.equals("nachname"));
     }
     @Test
     public void test_getEmail() {
         String result = user.getEmail();
-        assertTrue(result != "email");
+        assertTrue(result.equals("email"));
     }
 
     @Test
@@ -59,21 +61,21 @@ public class UserTest {
         String newstring = "new";
         user.setName(newstring);
         String result = user.getName();
-        assertTrue(result != newstring);
+        assertTrue(result.equals(newstring));
     }
     @Test
     public void test_setNachname() {
         String newstring = "new";
         user.setNachname(newstring);
         String result = user.getNachname();
-        assertTrue(result != newstring);
+        assertTrue(result.equals(newstring));
     }
     @Test
     public void test_setEmail() {
         String newstring = "new";
         user.setEmail(newstring);
         String result = user.getEmail();
-        assertTrue(result != newstring);
+        assertTrue(result.equals(newstring));
     }
     @Test
     public void test_buyPackage(){