Battle Bugfixes

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

@@ -1,4 +1,529 @@
 package at.reisinger;
 
+import java.util.ArrayList;
+import java.util.Collections;
+
 public class Battle {
+
+    private User player1, player2;
+    private int scorePlayer1, scorePlayer2, id;
+    private Cards deckPlayer1, deckPlayer2, deckPlayer1Init, deckPlayer2Init;
+    private Card spielfeldCardPlayer1, spielfeldCardPlayer2;
+    private ArrayList<String> log = new ArrayList<String>();
+
+
+    /**
+     * Erstellt ein neues Battle
+     * @param player1 Player 1 Obj
+     * @param player2 Player 2 Obj
+     * @param scorePlayer1 Score PLayer 1
+     * @param scorePlayer2 Score player 2
+     * @param deckPlayer1 Deck Player 1
+     * @param deckPlayer2 Deck Player 2
+     */
+    public Battle(int id, User player1, User player2, int scorePlayer1, int scorePlayer2, Cards deckPlayer1, Cards deckPlayer2) {
+        this.id = id;
+        this.player1 = player1;
+        this.player2 = player2;
+        this.scorePlayer1 = scorePlayer1;
+        this.scorePlayer2 = scorePlayer2;
+        this.deckPlayer1 = deckPlayer1;
+        this.deckPlayer2 = deckPlayer2;
+        this.deckPlayer1Init = deckPlayer1;
+        this.deckPlayer2Init = deckPlayer2;
+        this.spielfeldCardPlayer1 = null;
+        this.spielfeldCardPlayer2 = null;
+    }
+
+    /**
+     * Erstellt ein neues Battle, im zustand offenes battle
+     * @param id
+     * @param player1
+     * @param deckPlayer1
+     */
+    public Battle(int id, User player1, Cards deckPlayer1){
+        this.id = id;
+        this.player1 = player1;
+        this.deckPlayer1 = deckPlayer1;
+        this.scorePlayer1 = 100;
+        this.scorePlayer2 = 100;
+        this.deckPlayer2 = null;
+        this.deckPlayer1Init = deckPlayer1;
+        this.deckPlayer2Init = null;
+        this.spielfeldCardPlayer1 = null;
+        this.spielfeldCardPlayer2 = null;
+    }
+
+    /**
+     * Startet einen Kampf zw den beiden Playern
+     * @return true bei erfolg, sonst false
+     */
+    public boolean doFight(){
+        System.out.println("DAS IS DAS BATTTTLLLLLLLEEEEEEEEEE FIIIIIGHT!");
+        System.out.println(player1.getName() + " |vs|" + player2.getName());
+        System.out.println(deckPlayer1.getCards().toString()+ " |vs| " + deckPlayer2.getCards().toString());
+
+        if(deckPlayer1.getCards().size() == 4 && deckPlayer2.getCards().size() == 4) {
+            //SHUFFLE DECK
+            ArrayList<Card> d1 = deckPlayer1.getCards();
+            ArrayList<Card> d2 = deckPlayer2.getCards();
+            Collections.shuffle(d1);
+            Collections.shuffle(d2);
+            deckPlayer1.setCards(d1);
+            deckPlayer1.setCards(d2);
+
+            //Runden
+            int maxroundcount = 100, counter = 0, counter2 = 0;
+            while(counter<maxroundcount) {
+                counter++;
+                counter2++;
+                if(counter2 < d1.size()-1 && counter2 < d2.size()-1){
+                    counter2 = 0;
+                }
+                System.out.println("Runde: " + counter);
+                System.out.println("deck 1 size: " + d1.size() + " Deck 2 size: " + d2.size());
+                Card c1 = d1.get(counter2);
+                Card c2 = d2.get(counter2);
+                System.out.println("Card 1: " + c1.getElementTyp() + c1.getCardType() + "\nCard 2: " + c2.getElementTyp() + c2.getCardType());
+                if (d1.size() > 0 && d2.size() > 0 && counter<=maxroundcount) {
+                    //GLEICHER TYP Monster
+                    if (!c1.getCardType().name().toUpperCase().equals("SPELL") && !c2.getCardType().name().toUpperCase().equals("SPELL")) {
+                        System.out.println("Same Monster");
+                        //Check ob eine der beiden Carten ein Dragon ist
+                        if ((c1.getCardType().name().toUpperCase().equals("DRANGON") && !c2.getCardType().name().toUpperCase().equals("DRANGON") || (!c1.getCardType().name().toUpperCase().equals("DRANGON") && c2.getCardType().name().toUpperCase().equals("DRANGON")))) {
+                            //Eine der Karten is Dragon
+                            System.out.println("Eine ist ein dragon");
+                            Card dragon = null;
+                            int dragonOwner = 0;
+                            if (c1.getCardType().name().toUpperCase().equals("DRAGON")) {
+                                dragon = c1;
+                                dragonOwner = 1;
+                            } else if (c2.getCardType().name().toUpperCase().equals("DRAGON")) {
+                                dragon = c2;
+                                dragonOwner = 2;
+                            } else {
+                                System.out.println("KEIN DRAGON GEFUNDEN");
+                                return false;
+                            }
+                            if ((c1.getCardType().name().toUpperCase().equals("GOBLIN") && !c2.getCardType().name().toUpperCase().equals("GOBLIN") || (!c1.getCardType().name().toUpperCase().equals("GOBLIN") && c2.getCardType().name().toUpperCase().equals("GOBLIN")))) {
+                                //Eine der Karten ist Goblin
+                                System.out.println("Andere ist ein goblin");
+                                Card goblin = null;
+                                if (c1.getCardType().name().toUpperCase().equals("GOBLIN")) {
+                                    goblin = c1;
+                                } else if (c2.getCardType().name().toUpperCase().equals("GOBLIN")) {
+                                    goblin = c2;
+                                } else {
+                                    System.out.println("KEIN GOBLIN GEFUNDEN");
+                                    return false;
+                                }
+                                if (dragon.getDamage() > goblin.getDamage()) {
+                                    //Drache ist stärker
+                                    if (dragonOwner == 1) {
+                                        d1.add(c2);
+                                        d2.remove(c2);
+                                        this.scorePlayer1 += 3;
+                                        this.scorePlayer2 -= 5;
+                                    } else if (dragonOwner == 2) {
+                                        d2.add(c1);
+                                        d1.remove(c1);
+                                        this.scorePlayer1 -= 5;
+                                        this.scorePlayer2 += 3;
+                                    }
+                                    log.add("Player " + dragonOwner + " gewinnt!\nDrache ist stärker! Drache: " + dragon.getDamage() + " vs Goblin: " + goblin.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                } else {
+                                    System.out.println("DRAW: Drache zu schwach um anzugreifen und GOBLIN zu feige.");
+                                }
+                            } else if ((c1.getCardType().name().toUpperCase().equals("ELF") && c1.getElementTyp().name().toUpperCase().equals("FIRE") && !c2.getCardType().name().toUpperCase().equals("ELF") || (!c1.getCardType().name().toUpperCase().equals("ELF") && c2.getElementTyp().name().toUpperCase().equals("FIRE") && c2.getCardType().name().toUpperCase().equals("ELF")))) {
+                                //Eine der Karten ist der Fire Elf die andere Karte ist der drache
+                                System.out.println("Andere ist ein elf");
+                                Card fireelf = null;
+                                if (dragonOwner == 1) {
+                                    fireelf = c2;
+                                } else if (dragonOwner == 2) {
+                                    fireelf = c1;
+                                }
+
+                                if (fireelf.getDamage() > dragon.getDamage()) {
+                                    //Fireelf ist stärker
+                                    if (dragonOwner == 1) {
+                                        d2.add(c1);
+                                        d1.remove(c1);
+                                        this.scorePlayer2 += 3;
+                                        this.scorePlayer1 -= 5;
+                                    } else if (dragonOwner == 2) {
+                                        d1.add(c2);
+                                        d2.remove(c2);
+                                        this.scorePlayer2 -= 5;
+                                        this.scorePlayer1 += 3;
+                                    }
+                                    log.add("Player " + dragonOwner + " gewinnt!\nWizzard ist stärker! Drache: " + dragon.getDamage() + " vs FireElves: " + fireelf.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                }
+                                //Sonst nix tun, weil der drache den elf ned angreifen kann
+                            } else {
+                                if (c1.getDamage() > c2.getDamage()) {
+                                    d1.add(c2);
+                                    d2.remove(c2);
+                                    this.scorePlayer1 += 3;
+                                    this.scorePlayer2 -= 5;
+                                    log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                } else if (c1.getDamage() < c2.getDamage()) {
+                                    d2.add(c1);
+                                    d1.remove(c1);
+                                    this.scorePlayer2 += 3;
+                                    this.scorePlayer1 -= 5;
+                                    log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                }
+                            }
+
+                            //Checkt ob eine der beiden karten ein wizzard ist und der andere ein ork
+                        } else if ((c1.getCardType().name().toUpperCase().equals("WIZZARD") && c2.getCardType().name().toUpperCase().equals("ORK") || (c2.getCardType().name().toUpperCase().equals("WIZZARD") && c1.getCardType().name().toUpperCase().equals("ORK")))) {
+                            System.out.println("Eine wizzard Andere ist ein ork");
+                            Card wizzard = null;
+                            Card ork = null;
+                            int wizzardOwner = 0;
+                            if (c1.getCardType().name().toUpperCase().equals("WIZZARD")) {
+                                wizzardOwner = 1;
+                                wizzard = c1;
+                                ork = c2;
+                            } else if (c1.getCardType().name().toUpperCase().equals("WIZZARD")) {
+                                wizzardOwner = 2;
+                                wizzard = c2;
+                                ork = c1;
+                            }
+                            if (wizzard.getDamage() > ork.getDamage()) {
+                                if (wizzardOwner == 1) {
+                                    d1.add(c2);
+                                    d2.remove(c2);
+                                    this.scorePlayer1 += 3;
+                                    this.scorePlayer2 -= 5;
+                                } else if (wizzardOwner == 2) {
+                                    d2.add(c1);
+                                    d1.remove(c1);
+                                    this.scorePlayer2 += 3;
+                                    this.scorePlayer1 -= 5;
+                                }
+
+                                log.add("Player " + wizzardOwner + " gewinnt!\nWizzard ist stärker! Wizzard: " + wizzard.getDamage() + " vs Ork: " + ork.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                            }
+                            //Sonst nix tun, weil der ork dem wizzard keinen schaden machen kann
+                        } else {
+                            //PURE MONSTER
+                            if (c1.getDamage() > c2.getDamage()) {
+                                d1.add(c2);
+                                d2.remove(c2);
+                                this.scorePlayer1 += 3;
+                                this.scorePlayer2 -= 5;
+                                log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                            } else if (c1.getDamage() < c2.getDamage()) {
+                                d2.add(c1);
+                                d1.remove(c1);
+                                this.scorePlayer2 += 3;
+                                this.scorePlayer1 -= 5;
+                                log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                            }
+                            //sonst nix weil bei gleichen damage --> draw
+                        }
+                    } else {//PURE SPELL & mixed
+                        double damagePlayer1 = -1, damagePlayer2 = -1;
+
+                        if (c1.getCardType().name().toUpperCase().equals("KNIGHT") || c2.getCardType().name().toUpperCase().equals("KNIGHT")) {
+                            //Mixed mit "Spezialeffekt" KNIGHT
+                            System.out.println("Spell und knight");
+                            Card knight = null, other = null;
+                            int knightOwner = 0;
+                            if (c1.getCardType().name().toUpperCase().equals("KNIGHT")) {
+                                knight = c1;
+                                other = c2;
+                                knightOwner = 1;
+                            } else if (c2.getCardType().name().toUpperCase().equals("KNIGHT")) {
+                                knight = c2;
+                                other = c1;
+                                knightOwner = 2;
+                            }
+                            double damageKnight = -1, damageOther = -1;
+                            if (other.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                //tot
+                                damageKnight = 0;
+                                damageOther = other.getDamage();
+                            } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("REGULAR")) {
+                                //not effective
+                                damageKnight = knight.getDamage() / 2;
+                                //effective
+                                damageOther = other.getDamage() * 2;
+                            } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("FIRE")) {
+                                //no effect
+                                damageKnight = knight.getDamage();
+                                //no effect
+                                damageOther = other.getDamage();
+                            } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("WATER")) {
+                                //effective
+                                damageKnight = knight.getDamage() * 2;
+                                //not effective
+                                damageOther = other.getDamage() / 2;
+                            } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("REGULAR")) {
+                                //no effect
+                                damageKnight = knight.getDamage();
+                                //no effect
+                                damageOther = other.getDamage();
+                            } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("FIRE")) {
+                                //effective
+                                damageKnight = knight.getDamage() * 2;
+                                //not effective
+                                damageOther = other.getDamage() / 2;
+                            } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("WATER")) {
+                                //not effective
+                                damageKnight = knight.getDamage() / 2;
+                                //effective
+                                damageOther = other.getDamage() * 2;
+                            }
+                            if (damageKnight > damageOther) {
+                                if (knightOwner == 1) {
+                                    d1.add(c2);
+                                    d2.remove(c2);
+                                    this.scorePlayer1 += 3;
+                                    this.scorePlayer2 -= 5;
+                                    log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damageKnight + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                } else if (knightOwner == 2) {
+                                    d2.add(c1);
+                                    d1.remove(c1);
+                                    this.scorePlayer2 += 3;
+                                    this.scorePlayer1 -= 5;
+                                    log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damageKnight + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                }
+                            } else if (damageKnight < damageOther) {
+                                if (knightOwner == 2) {
+                                    d1.add(c2);
+                                    d2.remove(c2);
+                                    this.scorePlayer1 += 3;
+                                    this.scorePlayer2 -= 5;
+                                    log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damageOther + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                } else if (knightOwner == 1) {
+                                    d2.add(c1);
+                                    d1.remove(c1);
+                                    this.scorePlayer2 += 3;
+                                    this.scorePlayer1 -= 5;
+                                    log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damageOther + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                }
+                            }
+                        } else if (c1.getCardType().name().toUpperCase().equals("KRAKEN") || c2.getCardType().name().toUpperCase().equals("KRAKEN")) {
+                            //Mixed mit "Spezialeffekt" KRAKEN
+                            if (c1.getCardType().name().toUpperCase().equals("KRAKEN")) {
+                                d1.add(c2);
+                                d2.remove(c2);
+                                this.scorePlayer1 += 3;
+                                this.scorePlayer2 -= 5;
+                                log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                            } else if (c2.getCardType().name().toUpperCase().equals("KRAKEN")) {
+                                d2.add(c1);
+                                d1.remove(c1);
+                                this.scorePlayer2 += 3;
+                                this.scorePlayer1 -= 5;
+                                log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                            }
+                        } else {
+                            ////PURE SPELL & mixed mit elementen
+                            System.out.println("Spell und mixed mit elementen");
+                            //Player 1 Damage berechnen
+                            if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                    //effective
+                                    damagePlayer1 = c1.getDamage() * 2;
+                                } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                    //not effective
+                                    damagePlayer1 = c1.getDamage() / 2;
+                                } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                    //no effect
+                                    damagePlayer1 = c1.getDamage();
+                                }
+                            } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                    //effective
+                                    damagePlayer1 = c1.getDamage() * 2;
+                                } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                    //no effect
+                                    damagePlayer1 = c1.getDamage();
+                                } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                    //not effective
+                                    damagePlayer1 = c1.getDamage() / 2;
+                                }
+                            } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                    //effective
+                                    damagePlayer1 = c1.getDamage() * 2;
+                                } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                    //not effective
+                                    damagePlayer1 = c1.getDamage() / 2;
+                                } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                    //no effect
+                                    damagePlayer1 = c1.getDamage();
+                                }
+                            }
+                            //P2 damage
+                            if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                    //effective
+                                    damagePlayer2 = c2.getDamage() * 2;
+                                } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                    //not effective
+                                    damagePlayer2 = c2.getDamage() / 2;
+                                } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                    //no effect
+                                    damagePlayer2 = c2.getDamage();
+                                }
+                            } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                    //effective
+                                    damagePlayer2 = c2.getDamage() * 2;
+                                } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                    //no effect
+                                    damagePlayer2 = c2.getDamage();
+                                } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                    //not effective
+                                    damagePlayer2 = c2.getDamage() / 2;
+                                }
+                            } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                if (c1.getElementTyp().name().toUpperCase().equals("WATER")) {
+                                    //effective
+                                    damagePlayer2 = c2.getDamage() * 2;
+                                } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) {
+                                    //not effective
+                                    damagePlayer2 = c2.getDamage() / 2;
+                                } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) {
+                                    //no effect
+                                    damagePlayer2 = c2.getDamage();
+                                }
+                            }
+
+                            if (damagePlayer1 > -1 && damagePlayer2 > -1) {
+                                if (damagePlayer1 > damagePlayer2) {
+                                    d1.add(c2);
+                                    d2.remove(c2);
+                                    this.scorePlayer1 += 3;
+                                    this.scorePlayer2 -= 5;
+                                    log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damagePlayer1 + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damagePlayer2 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                } else if (damagePlayer2 > damagePlayer1) {
+                                    d2.add(c1);
+                                    d1.remove(c1);
+                                    this.scorePlayer2 += 3;
+                                    this.scorePlayer1 -= 5;
+                                    log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damagePlayer2 + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damagePlayer1 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2);
+                                }
+                            } else {
+                                System.out.println("Damage konnte nicht berechnet werden");
+                                return false;
+                            }
+                        }
+                    }
+                }
+            }
+            this.deckPlayer1 = new Cards(d1);
+            this.deckPlayer2 = new Cards(d2);
+        }else{
+            System.out.println("Einer der Spieler hat zu wenige Karten im Deck");
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Vergleicht 2 Card Typen von 2 Karten
+     * @param c1 Card 1
+     * @param c2 Card 2
+     * @return True wenn die CardType übereinstimmt, sonst false
+     */
+    private boolean sameCardType(Card c1, Card c2){
+        if(c1.getCardType().name().equals(c2.getCardType().name())){
+            return true;
+        }
+        return false;
+    }
+
+    public ArrayList<String> getLog() {
+        return log;
+    }
+
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public User getPlayer1() {
+        return player1;
+    }
+
+    public void setPlayer1(User player1) {
+        this.player1 = player1;
+    }
+
+    public User getPlayer2() {
+        return player2;
+    }
+
+    public void setPlayer2(User player2) {
+        this.player2 = player2;
+    }
+
+    public int getScorePlayer1() {
+        return scorePlayer1;
+    }
+
+    public void setScorePlayer1(int scorePlayer1) {
+        this.scorePlayer1 = scorePlayer1;
+
+    }
+
+    public int getScorePlayer2() {
+        return scorePlayer2;
+    }
+
+    public void setScorePlayer2(int scorePlayer2) {
+        this.scorePlayer2 = scorePlayer2;
+    }
+
+    public Cards getDeckPlayer1() {
+        return deckPlayer1;
+    }
+
+    public void setDeckPlayer1(Cards deckPlayer1) {
+        this.deckPlayer1 = deckPlayer1;
+        this.deckPlayer1Init = deckPlayer1;
+    }
+
+    public Cards getDeckPlayer2() {
+        return deckPlayer2;
+    }
+
+    public void setDeckPlayer2(Cards deckPlayer2) {
+        this.deckPlayer2 = deckPlayer2;
+        this.deckPlayer2Init = deckPlayer2;
+    }
+
+    public Card getSpielfeldCardPlayer1() {
+        return spielfeldCardPlayer1;
+    }
+
+    public void setSpielfeldCardPlayer1(Card spielfeldCardPlayer1) {
+        this.spielfeldCardPlayer1 = spielfeldCardPlayer1;
+    }
+
+    public Card getSpielfeldCardPlayer2() {
+        return spielfeldCardPlayer2;
+    }
+
+    public void setSpielfeldCardPlayer2(Card spielfeldCardPlayer2) {
+        this.spielfeldCardPlayer2 = spielfeldCardPlayer2;
+    }
+
+    public Cards getDeckPlayer1Init() {
+        return deckPlayer1Init;
+    }
+
+    public Cards getDeckPlayer2Init() {
+        return deckPlayer2Init;
+    }
 }

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

@@ -1,5 +1,6 @@
 package at.reisinger;
 
+import at.reisinger.server.helper.EnumHelper;
 import com.fasterxml.jackson.annotation.*;
 
 /**
@@ -15,6 +16,8 @@ public class Card {
     private ElementTyp elementTyp;
     @JsonProperty
     private CardType cardType;
+    @JsonProperty
+    private boolean locked;
 
     /**
      * Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften
@@ -39,66 +42,70 @@ public class Card {
      */
     @JsonCreator
     public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){
-        ElementTyp tmpElement = stringToElementType(elementCardTyp);
+        CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp);
-        if(tmpElement == null){
+        ElementTyp tmpElement = null;
-            tmpElement = ElementTyp.UNDEF;
-        }
-        CardType tmpCard = stringToCardType(elementCardTyp);
         if(tmpCard == null){
             tmpCard = CardType.UNDEF;
         }
+
+        //Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen
+        if (tmpCard.name().toLowerCase().equals("dragon")){
+            tmpElement = ElementTyp.FIRE;
+        }else if (tmpCard.name().toLowerCase().equals("ork")){
+            tmpElement = ElementTyp.REGULAR;
+        }
+        else if (tmpCard.name().toLowerCase().equals("wizzard")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("kraken")){
+            tmpElement = ElementTyp.WATER;
+        }else if (tmpCard.name().toLowerCase().equals("elf")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("goblin")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("troll")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("knight")){
+            tmpElement = ElementTyp.REGULAR;
+        }else if (tmpCard.name().toLowerCase().equals("fireelves")){
+            tmpElement = ElementTyp.FIRE;
+        }
+
+        if(tmpElement == null){
+            tmpElement = EnumHelper.stringToElementType(elementCardTyp);
+            //Deutsch übersetzung
+            if (tmpElement.name().toLowerCase().equals("feuer")){
+                tmpElement = ElementTyp.FIRE;
+            }else if (tmpElement.name().toLowerCase().equals("wasser")){
+                tmpElement = ElementTyp.WATER;
+            }else if (tmpElement.name().toLowerCase().equals("normal")){
+                tmpElement = ElementTyp.REGULAR;
+            }
+            if(tmpElement == null) {
+                tmpElement = ElementTyp.UNDEF;
+            }
+        }
         this.name = name;
         this.damage = damage;
         this.elementTyp = tmpElement;
         this.cardType = tmpCard;
     }
 
+
+
     /**
-     * Wenn ein String als ElementType vorhanden ist, dann gibt er den passenden ElementType zurück
+     * Prüft ob die Karte gesperrt ist
-     * @param elementTypeString elementType als String
+     * @return True wenn die Karte gesperrt ist
-     * @return Passender Element Type oder null falls nicht gefunden
      */
-    private ElementTyp stringToElementType(String elementTypeString){
+    public boolean isLocked() {
-        for (ElementTyp e : ElementTyp.values()) {
+        return locked;
-            System.out.println(e.toString().toLowerCase());
-            System.out.println(elementTypeString.toLowerCase().contains(e.name().toLowerCase()));
-            if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) {
-                System.out.println("\n\n\n");
-                System.out.println("####Element####, me.name() : elementTypeString");
-                System.out.println(e.name().toLowerCase());
-                System.out.print(" : ");
-                System.out.println(elementTypeString.toLowerCase());
-                System.out.println("\n\n\n");
-                return e;
-            }
-        }
-        return null;
     }
 
     /**
-     * Wenn ein String als cardType vorhanden ist, dann gibt er den passenden cardType zurück
+     * Setzt die sperre der Karte
-     * @param cardTypeString cardType als String
+     * @param locked True bedeuted gesperrt
-     * @return Passender Card Type oder null falls nicht gefunden
      */
-    private CardType stringToCardType(String cardTypeString){
+    public void setLocked(boolean locked) {
-        System.out.println("\n\n\n");
+        this.locked = locked;
-        System.out.println("###CARD###, me.name() : cardTypeString\n");
-        for (CardType me : CardType.values()) {
-            System.out.println("\n\n\n");
-            System.out.print(me.name().toLowerCase());
-            System.out.print(" : ");
-            System.out.println(cardTypeString.toLowerCase());
-            System.out.println("\n\n\n");
-            if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
-                System.out.println("\n\n\n");
-                System.out.print(me.name().toLowerCase());
-                System.out.print(" : ");
-                System.out.println(cardTypeString.toLowerCase());
-                System.out.println("\n\n\n");
-                return me;
-            }
-        }
-        return null;
     }
 
     /**

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

@@ -1,5 +1,5 @@
 package at.reisinger;
 
 public enum CardType {
-    MONSTER, SPELL, UNDEF, GOBLIN, TROLL, ELF, KNIGHT
+    MONSTER, SPELL, UNDEF, GOBLIN, TROLL, ELF, KNIGHT, DRAGON, WIZZARD, ORK, KRAKEN, FIREELVES
 }

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

@@ -1,28 +1,41 @@
 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
      */
-    public Cards(ArrayList<Card> cardsArrayList) {
+    @JsonCreator
+    public Cards(@JsonProperty("cards") ArrayList<Card> cardsArrayList) {
         this.cards = cardsArrayList;
     }
 
-
+    /**
+     * Setzt die Carten
+     * @param cards Cards in einer ArrayList die gesetzt werden sollen
+     */
+    public void setCards(ArrayList<Card> cards) {
+        this.cards = cards;
+    }
 
     /**
      * Fügt eine neue at.reisinger.Card hinzu
      * @param newCard neue at.reisinger.Card
      */
+    @JsonSetter
     public void addCard(Card newCard) {
         this.cards.add(newCard);
     }
@@ -31,6 +44,7 @@ public class Cards {
      * Holt alle at.reisinger.Cards
      * @return Alle at.reisinger.Cards
      */
+    @JsonGetter
     public ArrayList<Card> getCards() {
         return this.cards;
     }
@@ -48,10 +62,10 @@ public class Cards {
      * @param toCeck at.reisinger.Card nach der in den at.reisinger.Cards gesucht werden soll
      * @return True wenn die at.reisinger.Card in den at.reisinger.Cards ist
      */
-    public boolean containsCard(Card toCeck){
+    public boolean containsCard(String 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()){
+            if(item.getName().equals(toCeck)){
                 returnval.set(true);
             }else{
                 returnval.set(false);

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

@@ -1,17 +1,21 @@
 package at.reisinger;
 
+import at.reisinger.server.helper.JsonHelper;
 import at.reisinger.server.helper.PostgresHelper;
 
 import java.sql.*;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Stellt die Verbindung zur "Datenbank" her
  * Die "Datenbank" sind hier nur beispieldaten.
  */
 public class DBConnection {
-    private ArrayList<TradingDeal> tradingDeals;
+    //private ArrayList<TradingDeal> tradingDeals;
-    private ArrayList<Package> packages;
+    //private ArrayList<Package> packages;
     private Connection c;
     private Statement stmt;
 
@@ -28,13 +32,382 @@ public class DBConnection {
      * 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)", "User Table created");
+        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");
+        PostgresHelper.executeUpdate("create table if not exists battle(usernamecreator text not null constraint battle_users_username_fk references users,usernameplayer text constraint battle_users_username_fk_2 references users, battleid serial, deckcreator text not null);");
+        PostgresHelper.executeUpdateMessage("create unique index if not exists battle_battleid_uindex on battle (battleid);", "Battle Table created");
+        PostgresHelper.executeUpdate("create table IF NOT EXISTS battle_log(id int not null constraint battle_log_pk primary key, playerone text not null,playertwo text not null,playeronescore text not null,playertwoscore text not null);");
+        PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS battle_log_id_uindex on battle_log (id);", "Battle_lgo Table created");
     }
 
+    /**
+     * Fügt der Battle tabelle ein battle hinzu
+     * @return True bei erfolg, sonst false
+     */
+    public boolean addBattle(String usernamecreator){
+        ArrayList<String> decknamen = getDeck(usernamecreator);
+        if(decknamen != null && !decknamen.isEmpty()){
+            Cards deck = getCardsFromIDList(decknamen);
+            if(deck != null && !deck.getCards().isEmpty()){
+                String deckJson = JsonHelper.objToJson(deck.getCards());
+                if (deckJson != null && !deckJson.isEmpty()){
+                    System.out.println("insert into battle (usernamecreator, deckcreator) VALUES (\'"+ usernamecreator + "\',\'" + deckJson +"\');");
+                    return PostgresHelper.executeUpdateMessage("insert into battle (usernamecreator, deckcreator) VALUES (\'"+ usernamecreator + "\',\'" + deckJson +"\');", "Battle created");
+                }else {
+                    return false;
+                }
+            }else {
+                return false;
+            }
+        }else{
+            return false;
+        }
+    }
+
+    /**
+     * Sucht ein verfügbares open battle aus der DB und löscht gleichzeitig das open battle
+     * @return Null falls keines verfügbar ist oder ein erir auftritt
+     */
+    public Battle getOpenBattle(){
+        this.c = PostgresHelper.con();
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        int battleid = 0;
+        String usernamecreator = "", deckcreator = "";
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from battle limit 1;");
+            while (rs.next()) {
+                battleid = rs.getInt("battleid");
+                usernamecreator = rs.getString("usernamecreator");
+                deckcreator = rs.getString("deckcreator");
+                User player1 = new DBConnection().getUser(usernamecreator);
+                if(player1 != null){
+                    ArrayList<String> deckPlayer1Arr = new DBConnection().getDeck(usernamecreator);
+                    if (deckPlayer1Arr != null){
+                        Cards deckPlayer1 = new DBConnection().getCardsFromIDList(deckPlayer1Arr);
+                        if(deckPlayer1 != null){
+                            if(delBattleEinladung(battleid+"")){
+                                return new Battle(battleid, player1, deckPlayer1);
+                            }else{
+                                return null;
+                            }
+                        }else{
+                            return null;
+                        }
+                    }else {
+                        return null;
+                    }
+                }else{
+                    return null;
+                }
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+            return null;
+        }
+        return null;
+    }
+
+    /**
+     * Löscht die Battle einladung eines einzelnen spielers
+     * @param battleid Id die zu löschen ist
+     * @return true bei erfolg sonst false
+     */
+    public boolean delBattleEinladung(String battleid){
+        return PostgresHelper.executeUpdateMessage("delete from battle where battleid = \'"+ battleid +"\';", "Battle req deleted");
+    }
+
+
+    /**
+     * Nach einem Battle wird das log eingefügt, dabei wird die selbe id wie beim battle verwendet
+     * @param id Id des Battles
+     * @param playerone Name vom Player 1
+     * @param playertwo Name vom Player 2
+     * @param playeronescore Score vom Player 1
+     * @param playertwoscore Score vom Player 2
+     * @return true bei erfolg sonst false
+     */
+    public boolean addBattleLog(String id, String playerone, String playertwo, String playeronescore, String playertwoscore){
+        return PostgresHelper.executeUpdate("insert into battle_log (id, playerone, playertwo, playeronescore, playertwoscore) VALUES ("+id+",\'"+playerone+"\',\'"+playertwo+"\',\'"+playeronescore+"\',\'"+playertwoscore+"\');");
+    }
+
+    /**
+     * Holt alle logs von allen battles
+     * @return Jedes Battle ist in einer Map mit namen von player1 und player2, player1Score und player2Score diese Map ist in einer ArrayList
+     */
+    public ArrayList<Map<String,Object>> getAllBattleLogs(){
+        this.c = PostgresHelper.con();
+        String player1Str, player2Str, scorePlayer1, scorePlayer2;
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from battle_log;");
+            ArrayList<Map<String, Object>> output = new ArrayList<Map<String, Object>>();
+            while (rs.next()) {
+                Map<String, Object> map = Collections.emptyMap();
+                player1Str = rs.getString("playerone");
+                player2Str = rs.getString("playertwo");
+                scorePlayer1 = rs.getString("playeronescore");
+                scorePlayer2 = rs.getString("playertwoscore");
+
+                User player1 = new DBConnection().getUser(player1Str);
+                User player2 = new DBConnection().getUser(player2Str);
+
+                if(player1 != null && player2 != null){
+                    map.put("player1", player1);
+                    map.put("player2", player2);
+                    map.put("playeronescore", scorePlayer1);
+                    map.put("playertwoscore", scorePlayer2);
+                    output.add(map);
+                }else{
+                    return null;
+                }
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+            return null;
+        }
+        return null;
+    }
+
+    /**
+     * Holt das Battellog eines Bestimmten Battles
+     * @param battleid Id des battles
+     * @return Eine Map mit namen von player1 und player2, player1Score und player2Score
+     */
+    public Map<String, Object> getBattleLog(String battleid){
+        this.c = PostgresHelper.con();
+        String player1Str, player2Str, scorePlayer1, scorePlayer2;
+        Map<String, Object> map = Collections.emptyMap();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from battle_log where id = \'" + battleid + "\';");
+            while (rs.next()) {
+                player1Str = rs.getString("playerone");
+                player2Str = rs.getString("playertwo");
+                scorePlayer1 = rs.getString("playeronescore");
+                scorePlayer2 = rs.getString("playertwoscore");
+
+                User player1 = new DBConnection().getUser(player1Str);
+                User player2 = new DBConnection().getUser(player2Str);
+
+                if(player1 != null && player2 != null){
+                    map.put("player1", player1);
+                    map.put("player2", player2);
+                    map.put("playeronescore", scorePlayer1);
+                    map.put("playertwoscore", scorePlayer2);
+                    return map;
+                }else{
+                    return null;
+                }
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+            return null;
+        }
+        return null;
+    }
+
+    /**
+     * 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
      *
@@ -42,13 +415,11 @@ public class DBConnection {
      * @return Das Package aus dem Shop, null falls ein Fehler auftritt
      */
     public Package userAcquirePackage(String username) {
-        System.out.println("Vor den coins");
         int coins = checkCoins(username);
         if (!(coins - 5 >= 0)) {
             return null;
         }
         updateCoins(coins - 5, username);
-        System.out.println("nach den soins");
 
         this.c = PostgresHelper.con();
         String id = "";
@@ -57,8 +428,6 @@ public class DBConnection {
             ResultSet rs = stmt.executeQuery("select \"ID\" as id from package LIMIT 1;");
             while (rs.next()) {
                 id = rs.getString("id");
-                System.out.println("id = " + id);
-                System.out.println();
             }
             rs.close();
             stmt.close();
@@ -87,20 +456,9 @@ public class DBConnection {
                 damage = rs.getInt("damage");
                 Card newCard = new Card(cardname, elementtyp + cardtype, damage);
                 cards.addCard(newCard);
-                System.out.println();
+                if(!addUserCard(username, newCard.getName())){
-                Connection b = PostgresHelper.con();
-                try {
-                    stmt = b.createStatement();
-                    String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + newCard.getName() + "\', \'false\');";
-                    System.out.println(sql);
-                    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();
@@ -119,6 +477,37 @@ public class DBConnection {
         }
     }
 
+    /**
+     * Löscht eine user card aus der DB
+     * @param username Card löschen von
+     * @param cardname Card die vom user zu löschen ist
+     * @return True bei erfolg, sonst false
+     */
+    public boolean delUserCard(String username, String cardname){
+        return PostgresHelper.executeUpdate("delete from user_cards where username = \'"+username+"\' and name = \'"+cardname+"\';");
+    }
+
+    /**
+     * Fügt eine Card zu den User_Cards hinzu
+     * @param username Username der die Card bekommt
+     * @param cardName Card die der User bekommt
+     * @return True bei erfolg, sonst false
+     */
+    public boolean addUserCard(String username, String cardName){
+        Connection b = PostgresHelper.con();
+        try {
+            stmt = b.createStatement();
+            String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + cardName + "\', \'false\');";
+            stmt.executeUpdate(sql);
+            stmt.close();
+            b.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return false;
+        }
+        System.out.println("User got Card successfully");
+        return true;
+    }
     /**
      * Löscht ein Package anhand des Namens
      *
@@ -154,8 +543,6 @@ public class DBConnection {
             ResultSet rs = stmt.executeQuery("Select coins from users where username = \'" + username + "\';");
             while (rs.next()) {
                 coins = rs.getInt("coins");
-                System.out.println("Count: ");
-                System.out.print(coins);
             }
             rs.close();
             stmt.close();
@@ -183,8 +570,6 @@ public class DBConnection {
             ResultSet rs = stmt.executeQuery("select count(*) from card where name = \'" + name + "\';");
             while (rs.next()) {
                 count = rs.getInt("count");
-                System.out.println("Count: ");
-                System.out.print(count);
             }
             rs.close();
             stmt.close();
@@ -234,8 +619,6 @@ public class DBConnection {
             System.err.println(e.getClass().getName() + ": " + e.getMessage());
             return 0;
         }
-        System.out.println("Package Next id is: ");
-        System.out.print(id);
         return Integer.parseInt(id) + 1;
     }
 
@@ -270,8 +653,25 @@ public class DBConnection {
      * @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) {
+    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) values (\'" + username + "\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\')", "User added");
+        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 \'#\'");
     }
 
     /**
@@ -279,12 +679,12 @@ public class DBConnection {
      * Gibt ein User Objekt zurück
      *
      * @param uname Username der zu suchen ist
-     * @return User als User Objekt
+     * @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 = "";
+        String username = "", password = "", email = "", nachname = "", bio="", image="";
         try {
             stmt = this.c.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM users where username = \'" + uname + "\';");
@@ -293,28 +693,128 @@ public class DBConnection {
                 nachname = rs.getString("nachname");
                 email = rs.getString("email");
                 password = rs.getString("password");
-                System.out.println("username = " + username);
+                bio = rs.getString("bio");
-                System.out.println("nachname = " + nachname);
+                image = rs.getString("image");
-                System.out.println("email = " + email);
-                System.out.println("password = " + password);
-                System.out.println();
             }
             rs.close();
             stmt.close();
             this.c.close();
         } catch (Exception e) {
             System.err.println(e.getClass().getName() + ": " + e.getMessage());
-            System.exit(0);
+            return null;
         }
-        System.out.println("Operation done successfully");
+        System.out.println("User pulled successfully");
-        return new User(new Credentials(username, password), username, username, email, new Coins(20));
+        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;
     }
@@ -323,9 +823,9 @@ public class DBConnection {
      * 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/ElementTyp.java

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

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

@@ -1,43 +1,99 @@
 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 {
-    //private User tradingUser;
+    @JsonProperty
+    private String id, username;
+    @JsonProperty
     private Card cardToTrade;
+    @JsonProperty
     private ElementTyp requiredElementType;
+    @JsonProperty
     private double requiredMinDamage;
+    @JsonProperty
     private CardType requiredCardType;
 
     /**
-     * Ein at.reisinger.TradingDeal wird  erstellt
+     * Ein TradingDeal wird  erstellt
-     * @param user at.reisinger.User des Deals
+     * @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(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) {
+    public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) {
-        //this.tradingUser = user;
+        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;
     }
 
     /**
-     * Holt den Trading at.reisinger.User
+     * Ein TradingDeal wird  erstellt, anhand des type werden der ElementType und der CardType automatisch bestimmt
-     * @return at.reisinger.User der den Trade erstellt hat
+     * @param id Id des Trading deals
-
+     * @param cardToTrade at.reisinger.Card die getauscht werden soll
-    public User getTradingUser() {
+     * @param type ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
-        return this.tradingUser;
+     *             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;
     }
@@ -46,6 +102,7 @@ public class TradingDeal {
      * Req Element type holen
      * @return Req Element Type
      */
+    @JsonGetter
     public ElementTyp getRequiredElementType() {
         return this.requiredElementType;
     }
@@ -54,6 +111,7 @@ public class TradingDeal {
      * Req min damage holen
      * @return Req min damage
      */
+    @JsonGetter
     public double getRequiredMinDamage() {
         return this.requiredMinDamage;
     }
@@ -62,6 +120,7 @@ public class TradingDeal {
      * Hole req cardtype
      * @return Req at.reisinger.CardType
      */
+    @JsonGetter
     public CardType getRequiredCardType() {
         return this.requiredCardType;
     }
@@ -78,6 +137,7 @@ public class TradingDeal {
      * Setzt die Karte die Getradet werden soll
      * @param cardToTrade at.reisinger.Card zum tauschen
      */
+    @JsonSetter
     public void setCardToTrade(Card cardToTrade) {
         this.cardToTrade = cardToTrade;
     }
@@ -86,6 +146,7 @@ public class TradingDeal {
      * Setzt req elementType
      * @param requiredElementType Der Req elementType
      */
+    @JsonSetter
     public void setRequiredElementType(ElementTyp requiredElementType) {
         this.requiredElementType = requiredElementType;
     }
@@ -94,6 +155,7 @@ public class TradingDeal {
      * Setzt die req Min damage
      * @param requiredMinDamage Die req min gamage
      */
+    @JsonSetter
     public void setRequiredMinDamage(double requiredMinDamage) {
         this.requiredMinDamage = requiredMinDamage;
     }
@@ -102,6 +164,7 @@ public class TradingDeal {
      * Setzt req cardType
      * @param requiredCardType Der Req at.reisinger.CardType
      */
+    @JsonSetter
     public void setRequiredCardType(CardType requiredCardType) {
         this.requiredCardType = requiredCardType;
     }

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

@@ -8,9 +8,9 @@ import java.util.ArrayList;
  * at.reisinger.User & at.reisinger.Store Logik
  */
 @JsonAutoDetect
-public class User implements Store{
+public class User{
     @JsonProperty
-    private String name, nachname, email;
+    private String name, nachname, email, bio, image;
     /*
     @JsonProperty
     private Stack stack;
@@ -42,16 +42,54 @@ public class User implements Store{
     }
 */
     @JsonCreator
-    public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Coins coins) {
+    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 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
@@ -199,15 +237,16 @@ public class User implements Store{
     /**
      * Fügt dem at.reisinger.Store einen neuen Tradingdeal hinzu
      * @param tradingDeal Der neue Tradingdeal
-     */
+     *
     public void addTradingDeal(TradingDeal tradingDeal) {
         new DBConnection().addTradingDeal(tradingDeal);
     }
 
+
     /**
      * Holt alle verfügbaren Tradingdeals
      * @return Alle verfügbaren Deals
-     */
+     *
     public ArrayList<TradingDeal> getTradingDeals() {
         return new DBConnection().getAllTradingDeals();
     }
@@ -237,7 +276,7 @@ public class User implements Store{
      * 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 = new DBConnection().getAllTradingDeals();
@@ -251,6 +290,7 @@ public class User implements Store{
         return possible;
     }
 
+    */
     /**
      * Checkt ob es sich um den selben at.reisinger.User handelt
      * @param toCheck Mit diesem at.reisinger.User wird verglichen

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

@@ -1,7 +1,6 @@
 package at.reisinger.server;
 
 import at.reisinger.DBConnection;
-import at.reisinger.server.msg.MsgHandler;
 import at.reisinger.server.objects.Request;
 import at.reisinger.server.objects.Response;
 
@@ -17,7 +16,6 @@ public class Main {
     static final int port = 80;
     private Socket socket;
     private int id;
-    private MsgHandler msgHandler;
 
     /**
      * Initial Start
@@ -58,7 +56,9 @@ public class Main {
         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());
+            System.out.println("req done");
+            new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload());
+            System.out.println("res done");
             //this.msgHandler = rp.getMsghandler();
             this.socket.close();
             System.out.println("Socket von Client #" + this.id + " wurde geschlossen!");

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

@@ -3,11 +3,13 @@ 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;
 
 /**
@@ -23,21 +25,21 @@ public class JsonHelper {
      */
     public static String packageListToJson(ArrayList<Card> listCards, String name){
         Package packageCards = new Package(new Cards(listCards),name, 5);
-        return packageToJson(packageCards);
+        return objToJson(packageCards);
     }
 
     /**
      * Wandelt ein Package Objekt in ein Json um
-     * @param packageCards Package Objekt das in ein Json umgewandelt werden soll
+     * @param obj Objekt das in ein Json umgewandelt werden soll
      * @return Json String des Packages
      */
-    public static String packageToJson(Package packageCards){
+    public static String objToJson(Object obj){
         ObjectMapper objectMapper = new ObjectMapper();
         objectMapper = new ObjectMapper();
         String packageJson = "";
-        if(packageCards != null) {
+        if(obj != null) {
             try {
-                packageJson += objectMapper.writeValueAsString(packageCards);
+                packageJson += objectMapper.writeValueAsString(obj);
             } catch (JsonProcessingException e) {
                 packageJson = "Error: JsonProcessingException -> " + e.getMessage();
             }
@@ -47,7 +49,50 @@ public class JsonHelper {
         }
     }
 
-    public static Map<String, Object> jsonPayload2ToMap(String payload){
+    /**
+     * 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>>(){});
@@ -57,4 +102,9 @@ public class JsonHelper {
         }
     }
 
+    @Deprecated
+    public static String userToJson(User user){
+        return objToJson(user);
+    }
+
 }

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

@@ -34,9 +34,8 @@ public class PostgresHelper {
      * @return True bei erfolg, sonst false
      */
     public static boolean executeUpdateMessage(String sql, String message){
-        boolean tmp = executeUpdate(sql);
         System.out.println(message);
-        return tmp;
+        return executeUpdate(sql);
     }
 
     /**

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

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

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

@@ -1,37 +0,0 @@
-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

@@ -65,16 +65,24 @@ public class Request {
             headers.add(header);
         }
 
-        int authIndex = headers.toString().indexOf("Authorization");
-        String authString = headers.toString().substring(authIndex + 21);
-        int authIndexEnd = authString.indexOf(',');
-        authString = authString.substring(0, authIndexEnd);
 
-        this.authString = authString;
 
         String accessLog = String.format("Client %s, method %s, path %s, version %s, host %s, headers %s",
                 socket.toString(), method, path, version, host, headers.toString());
         System.out.println(accessLog);
+        if(headers.toString().contains("Authorization: Basic")) {
+            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;
+        }else{
+            this.authString = null;
+        }
     }
 
     /**

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

@@ -3,7 +3,7 @@ package at.reisinger.server.objects;
 import at.reisinger.*;
 import at.reisinger.Package;
 import at.reisinger.server.helper.JsonHelper;
-import at.reisinger.server.msg.MsgHandler;
+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;
@@ -47,10 +47,13 @@ public class Response {
         this.cmd = cmd;
         this.out = out;
         this.payload = payload;
-        System.out.println(cmd);
         if (this.url != null) {
             if (this.cmd.equals("GET")) {
-                getMethodes();
+                if(login()) {
+                    getMethodes();
+                }else{
+                    sendError("401");
+                }
             }else if (this.cmd.equals("POST")){
                 try {
                     postMethodes();
@@ -58,18 +61,88 @@ public class Response {
                     e.printStackTrace();
                 }
             }else if (this.cmd.equals("PUT")){
-                putMethodes();
+                if(login()) {
+                    putMethodes();
+                }else{
+                    sendError("401");
+                }
             }else if (this.cmd.equals("DELETE")){
-                deleteMethodes();
+                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("/messages")) {
+        if (this.url.startsWith("/users")) {
-        } else if (this.url.startsWith("/")) {
+            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");
         }
     }
 
@@ -96,10 +169,8 @@ public class Response {
      */
     private String basicAuthBase64(String username, String password){
         String authString = username + ":" + password;
-        //System.out.println("auth string: " + authString);
         byte[] authEncBytes = Base64.getEncoder().encode(authString.getBytes());
         String authStringEnc = new String(authEncBytes);
-        //System.out.println("Base64 encoded auth string: " + authStringEnc);
         return authStringEnc;
     }
 
@@ -110,13 +181,10 @@ public class Response {
      */
     private String basicAuthGetUsername(String authString) {
         String[] values;
-        System.out.println("auth To username");
         if (authString != null) {
             byte[] credDecoded = Base64.getDecoder().decode(authString);
             String credentials = new String(credDecoded);
             values = credentials.split(":", 2);
-            System.out.println("credentials:   ");
-            System.out.println(values[0]);
         }else{
             values = null;
         }
@@ -125,36 +193,30 @@ public class Response {
 
     /**
      * 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.jsonPayload2ToMap(this.payload);
+            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));
+            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(username, password, username, "not implemented")){
+            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);;
-            //User to json
+            if(userJson != null) {
-            ObjectMapper objectMapper = new ObjectMapper();
-            objectMapper = new ObjectMapper();
-            String userJson = "";
-            if(newUser != null) {
-                try {
-                    userJson += objectMapper.writeValueAsString(newUser);
-                } catch (JsonProcessingException e) {
-                    userJson = "Error: JsonProcessingException -> " + e.getMessage();
-                }
                 sendResponse(userJson, "201");
             }else{
                 sendError("500");
             }
         }else if (this.url.startsWith("/sessions")) {
-            Map<String, Object> map = JsonHelper.jsonPayload2ToMap(this.payload);
+            Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
             String username = (String) map.get("Username");
             String password = (String) map.get("Password");
             User user = null;
@@ -173,41 +235,256 @@ public class Response {
                 sendError("401");
             }
         }else if (this.url.startsWith("/packages")) {
-            if(basicAuth("admin", "admin", this.authString)){
+            if (basicAuth("admin", "istrator", this.authString)) {
                 ObjectMapper objectMapper = new ObjectMapper();
-                ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<ArrayList<Card>>(){});
+                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)){
+                Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5);
+                if (!new DBConnection().addPackage(packageCards)) {
                     sendError("500");
-                }else{
+                } else {
-                    String packageJson = JsonHelper.packageToJson(packageCards);
+                    String packageJson = JsonHelper.objToJson(packageCards);
-                    if(packageJson != null) {
+                    if (packageJson != null) {
                         sendResponse(packageJson, "201");
-                    }else{
+                    } else {
                         sendError("500");
                     }
                 }
-            }else{
+            } else {
                 sendError("401");
             }
         }else if (this.url.startsWith("/transactions/packages")) {
-            if(login()){
+            if (login()) {
                 DBConnection db = new DBConnection();
                 Package newPackage = db.userAcquirePackage(basicAuthGetUsername(this.authString));
-                if (newPackage == null){
+                if (newPackage == null) {
                     sendError("500");
-                }else{
+                } else {
-                    String packageJson = JsonHelper.packageToJson(newPackage);
+                    String packageJson = JsonHelper.objToJson(newPackage);
-                    if(packageJson == null){
+                    if (packageJson == null) {
                         sendError("500");
-                    }else {
+                    } else {
                         sendResponse(packageJson, "200");
                     }
                 }
             }else{
                 sendError("401");
             }
+        }else if (this.url.startsWith("/tradings")) {
+            if(login()) {
+                String dotradeid = this.url.substring(this.url.lastIndexOf('/') + 1);
+                System.out.println("DO TradeID in /tradings/{tradeID}: " + dotradeid);
+                if (!dotradeid.isEmpty() && dotradeid != null && !dotradeid.equals("tradings")) {
+                    //DO TRADE
+                    String username = basicAuthGetUsername(this.authString);
+                    if (username != null && !username.isEmpty()) {
+                        System.out.println(this.payload);
+                        ArrayList<TradingDeal> tradingDealArrayList = new DBConnection().getAllTradingDeals();
+                        TradingDeal tradingDeal = null;
+                        if (tradingDealArrayList != null && !tradingDealArrayList.isEmpty()) {
+                            for (TradingDeal tr : tradingDealArrayList) {
+                                if (tr.getId().equals(dotradeid)) {
+                                    tradingDeal = tr;
+                                }
+                            }
+                            Card card = new DBConnection().getCardFromID(this.payload);
+                            if (card != null) {
+                                if (tradingDeal != null) {
+                                    if (tradingDeal.cardOk(card)) {
+                                        String json = JsonHelper.objToJson(card);
+                                        if (json != null && !json.isEmpty()) {
+                                            if (new DBConnection().addUserCard(username, tradingDeal.getCardToTrade().getName())) {
+                                                if (new DBConnection().delUserCard(tradingDeal.getUsername(), tradingDeal.getCardToTrade().getName())) {
+                                                    if (new DBConnection().deleteTradingDeal(tradingDeal.getId())) {
+                                                        if (new DBConnection().delUserCard(username, card.getName())) {
+                                                            if (new DBConnection().addUserCard(tradingDeal.getUsername(), card.getName())) {
+                                                                sendResponse(json, "200");
+                                                            } else {
+                                                                sendError("500");
+                                                            }
+                                                        } else {
+                                                            sendError("500");
+                                                        }
+                                                    } else {
+                                                        sendError("500");
+                                                    }
+                                                } else {
+                                                    sendError("500");
+                                                }
+                                            } else {
+                                                sendError("500");
+                                            }
+                                        } else {
+                                            sendError("500");
+                                        }
+                                    } else {
+                                        sendError("500");
+                                    }
+                                } else {
+                                    sendError("500");
+                                }
+                            } else {
+                                sendError("500");
+                            }
+                        } else {
+                            sendError("500");
+                        }
+                    } else {
+                        sendError("401");
+                    }
+                } else {
+                    //CREATE TRADING DEAL
+                    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 if (this.url.startsWith("/battle")) {
+            if(login()){
+                String username = basicAuthGetUsername(this.authString);
+                if (username != null && !username.isEmpty()) {
+                    List<String> deckNamen = new DBConnection().getDeck(username);
+                    if (deckNamen != null && !deckNamen.isEmpty()) {
+                        Cards deck = new DBConnection().getCardsFromIDList(deckNamen);
+                        if(deck != null && deck.getCards().size() == 4) {
+                            Battle openBattle = new DBConnection().getOpenBattle();
+                            if (openBattle == null) {
+                                //Creator player Mode
+                                if(new DBConnection().addBattle(username)){
+                                    sendResponse("Du bist: #PLAYER 1\nBattle Einladung wurde erstellt von: " + username + "(#PLAYER1) \nSobald ein 2. Spieler dem Battle beitritt, kann das ergebnis mit /score abgefragt werden.","200");
+                                }else {
+                                    sendError("500");
+                                }
+
+                            } else {
+                                //Join game player
+                                try {
+                                    User player2 = new DBConnection().getUser(username);
+                                    if(player2 != null){
+                                        openBattle.setPlayer2(player2);
+                                        openBattle.setDeckPlayer2(deck);
+                                        if(new DBConnection().delBattleEinladung(openBattle.getId() + "")){
+                                            openBattle.doFight();
+                                            System.out.println(JsonHelper.objToJson(openBattle.getLog()));
+                                            if(new DBConnection().addBattleLog(openBattle.getId()+"", openBattle.getPlayer1().getName(), openBattle.getPlayer2().getName(), openBattle.getScorePlayer1()+"", openBattle.getScorePlayer2() +"")){
+                                                if(new DBConnection().delDeck(openBattle.getPlayer1().getCredentials().getUsername()) && new DBConnection().delDeck(openBattle.getPlayer2().getCredentials().getUsername())) {
+                                                    //DEL OLD DECK CARDS
+                                                    ArrayList<String> oldDeck1 = new ArrayList<String>();
+                                                    for (Card ca: openBattle.getDeckPlayer1Init().getCards()){
+                                                        oldDeck1.add(ca.getName());
+                                                    }
+                                                    ArrayList<String> oldDeck2 = new ArrayList<String>();
+                                                    for (Card ca: openBattle.getDeckPlayer2Init().getCards()){
+                                                        oldDeck2.add(ca.getName());
+                                                    }
+                                                    //DEL NEW CARDS IF EXIST
+                                                    Cards player1cards = new DBConnection().getCards(openBattle.getPlayer1().getCredentials().getUsername());
+                                                    for(Card ca:openBattle.getDeckPlayer1().getCards()){
+                                                        oldDeck1.add(ca.getName());
+                                                    }
+                                                    if(player1cards.getCards() != null && !player1cards.getCards().isEmpty()) {
+                                                        for (String ca : oldDeck1) {
+                                                            if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca)){
+                                                                sendResponse("Error Deleting user card1: " + ca, "500");
+                                                            }
+                                                        }
+                                                    }
+                                                    Cards player2cards = new DBConnection().getCards(openBattle.getPlayer2().getCredentials().getUsername());
+                                                    for(Card ca:openBattle.getDeckPlayer2().getCards()){
+                                                        oldDeck2.add(ca.getName());
+                                                    }
+                                                    if(player2cards.getCards() != null && !player2cards.getCards().isEmpty()) {
+                                                        for (String ca : oldDeck2) {
+                                                                if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca)){
+                                                                    sendResponse("Error Deleting user card2: " + ca, "500");
+                                                            }
+                                                        }
+                                                    }
+
+                                                    //ADD CARDS TO DECK
+                                                    for(Card ca : openBattle.getDeckPlayer1().getCards()){
+                                                        if(!new DBConnection().addUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){
+                                                            sendResponse("Error adding card to user1: " + ca.getName(), "500");
+                                                        }
+                                                    }
+                                                    for(Card ca : openBattle.getDeckPlayer2().getCards()){
+                                                        if(!new DBConnection().addUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){
+                                                            sendResponse("Error adding card to user2: " + ca.getName(), "500");
+                                                        }
+                                                    }
+                                                    sendResponse("Du bist: #PLAYER 2\nBattle --> " + openBattle.getPlayer1().getName() + "(#PLAYER1) |vs| " + openBattle.getPlayer2().getName() + "(#PLAYER2)\nErgebnisse unter /score abrufbar", "200");
+                                                }
+                                            }else{
+                                                sendResponse("Battle Log konnte ned geschrieben werden", "500"); //ERROR
+                                            }
+                                        }else{
+                                            sendResponse("Battle einladung konnte ned akzeptiert werden", "500"); //ERROR
+                                        }
+                                    }else{
+                                        sendResponse("GET User error", "500"); //ERROR
+                                    }
+                                } catch (SQLException throwables) {
+                                    throwables.printStackTrace();
+                                    sendResponse("GET User error", "500"); //ERROR
+                                }
+                            }
+                        }else {
+                            sendResponse("Nur "+deck.getCards().size()+" von 4 Karten im Deck. \nMach zuerst POST /deck [ID, ID, ID, ID] um dein Deck korrekt zu befüllen","424");
+                        }
+                    }else {
+                        sendResponse("Deck ist nicht gesetzt","424");
+                    }
+                }else {
+                    sendError("500");
+                }
+            }else {
+                sendError("401");
+            }
+        } else{
+            sendError("405");
         }
+
     }
 
     /**
@@ -215,37 +492,111 @@ public class Response {
      * @return True wenn login daten korrekt, sonst false
      */
     private boolean login(){
-        String username = basicAuthGetUsername(this.authString);
+        if(this.authString != null && !this.authString.isEmpty()){
-        User user = null;
+            String username = basicAuthGetUsername(this.authString);
-        DBConnection con = new DBConnection();
+            User user = null;
-        try {
+            try {
-            user = con.getUser(username);
+                user = new DBConnection().getUser(username);
-        } catch (SQLException throwables) {
+                if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){
-            throwables.printStackTrace();
+                    return true;
-            return false;
+                }else{
-        }
+                    return false;
-        if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){
+                }
-            return true;
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+                return false;
+            }
+
         }else{
             return false;
         }
     }
 
     /**
-     * Alle Put Methoden, siehe API beschreibung für genauere details
+     * Alle Put Methoden
+     * Nur für angemeldete user erreichbar
      * @throws JsonProcessingException Fehler beim de-/serialisieren
      */
     private void putMethodes(){
-        if (this.url.startsWith("/messages")) {
+        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("/messages")) {
+        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");
+                }
+            }
+
         }
     }
 

src/test/java/CardsTest.java

@@ -52,12 +52,12 @@ public class CardsTest {
 
     @Test
     void test_contains() {
-        assertTrue(cards2.containsCard(card));
+        assertTrue(cards2.containsCard(card.getName()));
     }
 
     @Test
     void test_contains2() {
-        assertFalse(cards.containsCard(newCard));
+        assertFalse(cards.containsCard(newCard.getName()));
     }
 
     @Test

src/test/java/StoreTest.java

@@ -36,18 +36,18 @@ public class StoreTest {
         Coins coins = new Coins(10);
         //at.reisinger.User
         Credentials credentials = new Credentials("username", "passwort");
-        user = new User(credentials, "name", "nachname", "email", coins);
+        user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
-        userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", coins);
+        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() {
 
@@ -66,7 +66,7 @@ public class StoreTest {
         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));
+        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));
@@ -108,7 +108,7 @@ public class StoreTest {
         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));
+        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));
@@ -136,10 +136,12 @@ public class StoreTest {
         stackArrList.add(c5);
         Cards deck = new Cards(deckArrList);
         Cards stack = new Cards(stackArrList);
-        TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "DerName", "Nachname", "Email", new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL);
+        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);
         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

@@ -36,15 +36,15 @@ public class TradingDealTest {
         //at.reisinger.User
         Credentials credentials = new Credentials("username", "passwort");
         Credentials newCredentials = new Credentials("usernamenew", "passwortnew");
-        user = new User(credentials, "name", "nachname", "email", coins);
+        user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
-        userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", coins);
+        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");
     }
 
     /*

src/test/java/UserTest.java

@@ -38,7 +38,7 @@ public class UserTest {
         Coins coins = new Coins(10);
         //at.reisinger.User
         Credentials credentials = new Credentials("username", "pw");
-        user = new User(credentials, "name", "nachname", "email", coins);
+        user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
     }
     @Test
     public void test_getName() {