Merge branch 'main' into feature/authentik

backend/build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
     java
-    id("org.springframework.boot") version "3.4.3"
+    id("org.springframework.boot") version "3.4.4"
     id("io.spring.dependency-management") version "1.1.7"
     id("checkstyle")
 }
@@ -39,7 +39,7 @@ repositories {
 }
 
 dependencies {
-    implementation("com.stripe:stripe-java:20.136.0")
+    implementation("com.stripe:stripe-java:29.0.0")
     implementation("org.springframework.boot:spring-boot-starter-data-jpa")
     implementation("org.springframework.boot:spring-boot-starter-web")
     compileOnly("org.projectlombok:lombok")
@@ -47,10 +47,10 @@ dependencies {
     testImplementation("org.springframework.boot:spring-boot-starter-test")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     implementation("org.springframework.boot:spring-boot-starter-security")
-    implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server")
-    implementation("org.springframework.security:spring-security-oauth2-jose")
+    implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server:3.4.4")
+    implementation("org.springframework.boot:spring-boot-starter-oauth2-client:3.4.4")
     runtimeOnly("org.postgresql:postgresql")
-    implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.5")
+    implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.6")
 }
 
 tasks.withType<Test> {

backend/requests/blackjack.http

@@ -0,0 +1,20 @@
+POST http://localhost:8080/blackjack/start
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{
+  "betAmount": 1.01
+}
+
+###
+POST http://localhost:8080/blackjack/54/hit
+Authorization: Bearer {{token}}
+
+###
+POST http://localhost:8080/blackjack/202/stand
+Authorization: Bearer {{token}}
+
+###
+GET http://localhost:8080/blackjack/202
+Authorization: Bearer {{token}}
+

backend/requests/getBearerToken.http

@@ -1,6 +1,6 @@
 POST http://localhost:9090/realms/LF12/protocol/openid-connect/token
 Content-Type: application/x-www-form-urlencoded
 
-grant_type=password&client_id=lf12&username=lf12_test_user&password=secret
+grant_type=password&client_id=lf12&username=lf12_test_user&password=secret&scope=openid
 
 > {% client.global.set("token", response.body.access_token); %}

backend/requests/lootboxes.http

@@ -0,0 +1,9 @@
+GET http://localhost:8080/lootboxes
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+###
+
+POST http://localhost:8080/lootboxes/2
+Authorization: Bearer {{token}}
+Content-Type: application/json

backend/src/main/java/de/szut/casino/CasinoApplication.java

@@ -1,10 +1,20 @@
 package de.szut.casino;
 
+import de.szut.casino.lootboxes.LootBoxEntity;
+import de.szut.casino.lootboxes.LootBoxRepository;
+import de.szut.casino.lootboxes.RewardEntity;
+import de.szut.casino.lootboxes.RewardRepository;
+import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.annotation.Bean;
 import org.springframework.web.client.RestTemplate;
 
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 @SpringBootApplication
 public class CasinoApplication {
 
@@ -16,4 +26,65 @@ public class CasinoApplication {
     public static RestTemplate restTemplate() {
         return new RestTemplate();
     }
+
+    @Bean
+    public CommandLineRunner initData(LootBoxRepository lootBoxRepository, RewardRepository rewardRepository) {
+        return _ -> {
+            if (lootBoxRepository.count() == 0) {
+                LootBoxEntity basicLootBox = new LootBoxEntity();
+                basicLootBox.setName("Basic LootBox");
+                basicLootBox.setPrice(new BigDecimal("2"));
+                basicLootBox.setRewards(new ArrayList<>()); // Initialize the list
+
+                LootBoxEntity premiumLootBox = new LootBoxEntity();
+                premiumLootBox.setName("Premium LootBox");
+                premiumLootBox.setPrice(new BigDecimal("5"));
+                premiumLootBox.setRewards(new ArrayList<>()); // Initialize the list
+
+                lootBoxRepository.saveAll(Arrays.asList(basicLootBox, premiumLootBox));
+
+                RewardEntity commonReward = new RewardEntity();
+                commonReward.setValue(new BigDecimal("0.50"));
+                commonReward.setProbability(new BigDecimal("0.7"));
+
+                RewardEntity rareReward = new RewardEntity();
+                rareReward.setValue(new BigDecimal("2.00"));
+                rareReward.setProbability(new BigDecimal("0.25"));
+
+                RewardEntity epicReward = new RewardEntity();
+                epicReward.setValue(new BigDecimal("5.00"));
+                epicReward.setProbability(new BigDecimal("0.5"));
+
+                RewardEntity premiumCommon = new RewardEntity();
+                premiumCommon.setValue(new BigDecimal("2.00"));
+                premiumCommon.setProbability(new BigDecimal("0.6"));
+
+                RewardEntity premiumRare = new RewardEntity();
+                premiumRare.setValue(new BigDecimal("5.00"));
+                premiumRare.setProbability(new BigDecimal("0.3"));
+
+                RewardEntity legendaryReward = new RewardEntity();
+                legendaryReward.setValue(new BigDecimal("15.00"));
+                legendaryReward.setProbability(new BigDecimal("0.10"));
+
+                rewardRepository.saveAll(Arrays.asList(
+                        commonReward, rareReward, epicReward,
+                        premiumCommon, premiumRare, legendaryReward
+                ));
+
+                basicLootBox.getRewards().add(commonReward);
+                basicLootBox.getRewards().add(premiumRare);
+
+                premiumLootBox.getRewards().add(premiumCommon);
+                premiumLootBox.getRewards().add(premiumRare);
+                premiumLootBox.getRewards().add(legendaryReward);
+
+                lootBoxRepository.saveAll(Arrays.asList(basicLootBox, premiumLootBox));
+
+                System.out.println("Initial LootBoxes and rewards created successfully");
+            } else {
+                System.out.println("LootBoxes already exist, skipping initialization");
+            }
+        };
+    }
 }

backend/src/main/java/de/szut/casino/blackjack/BlackJackGameController.java

@@ -0,0 +1,140 @@
+package de.szut.casino.blackjack;
+
+import de.szut.casino.blackjack.dto.CreateBlackJackGameDto;
+import de.szut.casino.user.UserEntity;
+import de.szut.casino.user.UserService;
+import jakarta.validation.Valid;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+@Slf4j
+@RestController
+public class BlackJackGameController {
+
+    private final UserService userService;
+    private final BlackJackService blackJackService;
+
+    public BlackJackGameController(UserService userService, BlackJackService blackJackService) {
+        this.blackJackService = blackJackService;
+        this.userService = userService;
+    }
+
+    @GetMapping("/blackjack/{id}")
+    public ResponseEntity<Object> getGame(@PathVariable Long id, @RequestHeader("Authorization") String token) {
+        Optional<UserEntity> optionalUser = userService.getCurrentUser(token);
+
+        if (optionalUser.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        UserEntity user = optionalUser.get();
+        BlackJackGameEntity game = blackJackService.getBlackJackGame(id);
+        if (game == null || !Objects.equals(game.getUserId(), user.getId())) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(game);
+    }
+
+    @PostMapping("/blackjack/{id}/hit")
+    public ResponseEntity<Object> hit(@PathVariable Long id, @RequestHeader("Authorization") String token) {
+        Optional<UserEntity> optionalUser = userService.getCurrentUser(token);
+
+        if (optionalUser.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        UserEntity user = optionalUser.get();
+        BlackJackGameEntity game = blackJackService.getBlackJackGame(id);
+        if (game == null || !Objects.equals(game.getUserId(), user.getId())) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(blackJackService.hit(game));
+    }
+
+    @PostMapping("/blackjack/{id}/stand")
+    public ResponseEntity<Object> stand(@PathVariable Long id, @RequestHeader("Authorization") String token) {
+        Optional<UserEntity> optionalUser = userService.getCurrentUser(token);
+
+        if (optionalUser.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        UserEntity user = optionalUser.get();
+        BlackJackGameEntity game = blackJackService.getBlackJackGame(id);
+        if (game == null || !Objects.equals(game.getUserId(), user.getId())) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(blackJackService.stand(game));
+    }
+
+    @PostMapping("/blackjack/{id}/doubleDown")
+    public ResponseEntity<Object> doubleDown(@PathVariable Long id, @RequestHeader("Authorization") String token) {
+        Optional<UserEntity> optionalUser = userService.getCurrentUser(token);
+
+        if (optionalUser.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        UserEntity user = optionalUser.get();
+        BlackJackGameEntity game = blackJackService.getBlackJackGame(id);
+        if (game == null || !Objects.equals(game.getUserId(), user.getId())) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(blackJackService.doubleDown(game));
+    }
+
+    @PostMapping("/blackjack/{id}/split")
+    public ResponseEntity<Object> split(@PathVariable Long id, @RequestHeader("Authorization") String token) {
+        Optional<UserEntity> optionalUser = userService.getCurrentUser(token);
+
+        if (optionalUser.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        UserEntity user = optionalUser.get();
+        BlackJackGameEntity game = blackJackService.getBlackJackGame(id);
+        if (game == null || !Objects.equals(game.getUserId(), user.getId())) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(blackJackService.split(game));
+    }
+
+    @PostMapping("/blackjack/start")
+    public ResponseEntity<Object> createBlackJackGame(@RequestBody @Valid CreateBlackJackGameDto createBlackJackGameDto, @RequestHeader("Authorization") String token) {
+        Optional<UserEntity> optionalUser = userService.getCurrentUser(token);
+
+        if (optionalUser.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        UserEntity user = optionalUser.get();
+        BigDecimal balance = user.getBalance();
+        BigDecimal betAmount = createBlackJackGameDto.getBetAmount();
+
+        if (betAmount.compareTo(BigDecimal.ZERO) <= 0) {
+            Map<String, String> errorResponse = new HashMap<>();
+            errorResponse.put("error", "Invalid bet amount");
+            return ResponseEntity.badRequest().body(errorResponse);
+        }
+
+        if (betAmount.compareTo(balance) > 0) {
+            Map<String, String> errorResponse = new HashMap<>();
+            errorResponse.put("error", "Insufficient funds");
+            return ResponseEntity.badRequest().body(errorResponse);
+        }
+
+        return ResponseEntity.ok(blackJackService.createBlackJackGame(user, betAmount));
+    }
+}

backend/src/main/java/de/szut/casino/blackjack/BlackJackGameEntity.java

@@ -0,0 +1,65 @@
+package de.szut.casino.blackjack;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonManagedReference;
+import de.szut.casino.user.UserEntity;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.SQLRestriction;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class BlackJackGameEntity {
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(name = "user_id", nullable = false)
+    @JsonIgnore
+    private UserEntity user;
+
+    public Long getUserId() {
+        return user != null ? user.getId() : null;
+    }
+
+    @Enumerated(EnumType.STRING)
+    private BlackJackState state;
+    private BigDecimal bet;
+
+    @OneToMany(mappedBy = "game", cascade = CascadeType.ALL, orphanRemoval = true)
+    @JsonIgnore
+    @SQLRestriction("card_type = 'DECK'")
+    private List<CardEntity> deck = new ArrayList<>();
+
+    @OneToMany(mappedBy = "game", cascade = CascadeType.ALL, orphanRemoval = true)
+    @JsonManagedReference
+    @SQLRestriction("card_type = 'PLAYER'")
+    private List<CardEntity> playerCards = new ArrayList<>();
+
+    @OneToMany(mappedBy = "game", cascade = CascadeType.ALL, orphanRemoval = true)
+    @JsonManagedReference
+    @SQLRestriction("card_type = 'DEALER'")
+    private List<CardEntity> dealerCards = new ArrayList<>();
+
+    @OneToMany(mappedBy = "game", cascade = CascadeType.ALL, orphanRemoval = true)
+    @JsonManagedReference
+    @SQLRestriction("card_type = 'PLAYER_SPLIT'")
+    private List<CardEntity> playerSplitCards = new ArrayList<>();
+
+    @Column(name = "split_bet")
+    private BigDecimal splitBet;
+
+    @Column(name = "is_split")
+    private boolean isSplit;
+}

backend/src/main/java/de/szut/casino/blackjack/BlackJackGameRepository.java

@@ -0,0 +1,12 @@
+package de.szut.casino.blackjack;
+
+import de.szut.casino.user.UserEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+public interface BlackJackGameRepository extends JpaRepository<BlackJackGameEntity, Long> {
+}

backend/src/main/java/de/szut/casino/blackjack/BlackJackService.java

@@ -0,0 +1,310 @@
+package de.szut.casino.blackjack;
+
+import de.szut.casino.user.UserEntity;
+import de.szut.casino.user.UserRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Optional;
+import java.util.Random;
+
+@Service
+public class BlackJackService {
+    private final BlackJackGameRepository blackJackGameRepository;
+    private final UserRepository userRepository;
+    private final Random random = new Random();
+
+    public BlackJackService(BlackJackGameRepository blackJackGameRepository, UserRepository userRepository) {
+        this.blackJackGameRepository = blackJackGameRepository;
+        this.userRepository = userRepository;
+    }
+
+    public BlackJackGameEntity getBlackJackGame(Long id) {
+        return blackJackGameRepository.findById(id).orElse(null);
+    }
+
+    @Transactional
+    public BlackJackGameEntity createBlackJackGame(UserEntity user, BigDecimal betAmount) {
+        BlackJackGameEntity game = new BlackJackGameEntity();
+        game.setUser(user);
+        game.setBet(betAmount);
+        
+        initializeDeck(game);
+        dealInitialCards(game);
+        
+        game.setState(getState(game));
+        deductBetFromBalance(user, betAmount);
+        
+        return blackJackGameRepository.save(game);
+    }
+
+    @Transactional
+    public BlackJackGameEntity hit(BlackJackGameEntity game) {
+        if (game.getState() != BlackJackState.IN_PROGRESS) {
+            return game;
+        }
+        
+        dealCardToPlayer(game);
+        
+        updateGameStateAndBalance(game);
+        
+        return blackJackGameRepository.save(game);
+    }
+
+    @Transactional
+    public BlackJackGameEntity stand(BlackJackGameEntity game) {
+        if (game.getState() != BlackJackState.IN_PROGRESS) {
+            return game;
+        }
+        
+        dealCardsToDealerUntilMinimumScore(game);
+        determineWinnerAndUpdateBalance(game);
+        
+        return blackJackGameRepository.save(game);
+    }
+
+    @Transactional
+    public BlackJackGameEntity doubleDown(BlackJackGameEntity game) {
+        if (game.getState() != BlackJackState.IN_PROGRESS || game.getPlayerCards().size() != 2) {
+            return game;
+        }
+        
+        UserEntity user = getUserWithFreshData(game.getUser());
+        BigDecimal additionalBet = game.getBet();
+        
+        deductBetFromBalance(user, additionalBet);
+        game.setBet(game.getBet().add(additionalBet));
+        
+        dealCardToPlayer(game);
+        updateGameStateAndBalance(game);
+        
+        if (game.getState() == BlackJackState.IN_PROGRESS) {
+            return stand(game);
+        }
+        
+        return game;
+    }
+
+    @Transactional
+    public BlackJackGameEntity split(BlackJackGameEntity game) {
+        if (game.getState() != BlackJackState.IN_PROGRESS || 
+            game.getPlayerCards().size() != 2 || 
+            game.isSplit() ||
+            !game.getPlayerCards().get(0).getRank().equals(game.getPlayerCards().get(1).getRank())) {
+            return game;
+        }
+        
+        UserEntity user = getUserWithFreshData(game.getUser());
+        BigDecimal splitBet = game.getBet();
+        
+        if (user.getBalance().compareTo(splitBet) < 0) {
+            return game;
+        }
+        
+        deductBetFromBalance(user, splitBet);
+        game.setSplitBet(splitBet);
+        game.setSplit(true);
+        
+        CardEntity card = game.getPlayerCards().remove(1);
+        card.setCardType(CardType.PLAYER_SPLIT);
+        game.getPlayerSplitCards().add(card);
+        
+        dealCardToPlayer(game);
+        dealCardToSplitHand(game);
+        
+        return blackJackGameRepository.save(game);
+    }
+
+    private BlackJackGameEntity refreshGameState(BlackJackGameEntity game) {
+        return blackJackGameRepository.findById(game.getId()).orElse(game);
+    }
+    
+    private UserEntity getUserWithFreshData(UserEntity user) {
+        return userRepository.findById(user.getId()).orElse(user);
+    }
+    
+    private void dealInitialCards(BlackJackGameEntity game) {
+        for (int i = 0; i < 2; i++) {
+            dealCardToPlayer(game);
+        }
+        
+        dealCardToDealer(game);
+    }
+    
+    private void dealCardToPlayer(BlackJackGameEntity game) {
+        CardEntity card = drawCardFromDeck(game);
+        card.setCardType(CardType.PLAYER);
+        game.getPlayerCards().add(card);
+    }
+    
+    private void dealCardToDealer(BlackJackGameEntity game) {
+        CardEntity card = drawCardFromDeck(game);
+        card.setCardType(CardType.DEALER);
+        game.getDealerCards().add(card);
+    }
+    
+    private void dealCardsToDealerUntilMinimumScore(BlackJackGameEntity game) {
+        while (calculateHandValue(game.getDealerCards()) < 17) {
+            dealCardToDealer(game);
+        }
+    }
+    
+    private void dealCardToSplitHand(BlackJackGameEntity game) {
+        CardEntity card = drawCardFromDeck(game);
+        card.setCardType(CardType.PLAYER_SPLIT);
+        game.getPlayerSplitCards().add(card);
+    }
+    
+    private void updateGameStateAndBalance(BlackJackGameEntity game) {
+        if (game.isSplit()) {
+            int mainHandValue = calculateHandValue(game.getPlayerCards());
+            int splitHandValue = calculateHandValue(game.getPlayerSplitCards());
+            
+            if (mainHandValue > 21 && splitHandValue > 21) {
+                game.setState(BlackJackState.PLAYER_LOST);
+                updateUserBalance(game, false);
+            } else if (mainHandValue <= 21 && splitHandValue <= 21) {
+                game.setState(BlackJackState.IN_PROGRESS);
+            } else {
+                game.setState(BlackJackState.IN_PROGRESS);
+            }
+        } else {
+            game.setState(getState(game));
+            
+            if (game.getState() == BlackJackState.PLAYER_WON) {
+                updateUserBalance(game, true);
+            } else if (game.getState() == BlackJackState.PLAYER_LOST) {
+                updateUserBalance(game, false);
+            }
+        }
+    }
+    
+    private void determineWinnerAndUpdateBalance(BlackJackGameEntity game) {
+        int playerValue = calculateHandValue(game.getPlayerCards());
+        int dealerValue = calculateHandValue(game.getDealerCards());
+
+        if (dealerValue > 21 || playerValue > dealerValue) {
+            game.setState(BlackJackState.PLAYER_WON);
+            updateUserBalance(game, true);
+        } else if (playerValue < dealerValue) {
+            game.setState(BlackJackState.PLAYER_LOST);
+            updateUserBalance(game, false);
+        } else {
+            game.setState(BlackJackState.DRAW);
+            updateUserBalance(game, false);
+        }
+    }
+    
+    private void deductBetFromBalance(UserEntity user, BigDecimal betAmount) {
+        user.setBalance(user.getBalance().subtract(betAmount));
+        userRepository.save(user);
+    }
+
+    @Transactional
+    private void updateUserBalance(BlackJackGameEntity game, boolean isWin) {
+        UserEntity user = getUserWithFreshData(game.getUser());
+        BigDecimal totalBet = game.getBet();
+        BigDecimal balance = user.getBalance();
+        
+        if (game.isSplit()) {
+            totalBet = totalBet.add(game.getSplitBet());
+            
+            if (isWin) {
+                int mainHandValue = calculateHandValue(game.getPlayerCards());
+                int splitHandValue = calculateHandValue(game.getPlayerSplitCards());
+                int dealerValue = calculateHandValue(game.getDealerCards());
+                
+                if (mainHandValue <= 21 && (dealerValue > 21 || mainHandValue > dealerValue)) {
+                    balance = balance.add(game.getBet().multiply(BigDecimal.valueOf(2)));
+                } else if (mainHandValue == dealerValue) {
+                    balance = balance.add(game.getBet());
+                }
+                
+                if (splitHandValue <= 21 && (dealerValue > 21 || splitHandValue > dealerValue)) {
+                    balance = balance.add(game.getSplitBet().multiply(BigDecimal.valueOf(2)));
+                } else if (splitHandValue == dealerValue) {
+                    balance = balance.add(game.getSplitBet());
+                }
+            } else if (game.getState() == BlackJackState.DRAW) {
+                balance = balance.add(totalBet);
+            }
+        } else {
+            if (isWin) {
+                balance = balance.add(totalBet.multiply(BigDecimal.valueOf(2)));
+            } else if (game.getState() == BlackJackState.DRAW) {
+                balance = balance.add(totalBet);
+            }
+        }
+        
+        user.setBalance(balance);
+        userRepository.save(user);
+    }
+
+    private void initializeDeck(BlackJackGameEntity game) {
+        for (Suit suit : Suit.values()) {
+            for (Rank rank : Rank.values()) {
+                CardEntity card = new CardEntity();
+                card.setGame(game);
+                card.setSuit(suit);
+                card.setRank(rank);
+                card.setCardType(CardType.DECK);
+                game.getDeck().add(card);
+            }
+        }
+
+        java.util.Collections.shuffle(game.getDeck(), random);
+    }
+
+    private CardEntity drawCardFromDeck(BlackJackGameEntity game) {
+        if (game.getDeck().isEmpty()) {
+            throw new IllegalStateException("Deck is empty");
+        }
+
+        return game.getDeck().removeFirst();
+    }
+
+    private BlackJackState getState(BlackJackGameEntity game) {
+        int playerHandValue = calculateHandValue(game.getPlayerCards());
+
+        if (playerHandValue == 21) {
+            CardEntity hole = drawCardFromDeck(game);
+            hole.setCardType(CardType.DEALER);
+            game.getDealerCards().add(hole);
+
+            int dealerHandValue = calculateHandValue(game.getDealerCards());
+
+            if (dealerHandValue == 21) {
+                return BlackJackState.DRAW;
+            } else {
+                BigDecimal blackjackWinnings = game.getBet().multiply(new BigDecimal("1.5"));
+                UserEntity user = getUserWithFreshData(game.getUser());
+                user.setBalance(user.getBalance().add(blackjackWinnings));
+                return BlackJackState.PLAYER_BLACKJACK;
+            }
+        } else if (playerHandValue > 21) {
+            return BlackJackState.PLAYER_LOST;
+        }
+
+        return BlackJackState.IN_PROGRESS;
+    }
+
+    private int calculateHandValue(List<CardEntity> hand) {
+        int sum = 0;
+        int aceCount = 0;
+        for (CardEntity card : hand) {
+            sum += card.getRank().getValue();
+            if (card.getRank() == Rank.ACE) {
+                aceCount++;
+            }
+        }
+
+        while (sum > 21 && aceCount > 0) {
+            sum -= 10;
+            aceCount--;
+        }
+
+        return sum;
+    }
+}

backend/src/main/java/de/szut/casino/blackjack/BlackJackState.java

@@ -0,0 +1,9 @@
+package de.szut.casino.blackjack;
+
+public enum BlackJackState {
+    IN_PROGRESS,
+    PLAYER_BLACKJACK,
+    PLAYER_LOST,
+    PLAYER_WON,
+    DRAW,
+}

backend/src/main/java/de/szut/casino/blackjack/CardEntity.java

@@ -0,0 +1,40 @@
+package de.szut.casino.blackjack;
+
+import com.fasterxml.jackson.annotation.JsonBackReference;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CardEntity {
+    @Id
+    @GeneratedValue
+    @JsonIgnore
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(name = "game_id", nullable = false)
+    @JsonBackReference
+    private BlackJackGameEntity game;
+
+    @Enumerated(EnumType.STRING)
+    private Suit suit;
+
+    @Enumerated(EnumType.STRING)
+    private Rank rank;
+
+    @Enumerated(EnumType.STRING)
+    @JsonIgnore
+    private CardType cardType;
+}
+
+enum CardType {
+    DECK, PLAYER, DEALER, PLAYER_SPLIT
+}

backend/src/main/java/de/szut/casino/blackjack/Rank.java

@@ -0,0 +1,31 @@
+package de.szut.casino.blackjack;
+
+import lombok.Getter;
+
+@Getter
+public enum Rank {
+    TWO("2", "Two", 2),
+    THREE("3", "Three", 3),
+    FOUR("4", "Four", 4),
+    FIVE("5", "Five", 5),
+    SIX("6", "Six", 6),
+    SEVEN("7", "Seven", 7),
+    EIGHT("8", "Eight", 8),
+    NINE("9", "Nine", 9),
+    TEN("10", "Ten", 10),
+    JACK("J", "Jack", 10),
+    QUEEN("Q", "Queen", 10),
+    KING("K", "King", 10),
+    ACE("A", "Ace", 11);
+
+    private final String symbol;
+    private final String displayName;
+    private final int value;
+
+    Rank(String symbol, String displayName, int value) {
+        this.symbol = symbol;
+        this.displayName = displayName;
+        this.value = value;
+    }
+
+}

backend/src/main/java/de/szut/casino/blackjack/Suit.java

@@ -0,0 +1,20 @@
+package de.szut.casino.blackjack;
+
+import lombok.Getter;
+
+@Getter
+public enum Suit {
+    HEARTS("H", "Hearts"),
+    DIAMONDS("D", "Diamonds"),
+    CLUBS("C", "Clubs"),
+    SPADES("S", "Spades");
+
+    private final String symbol;
+    private final String displayName;
+
+    Suit(String symbol, String displayName) {
+        this.symbol = symbol;
+        this.displayName = displayName;
+    }
+
+}

backend/src/main/java/de/szut/casino/blackjack/dto/CreateBlackJackGameDto.java

@@ -0,0 +1,16 @@
+package de.szut.casino.blackjack.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.math.BigDecimal;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CreateBlackJackGameDto {
+    private BigDecimal betAmount;
+}

backend/src/main/java/de/szut/casino/deposit/DepositController.java

@@ -52,10 +52,14 @@ public class DepositController {
 
         SessionCreateParams params = SessionCreateParams.builder()
                 .addLineItem(SessionCreateParams.LineItem.builder()
-                        .setAmount((long) amountDto.getAmount() * 100)
-                        .setCurrency("EUR")
+                        .setPriceData(SessionCreateParams.LineItem.PriceData.builder()
+                                .setCurrency("EUR")
+                                .setUnitAmount((long) amountDto.getAmount() * 100)
+                                .setProductData(SessionCreateParams.LineItem.PriceData.ProductData.builder()
+                                        .setName("Einzahlung")
+                                        .build())
+                                .build())
                         .setQuantity(1L)
-                        .setName("Einzahlung")
                         .build())
                 .setSuccessUrl(frontendHost+"/home?success=true")
                 .setCancelUrl(frontendHost+"/home?success=false")

backend/src/main/java/de/szut/casino/deposit/TransactionService.java

@@ -40,7 +40,7 @@ public class TransactionService {
                 .build();
         Session checkoutSession = Session.retrieve(sessionID, params, null);
 
-        if (!Objects.equals(checkoutSession.getPaymentStatus(), "paid")) {
+        if (!"paid".equals(checkoutSession.getPaymentStatus())) {
             return;
         }
 
@@ -53,10 +53,12 @@ public class TransactionService {
         transaction.setStatus(TransactionStatus.SUCCEEDED);
 
         UserEntity user = transaction.getUser();
-        user.addBalance(checkoutSession.getAmountTotal());
+        Long amountTotal = checkoutSession.getAmountTotal();
+        if (amountTotal != null) {
+            user.addBalance(amountTotal);
+        }
 
         userRepository.save(user);
         transactionRepository.save(transaction);
     }
-
 }

backend/src/main/java/de/szut/casino/deposit/WebhookController.java

@@ -51,12 +51,18 @@ public class WebhookController {
         switch (event.getType()) {
             case "checkout.session.completed":
             case "checkout.session.async_payment_succeeded":
-                Session session = (Session) event.getData().getObject();
-
-                this.transactionService.fulfillCheckout(session.getId());
+                EventDataObjectDeserializer dataObjectDeserializer = event.getDataObjectDeserializer();
+                
+                if (dataObjectDeserializer.getObject().isPresent()) {
+                    Session session = (Session) dataObjectDeserializer.getObject().get();
+                    this.transactionService.fulfillCheckout(session.getId());
+                } else {
+                    logger.error("Failed to deserialize webhook event data");
+                }
                 break;
             default:
-
+                // No action needed for other event types
+                break;
         }
 
         return ResponseEntity.ok().body(null);

backend/src/main/java/de/szut/casino/lootboxes/LootBoxController.java

@@ -0,0 +1,58 @@
+package de.szut.casino.lootboxes;
+
+import de.szut.casino.user.UserEntity;
+import de.szut.casino.user.UserRepository;
+import de.szut.casino.user.UserService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@RestController
+public class LootBoxController {
+    private final LootBoxRepository lootBoxRepository;
+    private final UserService userService;
+    private final LootBoxService lootBoxService;
+
+    public LootBoxController(LootBoxRepository lootBoxRepository, UserRepository userRepository, UserService userService, LootBoxService lootBoxService) {
+        this.lootBoxRepository = lootBoxRepository;
+        this.userService = userService;
+        this.lootBoxService = lootBoxService;
+    }
+
+    @GetMapping("/lootboxes")
+    public List<LootBoxEntity> getAllLootBoxes() {
+        return lootBoxRepository.findAll();
+    }
+
+    @PostMapping("/lootboxes/{id}")
+    public ResponseEntity<Object> purchaseLootBox(@PathVariable Long id, @RequestHeader("Authorization") String token) {
+        Optional<LootBoxEntity> optionalLootBox = lootBoxRepository.findById(id);
+        if (optionalLootBox.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        LootBoxEntity lootBox = optionalLootBox.get();
+
+        Optional<UserEntity> optionalUser = userService.getCurrentUser(token);
+        if (optionalUser.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        UserEntity user = optionalUser.get();
+
+        if (lootBoxService.hasSufficientBalance(user, lootBox.getPrice())) {
+            Map<String, String> errorResponse = new HashMap<>();
+            errorResponse.put("error", "Insufficient balance");
+            return ResponseEntity.badRequest().body(errorResponse);
+        }
+
+        RewardEntity reward = lootBoxService.determineReward(lootBox);
+        lootBoxService.handleBalance(user, lootBox, reward);
+
+        return ResponseEntity.ok(reward);
+    }
+}

backend/src/main/java/de/szut/casino/lootboxes/LootBoxEntity.java

@@ -0,0 +1,40 @@
+package de.szut.casino.lootboxes;
+
+import com.fasterxml.jackson.annotation.JsonBackReference;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonManagedReference;
+import de.szut.casino.blackjack.CardEntity;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.SQLRestriction;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class LootBoxEntity {
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private String name;
+
+    @Column(precision = 19, scale = 2)
+    private BigDecimal price;
+
+    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
+    @JoinTable(
+            name = "lootbox_reward",
+            joinColumns = @JoinColumn(name = "lootbox_id"),
+            inverseJoinColumns = @JoinColumn(name = "reward_id")
+    )
+    private List<RewardEntity> rewards = new ArrayList<>();
+}

backend/src/main/java/de/szut/casino/lootboxes/LootBoxRepository.java

@@ -0,0 +1,8 @@
+package de.szut.casino.lootboxes;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Service;
+
+@Service
+public interface LootBoxRepository extends JpaRepository<LootBoxEntity, Long> {
+}

backend/src/main/java/de/szut/casino/lootboxes/LootBoxService.java

@@ -0,0 +1,40 @@
+package de.szut.casino.lootboxes;
+
+import de.szut.casino.user.UserEntity;
+import de.szut.casino.user.UserRepository;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+
+@Service
+public class LootBoxService {
+    private final UserRepository userRepository;
+
+    public LootBoxService(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    public boolean hasSufficientBalance(UserEntity user, BigDecimal price) {
+        return user.getBalance().compareTo(price) < 0;
+    }
+
+    public RewardEntity determineReward(LootBoxEntity lootBox) {
+        double randomValue = Math.random();
+        BigDecimal cumulativeProbability = BigDecimal.ZERO;
+
+        for (RewardEntity reward : lootBox.getRewards()) {
+            cumulativeProbability = cumulativeProbability.add(reward.getProbability());
+            if (randomValue <= cumulativeProbability.doubleValue()) {
+                return reward;
+            }
+        }
+
+        return lootBox.getRewards().getLast();
+    }
+
+    public void handleBalance(UserEntity user, LootBoxEntity lootBox, RewardEntity reward) {
+        user.setBalance(user.getBalance().subtract(lootBox.getPrice()));
+        user.setBalance(user.getBalance().add(reward.getValue()));
+        userRepository.save(user);
+    }
+}

backend/src/main/java/de/szut/casino/lootboxes/RewardEntity.java

@@ -0,0 +1,30 @@
+package de.szut.casino.lootboxes;
+
+import com.fasterxml.jackson.annotation.JsonBackReference;
+import com.fasterxml.jackson.annotation.JsonManagedReference;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Setter
+@Entity
+public class RewardEntity {
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    @Column(precision = 19, scale = 2)
+    private BigDecimal value;
+
+    @Column(precision = 5, scale = 2)
+    private BigDecimal probability;
+
+    @ManyToMany(mappedBy = "rewards")
+    @JsonBackReference
+    private List<LootBoxEntity> lootBoxes = new ArrayList<>();
+}

backend/src/main/java/de/szut/casino/lootboxes/RewardRepository.java

@@ -0,0 +1,8 @@
+package de.szut.casino.lootboxes;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Service;
+
+@Service
+public interface RewardRepository extends JpaRepository<RewardEntity, Long> {
+}

backend/src/main/java/de/szut/casino/user/UserController.java

@@ -36,7 +36,7 @@ public class UserController {
 
     @GetMapping("/user")
     public ResponseEntity<GetUserDto> getCurrentUser(@RequestHeader("Authorization") String token) {
-        GetUserDto userData = userService.getCurrentUser(token);
+        GetUserDto userData = userService.getCurrentUserAsDto(token);
 
         if (userData == null) {
             return ResponseEntity.notFound().build();

backend/src/main/java/de/szut/casino/user/UserService.java

@@ -37,7 +37,7 @@ public class UserService {
         return user.map(userEntity -> mappingService.mapToGetUserDto(userEntity)).orElse(null);
     }
 
-    public GetUserDto getCurrentUser(String token) {
+    public GetUserDto getCurrentUserAsDto(String token) {
         KeycloakUserDto userData = getAuthentikUserInfo(token);
 
         if (userData == null) {
@@ -48,6 +48,15 @@ public class UserService {
         return user.map(userEntity -> mappingService.mapToGetUserDto(userEntity)).orElse(null);
     }
 
+    public Optional<UserEntity> getCurrentUser(String token) {
+        KeycloakUserDto userData = getKeycloakUserInfo(token);
+
+        if (userData == null) {
+            return Optional.empty();
+        }
+        return this.userRepository.findOneByKeycloakId(userData.getSub());
+    }
+
     private KeycloakUserDto getAuthentikUserInfo(String token) {
         try {
             HttpHeaders headers = new HttpHeaders();

backend/src/main/resources/application.properties

@@ -2,7 +2,7 @@ spring.datasource.url=jdbc:postgresql://${DB_HOST:localhost}:5432/postgresdb
 spring.datasource.username=postgres_user
 spring.datasource.password=postgres_pass
 server.port=8080
-spring.jpa.hibernate.ddl-auto=create-drop
+spring.jpa.hibernate.ddl-auto=update
 stripe.secret.key=${STRIPE_SECRET_KEY:sk_test_51QrePYIvCfqz7ANgqam8rEwWcMeKiLOof3j6SCMgu2sl4sESP45DJxca16mWcYo1sQaiBv32CMR6Z4AAAGQPCJo300ubuZKO8I}
 stripe.webhook.secret=whsec_746b6a488665f6057118bdb4a2b32f4916f16c277109eeaed5e8f8e8b81b8c15
 app.frontend-host=http://localhost:4200