diff --git a/.gitignore b/.gitignore index 45b7d7f..4867bb4 100644 --- a/.gitignore +++ b/.gitignore @@ -10,7 +10,7 @@ # Mobile Tools for Java (J2ME) .mtj.tmp/ -# Package Files # +# at.reisinger.Package Files # *.jar *.war *.nar @@ -23,3 +23,4 @@ hs_err_pid* .idea/compiler.xml *.lst +.idea/ diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 4e3ecef..d95228d 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -7,6 +7,7 @@ + diff --git a/README.md b/README.md index 3d0d7a4..8ef490b 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,2 @@ # SWE1-MTCG -Monster Trading Card Game +Monster Trading at.reisinger.Card Game diff --git a/pom.xml b/pom.xml index e091ca9..b62cfc7 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,18 @@ at.reisinger.mtcg MTCG 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 11 + 11 + + + + org.junit.jupiter @@ -24,6 +36,11 @@ mockito-junit-jupiter 3.5.13 + + com.fasterxml.jackson.core + jackson-databind + 2.11.2 + diff --git a/src/main/java/DBConnection.java b/src/main/java/DBConnection.java deleted file mode 100644 index 3c69e29..0000000 --- a/src/main/java/DBConnection.java +++ /dev/null @@ -1,68 +0,0 @@ -import java.util.ArrayList; - -/** - * Stellt die Verbindung zur "Datenbank" her - * Die "Datenbank" sind hier nur beispieldaten. - */ -public class DBConnection { - private ArrayList tradingDeals; - private ArrayList packages; - - /** - * Erstellt alle Beispieldaten und simuliert somit den - * Verbindungsaufbau zu einer DB - */ - public DBConnection(){ - Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); - Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL); - Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER); - Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL); - Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER); - ArrayList deckArrList = new ArrayList(); - ArrayList stackArrList = new ArrayList(); - 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(); - this.packages = new ArrayList(); - this.tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); - this.packages.add(new Package(stack, "Test Package", 100)); - } - - /** - * Holt alle verfügbaren TradingDeals - * @return Alle Trading Deals - */ - public ArrayList getAllTradingDeals(){ - return this.tradingDeals; - } - - /** - * Holt alle verfügbaren Packages - * @return Alle Packages - */ - public ArrayList getAllPackages(){ - return this.packages; - } - - /** - * Fügt einen neuen Tradingdeal zum Store hinzu - * @param tradingDeal Der neue Deal - */ - public void addTradingDeal(TradingDeal tradingDeal){ - this.tradingDeals.add(tradingDeal); - } - -// /** -// * Fügt ein neues Package zu dem Store hinzu -// * @param packageDeal Das neue Package -// */ -// public void addPackage(Package packageDeal){ -// this.packages.add(packageDeal); -// } -} diff --git a/src/main/java/Battle.java b/src/main/java/at/reisinger/Battle.java similarity index 51% rename from src/main/java/Battle.java rename to src/main/java/at/reisinger/Battle.java index b1d3db6..d43bbce 100644 --- a/src/main/java/Battle.java +++ b/src/main/java/at/reisinger/Battle.java @@ -1,2 +1,4 @@ +package at.reisinger; + public class Battle { } diff --git a/src/main/java/Card.java b/src/main/java/at/reisinger/Card.java similarity index 66% rename from src/main/java/Card.java rename to src/main/java/at/reisinger/Card.java index ca787b6..e3197d0 100644 --- a/src/main/java/Card.java +++ b/src/main/java/at/reisinger/Card.java @@ -1,5 +1,7 @@ +package at.reisinger; + /** - * Object einer Card + * Object einer at.reisinger.Card */ public class Card { private String name; @@ -8,11 +10,11 @@ public class Card { private CardType cardType; /** - * Erstellt eine neue Card mit gegebenen Eigenschaften - * @param name Name der Card - * @param damage Damage den die Card macht - * @param elementTyp ElementType der Card - * @param cardType CardType der Card + * Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften + * @param name Name der at.reisinger.Card + * @param damage Damage den die at.reisinger.Card macht + * @param elementTyp ElementType der at.reisinger.Card + * @param cardType at.reisinger.CardType der at.reisinger.Card */ public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) { this.name = name; @@ -22,42 +24,42 @@ public class Card { } /** - * Holt den Namen der Card - * @return Name der Card + * Holt den Namen der at.reisinger.Card + * @return Name der at.reisinger.Card */ public String getName() { return this.name; } /** - * Holt den Damage der Card - * @return Damage der Card + * Holt den Damage der at.reisinger.Card + * @return Damage der at.reisinger.Card */ public double getDamage() { return this.damage; } /** - * Holt den ElementType der Card - * @return ElementType der Card + * Holt den ElementType der at.reisinger.Card + * @return ElementType der at.reisinger.Card */ public ElementTyp getElementTyp() { return this.elementTyp; } /** - * Holt den CardType der Card - * @return CardType der Card + * Holt den at.reisinger.CardType der at.reisinger.Card + * @return at.reisinger.CardType der at.reisinger.Card */ public CardType getCardType() { return this.cardType; } /** - * Berechnet die Wirksamkeit gegen eine Andere card. Die Card im Parameter wird angegriffen - * @param toCeck Card gegen welche die Wirksamkeit geprüft werden soll + * Berechnet die Wirksamkeit gegen eine Andere card. Die at.reisinger.Card im Parameter wird angegriffen + * @param toCeck at.reisinger.Card gegen welche die Wirksamkeit geprüft werden soll * @return Gibt die Wirksamkeit zurück - * @throws InternalError Wenn die Effectifeness von den 2 Cards nicht berechnet werden kann + * @throws InternalError Wenn die Effectifeness von den 2 at.reisinger.Cards nicht berechnet werden kann */ public EffectivnessType getEffectivenessAgainst(Card toCeck) { if(toCeck.getCardType() == CardType.MONSTER){ @@ -75,19 +77,19 @@ public class Card { return EffectivnessType.NOEFFECT; } } - throw new InternalError("Konnte die Effectiveness von den Cards nicht berechnen"); + throw new InternalError("Konnte die Effectiveness von den at.reisinger.Cards nicht berechnen"); } /** - * Setztden namen der Card - * @param neuerName Name der Card + * Setztden namen der at.reisinger.Card + * @param neuerName Name der at.reisinger.Card */ public void setName(String neuerName) { this.name = neuerName; } /** - * Setzt den Damage der Card + * Setzt den Damage der at.reisinger.Card * @param damage Der Damage */ public void setDamage(int damage) { @@ -95,7 +97,7 @@ public class Card { } /** - * Setzt den ElementType der Card + * Setzt den ElementType der at.reisinger.Card * @param elementTyp Der ElementType */ public void setElementType(ElementTyp elementTyp) { @@ -104,7 +106,7 @@ public class Card { /** * Testet ob die beiden Karten gleich sind - * @param card Card die geprüft werden soll + * @param card at.reisinger.Card die geprüft werden soll * @return True wenn die Karten übereinstimmen */ public boolean equals(Card card){ diff --git a/src/main/java/CardType.java b/src/main/java/at/reisinger/CardType.java similarity index 65% rename from src/main/java/CardType.java rename to src/main/java/at/reisinger/CardType.java index 6256f99..8c5016f 100644 --- a/src/main/java/CardType.java +++ b/src/main/java/at/reisinger/CardType.java @@ -1,3 +1,5 @@ +package at.reisinger; + public enum CardType { MONSTER, SPELL } diff --git a/src/main/java/Cards.java b/src/main/java/at/reisinger/Cards.java similarity index 65% rename from src/main/java/Cards.java rename to src/main/java/at/reisinger/Cards.java index 1a2bbec..1d7a78d 100644 --- a/src/main/java/Cards.java +++ b/src/main/java/at/reisinger/Cards.java @@ -1,16 +1,17 @@ +package at.reisinger; + import java.util.ArrayList; -import java.util.Collections; import java.util.concurrent.atomic.AtomicBoolean; /** - * Verwaltet eine Liste vo Cards + * Verwaltet eine Liste vo at.reisinger.Cards */ public class Cards { private ArrayList cards; /** * Erstellt ein nues obj mit gegebenen Karten - * @param cardsArrayList Die Cards zum erstellen des Obj + * @param cardsArrayList Die at.reisinger.Cards zum erstellen des Obj */ public Cards(ArrayList cardsArrayList) { this.cards = cardsArrayList; @@ -19,33 +20,33 @@ public class Cards { /** - * Fügt eine neue Card hinzu - * @param newCard neue Card + * Fügt eine neue at.reisinger.Card hinzu + * @param newCard neue at.reisinger.Card */ public void addCard(Card newCard) { this.cards.add(newCard); } /** - * Holt alle Cards - * @return Alle Cards + * Holt alle at.reisinger.Cards + * @return Alle at.reisinger.Cards */ public ArrayList getCards() { return this.cards; } /** - * Löscht die gegebene Card - * @param delCard Card zum löschen + * Löscht die gegebene at.reisinger.Card + * @param delCard at.reisinger.Card zum löschen */ public void delCard(Card delCard) { this.cards.removeIf(obj -> obj.equals(delCard)); } /** - * Prüft ob eine Card in den Cards vorhanden ist - * @param toCeck Card nach der in den Cards gesucht werden soll - * @return True wenn die Card in den Cards ist + * Prüft ob eine at.reisinger.Card in den at.reisinger.Cards vorhanden ist + * @param toCeck at.reisinger.Card nach der in den at.reisinger.Cards gesucht werden soll + * @return True wenn die at.reisinger.Card in den at.reisinger.Cards ist */ public boolean containsCard(Card toCeck){ AtomicBoolean returnval = new AtomicBoolean(false); @@ -60,9 +61,9 @@ public class Cards { } /** - * Vergleicht 2 Cards Obj miteinander - * @param toCompare Cards zum vergleichen - * @return True wenn es aus den selben Cards besteht + * Vergleicht 2 at.reisinger.Cards Obj miteinander + * @param toCompare at.reisinger.Cards zum vergleichen + * @return True wenn es aus den selben at.reisinger.Cards besteht */ public boolean equals(Cards toCompare){ if (this.cards == null && toCompare.getCards() == null){ diff --git a/src/main/java/Coins.java b/src/main/java/at/reisinger/Coins.java similarity index 90% rename from src/main/java/Coins.java rename to src/main/java/at/reisinger/Coins.java index fd02ce9..abd2a5b 100644 --- a/src/main/java/Coins.java +++ b/src/main/java/at/reisinger/Coins.java @@ -1,3 +1,5 @@ +package at.reisinger; + /** * Alle coins eines Users */ @@ -27,7 +29,7 @@ public class Coins { */ public void addCoin(int coins) throws NegativAmountException{ if(coins < 0) { - throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden"); + throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"); }else { this.amount += coins; } @@ -41,7 +43,7 @@ public class Coins { */ public boolean removeCoin(int coins) throws NegativAmountException{ if(coins < 0) { - throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden"); + throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"); }else { this.amount -= coins; return true; @@ -56,7 +58,7 @@ public class Coins { */ public boolean changeCoinAmmount(int coins) throws NegativAmountException{ if(coins < 0) { - throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden"); + throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"); }else { this.amount = coins; return true; diff --git a/src/main/java/Credentials.java b/src/main/java/at/reisinger/Credentials.java similarity index 84% rename from src/main/java/Credentials.java rename to src/main/java/at/reisinger/Credentials.java index 8a9e7e0..ebbb97d 100644 --- a/src/main/java/Credentials.java +++ b/src/main/java/at/reisinger/Credentials.java @@ -1,11 +1,13 @@ +package at.reisinger; + /** - * User Login Daten + * at.reisinger.User Login Daten */ public class Credentials { private String passwort, username; /** - * Startet einen neuen User mit folgenden Daten + * Startet einen neuen at.reisinger.User mit folgenden Daten * @param username Diesem Usernamen * @param passwort Diesem Passwort */ @@ -23,7 +25,7 @@ public class Credentials { } // /** -// * Setzt das User Passwort +// * Setzt das at.reisinger.User Passwort // * @param passwort Neues Passwort // */ // public void setPasswort(String passwort) { diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java new file mode 100644 index 0000000..374cab1 --- /dev/null +++ b/src/main/java/at/reisinger/DBConnection.java @@ -0,0 +1,137 @@ +package at.reisinger; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; + +/** + * Stellt die Verbindung zur "Datenbank" her + * Die "Datenbank" sind hier nur beispieldaten. + */ +public class DBConnection { + private ArrayList tradingDeals; + private ArrayList 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"); + 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 deckArrList = new ArrayList(); + ArrayList stackArrList = new ArrayList(); + 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(); + this.packages = new ArrayList(); + 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); + stmt.close(); + this.c.close(); + } catch ( Exception e ) { + System.err.println( e.getClass().getName()+": "+ e.getMessage() ); + return false; + } + System.out.println("User added"); + return true; + } + + /** + * Holt alle verfügbaren TradingDeals + * @return Alle Trading Deals + */ + public ArrayList getAllTradingDeals(){ + return this.tradingDeals; + } + + /** + * Holt alle verfügbaren Packages + * @return Alle Packages + */ + public ArrayList getAllPackages(){ + return this.packages; + } + + /** + * Fügt einen neuen Tradingdeal zum at.reisinger.Store hinzu + * @param tradingDeal Der neue Deal + */ + public void addTradingDeal(TradingDeal tradingDeal){ + this.tradingDeals.add(tradingDeal); + } + +// /** +// * Fügt ein neues at.reisinger.Package zu dem at.reisinger.Store hinzu +// * @param packageDeal Das neue at.reisinger.Package +// */ +// public void addPackage(at.reisinger.Package packageDeal){ +// this.packages.add(packageDeal); +// } +} diff --git a/src/main/java/EffectivnessType.java b/src/main/java/at/reisinger/EffectivnessType.java similarity index 77% rename from src/main/java/EffectivnessType.java rename to src/main/java/at/reisinger/EffectivnessType.java index 150ce66..62421a1 100644 --- a/src/main/java/EffectivnessType.java +++ b/src/main/java/at/reisinger/EffectivnessType.java @@ -1,3 +1,5 @@ +package at.reisinger; + public enum EffectivnessType { EFFECTIVE, NOTEFFECTIVE, diff --git a/src/main/java/ElementTyp.java b/src/main/java/at/reisinger/ElementTyp.java similarity index 68% rename from src/main/java/ElementTyp.java rename to src/main/java/at/reisinger/ElementTyp.java index e9360db..b916e84 100644 --- a/src/main/java/ElementTyp.java +++ b/src/main/java/at/reisinger/ElementTyp.java @@ -1,3 +1,5 @@ +package at.reisinger; + public enum ElementTyp { WATER, FIRE, NORMAL } diff --git a/src/main/java/MonsterCard.java b/src/main/java/at/reisinger/MonsterCard.java similarity index 89% rename from src/main/java/MonsterCard.java rename to src/main/java/at/reisinger/MonsterCard.java index 2036952..c1ffc83 100644 --- a/src/main/java/MonsterCard.java +++ b/src/main/java/at/reisinger/MonsterCard.java @@ -1,3 +1,5 @@ +package at.reisinger; + public class MonsterCard extends Card{ public MonsterCard(String name, double damage, ElementTyp elementTyp, CardType cardType) { super(name, damage, elementTyp, cardType); diff --git a/src/main/java/NegativAmountException.java b/src/main/java/at/reisinger/NegativAmountException.java similarity index 94% rename from src/main/java/NegativAmountException.java rename to src/main/java/at/reisinger/NegativAmountException.java index a9c3dd1..0405378 100644 --- a/src/main/java/NegativAmountException.java +++ b/src/main/java/at/reisinger/NegativAmountException.java @@ -1,3 +1,5 @@ +package at.reisinger; + /** * Wenn ein negativer wert eingegeben wird aber ein Positiver erwartet wird, dann kann diese Exception geworfen werden */ diff --git a/src/main/java/Package.java b/src/main/java/at/reisinger/Package.java similarity index 72% rename from src/main/java/Package.java rename to src/main/java/at/reisinger/Package.java index 37964ea..f00de77 100644 --- a/src/main/java/Package.java +++ b/src/main/java/at/reisinger/Package.java @@ -1,13 +1,15 @@ +package at.reisinger; + /** - * Package besteht aus 4 Karten. Ist eine Erweiterung der Cards, zeigt für 4 Cards den Preis und einen Packagenamen an + * at.reisinger.Package besteht aus 4 Karten. Ist eine Erweiterung der at.reisinger.Cards, zeigt für 4 at.reisinger.Cards den Preis und einen Packagenamen an */ public class Package extends Cards{ private String name; private int price; /** - * Erstellt ein neues Package mit den gegebenen Stats - * @param stack Cards des Packages + * Erstellt ein neues at.reisinger.Package mit den gegebenen Stats + * @param stack at.reisinger.Cards des Packages * @param name Name des Packages * @param price Price des Packages */ diff --git a/src/main/java/SpellCard.java b/src/main/java/at/reisinger/SpellCard.java similarity index 89% rename from src/main/java/SpellCard.java rename to src/main/java/at/reisinger/SpellCard.java index fb74e62..f9f9881 100644 --- a/src/main/java/SpellCard.java +++ b/src/main/java/at/reisinger/SpellCard.java @@ -1,3 +1,5 @@ +package at.reisinger; + public class SpellCard extends Card{ public SpellCard(String name, double damage, ElementTyp elementTyp, CardType cardType) { super(name, damage, elementTyp, cardType); diff --git a/src/main/java/Stack.java b/src/main/java/at/reisinger/Stack.java similarity index 52% rename from src/main/java/Stack.java rename to src/main/java/at/reisinger/Stack.java index 6b0be43..eab8633 100644 --- a/src/main/java/Stack.java +++ b/src/main/java/at/reisinger/Stack.java @@ -1,12 +1,14 @@ +package at.reisinger; + /** - * Erweitert Cards insofern, dass es im Stack auch ein Deck gibt + * Erweitert at.reisinger.Cards insofern, dass es im at.reisinger.Stack auch ein Deck gibt */ public class Stack extends Cards{ private Cards deck; /** - * Erstellt einen neuen Stack aus den User Cards und seinem Deck - * @param cards Alle Cards des Users + * Erstellt einen neuen at.reisinger.Stack aus den at.reisinger.User at.reisinger.Cards und seinem Deck + * @param cards Alle at.reisinger.Cards des Users * @param deck Sein Deck */ public Stack(Cards cards, Cards deck) { @@ -15,7 +17,7 @@ public class Stack extends Cards{ } /** - * Fügt ein neues Deck in den Stack ein + * Fügt ein neues Deck in den at.reisinger.Stack ein * @param newCards Gesamtes Deck */ public void addDeck(Cards newCards) { @@ -31,18 +33,18 @@ public class Stack extends Cards{ } /** - * Löscht eine Card aus dem Deck - * @param toDel Card zum löschen + * Löscht eine at.reisinger.Card aus dem Deck + * @param toDel at.reisinger.Card zum löschen */ public void delDeck(Card toDel) { this.deck.delCard(toDel); } // /** -// * Fügt dem deck eine neue Card ein -// * @param toAdd Neue Card +// * Fügt dem deck eine neue at.reisinger.Card ein +// * @param toAdd Neue at.reisinger.Card // */ -// public void addDeckCard(Card toAdd){ +// public void addDeckCard(at.reisinger.Card toAdd){ // this.deck.addCard(toAdd); // } } diff --git a/src/main/java/Store.java b/src/main/java/at/reisinger/Store.java similarity index 93% rename from src/main/java/Store.java rename to src/main/java/at/reisinger/Store.java index 9b73a45..069c79d 100644 --- a/src/main/java/Store.java +++ b/src/main/java/at/reisinger/Store.java @@ -1,3 +1,5 @@ +package at.reisinger; + import java.util.ArrayList; public interface Store { diff --git a/src/main/java/TradingDeal.java b/src/main/java/at/reisinger/TradingDeal.java similarity index 76% rename from src/main/java/TradingDeal.java rename to src/main/java/at/reisinger/TradingDeal.java index 4f0c8a5..8c79b18 100644 --- a/src/main/java/TradingDeal.java +++ b/src/main/java/at/reisinger/TradingDeal.java @@ -1,23 +1,25 @@ +package at.reisinger; + /** * Ein einzelner Trading deal wird hier verwaltet. */ public class TradingDeal { - private User tradingUser; + //private User tradingUser; private Card cardToTrade; private ElementTyp requiredElementType; private double requiredMinDamage; private CardType requiredCardType; /** - * Ein TradingDeal wird erstellt - * @param user User des Deals - * @param cardToTrade Card die getauscht werden soll + * Ein at.reisinger.TradingDeal wird erstellt + * @param user at.reisinger.User des Deals + * @param cardToTrade at.reisinger.Card die getauscht werden soll * @param requiredElementType Req ElementType für den Tausch * @param requiredMinDamage Req min damage für den Tausch - * @param requiredCardType Req Card Type für den Tausch + * @param requiredCardType Req at.reisinger.Card Type für den Tausch */ public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) { - this.tradingUser = user; + //this.tradingUser = user; this.cardToTrade = cardToTrade; this.requiredElementType = requiredElementType; this.requiredMinDamage = requiredMinDamage; @@ -25,16 +27,16 @@ public class TradingDeal { } /** - * Holt den Trading User - * @return User der den Trade erstellt hat - */ + * Holt den Trading at.reisinger.User + * @return at.reisinger.User der den Trade erstellt hat + public User getTradingUser() { return this.tradingUser; } - +*/ /** - * Card die getraded werden soll - * @return Card die getradet werden soll + * at.reisinger.Card die getraded werden soll + * @return at.reisinger.Card die getradet werden soll */ public Card getCardToTrade() { return this.cardToTrade; @@ -58,23 +60,23 @@ public class TradingDeal { /** * Hole req cardtype - * @return Req CardType + * @return Req at.reisinger.CardType */ public CardType getRequiredCardType() { return this.requiredCardType; } /** - * Setzt den User des Trades - * @param tradingUser User der Traded - */ + * Setzt den at.reisinger.User des Trades + * @param tradingUser at.reisinger.User der Traded + public void setTradingUser(User tradingUser) { this.tradingUser = tradingUser; } - +*/ /** * Setzt die Karte die Getradet werden soll - * @param cardToTrade Card zum tauschen + * @param cardToTrade at.reisinger.Card zum tauschen */ public void setCardToTrade(Card cardToTrade) { this.cardToTrade = cardToTrade; @@ -98,14 +100,14 @@ public class TradingDeal { /** * Setzt req cardType - * @param requiredCardType Der Req CardType + * @param requiredCardType Der Req at.reisinger.CardType */ public void setRequiredCardType(CardType requiredCardType) { this.requiredCardType = requiredCardType; } /** - * Vom deal im Parameter wird die Card mit den Requirements von THIS verglichen + * Vom deal im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen * @param checkDeal Von diesem Deal wird die CardToTrade geprüft * @return True wenn der Deal passt */ @@ -114,8 +116,8 @@ public class TradingDeal { } /** - * Von der Card im Parameter wird die Card mit den Requirements von THIS verglichen - * @param checkCard Card die mit dem Deal verglichen wird + * Von der at.reisinger.Card im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen + * @param checkCard at.reisinger.Card die mit dem Deal verglichen wird * @return True wenn der Deal passt */ public boolean cardOk(Card checkCard){ diff --git a/src/main/java/User.java b/src/main/java/at/reisinger/User.java similarity index 63% rename from src/main/java/User.java rename to src/main/java/at/reisinger/User.java index bf37bc9..ebd65a3 100644 --- a/src/main/java/User.java +++ b/src/main/java/at/reisinger/User.java @@ -1,17 +1,26 @@ +package at.reisinger; + +import com.fasterxml.jackson.annotation.*; + import java.util.ArrayList; /** - * User & Store Logik + * at.reisinger.User & at.reisinger.Store Logik */ +@JsonAutoDetect public class User implements Store{ + @JsonProperty private String name, nachname, email; + @JsonProperty private Stack stack; - private DBConnection db; + //private DBConnection db; + @JsonProperty private Credentials credentials; + @JsonProperty private Coins coins; /** - * Erstellt einen neuen User + * Erstellt einen neuen at.reisinger.User * @param credentials Zugangsdaten des Users * @param name Name des Users * @param nachname Nachname des Users @@ -19,28 +28,42 @@ public class User implements Store{ * @param stack Alle Karten des Users * @param coins Alle Münzen des Users */ - public User(Credentials credentials, String name, String nachname, String email, Stack stack, Coins coins) { + @JsonCreator + public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Stack stack,@JsonProperty Coins coins) { this.credentials = credentials; this.name = name; this.nachname = nachname; this.email = email; this.stack = stack; this.coins = coins; - //this.db = new DBConnection(); + //this.db = new at.reisinger.DBConnection(); + } + + @JsonCreator + public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Coins coins) { + this.credentials = credentials; + this.name = name; + this.nachname = nachname; + this.email = email; + this.stack = null; + this.coins = coins; + //this.db = new at.reisinger.DBConnection(); } /** - * Holt den Stack des Users - * @return Stack des Users + * Holt den at.reisinger.Stack des Users + * @return at.reisinger.Stack des Users */ + @JsonGetter public Stack getStack() { return stack; } /** - * Setzt den Stack eines Users - * @param stack Der neue Stack des Users + * Setzt den at.reisinger.Stack eines Users + * @param stack Der neue at.reisinger.Stack des Users */ + @JsonSetter public void setStack(Stack stack) { this.stack = stack; } @@ -48,7 +71,8 @@ public class User implements Store{ /** * Holt das DB Obj * @return Das DB Obj - */ + + @JsonGetter public DBConnection getDb() { return new DBConnection(); } @@ -56,63 +80,74 @@ public class User implements Store{ /** * Setzt ein neues DB Obj * @param db Das neue DB Obj - */ + + + @JsonSetter public void setDb(DBConnection db) { this.db = db; } + */ + /** * Holt die eindeutigen Logindaten des Users * @return Eindeutige Logindaten */ + @JsonGetter public Credentials getCredentials() { return credentials; } /** * Setzt die eindeutigen Logindaten - * @param credentials Die neuen Credentials des Users + * @param credentials Die neuen at.reisinger.Credentials des Users */ + @JsonSetter public void setCredentials(Credentials credentials) { this.credentials = credentials; } /** - * Holt alle Coins des Users - * @return Coins des Users + * Holt alle at.reisinger.Coins des Users + * @return at.reisinger.Coins des Users */ + @JsonGetter public Coins getCoins() { return coins; } /** - * Setzt alle Coins des Users - * @param coins Neue Coins des Users + * Setzt alle at.reisinger.Coins des Users + * @param coins Neue at.reisinger.Coins des Users */ + @JsonSetter public void setCoins(Coins coins) { this.coins = coins; } /** - * Get Name of User - * @return Name of User + * Get Name of at.reisinger.User + * @return Name of at.reisinger.User */ + @JsonGetter public String getName() { return this.name; } /** - * Get Nachname of User - * @return Nachname of User + * Get Nachname of at.reisinger.User + * @return Nachname of at.reisinger.User */ + @JsonGetter public String getNachname() { return this.nachname; } /** - * Email of User - * @return Email of User + * Email of at.reisinger.User + * @return Email of at.reisinger.User */ + @JsonGetter public String getEmail() { return this.email; } @@ -121,6 +156,7 @@ public class User implements Store{ * Setzt den Namen des Users * @param name Neuer Name des Users */ + @JsonSetter public void setName(String name) { this.name = name; } @@ -129,6 +165,7 @@ public class User implements Store{ * Setzt den Nachnamen * @param nachname Neuer Nachname */ + @JsonSetter public void setNachname(String nachname) { this.nachname = nachname; } @@ -137,27 +174,28 @@ public class User implements Store{ * Setzt die Email des Users * @param email Neue Email des Users */ + @JsonSetter public void setEmail(String email) { this.email = email; } - //Store Methoden + //at.reisinger.Store Methoden /** - * Kauft ein Package - * @param mypackage Package welches gekauft werden soll - * @return Alle Karten des neuen Package - * @throws NegativAmountException Wenn ein negativer Preis im Package gesetzt wird. + * Kauft ein at.reisinger.Package + * @param mypackage at.reisinger.Package welches gekauft werden soll + * @return Alle Karten des neuen at.reisinger.Package + * @throws NegativAmountException Wenn ein negativer Preis im at.reisinger.Package gesetzt wird. */ public ArrayList buyPackage(Package mypackage) throws NegativAmountException { - ArrayList availablePackages = new DBConnection().getAllPackages(); - availablePackages.removeIf(obj -> obj.equals(mypackage)); + //ArrayList availablePackages = new DBConnection().getAllPackages(); + //availablePackages.removeIf(obj -> obj.equals(mypackage)); this.coins.removeCoin(mypackage.getPrice()); return mypackage.getCards(); } /** - * Fügt dem Store einen neuen Tradingdeal hinzu + * Fügt dem at.reisinger.Store einen neuen Tradingdeal hinzu * @param tradingDeal Der neue Tradingdeal */ public void addTradingDeal(TradingDeal tradingDeal) { @@ -174,8 +212,8 @@ public class User implements Store{ /** * Startet ein Trading zw 2 TradingDeals - * @param myTradingDeal Wenn der Deal passt, wird diese Karte aus dem Stack entfernt - * @param storeTradingDeal Wenn der Deal passt, wird diese Karte dem Stack hinzugefügt + * @param myTradingDeal Wenn der Deal passt, wird diese Karte aus dem at.reisinger.Stack entfernt + * @param storeTradingDeal Wenn der Deal passt, wird diese Karte dem at.reisinger.Stack hinzugefügt * @return True wenn erfolgreich, False wenn die Deals nicht zusammenpassen */ public boolean doTrading(TradingDeal myTradingDeal, TradingDeal storeTradingDeal) { @@ -206,9 +244,9 @@ public class User implements Store{ } /** - * Checkt ob es sich um den selben User handelt - * @param toCheck Mit diesem User wird verglichen - * @return True wenn es der selbe User ist + * Checkt ob es sich um den selben at.reisinger.User handelt + * @param toCheck Mit diesem at.reisinger.User wird verglichen + * @return True wenn es der selbe at.reisinger.User ist */ public boolean equals(User toCheck){ if (toCheck.getCredentials().getUsername() == this.credentials.getUsername() && toCheck.getCredentials().getPasswort() == this.credentials.getPasswort()){ diff --git a/src/main/java/at/reisinger/server/Main.java b/src/main/java/at/reisinger/server/Main.java new file mode 100644 index 0000000..1cc786e --- /dev/null +++ b/src/main/java/at/reisinger/server/Main.java @@ -0,0 +1,65 @@ +package at.reisinger.server; + +import at.reisinger.server.msg.MsgHandler; +import at.reisinger.server.objects.Request; +import at.reisinger.server.objects.Response; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; + +/** + * Grundlegende Server logic + * Vereint alle anderen Klassen + */ +public class Main { + static final int port = 80; + private Socket socket; + private int id; + private MsgHandler msgHandler; + + /** + * Initial Start + * @param args Nicht Verwendet + */ + public static void main(String[] args) { + System.out.println("Starte Server auf Port 80"); + new Main(port); + } + + /** + * Öffnet den Server Socket und akzepiert diesen + * @param port Port auf dem der Server läuft + */ + public Main(int port){ + ServerSocket serverSocket = null; + try { + serverSocket = new ServerSocket(port); + + //this.msgHandler = new MsgHandler(); + //this.id = 0; + while (true){ + this.socket = serverSocket.accept(); + requestResponding(); + } + } catch (IOException e) { + e.printStackTrace(); + } + } + + /** + * Jeder Request durchläuft diese Funktion, reagiert auf requests + */ + public void requestResponding(){ + try{ + System.out.println("Socket von Client #" + this.id + " wurde gestartet!"); + Request rq = new Request(this.socket, this.id); + Response rp = new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), null, rq.getPayload()); + //this.msgHandler = rp.getMsghandler(); + this.socket.close(); + System.out.println("Socket von Client #" + this.id + " wurde geschlossen!"); + }catch (IOException e){ + e.printStackTrace(); + } + } +} diff --git a/src/main/java/at/reisinger/server/helper/JsonHelper.java b/src/main/java/at/reisinger/server/helper/JsonHelper.java new file mode 100644 index 0000000..dd53af3 --- /dev/null +++ b/src/main/java/at/reisinger/server/helper/JsonHelper.java @@ -0,0 +1,7 @@ +package at.reisinger.server.helper; + +public class JsonHelper { + + + +} diff --git a/src/main/java/at/reisinger/server/msg/MsgHandler.java b/src/main/java/at/reisinger/server/msg/MsgHandler.java new file mode 100644 index 0000000..f9f609a --- /dev/null +++ b/src/main/java/at/reisinger/server/msg/MsgHandler.java @@ -0,0 +1,89 @@ +package at.reisinger.server.msg; + +import at.reisinger.server.objects.Msg; + +import java.util.HashMap; + +/** + * Der Speicher der Nachrichten + * Mit hilfe einer HashMap werden die MsgId und die Msg selbst gespeichert + * @author Georg Reisinger + */ +public class MsgHandler { + private HashMap msgHashMap; + private int lastID; + + /** + * Erstellt den MsgHandler mit standart Test Messages + */ + public MsgHandler(){ + msgHashMap = new HashMap(); + 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; + } +} diff --git a/src/main/java/at/reisinger/server/objects/Msg.java b/src/main/java/at/reisinger/server/objects/Msg.java new file mode 100644 index 0000000..87a2ea7 --- /dev/null +++ b/src/main/java/at/reisinger/server/objects/Msg.java @@ -0,0 +1,37 @@ +package at.reisinger.server.objects; + +/** + * Message Objekt beinmhaltet die MsgId und die Msg selbst + * @author Georg Reisinger + */ +public class Msg { + private int id; + private String msg; + + /** + * Erstellt eine Message + */ + public Msg(int id, String msg){ + this.id = id; + this.msg = msg; + } + + + /** + * get field + * + * @return id Message Id + */ + public int getId() { + return this.id; + } + + /** + * get field + * + * @return msg Message String + */ + public String getMsg() { + return this.msg; + } +} diff --git a/src/main/java/at/reisinger/server/objects/Request.java b/src/main/java/at/reisinger/server/objects/Request.java new file mode 100644 index 0000000..bc65127 --- /dev/null +++ b/src/main/java/at/reisinger/server/objects/Request.java @@ -0,0 +1,110 @@ +package at.reisinger.server.objects; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.PrintStream; +import java.net.Socket; +import java.util.ArrayList; +import java.util.List; + +/** + * Verarbeitet einen Request + * @author Georg Reisinger + */ +public class Request { + + private final Socket socket; + private final int id; + private PrintStream out; + private String cmd; + private String url; + private final StringBuilder rqBuilder; + private String payload; + + /** + * Get Request + * @param socket Socket von dem der Request kommt + * @param id Thread ID + */ + public Request(Socket socket, int id) throws IOException { + this.socket = socket; + this.rqBuilder = new StringBuilder(); + this.id = id; + this.out = new PrintStream(this.socket.getOutputStream()); + BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream())); + String line = bufferedReader.readLine(); + while (!line.isBlank()) { + rqBuilder.append(line + "\r\n"); + line = bufferedReader.readLine(); + System.out.println(line); + } + String request = rqBuilder.toString(); + String[] requestsLines = request.split("\r\n"); + String[] requestLine = requestsLines[0].split(" "); + String method = requestLine[0]; + String path = requestLine[1]; + String version = requestLine[2]; + String host = requestsLines[1].split(" ")[1]; + + //code to read the post payload data + StringBuilder payload = new StringBuilder(); + while(bufferedReader.ready()){ + payload.append((char) bufferedReader.read()); + } + System.out.println("Payload: " + payload.toString()); + this.payload = payload.toString(); + + this.url = path; + this.cmd = method; + + List headers = new ArrayList<>(); + for (int h = 2; h < requestsLines.length; h++) { + String header = requestsLines[h]; + headers.add(header); + } + + 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); + } + + + + /** + * Get PrintStream --> Output + * + * @return out PrintStream --> Output + */ + public PrintStream getOut() { + return this.out; + } + + /** + * Command wie GET, PUT, POST, DEL + * + * @return cmd als String + */ + public String getCmd() { + return this.cmd; + } + + /** + * Request url + * + * @return url als String + */ + public String getUrl() { + return this.url; + } + + /** + * Payload des Request + * + * @return payload als String + */ + public String getPayload() { + return this.payload; + } + +} diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java new file mode 100644 index 0000000..011777c --- /dev/null +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -0,0 +1,192 @@ +package at.reisinger.server.objects; + +import at.reisinger.*; +import at.reisinger.server.msg.MsgHandler; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; + +import java.io.PrintStream; +import java.util.Map; + +/** + * Erstellt und sendet eine Response anhand des Requests + * @author Georg Reisinger + */ +public class Response { + + //private final Socket socket; + private final int id; + private PrintStream out; + private String cmd; + private String url; + private String payload; + private MsgHandler msgHandler; + private StringBuilder rqBuilder; + + /** + * Nimmt die Daten des requests und generiert eine Response + * @param id Thread Id + * @param url Request Url + * @param cmd Request CMD + * @param out out Print Stream + * @param msgHandler Der MsgHandler + * @param payload Payload des Requests + */ + public Response(int id, String url, String cmd, PrintStream out, MsgHandler msgHandler, String payload){ + this.id = id; + this.msgHandler = msgHandler; + this.url = url; + this.cmd = cmd; + this.out = out; + this.payload = payload; + this.rqBuilder = new StringBuilder(); + System.out.println(cmd); + if (this.url != null) { + if (this.cmd.equals("GET")) { + getMethodes(); + }else if (this.cmd.equals("POST")){ + try { + postMethodes(); + } catch (JsonProcessingException e) { + e.printStackTrace(); + } + }else if (this.cmd.equals("PUT")){ + putMethodes(); + }else if (this.cmd.equals("DELETE")){ + deleteMethodes(); + }else{ + sendError("405"); + } + } + } + + private void getMethodes(){ + if (this.url.startsWith("/messages")) { + String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1); + System.out.println("Last Bit: " + lastBit); + if(lastBit.equals("messages")){ + listAllMsg(); + }else{ + String message = msgHandler.getMsg(Integer.parseInt(lastBit)).getMsg(); + if(message == null){ + sendError("404"); + }else { + sendResponse(message, "200"); + } + } + } else if (this.url.startsWith("/")) { + startseite(); + } + } + + private void postMethodes() throws JsonProcessingException { + if (this.url.startsWith("/users")) { + //payload to map + ObjectMapper objectMapper = new ObjectMapper(); + Map map = objectMapper.readValue(this.payload, new TypeReference>(){}); + String username = (String) map.get("Username"); + String password = (String) map.get("Password"); + User newUser = new User(new Credentials(username, password), username, username, "not implemented", new Coins(20)); + System.out.println("CON DB"); + DBConnection con = new DBConnection(); + if(!con.addUser(username, password, username, "not implemented")){ + sendError("500"); + } + + //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"); + }else{ + sendError("500"); + } + }else if (this.url.startsWith("/sessions")) { + + } + } + + private void putMethodes(){ + if (this.url.startsWith("/messages")) { + String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1); + System.out.println("Last Bit: " + lastBit); + System.out.println("Payload" + this.payload); + String message = msgHandler.editMsg(Integer.parseInt(lastBit), this.payload); + if(message == null){ + sendError("404"); + }else { + sendResponse("","200"); + } + } + } + + private void deleteMethodes(){ + if (this.url.startsWith("/messages")) { + String lastBit = this.url.substring(this.url.lastIndexOf('/') + 1); + String message = msgHandler.delMsg(Integer.parseInt(lastBit)); + if(message == null){ + sendError("404"); + }else { + sendResponse("", "200"); + } + } + } + + + /** + * Sendet einen Error Response + * @param errorCode Der Error Code + */ + private void sendError(String errorCode) { + out.print("HTTP/1.0 "+errorCode+"\r\n"); + out.print("Server: Apache/0.8.4\r\n"); + out.print("Content-Type: text/plain\r\n"); + out.print("Content-Length: 1\r\n"); + out.print("\r\n"); + //out.print(responseText); + } + + private void startseite() { + sendResponse("lists all messages: GET /messages
" + + "add message: POST /messages (Payload: the message; Response an id like1)
" + + "show first message: GET /messages/1
" + + "show third message: GET /messages/3
" + + "update first message: PUT /messages/1 (Payload: the message)
" + + "remove first message: DELETE /messages/1
", "200"); + } + + private void listAllMsg() { + sendResponse(msgHandler.getAllMsg(), "200"); + //sendResponse("Test"); + } + + /** + * Sendet eine Response + * @param responseText Text der zu senden ist + * @param code Http code + */ + private void sendResponse(String responseText, String code){ + out.print("HTTP/1.0 "+code+"\r\n"); + out.print("Server: Apache/0.8.4\r\n"); + out.print("Content-Type: text/plain\r\n"); + out.print("Content-Length: "+responseText.length()+"\r\n"); + out.print("\r\n"); + out.print(responseText); + } + + /** + * Get Msg Handler + * + * @return msgHandler Handler der Nachrichten + */ + public MsgHandler getMsghandler() { + return this.msgHandler; + } + +} diff --git a/src/test/java/CardTest.java b/src/test/java/CardTest.java index 3e000f2..b9a5c4b 100644 --- a/src/test/java/CardTest.java +++ b/src/test/java/CardTest.java @@ -1,3 +1,7 @@ +import at.reisinger.Card; +import at.reisinger.CardType; +import at.reisinger.EffectivnessType; +import at.reisinger.ElementTyp; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertTrue; diff --git a/src/test/java/CardsTest.java b/src/test/java/CardsTest.java index 578f8e8..811acf4 100644 --- a/src/test/java/CardsTest.java +++ b/src/test/java/CardsTest.java @@ -1,3 +1,7 @@ +import at.reisinger.Card; +import at.reisinger.CardType; +import at.reisinger.Cards; +import at.reisinger.ElementTyp; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.ArrayList; @@ -6,7 +10,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; public class CardsTest { - private Cards cards, cards2, cards3; + private Cards cards, cards2, cards3; private Card newCard, card, newerCard; private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; diff --git a/src/test/java/CoinsTest.java b/src/test/java/CoinsTest.java index 5f699f6..dc479c4 100644 --- a/src/test/java/CoinsTest.java +++ b/src/test/java/CoinsTest.java @@ -1,3 +1,5 @@ +import at.reisinger.Coins; +import at.reisinger.NegativAmountException; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -17,9 +19,9 @@ public class CoinsTest { try { Coins coin = new Coins(10); coin.addCoin(-10); - fail("Erwartet NegativAmountException - addCoin"); + fail("Erwartet at.reisinger.NegativAmountException - addCoin"); }catch (NegativAmountException negativAmountException) { - assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an Coins hinzugefügt werden")); + assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden")); } } @@ -28,9 +30,9 @@ public class CoinsTest { try { Coins coin = new Coins(10); coin.removeCoin(-10); - fail("Erwartet NegativAmountException - removeCoin"); + fail("Erwartet at.reisinger.NegativAmountException - removeCoin"); }catch (NegativAmountException negativAmountException) { - assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an Coins hinzugefügt werden")); + assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden")); } } diff --git a/src/test/java/PackageTest.java b/src/test/java/PackageTest.java index 9ec198e..10063b4 100644 --- a/src/test/java/PackageTest.java +++ b/src/test/java/PackageTest.java @@ -1,3 +1,5 @@ +import at.reisinger.*; +import at.reisinger.Package; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/src/test/java/StackTest.java b/src/test/java/StackTest.java index c81b096..75314a4 100644 --- a/src/test/java/StackTest.java +++ b/src/test/java/StackTest.java @@ -1,3 +1,4 @@ +import at.reisinger.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java index 64df1b1..d4d79a5 100644 --- a/src/test/java/StoreTest.java +++ b/src/test/java/StoreTest.java @@ -1,3 +1,5 @@ +import at.reisinger.*; +import at.reisinger.Package; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -17,7 +19,7 @@ public class StoreTest { @BeforeEach void setUp() { - //Stack + //at.reisinger.Stack card = new Card("Name", 100, ElementTyp.WATER, CardType.MONSTER); newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); cardsArrayList = new ArrayList(); @@ -30,9 +32,9 @@ public class StoreTest { nochNewCards = new Cards(cardsArrayList3); stack = new Stack(cards, nochNewCards); - //Coins + //at.reisinger.Coins Coins coins = new Coins(10); - //User + //at.reisinger.User Credentials credentials = new Credentials("username", "passwort"); user = new User(credentials, "name", "nachname", "email", stack, coins); userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", stack, coins); @@ -66,9 +68,9 @@ public class StoreTest { Cards stack = new Cards(stackArrList); User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)); ArrayList tradingDeals = new ArrayList(); - ArrayList packages = new ArrayList(); + ArrayList packages = new ArrayList(); tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); - packages.add(new Package(stack, "Test Package", 100)); + packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100)); System.out.println(user.getTradingDeals().toString()); @@ -108,9 +110,9 @@ public class StoreTest { Cards stack = new Cards(stackArrList); User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)); ArrayList tradingDeals = new ArrayList(); - ArrayList packages = new ArrayList(); + ArrayList packages = new ArrayList(); tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); - packages.add(new Package(stack, "Test Package", 100)); + packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100)); assertTrue(result.get(0).dealOk(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER))); } diff --git a/src/test/java/TradingDealTest.java b/src/test/java/TradingDealTest.java index 1e2e2e3..b43d44a 100644 --- a/src/test/java/TradingDealTest.java +++ b/src/test/java/TradingDealTest.java @@ -1,3 +1,4 @@ +import at.reisinger.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -17,7 +18,7 @@ public class TradingDealTest { @BeforeEach void setUp() { - //Stack + //at.reisinger.Stack card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); cardsArrayList = new ArrayList(); @@ -30,9 +31,9 @@ public class TradingDealTest { nochNewCards = new Cards(cardsArrayList3); stack = new Stack(cards, nochNewCards); - //Coins + //at.reisinger.Coins Coins coins = new Coins(10); - //User + //at.reisinger.User Credentials credentials = new Credentials("username", "passwort"); Credentials newCredentials = new Credentials("usernamenew", "passwortnew"); user = new User(credentials, "name", "nachname", "email", stack, coins); @@ -46,11 +47,14 @@ public class TradingDealTest { tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType); } + /* @Test void test_getTradingUser() { User result = tradingDeal.getTradingUser(); assertTrue(result.equals(user)); } + */ + @Test void test_getCardToTrade() { Card result = tradingDeal.getCardToTrade(); @@ -72,12 +76,15 @@ public class TradingDealTest { assertTrue(result==CardType.MONSTER); } + /* @Test void test_setTradingUser() { tradingDeal.setTradingUser(userNew); User result = tradingDeal.getTradingUser(); assertTrue(result.equals(userNew)); } + */ + @Test void test_setCardToTrade() { tradingDeal.setCardToTrade(newCard); diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java index 2d8b613..e78ebfa 100644 --- a/src/test/java/UserTest.java +++ b/src/test/java/UserTest.java @@ -1,3 +1,5 @@ +import at.reisinger.*; +import at.reisinger.Package; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -13,11 +15,11 @@ public class UserTest { private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; private Stack stack; private User user; - private Package myPackage; + private at.reisinger.Package myPackage; @BeforeEach void setUp() { - //Stack + //at.reisinger.Stack card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); cardsArrayList = new ArrayList(); @@ -29,12 +31,12 @@ public class UserTest { newCards = new Cards(cardsArrayList2); nochNewCards = new Cards(cardsArrayList3); stack = new Stack(cards, nochNewCards); - //Package + //at.reisinger.Package myPackage = new Package(cards, "Name", 100); - //Coins + //at.reisinger.Coins Coins coins = new Coins(10); - //User + //at.reisinger.User Credentials credentials = new Credentials("username", "pw"); user = new User(credentials, "name", "nachname", "email", stack, coins); }