doTrade /tradings

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,11 +42,11 @@ public class Card {
      */
     @JsonCreator
     public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){
-        ElementTyp tmpElement = stringToElementType(elementCardTyp);
+        ElementTyp tmpElement = EnumHelper.stringToElementType(elementCardTyp);
         if(tmpElement == null){
             tmpElement = ElementTyp.UNDEF;
         }
-        CardType tmpCard = stringToCardType(elementCardTyp);
+        CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp);
         if(tmpCard == null){
             tmpCard = CardType.UNDEF;
         }
@@ -54,31 +57,19 @@ public class Card {
     }
 
     /**
-     * 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
+     * Prüft ob die Karte gesperrt ist
+     * @return True wenn die Karte gesperrt ist
      */
-    private ElementTyp stringToElementType(String elementTypeString){
-        for (ElementTyp e : ElementTyp.values()) {
-            if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) {
-                return e;
-            }
-        }
-        return null;
+    public boolean isLocked() {
+        return locked;
     }
 
     /**
-     * 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
+     * Setzt die sperre der Karte
+     * @param locked True bedeuted gesperrt
      */
-    private CardType stringToCardType(String cardTypeString){
-        for (CardType me : CardType.values()) {
-            if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
-                return me;
-            }
-        }
-        return null;
+    public void setLocked(boolean locked) {
+        this.locked = locked;
     }
 
     /**

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

@@ -56,10 +56,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

@@ -4,6 +4,8 @@ import at.reisinger.server.helper.PostgresHelper;
 
 import java.sql.*;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Stellt die Verbindung zur "Datenbank" her
@@ -33,8 +35,197 @@ public class DBConnection {
         PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);", "Card Table created");
         PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS package(\"ID\" varchar(255) not null,name varchar(255) not null constraint name references card, i serial not null constraint package_i primary key );", "Package Table created");
         PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_cards(username TEXT not null constraint user_cards_users_username_fk references users,name text not null, gesperrt boolean not null);", "UserCards Table created");
+        PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_deck(username text not null constraint user_deck_users_username_fk references users,cardname text not null);", "UserDeck Table created");
+        PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS trading(username text not null constraint trading_users_username_fk references users,id text not null constraint trading_pk primary key, cardtotrade text not null constraint trading_card_name_fk references card, mindamage float not null,reqcardtype text not null,reqelement text not null);", "Trading Table created");
     }
 
+    /**
+     * Updated den Lock einer user card
+     * @param name Name der Card
+     * @param lock Zustand des Locks
+     * @return true bei erfolg, sonst false
+     */
+    public boolean updateCardLock(String name, boolean lock){
+        return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';");
+    }
+
+
+    /**
+     * Prüft ob eine Card für das Deck gesperrt ist
+     * @param name Name der Card die zu prüfen ist
+     * @return True falls gesperrt, ansonst false
+     * @throws SQLException Locked Cards konnten nicht aus der DB geholt werden
+     */
+    public boolean getCardLock(String name) throws SQLException {
+        this.c = PostgresHelper.con();
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        boolean locked = false;
+        stmt = this.c.createStatement();
+        ResultSet rs = stmt.executeQuery("select gesperrt from user_cards where name = \'" + name + "\';");
+        while (rs.next()) {
+            locked = rs.getBoolean("gesperrt");
+        }
+        rs.close();
+        stmt.close();
+        this.c.close();
+        System.out.println("Trading Deals pulled successfully");
+        return locked;
+    }
+
+    /**
+     * Löscht einen Trading Deal aus der Datenbank
+     * @param id Id des deals der gelöscht werden soll
+     * @return True bei erfolg, sonst false
+     */
+    public boolean deleteTradingDeal(String id){
+        return PostgresHelper.executeUpdate("delete from trading where id = \'" + id + "\';");
+    }
+
+    /**
+     * Fügt der DB einen Trading deal hinzu
+     * @param username User der den Trade hinzufügt
+     * @param id Id des Trades
+     * @param mindamage Min damage der für den trade benötigt wird
+     * @param reqcardtype Req Card Type der für den trade benötigt wird
+     * @param reqelement Req Element Typ der für den trade benötigt wird
+     * @param cardtotrade Card die zum Traden ist
+     * @return True bei erfolg, sonst false
+     */
+    public boolean addTradingdeal(String username, String id, double mindamage, String reqcardtype, String reqelement, String cardtotrade){
+        if(PostgresHelper.executeUpdate("INSERT INTO public.trading (username, id, cardtotrade, mindamage, reqcardtype, reqelement) VALUES (\'" + username + "\',\'" + id + "\',\'" + cardtotrade + "\',\'"+ mindamage + "\',\'" + reqcardtype + "\',\'" + reqelement + "\');")){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    /**
+     * Holt alle Trading Deals aus der DB
+     * @return Null bei error
+     */
+    public ArrayList<TradingDeal> getAllTradingDeals(){
+        this.c = PostgresHelper.con();
+        ArrayList<TradingDeal> tradingDeals = new ArrayList<TradingDeal>();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from trading;");
+            while (rs.next()) {
+                String username, id, cardtotrade, reqcardtype, reqelement;
+                int mindamage;
+                username = rs.getString("username");
+                id = rs.getString("id");
+                cardtotrade = rs.getString("cardtotrade");
+                reqcardtype = rs.getString("reqcardtype");
+                reqelement = rs.getString("reqelement");
+                mindamage = rs.getInt("mindamage");
+
+                Card card = new DBConnection().getCardFromID(cardtotrade);
+                if(card != null){
+                    TradingDeal tmp = new TradingDeal(id, card, mindamage, reqcardtype +reqelement, username);
+                    if (tmp != null){
+                        tradingDeals.add(tmp);
+                        System.out.println("Pulled TradingDeal");
+                    }else{
+                        return null;
+                    }
+                }else{
+                    return null;
+                }
+
+
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Trading Deals pulled successfully");
+        return tradingDeals;
+    }
+
+    /**
+     * Setzt das Deck eines Users
+     * @param username Username von dem das Deck gesetzt werden soll
+     * @param deck Die ID´s des Decks in der Form einer ArrayList<String>
+     * @return True bei erfolg, sonst false
+     */
+    public boolean setDeck(String username, List<String> deck){
+        for (String st :deck) {
+            try {
+                if(getCardLock(st)){
+                    return false;
+                }
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+                return false;
+            }
+        }
+        if (!delDeck(username)){
+            return false;
+        }
+        Cards allCards = getCards(username);
+        Cards deckCards = new Cards(new ArrayList<Card>());
+        int count = 0;
+        if(allCards != null){
+            for (String st : deck) {
+                for (Card ca: allCards.getCards()) {
+                    System.out.println("Count : " + count);
+                    System.out.println("CA: " + ca.getName() + " st: " + st);
+                    if(ca.getName().equals(st) && count < 4){
+                        deckCards.addCard(ca);
+                        if(!PostgresHelper.executeUpdateMessage("INSERT INTO public.user_deck (username, cardname) VALUES (\'"+username+"\', \'"+st+"\');", "Card #"+count+" added to Deck")){
+                            return false;
+                        }
+                    }
+                }
+                count++;
+            }
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Holt alle Card namen aus dem Deck eines Users
+     * @param username user von dem die Deck namen geholt werden soll
+     * @return null bedeuted error
+     */
+    public ArrayList<String> getDeck(String username){
+        this.c = PostgresHelper.con();
+        String cardname = "";
+        Cards allCards = new Cards(new ArrayList<Card>());
+        ArrayList<String> cardnamenarray = new ArrayList<String>();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from user_deck where username = \'" + username + "\';");
+            while (rs.next()) {
+                cardname = rs.getString("cardname");
+                cardnamenarray.add(cardname);
+                System.out.println("cardname = " + cardname);
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Deck names pulled successfully");
+        return cardnamenarray;
+    }
+
+    /**
+     * Löscht den gesammten inhalt des Decks eines users
+     * @param username Username von dem das Deck gelöscht werden soll
+     * @return True bei erfolg, sonst false
+     */
+    public boolean delDeck(String username){
+        return PostgresHelper.executeUpdateMessage("delete from user_deck where username = \'" + username + "\';", "User Deck: " + username + ", deleted");
+    }
+
+
     /**
      * Holt ein Random package aus dem Shop
      *
@@ -83,18 +274,9 @@ public class DBConnection {
                 damage = rs.getInt("damage");
                 Card newCard = new Card(cardname, elementtyp + cardtype, damage);
                 cards.addCard(newCard);
-                Connection b = PostgresHelper.con();
-                try {
-                    stmt = b.createStatement();
-                    String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + newCard.getName() + "\', \'false\');";
-                    stmt.executeUpdate(sql);
-                    stmt.close();
-                    b.close();
-                } catch (Exception e) {
-                    System.err.println(e.getClass().getName() + ": " + e.getMessage());
+                if(!addUserCard(username, newCard.getName())){
                     return null;
                 }
-                System.out.println("User got Card successfully");
             }
             rs.close();
             stmt.close();
@@ -113,6 +295,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
      *
@@ -313,31 +526,50 @@ public class DBConnection {
     }
 
     /**
-     * Holt alle Karten eines Users
-     * @param username Username des Users
-     * @return Cards Object, falls es null ist, war ein fehler
+     * 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 Cards getCards(String username){
-        this.c = PostgresHelper.con();
-        String cardname = "";
-        Cards allCards = new Cards(new ArrayList<Card>());
-        ArrayList<String> cardnamenarray = new ArrayList<String>();
+    public Card getCardFromID(String id){
+        System.out.println(id);
+        Connection b = PostgresHelper.con();
+        Card toreturn = null;
         try {
-            stmt = this.c.createStatement();
-            ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';");
+            stmt = b.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from card where NAME =  \'" + id + "\';");
             while (rs.next()) {
-                cardname = rs.getString("name");
-                cardnamenarray.add(cardname);
-                System.out.println("cardname = " + cardname);
+                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();
-            this.c.close();
+            b.close();
         } catch (Exception e) {
             System.err.println(e.getClass().getName() + ": " + e.getMessage());
-            System.exit(0);
+            return null;
         }
-        System.out.println("Card Namen pulled successfully");
+        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 {
@@ -358,14 +590,44 @@ public class DBConnection {
                 b.close();
             } catch (Exception e) {
                 System.err.println(e.getClass().getName() + ": " + e.getMessage());
-                System.exit(0);
+                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
      *

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

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
-     * @param user at.reisinger.User des Deals
+     * Ein TradingDeal wird  erstellt
+     * @param id Id des Trading deals
      * @param cardToTrade at.reisinger.Card die getauscht werden soll
      * @param requiredElementType Req ElementType für den Tausch
      * @param requiredMinDamage Req min damage für den Tausch
      * @param requiredCardType Req at.reisinger.Card Type für den Tausch
      */
-    public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) {
-        //this.tradingUser = user;
+    public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) {
+        this.id = id;
         this.cardToTrade = cardToTrade;
+        if(requiredElementType == null){
+            requiredElementType = ElementTyp.UNDEF;
+        }
+        if(requiredCardType == null) {
+            requiredCardType = CardType.UNDEF;
+        }
         this.requiredElementType = requiredElementType;
         this.requiredMinDamage = requiredMinDamage;
         this.requiredCardType = requiredCardType;
+        this.username = username;
     }
 
     /**
-     * Holt den Trading at.reisinger.User
-     * @return at.reisinger.User der den Trade erstellt hat
-
-    public User getTradingUser() {
-        return this.tradingUser;
+     * Ein TradingDeal wird  erstellt, anhand des type werden der ElementType und der CardType automatisch bestimmt
+     * @param id Id des Trading deals
+     * @param cardToTrade at.reisinger.Card die getauscht werden soll
+     * @param type ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
+     *             Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
+     */
+    @JsonCreator
+    public TradingDeal(@JsonProperty("Id") String id, @JsonProperty("CardToTrade") Card cardToTrade, @JsonProperty("MinimumDamage") double requiredMinDamage, @JsonProperty("Type") String type, String username) {
+        this(id, cardToTrade, EnumHelper.stringToElementType(type), requiredMinDamage, EnumHelper.stringToCardType(type), username);
     }
-*/
+
+    /**
+     * Holt die ID des Trading deals
+     * @return Id des Trading Deals
+     */
+    public String getId() {
+        return id;
+    }
+
+    /**
+     * Setzt die id des TradingDeals
+     * @param id Id des TradingDeals
+     */
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    /**
+     * Holt den usernamen
+     * @return Der username als String
+     */
+    @JsonGetter
+    public String getUsername() {
+        return username;
+    }
+
+    /**
+     * Setzt den usernamen
+     * @param username Der username als String
+     */
+    @JsonSetter
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+
     /**
      * at.reisinger.Card die getraded werden soll
      * @return at.reisinger.Card die getradet werden soll
      */
+    @JsonGetter
     public Card getCardToTrade() {
         return this.cardToTrade;
     }
@@ -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/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

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

@@ -9,6 +9,7 @@ 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;
 
 /**
@@ -48,6 +49,49 @@ public class JsonHelper {
         }
     }
 
+    /**
+     * 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 {
@@ -58,21 +102,9 @@ public class JsonHelper {
         }
     }
 
+    @Deprecated
     public static String userToJson(User user){
-        //User to json
-        ObjectMapper objectMapper = new ObjectMapper();
-        objectMapper = new ObjectMapper();
-        String userJson = "";
-        if(user != null) {
-            try {
-                userJson += objectMapper.writeValueAsString(user);
-            } catch (JsonProcessingException e) {
-                userJson = "Error: JsonProcessingException -> " + e.getMessage();
-            }
-            return userJson;
-        }else{
-            return null;
-        }
+        return objToJson(user);
     }
 
 }

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

@@ -4,7 +4,6 @@ import at.reisinger.*;
 import at.reisinger.Package;
 import at.reisinger.server.helper.JsonHelper;
 import at.reisinger.server.helper.PostgresHelper;
-import at.reisinger.server.msg.MsgHandler;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -111,6 +110,39 @@ public class Response {
             }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");
         }
     }
 
@@ -203,8 +235,7 @@ public class Response {
                 sendError("401");
             }
         }else if (this.url.startsWith("/packages")) {
-            if(login()) {
-                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>>() {
                 });
@@ -222,7 +253,6 @@ public class Response {
             } else {
                 sendError("401");
             }
-            }
         }else if (this.url.startsWith("/transactions/packages")) {
             if (login()) {
                 DBConnection db = new DBConnection();
@@ -237,6 +267,120 @@ public class Response {
                         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{
+                sendError("401");
             }
         }
     }
@@ -246,6 +390,7 @@ public class Response {
      * @return True wenn login daten korrekt, sonst false
      */
     private boolean login(){
+        if(this.authString != null && !this.authString.isEmpty()){
             String username = basicAuthGetUsername(this.authString);
             User user = null;
             DBConnection con = new DBConnection();
@@ -260,6 +405,9 @@ public class Response {
             }else{
                 return false;
             }
+        }else{
+            return false;
+        }
     }
 
     /**
@@ -296,6 +444,23 @@ public class Response {
             }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");
+            }
         }
     }
 
@@ -307,7 +472,28 @@ public class Response {
      * @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

@@ -44,7 +44,7 @@ public class StoreTest {
         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/TradingDealTest.java

@@ -44,7 +44,7 @@ public class TradingDealTest {
         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");
     }
 
     /*