Login Bugfix + put&get /users/{username} + get /cards

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

@@ -1,12 +1,19 @@
 package at.reisinger;
 
+import com.fasterxml.jackson.annotation.*;
+
 /**
  * Object einer at.reisinger.Card
  */
+@JsonAutoDetect
 public class Card {
+    @JsonProperty
     private String name;
+    @JsonProperty
     private double damage;
+    @JsonProperty
     private ElementTyp elementTyp;
+    @JsonProperty
     private CardType cardType;
 
     /**
@@ -23,10 +30,62 @@ public class Card {
         this.cardType = cardType;
     }
 
+    /**
+     * Erstellt eine neue Card mit, anhand des cardNamen werden der ElementType und der CardType automatisch bestimmt
+     * @param name Name der Card (ID)
+     * @param elementCardTyp ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt.
+     *                       Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null
+     * @param damage Damage der Card
+     */
+    @JsonCreator
+    public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){
+        ElementTyp tmpElement = stringToElementType(elementCardTyp);
+        if(tmpElement == null){
+            tmpElement = ElementTyp.UNDEF;
+        }
+        CardType tmpCard = stringToCardType(elementCardTyp);
+        if(tmpCard == null){
+            tmpCard = CardType.UNDEF;
+        }
+        this.name = name;
+        this.damage = damage;
+        this.elementTyp = tmpElement;
+        this.cardType = tmpCard;
+    }
+
+    /**
+     * Wenn ein String als ElementType vorhanden ist, dann gibt er den passenden ElementType zurück
+     * @param elementTypeString elementType als String
+     * @return Passender Element Type oder null falls nicht gefunden
+     */
+    private ElementTyp stringToElementType(String elementTypeString){
+        for (ElementTyp e : ElementTyp.values()) {
+            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
+     */
+    private CardType stringToCardType(String cardTypeString){
+        for (CardType me : CardType.values()) {
+            if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) {
+                return me;
+            }
+        }
+        return null;
+    }
+
     /**
      * Holt den Namen der at.reisinger.Card
      * @return Name der at.reisinger.Card
      */
+    @JsonGetter
     public String getName() {
         return this.name;
     }
@@ -35,6 +94,7 @@ public class Card {
      * Holt den Damage der at.reisinger.Card
      * @return Damage der at.reisinger.Card
      */
+    @JsonGetter
     public double getDamage() {
         return this.damage;
     }
@@ -43,6 +103,7 @@ public class Card {
      * Holt den ElementType der at.reisinger.Card
      * @return ElementType der at.reisinger.Card
      */
+    @JsonGetter
     public ElementTyp getElementTyp() {
         return this.elementTyp;
     }
@@ -51,6 +112,7 @@ public class Card {
      * Holt den at.reisinger.CardType der at.reisinger.Card
      * @return at.reisinger.CardType der at.reisinger.Card
      */
+    @JsonGetter
     public CardType getCardType() {
         return this.cardType;
     }
@@ -61,6 +123,7 @@ public class Card {
      * @return Gibt die Wirksamkeit zurück
      * @throws InternalError Wenn die Effectifeness von den 2 at.reisinger.Cards nicht berechnet werden kann
      */
+    @JsonGetter
     public EffectivnessType getEffectivenessAgainst(Card toCeck) {
         if(toCeck.getCardType() == CardType.MONSTER){
             if(this.cardType == CardType.MONSTER){
@@ -84,6 +147,7 @@ public class Card {
      * Setztden namen der at.reisinger.Card
      * @param neuerName Name der at.reisinger.Card
      */
+    @JsonSetter
     public void setName(String neuerName) {
         this.name = neuerName;
     }
@@ -92,6 +156,7 @@ public class Card {
      * Setzt den Damage der at.reisinger.Card
      * @param damage Der Damage
      */
+    @JsonSetter
     public void setDamage(int damage) {
         this.damage = damage;
     }
@@ -100,6 +165,7 @@ public class Card {
      * Setzt den ElementType der at.reisinger.Card
      * @param elementTyp Der ElementType
      */
+    @JsonSetter
     public void setElementType(ElementTyp elementTyp) {
         this.elementTyp = elementTyp;
     }

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

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

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

@@ -1,19 +1,25 @@
 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;
     }
 
@@ -23,6 +29,7 @@ public class 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 +38,7 @@ public class Cards {
      * Holt alle at.reisinger.Cards
      * @return Alle at.reisinger.Cards
      */
+    @JsonGetter
     public ArrayList<Card> getCards() {
         return this.cards;
     }

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

@@ -1,9 +1,8 @@
 package at.reisinger;
 
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.sql.Statement;
+import at.reisinger.server.helper.PostgresHelper;
+
+import java.sql.*;
 import java.util.ArrayList;
 
 /**
@@ -11,127 +10,378 @@ import java.util.ArrayList;
  * Die "Datenbank" sind hier nur beispieldaten.
  */
 public class DBConnection {
-    private ArrayList<TradingDeal> tradingDeals;
-    private ArrayList<Package> packages;
+    //private ArrayList<TradingDeal> tradingDeals;
+    //private ArrayList<Package> packages;
     private Connection c;
     private Statement stmt;
 
-    private Connection con(){
-        this.c = null;
-        try {
-            Class.forName("org.postgresql.Driver");
-            this.c = DriverManager
-                    .getConnection("jdbc:postgresql://postgres.dergeorg.at:5432/mtcg",
-                            "user", "user");
-        } catch (Exception e) {
-            e.printStackTrace();
-            System.err.println(e.getClass().getName()+": "+e.getMessage());
-            System.exit(0);
-        }
-        System.out.println("Opened database");
-        return c;
-    }
 
     /**
      * Erstellt alle Beispieldaten und simuliert somit den
      * Verbindungsaufbau zu einer DB
      */
-    public DBConnection(){
-        this.c = con();
-        System.out.println("Create Tables start");
+    public DBConnection() {
+        this.c = PostgresHelper.con();
+    }
+
+    /**
+     * Erstellt alle Tabellen die für den Betrieb der Software bennötigt werden
+     */
+    public void init() {
+        PostgresHelper.executeUpdateMessage("CREATE TABLE IF NOT EXISTS USERS (username TEXT PRIMARY KEY NOT NULL, nachname TEXT NOT NULL, email TEXT NOT NULL, password TEXT NOT NULL, bio TEXT, image TEXT, coins integer default 20 not null)", "User Table created");
+        PostgresHelper.executeUpdate("CREATE TABLE IF NOT EXISTS CARD(NAME TEXT not null,DAMAGE FLOAT not null,ELEMENTTYP TEXT not null,CARDTYPE TEXT not null, PRIMARY KEY (\"name\"));");
+        PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);", "Card Table created");
+        PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS package(\"ID\" varchar(255) not null,name varchar(255) not null constraint name references card, i serial not null constraint package_i primary key );", "Package Table created");
+        PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_cards(username TEXT not null constraint user_cards_users_username_fk references users,name text not null, gesperrt boolean not null);", "UserCards Table created");
+    }
+
+    /**
+     * Holt ein Random package aus dem Shop
+     *
+     * @param username User der das Package haben möchte
+     * @return Das Package aus dem Shop, null falls ein Fehler auftritt
+     */
+    public Package userAcquirePackage(String username) {
+        int coins = checkCoins(username);
+        if (!(coins - 5 >= 0)) {
+            return null;
+        }
+        updateCoins(coins - 5, username);
+
+        this.c = PostgresHelper.con();
+        String id = "";
         try {
-            createTables();
-        } catch (SQLException throwables) {
-            throwables.printStackTrace();
-        }
-        /*
-        Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER);
-        Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL);
-        Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER);
-        Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL);
-        Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER);
-        ArrayList<Card> deckArrList = new ArrayList<Card>();
-        ArrayList<Card> stackArrList = new ArrayList<Card>();
-        deckArrList.add(c1);
-        deckArrList.add(c2);
-        stackArrList.add(c3);
-        stackArrList.add(c4);
-        stackArrList.add(c5);
-        Cards deck = new Cards(deckArrList);
-        Cards stack = new Cards(stackArrList);
-        User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000));
-        this.tradingDeals = new ArrayList<TradingDeal>();
-        this.packages = new ArrayList<Package>();
-        this.tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER));
-        this.packages.add(new Package(stack, "Test at.reisinger.Package", 100));
-        */
-    }
-
-    private void createTables() throws SQLException {
-        this.c = con();
-        try{
-        stmt = this.c.createStatement();
-        String sql = "CREATE TABLE IF NOT EXISTS USERS " +
-                "(username       TEXT PRIMARY KEY     NOT NULL," +
-                " nachname           TEXT    NOT NULL, " +
-                " email            TEXT     NOT NULL, " +
-                " password        TEXT NOT NULL)";
-        stmt.executeUpdate(sql);
-        stmt.close();
-        this.c.close();
-        } catch ( Exception e ) {
-            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
-            System.exit(0);
-        }
-        System.out.println("User Table created");
-    }
-
-    public boolean addUser(String username, String password, String nachname, String email){
-        this.c = con();
-        try{
             stmt = this.c.createStatement();
-            String sql = "INSERT INTO users (username, nachname, email, password) values (\'" + username +"\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\')";
-            System.out.println(sql);
-            stmt.executeUpdate(sql);
+            ResultSet rs = stmt.executeQuery("select \"ID\" as id from package LIMIT 1;");
+            while (rs.next()) {
+                id = rs.getString("id");
+            }
+            rs.close();
             stmt.close();
             this.c.close();
-        } catch ( Exception e ) {
-            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Package selected successfully");
+        this.c = PostgresHelper.con();
+        String packagename = "", cardname = "", elementtyp = "", cardtype = "";
+        int zeilennummer = 0, damage = 0;
+        Cards cards = new Cards(new ArrayList<Card>());
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select  i as zeilennummer,  package.\"ID\" as id, package.name as packagename, c.name as cardname, c.DAMAGE as damage, c.ELEMENTTYP as elementtyp, c.CARDTYPE as cardtype from package join card c on c.name = package.name where \"ID\" = \'" + id + "\';");
+            int count = 0;
+            while (rs.next()) {
+                System.out.println(count++);
+                zeilennummer = rs.getInt("zeilennummer");
+                id = rs.getString("id");
+                packagename = rs.getString("packagename");
+                cardname = rs.getString("cardname");
+                elementtyp = rs.getString("elementtyp");
+                cardtype = rs.getString("cardtype");
+                damage = rs.getInt("damage");
+                Card newCard = new Card(cardname, elementtyp + cardtype, damage);
+                cards.addCard(newCard);
+                Connection b = PostgresHelper.con();
+                try {
+                    stmt = b.createStatement();
+                    String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + newCard.getName() + "\', \'false\');";
+                    stmt.executeUpdate(sql);
+                    stmt.close();
+                    b.close();
+                } catch (Exception e) {
+                    System.err.println(e.getClass().getName() + ": " + e.getMessage());
+                    return null;
+                }
+                System.out.println("User got Card successfully");
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("Package pulled successfully");
+        deletePackage(id);
+
+        if (cards.getCards().size() != 0 && cards != null) {
+            return new Package(cards, packagename, 5);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Löscht ein Package anhand des Namens
+     *
+     * @param name Name des Packages das gelöscht werden soll
+     * @return True bei erfolg, sonst false
+     */
+    public boolean deletePackage(String name) {
+        return PostgresHelper.executeUpdateMessage("DELETE FROM package WHERE \"ID\" = \'" + name + "\';", "Package deleted successfully");
+    }
+
+
+    /**
+     * Coins setzten
+     *
+     * @param coins Anzahl die zu setzten ist
+     * @return True bei erfolg, sonst false
+     */
+    public boolean updateCoins(int coins, String username) {
+        return PostgresHelper.executeUpdateMessage("UPDATE users SET coins = " + coins + " WHERE username = \'" + username + "\';", "Coins Updated");
+    }
+
+    /**
+     * Gibt die Anzahl an verfügbaren coins zurück
+     *
+     * @return Anzahl der Coins, -1 ist error
+     */
+    public int checkCoins(String username) {
+        System.out.println("Check coin start");
+        this.c = PostgresHelper.con();
+        int coins = 0;
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("Select coins from users where username = \'" + username + "\';");
+            while (rs.next()) {
+                coins = rs.getInt("coins");
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.out.println("check soin error");
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return -1;
+        }
+        System.out.println("\nCoins: " + coins);
+        return coins;
+    }
+
+    /**
+     * Überprüft anhand des Namen der Karte, ob es schon eine solche Karte gibt
+     *
+     * @param name Name der zu prüfen ist
+     * @return True falls die Karte bereits existiert
+     */
+    public boolean cardExists(String name) {
+        this.c = PostgresHelper.con();
+        int count = 0;
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select count(*) from card where name = \'" + name + "\';");
+            while (rs.next()) {
+                count = rs.getInt("count");
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            System.exit(0);
+        }
+        if (count == 1) {
+            return true;
+        } else {
             return false;
         }
-        System.out.println("User added");
+    }
+
+    /**
+     * Fügt eine Karte der DB hinzu
+     *
+     * @param card Card die hinzugefügt werden soll
+     * @return true bei erfolg, false bei error
+     */
+    public boolean addCard(Card card) {
+        return PostgresHelper.executeUpdateMessage("insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values (\'" + card.getName() + "\',\'" + card.getDamage() + "\',\'" + card.getElementTyp().name() + "\',\'" + card.getCardType().name() + "\')", "Card added");
+    }
+
+    /**
+     * Ermittelt die nächste Package ID
+     *
+     * @return Die Nächste Package id, wenn 0, dann ist ein error
+     */
+    public int nextPackageId() {
+        this.c = PostgresHelper.con();
+        String id = "";
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select max(\"ID\") from package;");
+            while (rs.next()) {
+                id = rs.getString("max");
+            }
+            if (id == null) {
+                id = "0";
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return 0;
+        }
+        return Integer.parseInt(id) + 1;
+    }
+
+    /**
+     * Fügt eine Package der DB hinzu,
+     * wenn eine Karte aus dem Package noch nicht in der Db ist,
+     * dann wird es automatisch hinzugefuegt
+     *
+     * @param pack Pack welches hinzugefügt werden soll
+     * @return True bei erfolg, false bei fehler
+     */
+    public boolean addPackage(Package pack) {
+        for (Card ca : pack.getCards()) {
+            if (!cardExists(ca.getName())) {
+                if (!addCard(ca)) {
+                    return false;
+                }
+            }
+            if(!PostgresHelper.executeUpdateMessage("INSERT INTO package (\"ID\", \"name\") values (\'" + pack.getName() + "\',\'" + ca.getName() + "\');", "Card zu Package hinzugefügt")){
+                return false;
+            }
+        }
         return true;
     }
 
     /**
-     * Holt alle verfügbaren TradingDeals
-     * @return Alle Trading Deals
+     * Fügt einen User der DB hinzu
+     *
+     * @param username Username des Users
+     * @param password Passwort des Users
+     * @param nachname nachname des Users
+     * @param email    Email des Users
+     * @return True wenn alles erfolgreich war, false wenn es nicht erfolgreich war
      */
-    public ArrayList<TradingDeal> getAllTradingDeals(){
+    public boolean addUser(String username, String password, String nachname, String email, String bio, String image) {
+        return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password, bio, image) values (\'" + username + "\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\',\'" + bio + "\',\'" + image + "\')", "User added");
+    }
+
+    /**
+     * Updated den Nachnamen, Bio und das Image eines Users mit gegebenen usernamen
+     * @param username User der geändert werden soll
+     * @param bio Neue BIO
+     * @param image Neues Image
+     * @param name Neuer Nachname
+     * @return True bei erfolg, sonst false
+     */
+    public boolean updateUser(String username, String bio, String image, String name){
+        System.out.println("UPDATE public.users SET nachname = \'"+ name+"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
+        return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = \'"+ name+"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
+    }
+    /**
+    private boolean updateUser(String username, String name, String bio, String image){
+        return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = \'"+ name +"\', bio = \'"+bio+"\', image = \'"+image+"\' WHERE username LIKE \'"+username+"\' ESCAPE \'#\'");
+    }
+
+    /**
+     * Sucht einen User anhand des Usernamens.
+     * Gibt ein User Objekt zurück
+     *
+     * @param uname Username der zu suchen ist
+     * @return User als User Objekt, null bei fehler
+     * @throws SQLException Fehler bei der Suche in der DB
+     */
+    public User getUser(String uname) throws SQLException {
+        this.c = PostgresHelper.con();
+        String username = "", password = "", email = "", nachname = "", bio="", image="";
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("SELECT * FROM users where username = \'" + uname + "\';");
+            while (rs.next()) {
+                username = rs.getString("username");
+                nachname = rs.getString("nachname");
+                email = rs.getString("email");
+                password = rs.getString("password");
+                bio = rs.getString("bio");
+                image = rs.getString("image");
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+        System.out.println("User pulled successfully");
+        return new User(new Credentials(username, password), username, username, email, new Coins(20), bio, image);
+    }
+
+    /**
+     * Holt 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 = "";
+        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");
+                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());
+            System.exit(0);
+        }
+        System.out.println("Card Namen pulled successfully");
+        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());
+                System.exit(0);
+            }
+            System.out.println("Card pulled successfully");
+        }
+
+        return allCards;
+    }
+
+    /**
+     * Holt alle verfügbaren TradingDeals
+     *
+     * @return Alle Trading Deals
+
+    public ArrayList<TradingDeal> getAllTradingDeals() {
         return this.tradingDeals;
     }
 
-    /**
-     * Holt alle verfügbaren Packages
-     * @return Alle Packages
-     */
-    public ArrayList<Package> getAllPackages(){
-        return this.packages;
-    }
-
     /**
      * Fügt einen neuen Tradingdeal zum at.reisinger.Store hinzu
+     *
      * @param tradingDeal Der neue Deal
-     */
-    public void addTradingDeal(TradingDeal tradingDeal){
+
+    public void addTradingDeal(TradingDeal tradingDeal) {
         this.tradingDeals.add(tradingDeal);
     }
-
-//    /**
-//     * Fügt ein neues at.reisinger.Package zu dem at.reisinger.Store hinzu
-//     * @param packageDeal Das neue at.reisinger.Package
-//     */
-//    public void addPackage(at.reisinger.Package packageDeal){
-//        this.packages.add(packageDeal);
-//    }
+*/
 }

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

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

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

@@ -1,10 +1,15 @@
 package at.reisinger;
 
+import com.fasterxml.jackson.annotation.*;
+
 /**
  * at.reisinger.Package besteht aus 4 Karten. Ist eine Erweiterung der at.reisinger.Cards, zeigt für 4 at.reisinger.Cards den Preis und einen Packagenamen an
  */
+@JsonAutoDetect
 public class Package extends Cards{
+    @JsonProperty
     private String name;
+    @JsonProperty
     private int price;
 
     /**
@@ -13,7 +18,8 @@ public class Package extends Cards{
      * @param name Name des Packages
      * @param price Price des Packages
      */
-    public Package(Cards stack, String name, int price) {
+    @JsonCreator
+    public Package(@JsonProperty Cards stack,@JsonProperty String name,@JsonProperty int price) {
         super(stack.getCards());
         this.name = name;
         this.price = price;
@@ -23,6 +29,7 @@ public class Package extends Cards{
      * Holt den namen des Packages
      * @return Name des Packages
      */
+    @JsonGetter
     public String getName() {
         return this.name;
     }
@@ -31,6 +38,7 @@ public class Package extends Cards{
      * Holt den Preis des Packages
      * @return Preis des Packages
      */
+    @JsonGetter
     public int getPrice() {
         return this.price;
     }
@@ -39,6 +47,7 @@ public class Package extends Cards{
      * Setzt den Namen des Packages
      * @param neuName Neuer name des Packages
      */
+    @JsonSetter
     public void setName(String neuName) {
         this.name = neuName;
     }

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

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

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

@@ -8,18 +8,20 @@ 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;
+    */
     //private DBConnection db;
     @JsonProperty
     private Credentials credentials;
     @JsonProperty
     private Coins coins;
 
-    /**
+    /*
      * Erstellt einen neuen at.reisinger.User
      * @param credentials Zugangsdaten des Users
      * @param name Name des Users
@@ -27,7 +29,7 @@ public class User implements Store{
      * @param email Email des Users
      * @param stack Alle Karten des Users
      * @param coins Alle Münzen des Users
-     */
+
     @JsonCreator
     public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Stack stack,@JsonProperty Coins coins) {
         this.credentials = credentials;
@@ -38,22 +40,60 @@ public class User implements Store{
         this.coins = coins;
         //this.db = new at.reisinger.DBConnection();
     }
-
+*/
     @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.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
-     */
+
     @JsonGetter
     public Stack getStack() {
         return stack;
@@ -62,7 +102,7 @@ public class User implements Store{
     /**
      * Setzt den at.reisinger.Stack eines Users
      * @param stack Der neue at.reisinger.Stack des Users
-     */
+
     @JsonSetter
     public void setStack(Stack stack) {
         this.stack = stack;
@@ -197,25 +237,31 @@ 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();
     }
 
+    @Override
+    public boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2) {
+        return false;
+    }
+
     /**
      * Startet ein Trading zw 2 TradingDeals
      * @param myTradingDeal Wenn der Deal passt, wird diese Karte aus dem at.reisinger.Stack entfernt
      * @param storeTradingDeal Wenn der Deal passt, wird diese Karte dem at.reisinger.Stack hinzugefügt
      * @return True wenn erfolgreich, False wenn die Deals nicht zusammenpassen
-     */
+
     public boolean doTrading(TradingDeal myTradingDeal, TradingDeal storeTradingDeal) {
         if (storeTradingDeal.dealOk(myTradingDeal)){
             stack.delCard(myTradingDeal.getCardToTrade());
@@ -224,12 +270,13 @@ public class User implements Store{
         }
         return false;
     }
+    */
 
     /**
      * Gibt alle Möglichen Trading Deals zurück
      * @param toTrade Prüft nach diesem Deal
      * @return
-     */
+     *
     @Override
     public ArrayList<TradingDeal> getPossibleTradingDeals(Card toTrade) {
         ArrayList<TradingDeal> storeList = new DBConnection().getAllTradingDeals();
@@ -243,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,5 +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;
@@ -23,8 +24,11 @@ public class Main {
      * @param args Nicht Verwendet
      */
     public static void main(String[] args) {
-        System.out.println("Starte Server auf Port 80");
+        System.out.println("DB init");
+        new DBConnection().init();
+        System.out.println("\n\nStarte Server auf Port " + port + "\n\n");
         new Main(port);
+
     }
 
     /**
@@ -54,7 +58,7 @@ 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(), null, rq.getPayload());
+            Response rp = new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload());
             //this.msgHandler = rp.getMsghandler();
             this.socket.close();
             System.out.println("Socket von Client #" + this.id + " wurde geschlossen!");

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

@@ -1,7 +1,78 @@
 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.Map;
+
+/**
+ * Hilfsfunktionen für Jackson Json
+ */
 public class JsonHelper {
 
+    /**
+     * Wandelt ein Package in form einer ArrayList<Card> om ein Json um
+     * @param listCards Cards die in dem Json stehen sollen
+     * @param name Name des Packages
+     * @return Json String des Packages
+     */
+    public static String packageListToJson(ArrayList<Card> listCards, String name){
+        Package packageCards = new Package(new Cards(listCards),name, 5);
+        return objToJson(packageCards);
+    }
 
+    /**
+     * Wandelt ein Package Objekt in ein Json um
+     * @param obj Objekt das in ein Json umgewandelt werden soll
+     * @return Json String des Packages
+     */
+    public static String objToJson(Object obj){
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper = new ObjectMapper();
+        String packageJson = "";
+        if(obj != null) {
+            try {
+                packageJson += objectMapper.writeValueAsString(obj);
+            } catch (JsonProcessingException e) {
+                packageJson = "Error: JsonProcessingException -> " + e.getMessage();
+            }
+            return packageJson;
+        }else{
+            return null;
+        }
+    }
+
+    public static Map<String, Object> jsonPayloadToMap(String payload){
+        ObjectMapper objectMapper = new ObjectMapper();
+        try {
+            return objectMapper.readValue(payload, new TypeReference<Map<String,Object>>(){});
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    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;
+        }
+    }
 
 }

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

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

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

@@ -21,6 +21,7 @@ public class Request {
     private String       url;
     private final StringBuilder rqBuilder;
     private String payload;
+    private String authString;
 
     /**
      * Get Request
@@ -64,12 +65,25 @@ 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);
     }
 
-
+    /**
+     * Auth Header
+     * @return get Auth Header
+     */
+    public String getAuthString() {
+        return authString;
+    }
 
     /**
      * Get PrintStream --> Output

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

@@ -1,12 +1,21 @@
 package at.reisinger.server.objects;
 
 import at.reisinger.*;
+import at.reisinger.Package;
+import at.reisinger.server.helper.JsonHelper;
+import at.reisinger.server.helper.PostgresHelper;
 import at.reisinger.server.msg.MsgHandler;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.postgresql.shaded.com.ongres.scram.common.bouncycastle.pbkdf2.Pack;
 
 import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -21,8 +30,7 @@ public class Response {
     private String       cmd;
     private String       url;
     private String payload;
-    private MsgHandler msgHandler;
-    private StringBuilder rqBuilder;
+    private String authString;
 
     /**
      * Nimmt die Daten des requests und generiert eine Response
@@ -30,21 +38,23 @@ public class Response {
      * @param url Request Url
      * @param cmd Request CMD
      * @param out out Print Stream
-     * @param msgHandler Der MsgHandler
+     * @param authString Der MsgHandler
      * @param payload Payload des Requests
      */
-    public Response(int id, String url, String cmd, PrintStream out, MsgHandler msgHandler, String payload){
+    public Response(int id, String url, String cmd, PrintStream out, String authString, String payload){
         this.id = id;
-        this.msgHandler = msgHandler;
+        this.authString = authString;
         this.url = url;
         this.cmd = cmd;
         this.out = out;
         this.payload = payload;
-        this.rqBuilder = new StringBuilder();
-        System.out.println(cmd);
         if (this.url != null) {
             if (this.cmd.equals("GET")) {
-                getMethodes();
+                if(login()) {
+                    getMethodes();
+                }else{
+                    sendError("401");
+                }
             }else if (this.cmd.equals("POST")){
                 try {
                     postMethodes();
@@ -52,89 +62,253 @@ 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")) {
-            String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1);
-            System.out.println("Last Bit: " + lastBit);
-            if(lastBit.equals("messages")){
-                listAllMsg();
-            }else{
-                String message = msgHandler.getMsg(Integer.parseInt(lastBit)).getMsg();
-                if(message == null){
-                    sendError("404");
-                }else {
-                    sendResponse(message, "200");
-                }
+        if (this.url.startsWith("/users")) {
+            String username = this.url.substring(this.url.lastIndexOf('/') + 1);
+            System.out.println("Username in /users/{username}: " + username);
+            User user = null;
+            try {
+                user = new DBConnection().getUser(username);
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+                sendError("401");
+            }
+            if (user != null){
+                String userJson = JsonHelper.userToJson(user);
+                if(userJson != null && !userJson.isEmpty()){
+                    sendResponse(userJson, "200");
+                }
+            }else{
+                sendError("500");
+            }
+        } else if (this.url.startsWith("/cards")) {
+            String username = basicAuthGetUsername(this.authString);
+            Cards allCards = new DBConnection().getCards(username);
+            String jsonCards = JsonHelper.objToJson(allCards);
+            if (jsonCards != null && !jsonCards.isEmpty()){
+                sendResponse(jsonCards, "200");
+            }else{
+                sendError("500");
             }
-        } else if (this.url.startsWith("/")) {
-            startseite();
         }
     }
 
+    /**
+     * Vergleicht das angegebene PW mit dem gespeicherten PW, True wenn richtig
+     * @param username User aus DB
+     * @param password PW zu User aus DB
+     * @param compareTo Base64 String von Basic Auth
+     * @return True if Login is correct, false if incorrect
+     */
+    private boolean basicAuth(String username, String password, String compareTo){
+        String authStringEnc = basicAuthBase64(username, password);
+        if (compareTo.equals(authStringEnc)){
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Erstellt den basicAuth Base64 Token aus Username und Passwort
+     * @param username Username für den Token
+     * @param password Passwort für den Token
+     * @return Der Base64 BasicAtuth String
+     */
+    private String basicAuthBase64(String username, String password){
+        String authString = username + ":" + password;
+        byte[] authEncBytes = Base64.getEncoder().encode(authString.getBytes());
+        String authStringEnc = new String(authEncBytes);
+        return authStringEnc;
+    }
+
+    /**
+     * Aus dem Base64 BasicAuth String wird der Username extrahiert
+     * @param authString Base64 BasicAuth String aus dem der Username ausgelesen werden soll
+     * @return Der Username der in dem Base64 BasicAuth String ist
+     */
+    private String basicAuthGetUsername(String authString) {
+        String[] values;
+        if (authString != null) {
+            byte[] credDecoded = Base64.getDecoder().decode(authString);
+            String credentials = new String(credDecoded);
+            values = credentials.split(":", 2);
+        }else{
+            values = null;
+        }
+        return values[0];
+    }
+
+    /**
+     * Alle Post Methoden, siehe API beschreibung für genauere details
+     *
+     * Kann auch von nicht angemeldeten usern erreicht werden.
+     * login() wird hier verwendet
+     * @throws JsonProcessingException Fehler beim de-/serialisieren
+     */
     private void postMethodes() throws JsonProcessingException {
         if (this.url.startsWith("/users")) {
-            //payload to map
-            ObjectMapper objectMapper = new ObjectMapper();
-            Map<String, Object> map = objectMapper.readValue(this.payload, new TypeReference<Map<String,Object>>(){});
+            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")){
-                sendError("500");
+            if(!con.addUser(newUser.getCredentials().getUsername(), newUser.getCredentials().getPasswort(), newUser.getCredentials().getUsername(), newUser.getEmail(), newUser.getBio(), newUser.getImage())){
+                sendError("409");
             }
-
-            //User to json
-            objectMapper = new ObjectMapper();
-            String userJson = "";
-            if(newUser != null) {
-                try {
-                    userJson += objectMapper.writeValueAsString(newUser);
-                } catch (JsonProcessingException e) {
-                    userJson = "Error: JsonProcessingException -> " + e.getMessage();
-                }
-                sendResponse(userJson, "200");
+            String userJson = JsonHelper.userToJson(newUser);;
+            if(userJson != null) {
+                sendResponse(userJson, "201");
             }else{
                 sendError("500");
             }
         }else if (this.url.startsWith("/sessions")) {
+            Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
+            String username = (String) map.get("Username");
+            String password = (String) map.get("Password");
+            User user = null;
 
-        }
-    }
+            DBConnection con = new DBConnection();
+            try {
+                user = con.getUser(username);
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+            }
 
-    private void putMethodes(){
-        if (this.url.startsWith("/messages")) {
-            String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1);
-            System.out.println("Last Bit: " + lastBit);
-            System.out.println("Payload" + this.payload);
-            String message = msgHandler.editMsg(Integer.parseInt(lastBit), this.payload);
-            if(message == null){
-                sendError("404");
-            }else {
-                sendResponse("","200");
+            String authString = basicAuthBase64(user.getCredentials().getUsername(), user.getCredentials().getPasswort());
+            if(basicAuth(username, password, authString)){
+                sendResponse(authString, "200");
+            }else{
+                sendError("401");
+            }
+        }else if (this.url.startsWith("/packages")) {
+            if(login()) {
+                if (basicAuth("admin", "admin", this.authString)) {
+                    ObjectMapper objectMapper = new ObjectMapper();
+                    ArrayList<Card> listCards = objectMapper.readValue(this.payload, new TypeReference<ArrayList<Card>>() {
+                    });
+                    Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5);
+                    if (!new DBConnection().addPackage(packageCards)) {
+                        sendError("500");
+                    } else {
+                        String packageJson = JsonHelper.objToJson(packageCards);
+                        if (packageJson != null) {
+                            sendResponse(packageJson, "201");
+                        } else {
+                            sendError("500");
+                        }
+                    }
+                } else {
+                    sendError("401");
+                }
+            }
+        }else if (this.url.startsWith("/transactions/packages")) {
+            if (login()) {
+                DBConnection db = new DBConnection();
+                Package newPackage = db.userAcquirePackage(basicAuthGetUsername(this.authString));
+                if (newPackage == null) {
+                    sendError("500");
+                } else {
+                    String packageJson = JsonHelper.objToJson(newPackage);
+                    if (packageJson == null) {
+                        sendError("500");
+                    } else {
+                        sendResponse(packageJson, "200");
+                    }
+                }
             }
         }
     }
 
+    /**
+     * Prüft den Login, anhand des BasicAuth Base64 String
+     * @return True wenn login daten korrekt, sonst false
+     */
+    private boolean login(){
+        String username = basicAuthGetUsername(this.authString);
+        User user = null;
+        DBConnection con = new DBConnection();
+        try {
+            user = con.getUser(username);
+        } catch (SQLException throwables) {
+            throwables.printStackTrace();
+            return false;
+        }
+        if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    /**
+     * Alle Put Methoden
+     * Nur für angemeldete user erreichbar
+     * @throws JsonProcessingException Fehler beim de-/serialisieren
+     */
+    private void putMethodes(){
+        if (this.url.startsWith("/users")) {
+            String username = this.url.substring(this.url.lastIndexOf('/') + 1);
+            System.out.println("Username in /users/{username}: " + username);
+            User user = null;
+            try {
+                user = new DBConnection().getUser(username);
+            } catch (SQLException throwables) {
+                throwables.printStackTrace();
+                sendError("401");
+            }
+            if(user != null) {
+                Map<String, Object> map = JsonHelper.jsonPayloadToMap(this.payload);
+                String bio = (String) map.get("Bio");
+                String image = (String) map.get("Image");
+                String name = (String) map.get("Name");
+                System.out.println("Request /users:");
+                System.out.println("Bio: " + bio + "\nImage: " + image + "\nName: " + name);
+                user.setBio(bio);
+                user.setImage(image);
+                user.setNachname(name);
+                if (new DBConnection().updateUser(username, user.getBio(), user.getImage(), user.getNachname())) {
+                    sendResponse(JsonHelper.userToJson(user), "200");
+                } else {
+                    sendError("500");
+                }
+            }else{
+                sendError("500");
+            }
+        }
+    }
+
+
+
+    /**
+     * 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")) {
-            String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1);
-            String message = msgHandler.delMsg(Integer.parseInt(lastBit));
-            if(message == null){
-                sendError("404");
-            }else {
-                sendResponse("", "200");
-            }
+
         }
     }
 
@@ -152,6 +326,9 @@ public class Response {
         //out.print(responseText);
     }
 
+    /**
+     * Sendet eine Startseite, mit allen befehlen und wie man diese verwendet
+
     private void startseite() {
         sendResponse("lists all messages:   GET    /messages<br>" +
                 "add message:          POST   /messages     (Payload: the message; Response an id like1)<br>" +
@@ -160,11 +337,7 @@ public class Response {
                 "update first message: PUT    /messages/1   (Payload: the message)<br>" +
                 "remove first message: DELETE /messages/1<br>", "200");
     }
-
-    private void listAllMsg() {
-        sendResponse(msgHandler.getAllMsg(), "200");
-        //sendResponse("Test");
-    }
+     */
 
     /**
      * Sendet eine Response
@@ -179,14 +352,4 @@ public class Response {
         out.print("\r\n");
         out.print(responseText);
     }
-
-    /**
-     * Get Msg Handler
-     *
-     * @return msgHandler Handler der Nachrichten
-     */
-    public MsgHandler getMsghandler() {
-        return this.msgHandler;
-    }
-
 }

src/test/java/StoreTest.java

@@ -36,8 +36,8 @@ public class StoreTest {
         Coins coins = new Coins(10);
         //at.reisinger.User
         Credentials credentials = new Credentials("username", "passwort");
-        user = new User(credentials, "name", "nachname", "email", stack, coins);
-        userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", stack, coins);
+        user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
+        userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE");
 
         //Trading Deal
         Card cardToTrade = card;
@@ -47,7 +47,7 @@ public class StoreTest {
         tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType);
 
     }
-
+/*
     @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 Stack(stack, deck), 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 Stack(stack, deck), 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 Stack(stack, deck), 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,8 +36,8 @@ 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", stack, coins);
-        userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", stack, coins);
+        user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
+        userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE");
 
         //Trading Deal
         Card cardToTrade = card;

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", stack, coins);
+        user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE");
     }
     @Test
     public void test_getName() {