From dcbb133489bbd85ffdb955689fe904379e399cb9 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Tue, 13 Oct 2020 23:42:12 +0200 Subject: [PATCH 01/20] Unit Test created and Classes created --- .idea/uiDesigner.xml | 124 ++++++++++++++++++++++ pom.xml | 14 +++ src/main/java/Battle.java | 2 + src/main/java/Card.java | 37 +++++++ src/main/java/CardType.java | 3 + src/main/java/Cards.java | 23 ++++ src/main/java/Coins.java | 21 ++++ src/main/java/Credentials.java | 2 + src/main/java/DBConnection.java | 2 + src/main/java/EffectivnessType.java | 5 + src/main/java/ElementTyp.java | 3 + src/main/java/MonsterCard.java | 5 + src/main/java/NegativAmountException.java | 2 + src/main/java/Package.java | 17 +++ src/main/java/SpellCard.java | 5 + src/main/java/Stack.java | 17 +++ src/main/java/Store.java | 15 +++ src/main/java/TradingDeal.java | 43 ++++++++ src/main/java/User.java | 55 ++++++++++ src/test/java/CardTest.java | 56 ++++++++++ src/test/java/CardsTest.java | 37 +++++++ src/test/java/CoinsTest.java | 62 +++++++++++ src/test/java/PackageTest.java | 46 ++++++++ src/test/java/StackTest.java | 43 ++++++++ src/test/java/StoreTest.java | 82 ++++++++++++++ src/test/java/TradingDealTest.java | 103 ++++++++++++++++++ src/test/java/UserTest.java | 79 ++++++++++++++ 27 files changed, 903 insertions(+) create mode 100644 .idea/uiDesigner.xml create mode 100644 src/main/java/Battle.java create mode 100644 src/main/java/Card.java create mode 100644 src/main/java/CardType.java create mode 100644 src/main/java/Cards.java create mode 100644 src/main/java/Coins.java create mode 100644 src/main/java/Credentials.java create mode 100644 src/main/java/DBConnection.java create mode 100644 src/main/java/EffectivnessType.java create mode 100644 src/main/java/ElementTyp.java create mode 100644 src/main/java/MonsterCard.java create mode 100644 src/main/java/NegativAmountException.java create mode 100644 src/main/java/Package.java create mode 100644 src/main/java/SpellCard.java create mode 100644 src/main/java/Stack.java create mode 100644 src/main/java/Store.java create mode 100644 src/main/java/TradingDeal.java create mode 100644 src/main/java/User.java create mode 100644 src/test/java/CardTest.java create mode 100644 src/test/java/CardsTest.java create mode 100644 src/test/java/CoinsTest.java create mode 100644 src/test/java/PackageTest.java create mode 100644 src/test/java/StackTest.java create mode 100644 src/test/java/StoreTest.java create mode 100644 src/test/java/TradingDealTest.java create mode 100644 src/test/java/UserTest.java diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml new file mode 100644 index 0000000..e96534f --- /dev/null +++ b/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml index 493c880..af721d2 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,20 @@ at.reisinger.mtcg MTCG 1.0-SNAPSHOT + + + junit + junit + RELEASE + test + + + org.junit.jupiter + junit-jupiter + RELEASE + test + + \ No newline at end of file diff --git a/src/main/java/Battle.java b/src/main/java/Battle.java new file mode 100644 index 0000000..b1d3db6 --- /dev/null +++ b/src/main/java/Battle.java @@ -0,0 +1,2 @@ +public class Battle { +} diff --git a/src/main/java/Card.java b/src/main/java/Card.java new file mode 100644 index 0000000..3d57be6 --- /dev/null +++ b/src/main/java/Card.java @@ -0,0 +1,37 @@ +public class Card { + public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) { + + } + + public String getName() { + return ""; + } + + public int getDamage() { + return 0; + } + + public ElementTyp getElementTyp() { + return null; + } + + public CardType getCardType() { + return null; + } + + public EffectivnessType getEffectivenessAgainst() { + return null; + } + + public boolean setName(String neuerName) { + return false; + } + + public boolean setDamage(int damage) { + return false; + } + + public boolean setElementType(ElementTyp elementTyp) { + return false; + } +} diff --git a/src/main/java/CardType.java b/src/main/java/CardType.java new file mode 100644 index 0000000..6256f99 --- /dev/null +++ b/src/main/java/CardType.java @@ -0,0 +1,3 @@ +public enum CardType { + MONSTER, SPELL +} diff --git a/src/main/java/Cards.java b/src/main/java/Cards.java new file mode 100644 index 0000000..1710848 --- /dev/null +++ b/src/main/java/Cards.java @@ -0,0 +1,23 @@ +import java.util.ArrayList; + +public class Cards { + public Cards(ArrayList cardsArrayList) { + + } + + public Cards() { + + } + + public void addCard(Card newCard) { + + } + + public ArrayList getCards() { + return null; + } + + public boolean delCard(Card delCard) { + return false; + } +} diff --git a/src/main/java/Coins.java b/src/main/java/Coins.java new file mode 100644 index 0000000..480e72f --- /dev/null +++ b/src/main/java/Coins.java @@ -0,0 +1,21 @@ +public class Coins { + public Coins(int coins) { + + } + + public int getCoinAmount() { + return 0; + } + + public void addCoin(int coins) throws NegativAmountException{ + throw new NegativAmountException(); + } + + public boolean removeCoin(int coins) throws NegativAmountException{ + throw new NegativAmountException(); + } + + public boolean changeCoinAmmount(int coins) { + return false; + } +} diff --git a/src/main/java/Credentials.java b/src/main/java/Credentials.java new file mode 100644 index 0000000..f9f52d3 --- /dev/null +++ b/src/main/java/Credentials.java @@ -0,0 +1,2 @@ +public class Credentials { +} diff --git a/src/main/java/DBConnection.java b/src/main/java/DBConnection.java new file mode 100644 index 0000000..508cea6 --- /dev/null +++ b/src/main/java/DBConnection.java @@ -0,0 +1,2 @@ +public class DBConnection { +} diff --git a/src/main/java/EffectivnessType.java b/src/main/java/EffectivnessType.java new file mode 100644 index 0000000..64b64b7 --- /dev/null +++ b/src/main/java/EffectivnessType.java @@ -0,0 +1,5 @@ +public enum EffectivnessType { + EFFEKTIVE, + NOTEFFEKTIVE, + NOEFFEKT +} diff --git a/src/main/java/ElementTyp.java b/src/main/java/ElementTyp.java new file mode 100644 index 0000000..df2fa30 --- /dev/null +++ b/src/main/java/ElementTyp.java @@ -0,0 +1,3 @@ +public enum ElementTyp { + WATER, FIRE +} diff --git a/src/main/java/MonsterCard.java b/src/main/java/MonsterCard.java new file mode 100644 index 0000000..2036952 --- /dev/null +++ b/src/main/java/MonsterCard.java @@ -0,0 +1,5 @@ +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/NegativAmountException.java new file mode 100644 index 0000000..7a79134 --- /dev/null +++ b/src/main/java/NegativAmountException.java @@ -0,0 +1,2 @@ +public class NegativAmountException extends Exception { +} diff --git a/src/main/java/Package.java b/src/main/java/Package.java new file mode 100644 index 0000000..9abf442 --- /dev/null +++ b/src/main/java/Package.java @@ -0,0 +1,17 @@ +public class Package extends Cards{ + public Package(Cards stack, Cards deck, String name, int price) { + + } + + public String getName() { + return null; + } + + public int getPrice() { + return 0; + } + + public void setName(String neuName) { + + } +} diff --git a/src/main/java/SpellCard.java b/src/main/java/SpellCard.java new file mode 100644 index 0000000..fb74e62 --- /dev/null +++ b/src/main/java/SpellCard.java @@ -0,0 +1,5 @@ +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/Stack.java new file mode 100644 index 0000000..2e63a5f --- /dev/null +++ b/src/main/java/Stack.java @@ -0,0 +1,17 @@ +public class Stack extends Cards{ + public Stack(Cards cards, Cards nochNewCards) { + + } + + public void addDeck(Cards newCards) { + + } + + public Cards getDeck() { + return null; + } + + public boolean delDeck(Cards delCards) { + return false; + } +} diff --git a/src/main/java/Store.java b/src/main/java/Store.java new file mode 100644 index 0000000..8fd1096 --- /dev/null +++ b/src/main/java/Store.java @@ -0,0 +1,15 @@ +import java.util.ArrayList; + +public interface Store { + DBConnection db = new DBConnection(); + + void addTradingDeal(TradingDeal tradingDeal); + + ArrayList getTradingDeals(); + + boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2); + + ArrayList getPossibleTradingDeals(); + + ArrayList getPossibleAvailableTradingDeals(); +} diff --git a/src/main/java/TradingDeal.java b/src/main/java/TradingDeal.java new file mode 100644 index 0000000..a09dc28 --- /dev/null +++ b/src/main/java/TradingDeal.java @@ -0,0 +1,43 @@ +public class TradingDeal { + public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) { + } + + public User getTradingUser() { + return null; + } + + public Card getCardToTrade() { + return null; + } + + public ElementTyp getRequiredElementType() { + return null; + } + + public int getRequiredMinDamage() { + return 0; + } + + public CardType getRequiredCardType() { + return null; + } + + public void setTradingUser(User user) { + + } + + public void setCardToTrade(Card card) { + + } + + public void setRequiredElementType(ElementTyp elementTyp) { + } + + public void setRequiredMinDamage(int damage) { + + } + + public void setRequiredCardType(CardType cardType) { + + } +} diff --git a/src/main/java/User.java b/src/main/java/User.java new file mode 100644 index 0000000..0e68ec7 --- /dev/null +++ b/src/main/java/User.java @@ -0,0 +1,55 @@ +import java.util.ArrayList; + +public class User implements Store{ + public User(Credentials credentials, String name, String nachname, String email, Stack stack, Coins coins) { + + } + + public String getName() { + return null; + } + + public String getNachname() { + return null; + } + + public String getEmail() { + return null; + } + + public String setName(String name) { + return null; + } + + public String setNachname(String nachname) { + return null; + } + + public String setEmail(String email) { + return null; + } + + public Cards buyPackage(Package mypackage) { + return null; + } + + public void addTradingDeal(TradingDeal tradingDeal) { + + } + + public ArrayList getTradingDeals() { + return null; + } + + public boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2) { + return false; + } + + public ArrayList getPossibleTradingDeals() { + return null; + } + + public ArrayList getPossibleAvailableTradingDeals() { + return null; + } +} diff --git a/src/test/java/CardTest.java b/src/test/java/CardTest.java new file mode 100644 index 0000000..2aedfe5 --- /dev/null +++ b/src/test/java/CardTest.java @@ -0,0 +1,56 @@ +import org.junit.Test; + + + + +import static org.junit.Assert.*; + +public class CardTest { + + @Test + public void test_getName() { + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); + assertTrue(card.getName() != ""); + } + @Test + public void test_getDamage() { + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); + assertTrue(card.getDamage() >= 0); + } + @Test + public void test_getElementType() { + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); + ElementTyp elementTyp = card.getElementTyp(); + assertTrue(elementTyp != null); + } + @Test + public void test_getCardType() { + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); + CardType cardType = card.getCardType(); + assertTrue(cardType != null); + } + @Test + public void test_getEffectivenessAgainst() { + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); + EffectivnessType effectivnessType = card.getEffectivenessAgainst(); + assertTrue(effectivnessType != null); + } + @Test + public void test_setName() { + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); + boolean result = card.setName("NeuerName"); + assertTrue(result); + } + @Test + public void test_setDamage() { + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); + boolean result = card.setDamage(100); + assertTrue(result); + } + @Test + public void test_setElementTyp() { + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); + boolean result = card.setElementType(ElementTyp.WATER); + assertTrue(result); + } +} diff --git a/src/test/java/CardsTest.java b/src/test/java/CardsTest.java new file mode 100644 index 0000000..eb40f8c --- /dev/null +++ b/src/test/java/CardsTest.java @@ -0,0 +1,37 @@ +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import static org.junit.Assert.assertTrue; +import java.util.ArrayList; + +public class CardsTest { + public Card newCard, card; + public Cards cards; + public ArrayList cardsArrayList; + @BeforeEach + void setUp() { + card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + cardsArrayList = new ArrayList(); + cardsArrayList.add(card); + cards = new Cards(cardsArrayList); + } + + @Test + void test_addCard() { + ArrayList result = cards.getCards(); + cards.addCard(newCard); + cardsArrayList.add(newCard); + assertTrue(result == cardsArrayList); + } + @Test + void test_delCard() { + boolean result = cards.delCard(newCard); + assertTrue(result); + } + @Test + void test_getCards() { + ArrayList result = cards.getCards(); + assertTrue(result == cardsArrayList); + } + +} diff --git a/src/test/java/CoinsTest.java b/src/test/java/CoinsTest.java new file mode 100644 index 0000000..580f423 --- /dev/null +++ b/src/test/java/CoinsTest.java @@ -0,0 +1,62 @@ +import static org.hamcrest.CoreMatchers.allOf; +import static org.hamcrest.CoreMatchers.anyOf; +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.CoreMatchers.not; +import static org.hamcrest.core.Is.is; +import static org.junit.Assert.*; + +import org.junit.Test; + + +public class CoinsTest { + + @Test + public void test_getCoinAmount(){ + Coins coin = new Coins(10); + assertTrue("Fehler getCoinAmmount ist negativ",coin.getCoinAmount() >= 0); + } + + @Test + public void test_addCoinException(){ + try { + Coins coin = new Coins(10); + coin.addCoin(-10); + fail("Erwartet NegativAmountException - addCoin"); + }catch (NegativAmountException negativAmountException) { + assertThat(negativAmountException.getMessage(), is("negativAmountException")); + } + } + + @Test + public void test_removeCoinException(){ + try { + Coins coin = new Coins(10); + coin.removeCoin(-10); + fail("Erwartet NegativAmountException - removeCoin"); + }catch (NegativAmountException negativAmountException) { + assertThat(negativAmountException.getMessage(), is("negativAmountException")); + } + } + + @Test + public void test_removeCoin(){ + Coins coin = new Coins(10); + try { + assertTrue(coin.removeCoin(10)); + } catch (NegativAmountException e) { + e.printStackTrace(); + } + } + + @Test + public void test_changeCoinAmount_true(){ + Coins coin = new Coins(10); + assertTrue(coin.changeCoinAmmount(-10)); + } + + @Test + public void test_changeCoinAmount_false(){ + Coins coin = new Coins(9); + assertFalse(coin.changeCoinAmmount(-10)); + } +} diff --git a/src/test/java/PackageTest.java b/src/test/java/PackageTest.java new file mode 100644 index 0000000..9d8fb99 --- /dev/null +++ b/src/test/java/PackageTest.java @@ -0,0 +1,46 @@ +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; + +import static org.junit.Assert.assertTrue; + +public class PackageTest { + private Cards newCards, cards, nochNewCards; + private Card newCard, card; + private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; + private Package myPackage; + @BeforeEach + void setUp() { + card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + cardsArrayList = new ArrayList(); + cardsArrayList2 = new ArrayList(); + cardsArrayList3 = new ArrayList(); + cardsArrayList.add(card); + cardsArrayList2.add(newCard); + cards = new Cards(cardsArrayList); + newCards = new Cards(cardsArrayList2); + nochNewCards = new Cards(cardsArrayList3); + myPackage = new Package(cards, nochNewCards, "Name", 100); + } + + @Test + void test_getName() { + String result = myPackage.getName(); + assertTrue(result=="Name"); + } + + @Test + void test_getPrice() { + int result = myPackage.getPrice(); + assertTrue(result==100); + } + + @Test + void test_setName() { + myPackage.setName("neuName"); + String result = myPackage.getName(); + assertTrue(result=="neuName"); + } +} diff --git a/src/test/java/StackTest.java b/src/test/java/StackTest.java new file mode 100644 index 0000000..0b8a4b5 --- /dev/null +++ b/src/test/java/StackTest.java @@ -0,0 +1,43 @@ +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; + +import static org.junit.Assert.assertTrue; + +public class StackTest { + private Cards newCards, cards, nochNewCards; + private Card newCard, card; + private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; + private Stack stack; + @BeforeEach + void setUp() { + card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + cardsArrayList = new ArrayList(); + cardsArrayList2 = new ArrayList(); + cardsArrayList3 = new ArrayList(); + cardsArrayList.add(card); + cardsArrayList2.add(newCard); + cards = new Cards(cardsArrayList); + newCards = new Cards(cardsArrayList2); + nochNewCards = new Cards(cardsArrayList3); + stack = new Stack(cards, nochNewCards); + } + @Test + void test_addDeck() { + stack.addDeck(newCards); + Cards result = stack.getDeck(); + assertTrue(result == newCards); + } + @Test + void test_delDeck() { + boolean result = stack.delDeck(cards); + assertTrue(result); + } + @Test + void test_getDeck() { + Cards result = stack.getDeck(); + assertTrue(result == cards); + } +} diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java new file mode 100644 index 0000000..cc82604 --- /dev/null +++ b/src/test/java/StoreTest.java @@ -0,0 +1,82 @@ +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; + +import static org.junit.Assert.assertTrue; + +public class StoreTest { + + private TradingDeal tradingDeal; + private Cards newCards, cards, nochNewCards; + private Card newCard, card; + private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; + private Stack stack; + private User user, userNew; + private Store store; + + @BeforeEach + void setUp() { + //Stack + card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + cardsArrayList = new ArrayList(); + cardsArrayList2 = new ArrayList(); + cardsArrayList3 = new ArrayList(); + cardsArrayList.add(card); + cardsArrayList2.add(newCard); + cards = new Cards(cardsArrayList); + newCards = new Cards(cardsArrayList2); + nochNewCards = new Cards(cardsArrayList3); + stack = new Stack(cards, nochNewCards); + + //Coins + Coins coins = new Coins(10); + //User + Credentials credentials = new Credentials(); + user = new User(credentials, "name", "nachname", "email", stack, coins); + userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", stack, coins); + + //Trading Deal + Card cardToTrade = card; + ElementTyp requiredElementType = ElementTyp.FIRE; + double requiredMinDamage = 100; + CardType requiredCardType = CardType.MONSTER; + tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType); + + } + + @Test + void test_addTradingDeal() { + user.addTradingDeal(tradingDeal); + ArrayList expected = new ArrayList(); + expected.add(tradingDeal); + assertTrue(user.getTradingDeals() == expected); + } + @Test + void test_doTrade() { + boolean result = user.doTrading(tradingDeal, tradingDeal); + assertTrue(result); + } + @Test + void test_getTradingDeals() { + ArrayList result = user.getTradingDeals(); + ArrayList expected = new ArrayList(); + expected.add(tradingDeal); + assertTrue(result == expected); + } + @Test + void test_getPossibleTradingDeals() { + ArrayList result = user.getPossibleTradingDeals(); + ArrayList expected = new ArrayList(); + expected.add(tradingDeal); + assertTrue(result == expected); + } + @Test + void test_getAvailableTradingDeals() { + ArrayList result = user.getPossibleAvailableTradingDeals(); + ArrayList expected = new ArrayList(); + expected.add(tradingDeal); + assertTrue(result == expected); + } +} diff --git a/src/test/java/TradingDealTest.java b/src/test/java/TradingDealTest.java new file mode 100644 index 0000000..3d32afb --- /dev/null +++ b/src/test/java/TradingDealTest.java @@ -0,0 +1,103 @@ +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; + +import static org.junit.Assert.assertTrue; + +public class TradingDealTest { + + private TradingDeal tradingDeal; + private Cards newCards, cards, nochNewCards; + private Card newCard, card; + private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; + private Stack stack; + private User user, userNew; + + @BeforeEach + void setUp() { + //Stack + card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + cardsArrayList = new ArrayList(); + cardsArrayList2 = new ArrayList(); + cardsArrayList3 = new ArrayList(); + cardsArrayList.add(card); + cardsArrayList2.add(newCard); + cards = new Cards(cardsArrayList); + newCards = new Cards(cardsArrayList2); + nochNewCards = new Cards(cardsArrayList3); + stack = new Stack(cards, nochNewCards); + + //Coins + Coins coins = new Coins(10); + //User + Credentials credentials = new Credentials(); + user = new User(credentials, "name", "nachname", "email", stack, coins); + userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", stack, coins); + + //Trading Deal + Card cardToTrade = card; + ElementTyp requiredElementType = ElementTyp.FIRE; + double requiredMinDamage = 100; + CardType requiredCardType = CardType.MONSTER; + tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType); + } + + @Test + void test_getTradingUser() { + User result = tradingDeal.getTradingUser(); + assertTrue(result==user); + } + @Test + void test_getCardToTrade() { + Card result = tradingDeal.getCardToTrade(); + assertTrue(result==card); + } + @Test + void test_getRequiredElementType() { + ElementTyp result = tradingDeal.getRequiredElementType(); + assertTrue(result==ElementTyp.FIRE); + } + @Test + void test_getRequiredMinDamage() { + int result = tradingDeal.getRequiredMinDamage(); + assertTrue(result==100); + } + @Test + void test_getRequiredCardType() { + CardType result = tradingDeal.getRequiredCardType(); + assertTrue(result==CardType.MONSTER); + } + + @Test + void test_setTradingUser() { + tradingDeal.setTradingUser(userNew); + User result = tradingDeal.getTradingUser(); + assertTrue(result==userNew); + } + @Test + void test_setCardToTrade() { + tradingDeal.setCardToTrade(newCard); + Card result = tradingDeal.getCardToTrade(); + assertTrue(result==newCard); + } + @Test + void test_setRequiredElementType() { + tradingDeal.setRequiredElementType(ElementTyp.WATER); + ElementTyp result = tradingDeal.getRequiredElementType(); + assertTrue(result==ElementTyp.WATER); + } + @Test + void test_setRequiredMinDamage() { + tradingDeal.setRequiredMinDamage(10); + int result = tradingDeal.getRequiredMinDamage(); + assertTrue(result==10); + } + @Test + void test_setRequiredCardType() { + tradingDeal.setRequiredCardType(CardType.SPELL); + CardType result = tradingDeal.getRequiredCardType(); + assertTrue(result==CardType.SPELL); + } +} diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java new file mode 100644 index 0000000..2dcef10 --- /dev/null +++ b/src/test/java/UserTest.java @@ -0,0 +1,79 @@ +import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; + +import java.util.ArrayList; + +import static org.junit.Assert.assertTrue; + +public class UserTest { + private TradingDeal tradingDeal; + private Cards newCards, cards, nochNewCards; + private Card newCard, card; + private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; + private Stack stack; + private User user; + private Package myPackage; + + @BeforeEach + void setUp() { + //Stack + card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + cardsArrayList = new ArrayList(); + cardsArrayList2 = new ArrayList(); + cardsArrayList3 = new ArrayList(); + cardsArrayList.add(card); + cardsArrayList2.add(newCard); + cards = new Cards(cardsArrayList); + newCards = new Cards(cardsArrayList2); + nochNewCards = new Cards(cardsArrayList3); + stack = new Stack(cards, nochNewCards); + //Package + myPackage = new Package(cards, nochNewCards, "Name", 100); + + //Coins + Coins coins = new Coins(10); + //User + Credentials credentials = new Credentials(); + user = new User(credentials, "name", "nachname", "email", stack, coins); + } + @Test + public void test_getName() { + String result = user.getName(); + assertTrue(result != ""); + } + @Test + public void test_getNachname() { + String result = user.getNachname(); + assertTrue(result != ""); + } + @Test + public void test_getEmail() { + String result = user.getEmail(); + assertTrue(result != ""); + } + + @Test + public void test_setName() { + String newstring = "new"; + String result = user.setName(newstring); + assertTrue(result != newstring); + } + @Test + public void test_setNachname() { + String newstring = "new"; + String result = user.setNachname(newstring); + assertTrue(result != newstring); + } + @Test + public void test_setEmail() { + String newstring = "new"; + String result = user.setEmail(newstring); + assertTrue(result != newstring); + } + @Test + public void test_buyPackage(){ + Cards cards = user.buyPackage(myPackage); + assertTrue(cards != null); + } +} From cfdab3230dd617527cd32a6ecb4397650f0d505b Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Thu, 15 Oct 2020 10:42:53 +0200 Subject: [PATCH 02/20] Gitignore + JUnit5 import fix --- .gitignore | 23 +++++++++++++++++++++++ pom.xml | 16 ++++++++++------ src/test/java/CardTest.java | 7 ++----- src/test/java/CardsTest.java | 3 ++- src/test/java/CoinsTest.java | 18 +++++++----------- src/test/java/PackageTest.java | 3 ++- src/test/java/SimpleCardTest.java | 18 ++++++++++++++++++ src/test/java/StackTest.java | 3 ++- src/test/java/StoreTest.java | 2 +- src/test/java/TradingDealTest.java | 3 ++- src/test/java/UserTest.java | 5 +++-- 11 files changed, 72 insertions(+), 29 deletions(-) create mode 100644 .gitignore create mode 100644 src/test/java/SimpleCardTest.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..dc7bdeb --- /dev/null +++ b/.gitignore @@ -0,0 +1,23 @@ +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* \ No newline at end of file diff --git a/pom.xml b/pom.xml index af721d2..e091ca9 100644 --- a/pom.xml +++ b/pom.xml @@ -8,18 +8,22 @@ MTCG 1.0-SNAPSHOT - - junit - junit - RELEASE - test - org.junit.jupiter junit-jupiter RELEASE test + + org.mockito + mockito-core + 3.5.13 + + + org.mockito + mockito-junit-jupiter + 3.5.13 + diff --git a/src/test/java/CardTest.java b/src/test/java/CardTest.java index 2aedfe5..2a17ca6 100644 --- a/src/test/java/CardTest.java +++ b/src/test/java/CardTest.java @@ -1,9 +1,6 @@ -import org.junit.Test; +import org.junit.jupiter.api.Test; - - - -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertTrue; public class CardTest { diff --git a/src/test/java/CardsTest.java b/src/test/java/CardsTest.java index eb40f8c..0ab708b 100644 --- a/src/test/java/CardsTest.java +++ b/src/test/java/CardsTest.java @@ -1,8 +1,9 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertTrue; import java.util.ArrayList; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class CardsTest { public Card newCard, card; public Cards cards; diff --git a/src/test/java/CoinsTest.java b/src/test/java/CoinsTest.java index 580f423..56bd270 100644 --- a/src/test/java/CoinsTest.java +++ b/src/test/java/CoinsTest.java @@ -1,19 +1,15 @@ -import static org.hamcrest.CoreMatchers.allOf; -import static org.hamcrest.CoreMatchers.anyOf; -import static org.hamcrest.CoreMatchers.hasItems; -import static org.hamcrest.CoreMatchers.not; -import static org.hamcrest.core.Is.is; -import static org.junit.Assert.*; - -import org.junit.Test; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; +import static org.junit.jupiter.api.Assertions.assertFalse; public class CoinsTest { @Test public void test_getCoinAmount(){ Coins coin = new Coins(10); - assertTrue("Fehler getCoinAmmount ist negativ",coin.getCoinAmount() >= 0); + assertTrue(coin.getCoinAmount() >= 0); } @Test @@ -23,7 +19,7 @@ public class CoinsTest { coin.addCoin(-10); fail("Erwartet NegativAmountException - addCoin"); }catch (NegativAmountException negativAmountException) { - assertThat(negativAmountException.getMessage(), is("negativAmountException")); + assertTrue(negativAmountException.getMessage()=="negativAmountException"); } } @@ -34,7 +30,7 @@ public class CoinsTest { coin.removeCoin(-10); fail("Erwartet NegativAmountException - removeCoin"); }catch (NegativAmountException negativAmountException) { - assertThat(negativAmountException.getMessage(), is("negativAmountException")); + assertTrue(negativAmountException.getMessage()=="negativAmountException"); } } diff --git a/src/test/java/PackageTest.java b/src/test/java/PackageTest.java index 9d8fb99..f117be2 100644 --- a/src/test/java/PackageTest.java +++ b/src/test/java/PackageTest.java @@ -3,7 +3,8 @@ import org.junit.jupiter.api.Test; import java.util.ArrayList; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class PackageTest { private Cards newCards, cards, nochNewCards; diff --git a/src/test/java/SimpleCardTest.java b/src/test/java/SimpleCardTest.java new file mode 100644 index 0000000..602bf5b --- /dev/null +++ b/src/test/java/SimpleCardTest.java @@ -0,0 +1,18 @@ +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.mockito.Mockito.mock; + +public class SimpleCardTest { + + @Test + @DisplayName("Test - getName()") + public void test_getName(){ + //arrange + Card mockedA = mock(Card.class); //Erstellt einen Mock + String name = "Neuer Name"; + //act + + //assert + } +} diff --git a/src/test/java/StackTest.java b/src/test/java/StackTest.java index 0b8a4b5..dfc491c 100644 --- a/src/test/java/StackTest.java +++ b/src/test/java/StackTest.java @@ -3,7 +3,8 @@ import org.junit.jupiter.api.Test; import java.util.ArrayList; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class StackTest { private Cards newCards, cards, nochNewCards; diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java index cc82604..24a6c9e 100644 --- a/src/test/java/StoreTest.java +++ b/src/test/java/StoreTest.java @@ -3,7 +3,7 @@ import org.junit.jupiter.api.Test; import java.util.ArrayList; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; public class StoreTest { diff --git a/src/test/java/TradingDealTest.java b/src/test/java/TradingDealTest.java index 3d32afb..a1bfffc 100644 --- a/src/test/java/TradingDealTest.java +++ b/src/test/java/TradingDealTest.java @@ -3,7 +3,8 @@ import org.junit.jupiter.api.Test; import java.util.ArrayList; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class TradingDealTest { diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java index 2dcef10..b066a91 100644 --- a/src/test/java/UserTest.java +++ b/src/test/java/UserTest.java @@ -1,9 +1,10 @@ -import org.junit.Test; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.util.ArrayList; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class UserTest { private TradingDeal tradingDeal; From 061a978f6c9c0ac1f737a61abd04d55d524c5088 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Thu, 15 Oct 2020 10:44:34 +0200 Subject: [PATCH 03/20] Gitignore --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index dc7bdeb..59aaf20 100644 --- a/.gitignore +++ b/.gitignore @@ -20,4 +20,5 @@ *.rar # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml -hs_err_pid* \ No newline at end of file +hs_err_pid* +.idea/compiler.xml From 95873d7e6d2ed2adce43af2c3bd82c1cbba1f3fc Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Sun, 18 Oct 2020 12:35:58 +0200 Subject: [PATCH 04/20] Funktionen Implementiert, Tests angepasst, Java Doc added --- .gitignore | 1 + src/main/java/Card.java | 109 ++++++++++-- src/main/java/Cards.java | 65 ++++++- src/main/java/Coins.java | 56 +++++- src/main/java/Credentials.java | 46 +++++ src/main/java/DBConnection.java | 62 +++++++ src/main/java/EffectivnessType.java | 6 +- src/main/java/ElementTyp.java | 2 +- src/main/java/NegativAmountException.java | 13 ++ src/main/java/Package.java | 34 +++- src/main/java/Stack.java | 41 ++++- src/main/java/Store.java | 4 +- src/main/java/TradingDeal.java | 113 ++++++++++-- src/main/java/User.java | 201 ++++++++++++++++++++-- src/test/java/CardTest.java | 27 +-- src/test/java/CardsTest.java | 28 +-- src/test/java/CoinsTest.java | 16 +- src/test/java/PackageTest.java | 6 +- src/test/java/SimpleCardTest.java | 18 -- src/test/java/StackTest.java | 11 +- src/test/java/StoreTest.java | 66 +++++-- src/test/java/TradingDealTest.java | 15 +- src/test/java/UserTest.java | 28 +-- 23 files changed, 810 insertions(+), 158 deletions(-) delete mode 100644 src/test/java/SimpleCardTest.java diff --git a/.gitignore b/.gitignore index 59aaf20..45b7d7f 100644 --- a/.gitignore +++ b/.gitignore @@ -22,3 +22,4 @@ # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* .idea/compiler.xml +*.lst diff --git a/src/main/java/Card.java b/src/main/java/Card.java index 3d57be6..d74cfbf 100644 --- a/src/main/java/Card.java +++ b/src/main/java/Card.java @@ -1,37 +1,118 @@ +/** + * Object einer Card + */ public class Card { + private String name; + private double damage; + private ElementTyp elementTyp; + private CardType cardType; + + /** + * Erstellt eine neue Card mit gegebenen Eigenschaften + * @param name Name der Card + * @param damage Damage den die Card macht + * @param elementTyp ElementType der Card + * @param cardType CardType der Card + */ public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) { - + this.name = name; + this.damage = damage; + this.elementTyp = elementTyp; + this.cardType = cardType; } + /** + * Holt den Namen der Card + * @return Name der Card + */ public String getName() { - return ""; + return this.name; } - public int getDamage() { - return 0; + /** + * Holt den Damage der Card + * @return Damage der Card + */ + public double getDamage() { + return this.damage; } + /** + * Holt den ElementType der Card + * @return ElementType der Card + */ public ElementTyp getElementTyp() { - return null; + return this.elementTyp; } + /** + * Holt den CardType der Card + * @return CardType der Card + */ public CardType getCardType() { - return null; + return this.cardType; } - public EffectivnessType getEffectivenessAgainst() { - return null; + /** + * Berechnet die Wirksamkeit gegen eine Andere card. Die Card im Parameter wird angegriffen + * @param toCeck Card gegen welche die Wirksamkeit geprüft werden soll + * @return Gibt die Wirksamkeit zurück + * @throws InternalError Wenn die Effectifeness von den 2 Cards nicht berechnet werden kann + */ + public EffectivnessType getEffectivenessAgainst(Card toCeck) { + if(toCeck.getCardType() == CardType.MONSTER){ + if(this.cardType == CardType.MONSTER){ + return EffectivnessType.NOEFFECT; + }else if (this.cardType == CardType.SPELL){ + + } + }else if (toCeck.getCardType() == CardType.SPELL){ + if ((toCeck.getElementTyp() == ElementTyp.FIRE && this.elementTyp == ElementTyp.WATER) || (toCeck.getElementTyp() == ElementTyp.NORMAL && this.elementTyp == ElementTyp.FIRE) || (toCeck.getElementTyp() == ElementTyp.WATER && this.elementTyp == ElementTyp.NORMAL)){ + return EffectivnessType.EFFECTIVE; + }else if (this.elementTyp == ElementTyp.FIRE && toCeck.getElementTyp() == ElementTyp.WATER){ + return EffectivnessType.NOTEFFECTIVE; + }else if ((toCeck.getElementTyp() == ElementTyp.NORMAL && this.cardType == CardType.MONSTER && this.elementTyp == ElementTyp.NORMAL)){ + return EffectivnessType.NOEFFECT; + } + } + throw new InternalError("Konnte die Effectiveness von den Cards nicht berechnen"); } - public boolean setName(String neuerName) { - return false; + /** + * Setztden namen der Card + * @param neuerName Name der Card + */ + public void setName(String neuerName) { + this.name = name; } - public boolean setDamage(int damage) { - return false; + /** + * Setzt den Damage der Card + * @param damage Der Damage + */ + public void setDamage(int damage) { + this.damage = damage; } - public boolean setElementType(ElementTyp elementTyp) { - return false; + /** + * Setzt den ElementType der Card + * @param elementTyp Der ElementType + */ + public void setElementType(ElementTyp elementTyp) { + this.elementTyp = elementTyp; + } + + /** + * Testet ob die beiden Karten gleich sind + * @param card Card die geprüft werden soll + * @return True wenn die Karten übereinstimmen + */ + public boolean equals(Card card){ + if(card == null) return false; + if(this.name == card.getName() && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage()){ + return true; + }else { + return false; + } } } diff --git a/src/main/java/Cards.java b/src/main/java/Cards.java index 1710848..65f2447 100644 --- a/src/main/java/Cards.java +++ b/src/main/java/Cards.java @@ -1,23 +1,78 @@ import java.util.ArrayList; +import java.util.concurrent.atomic.AtomicBoolean; +/** + * Verwaltet eine Liste vo Cards + */ public class Cards { - public Cards(ArrayList cardsArrayList) { + private ArrayList cards; + /** + * Erstellt ein nues obj mit gegebenen Karten + * @param cardsArrayList Die Cards zum erstellen des Obj + */ + public Cards(ArrayList cardsArrayList) { + this.cards = cardsArrayList; } + /** + * Erstellt ein neues Obj ohne Cards + */ public Cards() { } + /** + * Fügt eine neue Card hinzu + * @param newCard neue Card + */ public void addCard(Card newCard) { - + this.cards.add(newCard); } + /** + * Holt alle Cards + * @return Alle Cards + */ public ArrayList getCards() { - return null; + return this.cards; } - public boolean delCard(Card delCard) { - return false; + /** + * Löscht die gegebene Card + * @param delCard Card zum löschen + */ + public void delCard(Card delCard) { + this.cards.removeIf(obj -> obj.equals(delCard)); + } + + /** + * Prüft ob eine Card in den Cards vorhanden ist + * @param toCeck Card nach der in den Cards gesucht werden soll + * @return True wenn die Card in den Cards ist + */ + public boolean containsCard(Card toCeck){ + AtomicBoolean returnval = new AtomicBoolean(false); + this.cards.forEach(item -> { + if(item.getElementTyp().equals(toCeck.getElementTyp()) && item.getCardType().equals(toCeck.getCardType()) && item.getName().equals(toCeck.getName()) && item.getDamage() == toCeck.getDamage()){ + returnval.set(true); + } + }); + return returnval.get(); + } + + /** + * Vergleicht 2 Cards Obj miteinander + * @param toCompare Cards zum vergleichen + * @return True wenn es aus den selben Cards besteht + */ + public boolean equals(Cards toCompare){ + AtomicBoolean returnval = new AtomicBoolean(false); + this.cards.forEach(item -> { + if(toCompare.containsCard(item)){ + returnval.set(true); + } + }); + return returnval.get(); } } diff --git a/src/main/java/Coins.java b/src/main/java/Coins.java index 480e72f..fd02ce9 100644 --- a/src/main/java/Coins.java +++ b/src/main/java/Coins.java @@ -1,21 +1,65 @@ +/** + * Alle coins eines Users + */ public class Coins { + private int amount; + + /** + * Erstellt ein neues Münzen Obj + * @param coins Alle münzen des Users + */ public Coins(int coins) { - + this.amount = coins; } + /** + * Holt alle münzen + * @return Alle münzen + */ public int getCoinAmount() { - return 0; + return this.amount; } + /** + * Fügt münzen hinzu + * @param coins Münzen die hinzugefügt werden -> Positiv + * @throws NegativAmountException Wenn negative münzen hinzugefüght werden + */ public void addCoin(int coins) throws NegativAmountException{ - throw new NegativAmountException(); + if(coins < 0) { + throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden"); + }else { + this.amount += coins; + } } + /** + * Entfernt münzen + * @param coins Münzen die entfernt werden sollen, muss positiv sein + * @return True wenn erfolgreich + * @throws NegativAmountException Wenn ein negativer betrag abgezogen werden soll + */ public boolean removeCoin(int coins) throws NegativAmountException{ - throw new NegativAmountException(); + if(coins < 0) { + throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden"); + }else { + this.amount -= coins; + return true; + } } - public boolean changeCoinAmmount(int coins) { - return false; + /** + * Ändert den Absoluten Coin amount + * @param coins Neue Coin anzahl, muss positiv sein + * @return true wenn erfolgreich + * @throws NegativAmountException Wenn ein negativer wert eingegeben wird + */ + public boolean changeCoinAmmount(int coins) throws NegativAmountException{ + if(coins < 0) { + throw new NegativAmountException("Es kann kein negativer amount an Coins hinzugefügt werden"); + }else { + this.amount = coins; + return true; + } } } diff --git a/src/main/java/Credentials.java b/src/main/java/Credentials.java index f9f52d3..01818c8 100644 --- a/src/main/java/Credentials.java +++ b/src/main/java/Credentials.java @@ -1,2 +1,48 @@ +/** + * User Login Daten + */ public class Credentials { + private String passwort, username; + + /** + * Startet einen neuen User mit folgenden Daten + * @param username Diesem Usernamen + * @param passwort Diesem Passwort + */ + public Credentials(String username, String passwort){ + this.username = username; + this.passwort = passwort; + } + + /** + * Holt das Passwort des users + * @return PW des Users + */ + public String getPasswort() { + return passwort; + } + + /** + * Setzt das User Passwort + * @param passwort Neues Passwort + */ + public void setPasswort(String passwort) { + this.passwort = passwort; + } + + /** + * Holt den Usernamen des Users + * @return Username + */ + public String getUsername() { + return username; + } + + /** + * Setzt einen neuen Usernamen + * @param username Neuer Username + */ + public void setUsername(String username) { + this.username = username; + } } diff --git a/src/main/java/DBConnection.java b/src/main/java/DBConnection.java index 508cea6..3e734b1 100644 --- a/src/main/java/DBConnection.java +++ b/src/main/java/DBConnection.java @@ -1,2 +1,64 @@ +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); + Cards deck = new Cards(); + Cards stack = new Cards(); + deck.addCard(c1); + deck.addCard(c2); + stack.addCard(c3); + stack.addCard(c4); + stack.addCard(c5); + User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)); + this.tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.SPELL)); + this.packages.add(new Package(stack, "Test Package", 100)); + } + + /** + * Holt alle verfügbaren TradingDeals + * @return Alle Trading Deals + */ + public ArrayList 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/EffectivnessType.java b/src/main/java/EffectivnessType.java index 64b64b7..150ce66 100644 --- a/src/main/java/EffectivnessType.java +++ b/src/main/java/EffectivnessType.java @@ -1,5 +1,5 @@ public enum EffectivnessType { - EFFEKTIVE, - NOTEFFEKTIVE, - NOEFFEKT + EFFECTIVE, + NOTEFFECTIVE, + NOEFFECT } diff --git a/src/main/java/ElementTyp.java b/src/main/java/ElementTyp.java index df2fa30..e9360db 100644 --- a/src/main/java/ElementTyp.java +++ b/src/main/java/ElementTyp.java @@ -1,3 +1,3 @@ public enum ElementTyp { - WATER, FIRE + WATER, FIRE, NORMAL } diff --git a/src/main/java/NegativAmountException.java b/src/main/java/NegativAmountException.java index 7a79134..a9c3dd1 100644 --- a/src/main/java/NegativAmountException.java +++ b/src/main/java/NegativAmountException.java @@ -1,2 +1,15 @@ +/** + * Wenn ein negativer wert eingegeben wird aber ein Positiver erwartet wird, dann kann diese Exception geworfen werden + */ public class NegativAmountException extends Exception { + + /** + * Aufruf des Constructors der Super class Exception + * @param message Fehler Nachrichgt + * @param cause Fehler Ursache + */ + public NegativAmountException(String message){ + super(message); + } + } diff --git a/src/main/java/Package.java b/src/main/java/Package.java index 9abf442..37964ea 100644 --- a/src/main/java/Package.java +++ b/src/main/java/Package.java @@ -1,17 +1,43 @@ +/** + * Package besteht aus 4 Karten. Ist eine Erweiterung der Cards, zeigt für 4 Cards den Preis und einen Packagenamen an + */ public class Package extends Cards{ - public Package(Cards stack, Cards deck, String name, int price) { + private String name; + private int price; + /** + * Erstellt ein neues Package mit den gegebenen Stats + * @param stack Cards des Packages + * @param name Name des Packages + * @param price Price des Packages + */ + public Package(Cards stack, String name, int price) { + super(stack.getCards()); + this.name = name; + this.price = price; } + /** + * Holt den namen des Packages + * @return Name des Packages + */ public String getName() { - return null; + return this.name; } + /** + * Holt den Preis des Packages + * @return Preis des Packages + */ public int getPrice() { - return 0; + return this.price; } + /** + * Setzt den Namen des Packages + * @param neuName Neuer name des Packages + */ public void setName(String neuName) { - + this.name = neuName; } } diff --git a/src/main/java/Stack.java b/src/main/java/Stack.java index 2e63a5f..af4f858 100644 --- a/src/main/java/Stack.java +++ b/src/main/java/Stack.java @@ -1,17 +1,48 @@ +/** + * Erweitert Cards insofern, dass es im Stack auch ein Deck gibt + */ public class Stack extends Cards{ - public Stack(Cards cards, Cards nochNewCards) { + private Cards deck; + /** + * Erstellt einen neuen Stack aus den User Cards und seinem Deck + * @param cards Alle Cards des Users + * @param deck Sein Deck + */ + public Stack(Cards cards, Cards deck) { + super(cards.getCards()); + this.deck = deck; } + /** + * Fügt ein neues Deck in den Stack ein + * @param newCards Gesamtes Deck + */ public void addDeck(Cards newCards) { - + this.deck = newCards; } + /** + * Holt das gesamte Deck + * @return Gesamtes Deck + */ public Cards getDeck() { - return null; + return this.deck; } - public boolean delDeck(Cards delCards) { - return false; + /** + * Löscht eine Card aus dem Deck + * @param toDel Card zum löschen + */ + public void delDeck(Card toDel) { + this.deck.delCard(toDel); + } + + /** + * Fügt dem deck eine neue Card ein + * @param toAdd Neue Card + */ + public void addDeckCard(Card toAdd){ + this.deck.addCard(toAdd); } } diff --git a/src/main/java/Store.java b/src/main/java/Store.java index 8fd1096..9b73a45 100644 --- a/src/main/java/Store.java +++ b/src/main/java/Store.java @@ -9,7 +9,5 @@ public interface Store { boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2); - ArrayList getPossibleTradingDeals(); - - ArrayList getPossibleAvailableTradingDeals(); + ArrayList getPossibleTradingDeals(Card toTrade); } diff --git a/src/main/java/TradingDeal.java b/src/main/java/TradingDeal.java index a09dc28..80e377f 100644 --- a/src/main/java/TradingDeal.java +++ b/src/main/java/TradingDeal.java @@ -1,43 +1,128 @@ +/** + * Ein einzelner Trading deal wird hier verwaltet. + */ public class TradingDeal { + private User tradingUser; + private Card cardToTrade; + private ElementTyp requiredElementType; + private double requiredMinDamage; + private CardType requiredCardType; + + /** + * Ein TradingDeal wird erstellt + * @param user User des Deals + * @param cardToTrade Card die getauscht werden soll + * @param requiredElementType Req ElementType für den Tausch + * @param requiredMinDamage Req min damage für den Tausch + * @param requiredCardType Req Card Type für den Tausch + */ public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) { + this.tradingUser = user; + this.cardToTrade = cardToTrade; + this.requiredElementType = requiredElementType; + this.requiredMinDamage = requiredMinDamage; + this.requiredCardType = requiredCardType; } + /** + * Holt den Trading User + * @return User der den Trade erstellt hat + */ public User getTradingUser() { - return null; + return this.tradingUser; } + /** + * Card die getraded werden soll + * @return Card die getradet werden soll + */ public Card getCardToTrade() { - return null; + return this.cardToTrade; } + /** + * Req Element type holen + * @return Req Element Type + */ public ElementTyp getRequiredElementType() { - return null; + return this.requiredElementType; } - public int getRequiredMinDamage() { - return 0; + /** + * Req min damage holen + * @return Req min damage + */ + public double getRequiredMinDamage() { + return this.requiredMinDamage; } + /** + * Hole req cardtype + * @return Req CardType + */ public CardType getRequiredCardType() { - return null; + return this.requiredCardType; } - public void setTradingUser(User user) { - + /** + * Setzt den User des Trades + * @param tradingUser User der Traded + */ + public void setTradingUser(User tradingUser) { + this.tradingUser = tradingUser; } - public void setCardToTrade(Card card) { - + /** + * Setzt die Karte die Getradet werden soll + * @param cardToTrade Card zum tauschen + */ + public void setCardToTrade(Card cardToTrade) { + this.cardToTrade = cardToTrade; } - public void setRequiredElementType(ElementTyp elementTyp) { + /** + * Setzt req elementType + * @param requiredElementType Der Req elementType + */ + public void setRequiredElementType(ElementTyp requiredElementType) { + this.requiredElementType = requiredElementType; } - public void setRequiredMinDamage(int damage) { - + /** + * Setzt die req Min damage + * @param requiredMinDamage Die req min gamage + */ + public void setRequiredMinDamage(double requiredMinDamage) { + this.requiredMinDamage = requiredMinDamage; } - public void setRequiredCardType(CardType cardType) { + /** + * Setzt req cardType + * @param requiredCardType Der Req CardType + */ + public void setRequiredCardType(CardType requiredCardType) { + this.requiredCardType = requiredCardType; + } + /** + * Vom deal im Parameter wird die Card mit den Requirements von THIS verglichen + * @param checkDeal Von diesem Deal wird die CardToTrade geprüft + * @return True wenn der Deal passt + */ + public boolean dealOk(TradingDeal checkDeal){ + return this.cardOk(checkDeal.getCardToTrade()); + } + + /** + * Von der Card im Parameter wird die Card mit den Requirements von THIS verglichen + * @param checkCard Card die mit dem Deal verglichen wird + * @return True wenn der Deal passt + */ + public boolean cardOk(Card checkCard){ + if(checkCard.getCardType().equals(this.requiredCardType) && checkCard.getElementTyp().equals(this.requiredElementType) && checkCard.getDamage() >= this.requiredMinDamage){ + return true; + }else { + return false; + } } } diff --git a/src/main/java/User.java b/src/main/java/User.java index 0e68ec7..6edcfae 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -1,55 +1,218 @@ import java.util.ArrayList; +/** + * User & Store Logik + */ public class User implements Store{ + private String name, nachname, email; + private Stack stack; + private DBConnection db; + private Credentials credentials; + private Coins coins; + + /** + * Erstellt einen neuen User + * @param credentials Zugangsdaten des Users + * @param name Name des Users + * @param nachname Nachname des Users + * @param email Email des Users + * @param stack Alle Karten des Users + * @param coins Alle Münzen des Users + */ public User(Credentials credentials, String name, String nachname, String email, Stack stack, Coins coins) { - + this.credentials = credentials; + this.name = name; + this.nachname = nachname; + this.email = email; + this.stack = stack; + this.coins = coins; + this.db = new DBConnection(); } + /** + * Holt den Stack des Users + * @return Stack des Users + */ + public Stack getStack() { + return stack; + } + + /** + * Setzt den Stack eines Users + * @param stack Der neue Stack des Users + */ + public void setStack(Stack stack) { + this.stack = stack; + } + + /** + * Holt das DB Obj + * @return Das DB Obj + */ + public DBConnection getDb() { + return db; + } + + /** + * Setzt ein neues DB Obj + * @param db Das neue DB Obj + */ + public void setDb(DBConnection db) { + this.db = db; + } + + /** + * Holt die eindeutigen Logindaten des Users + * @return Eindeutige Logindaten + */ + public Credentials getCredentials() { + return credentials; + } + + /** + * Setzt die eindeutigen Logindaten + * @param credentials Die neuen Credentials des Users + */ + public void setCredentials(Credentials credentials) { + this.credentials = credentials; + } + + /** + * Holt alle Coins des Users + * @return Coins des Users + */ + public Coins getCoins() { + return coins; + } + + /** + * Setzt alle Coins des Users + * @param coins Neue Coins des Users + */ + public void setCoins(Coins coins) { + this.coins = coins; + } + + /** + * Get Name of User + * @return Name of User + */ public String getName() { - return null; + return this.name; } + /** + * Get Nachname of User + * @return Nachname of User + */ public String getNachname() { - return null; + return this.nachname; } + /** + * Email of User + * @return Email of User + */ public String getEmail() { - return null; + return this.email; } - public String setName(String name) { - return null; + /** + * Setzt den Namen des Users + * @param name Neuer Name des Users + */ + public void setName(String name) { + this.name = name; } - public String setNachname(String nachname) { - return null; + /** + * Setzt den Nachnamen + * @param nachname Neuer Nachname + */ + public void setNachname(String nachname) { + this.nachname = nachname; } - public String setEmail(String email) { - return null; + /** + * Setzt die Email des Users + * @param email Neue Email des Users + */ + public void setEmail(String email) { + this.email = email; } - public Cards buyPackage(Package mypackage) { - return null; + //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. + */ + public ArrayList buyPackage(Package mypackage) throws NegativAmountException { + ArrayList availablePackages = db.getAllPackages(); + availablePackages.removeIf(obj -> obj.equals(mypackage)); + this.coins.removeCoin(mypackage.getPrice()); + return mypackage.getCards(); } + /** + * Fügt dem Store einen neuen Tradingdeal hinzu + * @param tradingDeal Der neue Tradingdeal + */ public void addTradingDeal(TradingDeal tradingDeal) { - + db.addTradingDeal(tradingDeal); } + /** + * Holt alle verfügbaren Tradingdeals + * @return Alle verfügbaren Deals + */ public ArrayList getTradingDeals() { - return null; + return db.getAllTradingDeals(); } - public boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2) { + /** + * 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 + * @return True wenn erfolgreich, False wenn die Deals nicht zusammenpassen + */ + public boolean doTrading(TradingDeal myTradingDeal, TradingDeal storeTradingDeal) { + if (storeTradingDeal.dealOk(myTradingDeal)){ + stack.delCard(myTradingDeal.getCardToTrade()); + stack.addCard(storeTradingDeal.getCardToTrade()); + } return false; } - public ArrayList getPossibleTradingDeals() { - return null; + /** + * Gibt alle Möglichen Trading Deals zurück + * @param toTrade Prüft nach diesem Deal + * @return + */ + @Override + public ArrayList getPossibleTradingDeals(Card toTrade) { + ArrayList storeList = db.getAllTradingDeals(); + ArrayList possible = new ArrayList(); + storeList.forEach(item -> { + if(item.cardOk(toTrade)){ + possible.add(item); + } + }); + return possible; } - public ArrayList getPossibleAvailableTradingDeals() { - return null; + /** + * Checkt ob es sich um den selben User handelt + * @param toCheck Mit diesem User wird verglichen + * @return True wenn es der selbe User ist + */ + public boolean equals(User toCheck){ + if (toCheck.getCredentials().getUsername() == this.credentials.getUsername() && toCheck.getCredentials().getPasswort() == this.credentials.getPasswort()){ + return true; + }else { + return false; + } } } diff --git a/src/test/java/CardTest.java b/src/test/java/CardTest.java index 2a17ca6..9784c07 100644 --- a/src/test/java/CardTest.java +++ b/src/test/java/CardTest.java @@ -7,47 +7,48 @@ public class CardTest { @Test public void test_getName() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); - assertTrue(card.getName() != ""); + assertTrue(card.getName().equals("Name")); } @Test public void test_getDamage() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); - assertTrue(card.getDamage() >= 0); + assertTrue(card.getDamage() == 10); } @Test public void test_getElementType() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); ElementTyp elementTyp = card.getElementTyp(); - assertTrue(elementTyp != null); + assertTrue(elementTyp != ElementTyp.WATER); } @Test public void test_getCardType() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); CardType cardType = card.getCardType(); - assertTrue(cardType != null); + assertTrue(cardType != CardType.SPELL); } @Test public void test_getEffectivenessAgainst() { - Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); - EffectivnessType effectivnessType = card.getEffectivenessAgainst(); - assertTrue(effectivnessType != null); + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + Card card2 = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + EffectivnessType effectivnessType = card.getEffectivenessAgainst(card2); + assertTrue(effectivnessType != EffectivnessType.NOEFFECT); } @Test public void test_setName() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); - boolean result = card.setName("NeuerName"); - assertTrue(result); + card.setName("NeuerName"); + assertTrue(card.getName().equals("NeuerName")); } @Test public void test_setDamage() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); - boolean result = card.setDamage(100); - assertTrue(result); + card.setDamage(100); + assertTrue(card.getDamage() == 100); } @Test public void test_setElementTyp() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); - boolean result = card.setElementType(ElementTyp.WATER); - assertTrue(result); + card.setElementType(ElementTyp.FIRE); + assertTrue(card.getElementTyp() == ElementTyp.FIRE); } } diff --git a/src/test/java/CardsTest.java b/src/test/java/CardsTest.java index 0ab708b..6584e35 100644 --- a/src/test/java/CardsTest.java +++ b/src/test/java/CardsTest.java @@ -5,34 +5,40 @@ import java.util.ArrayList; import static org.junit.jupiter.api.Assertions.assertTrue; public class CardsTest { - public Card newCard, card; - public Cards cards; - public ArrayList cardsArrayList; + private Cards newCards, cards, nochNewCards; + private Card newCard, card; + private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; + private Stack stack; + @BeforeEach void setUp() { card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); cardsArrayList = new ArrayList(); + cardsArrayList2 = new ArrayList(); + cardsArrayList3 = new ArrayList(); cardsArrayList.add(card); + cardsArrayList2.add(newCard); + cardsArrayList2.add(card); cards = new Cards(cardsArrayList); + newCards = new Cards(cardsArrayList2); + nochNewCards = new Cards(cardsArrayList3); + stack = new Stack(cards, nochNewCards); } - @Test void test_addCard() { - ArrayList result = cards.getCards(); cards.addCard(newCard); - cardsArrayList.add(newCard); - assertTrue(result == cardsArrayList); + assertTrue(cards.getCards().equals(cardsArrayList2)); } @Test void test_delCard() { - boolean result = cards.delCard(newCard); - assertTrue(result); + cards.addCard(newCard); + cards.delCard(newCard); + assertTrue(cards.getCards().equals(cardsArrayList)); } @Test void test_getCards() { - ArrayList result = cards.getCards(); - assertTrue(result == cardsArrayList); + assertTrue(cards.getCards().equals(cardsArrayList)); } } diff --git a/src/test/java/CoinsTest.java b/src/test/java/CoinsTest.java index 56bd270..5f699f6 100644 --- a/src/test/java/CoinsTest.java +++ b/src/test/java/CoinsTest.java @@ -19,7 +19,7 @@ public class CoinsTest { coin.addCoin(-10); fail("Erwartet NegativAmountException - addCoin"); }catch (NegativAmountException negativAmountException) { - assertTrue(negativAmountException.getMessage()=="negativAmountException"); + assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an Coins hinzugefügt werden")); } } @@ -30,7 +30,7 @@ public class CoinsTest { coin.removeCoin(-10); fail("Erwartet NegativAmountException - removeCoin"); }catch (NegativAmountException negativAmountException) { - assertTrue(negativAmountException.getMessage()=="negativAmountException"); + assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an Coins hinzugefügt werden")); } } @@ -47,12 +47,20 @@ public class CoinsTest { @Test public void test_changeCoinAmount_true(){ Coins coin = new Coins(10); - assertTrue(coin.changeCoinAmmount(-10)); + try { + assertTrue(coin.changeCoinAmmount(10)); + } catch (NegativAmountException e) { + e.printStackTrace(); + } } @Test public void test_changeCoinAmount_false(){ Coins coin = new Coins(9); - assertFalse(coin.changeCoinAmmount(-10)); + try { + assertTrue(coin.changeCoinAmmount(7)); + } catch (NegativAmountException e) { + e.printStackTrace(); + } } } diff --git a/src/test/java/PackageTest.java b/src/test/java/PackageTest.java index f117be2..9ec198e 100644 --- a/src/test/java/PackageTest.java +++ b/src/test/java/PackageTest.java @@ -23,13 +23,13 @@ public class PackageTest { cards = new Cards(cardsArrayList); newCards = new Cards(cardsArrayList2); nochNewCards = new Cards(cardsArrayList3); - myPackage = new Package(cards, nochNewCards, "Name", 100); + myPackage = new Package(cards,"Name", 100); } @Test void test_getName() { String result = myPackage.getName(); - assertTrue(result=="Name"); + assertTrue(result.equals("Name")); } @Test @@ -42,6 +42,6 @@ public class PackageTest { void test_setName() { myPackage.setName("neuName"); String result = myPackage.getName(); - assertTrue(result=="neuName"); + assertTrue(result.equals("neuName")); } } diff --git a/src/test/java/SimpleCardTest.java b/src/test/java/SimpleCardTest.java deleted file mode 100644 index 602bf5b..0000000 --- a/src/test/java/SimpleCardTest.java +++ /dev/null @@ -1,18 +0,0 @@ -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; - -import static org.mockito.Mockito.mock; - -public class SimpleCardTest { - - @Test - @DisplayName("Test - getName()") - public void test_getName(){ - //arrange - Card mockedA = mock(Card.class); //Erstellt einen Mock - String name = "Neuer Name"; - //act - - //assert - } -} diff --git a/src/test/java/StackTest.java b/src/test/java/StackTest.java index dfc491c..1ad402b 100644 --- a/src/test/java/StackTest.java +++ b/src/test/java/StackTest.java @@ -11,6 +11,7 @@ public class StackTest { private Card newCard, card; private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; private Stack stack; + @BeforeEach void setUp() { card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); @@ -20,6 +21,7 @@ public class StackTest { cardsArrayList3 = new ArrayList(); cardsArrayList.add(card); cardsArrayList2.add(newCard); + cardsArrayList2.add(card); cards = new Cards(cardsArrayList); newCards = new Cards(cardsArrayList2); nochNewCards = new Cards(cardsArrayList3); @@ -29,16 +31,17 @@ public class StackTest { void test_addDeck() { stack.addDeck(newCards); Cards result = stack.getDeck(); - assertTrue(result == newCards); + assertTrue(result.equals(newCards)); } @Test void test_delDeck() { - boolean result = stack.delDeck(cards); - assertTrue(result); + stack.addDeck(newCards); + stack.delDeck(newCard); + assertTrue(stack.getDeck().equals(cards)); } @Test void test_getDeck() { Cards result = stack.getDeck(); - assertTrue(result == cards); + assertTrue(result.equals(cards)); } } diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java index 24a6c9e..0df2404 100644 --- a/src/test/java/StoreTest.java +++ b/src/test/java/StoreTest.java @@ -33,7 +33,7 @@ public class StoreTest { //Coins Coins coins = new Coins(10); //User - Credentials credentials = new Credentials(); + Credentials credentials = new Credentials("username", "passwort"); user = new User(credentials, "name", "nachname", "email", stack, coins); userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", stack, coins); @@ -51,32 +51,70 @@ public class StoreTest { user.addTradingDeal(tradingDeal); ArrayList expected = new ArrayList(); expected.add(tradingDeal); - assertTrue(user.getTradingDeals() == expected); + Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); + Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL); + Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER); + Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL); + Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER); + Cards deck = new Cards(); + Cards stack = new Cards(); + deck.addCard(c1); + deck.addCard(c2); + stack.addCard(c3); + stack.addCard(c4); + stack.addCard(c5); + TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL); + expected.add(vonDB); + assertTrue(user.getTradingDeals().equals(expected)); } @Test void test_doTrade() { - boolean result = user.doTrading(tradingDeal, tradingDeal); + Card cardtest = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); + TradingDeal tradingDealtest = new TradingDeal(user, cardtest, ElementTyp.WATER, 100, CardType.MONSTER); + boolean result = user.doTrading(tradingDeal, tradingDealtest); assertTrue(result); } @Test void test_getTradingDeals() { ArrayList result = user.getTradingDeals(); ArrayList expected = new ArrayList(); + Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); + Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL); + Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER); + Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL); + Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER); + Cards deck = new Cards(); + Cards stack = new Cards(); + deck.addCard(c1); + deck.addCard(c2); + stack.addCard(c3); + stack.addCard(c4); + stack.addCard(c5); + TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL); + expected.add(vonDB); expected.add(tradingDeal); - assertTrue(result == expected); + assertTrue(result.equals(expected)); } + @Test void test_getPossibleTradingDeals() { - ArrayList result = user.getPossibleTradingDeals(); + Card testCard = new Card("Test", 15, ElementTyp.FIRE, CardType.SPELL); + ArrayList result = user.getPossibleTradingDeals(testCard); ArrayList expected = new ArrayList(); - expected.add(tradingDeal); - assertTrue(result == expected); - } - @Test - void test_getAvailableTradingDeals() { - ArrayList result = user.getPossibleAvailableTradingDeals(); - ArrayList expected = new ArrayList(); - expected.add(tradingDeal); - assertTrue(result == expected); + Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); + Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL); + Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER); + Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL); + Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER); + Cards deck = new Cards(); + Cards stack = new Cards(); + deck.addCard(c1); + deck.addCard(c2); + stack.addCard(c3); + stack.addCard(c4); + stack.addCard(c5); + TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL); + expected.add(vonDB); + assertTrue(result.equals(expected)); } } diff --git a/src/test/java/TradingDealTest.java b/src/test/java/TradingDealTest.java index a1bfffc..1e2e2e3 100644 --- a/src/test/java/TradingDealTest.java +++ b/src/test/java/TradingDealTest.java @@ -33,9 +33,10 @@ public class TradingDealTest { //Coins Coins coins = new Coins(10); //User - Credentials credentials = new Credentials(); + Credentials credentials = new Credentials("username", "passwort"); + Credentials newCredentials = new Credentials("usernamenew", "passwortnew"); user = new User(credentials, "name", "nachname", "email", stack, coins); - userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", stack, coins); + userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", stack, coins); //Trading Deal Card cardToTrade = card; @@ -48,12 +49,12 @@ public class TradingDealTest { @Test void test_getTradingUser() { User result = tradingDeal.getTradingUser(); - assertTrue(result==user); + assertTrue(result.equals(user)); } @Test void test_getCardToTrade() { Card result = tradingDeal.getCardToTrade(); - assertTrue(result==card); + assertTrue(result.equals(card)); } @Test void test_getRequiredElementType() { @@ -62,7 +63,7 @@ public class TradingDealTest { } @Test void test_getRequiredMinDamage() { - int result = tradingDeal.getRequiredMinDamage(); + double result = tradingDeal.getRequiredMinDamage(); assertTrue(result==100); } @Test @@ -75,7 +76,7 @@ public class TradingDealTest { void test_setTradingUser() { tradingDeal.setTradingUser(userNew); User result = tradingDeal.getTradingUser(); - assertTrue(result==userNew); + assertTrue(result.equals(userNew)); } @Test void test_setCardToTrade() { @@ -92,7 +93,7 @@ public class TradingDealTest { @Test void test_setRequiredMinDamage() { tradingDeal.setRequiredMinDamage(10); - int result = tradingDeal.getRequiredMinDamage(); + double result = tradingDeal.getRequiredMinDamage(); assertTrue(result==10); } @Test diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java index b066a91..bb81ea5 100644 --- a/src/test/java/UserTest.java +++ b/src/test/java/UserTest.java @@ -30,51 +30,59 @@ public class UserTest { nochNewCards = new Cards(cardsArrayList3); stack = new Stack(cards, nochNewCards); //Package - myPackage = new Package(cards, nochNewCards, "Name", 100); + myPackage = new Package(cards, "Name", 100); //Coins Coins coins = new Coins(10); //User - Credentials credentials = new Credentials(); + Credentials credentials = new Credentials("username", "pw"); user = new User(credentials, "name", "nachname", "email", stack, coins); } @Test public void test_getName() { String result = user.getName(); - assertTrue(result != ""); + assertTrue(result != "name"); } @Test public void test_getNachname() { String result = user.getNachname(); - assertTrue(result != ""); + assertTrue(result != "nachname"); } @Test public void test_getEmail() { String result = user.getEmail(); - assertTrue(result != ""); + assertTrue(result != "email"); } @Test public void test_setName() { String newstring = "new"; - String result = user.setName(newstring); + user.setName(newstring); + String result = user.getName(); assertTrue(result != newstring); } @Test public void test_setNachname() { String newstring = "new"; - String result = user.setNachname(newstring); + user.setNachname(newstring); + String result = user.getNachname(); assertTrue(result != newstring); } @Test public void test_setEmail() { String newstring = "new"; - String result = user.setEmail(newstring); + user.setEmail(newstring); + String result = user.getEmail(); assertTrue(result != newstring); } @Test public void test_buyPackage(){ - Cards cards = user.buyPackage(myPackage); - assertTrue(cards != null); + Cards cards = null; + try { + cards = new Cards(user.buyPackage(myPackage)); + } catch (NegativAmountException e) { + e.printStackTrace(); + } + assertTrue(cards.equals(new Cards(myPackage.getCards()))); } } From e86ce341de55cd55d69c4545e4d1c19a0a7776f4 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Mon, 19 Oct 2020 12:34:56 +0200 Subject: [PATCH 05/20] JUnit verbessert --- src/main/java/Card.java | 2 +- src/main/java/Cards.java | 24 ++++----- src/main/java/Credentials.java | 28 +++++----- src/main/java/DBConnection.java | 34 ++++++------ src/main/java/Stack.java | 14 ++--- src/main/java/TradingDeal.java | 13 +++++ src/main/java/User.java | 14 ++--- src/test/java/CardTest.java | 6 +-- src/test/java/CardsTest.java | 42 ++++++++++++--- src/test/java/StackTest.java | 2 +- src/test/java/StoreTest.java | 95 ++++++++++++++++++++------------- src/test/java/UserTest.java | 12 ++--- 12 files changed, 178 insertions(+), 108 deletions(-) diff --git a/src/main/java/Card.java b/src/main/java/Card.java index d74cfbf..ca787b6 100644 --- a/src/main/java/Card.java +++ b/src/main/java/Card.java @@ -83,7 +83,7 @@ public class Card { * @param neuerName Name der Card */ public void setName(String neuerName) { - this.name = name; + this.name = neuerName; } /** diff --git a/src/main/java/Cards.java b/src/main/java/Cards.java index 65f2447..1a2bbec 100644 --- a/src/main/java/Cards.java +++ b/src/main/java/Cards.java @@ -1,4 +1,5 @@ import java.util.ArrayList; +import java.util.Collections; import java.util.concurrent.atomic.AtomicBoolean; /** @@ -15,12 +16,7 @@ public class Cards { this.cards = cardsArrayList; } - /** - * Erstellt ein neues Obj ohne Cards - */ - public Cards() { - } /** * Fügt eine neue Card hinzu @@ -56,6 +52,8 @@ public class Cards { this.cards.forEach(item -> { if(item.getElementTyp().equals(toCeck.getElementTyp()) && item.getCardType().equals(toCeck.getCardType()) && item.getName().equals(toCeck.getName()) && item.getDamage() == toCeck.getDamage()){ returnval.set(true); + }else{ + returnval.set(false); } }); return returnval.get(); @@ -67,12 +65,14 @@ public class Cards { * @return True wenn es aus den selben Cards besteht */ public boolean equals(Cards toCompare){ - AtomicBoolean returnval = new AtomicBoolean(false); - this.cards.forEach(item -> { - if(toCompare.containsCard(item)){ - returnval.set(true); - } - }); - return returnval.get(); + if (this.cards == null && toCompare.getCards() == null){ + return true; + }else if ((this.cards == null && toCompare.getCards() != null) || (this.cards != null && toCompare.getCards() == null)){ + return false; + }else if(this.cards.containsAll(toCompare.getCards()) && toCompare.getCards().containsAll(this.cards)){ + return true; + }else { + return false; + } } } diff --git a/src/main/java/Credentials.java b/src/main/java/Credentials.java index 01818c8..8a9e7e0 100644 --- a/src/main/java/Credentials.java +++ b/src/main/java/Credentials.java @@ -22,13 +22,13 @@ public class Credentials { return passwort; } - /** - * Setzt das User Passwort - * @param passwort Neues Passwort - */ - public void setPasswort(String passwort) { - this.passwort = passwort; - } +// /** +// * Setzt das User Passwort +// * @param passwort Neues Passwort +// */ +// public void setPasswort(String passwort) { +// this.passwort = passwort; +// } /** * Holt den Usernamen des Users @@ -38,11 +38,11 @@ public class Credentials { return username; } - /** - * Setzt einen neuen Usernamen - * @param username Neuer Username - */ - public void setUsername(String username) { - this.username = username; - } +// /** +// * Setzt einen neuen Usernamen +// * @param username Neuer Username +// */ +// public void setUsername(String username) { +// this.username = username; +// } } diff --git a/src/main/java/DBConnection.java b/src/main/java/DBConnection.java index 3e734b1..3c69e29 100644 --- a/src/main/java/DBConnection.java +++ b/src/main/java/DBConnection.java @@ -18,15 +18,19 @@ public class DBConnection { Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER); Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL); Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER); - Cards deck = new Cards(); - Cards stack = new Cards(); - deck.addCard(c1); - deck.addCard(c2); - stack.addCard(c3); - stack.addCard(c4); - stack.addCard(c5); + 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.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.SPELL)); + 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)); } @@ -54,11 +58,11 @@ public class DBConnection { 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); - } +// /** +// * 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/Stack.java b/src/main/java/Stack.java index af4f858..6b0be43 100644 --- a/src/main/java/Stack.java +++ b/src/main/java/Stack.java @@ -38,11 +38,11 @@ public class Stack extends Cards{ this.deck.delCard(toDel); } - /** - * Fügt dem deck eine neue Card ein - * @param toAdd Neue Card - */ - public void addDeckCard(Card toAdd){ - this.deck.addCard(toAdd); - } +// /** +// * Fügt dem deck eine neue Card ein +// * @param toAdd Neue Card +// */ +// public void addDeckCard(Card toAdd){ +// this.deck.addCard(toAdd); +// } } diff --git a/src/main/java/TradingDeal.java b/src/main/java/TradingDeal.java index 80e377f..4f0c8a5 100644 --- a/src/main/java/TradingDeal.java +++ b/src/main/java/TradingDeal.java @@ -119,9 +119,22 @@ public class TradingDeal { * @return True wenn der Deal passt */ public boolean cardOk(Card checkCard){ + System.out.println(checkCard.getCardType().equals(this.requiredCardType)); + System.out.println(checkCard.getCardType().toString()); + System.out.println(this.requiredCardType.toString()); + System.out.println(" "); + System.out.println(checkCard.getElementTyp().equals(this.requiredElementType)); + System.out.println(checkCard.getElementTyp().toString()); + System.out.println(this.requiredElementType); + System.out.println(" "); + System.out.println(checkCard.getDamage() >= this.requiredMinDamage); + System.out.println(checkCard.getDamage()); + System.out.println(this.requiredMinDamage); if(checkCard.getCardType().equals(this.requiredCardType) && checkCard.getElementTyp().equals(this.requiredElementType) && checkCard.getDamage() >= this.requiredMinDamage){ + System.out.println("Da simma true"); return true; }else { + System.out.println("da simma false"); return false; } } diff --git a/src/main/java/User.java b/src/main/java/User.java index 6edcfae..bf37bc9 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -26,7 +26,7 @@ public class User implements Store{ this.email = email; this.stack = stack; this.coins = coins; - this.db = new DBConnection(); + //this.db = new DBConnection(); } /** @@ -50,7 +50,7 @@ public class User implements Store{ * @return Das DB Obj */ public DBConnection getDb() { - return db; + return new DBConnection(); } /** @@ -150,7 +150,7 @@ public class User implements Store{ * @throws NegativAmountException Wenn ein negativer Preis im Package gesetzt wird. */ public ArrayList buyPackage(Package mypackage) throws NegativAmountException { - ArrayList availablePackages = db.getAllPackages(); + ArrayList availablePackages = new DBConnection().getAllPackages(); availablePackages.removeIf(obj -> obj.equals(mypackage)); this.coins.removeCoin(mypackage.getPrice()); return mypackage.getCards(); @@ -161,7 +161,7 @@ public class User implements Store{ * @param tradingDeal Der neue Tradingdeal */ public void addTradingDeal(TradingDeal tradingDeal) { - db.addTradingDeal(tradingDeal); + new DBConnection().addTradingDeal(tradingDeal); } /** @@ -169,7 +169,7 @@ public class User implements Store{ * @return Alle verfügbaren Deals */ public ArrayList getTradingDeals() { - return db.getAllTradingDeals(); + return new DBConnection().getAllTradingDeals(); } /** @@ -182,6 +182,7 @@ public class User implements Store{ if (storeTradingDeal.dealOk(myTradingDeal)){ stack.delCard(myTradingDeal.getCardToTrade()); stack.addCard(storeTradingDeal.getCardToTrade()); + return true; } return false; } @@ -193,10 +194,11 @@ public class User implements Store{ */ @Override public ArrayList getPossibleTradingDeals(Card toTrade) { - ArrayList storeList = db.getAllTradingDeals(); + ArrayList storeList = new DBConnection().getAllTradingDeals(); ArrayList possible = new ArrayList(); storeList.forEach(item -> { if(item.cardOk(toTrade)){ + System.out.println("ADDED ein item"); possible.add(item); } }); diff --git a/src/test/java/CardTest.java b/src/test/java/CardTest.java index 9784c07..3e000f2 100644 --- a/src/test/java/CardTest.java +++ b/src/test/java/CardTest.java @@ -18,20 +18,20 @@ public class CardTest { public void test_getElementType() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); ElementTyp elementTyp = card.getElementTyp(); - assertTrue(elementTyp != ElementTyp.WATER); + assertTrue(elementTyp == ElementTyp.WATER); } @Test public void test_getCardType() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); CardType cardType = card.getCardType(); - assertTrue(cardType != CardType.SPELL); + assertTrue(cardType == CardType.SPELL); } @Test public void test_getEffectivenessAgainst() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); Card card2 = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); EffectivnessType effectivnessType = card.getEffectivenessAgainst(card2); - assertTrue(effectivnessType != EffectivnessType.NOEFFECT); + assertTrue(effectivnessType == EffectivnessType.NOEFFECT); } @Test public void test_setName() { diff --git a/src/test/java/CardsTest.java b/src/test/java/CardsTest.java index 6584e35..578f8e8 100644 --- a/src/test/java/CardsTest.java +++ b/src/test/java/CardsTest.java @@ -2,38 +2,66 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.ArrayList; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; public class CardsTest { - private Cards newCards, cards, nochNewCards; - private Card newCard, card; + private Cards cards, cards2, cards3; + private Card newCard, card, newerCard; private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; - private Stack stack; @BeforeEach void setUp() { card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + newerCard = new Card("NameNewerer", 100, ElementTyp.FIRE, CardType.MONSTER); cardsArrayList = new ArrayList(); cardsArrayList2 = new ArrayList(); cardsArrayList3 = new ArrayList(); cardsArrayList.add(card); cardsArrayList2.add(newCard); cardsArrayList2.add(card); + cardsArrayList3.add(newerCard); cards = new Cards(cardsArrayList); - newCards = new Cards(cardsArrayList2); - nochNewCards = new Cards(cardsArrayList3); - stack = new Stack(cards, nochNewCards); + cards2 = new Cards(cardsArrayList2); + cards3 = new Cards(cardsArrayList3); } @Test void test_addCard() { + System.out.println(cards.getCards().toString()); cards.addCard(newCard); - assertTrue(cards.getCards().equals(cardsArrayList2)); + System.out.println(cards.getCards().toString()); + System.out.println(cards2.getCards().toString()); + assertTrue(cards.equals(cards2)); } + + @Test + void test_addCard2() { + cards.addCard(newCard); + assertFalse(cards.equals(cards3)); + } + + @Test + void test_equals() { + assertFalse(cards.equals(cards2)); + } + + @Test + void test_contains() { + assertTrue(cards2.containsCard(card)); + } + + @Test + void test_contains2() { + assertFalse(cards.containsCard(newCard)); + } + @Test void test_delCard() { cards.addCard(newCard); + cards.delCard(newCard); + assertTrue(cards.getCards().equals(cardsArrayList)); } @Test diff --git a/src/test/java/StackTest.java b/src/test/java/StackTest.java index 1ad402b..c81b096 100644 --- a/src/test/java/StackTest.java +++ b/src/test/java/StackTest.java @@ -42,6 +42,6 @@ public class StackTest { @Test void test_getDeck() { Cards result = stack.getDeck(); - assertTrue(result.equals(cards)); + assertTrue(result.equals(nochNewCards)); } } diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java index 0df2404..64df1b1 100644 --- a/src/test/java/StoreTest.java +++ b/src/test/java/StoreTest.java @@ -18,7 +18,7 @@ public class StoreTest { @BeforeEach void setUp() { //Stack - card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + card = new Card("Name", 100, ElementTyp.WATER, CardType.MONSTER); newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); cardsArrayList = new ArrayList(); cardsArrayList2 = new ArrayList(); @@ -48,28 +48,41 @@ public class StoreTest { @Test void test_addTradingDeal() { - user.addTradingDeal(tradingDeal); - ArrayList expected = new ArrayList(); - expected.add(tradingDeal); + + Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL); Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER); Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL); Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER); - Cards deck = new Cards(); - Cards stack = new Cards(); - deck.addCard(c1); - deck.addCard(c2); - stack.addCard(c3); - stack.addCard(c4); - stack.addCard(c5); - TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL); - expected.add(vonDB); - assertTrue(user.getTradingDeals().equals(expected)); + ArrayList 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)); + ArrayList tradingDeals = 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)); + + + System.out.println(user.getTradingDeals().toString()); + + user.addTradingDeal(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); + System.out.println(user.getTradingDeals().toString()); + + + System.out.println(tradingDeals.toString()); + assertTrue(user.getTradingDeals().get(0).dealOk(tradingDeals.get(0))); } @Test void test_doTrade() { - Card cardtest = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); + Card cardtest = new Card("Name", 100, ElementTyp.FIRE, CardType.MONSTER); TradingDeal tradingDealtest = new TradingDeal(user, cardtest, ElementTyp.WATER, 100, CardType.MONSTER); boolean result = user.doTrading(tradingDeal, tradingDealtest); assertTrue(result); @@ -78,27 +91,33 @@ public class StoreTest { void test_getTradingDeals() { ArrayList result = user.getTradingDeals(); ArrayList expected = new ArrayList(); + Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); Card c2 = new Card("Name1", 12, ElementTyp.FIRE, CardType.SPELL); Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER); Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL); Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER); - Cards deck = new Cards(); - Cards stack = new Cards(); - deck.addCard(c1); - deck.addCard(c2); - stack.addCard(c3); - stack.addCard(c4); - stack.addCard(c5); - TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL); - expected.add(vonDB); - expected.add(tradingDeal); - assertTrue(result.equals(expected)); + ArrayList 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)); + ArrayList tradingDeals = 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)); + + assertTrue(result.get(0).dealOk(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER))); } @Test void test_getPossibleTradingDeals() { - Card testCard = new Card("Test", 15, ElementTyp.FIRE, CardType.SPELL); + Card testCard = new Card("Test", 10, ElementTyp.FIRE, CardType.MONSTER); ArrayList result = user.getPossibleTradingDeals(testCard); ArrayList expected = new ArrayList(); Card c1 = new Card("Name", 10, ElementTyp.FIRE, CardType.MONSTER); @@ -106,15 +125,19 @@ public class StoreTest { Card c3 = new Card("Name2", 13, ElementTyp.WATER, CardType.MONSTER); Card c4 = new Card("Name3", 14, ElementTyp.WATER, CardType.SPELL); Card c5 = new Card("Name4", 15, ElementTyp.FIRE, CardType.MONSTER); - Cards deck = new Cards(); - Cards stack = new Cards(); - deck.addCard(c1); - deck.addCard(c2); - stack.addCard(c3); - stack.addCard(c4); - stack.addCard(c5); - TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Stack(stack, deck), new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL); + ArrayList 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); + 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); expected.add(vonDB); - assertTrue(result.equals(expected)); + System.out.println(result.get(0).getCardToTrade().getName()); + System.out.println(expected.get(0).getCardToTrade().getName()); + assertTrue(result.get(0).getCardToTrade().equals(expected.get(0).getCardToTrade())); } } diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java index bb81ea5..2d8b613 100644 --- a/src/test/java/UserTest.java +++ b/src/test/java/UserTest.java @@ -41,17 +41,17 @@ public class UserTest { @Test public void test_getName() { String result = user.getName(); - assertTrue(result != "name"); + assertTrue(result.equals("name")); } @Test public void test_getNachname() { String result = user.getNachname(); - assertTrue(result != "nachname"); + assertTrue(result.equals("nachname")); } @Test public void test_getEmail() { String result = user.getEmail(); - assertTrue(result != "email"); + assertTrue(result.equals("email")); } @Test @@ -59,21 +59,21 @@ public class UserTest { String newstring = "new"; user.setName(newstring); String result = user.getName(); - assertTrue(result != newstring); + assertTrue(result.equals(newstring)); } @Test public void test_setNachname() { String newstring = "new"; user.setNachname(newstring); String result = user.getNachname(); - assertTrue(result != newstring); + assertTrue(result.equals(newstring)); } @Test public void test_setEmail() { String newstring = "new"; user.setEmail(newstring); String result = user.getEmail(); - assertTrue(result != newstring); + assertTrue(result.equals(newstring)); } @Test public void test_buyPackage(){ From 6953010bd32bc32c70a3f7eb6ad6ae0da26fefea Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Mon, 28 Dec 2020 14:41:40 +0100 Subject: [PATCH 06/20] Added RestServer + Added Create User (/users) --- .gitignore | 3 +- .idea/compiler.xml | 1 + README.md | 2 +- pom.xml | 17 ++ src/main/java/DBConnection.java | 68 ------- src/main/java/{ => at/reisinger}/Battle.java | 2 + src/main/java/{ => at/reisinger}/Card.java | 48 ++--- .../java/{ => at/reisinger}/CardType.java | 2 + src/main/java/{ => at/reisinger}/Cards.java | 31 +-- src/main/java/{ => at/reisinger}/Coins.java | 8 +- .../java/{ => at/reisinger}/Credentials.java | 8 +- src/main/java/at/reisinger/DBConnection.java | 137 +++++++++++++ .../{ => at/reisinger}/EffectivnessType.java | 2 + .../java/{ => at/reisinger}/ElementTyp.java | 2 + .../java/{ => at/reisinger}/MonsterCard.java | 2 + .../reisinger}/NegativAmountException.java | 2 + src/main/java/{ => at/reisinger}/Package.java | 8 +- .../java/{ => at/reisinger}/SpellCard.java | 2 + src/main/java/{ => at/reisinger}/Stack.java | 20 +- src/main/java/{ => at/reisinger}/Store.java | 2 + .../java/{ => at/reisinger}/TradingDeal.java | 46 +++-- src/main/java/{ => at/reisinger}/User.java | 108 ++++++---- src/main/java/at/reisinger/server/Main.java | 65 ++++++ .../reisinger/server/helper/JsonHelper.java | 7 + .../at/reisinger/server/msg/MsgHandler.java | 89 ++++++++ .../java/at/reisinger/server/objects/Msg.java | 37 ++++ .../at/reisinger/server/objects/Request.java | 110 ++++++++++ .../at/reisinger/server/objects/Response.java | 192 ++++++++++++++++++ src/test/java/CardTest.java | 4 + src/test/java/CardsTest.java | 6 +- src/test/java/CoinsTest.java | 10 +- src/test/java/PackageTest.java | 2 + src/test/java/StackTest.java | 1 + src/test/java/StoreTest.java | 16 +- src/test/java/TradingDealTest.java | 13 +- src/test/java/UserTest.java | 12 +- 36 files changed, 882 insertions(+), 203 deletions(-) delete mode 100644 src/main/java/DBConnection.java rename src/main/java/{ => at/reisinger}/Battle.java (51%) rename src/main/java/{ => at/reisinger}/Card.java (66%) rename src/main/java/{ => at/reisinger}/CardType.java (65%) rename src/main/java/{ => at/reisinger}/Cards.java (65%) rename src/main/java/{ => at/reisinger}/Coins.java (90%) rename src/main/java/{ => at/reisinger}/Credentials.java (84%) create mode 100644 src/main/java/at/reisinger/DBConnection.java rename src/main/java/{ => at/reisinger}/EffectivnessType.java (77%) rename src/main/java/{ => at/reisinger}/ElementTyp.java (68%) rename src/main/java/{ => at/reisinger}/MonsterCard.java (89%) rename src/main/java/{ => at/reisinger}/NegativAmountException.java (94%) rename src/main/java/{ => at/reisinger}/Package.java (72%) rename src/main/java/{ => at/reisinger}/SpellCard.java (89%) rename src/main/java/{ => at/reisinger}/Stack.java (52%) rename src/main/java/{ => at/reisinger}/Store.java (93%) rename src/main/java/{ => at/reisinger}/TradingDeal.java (76%) rename src/main/java/{ => at/reisinger}/User.java (63%) create mode 100644 src/main/java/at/reisinger/server/Main.java create mode 100644 src/main/java/at/reisinger/server/helper/JsonHelper.java create mode 100644 src/main/java/at/reisinger/server/msg/MsgHandler.java create mode 100644 src/main/java/at/reisinger/server/objects/Msg.java create mode 100644 src/main/java/at/reisinger/server/objects/Request.java create mode 100644 src/main/java/at/reisinger/server/objects/Response.java 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); } From cd9e0a45e0616a383d98511750e9ce8a73ce7950 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Mon, 28 Dec 2020 22:42:49 +0100 Subject: [PATCH 07/20] Create Package (/packages) --- src/main/java/at/reisinger/Card.java | 86 ++++++ src/main/java/at/reisinger/CardType.java | 2 +- src/main/java/at/reisinger/DBConnection.java | 270 ++++++++++++++---- src/main/java/at/reisinger/ElementTyp.java | 2 +- src/main/java/at/reisinger/Package.java | 11 +- src/main/java/at/reisinger/Store.java | 2 +- src/main/java/at/reisinger/User.java | 22 +- src/main/java/at/reisinger/server/Main.java | 8 +- .../at/reisinger/server/objects/Request.java | 16 +- .../at/reisinger/server/objects/Response.java | 107 ++++++- src/test/java/StoreTest.java | 10 +- src/test/java/TradingDealTest.java | 4 +- src/test/java/UserTest.java | 2 +- 13 files changed, 467 insertions(+), 75 deletions(-) diff --git a/src/main/java/at/reisinger/Card.java b/src/main/java/at/reisinger/Card.java index e3197d0..8d180e6 100644 --- a/src/main/java/at/reisinger/Card.java +++ b/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,82 @@ 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()) { + System.out.println(e.toString().toLowerCase()); + System.out.println(elementTypeString.toLowerCase().contains(e.name().toLowerCase())); + if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) { + System.out.println("\n\n\n"); + System.out.println("####Element####, me.name() : elementTypeString"); + System.out.println(e.name().toLowerCase()); + System.out.print(" : "); + System.out.println(elementTypeString.toLowerCase()); + System.out.println("\n\n\n"); + return e; + } + } + return null; + } + + /** + * Wenn ein String als cardType vorhanden ist, dann gibt er den passenden cardType zurück + * @param cardTypeString cardType als String + * @return Passender Card Type oder null falls nicht gefunden + */ + private CardType stringToCardType(String cardTypeString){ + System.out.println("\n\n\n"); + System.out.println("###CARD###, me.name() : cardTypeString\n"); + for (CardType me : CardType.values()) { + System.out.println("\n\n\n"); + System.out.print(me.name().toLowerCase()); + System.out.print(" : "); + System.out.println(cardTypeString.toLowerCase()); + System.out.println("\n\n\n"); + if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) { + System.out.println("\n\n\n"); + System.out.print(me.name().toLowerCase()); + System.out.print(" : "); + System.out.println(cardTypeString.toLowerCase()); + System.out.println("\n\n\n"); + return me; + } + } + return null; + } + /** * Holt den Namen der at.reisinger.Card * @return Name der at.reisinger.Card */ + @JsonGetter public String getName() { return this.name; } @@ -35,6 +114,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 +123,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 +132,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 +143,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 +167,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 +176,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 +185,7 @@ public class Card { * Setzt den ElementType der at.reisinger.Card * @param elementTyp Der ElementType */ + @JsonSetter public void setElementType(ElementTyp elementTyp) { this.elementTyp = elementTyp; } diff --git a/src/main/java/at/reisinger/CardType.java b/src/main/java/at/reisinger/CardType.java index 8c5016f..8214d9a 100644 --- a/src/main/java/at/reisinger/CardType.java +++ b/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 } diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index 374cab1..5508a90 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -1,9 +1,6 @@ package at.reisinger; -import java.sql.Connection; -import java.sql.DriverManager; -import java.sql.SQLException; -import java.sql.Statement; +import java.sql.*; import java.util.ArrayList; /** @@ -16,7 +13,7 @@ public class DBConnection { private Connection c; private Statement stmt; - private Connection con(){ + private Connection con() { this.c = null; try { Class.forName("org.postgresql.Driver"); @@ -25,10 +22,9 @@ public class DBConnection { "user", "user"); } catch (Exception e) { e.printStackTrace(); - System.err.println(e.getClass().getName()+": "+e.getMessage()); + System.err.println(e.getClass().getName() + ": " + e.getMessage()); System.exit(0); } - System.out.println("Opened database"); return c; } @@ -36,56 +32,200 @@ public class DBConnection { * Erstellt alle Beispieldaten und simuliert somit den * Verbindungsaufbau zu einer DB */ - public DBConnection(){ + 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 { + /** + * Erstellt alle Tabellen die für den Betrieb der Software bennötigt werden + * + * @throws SQLException + */ + public void init() { 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() ); + 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"); + + this.c = con(); + try { + stmt = this.c.createStatement(); + String sql = "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\"));"; + stmt.executeUpdate(sql); + stmt.close(); + this.c.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + System.exit(0); + } + this.c = con(); + try { + stmt = this.c.createStatement(); + String sql = "create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);"; + 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("Card Table created"); + + this.c = con(); + try { + stmt = this.c.createStatement(); + String sql = "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" + + ");"; + 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("Package Table created"); } + /** + * Ü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 = 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"); + System.out.println("Count: "); + System.out.print(count); + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + System.exit(0); + } + if (count == 1) { + return true; + } else { + return false; + } + } + + /** + * Fügt eine Karte der DB hinzu + * @param card Card die hinzugefügt werden soll + * @return true bei erfolg, false bei error + */ + public boolean addCard(Card card) { + this.c = con(); + try{ + stmt = this.c.createStatement(); + String sql = "insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values (\'" + card.getName() +"\',\'" + card.getDamage() + "\',\'" + card.getElementTyp().name() + "\',\'" + card.getCardType().name() + "\')"; + 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("Card added"); + return true; + } + + /** + * Ermittelt die nächste Package ID + * @return Die Nächste Package id, wenn 0, dann ist ein error + */ + public int nextPackageId(){ + this.c = 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; + } + System.out.println("Package Next id is: "); + System.out.print(id); + 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; + } + } + this.c = con(); + try { + stmt = this.c.createStatement(); + String sql = "INSERT INTO package (\"ID\", \"name\") values (\'" + pack.getName() + "\',\'" + ca.getName() + "\');"; + 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("Card zu Package hinzugefügt"); + } + return true; + } + + /** + * Fügt einen User der DB hinzu + * @param username Username des Users + * @param password Passwort des Users + * @param nachname nachname des Users + * @param email Email des Users + * @return True wenn alles erfolgreich war, false wenn es nicht erfolgreich war + */ public boolean addUser(String username, String password, String nachname, String email){ this.c = con(); try{ @@ -103,6 +243,40 @@ public class DBConnection { return true; } + /** + * Sucht einen User anhand des Usernamens. + * Gibt ein User Objekt zurück + * @param uname Username der zu suchen ist + * @return User als User Objekt + * @throws SQLException Fehler bei der Suche in der DB + */ + public User getUser(String uname) throws SQLException { + this.c = con(); + String username="", password="", email ="", nachname = ""; + 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"); + System.out.println( "username = " + username ); + System.out.println( "nachname = " + nachname ); + System.out.println( "email = " + email ); + System.out.println( "password = " + password ); + System.out.println(); + } + rs.close(); + stmt.close(); + this.c.close(); + } catch ( Exception e ) { + System.err.println( e.getClass().getName()+": "+ e.getMessage() ); + System.exit(0); + } + System.out.println("Operation done successfully"); + return new User(new Credentials(username, password), username, username, email, new Coins(20)); + } /** * Holt alle verfügbaren TradingDeals * @return Alle Trading Deals diff --git a/src/main/java/at/reisinger/ElementTyp.java b/src/main/java/at/reisinger/ElementTyp.java index b916e84..f71ce55 100644 --- a/src/main/java/at/reisinger/ElementTyp.java +++ b/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 } diff --git a/src/main/java/at/reisinger/Package.java b/src/main/java/at/reisinger/Package.java index f00de77..edf6b3e 100644 --- a/src/main/java/at/reisinger/Package.java +++ b/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; } diff --git a/src/main/java/at/reisinger/Store.java b/src/main/java/at/reisinger/Store.java index 069c79d..7befd7e 100644 --- a/src/main/java/at/reisinger/Store.java +++ b/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); diff --git a/src/main/java/at/reisinger/User.java b/src/main/java/at/reisinger/User.java index ebd65a3..f01934f 100644 --- a/src/main/java/at/reisinger/User.java +++ b/src/main/java/at/reisinger/User.java @@ -11,15 +11,17 @@ import java.util.ArrayList; public class User implements Store{ @JsonProperty private String name, nachname, email; + /* @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,14 +40,14 @@ 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) { this.credentials = credentials; this.name = name; this.nachname = nachname; this.email = email; - this.stack = null; + //this.stack = null; this.coins = coins; //this.db = new at.reisinger.DBConnection(); } @@ -53,7 +55,7 @@ public class User implements Store{ /** * Holt den at.reisinger.Stack des Users * @return at.reisinger.Stack des Users - */ + @JsonGetter public Stack getStack() { return stack; @@ -62,7 +64,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; @@ -210,12 +212,17 @@ public class User implements Store{ 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,6 +231,7 @@ public class User implements Store{ } return false; } + */ /** * Gibt alle Möglichen Trading Deals zurück diff --git a/src/main/java/at/reisinger/server/Main.java b/src/main/java/at/reisinger/server/Main.java index 1cc786e..01fb64a 100644 --- a/src/main/java/at/reisinger/server/Main.java +++ b/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!"); diff --git a/src/main/java/at/reisinger/server/objects/Request.java b/src/main/java/at/reisinger/server/objects/Request.java index bc65127..68ce0a5 100644 --- a/src/main/java/at/reisinger/server/objects/Request.java +++ b/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 diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 011777c..7bd2d6d 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -1,12 +1,18 @@ package at.reisinger.server.objects; import at.reisinger.*; +import at.reisinger.Package; 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.io.UnsupportedEncodingException; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Base64; +import java.util.List; import java.util.Map; /** @@ -21,6 +27,7 @@ public class Response { private String cmd; private String url; private String payload; + private String authString; private MsgHandler msgHandler; private StringBuilder rqBuilder; @@ -30,12 +37,12 @@ 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; @@ -80,6 +87,47 @@ public class Response { } } + /** + * 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; + } + + private String basicAuthBase64(String username, String password){ + String authString = username + ":" + password; + //System.out.println("auth string: " + authString); + byte[] authEncBytes = Base64.getEncoder().encode(authString.getBytes()); + String authStringEnc = new String(authEncBytes); + //System.out.println("Base64 encoded auth string: " + authStringEnc); + return authStringEnc; + } + + private String basicAuthGetUsername(String authString) throws UnsupportedEncodingException { + String[] values; + if (authString != null) { + System.out.println("1"); + byte[] credDecoded = Base64.getDecoder().decode(authString); + System.out.println("2"); + String credentials = new String(credDecoded); + System.out.println("credentials: "); + System.out.println(credentials); + // credentials = username:password + values = credentials.split(":", 2); + }else{ + values = null; + } + return values[0]; + } + private void postMethodes() throws JsonProcessingException { if (this.url.startsWith("/users")) { //payload to map @@ -91,7 +139,7 @@ public class Response { System.out.println("CON DB"); DBConnection con = new DBConnection(); if(!con.addUser(username, password, username, "not implemented")){ - sendError("500"); + sendError("409"); } //User to json @@ -103,12 +151,61 @@ public class Response { } catch (JsonProcessingException e) { userJson = "Error: JsonProcessingException -> " + e.getMessage(); } - sendResponse(userJson, "200"); + sendResponse(userJson, "201"); }else{ sendError("500"); } }else if (this.url.startsWith("/sessions")) { + //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 user = null; + DBConnection con = new DBConnection(); + try { + user = con.getUser(username); + } catch (SQLException throwables) { + throwables.printStackTrace(); + } + + String authString = basicAuthBase64(user.getCredentials().getUsername(), user.getCredentials().getPasswort()); + if(basicAuth(username, password, authString)){ + sendResponse(authString, "200"); + }else{ + sendError("401"); + } + }else if (this.url.startsWith("/packages")) { + if(basicAuth("admin", "admin", this.authString)){ + System.out.println("1"); + ObjectMapper objectMapper = new ObjectMapper(); + System.out.println("2"); + ArrayList listCards = objectMapper.readValue(this.payload, new TypeReference>(){}); + System.out.println("List cards"); + System.out.println(listCards.toString()); + Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId()+"", 5); + System.out.println("3"); + if(!new DBConnection().addPackage(packageCards)){ + sendError("500"); + }else{ + //Package to json + objectMapper = new ObjectMapper(); + String packageJson = ""; + if(packageCards != null) { + try { + packageJson += objectMapper.writeValueAsString(packageCards); + } catch (JsonProcessingException e) { + packageJson = "Error: JsonProcessingException -> " + e.getMessage(); + } + sendResponse(packageJson, "201"); + }else{ + sendError("500"); + } + } + }else{ + sendError("401"); + } } } diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java index d4d79a5..558c5fd 100644 --- a/src/test/java/StoreTest.java +++ b/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); + userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", coins); //Trading Deal Card cardToTrade = card; @@ -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)); ArrayList tradingDeals = new ArrayList(); ArrayList packages = new ArrayList(); 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)); ArrayList tradingDeals = new ArrayList(); ArrayList packages = new ArrayList(); tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); @@ -136,7 +136,7 @@ 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)), 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()); diff --git a/src/test/java/TradingDealTest.java b/src/test/java/TradingDealTest.java index b43d44a..e4eaa6a 100644 --- a/src/test/java/TradingDealTest.java +++ b/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); + userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", coins); //Trading Deal Card cardToTrade = card; diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java index e78ebfa..40dc2c7 100644 --- a/src/test/java/UserTest.java +++ b/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); } @Test public void test_getName() { From e9fcbb36dc56dcbf4e6ccecf545bbf30ba5c1196 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Tue, 29 Dec 2020 16:59:37 +0100 Subject: [PATCH 08/20] JsonHelper + PostgresHelper + acquire package (/transactions/packages) --- src/main/java/at/reisinger/DBConnection.java | 338 ++++++++++-------- .../reisinger/server/helper/JsonHelper.java | 53 +++ .../server/helper/PostgresHelper.java | 61 ++++ .../at/reisinger/server/objects/Response.java | 149 ++++---- 4 files changed, 369 insertions(+), 232 deletions(-) create mode 100644 src/main/java/at/reisinger/server/helper/PostgresHelper.java diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index 5508a90..05e8ed1 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -1,5 +1,7 @@ package at.reisinger; +import at.reisinger.server.helper.PostgresHelper; + import java.sql.*; import java.util.ArrayList; @@ -13,97 +15,158 @@ public class DBConnection { 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); - } - return c; - } /** * Erstellt alle Beispieldaten und simuliert somit den * Verbindungsaufbau zu einer DB */ public DBConnection() { - this.c = con(); + this.c = PostgresHelper.con(); } /** * Erstellt alle Tabellen die für den Betrieb der Software bennötigt werden - * - * @throws SQLException */ public void init() { - 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"); + PostgresHelper.executeUpdateMessage("CREATE TABLE IF NOT EXISTS USERS (username TEXT PRIMARY KEY NOT NULL, nachname TEXT NOT NULL, email TEXT NOT NULL, password TEXT NOT NULL)", "User Table created"); + PostgresHelper.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"); + } - this.c = con(); - try { - stmt = this.c.createStatement(); - String sql = "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\"));"; - stmt.executeUpdate(sql); - stmt.close(); - this.c.close(); - } catch (Exception e) { - System.err.println(e.getClass().getName() + ": " + e.getMessage()); - System.exit(0); + /** + * 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) { + System.out.println("Vor den coins"); + int coins = checkCoins(username); + if (!(coins - 5 >= 0)) { + return null; } - this.c = con(); - try { - stmt = this.c.createStatement(); - String sql = "create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);"; - 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("Card Table created"); + updateCoins(coins - 5, username); + System.out.println("nach den soins"); - this.c = con(); + this.c = PostgresHelper.con(); + String id = ""; try { stmt = this.c.createStatement(); - String sql = "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" + - ");"; - stmt.executeUpdate(sql); + ResultSet rs = stmt.executeQuery("select \"ID\" as id from package LIMIT 1;"); + while (rs.next()) { + id = rs.getString("id"); + System.out.println("id = " + id); + System.out.println(); + } + rs.close(); stmt.close(); this.c.close(); } catch (Exception e) { System.err.println(e.getClass().getName() + ": " + e.getMessage()); - System.exit(0); + return null; } - System.out.println("Package Table created"); + 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()); + 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); + System.out.println(); + Connection b = PostgresHelper.con(); + try { + stmt = b.createStatement(); + String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + newCard.getName() + "\', \'false\');"; + System.out.println(sql); + stmt.executeUpdate(sql); + stmt.close(); + b.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + return null; + } + System.out.println("User got Card successfully"); + } + rs.close(); + stmt.close(); + 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"); + System.out.println("Count: "); + System.out.print(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; } /** @@ -113,7 +176,7 @@ public class DBConnection { * @return True falls die Karte bereits existiert */ public boolean cardExists(String name) { - this.c = con(); + this.c = PostgresHelper.con(); int count = 0; try { stmt = this.c.createStatement(); @@ -139,47 +202,36 @@ public class DBConnection { /** * 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) { - this.c = con(); - try{ - stmt = this.c.createStatement(); - String sql = "insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values (\'" + card.getName() +"\',\'" + card.getDamage() + "\',\'" + card.getElementTyp().name() + "\',\'" + card.getCardType().name() + "\')"; - 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("Card added"); - return true; + 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 = con(); + public int nextPackageId() { + this.c = PostgresHelper.con(); String id = ""; - try{ + try { stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery( "select max(\"ID\") from package;"); - while ( rs.next() ) { + ResultSet rs = stmt.executeQuery("select max(\"ID\") from package;"); + while (rs.next()) { id = rs.getString("max"); } - if (id == null){ + if (id == null) { id = "0"; } 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 0; } System.out.println("Package Next id is: "); @@ -191,121 +243,89 @@ public class DBConnection { * 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)){ + if (!addCard(ca)) { return false; } } - this.c = con(); - try { - stmt = this.c.createStatement(); - String sql = "INSERT INTO package (\"ID\", \"name\") values (\'" + pack.getName() + "\',\'" + ca.getName() + "\');"; - System.out.println(sql); - stmt.executeUpdate(sql); - stmt.close(); - this.c.close(); - } catch (Exception e) { - System.err.println(e.getClass().getName() + ": " + e.getMessage()); + if(!PostgresHelper.executeUpdateMessage("INSERT INTO package (\"ID\", \"name\") values (\'" + pack.getName() + "\',\'" + ca.getName() + "\');", "Card zu Package hinzugefügt")){ return false; } - System.out.println("Card zu Package hinzugefügt"); } return true; } /** * Fügt einen User der DB hinzu + * * @param username Username des Users * @param password Passwort des Users * @param nachname nachname des Users - * @param email Email des Users + * @param email Email des Users * @return True wenn alles erfolgreich war, false wenn es nicht erfolgreich war */ - public boolean addUser(String username, String password, String nachname, String email){ - 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; + public boolean addUser(String username, String password, String nachname, String email) { + return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password) values (\'" + username + "\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\')", "User added"); } /** * Sucht einen User anhand des Usernamens. * Gibt ein User Objekt zurück + * * @param uname Username der zu suchen ist * @return User als User Objekt * @throws SQLException Fehler bei der Suche in der DB */ public User getUser(String uname) throws SQLException { - this.c = con(); - String username="", password="", email ="", nachname = ""; - 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"); - System.out.println( "username = " + username ); - System.out.println( "nachname = " + nachname ); - System.out.println( "email = " + email ); - System.out.println( "password = " + password ); - System.out.println(); - } - rs.close(); - stmt.close(); - this.c.close(); - } catch ( Exception e ) { - System.err.println( e.getClass().getName()+": "+ e.getMessage() ); + this.c = PostgresHelper.con(); + String username = "", password = "", email = "", nachname = ""; + 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"); + System.out.println("username = " + username); + System.out.println("nachname = " + nachname); + System.out.println("email = " + email); + System.out.println("password = " + password); + System.out.println(); + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); System.exit(0); } - System.out.println("Operation done successfully"); + System.out.println("Operation done successfully"); return new User(new Credentials(username, password), username, username, email, new Coins(20)); } + /** * Holt alle verfügbaren TradingDeals + * * @return Alle Trading Deals */ - public ArrayList getAllTradingDeals(){ + 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){ + 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/at/reisinger/server/helper/JsonHelper.java b/src/main/java/at/reisinger/server/helper/JsonHelper.java index dd53af3..1b3a290 100644 --- a/src/main/java/at/reisinger/server/helper/JsonHelper.java +++ b/src/main/java/at/reisinger/server/helper/JsonHelper.java @@ -1,7 +1,60 @@ package at.reisinger.server.helper; +import at.reisinger.Card; +import at.reisinger.Cards; +import at.reisinger.Package; +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 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 listCards, String name){ + Package packageCards = new Package(new Cards(listCards),name, 5); + return packageToJson(packageCards); + } + /** + * Wandelt ein Package Objekt in ein Json um + * @param packageCards Package Objekt das in ein Json umgewandelt werden soll + * @return Json String des Packages + */ + public static String packageToJson(Package packageCards){ + ObjectMapper objectMapper = new ObjectMapper(); + objectMapper = new ObjectMapper(); + String packageJson = ""; + if(packageCards != null) { + try { + packageJson += objectMapper.writeValueAsString(packageCards); + } catch (JsonProcessingException e) { + packageJson = "Error: JsonProcessingException -> " + e.getMessage(); + } + return packageJson; + }else{ + return null; + } + } + + public static Map jsonPayload2ToMap(String payload){ + ObjectMapper objectMapper = new ObjectMapper(); + try { + return objectMapper.readValue(payload, new TypeReference>(){}); + } catch (JsonProcessingException e) { + e.printStackTrace(); + return null; + } + } } diff --git a/src/main/java/at/reisinger/server/helper/PostgresHelper.java b/src/main/java/at/reisinger/server/helper/PostgresHelper.java new file mode 100644 index 0000000..37db72c --- /dev/null +++ b/src/main/java/at/reisinger/server/helper/PostgresHelper.java @@ -0,0 +1,61 @@ +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){ + boolean tmp = executeUpdate(sql); + System.out.println(message); + return tmp; + } + + /** + * 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; + } +} diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 7bd2d6d..1db70a2 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -2,10 +2,12 @@ package at.reisinger.server.objects; import at.reisinger.*; import at.reisinger.Package; +import at.reisinger.server.helper.JsonHelper; import at.reisinger.server.msg.MsgHandler; import 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; @@ -28,8 +30,6 @@ public class Response { private String url; private String payload; private String authString; - private MsgHandler msgHandler; - private StringBuilder rqBuilder; /** * Nimmt die Daten des requests und generiert eine Response @@ -47,7 +47,6 @@ public class Response { 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")) { @@ -70,20 +69,7 @@ public class Response { 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(); } } @@ -102,6 +88,12 @@ public class Response { 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; //System.out.println("auth string: " + authString); @@ -111,28 +103,33 @@ public class Response { return authStringEnc; } - private String basicAuthGetUsername(String authString) throws UnsupportedEncodingException { + /** + * 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; + System.out.println("auth To username"); if (authString != null) { - System.out.println("1"); byte[] credDecoded = Base64.getDecoder().decode(authString); - System.out.println("2"); String credentials = new String(credDecoded); - System.out.println("credentials: "); - System.out.println(credentials); - // credentials = username:password values = credentials.split(":", 2); + System.out.println("credentials: "); + System.out.println(values[0]); }else{ values = null; } return values[0]; } + /** + * Alle Post Methoden, siehe API beschreibung für genauere details + * @throws JsonProcessingException Fehler beim de-/serialisieren + */ 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>(){}); + Map map = JsonHelper.jsonPayload2ToMap(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)); @@ -143,6 +140,7 @@ public class Response { } //User to json + ObjectMapper objectMapper = new ObjectMapper(); objectMapper = new ObjectMapper(); String userJson = ""; if(newUser != null) { @@ -156,9 +154,7 @@ public class Response { sendError("500"); } }else if (this.url.startsWith("/sessions")) { - //payload to map - ObjectMapper objectMapper = new ObjectMapper(); - Map map = objectMapper.readValue(this.payload, new TypeReference>(){}); + Map map = JsonHelper.jsonPayload2ToMap(this.payload); String username = (String) map.get("Username"); String password = (String) map.get("Password"); User user = null; @@ -178,26 +174,14 @@ public class Response { } }else if (this.url.startsWith("/packages")) { if(basicAuth("admin", "admin", this.authString)){ - System.out.println("1"); ObjectMapper objectMapper = new ObjectMapper(); - System.out.println("2"); ArrayList listCards = objectMapper.readValue(this.payload, new TypeReference>(){}); - System.out.println("List cards"); - System.out.println(listCards.toString()); Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId()+"", 5); - System.out.println("3"); if(!new DBConnection().addPackage(packageCards)){ sendError("500"); }else{ - //Package to json - objectMapper = new ObjectMapper(); - String packageJson = ""; - if(packageCards != null) { - try { - packageJson += objectMapper.writeValueAsString(packageCards); - } catch (JsonProcessingException e) { - packageJson = "Error: JsonProcessingException -> " + e.getMessage(); - } + String packageJson = JsonHelper.packageToJson(packageCards); + if(packageJson != null) { sendResponse(packageJson, "201"); }else{ sendError("500"); @@ -206,32 +190,62 @@ public class Response { }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.packageToJson(newPackage); + if(packageJson == null){ + sendError("500"); + }else { + sendResponse(packageJson, "200"); + } + } + }else{ + sendError("401"); + } } } + /** + * Prüft den Login, anhand des BasicAuth Base64 String + * @return True wenn login daten korrekt, sonst false + */ + private boolean login(){ + String username = basicAuthGetUsername(this.authString); + User user = null; + DBConnection con = new DBConnection(); + try { + user = con.getUser(username); + } catch (SQLException throwables) { + throwables.printStackTrace(); + return false; + } + if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){ + return true; + }else{ + return false; + } + } + + /** + * Alle Put Methoden, siehe API beschreibung für genauere details + * @throws JsonProcessingException Fehler beim de-/serialisieren + */ 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"); - } } } + /** + * Alle Delete Methoden, siehe API beschreibung für genauere details + * @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"); - } } } @@ -249,6 +263,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
" + "add message: POST /messages (Payload: the message; Response an id like1)
" + @@ -257,11 +274,7 @@ public class Response { "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 @@ -276,14 +289,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; - } - } From 0b1d3ad677dfc145e19291c93331f5c3e3a2bbda Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Tue, 29 Dec 2020 20:09:26 +0100 Subject: [PATCH 09/20] Login Bugfix + put&get /users/{username} + get /cards --- src/main/java/at/reisinger/Card.java | 20 --- src/main/java/at/reisinger/Cards.java | 10 +- src/main/java/at/reisinger/DBConnection.java | 114 +++++++++---- src/main/java/at/reisinger/User.java | 52 +++++- .../reisinger/server/helper/JsonHelper.java | 30 +++- .../server/helper/PostgresHelper.java | 3 +- .../at/reisinger/server/objects/Response.java | 161 ++++++++++++------ src/test/java/StoreTest.java | 14 +- src/test/java/TradingDealTest.java | 4 +- src/test/java/UserTest.java | 2 +- 10 files changed, 288 insertions(+), 122 deletions(-) diff --git a/src/main/java/at/reisinger/Card.java b/src/main/java/at/reisinger/Card.java index 8d180e6..a0f849f 100644 --- a/src/main/java/at/reisinger/Card.java +++ b/src/main/java/at/reisinger/Card.java @@ -60,15 +60,7 @@ public class Card { */ private ElementTyp stringToElementType(String elementTypeString){ for (ElementTyp e : ElementTyp.values()) { - System.out.println(e.toString().toLowerCase()); - System.out.println(elementTypeString.toLowerCase().contains(e.name().toLowerCase())); if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) { - System.out.println("\n\n\n"); - System.out.println("####Element####, me.name() : elementTypeString"); - System.out.println(e.name().toLowerCase()); - System.out.print(" : "); - System.out.println(elementTypeString.toLowerCase()); - System.out.println("\n\n\n"); return e; } } @@ -81,20 +73,8 @@ public class Card { * @return Passender Card Type oder null falls nicht gefunden */ private CardType stringToCardType(String cardTypeString){ - System.out.println("\n\n\n"); - System.out.println("###CARD###, me.name() : cardTypeString\n"); for (CardType me : CardType.values()) { - System.out.println("\n\n\n"); - System.out.print(me.name().toLowerCase()); - System.out.print(" : "); - System.out.println(cardTypeString.toLowerCase()); - System.out.println("\n\n\n"); if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) { - System.out.println("\n\n\n"); - System.out.print(me.name().toLowerCase()); - System.out.print(" : "); - System.out.println(cardTypeString.toLowerCase()); - System.out.println("\n\n\n"); return me; } } diff --git a/src/main/java/at/reisinger/Cards.java b/src/main/java/at/reisinger/Cards.java index 1d7a78d..9c9a343 100644 --- a/src/main/java/at/reisinger/Cards.java +++ b/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 cards; /** * Erstellt ein nues obj mit gegebenen Karten * @param cardsArrayList Die at.reisinger.Cards zum erstellen des Obj */ - public Cards(ArrayList cardsArrayList) { + @JsonCreator + public Cards(@JsonProperty("cards") ArrayList 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 getCards() { return this.cards; } diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index 05e8ed1..184c4b3 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -10,8 +10,8 @@ import java.util.ArrayList; * Die "Datenbank" sind hier nur beispieldaten. */ public class DBConnection { - private ArrayList tradingDeals; - private ArrayList packages; + //private ArrayList tradingDeals; + //private ArrayList packages; private Connection c; private Statement stmt; @@ -28,7 +28,7 @@ public class DBConnection { * Erstellt alle Tabellen die für den Betrieb der Software bennötigt werden */ public void init() { - PostgresHelper.executeUpdateMessage("CREATE TABLE IF NOT EXISTS USERS (username TEXT PRIMARY KEY NOT NULL, nachname TEXT NOT NULL, email TEXT NOT NULL, password TEXT NOT NULL)", "User Table created"); + PostgresHelper.executeUpdateMessage("CREATE TABLE IF NOT EXISTS USERS (username TEXT PRIMARY KEY NOT NULL, nachname TEXT NOT NULL, email TEXT NOT NULL, password TEXT NOT NULL, bio TEXT, image TEXT, coins integer default 20 not null)", "User Table created"); PostgresHelper.executeUpdate("CREATE TABLE IF NOT EXISTS CARD(NAME TEXT not null,DAMAGE FLOAT not null,ELEMENTTYP TEXT not null,CARDTYPE TEXT not null, PRIMARY KEY (\"name\"));"); PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);", "Card Table created"); PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS package(\"ID\" varchar(255) not null,name varchar(255) not null constraint name references card, i serial not null constraint package_i primary key );", "Package Table created"); @@ -42,13 +42,11 @@ public class DBConnection { * @return Das Package aus dem Shop, null falls ein Fehler auftritt */ public Package userAcquirePackage(String username) { - System.out.println("Vor den coins"); int coins = checkCoins(username); if (!(coins - 5 >= 0)) { return null; } updateCoins(coins - 5, username); - System.out.println("nach den soins"); this.c = PostgresHelper.con(); String id = ""; @@ -57,8 +55,6 @@ public class DBConnection { ResultSet rs = stmt.executeQuery("select \"ID\" as id from package LIMIT 1;"); while (rs.next()) { id = rs.getString("id"); - System.out.println("id = " + id); - System.out.println(); } rs.close(); stmt.close(); @@ -87,12 +83,10 @@ public class DBConnection { damage = rs.getInt("damage"); Card newCard = new Card(cardname, elementtyp + cardtype, damage); cards.addCard(newCard); - System.out.println(); Connection b = PostgresHelper.con(); try { stmt = b.createStatement(); String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + newCard.getName() + "\', \'false\');"; - System.out.println(sql); stmt.executeUpdate(sql); stmt.close(); b.close(); @@ -154,8 +148,6 @@ public class DBConnection { ResultSet rs = stmt.executeQuery("Select coins from users where username = \'" + username + "\';"); while (rs.next()) { coins = rs.getInt("coins"); - System.out.println("Count: "); - System.out.print(coins); } rs.close(); stmt.close(); @@ -183,8 +175,6 @@ public class DBConnection { ResultSet rs = stmt.executeQuery("select count(*) from card where name = \'" + name + "\';"); while (rs.next()) { count = rs.getInt("count"); - System.out.println("Count: "); - System.out.print(count); } rs.close(); stmt.close(); @@ -234,8 +224,6 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); return 0; } - System.out.println("Package Next id is: "); - System.out.print(id); return Integer.parseInt(id) + 1; } @@ -270,8 +258,25 @@ public class DBConnection { * @param email Email des Users * @return True wenn alles erfolgreich war, false wenn es nicht erfolgreich war */ - public boolean addUser(String username, String password, String nachname, String email) { - return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password) values (\'" + username + "\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\')", "User added"); + 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 \'#\'"); } /** @@ -279,12 +284,12 @@ public class DBConnection { * Gibt ein User Objekt zurück * * @param uname Username der zu suchen ist - * @return User als User Objekt + * @return User als User Objekt, null bei fehler * @throws SQLException Fehler bei der Suche in der DB */ public User getUser(String uname) throws SQLException { this.c = PostgresHelper.con(); - String username = "", password = "", email = "", nachname = ""; + String username = "", password = "", email = "", nachname = "", bio="", image=""; try { stmt = this.c.createStatement(); ResultSet rs = stmt.executeQuery("SELECT * FROM users where username = \'" + uname + "\';"); @@ -293,11 +298,37 @@ public class DBConnection { nachname = rs.getString("nachname"); email = rs.getString("email"); password = rs.getString("password"); - System.out.println("username = " + username); - System.out.println("nachname = " + nachname); - System.out.println("email = " + email); - System.out.println("password = " + password); - System.out.println(); + 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()); + ArrayList cardnamenarray = new ArrayList(); + 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(); @@ -306,15 +337,40 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); System.exit(0); } - System.out.println("Operation done successfully"); - return new User(new Credentials(username, password), username, username, email, new Coins(20)); + 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 getAllTradingDeals() { return this.tradingDeals; } @@ -323,9 +379,9 @@ public class DBConnection { * Fügt einen neuen Tradingdeal zum at.reisinger.Store hinzu * * @param tradingDeal Der neue Deal - */ + public void addTradingDeal(TradingDeal tradingDeal) { this.tradingDeals.add(tradingDeal); } - +*/ } diff --git a/src/main/java/at/reisinger/User.java b/src/main/java/at/reisinger/User.java index f01934f..b6d56c4 100644 --- a/src/main/java/at/reisinger/User.java +++ b/src/main/java/at/reisinger/User.java @@ -8,9 +8,9 @@ import java.util.ArrayList; * at.reisinger.User & at.reisinger.Store Logik */ @JsonAutoDetect -public class User implements Store{ +public class User{ @JsonProperty - private String name, nachname, email; + private String name, nachname, email, bio, image; /* @JsonProperty private Stack stack; @@ -42,16 +42,54 @@ public class User implements Store{ } */ @JsonCreator - public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Coins coins) { + public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Coins coins, @JsonProperty String bio, @JsonProperty String image) { this.credentials = credentials; this.name = name; this.nachname = nachname; this.email = email; //this.stack = null; this.coins = coins; + this.bio = bio; + this.image = image; //this.db = new at.reisinger.DBConnection(); } + /** + * Holt die Bio vom User + * @return Bio des Users + */ + @JsonGetter + public String getBio() { + return bio; + } + + /** + * Setzt die Bio vom User + * @param bio Bio des Users + */ + @JsonSetter + public void setBio(String bio) { + this.bio = bio; + } + + /** + * Holt das image vom user + * @return Image vom user + */ + @JsonGetter + public String getImage() { + return image; + } + + /** + * Setzt das image vom user + * @param image Image vom user + */ + @JsonSetter + public void setImage(String image) { + this.image = image; + } + /** * Holt den at.reisinger.Stack des Users * @return at.reisinger.Stack des Users @@ -199,15 +237,16 @@ public class User implements Store{ /** * Fügt dem at.reisinger.Store einen neuen Tradingdeal hinzu * @param tradingDeal Der neue Tradingdeal - */ + * public void addTradingDeal(TradingDeal tradingDeal) { new DBConnection().addTradingDeal(tradingDeal); } + /** * Holt alle verfügbaren Tradingdeals * @return Alle verfügbaren Deals - */ + * public ArrayList getTradingDeals() { return new DBConnection().getAllTradingDeals(); } @@ -237,7 +276,7 @@ public class User implements Store{ * Gibt alle Möglichen Trading Deals zurück * @param toTrade Prüft nach diesem Deal * @return - */ + * @Override public ArrayList getPossibleTradingDeals(Card toTrade) { ArrayList storeList = new DBConnection().getAllTradingDeals(); @@ -251,6 +290,7 @@ public class User implements Store{ return possible; } + */ /** * Checkt ob es sich um den selben at.reisinger.User handelt * @param toCheck Mit diesem at.reisinger.User wird verglichen diff --git a/src/main/java/at/reisinger/server/helper/JsonHelper.java b/src/main/java/at/reisinger/server/helper/JsonHelper.java index 1b3a290..6b51a74 100644 --- a/src/main/java/at/reisinger/server/helper/JsonHelper.java +++ b/src/main/java/at/reisinger/server/helper/JsonHelper.java @@ -3,6 +3,7 @@ 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; @@ -23,21 +24,21 @@ public class JsonHelper { */ public static String packageListToJson(ArrayList listCards, String name){ Package packageCards = new Package(new Cards(listCards),name, 5); - return packageToJson(packageCards); + return objToJson(packageCards); } /** * Wandelt ein Package Objekt in ein Json um - * @param packageCards Package Objekt das in ein Json umgewandelt werden soll + * @param obj Objekt das in ein Json umgewandelt werden soll * @return Json String des Packages */ - public static String packageToJson(Package packageCards){ + public static String objToJson(Object obj){ ObjectMapper objectMapper = new ObjectMapper(); objectMapper = new ObjectMapper(); String packageJson = ""; - if(packageCards != null) { + if(obj != null) { try { - packageJson += objectMapper.writeValueAsString(packageCards); + packageJson += objectMapper.writeValueAsString(obj); } catch (JsonProcessingException e) { packageJson = "Error: JsonProcessingException -> " + e.getMessage(); } @@ -47,7 +48,7 @@ public class JsonHelper { } } - public static Map jsonPayload2ToMap(String payload){ + public static Map jsonPayloadToMap(String payload){ ObjectMapper objectMapper = new ObjectMapper(); try { return objectMapper.readValue(payload, new TypeReference>(){}); @@ -57,4 +58,21 @@ public class JsonHelper { } } + 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; + } + } + } diff --git a/src/main/java/at/reisinger/server/helper/PostgresHelper.java b/src/main/java/at/reisinger/server/helper/PostgresHelper.java index 37db72c..e773291 100644 --- a/src/main/java/at/reisinger/server/helper/PostgresHelper.java +++ b/src/main/java/at/reisinger/server/helper/PostgresHelper.java @@ -34,9 +34,8 @@ public class PostgresHelper { * @return True bei erfolg, sonst false */ public static boolean executeUpdateMessage(String sql, String message){ - boolean tmp = executeUpdate(sql); System.out.println(message); - return tmp; + return executeUpdate(sql); } /** diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 1db70a2..6e9fd30 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -3,6 +3,7 @@ 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; @@ -47,10 +48,13 @@ public class Response { this.cmd = cmd; this.out = out; this.payload = payload; - System.out.println(cmd); if (this.url != null) { if (this.cmd.equals("GET")) { - getMethodes(); + if(login()) { + getMethodes(); + }else{ + sendError("401"); + } }else if (this.cmd.equals("POST")){ try { postMethodes(); @@ -58,18 +62,55 @@ 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")) { - } else if (this.url.startsWith("/")) { + 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"); + } } } @@ -96,10 +137,8 @@ public class Response { */ private String basicAuthBase64(String username, String password){ String authString = username + ":" + password; - //System.out.println("auth string: " + authString); byte[] authEncBytes = Base64.getEncoder().encode(authString.getBytes()); String authStringEnc = new String(authEncBytes); - //System.out.println("Base64 encoded auth string: " + authStringEnc); return authStringEnc; } @@ -110,13 +149,10 @@ public class Response { */ private String basicAuthGetUsername(String authString) { String[] values; - System.out.println("auth To username"); if (authString != null) { byte[] credDecoded = Base64.getDecoder().decode(authString); String credentials = new String(credDecoded); values = credentials.split(":", 2); - System.out.println("credentials: "); - System.out.println(values[0]); }else{ values = null; } @@ -125,36 +161,30 @@ public class Response { /** * Alle Post Methoden, siehe API beschreibung für genauere details + * + * Kann auch von nicht angemeldeten usern erreicht werden. + * login() wird hier verwendet * @throws JsonProcessingException Fehler beim de-/serialisieren */ private void postMethodes() throws JsonProcessingException { if (this.url.startsWith("/users")) { - Map map = JsonHelper.jsonPayload2ToMap(this.payload); + Map map = JsonHelper.jsonPayloadToMap(this.payload); String username = (String) map.get("Username"); String password = (String) map.get("Password"); - User newUser = new User(new Credentials(username, password), username, username, "not implemented", new Coins(20)); + User newUser = new User(new Credentials(username, password), username, username, "not implemented", new Coins(20), "BIO", "IMAGE"); System.out.println("CON DB"); DBConnection con = new DBConnection(); - if(!con.addUser(username, password, username, "not implemented")){ + if(!con.addUser(newUser.getCredentials().getUsername(), newUser.getCredentials().getPasswort(), newUser.getCredentials().getUsername(), newUser.getEmail(), newUser.getBio(), newUser.getImage())){ sendError("409"); } - - //User to json - ObjectMapper objectMapper = new ObjectMapper(); - objectMapper = new ObjectMapper(); - String userJson = ""; - if(newUser != null) { - try { - userJson += objectMapper.writeValueAsString(newUser); - } catch (JsonProcessingException e) { - userJson = "Error: JsonProcessingException -> " + e.getMessage(); - } + String userJson = JsonHelper.userToJson(newUser);; + if(userJson != null) { sendResponse(userJson, "201"); }else{ sendError("500"); } }else if (this.url.startsWith("/sessions")) { - Map map = JsonHelper.jsonPayload2ToMap(this.payload); + Map map = JsonHelper.jsonPayloadToMap(this.payload); String username = (String) map.get("Username"); String password = (String) map.get("Password"); User user = null; @@ -173,39 +203,40 @@ public class Response { sendError("401"); } }else if (this.url.startsWith("/packages")) { - if(basicAuth("admin", "admin", this.authString)){ - ObjectMapper objectMapper = new ObjectMapper(); - ArrayList listCards = objectMapper.readValue(this.payload, new TypeReference>(){}); - Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId()+"", 5); - if(!new DBConnection().addPackage(packageCards)){ - sendError("500"); - }else{ - String packageJson = JsonHelper.packageToJson(packageCards); - if(packageJson != null) { - sendResponse(packageJson, "201"); - }else{ + if(login()) { + if (basicAuth("admin", "admin", this.authString)) { + ObjectMapper objectMapper = new ObjectMapper(); + ArrayList listCards = objectMapper.readValue(this.payload, new TypeReference>() { + }); + 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{ - sendError("401"); } }else if (this.url.startsWith("/transactions/packages")) { - if(login()){ + if (login()) { DBConnection db = new DBConnection(); Package newPackage = db.userAcquirePackage(basicAuthGetUsername(this.authString)); - if (newPackage == null){ + if (newPackage == null) { sendError("500"); - }else{ - String packageJson = JsonHelper.packageToJson(newPackage); - if(packageJson == null){ + } else { + String packageJson = JsonHelper.objToJson(newPackage); + if (packageJson == null) { sendError("500"); - }else { + } else { sendResponse(packageJson, "200"); } } - }else{ - sendError("401"); } } } @@ -232,20 +263,52 @@ public class Response { } /** - * Alle Put Methoden, siehe API beschreibung für genauere details + * Alle Put Methoden + * Nur für angemeldete user erreichbar * @throws JsonProcessingException Fehler beim de-/serialisieren */ private void putMethodes(){ - if (this.url.startsWith("/messages")) { + if (this.url.startsWith("/users")) { + String username = this.url.substring(this.url.lastIndexOf('/') + 1); + System.out.println("Username in /users/{username}: " + username); + User user = null; + try { + user = new DBConnection().getUser(username); + } catch (SQLException throwables) { + throwables.printStackTrace(); + sendError("401"); + } + if(user != null) { + Map 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")) { + } } diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java index 558c5fd..d99402e 100644 --- a/src/test/java/StoreTest.java +++ b/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", coins); - userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", 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 Coins(1000)); + User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Coins(1000), "BIO", "IMAGE"); ArrayList tradingDeals = new ArrayList(); ArrayList packages = new ArrayList(); tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); @@ -108,7 +108,7 @@ public class StoreTest { stackArrList.add(c5); Cards deck = new Cards(deckArrList); Cards stack = new Cards(stackArrList); - User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Coins(1000)); + User user = new User(new Credentials("username", "passwort"), "Name", "Nachname", "Email", new Coins(1000), "BIO", "IMAGE"); ArrayList tradingDeals = new ArrayList(); ArrayList packages = new ArrayList(); tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); @@ -136,10 +136,12 @@ public class StoreTest { stackArrList.add(c5); Cards deck = new Cards(deckArrList); Cards stack = new Cards(stackArrList); - TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "DerName", "Nachname", "Email", new Coins(1000)), c1, ElementTyp.FIRE, 10, CardType.SPELL); + TradingDeal vonDB = new TradingDeal(new User(new Credentials("username", "passwort"), "DerName", "Nachname", "Email", new Coins(1000), "BIO", "IMAGE"), c1, ElementTyp.FIRE, 10, CardType.SPELL); expected.add(vonDB); System.out.println(result.get(0).getCardToTrade().getName()); System.out.println(expected.get(0).getCardToTrade().getName()); assertTrue(result.get(0).getCardToTrade().equals(expected.get(0).getCardToTrade())); } + + */ } diff --git a/src/test/java/TradingDealTest.java b/src/test/java/TradingDealTest.java index e4eaa6a..5b08790 100644 --- a/src/test/java/TradingDealTest.java +++ b/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", coins); - userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", 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; diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java index 40dc2c7..325c332 100644 --- a/src/test/java/UserTest.java +++ b/src/test/java/UserTest.java @@ -38,7 +38,7 @@ public class UserTest { Coins coins = new Coins(10); //at.reisinger.User Credentials credentials = new Credentials("username", "pw"); - user = new User(credentials, "name", "nachname", "email", coins); + user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE"); } @Test public void test_getName() { From e7f3679e0f8bf0436eda5e8a91ed53574749ef55 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Wed, 30 Dec 2020 14:39:20 +0100 Subject: [PATCH 10/20] EnumHelper + setDeck /deck + getDeck /deck + getDeckPlain + /deck?format=plain + started Trading --- .../reisinger/server/helper/EnumHelper.java | 2 + .../at/reisinger/server/msg/MsgHandler.java | 89 ------------------- 2 files changed, 2 insertions(+), 89 deletions(-) create mode 100644 src/main/java/at/reisinger/server/helper/EnumHelper.java delete mode 100644 src/main/java/at/reisinger/server/msg/MsgHandler.java diff --git a/src/main/java/at/reisinger/server/helper/EnumHelper.java b/src/main/java/at/reisinger/server/helper/EnumHelper.java new file mode 100644 index 0000000..df59604 --- /dev/null +++ b/src/main/java/at/reisinger/server/helper/EnumHelper.java @@ -0,0 +1,2 @@ +package at.reisinger.server.helper;public class EnumHelper { +} diff --git a/src/main/java/at/reisinger/server/msg/MsgHandler.java b/src/main/java/at/reisinger/server/msg/MsgHandler.java deleted file mode 100644 index f9f609a..0000000 --- a/src/main/java/at/reisinger/server/msg/MsgHandler.java +++ /dev/null @@ -1,89 +0,0 @@ -package at.reisinger.server.msg; - -import at.reisinger.server.objects.Msg; - -import java.util.HashMap; - -/** - * Der Speicher der Nachrichten - * Mit hilfe einer HashMap werden die MsgId und die Msg selbst gespeichert - * @author Georg Reisinger - */ -public class MsgHandler { - private HashMap 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; - } -} From 0df6ff129e4c5d9ea8e239cf59f77cd258a8feec Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Wed, 30 Dec 2020 14:40:24 +0100 Subject: [PATCH 11/20] EnumHelper + setDeck /deck + getDeck /deck + getDeckPlain + /deck?format=plain + started Trading --- src/main/java/at/reisinger/Card.java | 35 +-- src/main/java/at/reisinger/CardType.java | 2 +- src/main/java/at/reisinger/Cards.java | 4 +- src/main/java/at/reisinger/DBConnection.java | 223 ++++++++++++++++-- src/main/java/at/reisinger/ElementTyp.java | 2 +- src/main/java/at/reisinger/TradingDeal.java | 69 +++++- src/main/java/at/reisinger/server/Main.java | 2 - .../reisinger/server/helper/EnumHelper.java | 38 ++- .../reisinger/server/helper/JsonHelper.java | 60 +++-- .../at/reisinger/server/objects/Request.java | 5 +- .../at/reisinger/server/objects/Response.java | 110 +++++++-- src/test/java/CardsTest.java | 4 +- src/test/java/StoreTest.java | 2 +- src/test/java/TradingDealTest.java | 2 +- 14 files changed, 463 insertions(+), 95 deletions(-) diff --git a/src/main/java/at/reisinger/Card.java b/src/main/java/at/reisinger/Card.java index a0f849f..7c00cb6 100644 --- a/src/main/java/at/reisinger/Card.java +++ b/src/main/java/at/reisinger/Card.java @@ -1,5 +1,6 @@ package at.reisinger; +import at.reisinger.server.helper.EnumHelper; import com.fasterxml.jackson.annotation.*; /** @@ -15,6 +16,8 @@ public class Card { private ElementTyp elementTyp; @JsonProperty private CardType cardType; + @JsonProperty + private boolean locked; /** * Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften @@ -39,11 +42,11 @@ public class Card { */ @JsonCreator public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){ - ElementTyp tmpElement = stringToElementType(elementCardTyp); + ElementTyp tmpElement = EnumHelper.stringToElementType(elementCardTyp); if(tmpElement == null){ tmpElement = ElementTyp.UNDEF; } - CardType tmpCard = stringToCardType(elementCardTyp); + CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp); if(tmpCard == null){ tmpCard = CardType.UNDEF; } @@ -54,31 +57,19 @@ public class Card { } /** - * Wenn ein String als ElementType vorhanden ist, dann gibt er den passenden ElementType zurück - * @param elementTypeString elementType als String - * @return Passender Element Type oder null falls nicht gefunden + * Prüft ob die Karte gesperrt ist + * @return True wenn die Karte gesperrt ist */ - private ElementTyp stringToElementType(String elementTypeString){ - for (ElementTyp e : ElementTyp.values()) { - if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) { - return e; - } - } - return null; + public boolean isLocked() { + return locked; } /** - * Wenn ein String als cardType vorhanden ist, dann gibt er den passenden cardType zurück - * @param cardTypeString cardType als String - * @return Passender Card Type oder null falls nicht gefunden + * Setzt die sperre der Karte + * @param locked True bedeuted gesperrt */ - private CardType stringToCardType(String cardTypeString){ - for (CardType me : CardType.values()) { - if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) { - return me; - } - } - return null; + public void setLocked(boolean locked) { + this.locked = locked; } /** diff --git a/src/main/java/at/reisinger/CardType.java b/src/main/java/at/reisinger/CardType.java index 8214d9a..0bdbe17 100644 --- a/src/main/java/at/reisinger/CardType.java +++ b/src/main/java/at/reisinger/CardType.java @@ -1,5 +1,5 @@ package at.reisinger; public enum CardType { - MONSTER, SPELL, UNDEF, GOBLIN, TROLL, ELF, KNIGHT + MONSTER, SPELL, UNDEF, GOBLIN, TROLL, ELF, KNIGHT, DRAGON, WIZZARD, ORK, KRAKEN, FIREELVES } diff --git a/src/main/java/at/reisinger/Cards.java b/src/main/java/at/reisinger/Cards.java index 9c9a343..9b6fdbb 100644 --- a/src/main/java/at/reisinger/Cards.java +++ b/src/main/java/at/reisinger/Cards.java @@ -56,10 +56,10 @@ public class Cards { * @param toCeck at.reisinger.Card nach der in den at.reisinger.Cards gesucht werden soll * @return True wenn die at.reisinger.Card in den at.reisinger.Cards ist */ - public boolean containsCard(Card toCeck){ + public boolean containsCard(String toCeck){ AtomicBoolean returnval = new AtomicBoolean(false); this.cards.forEach(item -> { - if(item.getElementTyp().equals(toCeck.getElementTyp()) && item.getCardType().equals(toCeck.getCardType()) && item.getName().equals(toCeck.getName()) && item.getDamage() == toCeck.getDamage()){ + if(item.getName().equals(toCeck)){ returnval.set(true); }else{ returnval.set(false); diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index 184c4b3..949493c 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -4,6 +4,8 @@ import at.reisinger.server.helper.PostgresHelper; import java.sql.*; import java.util.ArrayList; +import java.util.Collections; +import java.util.List; /** * Stellt die Verbindung zur "Datenbank" her @@ -33,8 +35,145 @@ public class DBConnection { PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS card_name_uindex on CARD (NAME);", "Card Table created"); PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS package(\"ID\" varchar(255) not null,name varchar(255) not null constraint name references card, i serial not null constraint package_i primary key );", "Package Table created"); PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_cards(username TEXT not null constraint user_cards_users_username_fk references users,name text not null, gesperrt boolean not null);", "UserCards Table created"); + PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_deck(username text not null constraint user_deck_users_username_fk references users,cardname text not null);", "UserDeck Table created"); + PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS trading(username text not null constraint trading_users_username_fk references users,id text not null constraint trading_pk primary key, cardtotrade text not null constraint trading_card_name_fk references card, mindamage float not null,reqcardtype text not null,reqelement text not null);", "Trading Table created"); } + /** + * Fügt der DB einen Trading deal hinzu + * @param username User der den Trade hinzufügt + * @param id Id des Trades + * @param mindamage Min damage der für den trade benötigt wird + * @param reqcardtype Req Card Type der für den trade benötigt wird + * @param reqelement Req Element Typ der für den trade benötigt wird + * @param cardtotrade Card die zum Traden ist + * @return True bei erfolg, sonst false + */ + public boolean addTradingdeal(String username, String id, double mindamage, String reqcardtype, String reqelement, String cardtotrade){ + if(PostgresHelper.executeUpdate("INSERT INTO public.trading (username, id, cardtotrade, mindamage, reqcardtype, reqelement) VALUES (\'" + username + "\',\'" + id + "\',\'" + cardtotrade + "\',\'"+ mindamage + "\',\'" + reqcardtype + "\',\'" + reqelement + "\');")){ + return true; + }else{ + return false; + } + } + + /** + * Holt alle Trading Deals aus der DB + * @return Null bei error + */ + public ArrayList getAllTradingDeals(){ + this.c = PostgresHelper.con(); + ArrayList tradingDeals = new ArrayList(); + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select * from trading;"); + while (rs.next()) { + String username, id, cardtotrade, reqcardtype, reqelement; + int mindamage; + username = rs.getString("username"); + id = rs.getString("id"); + cardtotrade = rs.getString("cardtotrade"); + reqcardtype = rs.getString("reqcardtype"); + reqelement = rs.getString("reqelement"); + mindamage = rs.getInt("mindamage"); + + Card card = new DBConnection().getCardFromID(cardtotrade); + if(card != null){ + TradingDeal tmp = new TradingDeal(id, card, mindamage, reqcardtype +reqelement, username); + if (tmp != null){ + tradingDeals.add(tmp); + System.out.println("Pulled TradingDeal"); + }else{ + return null; + } + }else{ + return null; + } + + + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + return null; + } + System.out.println("Trading Deals pulled successfully"); + return tradingDeals; + } + + /** + * Setzt das Deck eines Users + * @param username Username von dem das Deck gesetzt werden soll + * @param deck Die ID´s des Decks in der Form einer ArrayList + * @return True bei erfolg, sonst false + */ + public boolean setDeck(String username, List deck){ + if (!delDeck(username)){ + return false; + } + Cards allCards = getCards(username); + Cards deckCards = new Cards(new ArrayList()); + int count = 0; + if(allCards != null){ + for (String st : deck) { + for (Card ca: allCards.getCards()) { + System.out.println("Count : " + count); + System.out.println("CA: " + ca.getName() + " st: " + st); + if(ca.getName().equals(st) && count < 4){ + deckCards.addCard(ca); + if(!PostgresHelper.executeUpdateMessage("INSERT INTO public.user_deck (username, cardname) VALUES (\'"+username+"\', \'"+st+"\');", "Card #"+count+" added to Deck")){ + return false; + } + } + } + count++; + } + return true; + } + return false; + } + + /** + * Holt alle Card namen aus dem Deck eines Users + * @param username user von dem die Deck namen geholt werden soll + * @return null bedeuted error + */ + public ArrayList getDeck(String username){ + this.c = PostgresHelper.con(); + String cardname = ""; + Cards allCards = new Cards(new ArrayList()); + ArrayList cardnamenarray = new ArrayList(); + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select * from user_deck where username = \'" + username + "\';"); + while (rs.next()) { + cardname = rs.getString("cardname"); + cardnamenarray.add(cardname); + System.out.println("cardname = " + cardname); + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + return null; + } + System.out.println("Deck names pulled successfully"); + return cardnamenarray; + } + + /** + * Löscht den gesammten inhalt des Decks eines users + * @param username Username von dem das Deck gelöscht werden soll + * @return True bei erfolg, sonst false + */ + public boolean delDeck(String username){ + return PostgresHelper.executeUpdateMessage("delete from user_deck where username = \'" + username + "\';", "User Deck: " + username + ", deleted"); + } + + /** * Holt ein Random package aus dem Shop * @@ -313,31 +452,49 @@ public class DBConnection { } /** - * Holt alle Karten eines Users - * @param username Username des Users - * @return Cards Object, falls es null ist, war ein fehler + * Holt eine Card aus der DB, anhand der gegebenen Card Id + * @param id Id der Card die geholt werden soll + * @return Null bei error */ - public Cards getCards(String username){ - this.c = PostgresHelper.con(); - String cardname = ""; - Cards allCards = new Cards(new ArrayList()); - ArrayList cardnamenarray = new ArrayList(); + public Card getCardFromID(String id){ + Connection b = PostgresHelper.con(); + Card toreturn = null; try { - stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';"); + stmt = b.createStatement(); + ResultSet rs = stmt.executeQuery("select * from card where NAME = \'" + id + "\';"); while (rs.next()) { - cardname = rs.getString("name"); - cardnamenarray.add(cardname); - System.out.println("cardname = " + cardname); + int damage =rs.getInt("damage"); + String elementtyp =rs.getString("elementtyp"); + String cardtype=rs.getString("cardtype"); + System.out.println("damage = " + damage); + System.out.println("elementtyp = " + elementtyp); + System.out.println("cardtype = " + cardtype); + System.out.println(); + toreturn = new Card(id, elementtyp+cardtype, damage); } rs.close(); stmt.close(); - this.c.close(); + b.close(); } catch (Exception e) { System.err.println(e.getClass().getName() + ": " + e.getMessage()); - System.exit(0); + return null; } - System.out.println("Card Namen pulled successfully"); + if (toreturn != null){ + System.out.println("Card pulled successfully"); + return toreturn; + }else { + System.out.println("Card NOT pulled"); + return null; + } + } + + /** + * Holt alle Carten einer gegebenen Card ID List + * @param cardnamenarray Card IDs in einer Liste + * @return Falls null, dann war ein error + */ + public Cards getCardsFromIDList(List cardnamenarray){ + Cards allCards = new Cards(new ArrayList()); for (String st : cardnamenarray) { Connection b = PostgresHelper.con(); try { @@ -358,14 +515,44 @@ public class DBConnection { b.close(); } catch (Exception e) { System.err.println(e.getClass().getName() + ": " + e.getMessage()); - System.exit(0); + return null; } System.out.println("Card pulled successfully"); } - return allCards; } + /** + * Holt alle Karten eines Users + * @param username Username des Users + * @return Cards Object, falls es null ist, war ein fehler + */ + public Cards getCards(String username){ + this.c = PostgresHelper.con(); + String cardname = ""; + boolean locked; + Cards allCards = new Cards(new ArrayList()); + ArrayList cardnamenarray = new ArrayList(); + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';"); + while (rs.next()) { + cardname = rs.getString("name"); + locked = rs.getBoolean("gesperrt"); + cardnamenarray.add(cardname); + System.out.println("cardname = " + cardname); + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + return null; + } + System.out.println("Card Namen pulled successfully"); + return getCardsFromIDList(cardnamenarray); + } + /** * Holt alle verfügbaren TradingDeals * diff --git a/src/main/java/at/reisinger/ElementTyp.java b/src/main/java/at/reisinger/ElementTyp.java index f71ce55..df30a72 100644 --- a/src/main/java/at/reisinger/ElementTyp.java +++ b/src/main/java/at/reisinger/ElementTyp.java @@ -1,5 +1,5 @@ package at.reisinger; public enum ElementTyp { - WATER, FIRE, NORMAL, UNDEF, REGULAR, GOBLIN, KNIGHT + WATER, FIRE, NORMAL, UNDEF, REGULAR, GOBLIN, TROLL, ELF, KNIGHT, DRAGON, WIZZARD, ORK, KRAKEN, FIREELVES } diff --git a/src/main/java/at/reisinger/TradingDeal.java b/src/main/java/at/reisinger/TradingDeal.java index 8c79b18..6be97e4 100644 --- a/src/main/java/at/reisinger/TradingDeal.java +++ b/src/main/java/at/reisinger/TradingDeal.java @@ -1,43 +1,83 @@ package at.reisinger; +import at.reisinger.server.helper.EnumHelper; +import com.fasterxml.jackson.annotation.*; + /** * Ein einzelner Trading deal wird hier verwaltet. */ +@JsonAutoDetect public class TradingDeal { - //private User tradingUser; + @JsonProperty + private String id, username; + @JsonProperty private Card cardToTrade; + @JsonProperty private ElementTyp requiredElementType; + @JsonProperty private double requiredMinDamage; + @JsonProperty private CardType requiredCardType; /** - * Ein at.reisinger.TradingDeal wird erstellt - * @param user at.reisinger.User des Deals + * Ein TradingDeal wird erstellt + * @param id Id des Trading deals * @param cardToTrade at.reisinger.Card die getauscht werden soll * @param requiredElementType Req ElementType für den Tausch * @param requiredMinDamage Req min damage für den Tausch * @param requiredCardType Req at.reisinger.Card Type für den Tausch */ - public TradingDeal(User user, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType) { - //this.tradingUser = user; + public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) { + this.id = id; this.cardToTrade = cardToTrade; + if(requiredElementType == null){ + requiredElementType = ElementTyp.UNDEF; + } + if(requiredCardType == null) { + requiredCardType = CardType.UNDEF; + } this.requiredElementType = requiredElementType; this.requiredMinDamage = requiredMinDamage; this.requiredCardType = requiredCardType; + this.username = username; } /** - * Holt den Trading at.reisinger.User - * @return at.reisinger.User der den Trade erstellt hat - - public User getTradingUser() { - return this.tradingUser; + * Ein TradingDeal wird erstellt, anhand des type werden der ElementType und der CardType automatisch bestimmt + * @param id Id des Trading deals + * @param cardToTrade at.reisinger.Card die getauscht werden soll + * @param type ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt. + * Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null + */ + @JsonCreator + public TradingDeal(@JsonProperty("Id") String id, @JsonProperty("CardToTrade") Card cardToTrade, @JsonProperty("MinimumDamage") double requiredMinDamage, @JsonProperty("Type") String type, String username) { + this(id, cardToTrade, EnumHelper.stringToElementType(type), requiredMinDamage, EnumHelper.stringToCardType(type), username); } -*/ + + /** + * Holt den usernamen + * @return Der username als String + */ + @JsonGetter + public String getUsername() { + return username; + } + + /** + * Setzt den usernamen + * @param username Der username als String + */ + @JsonSetter + public void setUsername(String username) { + this.username = username; + } + + /** * at.reisinger.Card die getraded werden soll * @return at.reisinger.Card die getradet werden soll */ + @JsonGetter public Card getCardToTrade() { return this.cardToTrade; } @@ -46,6 +86,7 @@ public class TradingDeal { * Req Element type holen * @return Req Element Type */ + @JsonGetter public ElementTyp getRequiredElementType() { return this.requiredElementType; } @@ -54,6 +95,7 @@ public class TradingDeal { * Req min damage holen * @return Req min damage */ + @JsonGetter public double getRequiredMinDamage() { return this.requiredMinDamage; } @@ -62,6 +104,7 @@ public class TradingDeal { * Hole req cardtype * @return Req at.reisinger.CardType */ + @JsonGetter public CardType getRequiredCardType() { return this.requiredCardType; } @@ -78,6 +121,7 @@ public class TradingDeal { * Setzt die Karte die Getradet werden soll * @param cardToTrade at.reisinger.Card zum tauschen */ + @JsonSetter public void setCardToTrade(Card cardToTrade) { this.cardToTrade = cardToTrade; } @@ -86,6 +130,7 @@ public class TradingDeal { * Setzt req elementType * @param requiredElementType Der Req elementType */ + @JsonSetter public void setRequiredElementType(ElementTyp requiredElementType) { this.requiredElementType = requiredElementType; } @@ -94,6 +139,7 @@ public class TradingDeal { * Setzt die req Min damage * @param requiredMinDamage Die req min gamage */ + @JsonSetter public void setRequiredMinDamage(double requiredMinDamage) { this.requiredMinDamage = requiredMinDamage; } @@ -102,6 +148,7 @@ public class TradingDeal { * Setzt req cardType * @param requiredCardType Der Req at.reisinger.CardType */ + @JsonSetter public void setRequiredCardType(CardType requiredCardType) { this.requiredCardType = requiredCardType; } diff --git a/src/main/java/at/reisinger/server/Main.java b/src/main/java/at/reisinger/server/Main.java index 01fb64a..2300a09 100644 --- a/src/main/java/at/reisinger/server/Main.java +++ b/src/main/java/at/reisinger/server/Main.java @@ -1,7 +1,6 @@ package at.reisinger.server; import at.reisinger.DBConnection; -import at.reisinger.server.msg.MsgHandler; import at.reisinger.server.objects.Request; import at.reisinger.server.objects.Response; @@ -17,7 +16,6 @@ public class Main { static final int port = 80; private Socket socket; private int id; - private MsgHandler msgHandler; /** * Initial Start diff --git a/src/main/java/at/reisinger/server/helper/EnumHelper.java b/src/main/java/at/reisinger/server/helper/EnumHelper.java index df59604..3bbe03d 100644 --- a/src/main/java/at/reisinger/server/helper/EnumHelper.java +++ b/src/main/java/at/reisinger/server/helper/EnumHelper.java @@ -1,2 +1,38 @@ -package at.reisinger.server.helper;public class EnumHelper { +package at.reisinger.server.helper; + +import at.reisinger.CardType; +import at.reisinger.ElementTyp; + +/** + * Hilft beim manipulieren von enums + */ +public class EnumHelper { + + /** + * Wenn ein String als ElementType vorhanden ist, dann gibt er den passenden ElementType zurück + * @param elementTypeString elementType als String + * @return Passender Element Type oder null falls nicht gefunden + */ + public static ElementTyp stringToElementType(String elementTypeString){ + for (ElementTyp e : ElementTyp.values()) { + if (elementTypeString.toLowerCase().contains(e.name().toLowerCase())) { + return e; + } + } + return null; + } + + /** + * Wenn ein String als cardType vorhanden ist, dann gibt er den passenden cardType zurück + * @param cardTypeString cardType als String + * @return Passender Card Type oder null falls nicht gefunden + */ + public static CardType stringToCardType(String cardTypeString){ + for (CardType me : CardType.values()) { + if (cardTypeString.toLowerCase().contains(me.toString().toLowerCase())) { + return me; + } + } + return null; + } } diff --git a/src/main/java/at/reisinger/server/helper/JsonHelper.java b/src/main/java/at/reisinger/server/helper/JsonHelper.java index 6b51a74..507cff3 100644 --- a/src/main/java/at/reisinger/server/helper/JsonHelper.java +++ b/src/main/java/at/reisinger/server/helper/JsonHelper.java @@ -9,6 +9,7 @@ import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import java.util.ArrayList; +import java.util.List; import java.util.Map; /** @@ -48,6 +49,49 @@ public class JsonHelper { } } + /** + * Json wird in ein Card Objekt umgewandelt + * @param json Json das umgewandelt werden soll + * @return Null bei JsonProcessingException + */ + public static Card jsonToCard(String json){ + ObjectMapper objectMapper = new ObjectMapper(); + Card card = null; + try { + card = objectMapper.readValue(json, Card.class); + if(card != null) { + return card; + }else{ + return null; + } + } catch (JsonProcessingException e) { + e.printStackTrace(); + return null; + } + } + + + + /** + * Json zu List + * @param payload Json String + * @return List aus dem json, bei einer JsonProcessingException null + */ + public static List jsonPayloadToList(String payload){ + ObjectMapper objectMapper = new ObjectMapper(); + try { + return objectMapper.readValue(payload, new TypeReference>(){}); + } catch (JsonProcessingException e) { + e.printStackTrace(); + return null; + } + } + + /** + * Json zu Map + * @param payload Json String + * @return Map aus dem json, bei einer JsonProcessingException null + */ public static Map jsonPayloadToMap(String payload){ ObjectMapper objectMapper = new ObjectMapper(); try { @@ -58,21 +102,9 @@ public class JsonHelper { } } + @Deprecated public static String userToJson(User user){ - //User to json - ObjectMapper objectMapper = new ObjectMapper(); - objectMapper = new ObjectMapper(); - String userJson = ""; - if(user != null) { - try { - userJson += objectMapper.writeValueAsString(user); - } catch (JsonProcessingException e) { - userJson = "Error: JsonProcessingException -> " + e.getMessage(); - } - return userJson; - }else{ - return null; - } + return objToJson(user); } } diff --git a/src/main/java/at/reisinger/server/objects/Request.java b/src/main/java/at/reisinger/server/objects/Request.java index 68ce0a5..cb4f8b8 100644 --- a/src/main/java/at/reisinger/server/objects/Request.java +++ b/src/main/java/at/reisinger/server/objects/Request.java @@ -65,10 +65,13 @@ public class Request { headers.add(header); } - int authIndex = headers.toString().indexOf("Authorization"); + int authIndex = headers.toString().indexOf("Authorization: Basic"); String authString = headers.toString().substring(authIndex + 21); + System.out.println("AUTH STRING: " + authString); int authIndexEnd = authString.indexOf(','); + System.out.println("INDEX OF: " + authIndexEnd); authString = authString.substring(0, authIndexEnd); + System.out.println("AUTH STRING: " + authString); this.authString = authString; diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 6e9fd30..90521f2 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -4,7 +4,6 @@ import at.reisinger.*; import at.reisinger.Package; import at.reisinger.server.helper.JsonHelper; import at.reisinger.server.helper.PostgresHelper; -import at.reisinger.server.msg.MsgHandler; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; @@ -111,6 +110,25 @@ public class Response { }else{ sendError("500"); } + }else if(this.url.startsWith("/deck")) { + String format = this.url.substring(this.url.lastIndexOf('?') + 1); + System.out.println("Format in /deck?{format=plain}: " + format); + String username = basicAuthGetUsername(this.authString); + ArrayList allCards = new DBConnection().getDeck(username); + Cards deck = null; + Object tmp = null; + if(format.startsWith("format=plain")){ + tmp = allCards; + }else{ + deck = new DBConnection().getCardsFromIDList(allCards); + tmp = deck; + } + String jsonCards = JsonHelper.objToJson(tmp); + if (jsonCards != null && !jsonCards.isEmpty()) { + sendResponse(jsonCards, "200"); + } else { + sendError("500"); + } } } @@ -203,25 +221,23 @@ public class Response { sendError("401"); } }else if (this.url.startsWith("/packages")) { - if(login()) { - if (basicAuth("admin", "admin", this.authString)) { - ObjectMapper objectMapper = new ObjectMapper(); - ArrayList listCards = objectMapper.readValue(this.payload, new TypeReference>() { - }); - 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"); - } - } + if (basicAuth("admin", "istrator", this.authString)) { + ObjectMapper objectMapper = new ObjectMapper(); + ArrayList listCards = objectMapper.readValue(this.payload, new TypeReference>() { + }); + Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5); + if (!new DBConnection().addPackage(packageCards)) { + sendError("500"); } else { - sendError("401"); + 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()) { @@ -237,6 +253,47 @@ public class Response { sendResponse(packageJson, "200"); } } + }else{ + sendError("401"); + } + }else if (this.url.startsWith("/tradings")) { + if(login()){ + Map map = JsonHelper.jsonPayloadToMap(this.payload); + String id = (String)map.get("Id"); + String cardtotrade = (String)map.get("CardToTrade"); + String type = (String)map.get("Type"); + double mindamage = (double)map.get("MinimumDamage"); + ArrayList cardname = new ArrayList(); + cardname.add(cardtotrade); + Cards cards = new DBConnection().getCardsFromIDList(cardname); + Card cardtoTradeC = null; + if (cards != null){ + cardtoTradeC = cards.getCards().get(0); + if (cardtoTradeC != null){ + TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, basicAuthGetUsername(this.authString)); + if (tradingDeal != null){ + String tradingJson = JsonHelper.objToJson(tradingDeal); + if (tradingDeal != null){ + //DB Trading deal add + // Lock Card for deck + //Wenn card im deck, dann del aus deck + //new DBConnection().; + sendResponse(tradingJson, "201"); + }else{ + sendError("500"); + } + }else{ + sendError("500"); + } + }else { + sendError("500"); + } + }else{ + sendError("500"); + } + + }else{ + sendError("401"); } } } @@ -296,6 +353,23 @@ public class Response { }else{ sendError("500"); } + }else if(this.url.startsWith("/deck")) { + List deckIds = JsonHelper.jsonPayloadToList(this.payload); + if (deckIds != null){ + if (new DBConnection().setDeck(basicAuthGetUsername(this.authString), deckIds)){ + Cards deck = new DBConnection().getCardsFromIDList(deckIds); + String deckJson = JsonHelper.objToJson(deck); + if (deck != null && deckJson != null){ + sendResponse(deckJson, "200"); + }else { + sendError("500"); + } + }else { + sendError("500"); + } + }else{ + sendError("500"); + } } } diff --git a/src/test/java/CardsTest.java b/src/test/java/CardsTest.java index 811acf4..82dd34c 100644 --- a/src/test/java/CardsTest.java +++ b/src/test/java/CardsTest.java @@ -52,12 +52,12 @@ public class CardsTest { @Test void test_contains() { - assertTrue(cards2.containsCard(card)); + assertTrue(cards2.containsCard(card.getName())); } @Test void test_contains2() { - assertFalse(cards.containsCard(newCard)); + assertFalse(cards.containsCard(newCard.getName())); } @Test diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java index d99402e..4b56943 100644 --- a/src/test/java/StoreTest.java +++ b/src/test/java/StoreTest.java @@ -44,7 +44,7 @@ public class StoreTest { ElementTyp requiredElementType = ElementTyp.FIRE; double requiredMinDamage = 100; CardType requiredCardType = CardType.MONSTER; - tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType); + tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME"); } /* diff --git a/src/test/java/TradingDealTest.java b/src/test/java/TradingDealTest.java index 5b08790..0c17119 100644 --- a/src/test/java/TradingDealTest.java +++ b/src/test/java/TradingDealTest.java @@ -44,7 +44,7 @@ public class TradingDealTest { ElementTyp requiredElementType = ElementTyp.FIRE; double requiredMinDamage = 100; CardType requiredCardType = CardType.MONSTER; - tradingDeal = new TradingDeal(user, cardToTrade, requiredElementType, requiredMinDamage, requiredCardType); + tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME"); } /* From 7b2ecd3bf09528d43e543c3aa1620be0e9ea0928 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Wed, 30 Dec 2020 15:03:30 +0100 Subject: [PATCH 12/20] add TradingDeal /tradings --- src/main/java/at/reisinger/DBConnection.java | 11 +++++ src/main/java/at/reisinger/TradingDeal.java | 16 +++++++ .../at/reisinger/server/objects/Response.java | 46 ++++++++++++------- 3 files changed, 57 insertions(+), 16 deletions(-) diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index 949493c..d3b0f8f 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -39,6 +39,16 @@ public class DBConnection { PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS trading(username text not null constraint trading_users_username_fk references users,id text not null constraint trading_pk primary key, cardtotrade text not null constraint trading_card_name_fk references card, mindamage float not null,reqcardtype text not null,reqelement text not null);", "Trading Table created"); } + /** + * Updated den Lock einer user card + * @param name Name der Card + * @param lock Zustand des Locks + * @return true bei erfolg, sonst false + */ + public boolean updateCardLock(String name, boolean lock){ + return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';"); + } + /** * Fügt der DB einen Trading deal hinzu * @param username User der den Trade hinzufügt @@ -457,6 +467,7 @@ public class DBConnection { * @return Null bei error */ public Card getCardFromID(String id){ + System.out.println(id); Connection b = PostgresHelper.con(); Card toreturn = null; try { diff --git a/src/main/java/at/reisinger/TradingDeal.java b/src/main/java/at/reisinger/TradingDeal.java index 6be97e4..0e748f0 100644 --- a/src/main/java/at/reisinger/TradingDeal.java +++ b/src/main/java/at/reisinger/TradingDeal.java @@ -54,6 +54,22 @@ public class TradingDeal { this(id, cardToTrade, EnumHelper.stringToElementType(type), requiredMinDamage, EnumHelper.stringToCardType(type), username); } + /** + * Holt die ID des Trading deals + * @return Id des Trading Deals + */ + public String getId() { + return id; + } + + /** + * Setzt die id des TradingDeals + * @param id Id des TradingDeals + */ + public void setId(String id) { + this.id = id; + } + /** * Holt den usernamen * @return Der username als String diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 90521f2..b99c93e 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -262,36 +262,50 @@ public class Response { String id = (String)map.get("Id"); String cardtotrade = (String)map.get("CardToTrade"); String type = (String)map.get("Type"); - double mindamage = (double)map.get("MinimumDamage"); - ArrayList cardname = new ArrayList(); - cardname.add(cardtotrade); - Cards cards = new DBConnection().getCardsFromIDList(cardname); - Card cardtoTradeC = null; - if (cards != null){ - cardtoTradeC = cards.getCards().get(0); - if (cardtoTradeC != null){ - TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, basicAuthGetUsername(this.authString)); - if (tradingDeal != null){ + double mindamage = Double.parseDouble(map.get("MinimumDamage") + ""); + String username = basicAuthGetUsername(this.authString); + if (username != null) { + Card cardtoTradeC = new DBConnection().getCardFromID(cardtotrade); + System.out.println("CARD TO TRAD: " + cardtoTradeC.getName()); + if (cardtoTradeC != null) { + TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, username); + if (tradingDeal != null) { String tradingJson = JsonHelper.objToJson(tradingDeal); - if (tradingDeal != null){ + if (tradingDeal != null) { //DB Trading deal add // Lock Card for deck - //Wenn card im deck, dann del aus deck + //Wenn card im deck, dann del aus deck //new DBConnection().; + ArrayList deckCards = new DBConnection().getDeck(username); + if (deckCards != null) { + if (deckCards.contains(cardtotrade)) { + new DBConnection().delDeck(username); + } + if(new DBConnection().addTradingdeal(tradingDeal.getUsername(), tradingDeal.getId(), tradingDeal.getRequiredMinDamage(), tradingDeal.getRequiredCardType().name(), tradingDeal.getRequiredElementType().name(), tradingDeal.getCardToTrade().getName())){ + if(new DBConnection().updateCardLock(tradingDeal.getUsername(), true)){ + sendResponse(JsonHelper.objToJson(tradingDeal), "201"); + }else{ + sendError("500"); + } + }else{ + sendError("500"); + } + } else { + sendError("500"); + } sendResponse(tradingJson, "201"); - }else{ + } else { sendError("500"); } - }else{ + } else { sendError("500"); } - }else { + } else { sendError("500"); } }else{ sendError("500"); } - }else{ sendError("401"); } From 6b8f84a262e35c410a3fe61eb408315577669af6 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Wed, 30 Dec 2020 15:14:31 +0100 Subject: [PATCH 13/20] getTradingDeals /tradings --- .../java/at/reisinger/server/objects/Response.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index b99c93e..4e53286 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -129,6 +129,20 @@ public class Response { } else { sendError("500"); } + }else if(this.url.startsWith("/tradings")) { + ArrayList allDeals = new DBConnection().getAllTradingDeals(); + if(allDeals != null && !allDeals.isEmpty()){ + String json = JsonHelper.objToJson(allDeals); + if(json != null && json != ""){ + sendResponse(json, "200"); + }else{ + sendError("500"); + } + }else{ + sendError("500"); + } + }else{ + sendError("204"); } } From 3e8003ab5058a628a37d10c44abab758fea433dc Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Wed, 30 Dec 2020 15:19:06 +0100 Subject: [PATCH 14/20] card lock bei tradingDeal Create --- src/main/java/at/reisinger/DBConnection.java | 1 + src/main/java/at/reisinger/server/objects/Response.java | 6 +----- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index d3b0f8f..24cceef 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -46,6 +46,7 @@ public class DBConnection { * @return true bei erfolg, sonst false */ public boolean updateCardLock(String name, boolean lock){ + System.out.println("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';"); return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';"); } diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 4e53286..717dd5e 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -286,17 +286,13 @@ public class Response { if (tradingDeal != null) { String tradingJson = JsonHelper.objToJson(tradingDeal); if (tradingDeal != null) { - //DB Trading deal add - // Lock Card for deck - //Wenn card im deck, dann del aus deck - //new DBConnection().; ArrayList deckCards = new DBConnection().getDeck(username); if (deckCards != null) { if (deckCards.contains(cardtotrade)) { new DBConnection().delDeck(username); } if(new DBConnection().addTradingdeal(tradingDeal.getUsername(), tradingDeal.getId(), tradingDeal.getRequiredMinDamage(), tradingDeal.getRequiredCardType().name(), tradingDeal.getRequiredElementType().name(), tradingDeal.getCardToTrade().getName())){ - if(new DBConnection().updateCardLock(tradingDeal.getUsername(), true)){ + if(new DBConnection().updateCardLock(tradingDeal.getCardToTrade().getName(), true)){ sendResponse(JsonHelper.objToJson(tradingDeal), "201"); }else{ sendError("500"); From 8e44e37804ff7ece5389d9f974ff20232693267f Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Wed, 30 Dec 2020 15:30:50 +0100 Subject: [PATCH 15/20] delTradingDeal + unlock card --- src/main/java/at/reisinger/DBConnection.java | 10 +++++++- .../at/reisinger/server/objects/Response.java | 23 ++++++++++++++++++- 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index 24cceef..b0201aa 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -46,10 +46,18 @@ public class DBConnection { * @return true bei erfolg, sonst false */ public boolean updateCardLock(String name, boolean lock){ - System.out.println("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';"); return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';"); } + /** + * Löscht einen Trading Deal aus der Datenbank + * @param id Id des deals der gelöscht werden soll + * @return True bei erfolg, sonst false + */ + public boolean deleteTradingDeal(String id){ + return PostgresHelper.executeUpdate("delete from trading where id = \'" + id + "\';"); + } + /** * Fügt der DB einen Trading deal hinzu * @param username User der den Trade hinzufügt diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 717dd5e..783b72c 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -405,7 +405,28 @@ public class Response { * @throws JsonProcessingException Fehler beim de-/serialisieren */ private void deleteMethodes(){ - if (this.url.startsWith("/messages")) { + if (this.url.startsWith("/tradings")) { + String tradeid = this.url.substring(this.url.lastIndexOf('/') + 1); + System.out.println("Format in /tradings/{tradingid}: " + tradeid); + ArrayList allTradingDeals = new DBConnection().getAllTradingDeals(); + TradingDeal tr = null; + if (allTradingDeals != null && !allTradingDeals.isEmpty()) { + for (TradingDeal i : allTradingDeals) { + if (i.getId().equals(tradeid)) { + tr = i; + } + } + if (tr != null) { + if (new DBConnection().deleteTradingDeal(tradeid)) { + if (new DBConnection().updateCardLock(tr.getCardToTrade().getName(), false)) + sendResponse("", "204"); + } else { + sendError("500"); + } + }else{ + sendError("500"); + } + } } } From 2c9242e45cf9c84ac1efb229d0297dfc16d871eb Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Wed, 30 Dec 2020 15:47:16 +0100 Subject: [PATCH 16/20] Lock Set deck --> if(card.isLocked() == true) --- src/main/java/at/reisinger/DBConnection.java | 33 ++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index b0201aa..aaac6b4 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -49,6 +49,29 @@ public class DBConnection { return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';"); } + + /** + * Prüft ob eine Card für das Deck gesperrt ist + * @param name Name der Card die zu prüfen ist + * @return True falls gesperrt, ansonst false + * @throws SQLException Locked Cards konnten nicht aus der DB geholt werden + */ + public boolean getCardLock(String name) throws SQLException { + this.c = PostgresHelper.con(); + ArrayList tradingDeals = new ArrayList(); + boolean locked = false; + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select gesperrt from user_cards where name = \'" + name + "\';"); + while (rs.next()) { + locked = rs.getBoolean("gesperrt"); + } + rs.close(); + stmt.close(); + this.c.close(); + System.out.println("Trading Deals pulled successfully"); + return locked; + } + /** * Löscht einen Trading Deal aus der Datenbank * @param id Id des deals der gelöscht werden soll @@ -129,6 +152,16 @@ public class DBConnection { * @return True bei erfolg, sonst false */ public boolean setDeck(String username, List deck){ + for (String st :deck) { + try { + if(getCardLock(st)){ + return false; + } + } catch (SQLException throwables) { + throwables.printStackTrace(); + return false; + } + } if (!delDeck(username)){ return false; } From a5c910b50881b696ade0c167dc4c9e693194e007 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Wed, 30 Dec 2020 16:35:15 +0100 Subject: [PATCH 17/20] doTrade /tradings --- src/main/java/at/reisinger/DBConnection.java | 42 +++-- .../java/at/reisinger/server/objects/Msg.java | 37 ----- .../at/reisinger/server/objects/Request.java | 21 ++- .../at/reisinger/server/objects/Response.java | 143 +++++++++++++----- 4 files changed, 150 insertions(+), 93 deletions(-) delete mode 100644 src/main/java/at/reisinger/server/objects/Msg.java diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index aaac6b4..0a86e90 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -274,18 +274,9 @@ public class DBConnection { damage = rs.getInt("damage"); Card newCard = new Card(cardname, elementtyp + cardtype, damage); cards.addCard(newCard); - Connection b = PostgresHelper.con(); - try { - stmt = b.createStatement(); - String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + newCard.getName() + "\', \'false\');"; - stmt.executeUpdate(sql); - stmt.close(); - b.close(); - } catch (Exception e) { - System.err.println(e.getClass().getName() + ": " + e.getMessage()); + if(!addUserCard(username, newCard.getName())){ return null; } - System.out.println("User got Card successfully"); } rs.close(); stmt.close(); @@ -304,6 +295,37 @@ public class DBConnection { } } + /** + * Löscht eine user card aus der DB + * @param username Card löschen von + * @param cardname Card die vom user zu löschen ist + * @return True bei erfolg, sonst false + */ + public boolean delUserCard(String username, String cardname){ + return PostgresHelper.executeUpdate("delete from user_cards where username = \'"+username+"\' and name = \'"+cardname+"\';"); + } + + /** + * Fügt eine Card zu den User_Cards hinzu + * @param username Username der die Card bekommt + * @param cardName Card die der User bekommt + * @return True bei erfolg, sonst false + */ + public boolean addUserCard(String username, String cardName){ + Connection b = PostgresHelper.con(); + try { + stmt = b.createStatement(); + String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + cardName + "\', \'false\');"; + stmt.executeUpdate(sql); + stmt.close(); + b.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + return false; + } + System.out.println("User got Card successfully"); + return true; + } /** * Löscht ein Package anhand des Namens * diff --git a/src/main/java/at/reisinger/server/objects/Msg.java b/src/main/java/at/reisinger/server/objects/Msg.java deleted file mode 100644 index 87a2ea7..0000000 --- a/src/main/java/at/reisinger/server/objects/Msg.java +++ /dev/null @@ -1,37 +0,0 @@ -package at.reisinger.server.objects; - -/** - * Message Objekt beinmhaltet die MsgId und die Msg selbst - * @author Georg Reisinger - */ -public class Msg { - private int id; - private String msg; - - /** - * Erstellt eine Message - */ - public Msg(int id, String msg){ - this.id = id; - this.msg = msg; - } - - - /** - * get field - * - * @return id Message Id - */ - public int getId() { - return this.id; - } - - /** - * get field - * - * @return msg Message String - */ - public String getMsg() { - return this.msg; - } -} diff --git a/src/main/java/at/reisinger/server/objects/Request.java b/src/main/java/at/reisinger/server/objects/Request.java index cb4f8b8..e4b703b 100644 --- a/src/main/java/at/reisinger/server/objects/Request.java +++ b/src/main/java/at/reisinger/server/objects/Request.java @@ -65,19 +65,24 @@ public class Request { headers.add(header); } - int authIndex = headers.toString().indexOf("Authorization: Basic"); - String authString = headers.toString().substring(authIndex + 21); - System.out.println("AUTH STRING: " + authString); - int authIndexEnd = authString.indexOf(','); - System.out.println("INDEX OF: " + authIndexEnd); - authString = authString.substring(0, authIndexEnd); - System.out.println("AUTH STRING: " + authString); - this.authString = authString; String accessLog = String.format("Client %s, method %s, path %s, version %s, host %s, headers %s", socket.toString(), method, path, version, host, headers.toString()); System.out.println(accessLog); + if(headers.toString().contains("Authorization: Basic")) { + int authIndex = headers.toString().indexOf("Authorization: Basic"); + String authString = headers.toString().substring(authIndex + 21); + System.out.println("AUTH STRING: " + authString); + int authIndexEnd = authString.indexOf(','); + System.out.println("INDEX OF: " + authIndexEnd); + authString = authString.substring(0, authIndexEnd); + System.out.println("AUTH STRING: " + authString); + + this.authString = authString; + }else{ + this.authString = null; + } } /** diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 783b72c..90b755e 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -272,38 +272,103 @@ public class Response { } }else if (this.url.startsWith("/tradings")) { if(login()){ - Map map = JsonHelper.jsonPayloadToMap(this.payload); - String id = (String)map.get("Id"); - String cardtotrade = (String)map.get("CardToTrade"); - String type = (String)map.get("Type"); - double mindamage = Double.parseDouble(map.get("MinimumDamage") + ""); - String username = basicAuthGetUsername(this.authString); - if (username != null) { - Card cardtoTradeC = new DBConnection().getCardFromID(cardtotrade); - System.out.println("CARD TO TRAD: " + cardtoTradeC.getName()); - if (cardtoTradeC != null) { - TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, username); - if (tradingDeal != null) { - String tradingJson = JsonHelper.objToJson(tradingDeal); - if (tradingDeal != null) { - ArrayList deckCards = new DBConnection().getDeck(username); - if (deckCards != null) { - if (deckCards.contains(cardtotrade)) { - new DBConnection().delDeck(username); - } - if(new DBConnection().addTradingdeal(tradingDeal.getUsername(), tradingDeal.getId(), tradingDeal.getRequiredMinDamage(), tradingDeal.getRequiredCardType().name(), tradingDeal.getRequiredElementType().name(), tradingDeal.getCardToTrade().getName())){ - if(new DBConnection().updateCardLock(tradingDeal.getCardToTrade().getName(), true)){ - sendResponse(JsonHelper.objToJson(tradingDeal), "201"); - }else{ + String dotradeid = this.url.substring(this.url.lastIndexOf('/') + 1); + System.out.println("DO TradeID in /tradings/{tradeID}: " + dotradeid); + if(!dotradeid.isEmpty() && dotradeid != null && !dotradeid.equals("tradings")){ + //DO TRADE + String username = basicAuthGetUsername(this.authString); + if(username != null && !username.isEmpty()) { + System.out.println(this.payload); + ArrayList tradingDealArrayList = new DBConnection().getAllTradingDeals(); + TradingDeal tradingDeal = null; + if (tradingDealArrayList != null && !tradingDealArrayList.isEmpty()) { + for (TradingDeal tr : tradingDealArrayList) { + if (tr.getId().equals(dotradeid)) { + tradingDeal = tr; + } + } + Card card = new DBConnection().getCardFromID(this.payload); + if (card != null) { + if (tradingDeal != null) { + if (tradingDeal.cardOk(card)) { + String json = JsonHelper.objToJson(card); + if (json != null && !json.isEmpty()) { + if (new DBConnection().addUserCard(username, tradingDeal.getCardToTrade().getName())){ + if (new DBConnection().delUserCard(tradingDeal.getUsername(), tradingDeal.getCardToTrade().getName())){ + if(new DBConnection().deleteTradingDeal(tradingDeal.getId())){ + if (new DBConnection().delUserCard(username, card.getName())){ + if(new DBConnection().addUserCard(tradingDeal.getUsername(), card.getName())){ + sendResponse(json, "200"); + }else { + sendError("500"); + } + }else { + sendError("500"); + } + }else{ + sendError("500"); + } + }else{ + sendError("500"); + } + }else{ + sendError("500"); + } + } else { sendError("500"); } - }else{ + } else { sendError("500"); } } else { sendError("500"); } - sendResponse(tradingJson, "201"); + } else { + sendError("500"); + } + } else { + sendError("500"); + } + }else{ + sendError("401"); + } + }else { + //CREATE TRADING DEAL + Map map = JsonHelper.jsonPayloadToMap(this.payload); + String id = (String) map.get("Id"); + String cardtotrade = (String) map.get("CardToTrade"); + String type = (String) map.get("Type"); + double mindamage = Double.parseDouble(map.get("MinimumDamage") + ""); + String username = basicAuthGetUsername(this.authString); + if (username != null) { + Card cardtoTradeC = new DBConnection().getCardFromID(cardtotrade); + System.out.println("CARD TO TRAD: " + cardtoTradeC.getName()); + if (cardtoTradeC != null) { + TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, username); + if (tradingDeal != null) { + String tradingJson = JsonHelper.objToJson(tradingDeal); + if (tradingDeal != null) { + ArrayList deckCards = new DBConnection().getDeck(username); + if (deckCards != null) { + if (deckCards.contains(cardtotrade)) { + new DBConnection().delDeck(username); + } + if (new DBConnection().addTradingdeal(tradingDeal.getUsername(), tradingDeal.getId(), tradingDeal.getRequiredMinDamage(), tradingDeal.getRequiredCardType().name(), tradingDeal.getRequiredElementType().name(), tradingDeal.getCardToTrade().getName())) { + if (new DBConnection().updateCardLock(tradingDeal.getCardToTrade().getName(), true)) { + sendResponse(JsonHelper.objToJson(tradingDeal), "201"); + } else { + sendError("500"); + } + } else { + sendError("500"); + } + } else { + sendError("500"); + } + sendResponse(tradingJson, "201"); + } else { + sendError("500"); + } } else { sendError("500"); } @@ -313,8 +378,6 @@ public class Response { } else { sendError("500"); } - }else{ - sendError("500"); } }else{ sendError("401"); @@ -327,17 +390,21 @@ public class Response { * @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; + if(this.authString != null && !this.authString.isEmpty()){ + 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; + } }else{ return false; } From 13bec601db78e32ff422aad7c8d9fa8c9c4dfc87 Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Thu, 31 Dec 2020 03:45:50 +0100 Subject: [PATCH 18/20] Battle --- src/main/java/at/reisinger/Battle.java | 517 ++++++++++++++++++ src/main/java/at/reisinger/Card.java | 44 +- src/main/java/at/reisinger/Cards.java | 8 +- src/main/java/at/reisinger/DBConnection.java | 182 ++++++ src/main/java/at/reisinger/ElementTyp.java | 2 +- src/main/java/at/reisinger/server/Main.java | 4 +- .../at/reisinger/server/objects/Response.java | 156 +++++- 7 files changed, 883 insertions(+), 30 deletions(-) diff --git a/src/main/java/at/reisinger/Battle.java b/src/main/java/at/reisinger/Battle.java index d43bbce..b34eb3b 100644 --- a/src/main/java/at/reisinger/Battle.java +++ b/src/main/java/at/reisinger/Battle.java @@ -1,4 +1,521 @@ package at.reisinger; +import java.util.ArrayList; +import java.util.Collections; + public class Battle { + + private User player1, player2; + private int scorePlayer1, scorePlayer2, id; + private Cards deckPlayer1, deckPlayer2, deckPlayer1Init, deckPlayer2Init; + private Card spielfeldCardPlayer1, spielfeldCardPlayer2; + private ArrayList log = new ArrayList(); + + + /** + * Erstellt ein neues Battle + * @param player1 Player 1 Obj + * @param player2 Player 2 Obj + * @param scorePlayer1 Score PLayer 1 + * @param scorePlayer2 Score player 2 + * @param deckPlayer1 Deck Player 1 + * @param deckPlayer2 Deck Player 2 + */ + public Battle(int id, User player1, User player2, int scorePlayer1, int scorePlayer2, Cards deckPlayer1, Cards deckPlayer2) { + this.id = id; + this.player1 = player1; + this.player2 = player2; + this.scorePlayer1 = scorePlayer1; + this.scorePlayer2 = scorePlayer2; + this.deckPlayer1 = deckPlayer1; + this.deckPlayer2 = deckPlayer2; + this.deckPlayer1Init = deckPlayer1; + this.deckPlayer2Init = deckPlayer2; + this.spielfeldCardPlayer1 = null; + this.spielfeldCardPlayer2 = null; + } + + /** + * Erstellt ein neues Battle, im zustand offenes battle + * @param id + * @param player1 + * @param deckPlayer1 + */ + public Battle(int id, User player1, Cards deckPlayer1){ + this.id = id; + this.player1 = player1; + this.deckPlayer1 = deckPlayer1; + this.scorePlayer1 = 100; + this.scorePlayer2 = 100; + this.deckPlayer2 = null; + this.deckPlayer1Init = deckPlayer1; + this.deckPlayer2Init = null; + this.spielfeldCardPlayer1 = null; + this.spielfeldCardPlayer2 = null; + } + + /** + * Startet einen Kampf zw den beiden Playern + * @return true bei erfolg, sonst false + */ + public boolean doFight(){ + System.out.println("DAS IS DAS BATTTTLLLLLLLEEEEEEEEEE FIIIIIGHT!"); + System.out.println(player1.getName() + " |vs|" + player2.getName()); + System.out.println(deckPlayer1.getCards().toString()+ " |vs| " + deckPlayer2.getCards().toString()); + + if(deckPlayer1.getCards().size() == 4 && deckPlayer2.getCards().size() == 4) { + //SHUFFLE DECK + ArrayList d1 = deckPlayer1.getCards(); + ArrayList d2 = deckPlayer2.getCards(); + Collections.shuffle(d1); + Collections.shuffle(d2); + deckPlayer1.setCards(d1); + deckPlayer1.setCards(d2); + + //Runden + int maxroundcount = 100; + for(int i = 0; d1.size()>i && d2.size()>i && i goblin.getDamage()) { + //Drache ist stärker + if (dragonOwner == 1) { + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + } else if (dragonOwner == 2) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer1 -= 5; + this.scorePlayer2 += 3; + } + log.add("Player "+dragonOwner+" gewinnt!\nDrache ist stärker! Drache: " + dragon.getDamage() + " vs Goblin: " + goblin.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } else { + System.out.println("DRAW: Drache zu schwach um anzugreifen und GOBLIN zu feige."); + } + } else if ((c1.getCardType().name().toUpperCase().equals("ELF") && c1.getElementTyp().name().toUpperCase().equals("FIRE") && !c2.getCardType().name().toUpperCase().equals("ELF") || (!c1.getCardType().name().toUpperCase().equals("ELF") && c2.getElementTyp().name().toUpperCase().equals("FIRE") && c2.getCardType().name().toUpperCase().equals("ELF")))) { + //Eine der Karten ist der Fire Elf die andere Karte ist der drache + System.out.println("Andere ist ein elf"); + Card fireelf = null; + if (dragonOwner == 1) { + fireelf = c2; + } else if (dragonOwner == 2) { + fireelf = c1; + } + + if (fireelf.getDamage() > dragon.getDamage()) { + //Fireelf ist stärker + if (dragonOwner == 1) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + } else if (dragonOwner == 2) { + d1.add(c2); + d2.remove(c2); + this.scorePlayer2 -= 5; + this.scorePlayer1 += 3; + } + log.add("Player "+dragonOwner+" gewinnt!\nWizzard ist stärker! Drache: " + dragon.getDamage() + " vs FireElves: " + fireelf.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } + //Sonst nix tun, weil der drache den elf ned angreifen kann + }else{ + if(c1.getDamage() > c2.getDamage()){ + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + " vs "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + }else if (c1.getDamage() < c2.getDamage()){ + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + " vs "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } + } + + //Checkt ob eine der beiden karten ein wizzard ist und der andere ein ork + } else if((c1.getCardType().name().toUpperCase().equals("WIZZARD") && c2.getCardType().name().toUpperCase().equals("ORK") || (c2.getCardType().name().toUpperCase().equals("WIZZARD") && c1.getCardType().name().toUpperCase().equals("ORK")))){ + System.out.println("Eine wizzard Andere ist ein ork"); + Card wizzard = null; + Card ork = null; + int wizzardOwner = 0; + if(c1.getCardType().name().toUpperCase().equals("WIZZARD")){ + wizzardOwner = 1; + wizzard = c1; + ork = c2; + }else if(c1.getCardType().name().toUpperCase().equals("WIZZARD")){ + wizzardOwner = 2; + wizzard = c2; + ork = c1; + } + if(wizzard.getDamage() > ork.getDamage()){ + if(wizzardOwner == 1){ + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + }else if (wizzardOwner == 2){ + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + } + + log.add("Player "+wizzardOwner+" gewinnt!\nWizzard ist stärker! Wizzard: " + wizzard.getDamage() + " vs Ork: " + ork.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } + //Sonst nix tun, weil der ork dem wizzard keinen schaden machen kann + }else{ + //PURE MONSTER + if(c1.getDamage() > c2.getDamage()){ + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + " vs "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + }else if (c1.getDamage() < c2.getDamage()){ + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + " vs "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } + //sonst nix weil bei gleichen damage --> draw + } + } else {//PURE SPELL & mixed + double damagePlayer1 = -1, damagePlayer2 = -1; + + if(c1.getCardType().name().toUpperCase().equals("KNIGHT") || c2.getCardType().name().toUpperCase().equals("KNIGHT")){ + //Mixed mit "Spezialeffekt" KNIGHT + System.out.println("Spell und knight"); + Card knight =null, other = null; + int knightOwner = 0; + if(c1.getCardType().name().toUpperCase().equals("KNIGHT")){ + knight = c1; + other = c2; + knightOwner = 1; + }else if(c2.getCardType().name().toUpperCase().equals("KNIGHT")){ + knight = c2; + other = c1; + knightOwner = 2; + } + double damageKnight = -1, damageOther = -1; + if (other.getElementTyp().name().toUpperCase().equals("WATER")){ + //tot + damageKnight = 0; + damageOther = other.getDamage(); + }else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("REGULAR")) { + //not effective + damageKnight = knight.getDamage() / 2; + //effective + damageOther = other.getDamage() *2; + } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("FIRE")) { + //no effect + damageKnight = knight.getDamage(); + //no effect + damageOther = other.getDamage(); + }else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("WATER")) { + //effective + damageKnight = knight.getDamage() * 2; + //not effective + damageOther = other.getDamage() / 2; + }else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("REGULAR")) { + //no effect + damageKnight = knight.getDamage(); + //no effect + damageOther = other.getDamage(); + } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("FIRE")) { + //effective + damageKnight = knight.getDamage() * 2; + //not effective + damageOther = other.getDamage() / 2; + }else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("WATER")) { + //not effective + damageKnight = knight.getDamage() / 2; + //effective + damageOther = other.getDamage() * 2; + } + if(damageKnight > damageOther){ + if(knightOwner == 1){ + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + damageKnight + " vs "+c2.getElementTyp()+c2.getCardType()+": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + }else if(knightOwner == 2){ + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + damageKnight + " vs "+c1.getElementTyp()+c1.getCardType()+": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } + }else if(damageKnight < damageOther){ + if(knightOwner == 2){ + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + damageOther + " vs "+c2.getElementTyp()+c2.getCardType()+": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + }else if(knightOwner == 1){ + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + damageOther + " vs "+c1.getElementTyp()+c1.getCardType()+": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } + } + }else if(c1.getCardType().name().toUpperCase().equals("KRAKEN") || c2.getCardType().name().toUpperCase().equals("KRAKEN")){ + //Mixed mit "Spezialeffekt" KRAKEN + if(c1.getCardType().name().toUpperCase().equals("KRAKEN")){ + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + " vs "+c2.getElementTyp()+c2.getCardType()+": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + }else if(c2.getCardType().name().toUpperCase().equals("KRAKEN")){ + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + " vs "+c1.getElementTyp()+c1.getCardType()+": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } + }else{ + ////PURE SPELL & mixed mit elementen + System.out.println("Spell und mixed mit elementen"); + //Player 1 Damage berechnen + if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { + if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //effective + damagePlayer1 = c1.getDamage() * 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { + //not effective + damagePlayer1 = c1.getDamage() / 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { + //no effect + damagePlayer1 = c1.getDamage(); + } + } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { + if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { + //effective + damagePlayer1 = c1.getDamage() * 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { + //no effect + damagePlayer1 = c1.getDamage(); + } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //not effective + damagePlayer1 = c1.getDamage() / 2; + } + } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { + if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { + //effective + damagePlayer1 = c1.getDamage() * 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { + //not effective + damagePlayer1 = c1.getDamage() / 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //no effect + damagePlayer1 = c1.getDamage(); + } + } + //P2 damage + if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { + if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //effective + damagePlayer2 = c2.getDamage() * 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { + //not effective + damagePlayer2 = c2.getDamage() / 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { + //no effect + damagePlayer2 = c2.getDamage(); + } + } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { + if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { + //effective + damagePlayer2 = c2.getDamage() * 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { + //no effect + damagePlayer2 = c2.getDamage(); + } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //not effective + damagePlayer2 = c2.getDamage() / 2; + } + } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { + if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { + //effective + damagePlayer2 = c2.getDamage() * 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { + //not effective + damagePlayer2 = c2.getDamage() / 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //no effect + damagePlayer2 = c2.getDamage(); + } + } + + if (damagePlayer1 > -1 && damagePlayer2 > -1) { + if (damagePlayer1 > damagePlayer2) { + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + damagePlayer1 + " vs "+c2.getElementTyp()+c2.getCardType()+": " + damagePlayer2 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } else if (damagePlayer2 > damagePlayer1) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + damagePlayer2 + " vs "+c1.getElementTyp()+c1.getCardType()+": " + damagePlayer1 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + } + } else { + System.out.println("Damage konnte nicht berechnet werden"); + return false; + } + } + } + } + this.deckPlayer1 = new Cards(d1); + this.deckPlayer2 = new Cards(d2); + }else{ + System.out.println("Einer der Spieler hat zu wenige Karten im Deck"); + return false; + } + return true; + } + + /** + * Vergleicht 2 Card Typen von 2 Karten + * @param c1 Card 1 + * @param c2 Card 2 + * @return True wenn die CardType übereinstimmt, sonst false + */ + private boolean sameCardType(Card c1, Card c2){ + if(c1.getCardType().name().equals(c2.getCardType().name())){ + return true; + } + return false; + } + + public ArrayList getLog() { + return log; + } + + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public User getPlayer1() { + return player1; + } + + public void setPlayer1(User player1) { + this.player1 = player1; + } + + public User getPlayer2() { + return player2; + } + + public void setPlayer2(User player2) { + this.player2 = player2; + } + + public int getScorePlayer1() { + return scorePlayer1; + } + + public void setScorePlayer1(int scorePlayer1) { + this.scorePlayer1 = scorePlayer1; + + } + + public int getScorePlayer2() { + return scorePlayer2; + } + + public void setScorePlayer2(int scorePlayer2) { + this.scorePlayer2 = scorePlayer2; + } + + public Cards getDeckPlayer1() { + return deckPlayer1; + } + + public void setDeckPlayer1(Cards deckPlayer1) { + this.deckPlayer1 = deckPlayer1; + this.deckPlayer1Init = deckPlayer1; + } + + public Cards getDeckPlayer2() { + return deckPlayer2; + } + + public void setDeckPlayer2(Cards deckPlayer2) { + this.deckPlayer2 = deckPlayer2; + this.deckPlayer2Init = deckPlayer2; + } + + public Card getSpielfeldCardPlayer1() { + return spielfeldCardPlayer1; + } + + public void setSpielfeldCardPlayer1(Card spielfeldCardPlayer1) { + this.spielfeldCardPlayer1 = spielfeldCardPlayer1; + } + + public Card getSpielfeldCardPlayer2() { + return spielfeldCardPlayer2; + } + + public void setSpielfeldCardPlayer2(Card spielfeldCardPlayer2) { + this.spielfeldCardPlayer2 = spielfeldCardPlayer2; + } + + public Cards getDeckPlayer1Init() { + return deckPlayer1Init; + } + + public Cards getDeckPlayer2Init() { + return deckPlayer2Init; + } } diff --git a/src/main/java/at/reisinger/Card.java b/src/main/java/at/reisinger/Card.java index 7c00cb6..51f7ed2 100644 --- a/src/main/java/at/reisinger/Card.java +++ b/src/main/java/at/reisinger/Card.java @@ -42,20 +42,56 @@ public class Card { */ @JsonCreator public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){ - ElementTyp tmpElement = EnumHelper.stringToElementType(elementCardTyp); - if(tmpElement == null){ - tmpElement = ElementTyp.UNDEF; - } CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp); + ElementTyp tmpElement = null; if(tmpCard == null){ tmpCard = CardType.UNDEF; } + + //Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen + if (tmpCard.name().toLowerCase().equals("dragon")){ + tmpElement = ElementTyp.FIRE; + }else if (tmpCard.name().toLowerCase().equals("ork")){ + tmpElement = ElementTyp.REGULAR; + } + else if (tmpCard.name().toLowerCase().equals("wizzard")){ + tmpElement = ElementTyp.REGULAR; + }else if (tmpCard.name().toLowerCase().equals("kraken")){ + tmpElement = ElementTyp.WATER; + }else if (tmpCard.name().toLowerCase().equals("elf")){ + tmpElement = ElementTyp.REGULAR; + }else if (tmpCard.name().toLowerCase().equals("goblin")){ + tmpElement = ElementTyp.REGULAR; + }else if (tmpCard.name().toLowerCase().equals("troll")){ + tmpElement = ElementTyp.REGULAR; + }else if (tmpCard.name().toLowerCase().equals("knight")){ + tmpElement = ElementTyp.REGULAR; + }else if (tmpCard.name().toLowerCase().equals("fireelves")){ + tmpElement = ElementTyp.FIRE; + } + + if(tmpElement == null){ + tmpElement = EnumHelper.stringToElementType(elementCardTyp); + //Deutsch übersetzung + if (tmpElement.name().toLowerCase().equals("feuer")){ + tmpElement = ElementTyp.FIRE; + }else if (tmpElement.name().toLowerCase().equals("wasser")){ + tmpElement = ElementTyp.WATER; + }else if (tmpElement.name().toLowerCase().equals("normal")){ + tmpElement = ElementTyp.REGULAR; + } + if(tmpElement == null) { + tmpElement = ElementTyp.UNDEF; + } + } this.name = name; this.damage = damage; this.elementTyp = tmpElement; this.cardType = tmpCard; } + + /** * Prüft ob die Karte gesperrt ist * @return True wenn die Karte gesperrt ist diff --git a/src/main/java/at/reisinger/Cards.java b/src/main/java/at/reisinger/Cards.java index 9b6fdbb..6227150 100644 --- a/src/main/java/at/reisinger/Cards.java +++ b/src/main/java/at/reisinger/Cards.java @@ -23,7 +23,13 @@ public class Cards { this.cards = cardsArrayList; } - + /** + * Setzt die Carten + * @param cards Cards in einer ArrayList die gesetzt werden sollen + */ + public void setCards(ArrayList cards) { + this.cards = cards; + } /** * Fügt eine neue at.reisinger.Card hinzu diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/DBConnection.java index 0a86e90..ef45c41 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/DBConnection.java @@ -1,11 +1,13 @@ package at.reisinger; +import at.reisinger.server.helper.JsonHelper; import at.reisinger.server.helper.PostgresHelper; import java.sql.*; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import java.util.Map; /** * Stellt die Verbindung zur "Datenbank" her @@ -37,6 +39,186 @@ public class DBConnection { PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_cards(username TEXT not null constraint user_cards_users_username_fk references users,name text not null, gesperrt boolean not null);", "UserCards Table created"); PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS user_deck(username text not null constraint user_deck_users_username_fk references users,cardname text not null);", "UserDeck Table created"); PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS trading(username text not null constraint trading_users_username_fk references users,id text not null constraint trading_pk primary key, cardtotrade text not null constraint trading_card_name_fk references card, mindamage float not null,reqcardtype text not null,reqelement text not null);", "Trading Table created"); + PostgresHelper.executeUpdate("create table if not exists battle(usernamecreator text not null constraint battle_users_username_fk references users,usernameplayer text constraint battle_users_username_fk_2 references users, battleid serial, deckcreator text not null);"); + PostgresHelper.executeUpdateMessage("create unique index if not exists battle_battleid_uindex on battle (battleid);", "Battle Table created"); + PostgresHelper.executeUpdate("create table IF NOT EXISTS battle_log(id int not null constraint battle_log_pk primary key, playerone text not null,playertwo text not null,playeronescore text not null,playertwoscore text not null);"); + PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS battle_log_id_uindex on battle_log (id);", "Battle_lgo Table created"); + } + + /** + * Fügt der Battle tabelle ein battle hinzu + * @return True bei erfolg, sonst false + */ + public boolean addBattle(String usernamecreator){ + ArrayList decknamen = getDeck(usernamecreator); + if(decknamen != null && !decknamen.isEmpty()){ + Cards deck = getCardsFromIDList(decknamen); + if(deck != null && !deck.getCards().isEmpty()){ + String deckJson = JsonHelper.objToJson(deck.getCards()); + if (deckJson != null && !deckJson.isEmpty()){ + System.out.println("insert into battle (usernamecreator, deckcreator) VALUES (\'"+ usernamecreator + "\',\'" + deckJson +"\');"); + return PostgresHelper.executeUpdateMessage("insert into battle (usernamecreator, deckcreator) VALUES (\'"+ usernamecreator + "\',\'" + deckJson +"\');", "Battle created"); + }else { + return false; + } + }else { + return false; + } + }else{ + return false; + } + } + + /** + * Sucht ein verfügbares open battle aus der DB und löscht gleichzeitig das open battle + * @return Null falls keines verfügbar ist oder ein erir auftritt + */ + public Battle getOpenBattle(){ + this.c = PostgresHelper.con(); + ArrayList tradingDeals = new ArrayList(); + int battleid = 0; + String usernamecreator = "", deckcreator = ""; + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select * from battle limit 1;"); + while (rs.next()) { + battleid = rs.getInt("battleid"); + usernamecreator = rs.getString("usernamecreator"); + deckcreator = rs.getString("deckcreator"); + User player1 = new DBConnection().getUser(usernamecreator); + if(player1 != null){ + ArrayList deckPlayer1Arr = new DBConnection().getDeck(usernamecreator); + if (deckPlayer1Arr != null){ + Cards deckPlayer1 = new DBConnection().getCardsFromIDList(deckPlayer1Arr); + if(deckPlayer1 != null){ + if(delBattleEinladung(battleid+"")){ + return new Battle(battleid, player1, deckPlayer1); + }else{ + return null; + } + }else{ + return null; + } + }else { + return null; + } + }else{ + return null; + } + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (SQLException throwables) { + throwables.printStackTrace(); + return null; + } + return null; + } + + /** + * Löscht die Battle einladung eines einzelnen spielers + * @param battleid Id die zu löschen ist + * @return true bei erfolg sonst false + */ + public boolean delBattleEinladung(String battleid){ + return PostgresHelper.executeUpdateMessage("delete from battle where battleid = \'"+ battleid +"\';", "Battle req deleted"); + } + + + /** + * Nach einem Battle wird das log eingefügt, dabei wird die selbe id wie beim battle verwendet + * @param id Id des Battles + * @param playerone Name vom Player 1 + * @param playertwo Name vom Player 2 + * @param playeronescore Score vom Player 1 + * @param playertwoscore Score vom Player 2 + * @return true bei erfolg sonst false + */ + public boolean addBattleLog(String id, String playerone, String playertwo, String playeronescore, String playertwoscore){ + return PostgresHelper.executeUpdate("insert into battle_log (id, playerone, playertwo, playeronescore, playertwoscore) VALUES ("+id+",\'"+playerone+"\',\'"+playertwo+"\',\'"+playeronescore+"\',\'"+playertwoscore+"\');"); + } + + /** + * Holt alle logs von allen battles + * @return Jedes Battle ist in einer Map mit namen von player1 und player2, player1Score und player2Score diese Map ist in einer ArrayList + */ + public ArrayList> getAllBattleLogs(){ + this.c = PostgresHelper.con(); + String player1Str, player2Str, scorePlayer1, scorePlayer2; + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select * from battle_log;"); + ArrayList> output = new ArrayList>(); + while (rs.next()) { + Map map = Collections.emptyMap(); + player1Str = rs.getString("playerone"); + player2Str = rs.getString("playertwo"); + scorePlayer1 = rs.getString("playeronescore"); + scorePlayer2 = rs.getString("playertwoscore"); + + User player1 = new DBConnection().getUser(player1Str); + User player2 = new DBConnection().getUser(player2Str); + + if(player1 != null && player2 != null){ + map.put("player1", player1); + map.put("player2", player2); + map.put("playeronescore", scorePlayer1); + map.put("playertwoscore", scorePlayer2); + output.add(map); + }else{ + return null; + } + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (SQLException throwables) { + throwables.printStackTrace(); + return null; + } + return null; + } + + /** + * Holt das Battellog eines Bestimmten Battles + * @param battleid Id des battles + * @return Eine Map mit namen von player1 und player2, player1Score und player2Score + */ + public Map getBattleLog(String battleid){ + this.c = PostgresHelper.con(); + String player1Str, player2Str, scorePlayer1, scorePlayer2; + Map map = Collections.emptyMap(); + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select * from battle_log where id = \'" + battleid + "\';"); + while (rs.next()) { + player1Str = rs.getString("playerone"); + player2Str = rs.getString("playertwo"); + scorePlayer1 = rs.getString("playeronescore"); + scorePlayer2 = rs.getString("playertwoscore"); + + User player1 = new DBConnection().getUser(player1Str); + User player2 = new DBConnection().getUser(player2Str); + + if(player1 != null && player2 != null){ + map.put("player1", player1); + map.put("player2", player2); + map.put("playeronescore", scorePlayer1); + map.put("playertwoscore", scorePlayer2); + return map; + }else{ + return null; + } + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (SQLException throwables) { + throwables.printStackTrace(); + return null; + } + return null; } /** diff --git a/src/main/java/at/reisinger/ElementTyp.java b/src/main/java/at/reisinger/ElementTyp.java index df30a72..9b10243 100644 --- a/src/main/java/at/reisinger/ElementTyp.java +++ b/src/main/java/at/reisinger/ElementTyp.java @@ -1,5 +1,5 @@ package at.reisinger; public enum ElementTyp { - WATER, FIRE, NORMAL, UNDEF, REGULAR, GOBLIN, TROLL, ELF, KNIGHT, DRAGON, WIZZARD, ORK, KRAKEN, FIREELVES + WATER, FIRE, NORMAL, UNDEF, REGULAR, FEUER, WASSER } diff --git a/src/main/java/at/reisinger/server/Main.java b/src/main/java/at/reisinger/server/Main.java index 2300a09..b581fb8 100644 --- a/src/main/java/at/reisinger/server/Main.java +++ b/src/main/java/at/reisinger/server/Main.java @@ -56,7 +56,9 @@ public class Main { try{ System.out.println("Socket von Client #" + this.id + " wurde gestartet!"); Request rq = new Request(this.socket, this.id); - Response rp = new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload()); + System.out.println("req done"); + new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload()); + System.out.println("res done"); //this.msgHandler = rp.getMsghandler(); this.socket.close(); System.out.println("Socket von Client #" + this.id + " wurde geschlossen!"); diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 90b755e..4e010de 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -271,13 +271,13 @@ public class Response { sendError("401"); } }else if (this.url.startsWith("/tradings")) { - if(login()){ + if(login()) { String dotradeid = this.url.substring(this.url.lastIndexOf('/') + 1); System.out.println("DO TradeID in /tradings/{tradeID}: " + dotradeid); - if(!dotradeid.isEmpty() && dotradeid != null && !dotradeid.equals("tradings")){ + if (!dotradeid.isEmpty() && dotradeid != null && !dotradeid.equals("tradings")) { //DO TRADE String username = basicAuthGetUsername(this.authString); - if(username != null && !username.isEmpty()) { + if (username != null && !username.isEmpty()) { System.out.println(this.payload); ArrayList tradingDealArrayList = new DBConnection().getAllTradingDeals(); TradingDeal tradingDeal = null; @@ -293,25 +293,25 @@ public class Response { if (tradingDeal.cardOk(card)) { String json = JsonHelper.objToJson(card); if (json != null && !json.isEmpty()) { - if (new DBConnection().addUserCard(username, tradingDeal.getCardToTrade().getName())){ - if (new DBConnection().delUserCard(tradingDeal.getUsername(), tradingDeal.getCardToTrade().getName())){ - if(new DBConnection().deleteTradingDeal(tradingDeal.getId())){ - if (new DBConnection().delUserCard(username, card.getName())){ - if(new DBConnection().addUserCard(tradingDeal.getUsername(), card.getName())){ + if (new DBConnection().addUserCard(username, tradingDeal.getCardToTrade().getName())) { + if (new DBConnection().delUserCard(tradingDeal.getUsername(), tradingDeal.getCardToTrade().getName())) { + if (new DBConnection().deleteTradingDeal(tradingDeal.getId())) { + if (new DBConnection().delUserCard(username, card.getName())) { + if (new DBConnection().addUserCard(tradingDeal.getUsername(), card.getName())) { sendResponse(json, "200"); - }else { + } else { sendError("500"); } - }else { + } else { sendError("500"); } - }else{ + } else { sendError("500"); } - }else{ + } else { sendError("500"); } - }else{ + } else { sendError("500"); } } else { @@ -329,10 +329,10 @@ public class Response { } else { sendError("500"); } - }else{ + } else { sendError("401"); } - }else { + } else { //CREATE TRADING DEAL Map map = JsonHelper.jsonPayloadToMap(this.payload); String id = (String) map.get("Id"); @@ -379,10 +379,120 @@ public class Response { sendError("500"); } } - }else{ + } + }else if (this.url.startsWith("/battle")) { + if(login()){ + String username = basicAuthGetUsername(this.authString); + if (username != null && !username.isEmpty()) { + List deckNamen = new DBConnection().getDeck(username); + if (deckNamen != null && !deckNamen.isEmpty()) { + Cards deck = new DBConnection().getCardsFromIDList(deckNamen); + if(deck != null && deck.getCards().size() == 4) { + Battle openBattle = new DBConnection().getOpenBattle(); + if (openBattle == null) { + //Creator player Mode + if(new DBConnection().addBattle(username)){ + sendResponse("Du bist: #PLAYER 1\nBattle Einladung wurde erstellt von: " + username + "(#PLAYER1) \nSobald ein 2. Spieler dem Battle beitritt, kann das ergebnis mit /score abgefragt werden.","200"); + }else { + sendError("500"); + } + + } else { + //Join game player + try { + User player2 = new DBConnection().getUser(username); + if(player2 != null){ + openBattle.setPlayer2(player2); + openBattle.setDeckPlayer2(deck); + if(new DBConnection().delBattleEinladung(openBattle.getId() + "")){ + openBattle.doFight(); + System.out.println(JsonHelper.objToJson(openBattle.getLog())); + if(new DBConnection().addBattleLog(openBattle.getId()+"", openBattle.getPlayer1().getName(), openBattle.getPlayer2().getName(), openBattle.getScorePlayer1()+"", openBattle.getScorePlayer2() +"")){ + if(new DBConnection().delDeck(openBattle.getPlayer1().getCredentials().getUsername()) && new DBConnection().delDeck(openBattle.getPlayer2().getCredentials().getUsername())) { + //DEL OLD DECK CARDS + for (Card ca: openBattle.getDeckPlayer1Init().getCards()){ + if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){ + sendResponse("Error Deleting user card1: " + ca.getName(), "500"); + } + } + for (Card ca: openBattle.getDeckPlayer2Init().getCards()){ + if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){ + sendResponse("Error Deleting user card2: " + ca.getName(), "500"); + } + } + //DEL NEW CARDS IF EXIST + Cards player1cards = new DBConnection().getCards(openBattle.getPlayer1().getCredentials().getUsername()); + ArrayList player1CardsList = new ArrayList(); + for(Card ca:player1cards.getCards()){ + player1CardsList.add(ca.getName()); + } + if(player1cards.getCards() != null && !player1cards.getCards().isEmpty()) { + for (Card ca : openBattle.getDeckPlayer1().getCards()) { + if (player1CardsList.contains(ca.getName())){ + if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){ + sendResponse("Error Deleting user card1: " + ca.getName(), "500"); + } + } + } + } + Cards player2cards = new DBConnection().getCards(openBattle.getPlayer2().getCredentials().getUsername()); + ArrayList player2CardsList = new ArrayList(); + for(Card ca:player2cards.getCards()){ + player2CardsList.add(ca.getName()); + } + if(player2cards.getCards() != null && !player2cards.getCards().isEmpty()) { + for (Card ca : openBattle.getDeckPlayer2().getCards()) { + if (player2CardsList.contains(ca.getName())){ + if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){ + sendResponse("Error Deleting user card2: " + ca.getName(), "500"); + } + } + } + } + + //ADD CARDS TO DECK + for(Card ca : openBattle.getDeckPlayer1().getCards()){ + if(!new DBConnection().addUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){ + sendResponse("Error adding card to user1: " + ca.getName(), "500"); + } + } + for(Card ca : openBattle.getDeckPlayer2().getCards()){ + if(!new DBConnection().addUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){ + sendResponse("Error adding card to user2: " + ca.getName(), "500"); + } + } + sendResponse("Du bist: #PLAYER 2\nBattle --> " + openBattle.getPlayer1().getName() + "(#PLAYER1) |vs| " + openBattle.getPlayer2().getName() + "(#PLAYER2)\nErgebnisse unter /score abrufbar", "200"); + } + }else{ + sendResponse("Battle Log konnte ned geschrieben werden", "500"); //ERROR + } + }else{ + sendResponse("Battle einladung konnte ned akzeptiert werden", "500"); //ERROR + } + }else{ + sendResponse("GET User error", "500"); //ERROR + } + } catch (SQLException throwables) { + throwables.printStackTrace(); + sendResponse("GET User error", "500"); //ERROR + } + } + }else { + sendResponse("Nur "+deck.getCards().size()+" von 4 Karten im Deck. \nMach zuerst POST /deck [ID, ID, ID, ID] um dein Deck korrekt zu befüllen","424"); + } + }else { + sendResponse("Deck ist nicht gesetzt","424"); + } + }else { + sendError("500"); + } + }else { sendError("401"); } + } else{ + sendError("405"); } + } /** @@ -393,18 +503,18 @@ public class Response { if(this.authString != null && !this.authString.isEmpty()){ String username = basicAuthGetUsername(this.authString); User user = null; - DBConnection con = new DBConnection(); try { - user = con.getUser(username); + user = new DBConnection().getUser(username); + if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){ + return true; + }else{ + return false; + } } catch (SQLException throwables) { throwables.printStackTrace(); return false; } - if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){ - return true; - }else{ - return false; - } + }else{ return false; } From 93cbd8aae28f49057426e75d0a70753079ab663f Mon Sep 17 00:00:00 2001 From: Georg Reisinger Date: Thu, 31 Dec 2020 04:26:32 +0100 Subject: [PATCH 19/20] Battle Bugfixes --- src/main/java/at/reisinger/Battle.java | 608 +++++++++--------- .../at/reisinger/server/objects/Response.java | 36 +- 2 files changed, 322 insertions(+), 322 deletions(-) diff --git a/src/main/java/at/reisinger/Battle.java b/src/main/java/at/reisinger/Battle.java index b34eb3b..8a93c6d 100644 --- a/src/main/java/at/reisinger/Battle.java +++ b/src/main/java/at/reisinger/Battle.java @@ -73,338 +73,346 @@ public class Battle { deckPlayer1.setCards(d2); //Runden - int maxroundcount = 100; - for(int i = 0; d1.size()>i && d2.size()>i && i 0 && d2.size() > 0 && counter<=maxroundcount) { + //GLEICHER TYP Monster + if (!c1.getCardType().name().toUpperCase().equals("SPELL") && !c2.getCardType().name().toUpperCase().equals("SPELL")) { + System.out.println("Same Monster"); + //Check ob eine der beiden Carten ein Dragon ist + if ((c1.getCardType().name().toUpperCase().equals("DRANGON") && !c2.getCardType().name().toUpperCase().equals("DRANGON") || (!c1.getCardType().name().toUpperCase().equals("DRANGON") && c2.getCardType().name().toUpperCase().equals("DRANGON")))) { + //Eine der Karten is Dragon + System.out.println("Eine ist ein dragon"); + Card dragon = null; + int dragonOwner = 0; + if (c1.getCardType().name().toUpperCase().equals("DRAGON")) { + dragon = c1; + dragonOwner = 1; + } else if (c2.getCardType().name().toUpperCase().equals("DRAGON")) { + dragon = c2; + dragonOwner = 2; } else { - System.out.println("KEIN GOBLIN GEFUNDEN"); + System.out.println("KEIN DRAGON GEFUNDEN"); return false; } - if (dragon.getDamage() > goblin.getDamage()) { - //Drache ist stärker + if ((c1.getCardType().name().toUpperCase().equals("GOBLIN") && !c2.getCardType().name().toUpperCase().equals("GOBLIN") || (!c1.getCardType().name().toUpperCase().equals("GOBLIN") && c2.getCardType().name().toUpperCase().equals("GOBLIN")))) { + //Eine der Karten ist Goblin + System.out.println("Andere ist ein goblin"); + Card goblin = null; + if (c1.getCardType().name().toUpperCase().equals("GOBLIN")) { + goblin = c1; + } else if (c2.getCardType().name().toUpperCase().equals("GOBLIN")) { + goblin = c2; + } else { + System.out.println("KEIN GOBLIN GEFUNDEN"); + return false; + } + if (dragon.getDamage() > goblin.getDamage()) { + //Drache ist stärker + if (dragonOwner == 1) { + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + } else if (dragonOwner == 2) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer1 -= 5; + this.scorePlayer2 += 3; + } + log.add("Player " + dragonOwner + " gewinnt!\nDrache ist stärker! Drache: " + dragon.getDamage() + " vs Goblin: " + goblin.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } else { + System.out.println("DRAW: Drache zu schwach um anzugreifen und GOBLIN zu feige."); + } + } else if ((c1.getCardType().name().toUpperCase().equals("ELF") && c1.getElementTyp().name().toUpperCase().equals("FIRE") && !c2.getCardType().name().toUpperCase().equals("ELF") || (!c1.getCardType().name().toUpperCase().equals("ELF") && c2.getElementTyp().name().toUpperCase().equals("FIRE") && c2.getCardType().name().toUpperCase().equals("ELF")))) { + //Eine der Karten ist der Fire Elf die andere Karte ist der drache + System.out.println("Andere ist ein elf"); + Card fireelf = null; if (dragonOwner == 1) { + fireelf = c2; + } else if (dragonOwner == 2) { + fireelf = c1; + } + + if (fireelf.getDamage() > dragon.getDamage()) { + //Fireelf ist stärker + if (dragonOwner == 1) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + } else if (dragonOwner == 2) { + d1.add(c2); + d2.remove(c2); + this.scorePlayer2 -= 5; + this.scorePlayer1 += 3; + } + log.add("Player " + dragonOwner + " gewinnt!\nWizzard ist stärker! Drache: " + dragon.getDamage() + " vs FireElves: " + fireelf.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } + //Sonst nix tun, weil der drache den elf ned angreifen kann + } else { + if (c1.getDamage() > c2.getDamage()) { d1.add(c2); d2.remove(c2); - this.scorePlayer1 += 3; - this.scorePlayer2 -= 5; - } else if (dragonOwner == 2) { + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } else if (c1.getDamage() < c2.getDamage()) { d2.add(c1); d1.remove(c1); - this.scorePlayer1 -= 5; - this.scorePlayer2 += 3; + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); } - log.add("Player "+dragonOwner+" gewinnt!\nDrache ist stärker! Drache: " + dragon.getDamage() + " vs Goblin: " + goblin.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - } else { - System.out.println("DRAW: Drache zu schwach um anzugreifen und GOBLIN zu feige."); - } - } else if ((c1.getCardType().name().toUpperCase().equals("ELF") && c1.getElementTyp().name().toUpperCase().equals("FIRE") && !c2.getCardType().name().toUpperCase().equals("ELF") || (!c1.getCardType().name().toUpperCase().equals("ELF") && c2.getElementTyp().name().toUpperCase().equals("FIRE") && c2.getCardType().name().toUpperCase().equals("ELF")))) { - //Eine der Karten ist der Fire Elf die andere Karte ist der drache - System.out.println("Andere ist ein elf"); - Card fireelf = null; - if (dragonOwner == 1) { - fireelf = c2; - } else if (dragonOwner == 2) { - fireelf = c1; } - if (fireelf.getDamage() > dragon.getDamage()) { - //Fireelf ist stärker - if (dragonOwner == 1) { - d2.add(c1); - d1.remove(c1); - this.scorePlayer2 += 3; - this.scorePlayer1 -= 5; - } else if (dragonOwner == 2) { + //Checkt ob eine der beiden karten ein wizzard ist und der andere ein ork + } else if ((c1.getCardType().name().toUpperCase().equals("WIZZARD") && c2.getCardType().name().toUpperCase().equals("ORK") || (c2.getCardType().name().toUpperCase().equals("WIZZARD") && c1.getCardType().name().toUpperCase().equals("ORK")))) { + System.out.println("Eine wizzard Andere ist ein ork"); + Card wizzard = null; + Card ork = null; + int wizzardOwner = 0; + if (c1.getCardType().name().toUpperCase().equals("WIZZARD")) { + wizzardOwner = 1; + wizzard = c1; + ork = c2; + } else if (c1.getCardType().name().toUpperCase().equals("WIZZARD")) { + wizzardOwner = 2; + wizzard = c2; + ork = c1; + } + if (wizzard.getDamage() > ork.getDamage()) { + if (wizzardOwner == 1) { d1.add(c2); d2.remove(c2); - this.scorePlayer2 -= 5; - this.scorePlayer1 += 3; + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + } else if (wizzardOwner == 2) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; } - log.add("Player "+dragonOwner+" gewinnt!\nWizzard ist stärker! Drache: " + dragon.getDamage() + " vs FireElves: " + fireelf.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + + log.add("Player " + wizzardOwner + " gewinnt!\nWizzard ist stärker! Wizzard: " + wizzard.getDamage() + " vs Ork: " + ork.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); } - //Sonst nix tun, weil der drache den elf ned angreifen kann - }else{ - if(c1.getDamage() > c2.getDamage()){ + //Sonst nix tun, weil der ork dem wizzard keinen schaden machen kann + } else { + //PURE MONSTER + if (c1.getDamage() > c2.getDamage()) { d1.add(c2); d2.remove(c2); this.scorePlayer1 += 3; this.scorePlayer2 -= 5; - log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + " vs "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - }else if (c1.getDamage() < c2.getDamage()){ + log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } else if (c1.getDamage() < c2.getDamage()) { d2.add(c1); d1.remove(c1); this.scorePlayer2 += 3; this.scorePlayer1 -= 5; - log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + " vs "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); } + //sonst nix weil bei gleichen damage --> draw } + } else {//PURE SPELL & mixed + double damagePlayer1 = -1, damagePlayer2 = -1; - //Checkt ob eine der beiden karten ein wizzard ist und der andere ein ork - } else if((c1.getCardType().name().toUpperCase().equals("WIZZARD") && c2.getCardType().name().toUpperCase().equals("ORK") || (c2.getCardType().name().toUpperCase().equals("WIZZARD") && c1.getCardType().name().toUpperCase().equals("ORK")))){ - System.out.println("Eine wizzard Andere ist ein ork"); - Card wizzard = null; - Card ork = null; - int wizzardOwner = 0; - if(c1.getCardType().name().toUpperCase().equals("WIZZARD")){ - wizzardOwner = 1; - wizzard = c1; - ork = c2; - }else if(c1.getCardType().name().toUpperCase().equals("WIZZARD")){ - wizzardOwner = 2; - wizzard = c2; - ork = c1; - } - if(wizzard.getDamage() > ork.getDamage()){ - if(wizzardOwner == 1){ + if (c1.getCardType().name().toUpperCase().equals("KNIGHT") || c2.getCardType().name().toUpperCase().equals("KNIGHT")) { + //Mixed mit "Spezialeffekt" KNIGHT + System.out.println("Spell und knight"); + Card knight = null, other = null; + int knightOwner = 0; + if (c1.getCardType().name().toUpperCase().equals("KNIGHT")) { + knight = c1; + other = c2; + knightOwner = 1; + } else if (c2.getCardType().name().toUpperCase().equals("KNIGHT")) { + knight = c2; + other = c1; + knightOwner = 2; + } + double damageKnight = -1, damageOther = -1; + if (other.getElementTyp().name().toUpperCase().equals("WATER")) { + //tot + damageKnight = 0; + damageOther = other.getDamage(); + } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("REGULAR")) { + //not effective + damageKnight = knight.getDamage() / 2; + //effective + damageOther = other.getDamage() * 2; + } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("FIRE")) { + //no effect + damageKnight = knight.getDamage(); + //no effect + damageOther = other.getDamage(); + } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("WATER")) { + //effective + damageKnight = knight.getDamage() * 2; + //not effective + damageOther = other.getDamage() / 2; + } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("REGULAR")) { + //no effect + damageKnight = knight.getDamage(); + //no effect + damageOther = other.getDamage(); + } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("FIRE")) { + //effective + damageKnight = knight.getDamage() * 2; + //not effective + damageOther = other.getDamage() / 2; + } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("WATER")) { + //not effective + damageKnight = knight.getDamage() / 2; + //effective + damageOther = other.getDamage() * 2; + } + if (damageKnight > damageOther) { + if (knightOwner == 1) { + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damageKnight + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } else if (knightOwner == 2) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damageKnight + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } + } else if (damageKnight < damageOther) { + if (knightOwner == 2) { + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damageOther + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } else if (knightOwner == 1) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damageOther + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } + } + } else if (c1.getCardType().name().toUpperCase().equals("KRAKEN") || c2.getCardType().name().toUpperCase().equals("KRAKEN")) { + //Mixed mit "Spezialeffekt" KRAKEN + if (c1.getCardType().name().toUpperCase().equals("KRAKEN")) { d1.add(c2); d2.remove(c2); - this.scorePlayer1 += 3; - this.scorePlayer2 -= 5; - }else if (wizzardOwner == 2){ + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } else if (c2.getCardType().name().toUpperCase().equals("KRAKEN")) { d2.add(c1); d1.remove(c1); - this.scorePlayer2 += 3; - this.scorePlayer1 -= 5; - } - - log.add("Player "+wizzardOwner+" gewinnt!\nWizzard ist stärker! Wizzard: " + wizzard.getDamage() + " vs Ork: " + ork.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - } - //Sonst nix tun, weil der ork dem wizzard keinen schaden machen kann - }else{ - //PURE MONSTER - if(c1.getDamage() > c2.getDamage()){ - d1.add(c2); - d2.remove(c2); - this.scorePlayer1 += 3; - this.scorePlayer2 -= 5; - log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + " vs "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - }else if (c1.getDamage() < c2.getDamage()){ - d2.add(c1); - d1.remove(c1); - this.scorePlayer2 += 3; - this.scorePlayer1 -= 5; - log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + " vs "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - } - //sonst nix weil bei gleichen damage --> draw - } - } else {//PURE SPELL & mixed - double damagePlayer1 = -1, damagePlayer2 = -1; - - if(c1.getCardType().name().toUpperCase().equals("KNIGHT") || c2.getCardType().name().toUpperCase().equals("KNIGHT")){ - //Mixed mit "Spezialeffekt" KNIGHT - System.out.println("Spell und knight"); - Card knight =null, other = null; - int knightOwner = 0; - if(c1.getCardType().name().toUpperCase().equals("KNIGHT")){ - knight = c1; - other = c2; - knightOwner = 1; - }else if(c2.getCardType().name().toUpperCase().equals("KNIGHT")){ - knight = c2; - other = c1; - knightOwner = 2; - } - double damageKnight = -1, damageOther = -1; - if (other.getElementTyp().name().toUpperCase().equals("WATER")){ - //tot - damageKnight = 0; - damageOther = other.getDamage(); - }else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("REGULAR")) { - //not effective - damageKnight = knight.getDamage() / 2; - //effective - damageOther = other.getDamage() *2; - } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("FIRE")) { - //no effect - damageKnight = knight.getDamage(); - //no effect - damageOther = other.getDamage(); - }else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("WATER")) { - //effective - damageKnight = knight.getDamage() * 2; - //not effective - damageOther = other.getDamage() / 2; - }else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("REGULAR")) { - //no effect - damageKnight = knight.getDamage(); - //no effect - damageOther = other.getDamage(); - } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("FIRE")) { - //effective - damageKnight = knight.getDamage() * 2; - //not effective - damageOther = other.getDamage() / 2; - }else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("WATER")) { - //not effective - damageKnight = knight.getDamage() / 2; - //effective - damageOther = other.getDamage() * 2; - } - if(damageKnight > damageOther){ - if(knightOwner == 1){ - d1.add(c2); - d2.remove(c2); - this.scorePlayer1 += 3; - this.scorePlayer2 -= 5; - log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + damageKnight + " vs "+c2.getElementTyp()+c2.getCardType()+": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - }else if(knightOwner == 2){ - d2.add(c1); - d1.remove(c1); - this.scorePlayer2 += 3; - this.scorePlayer1 -= 5; - log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + damageKnight + " vs "+c1.getElementTyp()+c1.getCardType()+": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - } - }else if(damageKnight < damageOther){ - if(knightOwner == 2){ - d1.add(c2); - d2.remove(c2); - this.scorePlayer1 += 3; - this.scorePlayer2 -= 5; - log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + damageOther + " vs "+c2.getElementTyp()+c2.getCardType()+": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - }else if(knightOwner == 1){ - d2.add(c1); - d1.remove(c1); - this.scorePlayer2 += 3; - this.scorePlayer1 -= 5; - log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + damageOther + " vs "+c1.getElementTyp()+c1.getCardType()+": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - } - } - }else if(c1.getCardType().name().toUpperCase().equals("KRAKEN") || c2.getCardType().name().toUpperCase().equals("KRAKEN")){ - //Mixed mit "Spezialeffekt" KRAKEN - if(c1.getCardType().name().toUpperCase().equals("KRAKEN")){ - d1.add(c2); - d2.remove(c2); - this.scorePlayer1 += 3; - this.scorePlayer2 -= 5; - log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + c1.getDamage() + " vs "+c2.getElementTyp()+c2.getCardType()+": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - }else if(c2.getCardType().name().toUpperCase().equals("KRAKEN")){ - d2.add(c1); - d1.remove(c1); - this.scorePlayer2 += 3; - this.scorePlayer1 -= 5; - log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + c2.getDamage() + " vs "+c1.getElementTyp()+c1.getCardType()+": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - } - }else{ - ////PURE SPELL & mixed mit elementen - System.out.println("Spell und mixed mit elementen"); - //Player 1 Damage berechnen - if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { - if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //effective - damagePlayer1 = c1.getDamage() * 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { - //not effective - damagePlayer1 = c1.getDamage() / 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { - //no effect - damagePlayer1 = c1.getDamage(); - } - } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { - if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { - //effective - damagePlayer1 = c1.getDamage() * 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { - //no effect - damagePlayer1 = c1.getDamage(); - } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //not effective - damagePlayer1 = c1.getDamage() / 2; - } - } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { - if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { - //effective - damagePlayer1 = c1.getDamage() * 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { - //not effective - damagePlayer1 = c1.getDamage() / 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //no effect - damagePlayer1 = c1.getDamage(); - } - } - //P2 damage - if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { - if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //effective - damagePlayer2 = c2.getDamage() * 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { - //not effective - damagePlayer2 = c2.getDamage() / 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { - //no effect - damagePlayer2 = c2.getDamage(); - } - } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { - if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { - //effective - damagePlayer2 = c2.getDamage() * 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { - //no effect - damagePlayer2 = c2.getDamage(); - } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //not effective - damagePlayer2 = c2.getDamage() / 2; - } - } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { - if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { - //effective - damagePlayer2 = c2.getDamage() * 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { - //not effective - damagePlayer2 = c2.getDamage() / 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //no effect - damagePlayer2 = c2.getDamage(); - } - } - - if (damagePlayer1 > -1 && damagePlayer2 > -1) { - if (damagePlayer1 > damagePlayer2) { - d1.add(c2); - d2.remove(c2); - this.scorePlayer1 += 3; - this.scorePlayer2 -= 5; - log.add("Player 1 gewinnt!\n"+c1.getElementTyp()+c1.getCardType()+" ist stärker! "+c1.getElementTyp()+c1.getCardType()+": " + damagePlayer1 + " vs "+c2.getElementTyp()+c2.getCardType()+": " + damagePlayer2 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); - } else if (damagePlayer2 > damagePlayer1) { - d2.add(c1); - d1.remove(c1); - this.scorePlayer2 += 3; - this.scorePlayer1 -= 5; - log.add("Player 2 gewinnt!\n"+c2.getElementTyp()+c2.getCardType()+" ist stärker! "+c2.getElementTyp()+c2.getCardType()+": " + damagePlayer2 + " vs "+c1.getElementTyp()+c1.getCardType()+": " + damagePlayer1 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: "+ scorePlayer2); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + c2.getDamage() + " vs " + c1.getElementTyp() + c1.getCardType() + ": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); } } else { - System.out.println("Damage konnte nicht berechnet werden"); - return false; + ////PURE SPELL & mixed mit elementen + System.out.println("Spell und mixed mit elementen"); + //Player 1 Damage berechnen + if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { + if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //effective + damagePlayer1 = c1.getDamage() * 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { + //not effective + damagePlayer1 = c1.getDamage() / 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { + //no effect + damagePlayer1 = c1.getDamage(); + } + } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { + if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { + //effective + damagePlayer1 = c1.getDamage() * 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { + //no effect + damagePlayer1 = c1.getDamage(); + } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //not effective + damagePlayer1 = c1.getDamage() / 2; + } + } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { + if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { + //effective + damagePlayer1 = c1.getDamage() * 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { + //not effective + damagePlayer1 = c1.getDamage() / 2; + } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //no effect + damagePlayer1 = c1.getDamage(); + } + } + //P2 damage + if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { + if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //effective + damagePlayer2 = c2.getDamage() * 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { + //not effective + damagePlayer2 = c2.getDamage() / 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { + //no effect + damagePlayer2 = c2.getDamage(); + } + } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { + if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { + //effective + damagePlayer2 = c2.getDamage() * 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { + //no effect + damagePlayer2 = c2.getDamage(); + } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //not effective + damagePlayer2 = c2.getDamage() / 2; + } + } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { + if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { + //effective + damagePlayer2 = c2.getDamage() * 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { + //not effective + damagePlayer2 = c2.getDamage() / 2; + } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { + //no effect + damagePlayer2 = c2.getDamage(); + } + } + + if (damagePlayer1 > -1 && damagePlayer2 > -1) { + if (damagePlayer1 > damagePlayer2) { + d1.add(c2); + d2.remove(c2); + this.scorePlayer1 += 3; + this.scorePlayer2 -= 5; + log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damagePlayer1 + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damagePlayer2 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } else if (damagePlayer2 > damagePlayer1) { + d2.add(c1); + d1.remove(c1); + this.scorePlayer2 += 3; + this.scorePlayer1 -= 5; + log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damagePlayer2 + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damagePlayer1 + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); + } + } else { + System.out.println("Damage konnte nicht berechnet werden"); + return false; + } } } } diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 4e010de..80928e3 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -410,42 +410,34 @@ public class Response { if(new DBConnection().addBattleLog(openBattle.getId()+"", openBattle.getPlayer1().getName(), openBattle.getPlayer2().getName(), openBattle.getScorePlayer1()+"", openBattle.getScorePlayer2() +"")){ if(new DBConnection().delDeck(openBattle.getPlayer1().getCredentials().getUsername()) && new DBConnection().delDeck(openBattle.getPlayer2().getCredentials().getUsername())) { //DEL OLD DECK CARDS + ArrayList oldDeck1 = new ArrayList(); for (Card ca: openBattle.getDeckPlayer1Init().getCards()){ - if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){ - sendResponse("Error Deleting user card1: " + ca.getName(), "500"); - } + oldDeck1.add(ca.getName()); } + ArrayList oldDeck2 = new ArrayList(); for (Card ca: openBattle.getDeckPlayer2Init().getCards()){ - if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){ - sendResponse("Error Deleting user card2: " + ca.getName(), "500"); - } + oldDeck2.add(ca.getName()); } //DEL NEW CARDS IF EXIST Cards player1cards = new DBConnection().getCards(openBattle.getPlayer1().getCredentials().getUsername()); - ArrayList player1CardsList = new ArrayList(); - for(Card ca:player1cards.getCards()){ - player1CardsList.add(ca.getName()); + for(Card ca:openBattle.getDeckPlayer1().getCards()){ + oldDeck1.add(ca.getName()); } if(player1cards.getCards() != null && !player1cards.getCards().isEmpty()) { - for (Card ca : openBattle.getDeckPlayer1().getCards()) { - if (player1CardsList.contains(ca.getName())){ - if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){ - sendResponse("Error Deleting user card1: " + ca.getName(), "500"); - } + for (String ca : oldDeck1) { + if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca)){ + sendResponse("Error Deleting user card1: " + ca, "500"); } } } Cards player2cards = new DBConnection().getCards(openBattle.getPlayer2().getCredentials().getUsername()); - ArrayList player2CardsList = new ArrayList(); - for(Card ca:player2cards.getCards()){ - player2CardsList.add(ca.getName()); + for(Card ca:openBattle.getDeckPlayer2().getCards()){ + oldDeck2.add(ca.getName()); } if(player2cards.getCards() != null && !player2cards.getCards().isEmpty()) { - for (Card ca : openBattle.getDeckPlayer2().getCards()) { - if (player2CardsList.contains(ca.getName())){ - if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){ - sendResponse("Error Deleting user card2: " + ca.getName(), "500"); - } + for (String ca : oldDeck2) { + if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca)){ + sendResponse("Error Deleting user card2: " + ca, "500"); } } } From b4f0edafe3456da8c4672e8392e4a9646d8a28af Mon Sep 17 00:00:00 2001 From: "DESKTOP-IDUS0DU\\georg" Date: Sat, 2 Jan 2021 15:15:47 +0100 Subject: [PATCH 20/20] /stats + /score + Performace Bugfixes + Removed unused + completed doc + Battle Bugfixes + other bugs --- .gitignore | 2 +- README.md | 2 +- src/main/java/at/reisinger/Card.java | 213 --------- .../java/at/reisinger/EffectivnessType.java | 7 - src/main/java/at/reisinger/MonsterCard.java | 7 - .../at/reisinger/NegativAmountException.java | 17 - src/main/java/at/reisinger/SpellCard.java | 7 - src/main/java/at/reisinger/Stack.java | 50 --- src/main/java/at/reisinger/Store.java | 15 - src/main/java/at/reisinger/User.java | 306 ------------- .../at/reisinger/{ => enums}/CardType.java | 2 +- .../at/reisinger/{ => enums}/ElementTyp.java | 2 +- .../java/at/reisinger/{ => obj}/Battle.java | 348 +++++++-------- src/main/java/at/reisinger/obj/Card.java | 176 ++++++++ .../java/at/reisinger/{ => obj}/Cards.java | 45 +- .../java/at/reisinger/{ => obj}/Coins.java | 19 +- .../at/reisinger/{ => obj}/Credentials.java | 24 +- .../java/at/reisinger/{ => obj}/Package.java | 10 +- .../at/reisinger/{ => obj}/TradingDeal.java | 82 +--- src/main/java/at/reisinger/obj/User.java | 163 +++++++ .../reisinger/{ => server}/DBConnection.java | 399 ++++++++--------- src/main/java/at/reisinger/server/Main.java | 20 +- .../reisinger/server/helper/EnumHelper.java | 4 +- .../reisinger/server/helper/JsonHelper.java | 55 +-- .../server/helper/PostgresHelper.java | 1 - .../server/helper/ResponseHelper.java | 23 + .../at/reisinger/server/objects/Request.java | 39 +- .../at/reisinger/server/objects/Response.java | 415 ++++++++---------- src/test/java/CardTest.java | 30 +- src/test/java/CardsTest.java | 28 +- src/test/java/CoinsTest.java | 55 +-- src/test/java/PackageTest.java | 34 +- src/test/java/StackTest.java | 48 -- src/test/java/StoreTest.java | 147 ------- src/test/java/TradingDealTest.java | 62 +-- src/test/java/UserTest.java | 57 ++- 36 files changed, 1064 insertions(+), 1850 deletions(-) delete mode 100644 src/main/java/at/reisinger/Card.java delete mode 100644 src/main/java/at/reisinger/EffectivnessType.java delete mode 100644 src/main/java/at/reisinger/MonsterCard.java delete mode 100644 src/main/java/at/reisinger/NegativAmountException.java delete mode 100644 src/main/java/at/reisinger/SpellCard.java delete mode 100644 src/main/java/at/reisinger/Stack.java delete mode 100644 src/main/java/at/reisinger/Store.java delete mode 100644 src/main/java/at/reisinger/User.java rename src/main/java/at/reisinger/{ => enums}/CardType.java (81%) rename src/main/java/at/reisinger/{ => enums}/ElementTyp.java (74%) rename src/main/java/at/reisinger/{ => obj}/Battle.java (62%) create mode 100644 src/main/java/at/reisinger/obj/Card.java rename src/main/java/at/reisinger/{ => obj}/Cards.java (55%) rename src/main/java/at/reisinger/{ => obj}/Coins.java (54%) rename src/main/java/at/reisinger/{ => obj}/Credentials.java (50%) rename src/main/java/at/reisinger/{ => obj}/Package.java (73%) rename src/main/java/at/reisinger/{ => obj}/TradingDeal.java (59%) create mode 100644 src/main/java/at/reisinger/obj/User.java rename src/main/java/at/reisinger/{ => server}/DBConnection.java (71%) create mode 100644 src/main/java/at/reisinger/server/helper/ResponseHelper.java delete mode 100644 src/test/java/StackTest.java delete mode 100644 src/test/java/StoreTest.java diff --git a/.gitignore b/.gitignore index 4867bb4..3373710 100644 --- a/.gitignore +++ b/.gitignore @@ -10,7 +10,7 @@ # Mobile Tools for Java (J2ME) .mtj.tmp/ -# at.reisinger.Package Files # +# at.reisinger.obj.Package Files # *.jar *.war *.nar diff --git a/README.md b/README.md index 8ef490b..183a51b 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,2 @@ # SWE1-MTCG -Monster Trading at.reisinger.Card Game +Monster Trading at.reisinger.obj.Card Game diff --git a/src/main/java/at/reisinger/Card.java b/src/main/java/at/reisinger/Card.java deleted file mode 100644 index 51f7ed2..0000000 --- a/src/main/java/at/reisinger/Card.java +++ /dev/null @@ -1,213 +0,0 @@ -package at.reisinger; - -import at.reisinger.server.helper.EnumHelper; -import com.fasterxml.jackson.annotation.*; - -/** - * Object einer at.reisinger.Card - */ -@JsonAutoDetect -public class Card { - @JsonProperty - private String name; - @JsonProperty - private double damage; - @JsonProperty - private ElementTyp elementTyp; - @JsonProperty - private CardType cardType; - @JsonProperty - private boolean locked; - - /** - * Erstellt eine neue at.reisinger.Card mit gegebenen Eigenschaften - * @param name Name der at.reisinger.Card - * @param damage Damage den die at.reisinger.Card macht - * @param elementTyp ElementType der at.reisinger.Card - * @param cardType at.reisinger.CardType der at.reisinger.Card - */ - public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) { - this.name = name; - this.damage = damage; - this.elementTyp = elementTyp; - this.cardType = cardType; - } - - /** - * Erstellt eine neue Card mit, anhand des cardNamen werden der ElementType und der CardType automatisch bestimmt - * @param name Name der Card (ID) - * @param elementCardTyp ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt. - * Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null - * @param damage Damage der Card - */ - @JsonCreator - public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){ - CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp); - ElementTyp tmpElement = null; - if(tmpCard == null){ - tmpCard = CardType.UNDEF; - } - - //Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen - if (tmpCard.name().toLowerCase().equals("dragon")){ - tmpElement = ElementTyp.FIRE; - }else if (tmpCard.name().toLowerCase().equals("ork")){ - tmpElement = ElementTyp.REGULAR; - } - else if (tmpCard.name().toLowerCase().equals("wizzard")){ - tmpElement = ElementTyp.REGULAR; - }else if (tmpCard.name().toLowerCase().equals("kraken")){ - tmpElement = ElementTyp.WATER; - }else if (tmpCard.name().toLowerCase().equals("elf")){ - tmpElement = ElementTyp.REGULAR; - }else if (tmpCard.name().toLowerCase().equals("goblin")){ - tmpElement = ElementTyp.REGULAR; - }else if (tmpCard.name().toLowerCase().equals("troll")){ - tmpElement = ElementTyp.REGULAR; - }else if (tmpCard.name().toLowerCase().equals("knight")){ - tmpElement = ElementTyp.REGULAR; - }else if (tmpCard.name().toLowerCase().equals("fireelves")){ - tmpElement = ElementTyp.FIRE; - } - - if(tmpElement == null){ - tmpElement = EnumHelper.stringToElementType(elementCardTyp); - //Deutsch übersetzung - if (tmpElement.name().toLowerCase().equals("feuer")){ - tmpElement = ElementTyp.FIRE; - }else if (tmpElement.name().toLowerCase().equals("wasser")){ - tmpElement = ElementTyp.WATER; - }else if (tmpElement.name().toLowerCase().equals("normal")){ - tmpElement = ElementTyp.REGULAR; - } - if(tmpElement == null) { - tmpElement = ElementTyp.UNDEF; - } - } - this.name = name; - this.damage = damage; - this.elementTyp = tmpElement; - this.cardType = tmpCard; - } - - - - /** - * Prüft ob die Karte gesperrt ist - * @return True wenn die Karte gesperrt ist - */ - public boolean isLocked() { - return locked; - } - - /** - * Setzt die sperre der Karte - * @param locked True bedeuted gesperrt - */ - public void setLocked(boolean locked) { - this.locked = locked; - } - - /** - * Holt den Namen der at.reisinger.Card - * @return Name der at.reisinger.Card - */ - @JsonGetter - public String getName() { - return this.name; - } - - /** - * Holt den Damage der at.reisinger.Card - * @return Damage der at.reisinger.Card - */ - @JsonGetter - public double getDamage() { - return this.damage; - } - - /** - * Holt den ElementType der at.reisinger.Card - * @return ElementType der at.reisinger.Card - */ - @JsonGetter - public ElementTyp getElementTyp() { - return this.elementTyp; - } - - /** - * Holt den at.reisinger.CardType der at.reisinger.Card - * @return at.reisinger.CardType der at.reisinger.Card - */ - @JsonGetter - public CardType getCardType() { - return this.cardType; - } - - /** - * Berechnet die Wirksamkeit gegen eine Andere card. Die at.reisinger.Card im Parameter wird angegriffen - * @param toCeck at.reisinger.Card gegen welche die Wirksamkeit geprüft werden soll - * @return Gibt die Wirksamkeit zurück - * @throws InternalError Wenn die Effectifeness von den 2 at.reisinger.Cards nicht berechnet werden kann - */ - @JsonGetter - public EffectivnessType getEffectivenessAgainst(Card toCeck) { - if(toCeck.getCardType() == CardType.MONSTER){ - if(this.cardType == CardType.MONSTER){ - return EffectivnessType.NOEFFECT; - }else if (this.cardType == CardType.SPELL){ - - } - }else if (toCeck.getCardType() == CardType.SPELL){ - if ((toCeck.getElementTyp() == ElementTyp.FIRE && this.elementTyp == ElementTyp.WATER) || (toCeck.getElementTyp() == ElementTyp.NORMAL && this.elementTyp == ElementTyp.FIRE) || (toCeck.getElementTyp() == ElementTyp.WATER && this.elementTyp == ElementTyp.NORMAL)){ - return EffectivnessType.EFFECTIVE; - }else if (this.elementTyp == ElementTyp.FIRE && toCeck.getElementTyp() == ElementTyp.WATER){ - return EffectivnessType.NOTEFFECTIVE; - }else if ((toCeck.getElementTyp() == ElementTyp.NORMAL && this.cardType == CardType.MONSTER && this.elementTyp == ElementTyp.NORMAL)){ - return EffectivnessType.NOEFFECT; - } - } - throw new InternalError("Konnte die Effectiveness von den at.reisinger.Cards nicht berechnen"); - } - - /** - * Setztden namen der at.reisinger.Card - * @param neuerName Name der at.reisinger.Card - */ - @JsonSetter - public void setName(String neuerName) { - this.name = neuerName; - } - - /** - * Setzt den Damage der at.reisinger.Card - * @param damage Der Damage - */ - @JsonSetter - public void setDamage(int damage) { - this.damage = damage; - } - - /** - * Setzt den ElementType der at.reisinger.Card - * @param elementTyp Der ElementType - */ - @JsonSetter - public void setElementType(ElementTyp elementTyp) { - this.elementTyp = elementTyp; - } - - /** - * Testet ob die beiden Karten gleich sind - * @param card at.reisinger.Card die geprüft werden soll - * @return True wenn die Karten übereinstimmen - */ - public boolean equals(Card card){ - if(card == null) return false; - if(this.name == card.getName() && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage()){ - return true; - }else { - return false; - } - } -} diff --git a/src/main/java/at/reisinger/EffectivnessType.java b/src/main/java/at/reisinger/EffectivnessType.java deleted file mode 100644 index 62421a1..0000000 --- a/src/main/java/at/reisinger/EffectivnessType.java +++ /dev/null @@ -1,7 +0,0 @@ -package at.reisinger; - -public enum EffectivnessType { - EFFECTIVE, - NOTEFFECTIVE, - NOEFFECT -} diff --git a/src/main/java/at/reisinger/MonsterCard.java b/src/main/java/at/reisinger/MonsterCard.java deleted file mode 100644 index c1ffc83..0000000 --- a/src/main/java/at/reisinger/MonsterCard.java +++ /dev/null @@ -1,7 +0,0 @@ -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/at/reisinger/NegativAmountException.java b/src/main/java/at/reisinger/NegativAmountException.java deleted file mode 100644 index 0405378..0000000 --- a/src/main/java/at/reisinger/NegativAmountException.java +++ /dev/null @@ -1,17 +0,0 @@ -package at.reisinger; - -/** - * Wenn ein negativer wert eingegeben wird aber ein Positiver erwartet wird, dann kann diese Exception geworfen werden - */ -public class NegativAmountException extends Exception { - - /** - * Aufruf des Constructors der Super class Exception - * @param message Fehler Nachrichgt - * @param cause Fehler Ursache - */ - public NegativAmountException(String message){ - super(message); - } - -} diff --git a/src/main/java/at/reisinger/SpellCard.java b/src/main/java/at/reisinger/SpellCard.java deleted file mode 100644 index f9f9881..0000000 --- a/src/main/java/at/reisinger/SpellCard.java +++ /dev/null @@ -1,7 +0,0 @@ -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/at/reisinger/Stack.java b/src/main/java/at/reisinger/Stack.java deleted file mode 100644 index eab8633..0000000 --- a/src/main/java/at/reisinger/Stack.java +++ /dev/null @@ -1,50 +0,0 @@ -package at.reisinger; - -/** - * Erweitert at.reisinger.Cards insofern, dass es im at.reisinger.Stack auch ein Deck gibt - */ -public class Stack extends Cards{ - private Cards deck; - - /** - * Erstellt einen neuen at.reisinger.Stack aus den at.reisinger.User at.reisinger.Cards und seinem Deck - * @param cards Alle at.reisinger.Cards des Users - * @param deck Sein Deck - */ - public Stack(Cards cards, Cards deck) { - super(cards.getCards()); - this.deck = deck; - } - - /** - * Fügt ein neues Deck in den at.reisinger.Stack ein - * @param newCards Gesamtes Deck - */ - public void addDeck(Cards newCards) { - this.deck = newCards; - } - - /** - * Holt das gesamte Deck - * @return Gesamtes Deck - */ - public Cards getDeck() { - return this.deck; - } - - /** - * Löscht eine at.reisinger.Card aus dem Deck - * @param toDel at.reisinger.Card zum löschen - */ - public void delDeck(Card toDel) { - this.deck.delCard(toDel); - } - -// /** -// * Fügt dem deck eine neue at.reisinger.Card ein -// * @param toAdd Neue at.reisinger.Card -// */ -// public void addDeckCard(at.reisinger.Card toAdd){ -// this.deck.addCard(toAdd); -// } -} diff --git a/src/main/java/at/reisinger/Store.java b/src/main/java/at/reisinger/Store.java deleted file mode 100644 index 7befd7e..0000000 --- a/src/main/java/at/reisinger/Store.java +++ /dev/null @@ -1,15 +0,0 @@ -package at.reisinger; - -import java.util.ArrayList; - -public interface Store { - //DBConnection db = new DBConnection(); - - void addTradingDeal(TradingDeal tradingDeal); - - ArrayList getTradingDeals(); - - boolean doTrading(TradingDeal tradingDeal1, TradingDeal tradingDeal2); - - ArrayList getPossibleTradingDeals(Card toTrade); -} diff --git a/src/main/java/at/reisinger/User.java b/src/main/java/at/reisinger/User.java deleted file mode 100644 index b6d56c4..0000000 --- a/src/main/java/at/reisinger/User.java +++ /dev/null @@ -1,306 +0,0 @@ -package at.reisinger; - -import com.fasterxml.jackson.annotation.*; - -import java.util.ArrayList; - -/** - * at.reisinger.User & at.reisinger.Store Logik - */ -@JsonAutoDetect -public class User{ - @JsonProperty - 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 - * @param nachname Nachname des Users - * @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; - this.name = name; - this.nachname = nachname; - this.email = email; - this.stack = stack; - 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, @JsonProperty String bio, @JsonProperty String image) { - this.credentials = credentials; - this.name = name; - this.nachname = nachname; - this.email = email; - //this.stack = null; - this.coins = coins; - this.bio = bio; - this.image = image; - //this.db = new at.reisinger.DBConnection(); - } - - /** - * Holt die Bio vom User - * @return Bio des Users - */ - @JsonGetter - public String getBio() { - return bio; - } - - /** - * Setzt die Bio vom User - * @param bio Bio des Users - */ - @JsonSetter - public void setBio(String bio) { - this.bio = bio; - } - - /** - * Holt das image vom user - * @return Image vom user - */ - @JsonGetter - public String getImage() { - return image; - } - - /** - * Setzt das image vom user - * @param image Image vom user - */ - @JsonSetter - public void setImage(String image) { - this.image = image; - } - - /** - * Holt den at.reisinger.Stack des Users - * @return at.reisinger.Stack des Users - - @JsonGetter - public Stack getStack() { - return stack; - } - - /** - * 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; - } - - /** - * Holt das DB Obj - * @return Das DB Obj - - @JsonGetter - public DBConnection getDb() { - return new DBConnection(); - } - - /** - * Setzt ein neues DB Obj - * @param db Das neue DB Obj - - - @JsonSetter - public void setDb(DBConnection db) { - this.db = db; - } - - */ - - /** - * Holt die eindeutigen Logindaten des Users - * @return Eindeutige Logindaten - */ - @JsonGetter - public Credentials getCredentials() { - return credentials; - } - - /** - * Setzt die eindeutigen Logindaten - * @param credentials Die neuen at.reisinger.Credentials des Users - */ - @JsonSetter - public void setCredentials(Credentials credentials) { - this.credentials = credentials; - } - - /** - * Holt alle at.reisinger.Coins des Users - * @return at.reisinger.Coins des Users - */ - @JsonGetter - public Coins getCoins() { - return coins; - } - - /** - * 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 at.reisinger.User - * @return Name of at.reisinger.User - */ - @JsonGetter - public String getName() { - return this.name; - } - - /** - * Get Nachname of at.reisinger.User - * @return Nachname of at.reisinger.User - */ - @JsonGetter - public String getNachname() { - return this.nachname; - } - - /** - * Email of at.reisinger.User - * @return Email of at.reisinger.User - */ - @JsonGetter - public String getEmail() { - return this.email; - } - - /** - * Setzt den Namen des Users - * @param name Neuer Name des Users - */ - @JsonSetter - public void setName(String name) { - this.name = name; - } - - /** - * Setzt den Nachnamen - * @param nachname Neuer Nachname - */ - @JsonSetter - public void setNachname(String nachname) { - this.nachname = nachname; - } - - /** - * Setzt die Email des Users - * @param email Neue Email des Users - */ - @JsonSetter - public void setEmail(String email) { - this.email = email; - } - - //at.reisinger.Store Methoden - - /** - * 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)); - this.coins.removeCoin(mypackage.getPrice()); - return mypackage.getCards(); - } - - /** - * 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 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()); - stack.addCard(storeTradingDeal.getCardToTrade()); - return true; - } - return false; - } - */ - - /** - * Gibt alle Möglichen Trading Deals zurück - * @param toTrade Prüft nach diesem Deal - * @return - * - @Override - public ArrayList getPossibleTradingDeals(Card toTrade) { - ArrayList storeList = new DBConnection().getAllTradingDeals(); - ArrayList possible = new ArrayList(); - storeList.forEach(item -> { - if(item.cardOk(toTrade)){ - System.out.println("ADDED ein item"); - possible.add(item); - } - }); - return possible; - } - - */ - /** - * Checkt ob es sich um den selben 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()){ - return true; - }else { - return false; - } - } -} diff --git a/src/main/java/at/reisinger/CardType.java b/src/main/java/at/reisinger/enums/CardType.java similarity index 81% rename from src/main/java/at/reisinger/CardType.java rename to src/main/java/at/reisinger/enums/CardType.java index 0bdbe17..341c5e4 100644 --- a/src/main/java/at/reisinger/CardType.java +++ b/src/main/java/at/reisinger/enums/CardType.java @@ -1,4 +1,4 @@ -package at.reisinger; +package at.reisinger.enums; public enum CardType { MONSTER, SPELL, UNDEF, GOBLIN, TROLL, ELF, KNIGHT, DRAGON, WIZZARD, ORK, KRAKEN, FIREELVES diff --git a/src/main/java/at/reisinger/ElementTyp.java b/src/main/java/at/reisinger/enums/ElementTyp.java similarity index 74% rename from src/main/java/at/reisinger/ElementTyp.java rename to src/main/java/at/reisinger/enums/ElementTyp.java index 9b10243..143989f 100644 --- a/src/main/java/at/reisinger/ElementTyp.java +++ b/src/main/java/at/reisinger/enums/ElementTyp.java @@ -1,4 +1,4 @@ -package at.reisinger; +package at.reisinger.enums; public enum ElementTyp { WATER, FIRE, NORMAL, UNDEF, REGULAR, FEUER, WASSER diff --git a/src/main/java/at/reisinger/Battle.java b/src/main/java/at/reisinger/obj/Battle.java similarity index 62% rename from src/main/java/at/reisinger/Battle.java rename to src/main/java/at/reisinger/obj/Battle.java index 8a93c6d..bfa5ad5 100644 --- a/src/main/java/at/reisinger/Battle.java +++ b/src/main/java/at/reisinger/obj/Battle.java @@ -1,45 +1,28 @@ -package at.reisinger; +package at.reisinger.obj; import java.util.ArrayList; import java.util.Collections; +import java.util.Objects; public class Battle { - private User player1, player2; - private int scorePlayer1, scorePlayer2, id; - private Cards deckPlayer1, deckPlayer2, deckPlayer1Init, deckPlayer2Init; - private Card spielfeldCardPlayer1, spielfeldCardPlayer2; - private ArrayList log = new ArrayList(); + private final User player1; + private User player2; + private int scorePlayer1; + private int scorePlayer2; + private final int id; + private Cards deckPlayer1; + private Cards deckPlayer2; + private final Cards deckPlayer1Init; + private Cards deckPlayer2Init; + private final ArrayList log = new ArrayList<>(); - /** - * Erstellt ein neues Battle - * @param player1 Player 1 Obj - * @param player2 Player 2 Obj - * @param scorePlayer1 Score PLayer 1 - * @param scorePlayer2 Score player 2 - * @param deckPlayer1 Deck Player 1 - * @param deckPlayer2 Deck Player 2 - */ - public Battle(int id, User player1, User player2, int scorePlayer1, int scorePlayer2, Cards deckPlayer1, Cards deckPlayer2) { - this.id = id; - this.player1 = player1; - this.player2 = player2; - this.scorePlayer1 = scorePlayer1; - this.scorePlayer2 = scorePlayer2; - this.deckPlayer1 = deckPlayer1; - this.deckPlayer2 = deckPlayer2; - this.deckPlayer1Init = deckPlayer1; - this.deckPlayer2Init = deckPlayer2; - this.spielfeldCardPlayer1 = null; - this.spielfeldCardPlayer2 = null; - } - /** * Erstellt ein neues Battle, im zustand offenes battle - * @param id - * @param player1 - * @param deckPlayer1 + * @param id Id des Battles + * @param player1 Player 1 des Battles + * @param deckPlayer1 Deck vom Player 1 als json */ public Battle(int id, User player1, Cards deckPlayer1){ this.id = id; @@ -50,8 +33,6 @@ public class Battle { this.deckPlayer2 = null; this.deckPlayer1Init = deckPlayer1; this.deckPlayer2Init = null; - this.spielfeldCardPlayer1 = null; - this.spielfeldCardPlayer2 = null; } /** @@ -59,9 +40,7 @@ public class Battle { * @return true bei erfolg, sonst false */ public boolean doFight(){ - System.out.println("DAS IS DAS BATTTTLLLLLLLEEEEEEEEEE FIIIIIGHT!"); System.out.println(player1.getName() + " |vs|" + player2.getName()); - System.out.println(deckPlayer1.getCards().toString()+ " |vs| " + deckPlayer2.getCards().toString()); if(deckPlayer1.getCards().size() == 4 && deckPlayer2.getCards().size() == 4) { //SHUFFLE DECK @@ -77,41 +56,41 @@ public class Battle { while(counter 0 && d2.size() > 0 && counter<=maxroundcount) { + System.out.println("Runde: " + counter); + System.out.println("deck 1 size: " + d1.size() + " Deck 2 size: " + d2.size() + " counter2: " + counter2); + Card c1 = d1.get(counter2); + Card c2 = d2.get(counter2); + System.out.println("Card 1: " + c1.getElementTyp() + c1.getCardType() + "\nCard 2: " + c2.getElementTyp() + c2.getCardType()); //GLEICHER TYP Monster - if (!c1.getCardType().name().toUpperCase().equals("SPELL") && !c2.getCardType().name().toUpperCase().equals("SPELL")) { + if (!c1.getCardType().name().equalsIgnoreCase("SPELL") && !c2.getCardType().name().equalsIgnoreCase("SPELL")) { System.out.println("Same Monster"); //Check ob eine der beiden Carten ein Dragon ist - if ((c1.getCardType().name().toUpperCase().equals("DRANGON") && !c2.getCardType().name().toUpperCase().equals("DRANGON") || (!c1.getCardType().name().toUpperCase().equals("DRANGON") && c2.getCardType().name().toUpperCase().equals("DRANGON")))) { + if ((c1.getCardType().name().equalsIgnoreCase("DRANGON") && !c2.getCardType().name().equalsIgnoreCase("DRANGON") || (!c1.getCardType().name().equalsIgnoreCase("DRANGON") && c2.getCardType().name().equalsIgnoreCase("DRANGON")))) { //Eine der Karten is Dragon System.out.println("Eine ist ein dragon"); - Card dragon = null; - int dragonOwner = 0; - if (c1.getCardType().name().toUpperCase().equals("DRAGON")) { + Card dragon; + int dragonOwner; + if (c1.getCardType().name().equalsIgnoreCase("DRAGON")) { dragon = c1; dragonOwner = 1; - } else if (c2.getCardType().name().toUpperCase().equals("DRAGON")) { + } else if (c2.getCardType().name().equalsIgnoreCase("DRAGON")) { dragon = c2; dragonOwner = 2; } else { System.out.println("KEIN DRAGON GEFUNDEN"); return false; } - if ((c1.getCardType().name().toUpperCase().equals("GOBLIN") && !c2.getCardType().name().toUpperCase().equals("GOBLIN") || (!c1.getCardType().name().toUpperCase().equals("GOBLIN") && c2.getCardType().name().toUpperCase().equals("GOBLIN")))) { + if ((c1.getCardType().name().equalsIgnoreCase("GOBLIN") && !c2.getCardType().name().equalsIgnoreCase("GOBLIN") || (!c1.getCardType().name().equalsIgnoreCase("GOBLIN") && c2.getCardType().name().equalsIgnoreCase("GOBLIN")))) { //Eine der Karten ist Goblin System.out.println("Andere ist ein goblin"); - Card goblin = null; - if (c1.getCardType().name().toUpperCase().equals("GOBLIN")) { + Card goblin; + if (c1.getCardType().name().equalsIgnoreCase("GOBLIN")) { goblin = c1; - } else if (c2.getCardType().name().toUpperCase().equals("GOBLIN")) { + } else if (c2.getCardType().name().equalsIgnoreCase("GOBLIN")) { goblin = c2; } else { System.out.println("KEIN GOBLIN GEFUNDEN"); @@ -124,7 +103,7 @@ public class Battle { d2.remove(c2); this.scorePlayer1 += 3; this.scorePlayer2 -= 5; - } else if (dragonOwner == 2) { + } else { d2.add(c1); d1.remove(c1); this.scorePlayer1 -= 5; @@ -134,13 +113,13 @@ public class Battle { } else { System.out.println("DRAW: Drache zu schwach um anzugreifen und GOBLIN zu feige."); } - } else if ((c1.getCardType().name().toUpperCase().equals("ELF") && c1.getElementTyp().name().toUpperCase().equals("FIRE") && !c2.getCardType().name().toUpperCase().equals("ELF") || (!c1.getCardType().name().toUpperCase().equals("ELF") && c2.getElementTyp().name().toUpperCase().equals("FIRE") && c2.getCardType().name().toUpperCase().equals("ELF")))) { + } else if ((c1.getCardType().name().equalsIgnoreCase("ELF") && c1.getElementTyp().name().equalsIgnoreCase("FIRE") && !c2.getCardType().name().equalsIgnoreCase("ELF") || (!c1.getCardType().name().equalsIgnoreCase("ELF") && c2.getElementTyp().name().equalsIgnoreCase("FIRE") && c2.getCardType().name().equalsIgnoreCase("ELF")))) { //Eine der Karten ist der Fire Elf die andere Karte ist der drache System.out.println("Andere ist ein elf"); - Card fireelf = null; + Card fireelf; if (dragonOwner == 1) { fireelf = c2; - } else if (dragonOwner == 2) { + } else { fireelf = c1; } @@ -151,7 +130,7 @@ public class Battle { d1.remove(c1); this.scorePlayer2 += 3; this.scorePlayer1 -= 5; - } else if (dragonOwner == 2) { + } else { d1.add(c2); d2.remove(c2); this.scorePlayer2 -= 5; @@ -177,27 +156,27 @@ public class Battle { } //Checkt ob eine der beiden karten ein wizzard ist und der andere ein ork - } else if ((c1.getCardType().name().toUpperCase().equals("WIZZARD") && c2.getCardType().name().toUpperCase().equals("ORK") || (c2.getCardType().name().toUpperCase().equals("WIZZARD") && c1.getCardType().name().toUpperCase().equals("ORK")))) { + } else if ((c1.getCardType().name().equalsIgnoreCase("WIZZARD") && c2.getCardType().name().equalsIgnoreCase("ORK") || (c2.getCardType().name().equalsIgnoreCase("WIZZARD") && c1.getCardType().name().equalsIgnoreCase("ORK")))) { System.out.println("Eine wizzard Andere ist ein ork"); Card wizzard = null; Card ork = null; int wizzardOwner = 0; - if (c1.getCardType().name().toUpperCase().equals("WIZZARD")) { + if (c1.getCardType().name().equalsIgnoreCase("WIZZARD")) { wizzardOwner = 1; wizzard = c1; ork = c2; - } else if (c1.getCardType().name().toUpperCase().equals("WIZZARD")) { + } else if (c2.getCardType().name().equalsIgnoreCase("WIZZARD")) { wizzardOwner = 2; wizzard = c2; ork = c1; } - if (wizzard.getDamage() > ork.getDamage()) { + if (wizzard != null && wizzard.getDamage() > ork.getDamage()) { if (wizzardOwner == 1) { d1.add(c2); d2.remove(c2); this.scorePlayer1 += 3; this.scorePlayer2 -= 5; - } else if (wizzardOwner == 2) { + } else { d2.add(c1); d1.remove(c1); this.scorePlayer2 += 3; @@ -227,51 +206,51 @@ public class Battle { } else {//PURE SPELL & mixed double damagePlayer1 = -1, damagePlayer2 = -1; - if (c1.getCardType().name().toUpperCase().equals("KNIGHT") || c2.getCardType().name().toUpperCase().equals("KNIGHT")) { + if (c1.getCardType().name().equalsIgnoreCase("KNIGHT") || c2.getCardType().name().equalsIgnoreCase("KNIGHT")) { //Mixed mit "Spezialeffekt" KNIGHT System.out.println("Spell und knight"); Card knight = null, other = null; int knightOwner = 0; - if (c1.getCardType().name().toUpperCase().equals("KNIGHT")) { + if (c1.getCardType().name().equalsIgnoreCase("KNIGHT")) { knight = c1; other = c2; knightOwner = 1; - } else if (c2.getCardType().name().toUpperCase().equals("KNIGHT")) { + } else if (c2.getCardType().name().equalsIgnoreCase("KNIGHT")) { knight = c2; other = c1; knightOwner = 2; } double damageKnight = -1, damageOther = -1; - if (other.getElementTyp().name().toUpperCase().equals("WATER")) { + if (Objects.requireNonNull(other).getElementTyp().name().equalsIgnoreCase("WATER")) { //tot damageKnight = 0; damageOther = other.getDamage(); - } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("REGULAR")) { + } else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("REGULAR")) { //not effective damageKnight = knight.getDamage() / 2; //effective damageOther = other.getDamage() * 2; - } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("FIRE")) { + } else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("FIRE")) { //no effect damageKnight = knight.getDamage(); //no effect damageOther = other.getDamage(); - } else if (other.getElementTyp().name().toUpperCase().equals("FIRE") && knight.getElementTyp().name().equals("WATER")) { + } else if (other.getElementTyp().name().equalsIgnoreCase("FIRE") && Objects.requireNonNull(knight).getElementTyp().name().equals("WATER")) { //effective damageKnight = knight.getDamage() * 2; //not effective damageOther = other.getDamage() / 2; - } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("REGULAR")) { + } else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("REGULAR")) { //no effect damageKnight = knight.getDamage(); //no effect damageOther = other.getDamage(); - } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("FIRE")) { + } else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("FIRE")) { //effective damageKnight = knight.getDamage() * 2; //not effective damageOther = other.getDamage() / 2; - } else if (other.getElementTyp().name().toUpperCase().equals("REGULAR") && knight.getElementTyp().name().equals("WATER")) { + } else if (other.getElementTyp().name().equalsIgnoreCase("REGULAR") && Objects.requireNonNull(knight).getElementTyp().name().equals("WATER")) { //not effective damageKnight = knight.getDamage() / 2; //effective @@ -284,7 +263,7 @@ public class Battle { this.scorePlayer1 += 3; this.scorePlayer2 -= 5; log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damageKnight + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damageOther + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); - } else if (knightOwner == 2) { + } else { d2.add(c1); d1.remove(c1); this.scorePlayer2 += 3; @@ -298,7 +277,7 @@ public class Battle { this.scorePlayer1 += 3; this.scorePlayer2 -= 5; log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + damageOther + " vs " + c2.getElementTyp() + c2.getCardType() + ": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); - } else if (knightOwner == 1) { + } else { d2.add(c1); d1.remove(c1); this.scorePlayer2 += 3; @@ -306,15 +285,15 @@ public class Battle { log.add("Player 2 gewinnt!\n" + c2.getElementTyp() + c2.getCardType() + " ist stärker! " + c2.getElementTyp() + c2.getCardType() + ": " + damageOther + " vs " + c1.getElementTyp() + c1.getCardType() + ": " + damageKnight + "\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); } } - } else if (c1.getCardType().name().toUpperCase().equals("KRAKEN") || c2.getCardType().name().toUpperCase().equals("KRAKEN")) { + } else if (c1.getCardType().name().equalsIgnoreCase("KRAKEN") || c2.getCardType().name().equalsIgnoreCase("KRAKEN")) { //Mixed mit "Spezialeffekt" KRAKEN - if (c1.getCardType().name().toUpperCase().equals("KRAKEN")) { + if (c1.getCardType().name().equalsIgnoreCase("KRAKEN")) { d1.add(c2); d2.remove(c2); this.scorePlayer1 += 3; this.scorePlayer2 -= 5; log.add("Player 1 gewinnt!\n" + c1.getElementTyp() + c1.getCardType() + " ist stärker! " + c1.getElementTyp() + c1.getCardType() + ": " + c1.getDamage() + " vs " + c2.getElementTyp() + c2.getCardType() + ": 0\nPlayer 1 score: " + scorePlayer1 + "\nPlayer 2 score: " + scorePlayer2); - } else if (c2.getCardType().name().toUpperCase().equals("KRAKEN")) { + } else if (c2.getCardType().name().equalsIgnoreCase("KRAKEN")) { d2.add(c1); d1.remove(c1); this.scorePlayer2 += 3; @@ -325,74 +304,106 @@ public class Battle { ////PURE SPELL & mixed mit elementen System.out.println("Spell und mixed mit elementen"); //Player 1 Damage berechnen - if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { - if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //effective - damagePlayer1 = c1.getDamage() * 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { - //not effective - damagePlayer1 = c1.getDamage() / 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { - //no effect - damagePlayer1 = c1.getDamage(); - } - } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { - if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { - //effective - damagePlayer1 = c1.getDamage() * 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { - //no effect - damagePlayer1 = c1.getDamage(); - } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //not effective - damagePlayer1 = c1.getDamage() / 2; - } - } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { - if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { - //effective - damagePlayer1 = c1.getDamage() * 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { - //not effective - damagePlayer1 = c1.getDamage() / 2; - } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //no effect - damagePlayer1 = c1.getDamage(); - } + switch (c1.getElementTyp().name().toUpperCase()) { + case "FIRE": + switch (c2.getElementTyp().name().toUpperCase()) { + case "REGULAR": + //effective + damagePlayer1 = c1.getDamage() * 2; + break; + case "WATER": + //not effective + damagePlayer1 = c1.getDamage() / 2; + break; + case "FIRE": + //no effect + damagePlayer1 = c1.getDamage(); + break; + } + break; + case "WATER": + switch (c2.getElementTyp().name().toUpperCase()) { + case "FIRE": + //effective + damagePlayer1 = c1.getDamage() * 2; + break; + case "WATER": + //no effect + damagePlayer1 = c1.getDamage(); + break; + case "REGULAR": + //not effective + damagePlayer1 = c1.getDamage() / 2; + break; + } + break; + case "REGULAR": + switch (c2.getElementTyp().name().toUpperCase()) { + case "WATER": + //effective + damagePlayer1 = c1.getDamage() * 2; + break; + case "FIRE": + //not effective + damagePlayer1 = c1.getDamage() / 2; + break; + case "REGULAR": + //no effect + damagePlayer1 = c1.getDamage(); + break; + } + break; } //P2 damage - if (c2.getElementTyp().name().toUpperCase().equals("FIRE")) { - if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //effective - damagePlayer2 = c2.getDamage() * 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { - //not effective - damagePlayer2 = c2.getDamage() / 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { - //no effect - damagePlayer2 = c2.getDamage(); - } - } else if (c2.getElementTyp().name().toUpperCase().equals("WATER")) { - if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { - //effective - damagePlayer2 = c2.getDamage() * 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { - //no effect - damagePlayer2 = c2.getDamage(); - } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //not effective - damagePlayer2 = c2.getDamage() / 2; - } - } else if (c2.getElementTyp().name().toUpperCase().equals("REGULAR")) { - if (c1.getElementTyp().name().toUpperCase().equals("WATER")) { - //effective - damagePlayer2 = c2.getDamage() * 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("FIRE")) { - //not effective - damagePlayer2 = c2.getDamage() / 2; - } else if (c1.getElementTyp().name().toUpperCase().equals("REGULAR")) { - //no effect - damagePlayer2 = c2.getDamage(); - } + switch (c2.getElementTyp().name().toUpperCase()) { + case "FIRE": + switch (c1.getElementTyp().name().toUpperCase()) { + case "REGULAR": + //effective + damagePlayer2 = c2.getDamage() * 2; + break; + case "WATER": + //not effective + damagePlayer2 = c2.getDamage() / 2; + break; + case "FIRE": + //no effect + damagePlayer2 = c2.getDamage(); + break; + } + break; + case "WATER": + switch (c1.getElementTyp().name().toUpperCase()) { + case "FIRE": + //effective + damagePlayer2 = c2.getDamage() * 2; + break; + case "WATER": + //no effect + damagePlayer2 = c2.getDamage(); + break; + case "REGULAR": + //not effective + damagePlayer2 = c2.getDamage() / 2; + break; + } + break; + case "REGULAR": + switch (c1.getElementTyp().name().toUpperCase()) { + case "WATER": + //effective + damagePlayer2 = c2.getDamage() * 2; + break; + case "FIRE": + //not effective + damagePlayer2 = c2.getDamage() / 2; + break; + case "REGULAR": + //no effect + damagePlayer2 = c2.getDamage(); + break; + } + break; } if (damagePlayer1 > -1 && damagePlayer2 > -1) { @@ -415,6 +426,8 @@ public class Battle { } } } + }else { + return true; } } this.deckPlayer1 = new Cards(d1); @@ -426,19 +439,6 @@ public class Battle { return true; } - /** - * Vergleicht 2 Card Typen von 2 Karten - * @param c1 Card 1 - * @param c2 Card 2 - * @return True wenn die CardType übereinstimmt, sonst false - */ - private boolean sameCardType(Card c1, Card c2){ - if(c1.getCardType().name().equals(c2.getCardType().name())){ - return true; - } - return false; - } - public ArrayList getLog() { return log; } @@ -448,18 +448,10 @@ public class Battle { return id; } - public void setId(int id) { - this.id = id; - } - public User getPlayer1() { return player1; } - public void setPlayer1(User player1) { - this.player1 = player1; - } - public User getPlayer2() { return player2; } @@ -472,27 +464,15 @@ public class Battle { return scorePlayer1; } - public void setScorePlayer1(int scorePlayer1) { - this.scorePlayer1 = scorePlayer1; - - } public int getScorePlayer2() { return scorePlayer2; } - public void setScorePlayer2(int scorePlayer2) { - this.scorePlayer2 = scorePlayer2; - } - public Cards getDeckPlayer1() { return deckPlayer1; } - public void setDeckPlayer1(Cards deckPlayer1) { - this.deckPlayer1 = deckPlayer1; - this.deckPlayer1Init = deckPlayer1; - } public Cards getDeckPlayer2() { return deckPlayer2; @@ -503,22 +483,6 @@ public class Battle { this.deckPlayer2Init = deckPlayer2; } - public Card getSpielfeldCardPlayer1() { - return spielfeldCardPlayer1; - } - - public void setSpielfeldCardPlayer1(Card spielfeldCardPlayer1) { - this.spielfeldCardPlayer1 = spielfeldCardPlayer1; - } - - public Card getSpielfeldCardPlayer2() { - return spielfeldCardPlayer2; - } - - public void setSpielfeldCardPlayer2(Card spielfeldCardPlayer2) { - this.spielfeldCardPlayer2 = spielfeldCardPlayer2; - } - public Cards getDeckPlayer1Init() { return deckPlayer1Init; } diff --git a/src/main/java/at/reisinger/obj/Card.java b/src/main/java/at/reisinger/obj/Card.java new file mode 100644 index 0000000..46c61ce --- /dev/null +++ b/src/main/java/at/reisinger/obj/Card.java @@ -0,0 +1,176 @@ +package at.reisinger.obj; + +import at.reisinger.enums.CardType; +import at.reisinger.enums.ElementTyp; +import at.reisinger.server.helper.EnumHelper; +import com.fasterxml.jackson.annotation.*; + +import java.util.Objects; + +/** + * Object einer at.reisinger.obj.Card + */ +@JsonAutoDetect +public class Card { + @JsonProperty + private String name; + @JsonProperty + private double damage; + @JsonProperty + private ElementTyp elementTyp; + @JsonProperty + private final CardType cardType; + @JsonProperty + private boolean locked; + + /** + * Erstellt eine neue at.reisinger.obj.Card mit gegebenen Eigenschaften + * @param name Name der at.reisinger.obj.Card + * @param damage Damage den die at.reisinger.obj.Card macht + * @param elementTyp ElementType der at.reisinger.obj.Card + * @param cardType at.reisinger.enums.CardType der at.reisinger.obj.Card + */ + public Card(String name, double damage, ElementTyp elementTyp, CardType cardType) { + this.name = name; + this.damage = damage; + this.elementTyp = elementTyp; + this.cardType = cardType; + } + + /** + * Erstellt eine neue Card mit, anhand des cardNamen werden der ElementType und der CardType automatisch bestimmt + * @param name Name der Card (ID) + * @param elementCardTyp ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt. + * Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null + * @param damage Damage der Card + */ + @JsonCreator + public Card(@JsonProperty("Id") String name, @JsonProperty("Name") String elementCardTyp, @JsonProperty("Damage") double damage){ + CardType tmpCard = EnumHelper.stringToCardType(elementCardTyp); + ElementTyp tmpElement = null; + if(tmpCard == null){ + tmpCard = CardType.UNDEF; + } + + //Spezialkarten die kein element besitzen, bekommen hier ihr natürliches element zugewiesen + switch (tmpCard.name().toLowerCase()) { + case "dragon": + case "fireelves": + tmpElement = ElementTyp.FIRE; + break; + case "ork": + case "wizzard": + case "knight": + case "troll": + case "goblin": + case "elf": + tmpElement = ElementTyp.REGULAR; + break; + case "kraken": + tmpElement = ElementTyp.WATER; + break; + } + + if(tmpElement == null){ + tmpElement = EnumHelper.stringToElementType(elementCardTyp); + //Deutsch übersetzung + switch (Objects.requireNonNull(tmpElement).name().toLowerCase()) { + case "feuer": + tmpElement = ElementTyp.FIRE; + break; + case "wasser": + tmpElement = ElementTyp.WATER; + break; + case "normal": + tmpElement = ElementTyp.REGULAR; + break; + } + } + this.name = name; + this.damage = damage; + this.elementTyp = tmpElement; + this.cardType = tmpCard; + } + + + public boolean isLocked() { + return locked; + } + + public void setLocked(boolean locked) { + this.locked = locked; + } + + /** + * Holt den Namen der at.reisinger.obj.Card + * @return Name der at.reisinger.obj.Card + */ + @JsonGetter + public String getName() { + return this.name; + } + + /** + * Holt den Damage der at.reisinger.obj.Card + * @return Damage der at.reisinger.obj.Card + */ + @JsonGetter + public double getDamage() { + return this.damage; + } + + /** + * Holt den ElementType der at.reisinger.obj.Card + * @return ElementType der at.reisinger.obj.Card + */ + @JsonGetter + public ElementTyp getElementTyp() { + return this.elementTyp; + } + + /** + * Holt den at.reisinger.enums.CardType der at.reisinger.obj.Card + * @return at.reisinger.enums.CardType der at.reisinger.obj.Card + */ + @JsonGetter + public CardType getCardType() { + return this.cardType; + } + + /** + * Setztden namen der at.reisinger.obj.Card + * @param neuerName Name der at.reisinger.obj.Card + */ + @JsonSetter + public void setName(String neuerName) { + this.name = neuerName; + } + + /** + * Setzt den Damage der at.reisinger.obj.Card + * @param damage Der Damage + */ + @JsonSetter + public void setDamage(int damage) { + this.damage = damage; + } + + /** + * Setzt den ElementType der at.reisinger.obj.Card + * @param elementTyp Der ElementType + */ + @JsonSetter + public void setElementType(ElementTyp elementTyp) { + this.elementTyp = elementTyp; + } + + /** + * Testet ob die beiden Karten gleich sind + * @param card at.reisinger.obj.Card die geprüft werden soll + * @return True wenn die Karten übereinstimmen + */ + public boolean equals(Card card){ + if(card == null) return false; + return this.name.equals(card.getName()) && this.cardType == card.getCardType() && this.elementTyp == card.getElementTyp() && this.damage == card.getDamage(); + } +} diff --git a/src/main/java/at/reisinger/Cards.java b/src/main/java/at/reisinger/obj/Cards.java similarity index 55% rename from src/main/java/at/reisinger/Cards.java rename to src/main/java/at/reisinger/obj/Cards.java index 6227150..0615ede 100644 --- a/src/main/java/at/reisinger/Cards.java +++ b/src/main/java/at/reisinger/obj/Cards.java @@ -1,13 +1,14 @@ -package at.reisinger; +package at.reisinger.obj; import com.fasterxml.jackson.annotation.*; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import java.util.ArrayList; +import java.util.Objects; import java.util.concurrent.atomic.AtomicBoolean; /** - * Verwaltet eine Liste vo at.reisinger.Cards + * Verwaltet eine Liste vo at.reisinger.obj.Cards */ @JsonAutoDetect public class Cards { @@ -16,7 +17,7 @@ public class Cards { /** * Erstellt ein nues obj mit gegebenen Karten - * @param cardsArrayList Die at.reisinger.Cards zum erstellen des Obj + * @param cardsArrayList Die at.reisinger.obj.Cards zum erstellen des Obj */ @JsonCreator public Cards(@JsonProperty("cards") ArrayList cardsArrayList) { @@ -32,8 +33,8 @@ public class Cards { } /** - * Fügt eine neue at.reisinger.Card hinzu - * @param newCard neue at.reisinger.Card + * Fügt eine neue at.reisinger.obj.Card hinzu + * @param newCard neue at.reisinger.obj.Card */ @JsonSetter public void addCard(Card newCard) { @@ -41,8 +42,8 @@ public class Cards { } /** - * Holt alle at.reisinger.Cards - * @return Alle at.reisinger.Cards + * Holt alle at.reisinger.obj.Cards + * @return Alle at.reisinger.obj.Cards */ @JsonGetter public ArrayList getCards() { @@ -50,44 +51,34 @@ public class Cards { } /** - * Löscht die gegebene at.reisinger.Card - * @param delCard at.reisinger.Card zum löschen + * Löscht die gegebene at.reisinger.obj.Card + * @param delCard at.reisinger.obj.Card zum löschen */ public void delCard(Card delCard) { this.cards.removeIf(obj -> obj.equals(delCard)); } /** - * Prüft ob eine at.reisinger.Card in den at.reisinger.Cards vorhanden ist - * @param toCeck at.reisinger.Card nach der in den at.reisinger.Cards gesucht werden soll - * @return True wenn die at.reisinger.Card in den at.reisinger.Cards ist + * Prüft ob eine at.reisinger.obj.Card in den at.reisinger.obj.Cards vorhanden ist + * @param toCeck at.reisinger.obj.Card nach der in den at.reisinger.obj.Cards gesucht werden soll + * @return True wenn die at.reisinger.obj.Card in den at.reisinger.obj.Cards ist */ public boolean containsCard(String toCeck){ AtomicBoolean returnval = new AtomicBoolean(false); - this.cards.forEach(item -> { - if(item.getName().equals(toCeck)){ - returnval.set(true); - }else{ - returnval.set(false); - } - }); + this.cards.forEach(item -> returnval.set(item.getName().equals(toCeck))); return returnval.get(); } /** - * Vergleicht 2 at.reisinger.Cards Obj miteinander - * @param toCompare at.reisinger.Cards zum vergleichen - * @return True wenn es aus den selben at.reisinger.Cards besteht + * Vergleicht 2 at.reisinger.obj.Cards Obj miteinander + * @param toCompare at.reisinger.obj.Cards zum vergleichen + * @return True wenn es aus den selben at.reisinger.obj.Cards besteht */ public boolean equals(Cards toCompare){ if (this.cards == null && toCompare.getCards() == null){ return true; }else if ((this.cards == null && toCompare.getCards() != null) || (this.cards != null && toCompare.getCards() == null)){ return false; - }else if(this.cards.containsAll(toCompare.getCards()) && toCompare.getCards().containsAll(this.cards)){ - return true; - }else { - return false; - } + }else return Objects.requireNonNull(this.cards).containsAll(toCompare.getCards()) && toCompare.getCards().containsAll(this.cards); } } diff --git a/src/main/java/at/reisinger/Coins.java b/src/main/java/at/reisinger/obj/Coins.java similarity index 54% rename from src/main/java/at/reisinger/Coins.java rename to src/main/java/at/reisinger/obj/Coins.java index abd2a5b..8eadaf7 100644 --- a/src/main/java/at/reisinger/Coins.java +++ b/src/main/java/at/reisinger/obj/Coins.java @@ -1,4 +1,4 @@ -package at.reisinger; +package at.reisinger.obj; /** * Alle coins eines Users @@ -25,12 +25,9 @@ public class Coins { /** * Fügt münzen hinzu * @param coins Münzen die hinzugefügt werden -> Positiv - * @throws NegativAmountException Wenn negative münzen hinzugefüght werden */ - public void addCoin(int coins) throws NegativAmountException{ - if(coins < 0) { - throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"); - }else { + public void addCoin(int coins){ + if(coins > 0) { this.amount += coins; } } @@ -39,11 +36,10 @@ public class Coins { * Entfernt münzen * @param coins Münzen die entfernt werden sollen, muss positiv sein * @return True wenn erfolgreich - * @throws NegativAmountException Wenn ein negativer betrag abgezogen werden soll */ - public boolean removeCoin(int coins) throws NegativAmountException{ + public boolean removeCoin(int coins){ if(coins < 0) { - throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"); + return false; }else { this.amount -= coins; return true; @@ -54,11 +50,10 @@ public class Coins { * Ändert den Absoluten Coin amount * @param coins Neue Coin anzahl, muss positiv sein * @return true wenn erfolgreich - * @throws NegativAmountException Wenn ein negativer wert eingegeben wird */ - public boolean changeCoinAmmount(int coins) throws NegativAmountException{ + public boolean changeCoinAmmount(int coins){ if(coins < 0) { - throw new NegativAmountException("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden"); + return false; }else { this.amount = coins; return true; diff --git a/src/main/java/at/reisinger/Credentials.java b/src/main/java/at/reisinger/obj/Credentials.java similarity index 50% rename from src/main/java/at/reisinger/Credentials.java rename to src/main/java/at/reisinger/obj/Credentials.java index ebbb97d..7e38f32 100644 --- a/src/main/java/at/reisinger/Credentials.java +++ b/src/main/java/at/reisinger/obj/Credentials.java @@ -1,13 +1,14 @@ -package at.reisinger; +package at.reisinger.obj; /** - * at.reisinger.User Login Daten + * at.reisinger.obj.User Login Daten */ public class Credentials { - private String passwort, username; + private final String passwort; + private final String username; /** - * Startet einen neuen at.reisinger.User mit folgenden Daten + * Startet einen neuen at.reisinger.obj.User mit folgenden Daten * @param username Diesem Usernamen * @param passwort Diesem Passwort */ @@ -24,14 +25,6 @@ public class Credentials { return passwort; } -// /** -// * Setzt das at.reisinger.User Passwort -// * @param passwort Neues Passwort -// */ -// public void setPasswort(String passwort) { -// this.passwort = passwort; -// } - /** * Holt den Usernamen des Users * @return Username @@ -40,11 +33,4 @@ public class Credentials { return username; } -// /** -// * Setzt einen neuen Usernamen -// * @param username Neuer Username -// */ -// public void setUsername(String username) { -// this.username = username; -// } } diff --git a/src/main/java/at/reisinger/Package.java b/src/main/java/at/reisinger/obj/Package.java similarity index 73% rename from src/main/java/at/reisinger/Package.java rename to src/main/java/at/reisinger/obj/Package.java index edf6b3e..616e9a6 100644 --- a/src/main/java/at/reisinger/Package.java +++ b/src/main/java/at/reisinger/obj/Package.java @@ -1,20 +1,20 @@ -package at.reisinger; +package at.reisinger.obj; 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 + * at.reisinger.obj.Package besteht aus 4 Karten. Ist eine Erweiterung der at.reisinger.obj.Cards, zeigt für 4 at.reisinger.obj.Cards den Preis und einen Packagenamen an */ @JsonAutoDetect public class Package extends Cards{ @JsonProperty private String name; @JsonProperty - private int price; + private final int price; /** - * Erstellt ein neues at.reisinger.Package mit den gegebenen Stats - * @param stack at.reisinger.Cards des Packages + * Erstellt ein neues at.reisinger.obj.Package mit den gegebenen Stats + * @param stack at.reisinger.obj.Cards des Packages * @param name Name des Packages * @param price Price des Packages */ diff --git a/src/main/java/at/reisinger/TradingDeal.java b/src/main/java/at/reisinger/obj/TradingDeal.java similarity index 59% rename from src/main/java/at/reisinger/TradingDeal.java rename to src/main/java/at/reisinger/obj/TradingDeal.java index 0e748f0..f5a1241 100644 --- a/src/main/java/at/reisinger/TradingDeal.java +++ b/src/main/java/at/reisinger/obj/TradingDeal.java @@ -1,5 +1,7 @@ -package at.reisinger; +package at.reisinger.obj; +import at.reisinger.enums.CardType; +import at.reisinger.enums.ElementTyp; import at.reisinger.server.helper.EnumHelper; import com.fasterxml.jackson.annotation.*; @@ -9,7 +11,9 @@ import com.fasterxml.jackson.annotation.*; @JsonAutoDetect public class TradingDeal { @JsonProperty - private String id, username; + private final String id; + @JsonProperty + private final String username; @JsonProperty private Card cardToTrade; @JsonProperty @@ -22,10 +26,10 @@ public class TradingDeal { /** * Ein TradingDeal wird erstellt * @param id Id des Trading deals - * @param cardToTrade at.reisinger.Card die getauscht werden soll + * @param cardToTrade at.reisinger.obj.Card die getauscht werden soll * @param requiredElementType Req ElementType für den Tausch * @param requiredMinDamage Req min damage für den Tausch - * @param requiredCardType Req at.reisinger.Card Type für den Tausch + * @param requiredCardType Req at.reisinger.obj.Card Type für den Tausch */ public TradingDeal(String id, Card cardToTrade, ElementTyp requiredElementType, double requiredMinDamage, CardType requiredCardType, String username) { this.id = id; @@ -45,7 +49,7 @@ public class TradingDeal { /** * Ein TradingDeal wird erstellt, anhand des type werden der ElementType und der CardType automatisch bestimmt * @param id Id des Trading deals - * @param cardToTrade at.reisinger.Card die getauscht werden soll + * @param cardToTrade at.reisinger.obj.Card die getauscht werden soll * @param type ElementTyp und CardType in einem String. Beide Enums werden durch diesen String gewählt. * Wird kein passender Typ gefunden, dann bleibt diese Eigenschaft auf null */ @@ -62,14 +66,6 @@ public class TradingDeal { return id; } - /** - * Setzt die id des TradingDeals - * @param id Id des TradingDeals - */ - public void setId(String id) { - this.id = id; - } - /** * Holt den usernamen * @return Der username als String @@ -80,18 +76,8 @@ public class TradingDeal { } /** - * Setzt den usernamen - * @param username Der username als String - */ - @JsonSetter - public void setUsername(String username) { - this.username = username; - } - - - /** - * at.reisinger.Card die getraded werden soll - * @return at.reisinger.Card die getradet werden soll + * at.reisinger.obj.Card die getraded werden soll + * @return at.reisinger.obj.Card die getradet werden soll */ @JsonGetter public Card getCardToTrade() { @@ -118,24 +104,16 @@ public class TradingDeal { /** * Hole req cardtype - * @return Req at.reisinger.CardType + * @return Req at.reisinger.enums.CardType */ @JsonGetter public CardType getRequiredCardType() { return this.requiredCardType; } - /** - * Setzt den at.reisinger.User des Trades - * @param tradingUser at.reisinger.User der Traded - - public void setTradingUser(User tradingUser) { - this.tradingUser = tradingUser; - } -*/ /** * Setzt die Karte die Getradet werden soll - * @param cardToTrade at.reisinger.Card zum tauschen + * @param cardToTrade at.reisinger.obj.Card zum tauschen */ @JsonSetter public void setCardToTrade(Card cardToTrade) { @@ -162,7 +140,7 @@ public class TradingDeal { /** * Setzt req cardType - * @param requiredCardType Der Req at.reisinger.CardType + * @param requiredCardType Der Req at.reisinger.enums.CardType */ @JsonSetter public void setRequiredCardType(CardType requiredCardType) { @@ -170,37 +148,11 @@ public class TradingDeal { } /** - * Vom deal im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen - * @param checkDeal Von diesem Deal wird die CardToTrade geprüft - * @return True wenn der Deal passt - */ - public boolean dealOk(TradingDeal checkDeal){ - return this.cardOk(checkDeal.getCardToTrade()); - } - - /** - * Von der at.reisinger.Card im Parameter wird die at.reisinger.Card mit den Requirements von THIS verglichen - * @param checkCard at.reisinger.Card die mit dem Deal verglichen wird + * Von der at.reisinger.obj.Card im Parameter wird die at.reisinger.obj.Card mit den Requirements von THIS verglichen + * @param checkCard at.reisinger.obj.Card die mit dem Deal verglichen wird * @return True wenn der Deal passt */ public boolean cardOk(Card checkCard){ - System.out.println(checkCard.getCardType().equals(this.requiredCardType)); - System.out.println(checkCard.getCardType().toString()); - System.out.println(this.requiredCardType.toString()); - System.out.println(" "); - System.out.println(checkCard.getElementTyp().equals(this.requiredElementType)); - System.out.println(checkCard.getElementTyp().toString()); - System.out.println(this.requiredElementType); - System.out.println(" "); - System.out.println(checkCard.getDamage() >= this.requiredMinDamage); - System.out.println(checkCard.getDamage()); - System.out.println(this.requiredMinDamage); - if(checkCard.getCardType().equals(this.requiredCardType) && checkCard.getElementTyp().equals(this.requiredElementType) && checkCard.getDamage() >= this.requiredMinDamage){ - System.out.println("Da simma true"); - return true; - }else { - System.out.println("da simma false"); - return false; - } + return checkCard.getCardType().equals(this.requiredCardType) && (checkCard.getElementTyp().equals(this.requiredElementType) || this.requiredElementType.name().equalsIgnoreCase("undef")) && checkCard.getDamage() >= this.requiredMinDamage; } } diff --git a/src/main/java/at/reisinger/obj/User.java b/src/main/java/at/reisinger/obj/User.java new file mode 100644 index 0000000..1ec5edf --- /dev/null +++ b/src/main/java/at/reisinger/obj/User.java @@ -0,0 +1,163 @@ +package at.reisinger.obj; + +import com.fasterxml.jackson.annotation.*; + +import java.util.ArrayList; + +/** + * at.reisinger.obj.User & at.reisinger.Store Logik + */ +@JsonAutoDetect +public class User{ + @JsonProperty + private String name, nachname, email, bio, image; + //private DBConnection db; + @JsonProperty + private final Credentials credentials; + @JsonProperty + private final Coins coins; + + /* + * Erstellt einen neuen at.reisinger.obj.User + * @param credentials Zugangsdaten des Users + * @param name Name des Users + * @param nachname Nachname des Users + * @param email Email des Users + * @param stack Alle Karten des Users + * @param coins Alle Münzen des Users + + @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 at.reisinger.server.DBConnection(); + } +*/ + @JsonCreator + public User(@JsonProperty Credentials credentials,@JsonProperty String name,@JsonProperty String nachname,@JsonProperty String email,@JsonProperty Coins coins, @JsonProperty String bio, @JsonProperty String image) { + this.credentials = credentials; + this.name = name; + this.nachname = nachname; + this.email = email; + //this.stack = null; + this.coins = coins; + this.bio = bio; + this.image = image; + //this.db = new at.reisinger.server.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 die eindeutigen Logindaten des Users + * @return Eindeutige Logindaten + */ + @JsonGetter + public Credentials getCredentials() { + return credentials; + } + + /** + * Get Name of at.reisinger.obj.User + * @return Name of at.reisinger.obj.User + */ + @JsonGetter + public String getName() { + return this.name; + } + + /** + * Get Nachname of at.reisinger.obj.User + * @return Nachname of at.reisinger.obj.User + */ + @JsonGetter + public String getNachname() { + return this.nachname; + } + + /** + * Email of at.reisinger.obj.User + * @return Email of at.reisinger.obj.User + */ + @JsonGetter + public String getEmail() { + return this.email; + } + + /** + * Setzt den Namen des Users + * @param name Neuer Name des Users + */ + @JsonSetter + public void setName(String name) { + this.name = name; + } + + /** + * Setzt den Nachnamen + * @param nachname Neuer Nachname + */ + @JsonSetter + public void setNachname(String nachname) { + this.nachname = nachname; + } + + /** + * Setzt die Email des Users + * @param email Neue Email des Users + */ + @JsonSetter + public void setEmail(String email) { + this.email = email; + } + + //at.reisinger.Store Methoden + + /** + * Kauft ein at.reisinger.obj.Package + * @param mypackage at.reisinger.obj.Package welches gekauft werden soll + * @return Alle Karten des neuen at.reisinger.obj.Package + */ + public ArrayList buyPackage(Package mypackage){ + this.coins.removeCoin(mypackage.getPrice()); + return mypackage.getCards(); + } +} diff --git a/src/main/java/at/reisinger/DBConnection.java b/src/main/java/at/reisinger/server/DBConnection.java similarity index 71% rename from src/main/java/at/reisinger/DBConnection.java rename to src/main/java/at/reisinger/server/DBConnection.java index ef45c41..b97b333 100644 --- a/src/main/java/at/reisinger/DBConnection.java +++ b/src/main/java/at/reisinger/server/DBConnection.java @@ -1,5 +1,7 @@ -package at.reisinger; +package at.reisinger.server; +import at.reisinger.obj.*; +import at.reisinger.obj.Package; import at.reisinger.server.helper.JsonHelper; import at.reisinger.server.helper.PostgresHelper; @@ -14,8 +16,6 @@ import java.util.Map; * Die "Datenbank" sind hier nur beispieldaten. */ public class DBConnection { - //private ArrayList tradingDeals; - //private ArrayList packages; private Connection c; private Statement stmt; @@ -25,7 +25,7 @@ public class DBConnection { * Verbindungsaufbau zu einer DB */ public DBConnection() { - this.c = PostgresHelper.con(); + this.c = null; } /** @@ -41,10 +41,118 @@ public class DBConnection { PostgresHelper.executeUpdateMessage("create table IF NOT EXISTS trading(username text not null constraint trading_users_username_fk references users,id text not null constraint trading_pk primary key, cardtotrade text not null constraint trading_card_name_fk references card, mindamage float not null,reqcardtype text not null,reqelement text not null);", "Trading Table created"); PostgresHelper.executeUpdate("create table if not exists battle(usernamecreator text not null constraint battle_users_username_fk references users,usernameplayer text constraint battle_users_username_fk_2 references users, battleid serial, deckcreator text not null);"); PostgresHelper.executeUpdateMessage("create unique index if not exists battle_battleid_uindex on battle (battleid);", "Battle Table created"); - PostgresHelper.executeUpdate("create table IF NOT EXISTS battle_log(id int not null constraint battle_log_pk primary key, playerone text not null,playertwo text not null,playeronescore text not null,playertwoscore text not null);"); + PostgresHelper.executeUpdate("create table IF NOT EXISTS battle_log(id int not null constraint battle_log_pk primary key, playerone text not null,playertwo text not null,playeronescore text not null,playertwoscore text not null,log varchar(10485760));"); PostgresHelper.executeUpdateMessage("create unique index IF NOT EXISTS battle_log_id_uindex on battle_log (id);", "Battle_lgo Table created"); } + /** + * Holt alle BattleIds an denen der User beteiligt war + * @param username User der zu prüfen ist + * @return Null bei fehler, sonst eine List aus den IDs + */ + public ArrayList getAllBattleIdUser(String username){ + this.c = PostgresHelper.con(); + int id; + ArrayList battleIds = new ArrayList<>(); + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select id from battle_log where playerone = '" + username + "' or playertwo = '" + username + "';"); + while (rs.next()) { + id = rs.getInt("id"); + if (id > 0) { + System.out.println("BATTLE ID: " + id); + battleIds.add(id + ""); + }else { + return null; + } + } + rs.close(); + stmt.close(); + this.c.close(); + return battleIds; + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + return null; + } + } + + /** + * Holt die Letzte BattleId eines users + * @param username Userid die geprüft werden soll + * @return -1 bei error, sonst die letzte battleid des users + */ + public int getLastBattleIdUser(String username){ + this.c = PostgresHelper.con(); + int id; + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select max(id) from battle_log where playerone = '" + username + "' or playertwo = '" + username + "';"); + while (rs.next()) { + id = rs.getInt("max"); + System.out.println("select max(id) from battle_log where playerone = '" + username + "' or playerone = '" + username + "';"); + System.out.println("PREEEE IF ID: " + id); + if (id > 0) { + System.out.println("LAST BATTLE ID: " + id); + return id; + }else { + return -1; + } + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + return -1; + } + return -1; + } + + /** + * Holt das Battellog eines Bestimmten Battles + * @param battleId Id des battles + * @return Eine Map mit namen von player1 und player2, player1Score und player2Score und log + */ + public Map getBattleLog(String battleId){ + this.c = PostgresHelper.con(); + String playerone, playertwo, score1, score2, log; + int id; + try { + stmt = this.c.createStatement(); + ResultSet rs = stmt.executeQuery("select * from battle_log where id = " + battleId + ";"); + while (rs.next()) { + id = rs.getInt("id"); + playerone = rs.getString("playerone"); + playertwo = rs.getString("playertwo"); + score1 = rs.getString("playeronescore"); + score2 = rs.getString("playertwoscore"); + log = rs.getString("log"); + if (id > 0 && !playerone.isEmpty() && !playertwo.isEmpty() && !score1.isEmpty() && !score2.isEmpty() && !log.isEmpty()){ + Map map = new java.util.HashMap<>(Collections.emptyMap()); + map.put("playerone", playerone); + map.put("playertwo", playertwo); + map.put("playeronescore", score1); + map.put("playertwoscore", score2); + map.put("log", log); + map.put("id", id+""); + return map; + }else{ + System.out.println("GET BATTLE LOG WAS EMPTY"); + return null; + } + + } + rs.close(); + stmt.close(); + this.c.close(); + } catch (Exception e) { + System.err.println(e.getClass().getName() + ": " + e.getMessage()); + return null; + } + return null; + } + + /** * Fügt der Battle tabelle ein battle hinzu * @return True bei erfolg, sonst false @@ -56,8 +164,7 @@ public class DBConnection { if(deck != null && !deck.getCards().isEmpty()){ String deckJson = JsonHelper.objToJson(deck.getCards()); if (deckJson != null && !deckJson.isEmpty()){ - System.out.println("insert into battle (usernamecreator, deckcreator) VALUES (\'"+ usernamecreator + "\',\'" + deckJson +"\');"); - return PostgresHelper.executeUpdateMessage("insert into battle (usernamecreator, deckcreator) VALUES (\'"+ usernamecreator + "\',\'" + deckJson +"\');", "Battle created"); + return PostgresHelper.executeUpdateMessage("insert into battle (usernamecreator, deckcreator) VALUES ('" + usernamecreator + "','" + deckJson + "');", "Battle created"); }else { return false; } @@ -75,16 +182,14 @@ public class DBConnection { */ public Battle getOpenBattle(){ this.c = PostgresHelper.con(); - ArrayList tradingDeals = new ArrayList(); - int battleid = 0; - String usernamecreator = "", deckcreator = ""; + int battleid; + String usernamecreator; try { stmt = this.c.createStatement(); ResultSet rs = stmt.executeQuery("select * from battle limit 1;"); while (rs.next()) { battleid = rs.getInt("battleid"); usernamecreator = rs.getString("usernamecreator"); - deckcreator = rs.getString("deckcreator"); User player1 = new DBConnection().getUser(usernamecreator); if(player1 != null){ ArrayList deckPlayer1Arr = new DBConnection().getDeck(usernamecreator); @@ -122,7 +227,7 @@ public class DBConnection { * @return true bei erfolg sonst false */ public boolean delBattleEinladung(String battleid){ - return PostgresHelper.executeUpdateMessage("delete from battle where battleid = \'"+ battleid +"\';", "Battle req deleted"); + return PostgresHelper.executeUpdateMessage("delete from battle where battleid = '" + battleid + "';", "Battle req deleted"); } @@ -135,91 +240,12 @@ public class DBConnection { * @param playertwoscore Score vom Player 2 * @return true bei erfolg sonst false */ - public boolean addBattleLog(String id, String playerone, String playertwo, String playeronescore, String playertwoscore){ - return PostgresHelper.executeUpdate("insert into battle_log (id, playerone, playertwo, playeronescore, playertwoscore) VALUES ("+id+",\'"+playerone+"\',\'"+playertwo+"\',\'"+playeronescore+"\',\'"+playertwoscore+"\');"); + public boolean addBattleLog(String id, String playerone, String playertwo, String playeronescore, String playertwoscore, String log){ + return PostgresHelper.executeUpdate("insert into battle_log (id, playerone, playertwo, playeronescore, playertwoscore, log) VALUES ("+id+ ",'" +playerone+ "','" +playertwo+ "','" +playeronescore+ "','" +playertwoscore+ "','" +log+ "');"); } - /** - * Holt alle logs von allen battles - * @return Jedes Battle ist in einer Map mit namen von player1 und player2, player1Score und player2Score diese Map ist in einer ArrayList - */ - public ArrayList> getAllBattleLogs(){ - this.c = PostgresHelper.con(); - String player1Str, player2Str, scorePlayer1, scorePlayer2; - try { - stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery("select * from battle_log;"); - ArrayList> output = new ArrayList>(); - while (rs.next()) { - Map map = Collections.emptyMap(); - player1Str = rs.getString("playerone"); - player2Str = rs.getString("playertwo"); - scorePlayer1 = rs.getString("playeronescore"); - scorePlayer2 = rs.getString("playertwoscore"); - User player1 = new DBConnection().getUser(player1Str); - User player2 = new DBConnection().getUser(player2Str); - if(player1 != null && player2 != null){ - map.put("player1", player1); - map.put("player2", player2); - map.put("playeronescore", scorePlayer1); - map.put("playertwoscore", scorePlayer2); - output.add(map); - }else{ - return null; - } - } - rs.close(); - stmt.close(); - this.c.close(); - } catch (SQLException throwables) { - throwables.printStackTrace(); - return null; - } - return null; - } - - /** - * Holt das Battellog eines Bestimmten Battles - * @param battleid Id des battles - * @return Eine Map mit namen von player1 und player2, player1Score und player2Score - */ - public Map getBattleLog(String battleid){ - this.c = PostgresHelper.con(); - String player1Str, player2Str, scorePlayer1, scorePlayer2; - Map map = Collections.emptyMap(); - try { - stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery("select * from battle_log where id = \'" + battleid + "\';"); - while (rs.next()) { - player1Str = rs.getString("playerone"); - player2Str = rs.getString("playertwo"); - scorePlayer1 = rs.getString("playeronescore"); - scorePlayer2 = rs.getString("playertwoscore"); - - User player1 = new DBConnection().getUser(player1Str); - User player2 = new DBConnection().getUser(player2Str); - - if(player1 != null && player2 != null){ - map.put("player1", player1); - map.put("player2", player2); - map.put("playeronescore", scorePlayer1); - map.put("playertwoscore", scorePlayer2); - return map; - }else{ - return null; - } - } - rs.close(); - stmt.close(); - this.c.close(); - } catch (SQLException throwables) { - throwables.printStackTrace(); - return null; - } - return null; - } /** * Updated den Lock einer user card @@ -228,7 +254,7 @@ public class DBConnection { * @return true bei erfolg, sonst false */ public boolean updateCardLock(String name, boolean lock){ - return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = \'" + name + "\';"); + return PostgresHelper.executeUpdate("Update user_cards set gesperrt = " + lock + " where name = '" + name + "';"); } @@ -240,17 +266,15 @@ public class DBConnection { */ public boolean getCardLock(String name) throws SQLException { this.c = PostgresHelper.con(); - ArrayList tradingDeals = new ArrayList(); boolean locked = false; stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery("select gesperrt from user_cards where name = \'" + name + "\';"); + ResultSet rs = stmt.executeQuery("select gesperrt from user_cards where name = '" + name + "';"); while (rs.next()) { locked = rs.getBoolean("gesperrt"); } rs.close(); stmt.close(); this.c.close(); - System.out.println("Trading Deals pulled successfully"); return locked; } @@ -260,7 +284,7 @@ public class DBConnection { * @return True bei erfolg, sonst false */ public boolean deleteTradingDeal(String id){ - return PostgresHelper.executeUpdate("delete from trading where id = \'" + id + "\';"); + return PostgresHelper.executeUpdate("delete from trading where id = '" + id + "';"); } /** @@ -274,11 +298,7 @@ public class DBConnection { * @return True bei erfolg, sonst false */ public boolean addTradingdeal(String username, String id, double mindamage, String reqcardtype, String reqelement, String cardtotrade){ - if(PostgresHelper.executeUpdate("INSERT INTO public.trading (username, id, cardtotrade, mindamage, reqcardtype, reqelement) VALUES (\'" + username + "\',\'" + id + "\',\'" + cardtotrade + "\',\'"+ mindamage + "\',\'" + reqcardtype + "\',\'" + reqelement + "\');")){ - return true; - }else{ - return false; - } + return PostgresHelper.executeUpdate("INSERT INTO public.trading (username, id, cardtotrade, mindamage, reqcardtype, reqelement) VALUES ('" + username + "','" + id + "','" + cardtotrade + "','" + mindamage + "','" + reqcardtype + "','" + reqelement + "');"); } /** @@ -287,7 +307,7 @@ public class DBConnection { */ public ArrayList getAllTradingDeals(){ this.c = PostgresHelper.con(); - ArrayList tradingDeals = new ArrayList(); + ArrayList tradingDeals = new ArrayList<>(); try { stmt = this.c.createStatement(); ResultSet rs = stmt.executeQuery("select * from trading;"); @@ -304,12 +324,7 @@ public class DBConnection { Card card = new DBConnection().getCardFromID(cardtotrade); if(card != null){ TradingDeal tmp = new TradingDeal(id, card, mindamage, reqcardtype +reqelement, username); - if (tmp != null){ - tradingDeals.add(tmp); - System.out.println("Pulled TradingDeal"); - }else{ - return null; - } + tradingDeals.add(tmp); }else{ return null; } @@ -323,7 +338,6 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); return null; } - System.out.println("Trading Deals pulled successfully"); return tradingDeals; } @@ -344,27 +358,34 @@ public class DBConnection { return false; } } - if (!delDeck(username)){ - return false; - } Cards allCards = getCards(username); - Cards deckCards = new Cards(new ArrayList()); + Cards deckCards = new Cards(new ArrayList<>()); int count = 0; - if(allCards != null){ + if(allCards != null && deck.size() == 4){ for (String st : deck) { for (Card ca: allCards.getCards()) { - System.out.println("Count : " + count); - System.out.println("CA: " + ca.getName() + " st: " + st); if(ca.getName().equals(st) && count < 4){ + if(deckCards.getCards().size() == 0){ + if (!delDeck(username)){ + return false; + } + } deckCards.addCard(ca); - if(!PostgresHelper.executeUpdateMessage("INSERT INTO public.user_deck (username, cardname) VALUES (\'"+username+"\', \'"+st+"\');", "Card #"+count+" added to Deck")){ - return false; + if(deckCards.getCards().size() == 4){ + int c = 0; + for(Card cardtmp : deckCards.getCards()){ + c++; + if(!PostgresHelper.executeUpdateMessage("INSERT INTO public.user_deck (username, cardname) VALUES ('" +username+ "', '" +cardtmp.getName()+ "');", "Card #"+c+" added to Deck")){ + return false; + } + } + return true; } } } count++; } - return true; + return false; } return false; } @@ -376,16 +397,14 @@ public class DBConnection { */ public ArrayList getDeck(String username){ this.c = PostgresHelper.con(); - String cardname = ""; - Cards allCards = new Cards(new ArrayList()); - ArrayList cardnamenarray = new ArrayList(); + String cardname; + ArrayList cardnamenarray = new ArrayList<>(); try { stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery("select * from user_deck where username = \'" + username + "\';"); + ResultSet rs = stmt.executeQuery("select * from user_deck where username = '" + username + "';"); while (rs.next()) { cardname = rs.getString("cardname"); cardnamenarray.add(cardname); - System.out.println("cardname = " + cardname); } rs.close(); stmt.close(); @@ -394,7 +413,6 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); return null; } - System.out.println("Deck names pulled successfully"); return cardnamenarray; } @@ -404,7 +422,7 @@ public class DBConnection { * @return True bei erfolg, sonst false */ public boolean delDeck(String username){ - return PostgresHelper.executeUpdateMessage("delete from user_deck where username = \'" + username + "\';", "User Deck: " + username + ", deleted"); + return PostgresHelper.executeUpdateMessage("delete from user_deck where username = '" + username + "';", "User Deck: " + username + ", deleted"); } @@ -419,7 +437,9 @@ public class DBConnection { if (!(coins - 5 >= 0)) { return null; } - updateCoins(coins - 5, username); + if(!updateCoins(coins - 5, username)){ + return null; + } this.c = PostgresHelper.con(); String id = ""; @@ -436,18 +456,14 @@ public class DBConnection { 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()); + String packagename = "", cardname, elementtyp, cardtype; + int damage; + Cards cards = new Cards(new ArrayList<>()); 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; + 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 + "';"); while (rs.next()) { - System.out.println(count++); - zeilennummer = rs.getInt("zeilennummer"); id = rs.getString("id"); packagename = rs.getString("packagename"); cardname = rs.getString("cardname"); @@ -467,11 +483,12 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); return null; } - System.out.println("Package pulled successfully"); - deletePackage(id); + if(!deletePackage(id)){ + return null; + } - if (cards.getCards().size() != 0 && cards != null) { - return new Package(cards, packagename, 5); + if (cards.getCards().size() != 0) { + return new at.reisinger.obj.Package(cards, packagename, 5); } else { return null; } @@ -484,7 +501,7 @@ public class DBConnection { * @return True bei erfolg, sonst false */ public boolean delUserCard(String username, String cardname){ - return PostgresHelper.executeUpdate("delete from user_cards where username = \'"+username+"\' and name = \'"+cardname+"\';"); + return PostgresHelper.executeUpdate("delete from user_cards where username = '" +username+ "' and name = '" +cardname+ "';"); } /** @@ -497,7 +514,7 @@ public class DBConnection { Connection b = PostgresHelper.con(); try { stmt = b.createStatement(); - String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( \'" + username + "\',\'" + cardName + "\', \'false\');"; + String sql = "INSERT INTO public.user_cards (username, name, gesperrt) VALUES ( '" + username + "','" + cardName + "', 'false');"; stmt.executeUpdate(sql); stmt.close(); b.close(); @@ -505,7 +522,6 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); return false; } - System.out.println("User got Card successfully"); return true; } /** @@ -515,7 +531,7 @@ public class DBConnection { * @return True bei erfolg, sonst false */ public boolean deletePackage(String name) { - return PostgresHelper.executeUpdateMessage("DELETE FROM package WHERE \"ID\" = \'" + name + "\';", "Package deleted successfully"); + return PostgresHelper.executeUpdateMessage("DELETE FROM package WHERE \"ID\" = '" + name + "';", "Package deleted successfully"); } @@ -526,7 +542,7 @@ public class DBConnection { * @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"); + return PostgresHelper.executeUpdateMessage("UPDATE users SET coins = " + coins + " WHERE username = '" + username + "';", "Coins Updated"); } /** @@ -535,12 +551,11 @@ public class DBConnection { * @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 + "\';"); + ResultSet rs = stmt.executeQuery("Select coins from users where username = '" + username + "';"); while (rs.next()) { coins = rs.getInt("coins"); } @@ -548,11 +563,9 @@ public class DBConnection { 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; } @@ -567,7 +580,7 @@ public class DBConnection { int count = 0; try { stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery("select count(*) from card where name = \'" + name + "\';"); + ResultSet rs = stmt.executeQuery("select count(*) from card where name = '" + name + "';"); while (rs.next()) { count = rs.getInt("count"); } @@ -578,11 +591,7 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); System.exit(0); } - if (count == 1) { - return true; - } else { - return false; - } + return count == 1; } /** @@ -592,7 +601,7 @@ public class DBConnection { * @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"); + return PostgresHelper.executeUpdateMessage("insert into card (NAME, DAMAGE, ELEMENTTYP, CARDTYPE) values ('" + card.getName() + "','" + card.getDamage() + "','" + card.getElementTyp().name() + "','" + card.getCardType().name() + "')", "Card added"); } /** @@ -630,14 +639,14 @@ public class DBConnection { * @param pack Pack welches hinzugefügt werden soll * @return True bei erfolg, false bei fehler */ - public boolean addPackage(Package pack) { + public boolean addPackage(at.reisinger.obj.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")){ + if(!PostgresHelper.executeUpdateMessage("INSERT INTO package (\"ID\", \"name\") values ('" + pack.getName() + "','" + ca.getName() + "');", "Card zu Package hinzugefügt")){ return false; } } @@ -654,7 +663,7 @@ public class DBConnection { * @return True wenn alles erfolgreich war, false wenn es nicht erfolgreich war */ public boolean addUser(String username, String password, String nachname, String email, String bio, String image) { - return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password, bio, image) values (\'" + username + "\',\'" + nachname + "\',\'" + email + "\',\'" + password + "\',\'" + bio + "\',\'" + image + "\')", "User added"); + return PostgresHelper.executeUpdateMessage("INSERT INTO users (username, nachname, email, password, bio, image) values ('" + username + "','" + nachname + "','" + email + "','" + password + "','" + bio + "','" + image + "')", "User added"); } /** @@ -666,12 +675,7 @@ public class DBConnection { * @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 \'#\'"); + return PostgresHelper.executeUpdate("UPDATE public.users SET nachname = '" + name+ "', bio = '" +bio+ "', image = '" +image+ "' WHERE username LIKE '" +username+ "' ESCAPE '#'"); } /** @@ -680,17 +684,15 @@ public class DBConnection { * * @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 { + public User getUser(String uname){ this.c = PostgresHelper.con(); - String username = "", password = "", email = "", nachname = "", bio="", image=""; + String username = "", password = "", email = "", bio="", image=""; try { stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery("SELECT * FROM users where username = \'" + uname + "\';"); + 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"); @@ -703,7 +705,6 @@ public class DBConnection { 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); } @@ -713,20 +714,15 @@ public class DBConnection { * @return Null bei error */ public Card getCardFromID(String id){ - System.out.println(id); Connection b = PostgresHelper.con(); Card toreturn = null; try { stmt = b.createStatement(); - ResultSet rs = stmt.executeQuery("select * from card where NAME = \'" + id + "\';"); + ResultSet rs = stmt.executeQuery("select * from card where NAME = '" + id + "';"); while (rs.next()) { int damage =rs.getInt("damage"); String elementtyp =rs.getString("elementtyp"); String cardtype=rs.getString("cardtype"); - System.out.println("damage = " + damage); - System.out.println("elementtyp = " + elementtyp); - System.out.println("cardtype = " + cardtype); - System.out.println(); toreturn = new Card(id, elementtyp+cardtype, damage); } rs.close(); @@ -736,13 +732,7 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); return null; } - if (toreturn != null){ - System.out.println("Card pulled successfully"); - return toreturn; - }else { - System.out.println("Card NOT pulled"); - return null; - } + return toreturn; } /** @@ -751,20 +741,16 @@ public class DBConnection { * @return Falls null, dann war ein error */ public Cards getCardsFromIDList(List cardnamenarray){ - Cards allCards = new Cards(new ArrayList()); + Cards allCards = new Cards(new ArrayList<>()); for (String st : cardnamenarray) { Connection b = PostgresHelper.con(); try { stmt = b.createStatement(); - ResultSet rs = stmt.executeQuery("select * from card where NAME = \'" + st + "\';"); + 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(); @@ -774,7 +760,6 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); return null; } - System.out.println("Card pulled successfully"); } return allCards; } @@ -786,18 +771,14 @@ public class DBConnection { */ public Cards getCards(String username){ this.c = PostgresHelper.con(); - String cardname = ""; - boolean locked; - Cards allCards = new Cards(new ArrayList()); - ArrayList cardnamenarray = new ArrayList(); + String cardname; + ArrayList cardnamenarray = new ArrayList<>(); try { stmt = this.c.createStatement(); - ResultSet rs = stmt.executeQuery("select * from user_cards where username = \'" + username + "\';"); + ResultSet rs = stmt.executeQuery("select * from user_cards where username = '" + username + "';"); while (rs.next()) { cardname = rs.getString("name"); - locked = rs.getBoolean("gesperrt"); cardnamenarray.add(cardname); - System.out.println("cardname = " + cardname); } rs.close(); stmt.close(); @@ -806,26 +787,6 @@ public class DBConnection { System.err.println(e.getClass().getName() + ": " + e.getMessage()); return null; } - System.out.println("Card Namen pulled successfully"); return getCardsFromIDList(cardnamenarray); } - - /** - * Holt alle verfügbaren TradingDeals - * - * @return Alle Trading Deals - - public ArrayList getAllTradingDeals() { - return this.tradingDeals; - } - - /** - * Fügt einen neuen Tradingdeal zum at.reisinger.Store hinzu - * - * @param tradingDeal Der neue Deal - - public void addTradingDeal(TradingDeal tradingDeal) { - this.tradingDeals.add(tradingDeal); - } -*/ } diff --git a/src/main/java/at/reisinger/server/Main.java b/src/main/java/at/reisinger/server/Main.java index b581fb8..54d3280 100644 --- a/src/main/java/at/reisinger/server/Main.java +++ b/src/main/java/at/reisinger/server/Main.java @@ -1,6 +1,5 @@ package at.reisinger.server; -import at.reisinger.DBConnection; import at.reisinger.server.objects.Request; import at.reisinger.server.objects.Response; @@ -15,18 +14,15 @@ import java.net.Socket; public class Main { static final int port = 80; private Socket socket; - private int id; /** * Initial Start * @param args Nicht Verwendet */ public static void main(String[] args) { - System.out.println("DB init"); new DBConnection().init(); System.out.println("\n\nStarte Server auf Port " + port + "\n\n"); new Main(port); - } /** @@ -34,12 +30,9 @@ public class Main { * @param port Port auf dem der Server läuft */ public Main(int port){ - ServerSocket serverSocket = null; + ServerSocket serverSocket; try { serverSocket = new ServerSocket(port); - - //this.msgHandler = new MsgHandler(); - //this.id = 0; while (true){ this.socket = serverSocket.accept(); requestResponding(); @@ -54,14 +47,11 @@ public class Main { */ public void requestResponding(){ try{ - System.out.println("Socket von Client #" + this.id + " wurde gestartet!"); - Request rq = new Request(this.socket, this.id); - System.out.println("req done"); - new Response(this.id, rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload()); - System.out.println("res done"); - //this.msgHandler = rp.getMsghandler(); + System.out.println("Socket wurde gestartet!"); + Request rq = new Request(this.socket); + new Response(rq.getUrl(), rq.getCmd(), rq.getOut(), rq.getAuthString(), rq.getPayload()); this.socket.close(); - System.out.println("Socket von Client #" + this.id + " wurde geschlossen!"); + System.out.println("Socket wurde geschlossen!"); }catch (IOException e){ e.printStackTrace(); } diff --git a/src/main/java/at/reisinger/server/helper/EnumHelper.java b/src/main/java/at/reisinger/server/helper/EnumHelper.java index 3bbe03d..55c5e4b 100644 --- a/src/main/java/at/reisinger/server/helper/EnumHelper.java +++ b/src/main/java/at/reisinger/server/helper/EnumHelper.java @@ -1,7 +1,7 @@ package at.reisinger.server.helper; -import at.reisinger.CardType; -import at.reisinger.ElementTyp; +import at.reisinger.enums.CardType; +import at.reisinger.enums.ElementTyp; /** * Hilft beim manipulieren von enums diff --git a/src/main/java/at/reisinger/server/helper/JsonHelper.java b/src/main/java/at/reisinger/server/helper/JsonHelper.java index 507cff3..2bb21bd 100644 --- a/src/main/java/at/reisinger/server/helper/JsonHelper.java +++ b/src/main/java/at/reisinger/server/helper/JsonHelper.java @@ -1,14 +1,10 @@ package at.reisinger.server.helper; -import at.reisinger.Card; -import at.reisinger.Cards; -import at.reisinger.Package; -import at.reisinger.User; +import at.reisinger.obj.User; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; -import java.util.ArrayList; import java.util.List; import java.util.Map; @@ -18,24 +14,12 @@ import java.util.Map; public class JsonHelper { /** - * Wandelt ein Package in form einer ArrayList 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 listCards, String name){ - Package packageCards = new Package(new Cards(listCards),name, 5); - return objToJson(packageCards); - } - - /** - * Wandelt ein Package Objekt in ein Json um + * Wandelt ein 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 { @@ -49,29 +33,6 @@ public class JsonHelper { } } - /** - * Json wird in ein Card Objekt umgewandelt - * @param json Json das umgewandelt werden soll - * @return Null bei JsonProcessingException - */ - public static Card jsonToCard(String json){ - ObjectMapper objectMapper = new ObjectMapper(); - Card card = null; - try { - card = objectMapper.readValue(json, Card.class); - if(card != null) { - return card; - }else{ - return null; - } - } catch (JsonProcessingException e) { - e.printStackTrace(); - return null; - } - } - - - /** * Json zu List * @param payload Json String @@ -80,7 +41,8 @@ public class JsonHelper { public static List jsonPayloadToList(String payload){ ObjectMapper objectMapper = new ObjectMapper(); try { - return objectMapper.readValue(payload, new TypeReference>(){}); + return objectMapper.readValue(payload, new TypeReference<>() { + }); } catch (JsonProcessingException e) { e.printStackTrace(); return null; @@ -95,14 +57,19 @@ public class JsonHelper { public static Map jsonPayloadToMap(String payload){ ObjectMapper objectMapper = new ObjectMapper(); try { - return objectMapper.readValue(payload, new TypeReference>(){}); + return objectMapper.readValue(payload, new TypeReference<>() { + }); } catch (JsonProcessingException e) { e.printStackTrace(); return null; } } - @Deprecated + /** + * Wandelt ein Objekt in ein Json um + * @param user Objekt das in ein Json umgewandelt werden soll + * @return Json String des Packages + */ public static String userToJson(User user){ return objToJson(user); } diff --git a/src/main/java/at/reisinger/server/helper/PostgresHelper.java b/src/main/java/at/reisinger/server/helper/PostgresHelper.java index e773291..40e1b4d 100644 --- a/src/main/java/at/reisinger/server/helper/PostgresHelper.java +++ b/src/main/java/at/reisinger/server/helper/PostgresHelper.java @@ -23,7 +23,6 @@ public class PostgresHelper { } catch (Exception e) { e.printStackTrace(); System.err.println(e.getClass().getName() + ": " + e.getMessage()); - System.exit(0); } return c; } diff --git a/src/main/java/at/reisinger/server/helper/ResponseHelper.java b/src/main/java/at/reisinger/server/helper/ResponseHelper.java new file mode 100644 index 0000000..e6cabc9 --- /dev/null +++ b/src/main/java/at/reisinger/server/helper/ResponseHelper.java @@ -0,0 +1,23 @@ +package at.reisinger.server.helper; + +/** + * Einige helper Funktionen der Respone Class + */ +public class ResponseHelper { + + public static StringBuilder logLineBreak(String log){ + StringBuilder resString = new StringBuilder(); + for (char lo: log.toCharArray()){ + if(lo == ','){ + resString.append("\n"); + }else if(lo == '['){ + resString.append("\n"); + }else if(lo == ']'){ + resString.append("\n"); + }else { + resString.append(lo); + } + } + return resString; + } +} diff --git a/src/main/java/at/reisinger/server/objects/Request.java b/src/main/java/at/reisinger/server/objects/Request.java index e4b703b..87b9df9 100644 --- a/src/main/java/at/reisinger/server/objects/Request.java +++ b/src/main/java/at/reisinger/server/objects/Request.java @@ -6,6 +6,7 @@ import java.io.InputStreamReader; import java.io.PrintStream; import java.net.Socket; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; /** @@ -14,29 +15,23 @@ import java.util.List; */ public class Request { - private final Socket socket; - private final int id; - private PrintStream out; - private String cmd; - private String url; - private final StringBuilder rqBuilder; - private String payload; - private String authString; + private final PrintStream out; + private final String cmd; + private final String url; + private final String payload; + private final String authString; /** - * Get Request + * Besorgt alle nötigen infos aus dem 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()); + public Request(Socket socket) throws IOException { + StringBuilder rqBuilder = new StringBuilder(); + this.out = new PrintStream(socket.getOutputStream()); BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream())); String line = bufferedReader.readLine(); while (!line.isBlank()) { - rqBuilder.append(line + "\r\n"); + rqBuilder.append(line).append("\r\n"); line = bufferedReader.readLine(); System.out.println(line); } @@ -59,11 +54,7 @@ public class Request { 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); - } + List headers = new ArrayList<>(Arrays.asList(requestsLines).subList(2, requestsLines.length)); @@ -73,11 +64,11 @@ public class Request { if(headers.toString().contains("Authorization: Basic")) { int authIndex = headers.toString().indexOf("Authorization: Basic"); String authString = headers.toString().substring(authIndex + 21); - System.out.println("AUTH STRING: " + authString); int authIndexEnd = authString.indexOf(','); - System.out.println("INDEX OF: " + authIndexEnd); + if(authIndexEnd == -1){ + authIndexEnd = authString.indexOf(']'); + } authString = authString.substring(0, authIndexEnd); - System.out.println("AUTH STRING: " + authString); this.authString = authString; }else{ diff --git a/src/main/java/at/reisinger/server/objects/Response.java b/src/main/java/at/reisinger/server/objects/Response.java index 80928e3..9efaa68 100644 --- a/src/main/java/at/reisinger/server/objects/Response.java +++ b/src/main/java/at/reisinger/server/objects/Response.java @@ -1,79 +1,73 @@ package at.reisinger.server.objects; -import at.reisinger.*; -import at.reisinger.Package; +import at.reisinger.obj.*; +import at.reisinger.obj.Package; +import at.reisinger.server.DBConnection; import at.reisinger.server.helper.JsonHelper; -import at.reisinger.server.helper.PostgresHelper; +import at.reisinger.server.helper.ResponseHelper; 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; +import java.util.*; /** * Erstellt und sendet eine Response anhand des Requests * @author Georg Reisinger */ public class Response { - - //private final Socket socket; - private final int id; - private PrintStream out; - private String cmd; - private String url; - private String payload; - private String authString; + private final PrintStream out; + private final String url; + private final String payload; + private final String authString; /** * Nimmt die Daten des requests und generiert eine Response - * @param id Thread Id * @param url Request Url * @param cmd Request CMD * @param out out Print Stream * @param authString Der MsgHandler * @param payload Payload des Requests */ - public Response(int id, String url, String cmd, PrintStream out, String authString, String payload){ - this.id = id; + public Response(String url, String cmd, PrintStream out, String authString, String payload){ this.authString = authString; this.url = url; - this.cmd = cmd; this.out = out; this.payload = payload; if (this.url != null) { - if (this.cmd.equals("GET")) { - if(login()) { - getMethodes(); - }else{ - sendError("401"); - } - }else if (this.cmd.equals("POST")){ - try { - postMethodes(); - } catch (JsonProcessingException e) { - e.printStackTrace(); - } - }else if (this.cmd.equals("PUT")){ - if(login()) { - putMethodes(); - }else{ - sendError("401"); - } - }else if (this.cmd.equals("DELETE")){ - if(login()) { - deleteMethodes(); - }else{ - sendError("401"); - } - }else{ - sendError("405"); + switch (cmd) { + case "GET": + if (login()) { + getMethodes(); + } else { + sendResponse("Login Error", "401"); + } + break; + case "POST": + try { + postMethodes(); + } catch (JsonProcessingException e) { + e.printStackTrace(); + } + break; + case "PUT": + if (login()) { + putMethodes(); + } else { + sendResponse("Login Error", "401"); + } + break; + case "DELETE": + if (login()) { + deleteMethodes(); + } else { + sendResponse("Login Error", "401"); + } + break; + default: + sendResponse("", "405"); + break; } } } @@ -85,21 +79,15 @@ public class Response { private void getMethodes(){ if (this.url.startsWith("/users")) { String username = this.url.substring(this.url.lastIndexOf('/') + 1); - System.out.println("Username in /users/{username}: " + username); - User user = null; - try { - user = new DBConnection().getUser(username); - } catch (SQLException throwables) { - throwables.printStackTrace(); - sendError("401"); - } + User user; + user = new DBConnection().getUser(username); if (user != null){ String userJson = JsonHelper.userToJson(user); if(userJson != null && !userJson.isEmpty()){ sendResponse(userJson, "200"); } }else{ - sendError("500"); + sendResponse("", "500"); } } else if (this.url.startsWith("/cards")) { String username = basicAuthGetUsername(this.authString); @@ -108,15 +96,14 @@ public class Response { if (jsonCards != null && !jsonCards.isEmpty()){ sendResponse(jsonCards, "200"); }else{ - sendError("500"); + sendResponse("", "500"); } }else if(this.url.startsWith("/deck")) { String format = this.url.substring(this.url.lastIndexOf('?') + 1); - System.out.println("Format in /deck?{format=plain}: " + format); String username = basicAuthGetUsername(this.authString); ArrayList allCards = new DBConnection().getDeck(username); - Cards deck = null; - Object tmp = null; + Cards deck; + Object tmp; if(format.startsWith("format=plain")){ tmp = allCards; }else{ @@ -127,22 +114,62 @@ public class Response { if (jsonCards != null && !jsonCards.isEmpty()) { sendResponse(jsonCards, "200"); } else { - sendError("500"); + sendResponse("", "500"); } }else if(this.url.startsWith("/tradings")) { ArrayList allDeals = new DBConnection().getAllTradingDeals(); if(allDeals != null && !allDeals.isEmpty()){ String json = JsonHelper.objToJson(allDeals); - if(json != null && json != ""){ + if(json != null && !json.equals("")){ sendResponse(json, "200"); }else{ - sendError("500"); + sendResponse("", "500"); } }else{ - sendError("500"); + sendResponse("", "500"); + } + }else if(this.url.startsWith("/score")) { + String username = basicAuthGetUsername(this.authString); + if (username != null && !username.isEmpty()){ + int lastBallteId = new DBConnection().getLastBattleIdUser(username); + if (lastBallteId > -1){ + Map map = new DBConnection().getBattleLog(lastBallteId + ""); + if(map != null && !map.isEmpty()){ + sendResponse("BATTLE #" + map.get("id") + "\nSCORE\n" + map.get("playerone") + "(#Player1) |vs| " + map.get("playertwo") + "(#Player2) \n" + map.get("playeronescore") + "(#Player1) |vs| " + map.get("playertwoscore") + "(#Player2) \nGame LOG:\n" + ResponseHelper.logLineBreak(map.get("log")), "200"); + }else { + sendResponse("Konnte Battle log nicht holen", "500"); + } + }else { + sendResponse("Last Battle ID error", "500"); + } + + }else{ + sendResponse("Login Error", "401"); + } + }else if(this.url.startsWith("/stats")) { + String username = basicAuthGetUsername(this.authString); + if (username != null && !username.isEmpty()) { + ArrayList battleIds = new DBConnection().getAllBattleIdUser(username); + if (battleIds != null && !battleIds.isEmpty()){ + StringBuilder resString = new StringBuilder(); + for(String i : battleIds){ + Map map = new DBConnection().getBattleLog(i + ""); + if(map != null && !map.isEmpty()){ + resString = new StringBuilder("BATTLE #" + map.get("id") + "\nSCORE\n" + map.get("playerone") + "(#Player1) |vs| " + map.get("playertwo") + "(#Player2) \n" + map.get("playeronescore") + "(#Player1) |vs| " + map.get("playertwoscore") + "(#Player2) \nGame LOG:\n"); + resString.append(ResponseHelper.logLineBreak(map.get("log"))); + }else { + sendResponse("Konnte Battle log nicht holen", "500"); + } + } + sendResponse(resString.toString(), "200"); + }else { + sendResponse("Konnte Battle ids ned holen", "500"); + } + }else{ + sendResponse("Login Error", "401"); } }else{ - sendError("204"); + sendResponse("", "204"); } } @@ -155,10 +182,7 @@ public class Response { */ private boolean basicAuth(String username, String password, String compareTo){ String authStringEnc = basicAuthBase64(username, password); - if (compareTo.equals(authStringEnc)){ - return true; - } - return false; + return compareTo.equals(authStringEnc); } /** @@ -170,8 +194,7 @@ public class Response { 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; + return new String(authEncBytes); } /** @@ -188,7 +211,7 @@ public class Response { }else{ values = null; } - return values[0]; + return Objects.requireNonNull(values)[0]; } /** @@ -201,84 +224,77 @@ public class Response { private void postMethodes() throws JsonProcessingException { if (this.url.startsWith("/users")) { Map map = JsonHelper.jsonPayloadToMap(this.payload); - String username = (String) map.get("Username"); + String username = (String) Objects.requireNonNull(map).get("Username"); String password = (String) map.get("Password"); User newUser = new User(new Credentials(username, password), username, username, "not implemented", new Coins(20), "BIO", "IMAGE"); - System.out.println("CON DB"); DBConnection con = new DBConnection(); if(!con.addUser(newUser.getCredentials().getUsername(), newUser.getCredentials().getPasswort(), newUser.getCredentials().getUsername(), newUser.getEmail(), newUser.getBio(), newUser.getImage())){ - sendError("409"); + sendResponse("", "409"); } - String userJson = JsonHelper.userToJson(newUser);; + String userJson = JsonHelper.userToJson(newUser); if(userJson != null) { sendResponse(userJson, "201"); }else{ - sendError("500"); + sendResponse("", "500"); } }else if (this.url.startsWith("/sessions")) { Map map = JsonHelper.jsonPayloadToMap(this.payload); - String username = (String) map.get("Username"); + String username = (String) Objects.requireNonNull(map).get("Username"); String password = (String) map.get("Password"); - User user = null; + User user; DBConnection con = new DBConnection(); - try { - user = con.getUser(username); - } catch (SQLException throwables) { - throwables.printStackTrace(); - } + user = con.getUser(username); String authString = basicAuthBase64(user.getCredentials().getUsername(), user.getCredentials().getPasswort()); if(basicAuth(username, password, authString)){ sendResponse(authString, "200"); }else{ - sendError("401"); + sendResponse("Login Error", "401"); } }else if (this.url.startsWith("/packages")) { if (basicAuth("admin", "istrator", this.authString)) { ObjectMapper objectMapper = new ObjectMapper(); - ArrayList listCards = objectMapper.readValue(this.payload, new TypeReference>() { + ArrayList listCards = objectMapper.readValue(this.payload, new TypeReference<>() { }); Package packageCards = new Package(new Cards(listCards), new DBConnection().nextPackageId() + "", 5); if (!new DBConnection().addPackage(packageCards)) { - sendError("500"); + sendResponse("", "500"); } else { String packageJson = JsonHelper.objToJson(packageCards); if (packageJson != null) { sendResponse(packageJson, "201"); } else { - sendError("500"); + sendResponse("", "500"); } } } else { - sendError("401"); + sendResponse("Login Error", "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"); + sendResponse("", "500"); } else { String packageJson = JsonHelper.objToJson(newPackage); if (packageJson == null) { - sendError("500"); + sendResponse("", "500"); } else { sendResponse(packageJson, "200"); } } }else{ - sendError("401"); + sendResponse("Login Error", "401"); } }else if (this.url.startsWith("/tradings")) { if(login()) { String dotradeid = this.url.substring(this.url.lastIndexOf('/') + 1); - System.out.println("DO TradeID in /tradings/{tradeID}: " + dotradeid); - if (!dotradeid.isEmpty() && dotradeid != null && !dotradeid.equals("tradings")) { + if (!dotradeid.isEmpty() && !dotradeid.equals("tradings")) { //DO TRADE String username = basicAuthGetUsername(this.authString); if (username != null && !username.isEmpty()) { - System.out.println(this.payload); ArrayList tradingDealArrayList = new DBConnection().getAllTradingDeals(); TradingDeal tradingDeal = null; if (tradingDealArrayList != null && !tradingDealArrayList.isEmpty()) { @@ -300,83 +316,74 @@ public class Response { if (new DBConnection().addUserCard(tradingDeal.getUsername(), card.getName())) { sendResponse(json, "200"); } else { - sendError("500"); + sendResponse("ERROR --> Add Card to: " + tradingDeal.getUsername(), "500"); } } else { - sendError("500"); + sendResponse("ERROR --> Del Card from: " + username, "500"); } } else { - sendError("500"); + sendResponse("Error --> Del Trading Deal", "500"); } } else { - sendError("500"); + sendResponse("ERROR --> Del Card from: " + tradingDeal.getUsername(), "500"); } } else { - sendError("500"); + sendResponse("ERROR --> Add Card to: " + username, "500"); } } else { - sendError("500"); + sendResponse("ERROR --> JSON Empty", "500"); } } else { - sendError("500"); + sendResponse("ERROR --> Trading Deal not ok", "500"); } } else { - sendError("500"); + sendResponse("ERROR --> Trading Deal not exist", "500"); } } else { - sendError("500"); + sendResponse("ERROR --> Card not exist", "500"); } } else { - sendError("500"); + sendResponse("ERROR --> Trading Deal not exist", "500"); } } else { - sendError("401"); + sendResponse("ERROR --> Username empty", "401"); } } else { //CREATE TRADING DEAL Map map = JsonHelper.jsonPayloadToMap(this.payload); - String id = (String) map.get("Id"); + String id = (String) Objects.requireNonNull(map).get("Id"); String cardtotrade = (String) map.get("CardToTrade"); String type = (String) map.get("Type"); double mindamage = Double.parseDouble(map.get("MinimumDamage") + ""); String username = basicAuthGetUsername(this.authString); if (username != null) { Card cardtoTradeC = new DBConnection().getCardFromID(cardtotrade); - System.out.println("CARD TO TRAD: " + cardtoTradeC.getName()); if (cardtoTradeC != null) { TradingDeal tradingDeal = new TradingDeal(id, cardtoTradeC, mindamage, type, username); - if (tradingDeal != null) { - String tradingJson = JsonHelper.objToJson(tradingDeal); - if (tradingDeal != null) { - ArrayList deckCards = new DBConnection().getDeck(username); - if (deckCards != null) { - if (deckCards.contains(cardtotrade)) { - new DBConnection().delDeck(username); - } - if (new DBConnection().addTradingdeal(tradingDeal.getUsername(), tradingDeal.getId(), tradingDeal.getRequiredMinDamage(), tradingDeal.getRequiredCardType().name(), tradingDeal.getRequiredElementType().name(), tradingDeal.getCardToTrade().getName())) { - if (new DBConnection().updateCardLock(tradingDeal.getCardToTrade().getName(), true)) { - sendResponse(JsonHelper.objToJson(tradingDeal), "201"); - } else { - sendError("500"); - } - } else { - sendError("500"); - } + String tradingJson = JsonHelper.objToJson(tradingDeal); + ArrayList deckCards = new DBConnection().getDeck(username); + if (deckCards != null) { + if (deckCards.contains(cardtotrade)) { + new DBConnection().delDeck(username); + } + if (new DBConnection().addTradingdeal(tradingDeal.getUsername(), tradingDeal.getId(), tradingDeal.getRequiredMinDamage(), tradingDeal.getRequiredCardType().name(), tradingDeal.getRequiredElementType().name(), tradingDeal.getCardToTrade().getName())) { + if (new DBConnection().updateCardLock(tradingDeal.getCardToTrade().getName(), true)) { + sendResponse(Objects.requireNonNull(JsonHelper.objToJson(tradingDeal)), "201"); } else { - sendError("500"); + sendResponse("", "500"); } - sendResponse(tradingJson, "201"); } else { - sendError("500"); + sendResponse("", "500"); } } else { - sendError("500"); + sendResponse("", "500"); } + sendResponse(Objects.requireNonNull(tradingJson), "201"); } else { - sendError("500"); + sendResponse("", "500"); } } else { - sendError("500"); + sendResponse("", "500"); } } } @@ -394,95 +401,93 @@ public class Response { if(new DBConnection().addBattle(username)){ sendResponse("Du bist: #PLAYER 1\nBattle Einladung wurde erstellt von: " + username + "(#PLAYER1) \nSobald ein 2. Spieler dem Battle beitritt, kann das ergebnis mit /score abgefragt werden.","200"); }else { - sendError("500"); + sendResponse("", "500"); } } else { //Join game player - try { - User player2 = new DBConnection().getUser(username); - if(player2 != null){ - openBattle.setPlayer2(player2); - openBattle.setDeckPlayer2(deck); - if(new DBConnection().delBattleEinladung(openBattle.getId() + "")){ - openBattle.doFight(); - System.out.println(JsonHelper.objToJson(openBattle.getLog())); - if(new DBConnection().addBattleLog(openBattle.getId()+"", openBattle.getPlayer1().getName(), openBattle.getPlayer2().getName(), openBattle.getScorePlayer1()+"", openBattle.getScorePlayer2() +"")){ - if(new DBConnection().delDeck(openBattle.getPlayer1().getCredentials().getUsername()) && new DBConnection().delDeck(openBattle.getPlayer2().getCredentials().getUsername())) { + User player2 = new DBConnection().getUser(username); + if(player2 != null){ + openBattle.setPlayer2(player2); + openBattle.setDeckPlayer2(deck); + if(new DBConnection().delBattleEinladung(openBattle.getId() + "")) { + if (openBattle.doFight()){ + System.out.println(JsonHelper.objToJson(openBattle.getLog().size())); + if (new DBConnection().addBattleLog(openBattle.getId() + "", openBattle.getPlayer1().getName(), openBattle.getPlayer2().getName(), openBattle.getScorePlayer1() + "", openBattle.getScorePlayer2() + "", openBattle.getLog().toString())) { + if (new DBConnection().delDeck(openBattle.getPlayer1().getCredentials().getUsername()) && new DBConnection().delDeck(openBattle.getPlayer2().getCredentials().getUsername())) { //DEL OLD DECK CARDS - ArrayList oldDeck1 = new ArrayList(); - for (Card ca: openBattle.getDeckPlayer1Init().getCards()){ + ArrayList oldDeck1 = new ArrayList<>(); + for (Card ca : openBattle.getDeckPlayer1Init().getCards()) { oldDeck1.add(ca.getName()); } - ArrayList oldDeck2 = new ArrayList(); - for (Card ca: openBattle.getDeckPlayer2Init().getCards()){ + ArrayList oldDeck2 = new ArrayList<>(); + for (Card ca : openBattle.getDeckPlayer2Init().getCards()) { oldDeck2.add(ca.getName()); } //DEL NEW CARDS IF EXIST Cards player1cards = new DBConnection().getCards(openBattle.getPlayer1().getCredentials().getUsername()); - for(Card ca:openBattle.getDeckPlayer1().getCards()){ + for (Card ca : openBattle.getDeckPlayer1().getCards()) { oldDeck1.add(ca.getName()); } - if(player1cards.getCards() != null && !player1cards.getCards().isEmpty()) { + if (player1cards.getCards() != null && !player1cards.getCards().isEmpty()) { for (String ca : oldDeck1) { - if(!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca)){ + if (!new DBConnection().delUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca)) { sendResponse("Error Deleting user card1: " + ca, "500"); } } } Cards player2cards = new DBConnection().getCards(openBattle.getPlayer2().getCredentials().getUsername()); - for(Card ca:openBattle.getDeckPlayer2().getCards()){ + for (Card ca : openBattle.getDeckPlayer2().getCards()) { oldDeck2.add(ca.getName()); } - if(player2cards.getCards() != null && !player2cards.getCards().isEmpty()) { + if (player2cards.getCards() != null && !player2cards.getCards().isEmpty()) { for (String ca : oldDeck2) { - if(!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca)){ - sendResponse("Error Deleting user card2: " + ca, "500"); + if (!new DBConnection().delUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca)) { + sendResponse("Error Deleting user card2: " + ca, "500"); } } } //ADD CARDS TO DECK - for(Card ca : openBattle.getDeckPlayer1().getCards()){ - if(!new DBConnection().addUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())){ + for (Card ca : openBattle.getDeckPlayer1().getCards()) { + if (!new DBConnection().addUserCard(openBattle.getPlayer1().getCredentials().getUsername(), ca.getName())) { sendResponse("Error adding card to user1: " + ca.getName(), "500"); } } - for(Card ca : openBattle.getDeckPlayer2().getCards()){ - if(!new DBConnection().addUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())){ + for (Card ca : openBattle.getDeckPlayer2().getCards()) { + if (!new DBConnection().addUserCard(openBattle.getPlayer2().getCredentials().getUsername(), ca.getName())) { sendResponse("Error adding card to user2: " + ca.getName(), "500"); } } sendResponse("Du bist: #PLAYER 2\nBattle --> " + openBattle.getPlayer1().getName() + "(#PLAYER1) |vs| " + openBattle.getPlayer2().getName() + "(#PLAYER2)\nErgebnisse unter /score abrufbar", "200"); } - }else{ + } else { sendResponse("Battle Log konnte ned geschrieben werden", "500"); //ERROR } - }else{ - sendResponse("Battle einladung konnte ned akzeptiert werden", "500"); //ERROR + }else { + sendResponse("Battle konnte ned durchgeführt werden", "500"); } }else{ - sendResponse("GET User error", "500"); //ERROR + sendResponse("Battle einladung konnte ned akzeptiert werden", "500"); //ERROR } - } catch (SQLException throwables) { - throwables.printStackTrace(); + }else{ sendResponse("GET User error", "500"); //ERROR } } }else { - sendResponse("Nur "+deck.getCards().size()+" von 4 Karten im Deck. \nMach zuerst POST /deck [ID, ID, ID, ID] um dein Deck korrekt zu befüllen","424"); + sendResponse("Nur "+ Objects.requireNonNull(deck).getCards().size()+" von 4 Karten im Deck. \nMach zuerst POST /deck [ID, ID, ID, ID] um dein Deck korrekt zu befüllen","424"); } }else { sendResponse("Deck ist nicht gesetzt","424"); } }else { - sendError("500"); + sendResponse("", "500"); } }else { - sendError("401"); + sendResponse("Login Error", "401"); } } else{ - sendError("405"); + sendResponse("", "405"); } } @@ -494,18 +499,9 @@ public class Response { private boolean login(){ if(this.authString != null && !this.authString.isEmpty()){ String username = basicAuthGetUsername(this.authString); - User user = null; - try { - user = new DBConnection().getUser(username); - if (basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString)){ - return true; - }else{ - return false; - } - } catch (SQLException throwables) { - throwables.printStackTrace(); - return false; - } + User user; + user = new DBConnection().getUser(username); + return basicAuth(user.getCredentials().getUsername(), user.getCredentials().getPasswort(), this.authString); }else{ return false; @@ -515,53 +511,44 @@ public class Response { /** * 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"); - } + User user; + user = new DBConnection().getUser(username); if(user != null) { Map map = JsonHelper.jsonPayloadToMap(this.payload); - String bio = (String) map.get("Bio"); + String bio = (String) Objects.requireNonNull(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"); + sendResponse("", "500"); } }else{ - sendError("500"); + sendResponse("", "500"); } }else if(this.url.startsWith("/deck")) { List deckIds = JsonHelper.jsonPayloadToList(this.payload); - if (deckIds != null){ + if (deckIds != null && deckIds.size() == 4){ if (new DBConnection().setDeck(basicAuthGetUsername(this.authString), deckIds)){ Cards deck = new DBConnection().getCardsFromIDList(deckIds); String deckJson = JsonHelper.objToJson(deck); if (deck != null && deckJson != null){ sendResponse(deckJson, "200"); }else { - sendError("500"); + sendResponse("", "500"); } }else { - sendError("500"); + sendResponse("", "500"); } }else{ - sendError("500"); + sendResponse(Objects.requireNonNull(deckIds).size() + " von 4 Karten sind im Deck.","500"); } } } @@ -571,12 +558,10 @@ public class Response { /** * Alle Delete Methoden, siehe API beschreibung für genauere details * Nur für angemeldete user erreichbar - * @throws JsonProcessingException Fehler beim de-/serialisieren */ private void deleteMethodes(){ if (this.url.startsWith("/tradings")) { String tradeid = this.url.substring(this.url.lastIndexOf('/') + 1); - System.out.println("Format in /tradings/{tradingid}: " + tradeid); ArrayList allTradingDeals = new DBConnection().getAllTradingDeals(); TradingDeal tr = null; if (allTradingDeals != null && !allTradingDeals.isEmpty()) { @@ -590,10 +575,10 @@ public class Response { if (new DBConnection().updateCardLock(tr.getCardToTrade().getName(), false)) sendResponse("", "204"); } else { - sendError("500"); + sendResponse("", "500"); } }else{ - sendError("500"); + sendResponse("", "500"); } } @@ -601,32 +586,6 @@ public class Response { } - /** - * Sendet einen Error Response - * @param errorCode Der Error Code - */ - private void sendError(String errorCode) { - out.print("HTTP/1.0 "+errorCode+"\r\n"); - out.print("Server: Apache/0.8.4\r\n"); - out.print("Content-Type: text/plain\r\n"); - out.print("Content-Length: 1\r\n"); - out.print("\r\n"); - //out.print(responseText); - } - - /** - * Sendet eine Startseite, mit allen befehlen und wie man diese verwendet - - private void startseite() { - sendResponse("lists all messages: GET /messages
" + - "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"); - } - */ - /** * Sendet eine Response * @param responseText Text der zu senden ist diff --git a/src/test/java/CardTest.java b/src/test/java/CardTest.java index b9a5c4b..f562c52 100644 --- a/src/test/java/CardTest.java +++ b/src/test/java/CardTest.java @@ -1,58 +1,50 @@ -import at.reisinger.Card; -import at.reisinger.CardType; -import at.reisinger.EffectivnessType; -import at.reisinger.ElementTyp; +import at.reisinger.obj.Card; +import at.reisinger.enums.CardType; +import at.reisinger.enums.ElementTyp; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.*; public class CardTest { @Test public void test_getName() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); - assertTrue(card.getName().equals("Name")); + assertEquals(card.getName(), "Name"); } @Test public void test_getDamage() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); - assertTrue(card.getDamage() == 10); + assertEquals(card.getDamage(), 10); } @Test public void test_getElementType() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); ElementTyp elementTyp = card.getElementTyp(); - assertTrue(elementTyp == ElementTyp.WATER); + assertSame(elementTyp, ElementTyp.WATER); } @Test public void test_getCardType() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); CardType cardType = card.getCardType(); - assertTrue(cardType == CardType.SPELL); - } - @Test - public void test_getEffectivenessAgainst() { - Card card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); - Card card2 = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); - EffectivnessType effectivnessType = card.getEffectivenessAgainst(card2); - assertTrue(effectivnessType == EffectivnessType.NOEFFECT); + assertSame(cardType, CardType.SPELL); } @Test public void test_setName() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); card.setName("NeuerName"); - assertTrue(card.getName().equals("NeuerName")); + assertEquals(card.getName(), "NeuerName"); } @Test public void test_setDamage() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); card.setDamage(100); - assertTrue(card.getDamage() == 100); + assertEquals(card.getDamage(), 100); } @Test public void test_setElementTyp() { Card card = new Card("Name", 10, ElementTyp.WATER, CardType.SPELL); card.setElementType(ElementTyp.FIRE); - assertTrue(card.getElementTyp() == ElementTyp.FIRE); + assertSame(card.getElementTyp(), ElementTyp.FIRE); } } diff --git a/src/test/java/CardsTest.java b/src/test/java/CardsTest.java index 82dd34c..d1127ee 100644 --- a/src/test/java/CardsTest.java +++ b/src/test/java/CardsTest.java @@ -1,27 +1,27 @@ -import at.reisinger.Card; -import at.reisinger.CardType; -import at.reisinger.Cards; -import at.reisinger.ElementTyp; +import at.reisinger.obj.Card; +import at.reisinger.enums.CardType; +import at.reisinger.obj.Cards; +import at.reisinger.enums.ElementTyp; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.ArrayList; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.*; public class CardsTest { private Cards cards, cards2, cards3; - private Card newCard, card, newerCard; - private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; + private Card newCard; + private Card card; + private ArrayList cardsArrayList; @BeforeEach void setUp() { card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); - newerCard = new Card("NameNewerer", 100, ElementTyp.FIRE, CardType.MONSTER); - cardsArrayList = new ArrayList(); - cardsArrayList2 = new ArrayList(); - cardsArrayList3 = new ArrayList(); + Card newerCard = new Card("NameNewerer", 100, ElementTyp.FIRE, CardType.MONSTER); + cardsArrayList = new ArrayList<>(); + ArrayList cardsArrayList2 = new ArrayList<>(); + ArrayList cardsArrayList3 = new ArrayList<>(); cardsArrayList.add(card); cardsArrayList2.add(newCard); cardsArrayList2.add(card); @@ -66,11 +66,11 @@ public class CardsTest { cards.delCard(newCard); - assertTrue(cards.getCards().equals(cardsArrayList)); + assertEquals(cardsArrayList, cards.getCards()); } @Test void test_getCards() { - assertTrue(cards.getCards().equals(cardsArrayList)); + assertEquals(cardsArrayList, cards.getCards()); } } diff --git a/src/test/java/CoinsTest.java b/src/test/java/CoinsTest.java index dc479c4..7227fe1 100644 --- a/src/test/java/CoinsTest.java +++ b/src/test/java/CoinsTest.java @@ -1,10 +1,8 @@ -import at.reisinger.Coins; -import at.reisinger.NegativAmountException; +import at.reisinger.obj.Coins; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; -import static org.junit.jupiter.api.Assertions.assertFalse; public class CoinsTest { @@ -14,55 +12,4 @@ public class CoinsTest { assertTrue(coin.getCoinAmount() >= 0); } - @Test - public void test_addCoinException(){ - try { - Coins coin = new Coins(10); - coin.addCoin(-10); - fail("Erwartet at.reisinger.NegativAmountException - addCoin"); - }catch (NegativAmountException negativAmountException) { - assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden")); - } - } - - @Test - public void test_removeCoinException(){ - try { - Coins coin = new Coins(10); - coin.removeCoin(-10); - fail("Erwartet at.reisinger.NegativAmountException - removeCoin"); - }catch (NegativAmountException negativAmountException) { - assertTrue(negativAmountException.getMessage().equals("Es kann kein negativer amount an at.reisinger.Coins hinzugefügt werden")); - } - } - - @Test - public void test_removeCoin(){ - Coins coin = new Coins(10); - try { - assertTrue(coin.removeCoin(10)); - } catch (NegativAmountException e) { - e.printStackTrace(); - } - } - - @Test - public void test_changeCoinAmount_true(){ - Coins coin = new Coins(10); - try { - assertTrue(coin.changeCoinAmmount(10)); - } catch (NegativAmountException e) { - e.printStackTrace(); - } - } - - @Test - public void test_changeCoinAmount_false(){ - Coins coin = new Coins(9); - try { - assertTrue(coin.changeCoinAmmount(7)); - } catch (NegativAmountException e) { - e.printStackTrace(); - } - } } diff --git a/src/test/java/PackageTest.java b/src/test/java/PackageTest.java index 10063b4..49ab2fd 100644 --- a/src/test/java/PackageTest.java +++ b/src/test/java/PackageTest.java @@ -1,49 +1,49 @@ -import at.reisinger.*; -import at.reisinger.Package; +import at.reisinger.obj.Card; +import at.reisinger.obj.Cards; +import at.reisinger.obj.Package; +import at.reisinger.enums.CardType; +import at.reisinger.enums.ElementTyp; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.ArrayList; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; public class PackageTest { - private Cards newCards, cards, nochNewCards; - private Card newCard, card; - private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; private Package myPackage; @BeforeEach void setUp() { - card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); - newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); - cardsArrayList = new ArrayList(); - cardsArrayList2 = new ArrayList(); - cardsArrayList3 = new ArrayList(); + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + Card newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + ArrayList cardsArrayList = new ArrayList<>(); + ArrayList cardsArrayList2 = new ArrayList<>(); + ArrayList cardsArrayList3 = new ArrayList<>(); cardsArrayList.add(card); cardsArrayList2.add(newCard); - cards = new Cards(cardsArrayList); - newCards = new Cards(cardsArrayList2); - nochNewCards = new Cards(cardsArrayList3); + Cards cards = new Cards(cardsArrayList); + Cards newCards = new Cards(cardsArrayList2); + Cards nochNewCards = new Cards(cardsArrayList3); myPackage = new Package(cards,"Name", 100); } @Test void test_getName() { String result = myPackage.getName(); - assertTrue(result.equals("Name")); + assertEquals(result, "Name"); } @Test void test_getPrice() { int result = myPackage.getPrice(); - assertTrue(result==100); + assertEquals(result, 100); } @Test void test_setName() { myPackage.setName("neuName"); String result = myPackage.getName(); - assertTrue(result.equals("neuName")); + assertEquals(result, "neuName"); } } diff --git a/src/test/java/StackTest.java b/src/test/java/StackTest.java deleted file mode 100644 index 75314a4..0000000 --- a/src/test/java/StackTest.java +++ /dev/null @@ -1,48 +0,0 @@ -import at.reisinger.*; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -import java.util.ArrayList; - -import static org.junit.jupiter.api.Assertions.assertTrue; - - -public class StackTest { - private Cards newCards, cards, nochNewCards; - private Card newCard, card; - private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; - private Stack stack; - - @BeforeEach - void setUp() { - card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); - newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); - cardsArrayList = new ArrayList(); - cardsArrayList2 = new ArrayList(); - cardsArrayList3 = new ArrayList(); - cardsArrayList.add(card); - cardsArrayList2.add(newCard); - cardsArrayList2.add(card); - cards = new Cards(cardsArrayList); - newCards = new Cards(cardsArrayList2); - nochNewCards = new Cards(cardsArrayList3); - stack = new Stack(cards, nochNewCards); - } - @Test - void test_addDeck() { - stack.addDeck(newCards); - Cards result = stack.getDeck(); - assertTrue(result.equals(newCards)); - } - @Test - void test_delDeck() { - stack.addDeck(newCards); - stack.delDeck(newCard); - assertTrue(stack.getDeck().equals(cards)); - } - @Test - void test_getDeck() { - Cards result = stack.getDeck(); - assertTrue(result.equals(nochNewCards)); - } -} diff --git a/src/test/java/StoreTest.java b/src/test/java/StoreTest.java deleted file mode 100644 index 4b56943..0000000 --- a/src/test/java/StoreTest.java +++ /dev/null @@ -1,147 +0,0 @@ -import at.reisinger.*; -import at.reisinger.Package; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -import java.util.ArrayList; - -import static org.junit.jupiter.api.Assertions.assertTrue; - -public class StoreTest { - - private TradingDeal tradingDeal; - private Cards newCards, cards, nochNewCards; - private Card newCard, card; - private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; - private Stack stack; - private User user, userNew; - private Store store; - - @BeforeEach - void setUp() { - //at.reisinger.Stack - card = new Card("Name", 100, ElementTyp.WATER, CardType.MONSTER); - newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); - cardsArrayList = new ArrayList(); - cardsArrayList2 = new ArrayList(); - cardsArrayList3 = new ArrayList(); - cardsArrayList.add(card); - cardsArrayList2.add(newCard); - cards = new Cards(cardsArrayList); - newCards = new Cards(cardsArrayList2); - nochNewCards = new Cards(cardsArrayList3); - stack = new Stack(cards, nochNewCards); - - //at.reisinger.Coins - Coins coins = new Coins(10); - //at.reisinger.User - Credentials credentials = new Credentials("username", "passwort"); - user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE"); - userNew = new User(credentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE"); - - //Trading Deal - Card cardToTrade = card; - ElementTyp requiredElementType = ElementTyp.FIRE; - double requiredMinDamage = 100; - CardType requiredCardType = CardType.MONSTER; - tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME"); - - } -/* - @Test - void test_addTradingDeal() { - - - 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 Coins(1000), "BIO", "IMAGE"); - ArrayList tradingDeals = new ArrayList(); - ArrayList packages = new ArrayList(); - tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); - packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100)); - - - System.out.println(user.getTradingDeals().toString()); - - user.addTradingDeal(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); - System.out.println(user.getTradingDeals().toString()); - - - System.out.println(tradingDeals.toString()); - assertTrue(user.getTradingDeals().get(0).dealOk(tradingDeals.get(0))); - } - @Test - void test_doTrade() { - Card cardtest = new Card("Name", 100, ElementTyp.FIRE, CardType.MONSTER); - TradingDeal tradingDealtest = new TradingDeal(user, cardtest, ElementTyp.WATER, 100, CardType.MONSTER); - boolean result = user.doTrading(tradingDeal, tradingDealtest); - assertTrue(result); - } - @Test - void test_getTradingDeals() { - ArrayList result = user.getTradingDeals(); - ArrayList expected = new ArrayList(); - - 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 Coins(1000), "BIO", "IMAGE"); - ArrayList tradingDeals = new ArrayList(); - ArrayList packages = new ArrayList(); - tradingDeals.add(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER)); - packages.add(new at.reisinger.Package(stack, "Test at.reisinger.Package", 100)); - - assertTrue(result.get(0).dealOk(new TradingDeal(user, c1, ElementTyp.FIRE, 10, CardType.MONSTER))); - } - - @Test - void test_getPossibleTradingDeals() { - Card testCard = new Card("Test", 10, ElementTyp.FIRE, CardType.MONSTER); - ArrayList result = user.getPossibleTradingDeals(testCard); - ArrayList expected = new ArrayList(); - 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); - 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())); - } - - */ -} diff --git a/src/test/java/TradingDealTest.java b/src/test/java/TradingDealTest.java index 0c17119..0c7257a 100644 --- a/src/test/java/TradingDealTest.java +++ b/src/test/java/TradingDealTest.java @@ -1,43 +1,40 @@ -import at.reisinger.*; +import at.reisinger.enums.CardType; +import at.reisinger.enums.ElementTyp; +import at.reisinger.obj.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.ArrayList; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.*; public class TradingDealTest { private TradingDeal tradingDeal; - private Cards newCards, cards, nochNewCards; private Card newCard, card; - private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; - private Stack stack; - private User user, userNew; @BeforeEach void setUp() { //at.reisinger.Stack card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); - cardsArrayList = new ArrayList(); - cardsArrayList2 = new ArrayList(); - cardsArrayList3 = new ArrayList(); + ArrayList cardsArrayList = new ArrayList<>(); + ArrayList cardsArrayList2 = new ArrayList<>(); + ArrayList cardsArrayList3 = new ArrayList<>(); cardsArrayList.add(card); cardsArrayList2.add(newCard); - cards = new Cards(cardsArrayList); - newCards = new Cards(cardsArrayList2); - nochNewCards = new Cards(cardsArrayList3); - stack = new Stack(cards, nochNewCards); + Cards cards = new Cards(cardsArrayList); + Cards newCards = new Cards(cardsArrayList2); + Cards nochNewCards = new Cards(cardsArrayList3); - //at.reisinger.Coins + //at.reisinger.obj.Coins Coins coins = new Coins(10); - //at.reisinger.User + //at.reisinger.obj.User Credentials credentials = new Credentials("username", "passwort"); Credentials newCredentials = new Credentials("usernamenew", "passwortnew"); - user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE"); - userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE"); + User user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE"); + User userNew = new User(newCredentials, "nameNew", "nachnameNew", "emailNew", coins, "BIO", "IMAGE"); //Trading Deal Card cardToTrade = card; @@ -47,14 +44,6 @@ public class TradingDealTest { tradingDeal = new TradingDeal("ID", cardToTrade, requiredElementType, requiredMinDamage, requiredCardType, "NAME"); } - /* - @Test - void test_getTradingUser() { - User result = tradingDeal.getTradingUser(); - assertTrue(result.equals(user)); - } - */ - @Test void test_getCardToTrade() { Card result = tradingDeal.getCardToTrade(); @@ -63,50 +52,41 @@ public class TradingDealTest { @Test void test_getRequiredElementType() { ElementTyp result = tradingDeal.getRequiredElementType(); - assertTrue(result==ElementTyp.FIRE); + assertSame(result, ElementTyp.FIRE); } @Test void test_getRequiredMinDamage() { double result = tradingDeal.getRequiredMinDamage(); - assertTrue(result==100); + assertEquals(result, 100); } @Test void test_getRequiredCardType() { CardType result = tradingDeal.getRequiredCardType(); - assertTrue(result==CardType.MONSTER); + assertSame(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); Card result = tradingDeal.getCardToTrade(); - assertTrue(result==newCard); + assertSame(result, newCard); } @Test void test_setRequiredElementType() { tradingDeal.setRequiredElementType(ElementTyp.WATER); ElementTyp result = tradingDeal.getRequiredElementType(); - assertTrue(result==ElementTyp.WATER); + assertSame(result, ElementTyp.WATER); } @Test void test_setRequiredMinDamage() { tradingDeal.setRequiredMinDamage(10); double result = tradingDeal.getRequiredMinDamage(); - assertTrue(result==10); + assertEquals(result, 10); } @Test void test_setRequiredCardType() { tradingDeal.setRequiredCardType(CardType.SPELL); CardType result = tradingDeal.getRequiredCardType(); - assertTrue(result==CardType.SPELL); + assertSame(result, CardType.SPELL); } } diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java index 325c332..4f1baa1 100644 --- a/src/test/java/UserTest.java +++ b/src/test/java/UserTest.java @@ -1,59 +1,58 @@ -import at.reisinger.*; -import at.reisinger.Package; +import at.reisinger.obj.*; +import at.reisinger.enums.CardType; +import at.reisinger.enums.ElementTyp; +import at.reisinger.obj.Package; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.ArrayList; +import java.util.Objects; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; public class UserTest { private TradingDeal tradingDeal; - private Cards newCards, cards, nochNewCards; - private Card newCard, card; - private ArrayList cardsArrayList, cardsArrayList2, cardsArrayList3; - private Stack stack; private User user; - private at.reisinger.Package myPackage; + private Package myPackage; @BeforeEach void setUp() { //at.reisinger.Stack - card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); - newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); - cardsArrayList = new ArrayList(); - cardsArrayList2 = new ArrayList(); - cardsArrayList3 = new ArrayList(); + Card card = new Card("Name", 10, ElementTyp.WATER, CardType.MONSTER); + Card newCard = new Card("NameNew", 10, ElementTyp.WATER, CardType.SPELL); + ArrayList cardsArrayList = new ArrayList<>(); + ArrayList cardsArrayList2 = new ArrayList<>(); + ArrayList cardsArrayList3 = new ArrayList<>(); cardsArrayList.add(card); cardsArrayList2.add(newCard); - cards = new Cards(cardsArrayList); - newCards = new Cards(cardsArrayList2); - nochNewCards = new Cards(cardsArrayList3); - stack = new Stack(cards, nochNewCards); - //at.reisinger.Package + Cards cards = new Cards(cardsArrayList); + Cards newCards = new Cards(cardsArrayList2); + Cards nochNewCards = new Cards(cardsArrayList3); + //at.reisinger.obj.Package myPackage = new Package(cards, "Name", 100); - //at.reisinger.Coins + //at.reisinger.obj.Coins Coins coins = new Coins(10); - //at.reisinger.User + //at.reisinger.obj.User Credentials credentials = new Credentials("username", "pw"); user = new User(credentials, "name", "nachname", "email", coins, "BIO", "IMAGE"); } @Test public void test_getName() { String result = user.getName(); - assertTrue(result.equals("name")); + assertEquals(result, "name"); } @Test public void test_getNachname() { String result = user.getNachname(); - assertTrue(result.equals("nachname")); + assertEquals(result, "nachname"); } @Test public void test_getEmail() { String result = user.getEmail(); - assertTrue(result.equals("email")); + assertEquals(result, "email"); } @Test @@ -61,30 +60,26 @@ public class UserTest { String newstring = "new"; user.setName(newstring); String result = user.getName(); - assertTrue(result.equals(newstring)); + assertEquals(newstring, result); } @Test public void test_setNachname() { String newstring = "new"; user.setNachname(newstring); String result = user.getNachname(); - assertTrue(result.equals(newstring)); + assertEquals(newstring, result); } @Test public void test_setEmail() { String newstring = "new"; user.setEmail(newstring); String result = user.getEmail(); - assertTrue(result.equals(newstring)); + assertEquals(newstring, result); } @Test public void test_buyPackage(){ - Cards cards = null; - try { + Cards cards; cards = new Cards(user.buyPackage(myPackage)); - } catch (NegativAmountException e) { - e.printStackTrace(); - } - assertTrue(cards.equals(new Cards(myPackage.getCards()))); + assertTrue(Objects.requireNonNull(cards).equals(new Cards(myPackage.getCards()))); } }