Scrapers 2

src/main/java/com/appdev/allin/Application.java

@@ -21,6 +21,8 @@
 
 import org.springframework.scheduling.annotation.Scheduled;
 
+import com.appdev.allin.playerData.PlayerData;
+
 @SpringBootApplication
 @EnableScheduling
 public class Application {
@@ -67,9 +69,33 @@ public void checkAndProcessContracts() {
         }
     }
 
-    // TODO: Finish
     public boolean isContractHit(Contract contract) {
-        return true;
+
+        if (contract == null || contract.getPlayer() == null || contract.getEvent() == null || contract.getOpposingTeam() == null) {
+            return false;
+        }
+        if (contract.getExpired() != null && contract.getExpired()) {
+            return false;
+        }
+
+        // getting player data
+        List<PlayerData> playerDataList = playerDataRepo.findByPlayer(contract.getPlayer());
+
+        // no data found, so contract is not hit
+        if (playerDataList == null || playerDataList.isEmpty()) {
+            return false;
+        }
+        // comparing data to contract
+        for (PlayerData playerData : playerDataList) {
+            if (playerData.getOpposingTeam() == contract.getOpposingTeam()) {
+                Integer actualValue = playerData.getEvent(contract.getEvent());
+                if (actualValue >= contract.getEventThreshold()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+
     }
 
     private void processPayout(Contract contract) {

src/main/java/com/appdev/allin/DataInitializer.java

@@ -1,63 +1,84 @@
 package com.appdev.allin;
 
-import com.appdev.allin.player.PlayerRepo;
-import com.appdev.allin.playerData.PlayerDataRepo;
-import com.appdev.allin.gameData.GameDataRepo;
-
-import com.appdev.allin.scrapers.PlayerScraper;
-import com.appdev.allin.scrapers.PlayerDataScraper;
-import com.appdev.allin.scrapers.GameDataScraper;
-
-// import java.util.concurrent.Executors;
-// import java.util.concurrent.ScheduledExecutorService;
-// import java.util.concurrent.TimeUnit;
+import java.text.NumberFormat;
 
 import org.springframework.boot.context.event.ApplicationReadyEvent;
 import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Component;
 
+import com.appdev.allin.gameData.GameDataService;
+import com.appdev.allin.player.PlayerService;
+import com.appdev.allin.playerData.PlayerDataService;
+import com.appdev.allin.scrapers.GameDataScraper;
+import com.appdev.allin.scrapers.PlayerDataScraper;
+import com.appdev.allin.scrapers.PlayerScraper;
+
 @Component
 public class DataInitializer {
 
-        private final PlayerRepo playerRepo;
-        private final PlayerDataRepo playerDataRepo;
-        private final GameDataRepo gameDataRepo;
+        private final PlayerService playerService;
+        private final PlayerDataService playerDataService;
+        private final GameDataService gameDataService;
 
-        public DataInitializer(PlayerRepo playerRepo, PlayerDataRepo playerDataRepo, GameDataRepo gameDataRepo) {
-                this.playerRepo = playerRepo;
-                this.playerDataRepo = playerDataRepo;
-                this.gameDataRepo = gameDataRepo;
+        public DataInitializer(PlayerService playerService, PlayerDataService playerDataService, GameDataService gameDataService) {
+                this.playerService = playerService;
+                this.playerDataService = playerDataService;
+                this.gameDataService = gameDataService;
         }
 
         @EventListener(ApplicationReadyEvent.class)
         public void initializeData() {
-                // PlayerScraper playerScraper = new PlayerScraper(playerRepo);
-                // playerScraper.run();
+                logMemoryUsage("Before player scraper");
+                PlayerScraper playerScraper = new PlayerScraper(playerService);
+                playerScraper.run();
+
+                logMemoryUsage("After player scraper");
+
+                PlayerDataScraper playerDataScraper = new PlayerDataScraper(playerService,
+                playerDataService);
+                playerDataScraper.run();
+
+                logMemoryUsage("After player data scraper");
 
-                // PlayerDataScraper playerDataScraper = new PlayerDataScraper(playerRepo,
-                // playerDataRepo);
-                // playerDataScraper.run();
+                GameDataScraper gameDataScraper = new GameDataScraper(gameDataService);
+                gameDataScraper.run();
+                logMemoryUsage("After all scrapers");
 
-                // GameDataScraper gameDataScraper = new GameDataScraper(gameDataRepo);
-                // gameDataScraper.run();
-                // Uncomment the above lines to schedule the scrapers to run periodically
+                // Uncoment the above lines to schedule the scrapers to run periodically
 
                 // ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
 
                 // scheduler.scheduleAtFixedRate(() -> {
                 // try {
-                // PlayerScraper playerScraper = new PlayerScraper(playerRepo);
-                // playerScraper.run();
+                //         PlayerScraper playerScraper = new PlayerScraper(playerService);
+                //         playerScraper.run();
 
-                // PlayerDataScraper playerDataScraper = new PlayerDataScraper(playerRepo,
-                // playerDataRepo);
-                // playerDataScraper.run();
+                //         PlayerDataScraper playerDataScraper = new PlayerDataScraper(playerService,
+                //         playerDataService);
+                //         playerDataScraper.run();
 
-                // GameDataScraper gameDataScraper = new GameDataScraper(gameDataRepo);
-                // gameDataScraper.run();
+                //         GameDataScraper gameDataScraper = new GameDataScraper(gameDataService);
+                //         gameDataScraper.run();
                 // } catch (Exception e) {
                 // e.printStackTrace();
                 // }
                 // }, 0, 1, TimeUnit.DAYS); // Initial delay: 0, Repeat every 1 day
         }
+
+
+        private void logMemoryUsage(String point) {
+                Runtime runtime = Runtime.getRuntime();
+                NumberFormat format = NumberFormat.getInstance();
+
+                long maxMemory = runtime.maxMemory();
+                long allocatedMemory = runtime.totalMemory();
+                long freeMemory = runtime.freeMemory();
+                long usedMemory = allocatedMemory - freeMemory;
+
+                System.out.println("Memory Usage at " + point);
+                System.out.println("Max Memory: " + format.format(maxMemory / 1024 / 1024) + " MB");
+                System.out.println("Allocated Memory: " + format.format(allocatedMemory / 1024 / 1024) + " MB");
+                System.out.println("Used Memory: " + format.format(usedMemory / 1024 / 1024) + " MB");
+                System.out.println("Free Memory: " + format.format(freeMemory / 1024 / 1024) + " MB");
+        }
 }

src/main/java/com/appdev/allin/SecurityConfig.java

@@ -25,7 +25,8 @@ SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
                 "/swagger-ui/**",
                 "/v3/api-docs/**",
                 "/swagger-resources/**",
-                "/webjars/**")
+                "/webjars/**"
+                )
             .permitAll()
             .anyRequest().authenticated())
         // Needed for Spring to place the filter in the correct order

src/main/java/com/appdev/allin/gameData/GameDataService.java

@@ -0,0 +1,19 @@
+package com.appdev.allin.gameData;
+import org.springframework.stereotype.Service;
+
+@Service
+public class GameDataService {
+  private final GameDataRepo gameDataRepo;
+
+  public GameDataService(GameDataRepo gameDataRepo) {
+    this.gameDataRepo = gameDataRepo;
+  }
+
+  public GameData findByOpposingTeamAndGameDateTime(String opposingTeam, String gameDateTime) {
+    return gameDataRepo.findByOpposingTeamAndGameDateTime(opposingTeam, gameDateTime);
+  }
+
+  public GameData saveGameData(GameData gameData) {
+    return gameDataRepo.save(gameData);
+  }
+}

src/main/java/com/appdev/allin/player/PlayerService.java

@@ -1,8 +1,15 @@
 package com.appdev.allin.player;
 
-import com.appdev.allin.exceptions.NotFoundException;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.List;
+import java.util.Optional;
+
 import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.appdev.allin.exceptions.NotFoundException;
+import com.appdev.allin.utils.Constants;
 
 @Service
 public class PlayerService {
@@ -23,7 +30,118 @@ public Player getPlayerById(final Integer pid) {
     return player;
   }
 
+  public Player getPlayerByNumber(final Integer number) {
+    Player player = playerRepo.findByNumber(number);
+    return player;
+  }
+
+  public Player savePlayer(final Player player) {
+    Player existingPlayer = playerRepo.findByFirstNameAndLastName(player.getFirstName(),
+        player.getLastName());
+    if (existingPlayer == null) {
+      return playerRepo.save(player);
+    }
+    return existingPlayer;
+  }
+
+
   public Player createPlayer(final Player player) {
     return playerRepo.save(player);
   }
-}
+
+  public Player updatePlayer(final Integer player_id, final Player player)
+      throws NotFoundException {
+    Optional<Player> playerOptional = playerRepo.findById(player_id);
+    if (playerOptional.isEmpty()) {
+      throw new NotFoundException("Player with id " + player_id + " not found.");
+    }
+    Player playerToUpdate = playerOptional.get();
+    playerToUpdate.setFirstName(player.getFirstName());
+    playerToUpdate.setLastName(player.getLastName());
+    playerToUpdate.setPositions(player.getPositions());
+    playerToUpdate.setNumber(player.getNumber());
+    playerToUpdate.setHeight(player.getHeight());
+    playerToUpdate.setWeight(player.getWeight());
+    playerToUpdate.setHometown(player.getHometown());
+    playerToUpdate.setHighSchool(player.getHighSchool());
+    playerToUpdate.setImage(player.getImage());
+    return playerRepo.save(playerToUpdate);
+  }
+
+  public Player deletePlayer(final Integer player_id) throws NotFoundException {
+    Optional<Player> playerOptional = playerRepo.findById(player_id);
+    if (playerOptional.isEmpty()) {
+      throw new NotFoundException("Player with id " + player_id + " not found.");
+    }
+    playerRepo.deleteById(player_id);
+    return playerOptional.get();
+  }
+
+  public byte[] getImageFromStorage(final String uploadDirectory, final String fileName) {
+    Path uploadPath = Path.of(uploadDirectory);
+    Path filePath = uploadPath.resolve(fileName);
+    try {
+      return Files.readAllBytes(filePath);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return null;
+  }
+
+  public void updatePlayerImageById(
+      final Integer player_id, final MultipartFile image, final String uploadDirectory)
+      throws NotFoundException {
+    Optional<Player> playerOptional = playerRepo.findById(player_id);
+    if (playerOptional.isEmpty()) {
+      throw new NotFoundException("Player with id " + player_id + " not found.");
+    }
+    Player playerToUpdate = playerOptional.get();
+    String uniqueFileName = player_id + "_" + image.getOriginalFilename();
+    Path uploadPath = Path.of(uploadDirectory);
+    Path filePath = uploadPath.resolve(uniqueFileName);
+    if (!Files.exists(uploadPath)) {
+      try {
+        Files.createDirectories(uploadPath);
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    }
+    try {
+      Files.copy(
+          image.getInputStream(), filePath, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    playerToUpdate.setImage(uploadDirectory + uniqueFileName);
+    playerRepo.save(playerToUpdate);
+  }
+
+  public boolean deletePlayerImageById(final Integer player_id, final String uploadDirectory)
+      throws NotFoundException {
+    Optional<Player> playerOptional = playerRepo.findById(player_id);
+    if (playerOptional.isEmpty()) {
+      throw new NotFoundException("Player with id " + player_id + " not found.");
+    }
+    Player playerToUpdate = playerOptional.get();
+    String image = playerToUpdate.getImage();
+    if (image.equals(Constants.DEFAULT_PLAYER_IMAGE)) {
+      return false;
+    }
+    Path pathToFile = Path.of(playerToUpdate.getImage());
+    try {
+      Files.delete(pathToFile);
+      playerToUpdate.setImage("src/main/resources/static/images/players/default.jpg");
+      playerRepo.save(playerToUpdate);
+      return true;
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return false;
+  }
+
+  public Player getPlayerByFirstNameAndLastName(final String firstName,
+      final String lastName) {
+    Player player = playerRepo.findByFirstNameAndLastName(firstName, lastName);
+    return player;
+  }
+}

src/main/java/com/appdev/allin/playerData/PlayerDataService.java

@@ -28,4 +28,8 @@ public List<PlayerData> getPlayerDataByPlayer(final Player player) {
   public List<PlayerData> getPlayerDataByDate(final LocalDate gameDate) {
     return playerDataRepo.findByGameDate(gameDate);
   }
+
+  public List<PlayerData> getPlayerDataByDateAndPlayer(Player player, LocalDate gameDate) {
+    return playerDataRepo.findByPlayerAndGameDate(player, gameDate);
+}
 }

src/main/java/com/appdev/allin/scrapers/GameDataScraper.java

@@ -11,23 +11,23 @@
 import org.slf4j.LoggerFactory;
 
 import com.appdev.allin.gameData.GameData;
-import com.appdev.allin.gameData.GameDataRepo;
+import com.appdev.allin.gameData.GameDataService;
 
 public class GameDataScraper {
     private static final Logger logger = LoggerFactory.getLogger(GameDataScraper.class);
 
-    private final GameDataRepo gameDataRepo;
+    private final GameDataService gameDataService;
 
-    public GameDataScraper(GameDataRepo gameDataRepo) {
-        this.gameDataRepo = Objects.requireNonNull(gameDataRepo);
+    public GameDataScraper(GameDataService gameDataService) {
+        this.gameDataService = Objects.requireNonNull(gameDataService);
     }
 
-    private static final String SCHEDULE_URL = "https://cornellbigred.com/sports/mens-basketball/schedule/2024-25";
+    private static final String BASE_URL = "https://cornellbigred.com/sports/mens-basketball/schedule/2024-25";
 
-    public void populateUpcomingGames() throws IOException {
-        logger.info("Scraping game schedule data from URL: {}", SCHEDULE_URL);
+    public void populate() throws IOException {
+        logger.info("Scraping game schedule data from URL: {}", BASE_URL);
         try {
-            Document doc = Jsoup.connect(SCHEDULE_URL).get();
+            Document doc = Jsoup.connect(BASE_URL).get();
 
             Elements gameElements = doc.select("div.sidearm-schedule-game-opponent-name");
             Elements dateElements = doc.select("div.sidearm-schedule-game-opponent-date");
@@ -63,11 +63,12 @@ public void populateUpcomingGames() throws IOException {
                 logger.info("Upcoming Game {}: {} on {} in {}, Logo URL: {}", i + 1, opponentName, gameDate,
                         fullLocation, logoUrl);
                 GameData gameData = new GameData(opponentName, gameDate, fullLocation, logoUrl);
-                if (gameDataRepo.findByOpposingTeamAndGameDateTime(opponentName, gameDate) == null) {
-                    gameDataRepo.save(gameData);
+                if (gameDataService.findByOpposingTeamAndGameDateTime(opponentName, gameDate) == null) {
+                    gameDataService.saveGameData(gameData);
                 } else {
                     logger.info("Game {} with opponent: {} already exists in the database", i + 1, opponentName);
                 }
+                System.gc();
             }
 
             logger.info("Game schedule scraping completed");
@@ -80,7 +81,7 @@ public void populateUpcomingGames() throws IOException {
 
     public void run() {
         try {
-            populateUpcomingGames();
+            populate();
         } catch (IOException e) {
             logger.error("Failed to populate game schedule data: {}", e.getMessage());
         }