Lock Set deck --> if(card.isLocked() == true)

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

@@ -1,128 +0,0 @@
-/**
- * Ein einzelner Trading deal wird hier verwaltet.
- */
-public class TradingDeal {
-    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
-     * @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
-     */
-    public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) {
-        this.tradingUser = user;
-        this.cardToTrade = cardToTrade;
-        this.requiredElementType = requiredElementType;
-        this.requiredMinDamage = requiredMinDamage;
-        this.requiredCardType = requiredCardType;
-    }
-
-    /**
-     * Holt den Trading User
-     * @return User der den Trade erstellt hat
-     */
-    public User getTradingUser() {
-        return this.tradingUser;
-    }
-
-    /**
-     * Card die getraded werden soll
-     * @return Card die getradet werden soll
-     */
-    public Card getCardToTrade() {
-        return this.cardToTrade;
-    }
-
-    /**
-     * Req Element type holen
-     * @return Req Element Type
-     */
-    public ElementTyp getRequiredElementType() {
-        return this.requiredElementType;
-    }
-
-    /**
-     * Req min damage holen
-     * @return Req min damage
-     */
-    public double getRequiredMinDamage() {
-        return this.requiredMinDamage;
-    }
-
-    /**
-     * Hole req cardtype
-     * @return Req CardType
-     */
-    public CardType getRequiredCardType() {
-        return this.requiredCardType;
-    }
-
-    /**
-     * Setzt den User des Trades
-     * @param tradingUser User der Traded
-     */
-    public void setTradingUser(User tradingUser) {
-        this.tradingUser = tradingUser;
-    }
-
-    /**
-     * Setzt die Karte die Getradet werden soll
-     * @param cardToTrade Card zum tauschen
-     */
-    public void setCardToTrade(Card cardToTrade) {
-        this.cardToTrade = cardToTrade;
-    }
-
-    /**
-     * Setzt req elementType
-     * @param requiredElementType Der Req elementType
-     */
-    public void setRequiredElementType(ElementTyp requiredElementType) {
-        this.requiredElementType = requiredElementType;
-    }
-
-    /**
-     * Setzt die req Min damage
-     * @param requiredMinDamage Die req min gamage
-     */
-    public void setRequiredMinDamage(double requiredMinDamage) {
-        this.requiredMinDamage = requiredMinDamage;
-    }
-
-    /**
-     * Setzt req cardType
-     * @param requiredCardType Der Req CardType
-     */
-    public void setRequiredCardType(CardType requiredCardType) {
-        this.requiredCardType = requiredCardType;
-    }
-
-    /**
-     * Vom deal im Parameter wird die Card mit den Requirements von THIS verglichen
-     * @param checkDeal Von diesem Deal wird die CardToTrade geprüft
-     * @return True wenn der Deal passt
-     */
-    public boolean dealOk(TradingDeal checkDeal){
-        return this.cardOk(checkDeal.getCardToTrade());
-    }
-
-    /**
-     * Von der Card im Parameter wird die Card mit den Requirements von THIS verglichen
-     * @param checkCard Card die mit dem Deal verglichen wird
-     * @return True wenn der Deal passt
-     */
-    public boolean cardOk(Card checkCard){
-        if(checkCard.getCardType().equals(this.requiredCardType) && checkCard.getElementTyp().equals(this.requiredElementType) && checkCard.getDamage() >= this.requiredMinDamage){
-            return true;
-        }else {
-            return false;
-        }
-    }
-}

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,177 @@
+package at.reisinger;
+
+import at.reisinger.server.helper.EnumHelper;
+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;
+    @JsonProperty
+    private boolean locked;
+
+    /**
+     * 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 = EnumHelper.stringToElementType(elementCardTyp);
+        if(tmpElement == null){
+            tmpElement = ElementTyp.UNDEF;
+        }
+        CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp);
+        if(tmpCard == null){
+            tmpCard = CardType.UNDEF;
+        }
+        this.name = name;
+        this.damage = damage;
+        this.elementTyp = tmpElement;
+        this.cardType = tmpCard;
+    }
+
+    /**
+     * Prüft ob die Karte gesperrt ist
+     * @return True wenn die Karte gesperrt ist
+     */
+    public boolean isLocked() {
+        return locked;
+    }
+
+    /**
+     * Setzt die sperre der Karte
+     * @param locked True bedeuted gesperrt
+     */
+    public void setLocked(boolean locked) {
+        this.locked = locked;
+    }
+
+    /**
+     * 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, DRAGON, WIZZARD, ORK, KRAKEN, FIREELVES
+}

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

@@ -0,0 +1,87 @@
+package at.reisinger;
+
+import com.fasterxml.jackson.annotation.*;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Verwaltet eine Liste vo at.reisinger.Cards
+ */
+@JsonAutoDetect
+public class Cards {
+    @JsonDeserialize(as = ArrayList.class, contentAs = Card.class)
+    private ArrayList<Card> cards;
+
+    /**
+     * Erstellt ein nues obj mit gegebenen Karten
+     * @param cardsArrayList Die at.reisinger.Cards zum erstellen des Obj
+     */
+    @JsonCreator
+    public Cards(@JsonProperty("cards") ArrayList<Card> cardsArrayList) {
+        this.cards = cardsArrayList;
+    }
+
+
+
+    /**
+     * Fügt eine neue at.reisinger.Card hinzu
+     * @param newCard neue at.reisinger.Card
+     */
+    @JsonSetter
+    public void addCard(Card newCard) {
+        this.cards.add(newCard);
+    }
+
+    /**
+     * Holt alle at.reisinger.Cards
+     * @return Alle at.reisinger.Cards
+     */
+    @JsonGetter
+    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(String toCeck){
+        AtomicBoolean returnval = new AtomicBoolean(false);
+        this.cards.forEach(item -> {
+            if(item.getName().equals(toCeck)){
+                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,627 @@
+package at.reisinger;
+
+import at.reisinger.server.helper.PostgresHelper;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 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;
+
+
+    /**
+     * Erstellt alle Beispieldaten und simuliert somit den
+     * Verbindungsaufbau zu einer DB
+     */
+    public DBConnection() {
+        this.c = PostgresHelper.con();
+    }
+
+    /**
+     * Erstellt alle Tabellen die für den Betrieb der Software bennötigt werden
+     */
+    public void init() {
+        PostgresHelper.executeUpdateMessage("CREATE TABLE IF NOT EXISTS USERS (username TEXT PRIMARY KEY NOT NULL, nachname TEXT NOT NULL, email TEXT NOT NULL, password TEXT NOT NULL, bio TEXT, image TEXT, coins integer default 20 not null)", "User Table created");
+        PostgresHelper.executeUpdate("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\"));");
+        PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);", "Card Table created");
+        PostgresHelper.executeUpdateMessage("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 );", "Package Table created");
+        PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_cards(username TEXT not null constraint user_cards_users_username_fk references users,name text not null, gesperrt boolean not null);", "UserCards Table created");
+        PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_deck(username text not null constraint user_deck_users_username_fk references users,cardname text not null);", "UserDeck Table created");
+        PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS trading(username text not null constraint trading_users_username_fk references users,id text not null constraint trading_pk primary key, cardtotrade text not null constraint trading_card_name_fk references card, mindamage float not null,reqcardtype text not null,reqelement text not null);", "Trading Table created");
+    }
+
+    /**
+     * Updated den Lock einer user card
+     * @param name Name der Card
+     * @param lock Zustand des Locks
+     * @return true bei erfolg, sonst false
+     */
+    public boolean updateCardLock(String name, boolean lock){
+        return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';");
+    }
+
+
+    /**
+     * Prüft ob eine Card für das Deck gesperrt ist
+     * @param name Name der Card die zu prüfen ist
+     * @return True falls gesperrt, ansonst false
+     * @throws SQLException Locked Cards konnten nicht aus der DB geholt werden
+     */
+    public boolean getCardLock(String name) throws SQLException {
+        this.c = PostgresHelper.con();
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        boolean locked = false;
+        stmt = this.c.createStatement();
+        ResultSet rs = stmt.executeQuery("select gesperrt from user_cards where name = \'" + name + "\';");
+        while (rs.next()) {
+            locked = rs.getBoolean("gesperrt");
+        }
+        rs.close();
+        stmt.close();
+        this.c.close();
+        System.out.println("Trading Deals pulled successfully");
+        return locked;
+    }
+
+    /**
+     * Löscht einen Trading Deal aus der Datenbank
+     * @param id Id des deals der gelöscht werden soll
+     * @return True bei erfolg, sonst false
+     */
+    public boolean deleteTradingDeal(String id){
+        return PostgresHelper.executeUpdate("delete from trading where id = \'" + id + "\';");
+    }
+
+    /**
+     * Fügt der DB einen Trading deal hinzu
+     * @param username User der den Trade hinzufügt
+     * @param id Id des Trades
+     * @param mindamage Min damage der für den trade benötigt wird
+     * @param reqcardtype Req Card Type der für den trade benötigt wird
+     * @param reqelement Req Element Typ der für den trade benötigt wird
+     * @param cardtotrade Card die zum Traden ist
+     * @return True bei erfolg, sonst false
+     */
+    public boolean addTradingdeal(String username, String id, double mindamage, String reqcardtype, String reqelement, String cardtotrade){
+        if(PostgresHelper.executeUpdate("INSERT INTO public.trading (username, id, cardtotrade, mindamage, reqcardtype, reqelement) VALUES (\'" + username + "\',\'" + id + "\',\'" + cardtotrade + "\',\'"+ mindamage + "\',\'" + reqcardtype + "\',\'" + reqelement + "\');")){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    /**
+     * Holt alle Trading Deals aus der DB
+     * @return Null bei error
+     */
+    public ArrayList<TradingDeal> getAllTradingDeals(){
+        this.c = PostgresHelper.con();
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from trading;");
+            while (rs.next()) {
+                String username, id, cardtotrade, reqcardtype, reqelement;
+                int mindamage;
+                username = rs.getString("username");
+                id = rs.getString("id");
+                cardtotrade = rs.getString("cardtotrade");
+                reqcardtype = rs.getString("reqcardtype");
+                reqelement = rs.getString("reqelement");
+                mindamage = rs.getInt("mindamage");
+
+                Card card = new DBConnection().getCardFromID(cardtotrade);
+                if(card != null){
+                    TradingDeal tmp = new TradingDeal(id, card, mindamage, reqcardtype +reqelement, username);
+                    if (tmp != null){
+                        tradingDeals.add(tmp);
+                        System.out.println("Pulled TradingDeal");
+                    }else{
+                        return null;
+                    }
+                }else{
+                    return null;
+                }
+
+
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Trading Deals pulled successfully");
+        return tradingDeals;
+    }
+
+    /**
+     * Setzt das Deck eines Users
+     * @param username Username von dem das Deck gesetzt werden soll
+     * @param deck Die ID´s des Decks in der Form einer ArrayList<String>
+     * @return True bei erfolg, sonst false
+     */
+    public boolean setDeck(String username, List<String> deck){
+        for (String st :deck) {
+            try {
+                if(getCardLock(st)){
+                    return false;
+                }
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+                return false;
+            }
+        }
+        if (!delDeck(username)){
+            return false;
+        }
+        Cards allCards = getCards(username);
+        Cards deckCards = new Cards(new ArrayList<Card>());
+        int count = 0;
+        if(allCards != null){
+            for (String st : deck) {
+                for (Card ca: allCards.getCards()) {
+                    System.out.println("Count : " + count);
+                    System.out.println("CA: " + ca.getName() + " st: " + st);
+                    if(ca.getName().equals(st) && count < 4){
+                        deckCards.addCard(ca);
+                        if(!PostgresHelper.executeUpdateMessage("INSERT INTO public.user_deck (username, cardname) VALUES (\'"+username+"\', \'"+st+"\');", "Card #"+count+" added to Deck")){
+                            return false;
+                        }
+                    }
+                }
+                count++;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Holt alle Card namen aus dem Deck eines Users
+     * @param username user von dem die Deck namen geholt werden soll
+     * @return null bedeuted error
+     */
+    public ArrayList<String> getDeck(String username){
+        this.c = PostgresHelper.con();
+        String cardname = "";
+        Cards allCards = new Cards(new ArrayList<Card>());
+        ArrayList<String> cardnamenarray = new ArrayList<String>();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from user_deck where username = \'" + username + "\';");
+            while (rs.next()) {
+                cardname = rs.getString("cardname");
+                cardnamenarray.add(cardname);
+                System.out.println("cardname = " + cardname);
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Deck names pulled successfully");
+        return cardnamenarray;
+    }
+
+    /**
+     * Löscht den gesammten inhalt des Decks eines users
+     * @param username Username von dem das Deck gelöscht werden soll
+     * @return True bei erfolg, sonst false
+     */
+    public boolean delDeck(String username){
+        return PostgresHelper.executeUpdateMessage("delete from user_deck where username = \'" + username + "\';", "User Deck: " + username + ", deleted");
+    }
+
+
+    /**
+     * Holt ein Random package aus dem Shop
+     *
+     * @param username User der das Package haben möchte
+     * @return Das Package aus dem Shop, null falls ein Fehler auftritt
+     */
+    public Package userAcquirePackage(String username) {
+        int coins = checkCoins(username);
+        if (!(coins - 5 >= 0)) {
+            return null;
+        }
+        updateCoins(coins - 5, username);
+
+        this.c = PostgresHelper.con();
+        String id = "";
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select \"ID\" as id from package LIMIT 1;");
+            while (rs.next()) {
+                id = rs.getString("id");
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Package selected successfully");
+        this.c = PostgresHelper.con();
+        String packagename = "", cardname = "", elementtyp = "", cardtype = "";
+        int zeilennummer = 0, damage = 0;
+        Cards cards = new Cards(new ArrayList<Card>());
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select  i as zeilennummer,  package.\"ID\" as id, package.name as packagename, c.name as cardname, c.DAMAGE as damage, c.ELEMENTTYP as elementtyp, c.CARDTYPE as cardtype from package join card c on c.name = package.name where \"ID\" = \'" + id + "\';");
+            int count = 0;
+            while (rs.next()) {
+                System.out.println(count++);
+                zeilennummer = rs.getInt("zeilennummer");
+                id = rs.getString("id");
+                packagename = rs.getString("packagename");
+                cardname = rs.getString("cardname");
+                elementtyp = rs.getString("elementtyp");
+                cardtype = rs.getString("cardtype");
+                damage = rs.getInt("damage");
+                Card newCard = new Card(cardname, elementtyp + cardtype, damage);
+                cards.addCard(newCard);
+                Connection b = PostgresHelper.con();
+                try {
+                    stmt = b.createStatement();
+                    String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + newCard.getName() + "\', \'false\');";
+                    stmt.executeUpdate(sql);
+                    stmt.close();
+                    b.close();
+                } catch (Exception e) {
+                    System.err.println(e.getClass().getName() + ": " + e.getMessage());
+                    return null;
+                }
+                System.out.println("User got Card successfully");
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Package pulled successfully");
+        deletePackage(id);
+
+        if (cards.getCards().size() != 0 && cards != null) {
+            return new Package(cards, packagename, 5);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Löscht ein Package anhand des Namens
+     *
+     * @param name Name des Packages das gelöscht werden soll
+     * @return True bei erfolg, sonst false
+     */
+    public boolean deletePackage(String name) {
+        return PostgresHelper.executeUpdateMessage("DELETE FROM package WHERE \"ID\" = \'" + name + "\';", "Package deleted successfully");
+    }
+
+
+    /**
+     * Coins setzten
+     *
+     * @param coins Anzahl die zu setzten ist
+     * @return True bei erfolg, sonst false
+     */
+    public boolean updateCoins(int coins, String username) {
+        return PostgresHelper.executeUpdateMessage("UPDATE users SET coins = " + coins + " WHERE username = \'" + username + "\';", "Coins Updated");
+    }
+
+    /**
+     * Gibt die Anzahl an verfügbaren coins zurück
+     *
+     * @return Anzahl der Coins, -1 ist error
+     */
+    public int checkCoins(String username) {
+        System.out.println("Check coin start");
+        this.c = PostgresHelper.con();
+        int coins = 0;
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("Select coins from users where username = \'" + username + "\';");
+            while (rs.next()) {
+                coins = rs.getInt("coins");
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.out.println("check soin error");
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return -1;
+        }
+        System.out.println("\nCoins: " + coins);
+        return coins;
+    }
+
+    /**
+     * Ü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 = PostgresHelper.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");
+            }
+            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) {
+        return PostgresHelper.executeUpdateMessage("insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values (\'" + card.getName() + "\',\'" + card.getDamage() + "\',\'" + card.getElementTyp().name() + "\',\'" + card.getCardType().name() + "\')", "Card added");
+    }
+
+    /**
+     * Ermittelt die nächste Package ID
+     *
+     * @return Die Nächste Package id, wenn 0, dann ist ein error
+     */
+    public int nextPackageId() {
+        this.c = PostgresHelper.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;
+        }
+        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;
+                }
+            }
+            if(!PostgresHelper.executeUpdateMessage("INSERT INTO package (\"ID\", \"name\") values (\'" + pack.getName() + "\',\'" + ca.getName() + "\');", "Card zu Package hinzugefügt")){
+                return false;
+            }
+        }
+        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, String bio, String image) {
+        return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password, bio, image) values (\'" + username + "\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\',\'" + bio + "\',\'" + image + "\')", "User added");
+    }
+
+    /**
+     * Updated den Nachnamen, Bio und das Image eines Users mit gegebenen usernamen
+     * @param username User der geändert werden soll
+     * @param bio Neue BIO
+     * @param image Neues Image
+     * @param name Neuer Nachname
+     * @return True bei erfolg, sonst false
+     */
+    public boolean updateUser(String username, String bio, String image, String name){
+        System.out.println("UPDATE public.users SET nachname = \'"+ name+"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
+        return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = \'"+ name+"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
+    }
+    /**
+    private boolean updateUser(String username, String name, String bio, String image){
+        return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = \'"+ name +"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
+    }
+
+    /**
+     * Sucht einen User anhand des Usernamens.
+     * Gibt ein User Objekt zurück
+     *
+     * @param uname Username der zu suchen ist
+     * @return User als User Objekt, null bei fehler
+     * @throws SQLException Fehler bei der Suche in der DB
+     */
+    public User getUser(String uname) throws SQLException {
+        this.c = PostgresHelper.con();
+        String username = "", password = "", email = "", nachname = "", bio="", image="";
+        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");
+                bio = rs.getString("bio");
+                image = rs.getString("image");
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("User pulled successfully");
+        return new User(new Credentials(username, password), username, username, email, new Coins(20), bio, image);
+    }
+
+    /**
+     * Holt eine Card aus der DB, anhand der gegebenen Card Id
+     * @param id Id der Card die geholt werden soll
+     * @return Null bei error
+     */
+    public Card getCardFromID(String id){
+        System.out.println(id);
+        Connection b = PostgresHelper.con();
+        Card toreturn = null;
+        try {
+            stmt = b.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from card where NAME =  \'" + id + "\';");
+            while (rs.next()) {
+                int damage =rs.getInt("damage");
+                String elementtyp =rs.getString("elementtyp");
+                String cardtype=rs.getString("cardtype");
+                System.out.println("damage = " + damage);
+                System.out.println("elementtyp = " + elementtyp);
+                System.out.println("cardtype = " + cardtype);
+                System.out.println();
+                toreturn = new Card(id, elementtyp+cardtype, damage);
+            }
+            rs.close();
+            stmt.close();
+            b.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        if (toreturn != null){
+            System.out.println("Card pulled successfully");
+            return toreturn;
+        }else {
+            System.out.println("Card NOT pulled");
+            return null;
+        }
+    }
+
+    /**
+     * Holt alle Carten einer gegebenen Card ID List
+     * @param cardnamenarray Card IDs in einer Liste
+     * @return Falls null, dann war ein error
+     */
+    public Cards getCardsFromIDList(List<String> cardnamenarray){
+        Cards allCards = new Cards(new ArrayList<Card>());
+        for (String st : cardnamenarray) {
+            Connection b = PostgresHelper.con();
+            try {
+                stmt = b.createStatement();
+                ResultSet rs = stmt.executeQuery("select * from card where NAME =  \'" + st + "\';");
+                while (rs.next()) {
+                    int damage =rs.getInt("damage");
+                    String elementtyp =rs.getString("elementtyp");
+                    String cardtype=rs.getString("cardtype");
+                    System.out.println("damage = " + damage);
+                    System.out.println("elementtyp = " + elementtyp);
+                    System.out.println("cardtype = " + cardtype);
+                    System.out.println();
+                    allCards.addCard(new Card(st, elementtyp+cardtype, damage));
+                }
+                rs.close();
+                stmt.close();
+                b.close();
+            } catch (Exception e) {
+                System.err.println(e.getClass().getName() + ": " + e.getMessage());
+                return null;
+            }
+            System.out.println("Card pulled successfully");
+        }
+        return allCards;
+    }
+
+    /**
+     * Holt alle Karten eines Users
+     * @param username Username des Users
+     * @return Cards Object, falls es null ist, war ein fehler
+     */
+    public Cards getCards(String username){
+        this.c = PostgresHelper.con();
+        String cardname = "";
+        boolean locked;
+        Cards allCards = new Cards(new ArrayList<Card>());
+        ArrayList<String> cardnamenarray = new ArrayList<String>();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';");
+            while (rs.next()) {
+                cardname = rs.getString("name");
+                locked = rs.getBoolean("gesperrt");
+                cardnamenarray.add(cardname);
+                System.out.println("cardname = " + cardname);
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Card Namen pulled successfully");
+        return getCardsFromIDList(cardnamenarray);
+    }
+
+    /**
+     * Holt alle verfügbaren TradingDeals
+     *
+     * @return Alle Trading Deals
+
+    public ArrayList<TradingDeal> getAllTradingDeals() {
+        return this.tradingDeals;
+    }
+
+    /**
+     * Fügt einen neuen Tradingdeal zum at.reisinger.Store hinzu
+     *
+     * @param tradingDeal Der neue Deal
+
+    public void addTradingDeal(TradingDeal tradingDeal) {
+        this.tradingDeals.add(tradingDeal);
+    }
+*/
+}

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, TROLL, ELF, KNIGHT, DRAGON, WIZZARD, ORK, KRAKEN, FIREELVES
+}

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

@@ -0,0 +1,206 @@
+package at.reisinger;
+
+import at.reisinger.server.helper.EnumHelper;
+import com.fasterxml.jackson.annotation.*;
+
+/**
+ * Ein einzelner Trading deal wird hier verwaltet.
+ */
+@JsonAutoDetect
+public class TradingDeal {
+    @JsonProperty
+    private String id, username;
+    @JsonProperty
+    private Card cardToTrade;
+    @JsonProperty
+    private ElementTyp requiredElementType;
+    @JsonProperty
+    private double requiredMinDamage;
+    @JsonProperty
+    private CardType requiredCardType;
+
+    /**
+     * Ein TradingDeal wird  erstellt
+     * @param id Id des Trading 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 at.reisinger.Card Type für den Tausch
+     */
+    public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) {
+        this.id = id;
+        this.cardToTrade = cardToTrade;
+        if(requiredElementType == null){
+            requiredElementType = ElementTyp.UNDEF;
+        }
+        if(requiredCardType == null) {
+            requiredCardType = CardType.UNDEF;
+        }
+        this.requiredElementType = requiredElementType;
+        this.requiredMinDamage = requiredMinDamage;
+        this.requiredCardType = requiredCardType;
+        this.username = username;
+    }
+
+    /**
+     * Ein TradingDeal wird  erstellt, anhand des type werden der ElementType und der CardType automatisch bestimmt
+     * @param id Id des Trading deals
+     * @param cardToTrade at.reisinger.Card die getauscht werden soll
+     * @param type 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
+     */
+    @JsonCreator
+    public TradingDeal(@JsonProperty("Id") String id, @JsonProperty("CardToTrade") Card cardToTrade, @JsonProperty("MinimumDamage") double requiredMinDamage, @JsonProperty("Type") String type, String username) {
+        this(id, cardToTrade, EnumHelper.stringToElementType(type), requiredMinDamage, EnumHelper.stringToCardType(type), username);
+    }
+
+    /**
+     * Holt die ID des Trading deals
+     * @return Id des Trading Deals
+     */
+    public String getId() {
+        return id;
+    }
+
+    /**
+     * Setzt die id des TradingDeals
+     * @param id Id des TradingDeals
+     */
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    /**
+     * Holt den usernamen
+     * @return Der username als String
+     */
+    @JsonGetter
+    public String getUsername() {
+        return username;
+    }
+
+    /**
+     * Setzt den usernamen
+     * @param username Der username als String
+     */
+    @JsonSetter
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+
+    /**
+     * at.reisinger.Card die getraded werden soll
+     * @return at.reisinger.Card die getradet werden soll
+     */
+    @JsonGetter
+    public Card getCardToTrade() {
+        return this.cardToTrade;
+    }
+
+    /**
+     * Req Element type holen
+     * @return Req Element Type
+     */
+    @JsonGetter
+    public ElementTyp getRequiredElementType() {
+        return this.requiredElementType;
+    }
+
+    /**
+     * Req min damage holen
+     * @return Req min damage
+     */
+    @JsonGetter
+    public double getRequiredMinDamage() {
+        return this.requiredMinDamage;
+    }
+
+    /**
+     * Hole req cardtype
+     * @return Req at.reisinger.CardType
+     */
+    @JsonGetter
+    public CardType getRequiredCardType() {
+        return this.requiredCardType;
+    }
+
+    /**
+     * 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 at.reisinger.Card zum tauschen
+     */
+    @JsonSetter
+    public void setCardToTrade(Card cardToTrade) {
+        this.cardToTrade = cardToTrade;
+    }
+
+    /**
+     * Setzt req elementType
+     * @param requiredElementType Der Req elementType
+     */
+    @JsonSetter
+    public void setRequiredElementType(ElementTyp requiredElementType) {
+        this.requiredElementType = requiredElementType;
+    }
+
+    /**
+     * Setzt die req Min damage
+     * @param requiredMinDamage Die req min gamage
+     */
+    @JsonSetter
+    public void setRequiredMinDamage(double requiredMinDamage) {
+        this.requiredMinDamage = requiredMinDamage;
+    }
+
+    /**
+     * Setzt req cardType
+     * @param requiredCardType Der Req at.reisinger.CardType
+     */
+    @JsonSetter
+    public void setRequiredCardType(CardType requiredCardType) {
+        this.requiredCardType = requiredCardType;
+    }
+
+    /**
+     * 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
+     */
+    public boolean dealOk(TradingDeal checkDeal){
+        return this.cardOk(checkDeal.getCardToTrade());
+    }
+
+    /**
+     * 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,109 @@
+package at.reisinger;
+
+import com.fasterxml.jackson.annotation.*;
+
 import java.util.ArrayList;
 
 /**
- * User & Store Logik
+ * at.reisinger.User & at.reisinger.Store Logik
  */
-public class User implements Store{
-    private String name, nachname, email;
+@JsonAutoDetect
+public class User{
+    @JsonProperty
+    private String name, nachname, email, bio, image;
+    /*
+    @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, @JsonProperty String bio, @JsonProperty String image) {
+        this.credentials = credentials;
+        this.name = name;
+        this.nachname = nachname;
+        this.email = email;
+        //this.stack = null;
+        this.coins = coins;
+        this.bio = bio;
+        this.image = image;
+        //this.db = new at.reisinger.DBConnection();
     }
 
     /**
-     * Holt den Stack des Users
-     * @return Stack des Users
+     * Holt die Bio vom User
+     * @return Bio des Users
      */
+    @JsonGetter
+    public String getBio() {
+        return bio;
+    }
+
+    /**
+     * Setzt die Bio vom User
+     * @param bio Bio des Users
+     */
+    @JsonSetter
+    public void setBio(String bio) {
+        this.bio = bio;
+    }
+
+    /**
+     * Holt das image vom user
+     * @return Image vom user
+     */
+    @JsonGetter
+    public String getImage() {
+        return image;
+    }
+
+    /**
+     * Setzt das image vom user
+     * @param image Image vom user
+     */
+    @JsonSetter
+    public void setImage(String image) {
+        this.image = image;
+    }
+
+    /**
+     * 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 +111,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 +196,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 +205,7 @@ public class User implements Store{
      * Setzt den Nachnamen
      * @param nachname Neuer Nachname
      */
+    @JsonSetter
     public void setNachname(String nachname) {
         this.nachname = nachname;
     }
@@ -137,76 +214,87 @@ 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);
     }
 
+
     /**
      * Holt alle verfügbaren Tradingdeals
      * @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
      * @param toTrade Prüft nach diesem Deal
      * @return
-     */
+     *
     @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);
             }
         });
         return possible;
     }
 
+    */
     /**
-     * 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,67 @@
+package at.reisinger.server;
+
+import at.reisinger.DBConnection;
+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;
+
+    /**
+     * 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/EnumHelper.java

@@ -0,0 +1,38 @@
+package at.reisinger.server.helper;
+
+import at.reisinger.CardType;
+import at.reisinger.ElementTyp;
+
+/**
+ * Hilft beim manipulieren von enums
+ */
+public class EnumHelper {
+
+    /**
+     * 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
+     */
+    public static ElementTyp stringToElementType(String elementTypeString){
+        for (ElementTyp e : ElementTyp.values()) {
+            if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) {
+                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
+     */
+    public static CardType stringToCardType(String cardTypeString){
+        for (CardType me : CardType.values()) {
+            if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
+                return me;
+            }
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,110 @@
+package at.reisinger.server.helper;
+
+import at.reisinger.Card;
+import at.reisinger.Cards;
+import at.reisinger.Package;
+import at.reisinger.User;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Hilfsfunktionen für Jackson Json
+ */
+public class JsonHelper {
+
+    /**
+     * Wandelt ein Package in form einer ArrayList<Card> om ein Json um
+     * @param listCards Cards die in dem Json stehen sollen
+     * @param name Name des Packages
+     * @return Json String des Packages
+     */
+    public static String packageListToJson(ArrayList<Card> listCards, String name){
+        Package packageCards = new Package(new Cards(listCards),name, 5);
+        return objToJson(packageCards);
+    }
+
+    /**
+     * Wandelt ein Package Objekt in ein Json um
+     * @param obj Objekt das in ein Json umgewandelt werden soll
+     * @return Json String des Packages
+     */
+    public static String objToJson(Object obj){
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper = new ObjectMapper();
+        String packageJson = "";
+        if(obj != null) {
+            try {
+                packageJson += objectMapper.writeValueAsString(obj);
+            } catch (JsonProcessingException e) {
+                packageJson = "Error: JsonProcessingException -> " + e.getMessage();
+            }
+            return packageJson;
+        }else{
+            return null;
+        }
+    }
+
+    /**
+     * Json wird in ein Card Objekt umgewandelt
+     * @param json Json das umgewandelt werden soll
+     * @return Null bei JsonProcessingException
+     */
+    public static Card jsonToCard(String json){
+        ObjectMapper objectMapper = new ObjectMapper();
+        Card card = null;
+        try {
+           card = objectMapper.readValue(json, Card.class);
+           if(card != null) {
+               return card;
+           }else{
+               return null;
+           }
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+
+
+    /**
+     * Json zu List
+     * @param payload Json String
+     * @return List aus dem json, bei einer JsonProcessingException null
+     */
+    public static List<String> jsonPayloadToList(String payload){
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            return objectMapper.readValue(payload, new TypeReference<List<String>>(){});
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * Json zu Map
+     * @param payload Json String
+     * @return Map aus dem json, bei einer JsonProcessingException null
+     */
+    public static Map<String, Object> jsonPayloadToMap(String payload){
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            return objectMapper.readValue(payload, new TypeReference<Map<String,Object>>(){});
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @Deprecated
+    public static String userToJson(User user){
+        return objToJson(user);
+    }
+
+}

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

@@ -0,0 +1,60 @@
+package at.reisinger.server.helper;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.Statement;
+
+/**
+ * Hilfsfunktionen für die verwendung der Postgres DB
+ */
+public class PostgresHelper {
+
+    /**
+     * Verbindet mit der Datenbank
+     * @return Das Connection Objekt
+     */
+    public static Connection con() {
+        Connection c = null;
+        try {
+            Class.forName("org.postgresql.Driver");
+            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;
+    }
+
+    /**
+     * Führt ein Sql statement ohne rückgabe aus, mit message nachricht
+     * @param sql Sql command
+     * @return True bei erfolg, sonst false
+     */
+    public static boolean executeUpdateMessage(String sql, String message){
+        System.out.println(message);
+        return executeUpdate(sql);
+    }
+
+    /**
+     * Führt ein Sql statement ohne rückgabe aus
+     * @param sql Sql command
+     * @return True bei erfolg, sonst false
+     */
+    public static boolean executeUpdate(String sql){
+        Connection c = con();
+        Statement stmt;
+        try {
+            stmt = c.createStatement();
+            stmt.executeUpdate(sql);
+            stmt.close();
+            c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return false;
+        }
+        return true;
+    }
+}

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,127 @@
+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: Basic");
+        String authString = headers.toString().substring(authIndex + 21);
+        System.out.println("AUTH STRING: " + authString);
+        int authIndexEnd = authString.indexOf(',');
+        System.out.println("INDEX OF: " + authIndexEnd);
+        authString = authString.substring(0, authIndexEnd);
+        System.out.println("AUTH STRING: " + authString);
+
+        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,474 @@
+package at.reisinger.server.objects;
+
+import at.reisinger.*;
+import at.reisinger.Package;
+import at.reisinger.server.helper.JsonHelper;
+import at.reisinger.server.helper.PostgresHelper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.postgresql.shaded.com.ongres.scram.common.bouncycastle.pbkdf2.Pack;
+
+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;
+
+    /**
+     * 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;
+        if (this.url != null) {
+            if (this.cmd.equals("GET")) {
+                if(login()) {
+                    getMethodes();
+                }else{
+                    sendError("401");
+                }
+            }else if (this.cmd.equals("POST")){
+                try {
+                    postMethodes();
+                } catch (JsonProcessingException e) {
+                    e.printStackTrace();
+                }
+            }else if (this.cmd.equals("PUT")){
+                if(login()) {
+                    putMethodes();
+                }else{
+                    sendError("401");
+                }
+            }else if (this.cmd.equals("DELETE")){
+                if(login()) {
+                    deleteMethodes();
+                }else{
+                    sendError("401");
+                }
+            }else{
+                sendError("405");
+            }
+        }
+    }
+
+    /**
+     * Alle Get Methoden
+     * Nur für angemeldete user erreichbar
+     */
+    private void getMethodes(){
+        if (this.url.startsWith("/users")) {
+            String username = this.url.substring(this.url.lastIndexOf('/') + 1);
+            System.out.println("Username in /users/{username}: " + username);
+            User user = null;
+            try {
+                user = new DBConnection().getUser(username);
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+                sendError("401");
+            }
+            if (user != null){
+                String userJson = JsonHelper.userToJson(user);
+                if(userJson != null && !userJson.isEmpty()){
+                    sendResponse(userJson, "200");
+                }
+            }else{
+                sendError("500");
+            }
+        } else if (this.url.startsWith("/cards")) {
+            String username = basicAuthGetUsername(this.authString);
+            Cards allCards = new DBConnection().getCards(username);
+            String jsonCards = JsonHelper.objToJson(allCards);
+            if (jsonCards != null && !jsonCards.isEmpty()){
+                sendResponse(jsonCards, "200");
+            }else{
+                sendError("500");
+            }
+        }else if(this.url.startsWith("/deck")) {
+            String format = this.url.substring(this.url.lastIndexOf('?') + 1);
+            System.out.println("Format in /deck?{format=plain}: " + format);
+            String username = basicAuthGetUsername(this.authString);
+            ArrayList<String> allCards = new DBConnection().getDeck(username);
+            Cards deck = null;
+            Object tmp = null;
+            if(format.startsWith("format=plain")){
+                tmp = allCards;
+            }else{
+                deck = new DBConnection().getCardsFromIDList(allCards);
+                tmp = deck;
+            }
+            String jsonCards = JsonHelper.objToJson(tmp);
+            if (jsonCards != null && !jsonCards.isEmpty()) {
+                sendResponse(jsonCards, "200");
+            } else {
+                sendError("500");
+            }
+        }else if(this.url.startsWith("/tradings")) {
+            ArrayList<TradingDeal> allDeals = new DBConnection().getAllTradingDeals();
+            if(allDeals != null && !allDeals.isEmpty()){
+                String json = JsonHelper.objToJson(allDeals);
+                if(json != null && json != ""){
+                    sendResponse(json, "200");
+                }else{
+                    sendError("500");
+                }
+            }else{
+                sendError("500");
+            }
+        }else{
+            sendError("204");
+        }
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Erstellt den basicAuth Base64 Token aus Username und Passwort
+     * @param username Username für den Token
+     * @param password Passwort für den Token
+     * @return Der Base64 BasicAtuth String
+     */
+    private String basicAuthBase64(String username, String password){
+        String authString = username + ":" + password;
+        byte[] authEncBytes = Base64.getEncoder().encode(authString.getBytes());
+        String authStringEnc = new String(authEncBytes);
+        return authStringEnc;
+    }
+
+    /**
+     * Aus dem Base64 BasicAuth String wird der Username extrahiert
+     * @param authString Base64 BasicAuth String aus dem der Username ausgelesen werden soll
+     * @return Der Username der in dem Base64 BasicAuth String ist
+     */
+    private String basicAuthGetUsername(String authString) {
+        String[] values;
+        if (authString != null) {
+            byte[] credDecoded = Base64.getDecoder().decode(authString);
+            String credentials = new String(credDecoded);
+            values = credentials.split(":", 2);
+        }else{
+            values = null;
+        }
+        return values[0];
+    }
+
+    /**
+     * Alle Post Methoden, siehe API beschreibung für genauere details
+     *
+     * Kann auch von nicht angemeldeten usern erreicht werden.
+     * login() wird hier verwendet
+     * @throws JsonProcessingException Fehler beim de-/serialisieren
+     */
+    private void postMethodes() throws JsonProcessingException {
+        if (this.url.startsWith("/users")) {
+            Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
+            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), "BIO", "IMAGE");
+            System.out.println("CON DB");
+            DBConnection con = new DBConnection();
+            if(!con.addUser(newUser.getCredentials().getUsername(), newUser.getCredentials().getPasswort(), newUser.getCredentials().getUsername(), newUser.getEmail(), newUser.getBio(), newUser.getImage())){
+                sendError("409");
+            }
+            String userJson = JsonHelper.userToJson(newUser);;
+            if(userJson != null) {
+                sendResponse(userJson, "201");
+            }else{
+                sendError("500");
+            }
+        }else if (this.url.startsWith("/sessions")) {
+            Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
+            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", "istrator", this.authString)) {
+                ObjectMapper objectMapper = new ObjectMapper();
+                ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<ArrayList<Card>>() {
+                });
+                Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5);
+                if (!new DBConnection().addPackage(packageCards)) {
+                    sendError("500");
+                } else {
+                    String packageJson = JsonHelper.objToJson(packageCards);
+                    if (packageJson != null) {
+                        sendResponse(packageJson, "201");
+                    } else {
+                        sendError("500");
+                    }
+                }
+            } else {
+                sendError("401");
+            }
+        }else if (this.url.startsWith("/transactions/packages")) {
+            if (login()) {
+                DBConnection db = new DBConnection();
+                Package newPackage = db.userAcquirePackage(basicAuthGetUsername(this.authString));
+                if (newPackage == null) {
+                    sendError("500");
+                } else {
+                    String packageJson = JsonHelper.objToJson(newPackage);
+                    if (packageJson == null) {
+                        sendError("500");
+                    } else {
+                        sendResponse(packageJson, "200");
+                    }
+                }
+            }else{
+                sendError("401");
+            }
+        }else if (this.url.startsWith("/tradings")) {
+            if(login()){
+                Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
+                String id = (String)map.get("Id");
+                String cardtotrade = (String)map.get("CardToTrade");
+                String type = (String)map.get("Type");
+                double mindamage = Double.parseDouble(map.get("MinimumDamage") + "");
+                String username = basicAuthGetUsername(this.authString);
+                if (username != null) {
+                    Card cardtoTradeC = new DBConnection().getCardFromID(cardtotrade);
+                    System.out.println("CARD TO TRAD: " + cardtoTradeC.getName());
+                    if (cardtoTradeC != null) {
+                        TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, username);
+                        if (tradingDeal != null) {
+                            String tradingJson = JsonHelper.objToJson(tradingDeal);
+                            if (tradingDeal != null) {
+                                ArrayList<String> deckCards = new DBConnection().getDeck(username);
+                                if (deckCards != null) {
+                                    if (deckCards.contains(cardtotrade)) {
+                                        new DBConnection().delDeck(username);
+                                    }
+                                    if(new DBConnection().addTradingdeal(tradingDeal.getUsername(), tradingDeal.getId(), tradingDeal.getRequiredMinDamage(), tradingDeal.getRequiredCardType().name(), tradingDeal.getRequiredElementType().name(), tradingDeal.getCardToTrade().getName())){
+                                        if(new DBConnection().updateCardLock(tradingDeal.getCardToTrade().getName(), true)){
+                                            sendResponse(JsonHelper.objToJson(tradingDeal), "201");
+                                        }else{
+                                            sendError("500");
+                                        }
+                                    }else{
+                                        sendError("500");
+                                    }
+                                } else {
+                                    sendError("500");
+                                }
+                                sendResponse(tradingJson, "201");
+                            } else {
+                                sendError("500");
+                            }
+                        } else {
+                            sendError("500");
+                        }
+                    } else {
+                        sendError("500");
+                    }
+                }else{
+                    sendError("500");
+                }
+            }else{
+                sendError("401");
+            }
+        }
+    }
+
+    /**
+     * Prüft den Login, anhand des BasicAuth Base64 String
+     * @return True wenn login daten korrekt, sonst false
+     */
+    private boolean login(){
+        String username = basicAuthGetUsername(this.authString);
+        User user = null;
+        DBConnection con = new DBConnection();
+        try {
+            user = con.getUser(username);
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+            return false;
+        }
+        if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    /**
+     * Alle Put Methoden
+     * Nur für angemeldete user erreichbar
+     * @throws JsonProcessingException Fehler beim de-/serialisieren
+     */
+    private void putMethodes(){
+        if (this.url.startsWith("/users")) {
+            String username = this.url.substring(this.url.lastIndexOf('/') + 1);
+            System.out.println("Username in /users/{username}: " + username);
+            User user = null;
+            try {
+                user = new DBConnection().getUser(username);
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+                sendError("401");
+            }
+            if(user != null) {
+                Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
+                String bio = (String) map.get("Bio");
+                String image = (String) map.get("Image");
+                String name = (String) map.get("Name");
+                System.out.println("Request /users:");
+                System.out.println("Bio: " + bio + "\nImage: " + image + "\nName: " + name);
+                user.setBio(bio);
+                user.setImage(image);
+                user.setNachname(name);
+                if (new DBConnection().updateUser(username, user.getBio(), user.getImage(), user.getNachname())) {
+                    sendResponse(JsonHelper.userToJson(user), "200");
+                } else {
+                    sendError("500");
+                }
+            }else{
+                sendError("500");
+            }
+        }else if(this.url.startsWith("/deck")) {
+            List<String> deckIds = JsonHelper.jsonPayloadToList(this.payload);
+            if (deckIds != null){
+                if (new DBConnection().setDeck(basicAuthGetUsername(this.authString), deckIds)){
+                    Cards deck = new DBConnection().getCardsFromIDList(deckIds);
+                    String deckJson = JsonHelper.objToJson(deck);
+                    if (deck != null && deckJson != null){
+                        sendResponse(deckJson, "200");
+                    }else {
+                        sendError("500");
+                    }
+                }else {
+                    sendError("500");
+                }
+            }else{
+                sendError("500");
+            }
+        }
+    }
+
+
+
+    /**
+     * Alle Delete Methoden, siehe API beschreibung für genauere details
+     * Nur für angemeldete user erreichbar
+     * @throws JsonProcessingException Fehler beim de-/serialisieren
+     */
+    private void deleteMethodes(){
+        if (this.url.startsWith("/tradings")) {
+            String tradeid = this.url.substring(this.url.lastIndexOf('/') + 1);
+            System.out.println("Format in /tradings/{tradingid}: " + tradeid);
+            ArrayList<TradingDeal> allTradingDeals = new DBConnection().getAllTradingDeals();
+            TradingDeal tr = null;
+            if (allTradingDeals != null && !allTradingDeals.isEmpty()) {
+                for (TradingDeal i : allTradingDeals) {
+                    if (i.getId().equals(tradeid)) {
+                        tr = i;
+                    }
+                }
+                if (tr != null) {
+                    if (new DBConnection().deleteTradingDeal(tradeid)) {
+                        if (new DBConnection().updateCardLock(tr.getCardToTrade().getName(), false))
+                            sendResponse("", "204");
+                    } else {
+                        sendError("500");
+                    }
+                }else{
+                    sendError("500");
+                }
+            }
+
+        }
+    }
+
+
+    /**
+     * 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);
+    }
+
+    /**
+     * Sendet eine Startseite, mit allen befehlen und wie man diese verwendet
+
+    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");
+    }
+     */
+
+    /**
+     * 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);
+    }
+}

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.getName()));
+    }
+
+    @Test
+    void test_contains2() {
+        assertFalse(cards.containsCard(newCard.getName()));
+    }
+
     @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,46 +32,59 @@ 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, "BIO", "IMAGE");
+        userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE");
 
         //Trading Deal
         Card cardToTrade = card;
         ElementTyp requiredElementType = ElementTyp.FIRE;
         double requiredMinDamage = 100;
         CardType requiredCardType = CardType.MONSTER;
-        tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType);
+        tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME");
 
     }
-
+/*
     @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), "BIO", "IMAGE");
+        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), "BIO", "IMAGE");
+        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,21 @@ 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), "BIO", "IMAGE"), 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,27 +31,30 @@ 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, "BIO", "IMAGE");
+        userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE");
 
         //Trading Deal
         Card cardToTrade = card;
         ElementTyp requiredElementType = ElementTyp.FIRE;
         double requiredMinDamage = 100;
         CardType requiredCardType = CardType.MONSTER;
-        tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType);
+        tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME");
     }
 
+    /*
     @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, "BIO", "IMAGE");
     }
     @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(){