From 4d04b75c855f08f2683ffd766bc72325e7f7982a Mon Sep 17 00:00:00 2001 From: YZY <1104325451@qq.com> Date: Wed, 9 Apr 2025 21:25:51 +0800 Subject: [PATCH] xiu3 --- server/.idea/uiDesigner.xml | 124 ++++ server/.idea/workspace.xml | 1 + .../self/cases/teams/teaa/BankSystem.java | 395 ++++++++++++ .../self/cases/teams/teaa/BankingSystem.java | 380 ++++++++++++ .../java/self/cases/teams/teaa/Bookstore.java | 154 +++++ .../self/cases/teams/teaa/ClubManage.java | 578 ++++++++++++++++++ .../teams/teaa/ClubManagementSystem.java | 392 ++++++++++++ .../cases/teams/teaa/ECommercePlatform.java | 422 +++++++++++++ .../java/self/cases/teams/teaa/Managexiu.java | 390 ++++++++++++ .../cases/teams/teaa/BankSystem$Account.class | Bin 0 -> 2051 bytes .../teams/teaa/BankSystem$Transaction.class | Bin 0 -> 1260 bytes .../self/cases/teams/teaa/BankSystem.class | Bin 0 -> 14068 bytes .../teams/teaa/BankingSystem$Account.class | Bin 0 -> 2644 bytes .../cases/teams/teaa/BankingSystem$Loan.class | Bin 0 -> 2957 bytes .../self/cases/teams/teaa/BankingSystem.class | Bin 0 -> 11561 bytes .../cases/teams/teaa/Bookstore$Book.class | Bin 0 -> 1111 bytes .../cases/teams/teaa/Bookstore$Order.class | Bin 0 -> 1426 bytes .../self/cases/teams/teaa/Bookstore.class | Bin 0 -> 3789 bytes .../cases/teams/teaa/ClubManage$Club.class | Bin 0 -> 2167 bytes .../cases/teams/teaa/ClubManage$Event.class | Bin 0 -> 2104 bytes .../cases/teams/teaa/ClubManage$Member.class | Bin 0 -> 2075 bytes .../self/cases/teams/teaa/ClubManage.class | Bin 0 -> 20688 bytes .../teaa/ClubManagementSystem$Club.class | Bin 0 -> 1973 bytes .../teaa/ClubManagementSystem$Event.class | Bin 0 -> 1765 bytes .../teaa/ClubManagementSystem$Member.class | Bin 0 -> 1725 bytes .../teams/teaa/ClubManagementSystem.class | Bin 0 -> 11325 bytes .../teams/teaa/ECommercePlatform$Order.class | Bin 0 -> 2788 bytes .../teaa/ECommercePlatform$OrderItem.class | Bin 0 -> 1421 bytes .../teaa/ECommercePlatform$Product.class | Bin 0 -> 1857 bytes .../teams/teaa/ECommercePlatform$User.class | Bin 0 -> 1597 bytes .../cases/teams/teaa/ECommercePlatform.class | Bin 0 -> 12626 bytes .../cases/teams/teaa/Managexiu$User.class | Bin 0 -> 3409 bytes .../self/cases/teams/teaa/Managexiu.class | Bin 0 -> 25510 bytes 33 files changed, 2836 insertions(+) create mode 100644 server/.idea/uiDesigner.xml create mode 100644 server/src/main/java/self/cases/teams/teaa/BankSystem.java create mode 100644 server/src/main/java/self/cases/teams/teaa/BankingSystem.java create mode 100644 server/src/main/java/self/cases/teams/teaa/Bookstore.java create mode 100644 server/src/main/java/self/cases/teams/teaa/ClubManage.java create mode 100644 server/src/main/java/self/cases/teams/teaa/ClubManagementSystem.java create mode 100644 server/src/main/java/self/cases/teams/teaa/ECommercePlatform.java create mode 100644 server/src/main/java/self/cases/teams/teaa/Managexiu.java create mode 100644 server/target/classes/self/cases/teams/teaa/BankSystem$Account.class create mode 100644 server/target/classes/self/cases/teams/teaa/BankSystem$Transaction.class create mode 100644 server/target/classes/self/cases/teams/teaa/BankSystem.class create mode 100644 server/target/classes/self/cases/teams/teaa/BankingSystem$Account.class create mode 100644 server/target/classes/self/cases/teams/teaa/BankingSystem$Loan.class create mode 100644 server/target/classes/self/cases/teams/teaa/BankingSystem.class create mode 100644 server/target/classes/self/cases/teams/teaa/Bookstore$Book.class create mode 100644 server/target/classes/self/cases/teams/teaa/Bookstore$Order.class create mode 100644 server/target/classes/self/cases/teams/teaa/Bookstore.class create mode 100644 server/target/classes/self/cases/teams/teaa/ClubManage$Club.class create mode 100644 server/target/classes/self/cases/teams/teaa/ClubManage$Event.class create mode 100644 server/target/classes/self/cases/teams/teaa/ClubManage$Member.class create mode 100644 server/target/classes/self/cases/teams/teaa/ClubManage.class create mode 100644 server/target/classes/self/cases/teams/teaa/ClubManagementSystem$Club.class create mode 100644 server/target/classes/self/cases/teams/teaa/ClubManagementSystem$Event.class create mode 100644 server/target/classes/self/cases/teams/teaa/ClubManagementSystem$Member.class create mode 100644 server/target/classes/self/cases/teams/teaa/ClubManagementSystem.class create mode 100644 server/target/classes/self/cases/teams/teaa/ECommercePlatform$Order.class create mode 100644 server/target/classes/self/cases/teams/teaa/ECommercePlatform$OrderItem.class create mode 100644 server/target/classes/self/cases/teams/teaa/ECommercePlatform$Product.class create mode 100644 server/target/classes/self/cases/teams/teaa/ECommercePlatform$User.class create mode 100644 server/target/classes/self/cases/teams/teaa/ECommercePlatform.class create mode 100644 server/target/classes/self/cases/teams/teaa/Managexiu$User.class create mode 100644 server/target/classes/self/cases/teams/teaa/Managexiu.class diff --git a/server/.idea/uiDesigner.xml b/server/.idea/uiDesigner.xml new file mode 100644 index 00000000..2b63946d --- /dev/null +++ b/server/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/server/.idea/workspace.xml b/server/.idea/workspace.xml index a74db1e5..a846d08b 100644 --- a/server/.idea/workspace.xml +++ b/server/.idea/workspace.xml @@ -145,6 +145,7 @@ + diff --git a/server/src/main/java/self/cases/teams/teaa/BankSystem.java b/server/src/main/java/self/cases/teams/teaa/BankSystem.java new file mode 100644 index 00000000..c0d2e50b --- /dev/null +++ b/server/src/main/java/self/cases/teams/teaa/BankSystem.java @@ -0,0 +1,395 @@ +package self.cases.teams.teaa; + +import java.util.*; +import java.util.stream.Collectors; + +public class BankSystem { + private Map accounts; + private List transactions; + + public BankSystem() { + accounts = new HashMap<>(); + transactions = new ArrayList<>(); + } + + // Inner class to represent an Account + public static class Account { + private String accountNumber; + private String owner; + private double balance; + + public Account(String accountNumber, String owner, double initialBalance) { + this.accountNumber = accountNumber; + this.owner = owner; + this.balance = initialBalance; + } + + public String getAccountNumber() { + return accountNumber; + } + + public String getOwner() { + return owner; + } + + public double getBalance() { + return balance; + } + + public void deposit(double amount) { + if (amount > 0) { + balance += amount; + } else { + throw new IllegalArgumentException("Deposit amount must be positive"); + } + } + + public void withdraw(double amount) { + if (amount > 0 && amount <= balance) { + balance -= amount; + } else { + throw new IllegalArgumentException("Invalid withdrawal amount"); + } + } + + public void transfer(Account target, double amount) { + if (amount > 0 && amount <= balance) { + balance -= amount; + target.deposit(amount); + System.out.println("Transfer of $" + amount + " from " + accountNumber + " to " + target.getAccountNumber() + " successful."); + } else { + throw new IllegalArgumentException("Invalid transfer amount"); + } + } + } + + // Inner class to represent a Transaction + public static class Transaction { + private String transactionId; + private String fromAccount; + private String toAccount; + private double amount; + private Date timestamp; + + public Transaction(String transactionId, String fromAccount, String toAccount, double amount, Date timestamp) { + this.transactionId = transactionId; + this.fromAccount = fromAccount; + this.toAccount = toAccount; + this.amount = amount; + this.timestamp = timestamp; + } + + public String getTransactionId() { + return transactionId; + } + + public String getFromAccount() { + return fromAccount; + } + + public String getToAccount() { + return toAccount; + } + + public double getAmount() { + return amount; + } + + public Date getTimestamp() { + return timestamp; + } + } + + // Method to create a new account + public String createAccount(String owner, double initialBalance) { + String accountNumber = generateAccountNumber(); + Account account = new Account(accountNumber, owner, initialBalance); + accounts.put(accountNumber, account); + return accountNumber; + } + + // Method to generate a unique account number + private String generateAccountNumber() { + Random random = new Random(); + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < 10; i++) { + sb.append(random.nextInt(10)); + } + return sb.toString(); + } + + // Method to deposit money into an account + public void deposit(String accountNumber, double amount) { + Account account = accounts.get(accountNumber); + if (account == null) { + throw new IllegalArgumentException("Account not found"); + } + account.deposit(amount); + transactions.add(new Transaction(UUID.randomUUID().toString(), accountNumber, accountNumber, amount, new Date())); + } + + // Method to withdraw money from an account + public void withdraw(String accountNumber, double amount) { + Account account = accounts.get(accountNumber); + if (account == null) { + throw new IllegalArgumentException("Account not found"); + } + account.withdraw(amount); + transactions.add(new Transaction(UUID.randomUUID().toString(), accountNumber, accountNumber, -amount, new Date())); + } + + // Method to transfer money between accounts + public void transfer(String fromAccountNumber, String toAccountNumber, double amount) { + Account fromAccount = accounts.get(fromAccountNumber); + Account toAccount = accounts.get(toAccountNumber); + if (fromAccount == null || toAccount == null) { + throw new IllegalArgumentException("One or both accounts not found"); + } + fromAccount.transfer(toAccount, amount); + transactions.add(new Transaction(UUID.randomUUID().toString(), fromAccountNumber, toAccountNumber, amount, new Date())); + } + + // Method to list all accounts + public List listAllAccounts() { + return new ArrayList<>(accounts.values()); + } + + // Method to list all transactions + public List listAllTransactions() { + return new ArrayList<>(transactions); + } + + // Method to find an account by account number + public Account findAccountByNumber(String accountNumber) { + return accounts.get(accountNumber); + } + + // Method to calculate total balance of all accounts + public double calculateTotalBalance() { + double totalBalance = 0; + for (Account account : accounts.values()) { + totalBalance += account.getBalance(); + } + return totalBalance; + } + + // Method to calculate average account balance + public double calculateAverageBalance() { + if (accounts.isEmpty()) { + return 0; + } + double totalBalance = 0; + for (Account account : accounts.values()) { + totalBalance += account.getBalance(); + } + return totalBalance / accounts.size(); + } + + // Method to list top accounts by balance + public List listTopAccountsByBalance(int topN) { + return accounts.values() + .stream() + .sorted((a1, a2) -> Double.compare(a2.getBalance(), a1.getBalance())) + .limit(topN) + .collect(Collectors.toList()); + } + + // Method to list most active accounts + public List listMostActiveAccounts(int topN) { + Map activityMap = new HashMap<>(); + for (Transaction transaction : transactions) { + Account account = accounts.get(transaction.getFromAccount()); + if (account != null) { + activityMap.put(account, activityMap.getOrDefault(account, 0) + 1); + } + account = accounts.get(transaction.getToAccount()); + if (account != null) { + activityMap.put(account, activityMap.getOrDefault(account, 0) + 1); + } + } + return activityMap.entrySet() + .stream() + .sorted(Map.Entry.comparingByValue().reversed()) + .limit(topN) + .map(Map.Entry::getKey) + .collect(Collectors.toList()); + } + + // Method to list recent transactions + public List listRecentTransactions(int limit) { + return transactions.stream() + .sorted((t1, t2) -> t2.getTimestamp().compareTo(t1.getTimestamp())) + .limit(limit) + .collect(Collectors.toList()); + } + + // Method to list transactions by account + public List listTransactionsByAccount(String accountNumber) { + return transactions.stream() + .filter(t -> t.getFromAccount().equals(accountNumber) || t.getToAccount().equals(accountNumber)) + .collect(Collectors.toList()); + } + + // Method to calculate total deposits + public double calculateTotalDeposits() { + double totalDeposits = 0; + for (Transaction transaction : transactions) { + if (transaction.getAmount() > 0) { + totalDeposits += transaction.getAmount(); + } + } + return totalDeposits; + } + + // Method to calculate total withdrawals + public double calculateTotalWithdrawals() { + double totalWithdrawals = 0; + for (Transaction transaction : transactions) { + if (transaction.getAmount() < 0) { + totalWithdrawals -= transaction.getAmount(); + } + } + return totalWithdrawals; + } + + // Method to calculate total transfers + public double calculateTotalTransfers() { + double totalTransfers = 0; + for (Transaction transaction : transactions) { + if (transaction.getAmount() > 0) { + totalTransfers += transaction.getAmount(); + } + } + return totalTransfers; + } + + // Method to list all owners + public Set listAllOwners() { + return accounts.values().stream() + .map(Account::getOwner) + .collect(Collectors.toSet()); + } + + // Method to list accounts by owner + public List listAccountsByOwner(String owner) { + return accounts.values().stream() + .filter(a -> a.getOwner().equals(owner)) + .collect(Collectors.toList()); + } + + // Method to list accounts with low balance + public List listAccountsWithLowBalance(double threshold) { + return accounts.values().stream() + .filter(a -> a.getBalance() < threshold) + .collect(Collectors.toList()); + } + + // Method to list accounts with high balance + public List listAccountsWithHighBalance(double threshold) { + return accounts.values().stream() + .filter(a -> a.getBalance() >= threshold) + .collect(Collectors.toList()); + } + + // Main method to demonstrate functionality + public static void main(String[] args) { + BankSystem bank = new BankSystem(); + + // Creating accounts + String account1 = bank.createAccount("Alice Smith", 1000); + String account2 = bank.createAccount("Bob Johnson", 500); + String account3 = bank.createAccount("Charlie Brown", 2000); + + // Depositing money + bank.deposit(account1, 500); + bank.deposit(account2, 200); + + // Withdrawing money + bank.withdraw(account1, 200); + + // Transferring money + bank.transfer(account1, account2, 300); + + // Listing all accounts + System.out.println("\\nList of Accounts:"); + for (Account account : bank.listAllAccounts()) { + System.out.println("Account Number: " + account.getAccountNumber() + ", Owner: " + account.getOwner() + ", Balance: $" + account.getBalance()); + } + + // Listing all transactions + System.out.println("\\nList of Transactions:"); + for (Transaction transaction : bank.listAllTransactions()) { + System.out.println("Transaction ID: " + transaction.getTransactionId() + ", From: " + transaction.getFromAccount() + ", To: " + transaction.getToAccount() + ", Amount: $" + transaction.getAmount() + ", Timestamp: " + transaction.getTimestamp()); + } + + // Finding an account by number + Account account = bank.findAccountByNumber(account1); + if (account != null) { + System.out.println("\\nAccount Found: " + account.getAccountNumber() + ", Owner: " + account.getOwner() + ", Balance: $" + account.getBalance()); + } + + // Calculating total balance + System.out.println("\\nTotal Balance: $" + bank.calculateTotalBalance()); + + // Calculating average balance + System.out.println("Average Balance: $" + bank.calculateAverageBalance()); + + // Listing top accounts by balance + System.out.println("\\nTop Accounts by Balance:"); + for (Account topAccount : bank.listTopAccountsByBalance(2)) { + System.out.println(topAccount.getAccountNumber() + ", Owner: " + topAccount.getOwner() + ", Balance: $" + topAccount.getBalance()); + } + + // Listing most active accounts + System.out.println("\\nMost Active Accounts:"); + for (Account activeAccount : bank.listMostActiveAccounts(2)) { + System.out.println(activeAccount.getAccountNumber() + ", Owner: " + activeAccount.getOwner()); + } + + // Listing recent transactions + System.out.println("\\nRecent Transactions:"); + for (Transaction recentTransaction : bank.listRecentTransactions(5)) { + System.out.println(recentTransaction.getTransactionId() + ", From: " + recentTransaction.getFromAccount() + ", To: " + recentTransaction.getToAccount() + ", Amount: $" + recentTransaction.getAmount() + ", Timestamp: " + recentTransaction.getTimestamp()); + } + + // Listing transactions by account + System.out.println("\\nTransactions by Account " + account1 + ":"); + for (Transaction transaction : bank.listTransactionsByAccount(account1)) { + System.out.println(transaction.getTransactionId() + ", From: " + transaction.getFromAccount() + ", To: " + transaction.getToAccount() + ", Amount: $" + transaction.getAmount() + ", Timestamp: " + transaction.getTimestamp()); + } + + // Calculating total deposits + System.out.println("\\nTotal Deposits: $" + bank.calculateTotalDeposits()); + + // Calculating total withdrawals + System.out.println("Total Withdrawals: $" + bank.calculateTotalWithdrawals()); + + // Calculating total transfers + System.out.println("Total Transfers: $" + bank.calculateTotalTransfers()); + + // Listing all owners + System.out.println("\\nList of Owners:"); + for (String owner : bank.listAllOwners()) { + System.out.println(owner); + } + + // Listing accounts by owner + System.out.println("\\nAccounts by Owner Alice Smith:"); + for (Account accountByOwner : bank.listAccountsByOwner("Alice Smith")) { + System.out.println(accountByOwner.getAccountNumber() + ", Balance: $" + accountByOwner.getBalance()); + } + + // Listing accounts with low balance + System.out.println("\\nAccounts with Low Balance (<$500):"); + for (Account lowBalanceAccount : bank.listAccountsWithLowBalance(500)) { + System.out.println(lowBalanceAccount.getAccountNumber() + ", Owner: " + lowBalanceAccount.getOwner() + ", Balance: $" + lowBalanceAccount.getBalance()); + } + + // Listing accounts with high balance + System.out.println("\\nAccounts with High Balance (>= $1500):"); + for (Account highBalanceAccount : bank.listAccountsWithHighBalance(1500)) { + System.out.println(highBalanceAccount.getAccountNumber() + ", Owner: " + highBalanceAccount.getOwner() + ", Balance: $" + highBalanceAccount.getBalance()); + } + } +} + diff --git a/server/src/main/java/self/cases/teams/teaa/BankingSystem.java b/server/src/main/java/self/cases/teams/teaa/BankingSystem.java new file mode 100644 index 00000000..eafe41f1 --- /dev/null +++ b/server/src/main/java/self/cases/teams/teaa/BankingSystem.java @@ -0,0 +1,380 @@ +package self.cases.teams.teaa; + +import java.util.*; +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.stream.Collectors; + +public class BankingSystem { + private static Map accounts; + private Map loans; + + public BankingSystem() { + accounts = new HashMap<>(); + loans = new HashMap<>(); + } + + // Inner class to represent an Account + public static class Account { + private String accountId; + private String ownerName; + private BigDecimal balance; + + public Account(String accountId, String ownerName, BigDecimal initialBalance) { + this.accountId = accountId; + this.ownerName = ownerName; + this.balance = initialBalance; + } + + public String getAccountId() { + return accountId; + } + + public String getOwnerName() { + return ownerName; + } + + public BigDecimal getBalance() { + return balance; + } + + public void deposit(BigDecimal amount) { + if (amount.compareTo(BigDecimal.ZERO) <= 0) { + throw new IllegalArgumentException("Deposit amount must be positive"); + } + balance = balance.add(amount); + } + + public void withdraw(BigDecimal amount) { + if (amount.compareTo(BigDecimal.ZERO) <= 0) { + throw new IllegalArgumentException("Withdrawal amount must be positive"); + } + if (balance.compareTo(amount) < 0) { + throw new IllegalArgumentException("Insufficient funds"); + } + balance = balance.subtract(amount); + } + + public void transfer(Account targetAccount, BigDecimal amount) { + if (amount.compareTo(BigDecimal.ZERO) <= 0) { + throw new IllegalArgumentException("Transfer amount must be positive"); + } + if (this.balance.compareTo(amount) < 0) { + throw new IllegalArgumentException("Insufficient funds"); + } + this.withdraw(amount); + targetAccount.deposit(amount); + } + + @Override + public String toString() { + return "Account{" + + "accountId='" + accountId + '\\' + + ", ownerName='" + ownerName + '\\' + + ", balance=" + balance + + '}'; + } + + public List getTransferRecords() { + return null; + } + } + + // Inner class to represent a Loan + public static class Loan { + private String loanId; + private String accountId; + private BigDecimal amount; + private BigDecimal interestRate; + private LocalDateTime issueDate; + private LocalDateTime dueDate; + private boolean paid; + + public Loan(String loanId, String accountId, BigDecimal amount, BigDecimal interestRate, LocalDateTime issueDate, LocalDateTime dueDate) { + this.loanId = loanId; + this.accountId = accountId; + this.amount = amount; + this.interestRate = interestRate; + this.issueDate = issueDate; + this.dueDate = dueDate; + this.paid = false; + } + + public String getLoanId() { + return loanId; + } + + public String getAccountId() { + return accountId; + } + + public BigDecimal getAmount() { + return amount; + } + + public BigDecimal getInterestRate() { + return interestRate; + } + + public LocalDateTime getIssueDate() { + return issueDate; + } + + public LocalDateTime getDueDate() { + return dueDate; + } + + public boolean isPaid() { + return paid; + } + + public void payLoan() { + if (paid) { + throw new IllegalStateException("Loan already paid"); + } + Account account = accounts.get(accountId); + if (account == null) { + throw new IllegalArgumentException("Account not found"); + } + BigDecimal totalAmount = amount.add(amount.multiply(interestRate)); + account.withdraw(totalAmount); + paid = true; + } + + @Override + public String toString() { + return "Loan{" + + "loanId='" + loanId + '\\' + + ", accountId='" + accountId + '\\' + + ", amount=" + amount + + ", interestRate=" + interestRate + + ", issueDate=" + issueDate + + ", dueDate=" + dueDate + + ", paid=" + paid + + '}'; + } + } + + // Method to add an account + public void addAccount(String accountId, String ownerName, BigDecimal initialBalance) { + if (accounts.containsKey(accountId)) { + throw new IllegalArgumentException("Account already exists"); + } + accounts.put(accountId, new Account(accountId, ownerName, initialBalance)); + } + + // Method to remove an account + public void removeAccount(String accountId) { + if (!accounts.containsKey(accountId)) { + throw new IllegalArgumentException("Account not found"); + } + accounts.remove(accountId); + } + + // Method to list all accounts + public List listAllAccounts() { + return new ArrayList<>(accounts.values()); + } + + // Method to find an account by ID + public Account findAccountById(String accountId) { + return accounts.get(accountId); + } + + // Method to deposit into an account + public void deposit(String accountId, BigDecimal amount) { + Account account = accounts.get(accountId); + if (account == null) { + throw new IllegalArgumentException("Account not found"); + } + account.deposit(amount); + } + + // Method to withdraw from an account + public void withdraw(String accountId, BigDecimal amount) { + Account account = accounts.get(accountId); + if (account == null) { + throw new IllegalArgumentException("Account not found"); + } + account.withdraw(amount); + } + + // Method to transfer between accounts + public void transfer(String sourceAccountId, String targetAccountId, BigDecimal amount) { + Account sourceAccount = accounts.get(sourceAccountId); + Account targetAccount = accounts.get(targetAccountId); + if (sourceAccount == null || targetAccount == null) { + throw new IllegalArgumentException("One or both accounts not found"); + } + sourceAccount.transfer(targetAccount, amount); + } + + // Method to list transfers + public List listTransfers(String accountId) { + Account account = accounts.get(accountId); + if (account == null) { + throw new IllegalArgumentException("Account not found"); + } + return account.getTransferRecords(); + } + + // Method to add a loan + public void addLoan(String loanId, String accountId, BigDecimal amount, BigDecimal interestRate, LocalDateTime issueDate, LocalDateTime dueDate) { + if (loans.containsKey(loanId)) { + throw new IllegalArgumentException("Loan already exists"); + } + loans.put(loanId, new Loan(loanId, accountId, amount, interestRate, issueDate, dueDate)); + } + + // Method to remove a loan + public void removeLoan(String loanId) { + if (!loans.containsKey(loanId)) { + throw new IllegalArgumentException("Loan not found"); + } + loans.remove(loanId); + } + + // Method to list all loans + public List listAllLoans() { + return new ArrayList<>(loans.values()); + } + + // Method to find a loan by ID + public Loan findLoanById(String loanId) { + return loans.get(loanId); + } + + // Method to pay a loan + public void payLoan(String loanId) { + Loan loan = loans.get(loanId); + if (loan == null) { + throw new IllegalArgumentException("Loan not found"); + } + loan.payLoan(); + } + + // Method to list unpaid loans + public List listUnpaidLoans() { + return loans.values().stream() + .filter(l -> !l.isPaid()) + .collect(Collectors.toList()); + } + + // Method to list loans by account + public List listLoansByAccount(String accountId) { + return loans.values().stream() + .filter(l -> l.getAccountId().equals(accountId)) + .collect(Collectors.toList()); + } + + // Method to list loans by issue date range + public List listLoansByDateRange(LocalDateTime startDate, LocalDateTime endDate) { + return loans.values().stream() + .filter(l -> !l.getIssueDate().isBefore(startDate) && !l.getIssueDate().isAfter(endDate)) + .collect(Collectors.toList()); + } + + // Method to list loans by due date range + public List listLoansByDueDateRange(LocalDateTime startDate, LocalDateTime endDate) { + return loans.values().stream() + .filter(l -> !l.getDueDate().isBefore(startDate) && !l.getDueDate().isAfter(endDate)) + .collect(Collectors.toList()); + } + + // Method to list loans by interest rate range + public List listLoansByInterestRateRange(BigDecimal minRate, BigDecimal maxRate) { + return loans.values().stream() + .filter(l -> l.getInterestRate().compareTo(minRate) >= 0 && l.getInterestRate().compareTo(maxRate) <= 0) + .collect(Collectors.toList()); + } + + // Method to list loans by amount range + public List listLoansByAmountRange(BigDecimal minAmount, BigDecimal maxAmount) { + return loans.values().stream() + .filter(l -> l.getAmount().compareTo(minAmount) >= 0 && l.getAmount().compareTo(maxAmount) <= 0) + .collect(Collectors.toList()); + } + + // Main method to demonstrate functionality + public static void main(String[] args) { + BankingSystem bank = new BankingSystem(); + + // Adding accounts + bank.addAccount("A001", "Alice", new BigDecimal("1000.00")); + bank.addAccount("A002", "Bob", new BigDecimal("500.00")); + + // Depositing into accounts + bank.deposit("A001", new BigDecimal("500.00")); + bank.deposit("A002", new BigDecimal("200.00")); + + // Withdrawing from accounts + bank.withdraw("A001", new BigDecimal("200.00")); + bank.withdraw("A002", new BigDecimal("100.00")); + + // Transferring between accounts + bank.transfer("A001", "A002", new BigDecimal("300.00")); + + // Listing all accounts + System.out.println("\\nList of Accounts:"); + for (Account account : bank.listAllAccounts()) { + System.out.println(account); + } + + // Finding an account by ID + Account aliceAccount = bank.findAccountById("A001"); + System.out.println("\\nAlice's Account: " + aliceAccount); + + // Adding loans + bank.addLoan("L001", "A001", new BigDecimal("1000.00"), new BigDecimal("0.05"), LocalDateTime.of(2023, 1, 1, 0, 0), LocalDateTime.of(2023, 12, 31, 23, 59)); + bank.addLoan("L002", "A002", new BigDecimal("500.00"), new BigDecimal("0.07"), LocalDateTime.of(2023, 2, 1, 0, 0), LocalDateTime.of(2023, 11, 30, 23, 59)); + + // Paying a loan + bank.payLoan("L001"); + + // Listing all loans + System.out.println("\\nList of Loans:"); + for (Loan loan : bank.listAllLoans()) { + System.out.println(loan); + } + + // Finding a loan by ID + Loan loan1 = bank.findLoanById("L001"); + System.out.println("\\nLoan L001: " + loan1); + + // Listing unpaid loans + System.out.println("\\nUnpaid Loans:"); + for (Loan unpaidLoan : bank.listUnpaidLoans()) { + System.out.println(unpaidLoan); + } + + // Listing loans by account + System.out.println("\\nLoans by Account A001:"); + for (Loan loan : bank.listLoansByAccount("A001")) { + System.out.println(loan); + } + + // Listing loans by issue date range + System.out.println("\\nLoans Issued Between 2023-01-01 and 2023-06-30:"); + for (Loan loan : bank.listLoansByDateRange(LocalDateTime.of(2023, 1, 1, 0, 0), LocalDateTime.of(2023, 6, 30, 23, 59))) { + System.out.println(loan); + } + + // Listing loans by due date range + System.out.println("\\nLoans Due Between 2023-07-01 and 2023-12-31:"); + for (Loan loan : bank.listLoansByDueDateRange(LocalDateTime.of(2023, 7, 1, 0, 0), LocalDateTime.of(2023, 12, 31, 23, 59))) { + System.out.println(loan); + } + + // Listing loans by interest rate range + System.out.println("\\nLoans with Interest Rate Between 5% and 7%:"); + for (Loan loan : bank.listLoansByInterestRateRange(new BigDecimal("0.05"), new BigDecimal("0.07"))) { + System.out.println(loan); + } + + // Listing loans by amount range + System.out.println("\\nLoans with Amount Between $500 and $1000:"); + for (Loan loan : bank.listLoansByAmountRange(new BigDecimal("500.00"), new BigDecimal("1000.00"))) { + System.out.println(loan); + } + } +} diff --git a/server/src/main/java/self/cases/teams/teaa/Bookstore.java b/server/src/main/java/self/cases/teams/teaa/Bookstore.java new file mode 100644 index 00000000..ae9619b4 --- /dev/null +++ b/server/src/main/java/self/cases/teams/teaa/Bookstore.java @@ -0,0 +1,154 @@ +package self.cases.teams.teaa; +import java.util.ArrayList; +import java.util.List; + +public class Bookstore { + private List books; + + public Bookstore() { + books = new ArrayList<>(); + } + + // Inner class to represent a Book + public static class Book { + private String title; + private String author; + private double price; + private int stock; + + public Book(String title, String author, double price, int stock) { + this.title = title; + this.author = author; + this.price = price; + this.stock = stock; + } + + public String getTitle() { + return title; + } + + public String getAuthor() { + return author; + } + + public double getPrice() { + return price; + } + + public int getStock() { + return stock; + } + + public void setStock(int stock) { + this.stock = stock; + } + } + + // Inner class to represent an Order + public static class Order { + private int orderId; + private String customerName; + private Book[] books; + private int[] quantities; + + public Order(int orderId, String customerName, Book[] books, int[] quantities) { + this.orderId = orderId; + this.customerName = customerName; + this.books = books; + this.quantities = quantities; + } + + public int getOrderId() { + return orderId; + } + + public String getCustomerName() { + return customerName; + } + + public Book[] getBooks() { + return books; + } + + public int[] getQuantities() { + return quantities; + } + + public double getTotalPrice() { + double total = 0; + for (int i = 0; i < books.length; i++) { + total += books[i].getPrice() * quantities[i]; + } + return total; + } + } + + // Method to add a book to the inventory + public void addBook(Book book) { + books.add(book); + } + + // Method to find a book by title + public Book findBookByTitle(String title) { + for (Book book : books) { + if (book.getTitle().equals(title)) { + return book; + } + } + return null; + } + + // Method to list all books in the inventory + public List listAllBooks() { + return new ArrayList<>(books); + } + + // Method to reduce stock after placing an order + public boolean reduceStock(String title, int quantity) { + Book book = findBookByTitle(title); + if (book != null && book.getStock() >= quantity) { + book.setStock(book.getStock() - quantity); + return true; + } + return false; + } + + // Main method to demonstrate functionality + public static void main(String[] args) { + Bookstore bookstore = new Bookstore(); + + // Adding some books to the inventory + bookstore.addBook(new Bookstore.Book("Effective Java", "Joshua Bloch", 49.99, 50)); + bookstore.addBook(new Bookstore.Book("Clean Code", "Robert C. Martin", 39.99, 30)); + bookstore.addBook(new Bookstore.Book("The Pragmatic Programmer", "Andrew Hunt", 29.99, 20)); + + // Listing all books in the inventory + System.out.println("List of Books:"); + for (Bookstore.Book book : bookstore.listAllBooks()) { + System.out.println(book.getTitle() + " by " + book.getAuthor()); + } + + // Placing an order + Bookstore.Book[] books = {bookstore.findBookByTitle("Effective Java"), bookstore.findBookByTitle("Clean Code")}; + int[] quantities = {2, 1}; + Bookstore.Order order = new Bookstore.Order(1, "John Doe", books, quantities); + + System.out.println("\\nOrder Details:"); + System.out.println("Customer: " + order.getCustomerName()); + System.out.println("Order ID: " + order.getOrderId()); + for (int i = 0; i < books.length; i++) { + System.out.println("Book: " + books[i].getTitle() + ", Quantity: " + quantities[i]); + } + System.out.println("Total Price: $" + order.getTotalPrice()); + + // Reducing stock after placing the order + bookstore.reduceStock("Effective Java", 2); + bookstore.reduceStock("Clean Code", 1); + + // Listing all books again to verify stock reduction + System.out.println("\\nUpdated List of Books:"); + for (Bookstore.Book book : bookstore.listAllBooks()) { + System.out.println(book.getTitle() + " by " + book.getAuthor() + ", Stock: " + book.getStock()); + } + } +} diff --git a/server/src/main/java/self/cases/teams/teaa/ClubManage.java b/server/src/main/java/self/cases/teams/teaa/ClubManage.java new file mode 100644 index 00000000..bacddcce --- /dev/null +++ b/server/src/main/java/self/cases/teams/teaa/ClubManage.java @@ -0,0 +1,578 @@ +package self.cases.teams.teaa; + +import java.util.*; +import java.time.LocalDate; +import java.util.stream.Collectors; + +public class ClubManage { + + private Map clubs; + private Map members; + private Map events; + + public ClubManage() { + clubs = new HashMap<>(); + members = new HashMap<>(); + events = new HashMap<>(); + } + + // Inner class to represent a Club + public static class Club { + private int clubId; + private String name; + private String description; + private LocalDate foundingDate; + private int memberCount; + + public Club(int clubId, String name, String description, LocalDate foundingDate) { + this.clubId = clubId; + this.name = name; + this.description = description; + this.foundingDate = foundingDate; + this.memberCount = 0; + } + + public int getClubId() { + return clubId; + } + + public String getName() { + return name; + } + + public String getDescription() { + return description; + } + + public LocalDate getFoundingDate() { + return foundingDate; + } + + public int getMemberCount() { + return memberCount; + } + + public void increaseMemberCount() { + this.memberCount++; + } + + public void decreaseMemberCount() { + if (this.memberCount > 0) { + this.memberCount--; + } + } + + @Override + public String toString() { + return "Club{" + + "clubId=" + clubId + + ", name='" + name + '\\' + + ", description='" + description + '\\' + + ", foundingDate=" + foundingDate + + ", memberCount=" + memberCount + + '}'; + } + + public void setName(String newName) { + } + + public void setDescription(String newDescription) { + } + } + + // Inner class to represent a Member + public static class Member { + private int memberId; + private String name; + private String email; + private String role; + private boolean isActive; + + public Member(int memberId, String name, String email, String role) { + this.memberId = memberId; + this.name = name; + this.email = email; + this.role = role; + this.isActive = true; + } + + public int getMemberId() { + return memberId; + } + + public String getName() { + return name; + } + + public String getEmail() { + return email; + } + + public String getRole() { + return role; + } + + public boolean isActive() { + return isActive; + } + + public void deactivate() { + this.isActive = false; + } + + @Override + public String toString() { + return "Member{" + + "memberId=" + memberId + + ", name='" + name + '\\' + + ", email='" + email + '\\' + + ", role='" + role + '\\' + + ", isActive=" + isActive + + '}'; + } + + public void setName(String newName) { + } + + public void setEmail(String newEmail) { + } + + public void setRole(String newRole) { + } + + public int getClubId() { + return 0; + } + } + + // Inner class to represent an Event + public static class Event { + private int eventId; + private int clubId; + private LocalDate eventDate; + private String eventName; + private String description; + + public Event(int eventId, int clubId, LocalDate eventDate, String eventName, String description) { + this.eventId = eventId; + this.clubId = clubId; + this.eventDate = eventDate; + this.eventName = eventName; + this.description = description; + } + + public int getEventId() { + return eventId; + } + + public int getClubId() { + return clubId; + } + + public LocalDate getEventDate() { + return eventDate; + } + + public String getEventName() { + return eventName; + } + + public String getDescription() { + return description; + } + + @Override + public String toString() { + return "Event{" + + "eventId=" + eventId + + ", clubId=" + clubId + + ", eventDate=" + eventDate + + ", eventName='" + eventName + '\\' + + ", description='" + description + '\\' + + '}'; + } + + public void setEventDate(LocalDate newEventDate) { + } + + public void setEventName(String newEventName) { + } + + public void setDescription(String newDescription) { + } + } + + // Method to add a club + public void addClub(int clubId, String name, String description, LocalDate foundingDate) { + if (clubs.containsKey(clubId)) { + throw new IllegalArgumentException("Club already exists"); + } + clubs.put(clubId, new Club(clubId, name, description, foundingDate)); + } + + // Method to remove a club + public void removeClub(int clubId) { + if (!clubs.containsKey(clubId)) { + throw new IllegalArgumentException("Club not found"); + } + clubs.remove(clubId); + } + + // Method to list all clubs + public List listAllClubs() { + return new ArrayList<>(clubs.values()); + } + + // Method to find a club by ID + public Club findClubById(int clubId) { + return clubs.get(clubId); + } + + // Method to add a member + public void addMember(int memberId, String name, String email, String role) { + if (members.containsKey(memberId)) { + throw new IllegalArgumentException("Member already exists"); + } + members.put(memberId, new Member(memberId, name, email, role)); + } + + // Method to remove a member + public void removeMember(int memberId) { + if (!members.containsKey(memberId)) { + throw new IllegalArgumentException("Member not found"); + } + members.remove(memberId); + } + + // Method to list all members + public List listAllMembers() { + return new ArrayList<>(members.values()); + } + + // Method to find a member by ID + public Member findMemberById(int memberId) { + return members.get(memberId); + } + + // Method to deactivate a member + public void deactivateMember(int memberId) { + Member member = members.get(memberId); + if (member == null) { + throw new IllegalArgumentException("Member not found"); + } + member.deactivate(); + } + + // Method to add an event + public void addEvent(int eventId, int clubId, LocalDate eventDate, String eventName, String description) { + if (events.containsKey(eventId)) { + throw new IllegalArgumentException("Event already exists"); + } + events.put(eventId, new Event(eventId, clubId, eventDate, eventName, description)); + Club club = clubs.get(clubId); + if (club != null) { + club.increaseMemberCount(); + } + } + + // Method to remove an event + public void removeEvent(int eventId) { + if (!events.containsKey(eventId)) { + throw new IllegalArgumentException("Event not found"); + } + Event event = events.get(eventId); + Club club = clubs.get(event.getClubId()); + if (club != null) { + club.decreaseMemberCount(); + } + events.remove(eventId); + } + + // Method to list all events + public List listAllEvents() { + return new ArrayList<>(events.values()); + } + + // Method to find an event by ID + public Event findEventById(int eventId) { + return events.get(eventId); + } + + // Method to list events by club + public List listEventsByClub(int clubId) { + return events.values().stream() + .filter(e -> e.getClubId() == clubId) + .collect(Collectors.toList()); + } + + // Method to list events by date range + public List listEventsByDateRange(LocalDate startDate, LocalDate endDate) { + return events.values().stream() + .filter(e -> !e.getEventDate().isBefore(startDate) && !e.getEventDate().isAfter(endDate)) + .collect(Collectors.toList()); + } + + // Method to list events by name + public List listEventsByName(String eventName) { + return events.values().stream() + .filter(e -> e.getEventName().equalsIgnoreCase(eventName)) + .collect(Collectors.toList()); + } + + // Method to list events by description + public List listEventsByDescription(String description) { + return events.values().stream() + .filter(e -> e.getDescription().contains(description)) + .collect(Collectors.toList()); + } + + // Method to list events by active members + public List listEventsByActiveMembers() { + return events.values().stream() + .filter(e -> { + Club club = clubs.get(e.getClubId()); + return club != null && club.getMemberCount() > 0; + }) + .collect(Collectors.toList()); + } + + // Method to update club information + public void updateClub(int clubId, String newName, String newDescription) { + Club club = clubs.get(clubId); + if (club == null) { + throw new IllegalArgumentException("Club not found"); + } + club.setName(newName); + club.setDescription(newDescription); + } + + // Method to update member information + public void updateMember(int memberId, String newName, String newEmail, String newRole) { + Member member = members.get(memberId); + if (member == null) { + throw new IllegalArgumentException("Member not found"); + } + member.setName(newName); + member.setEmail(newEmail); + member.setRole(newRole); + } + + // Method to update event information + public void updateEvent(int eventId, LocalDate newEventDate, String newEventName, String newDescription) { + Event event = events.get(eventId); + if (event == null) { + throw new IllegalArgumentException("Event not found"); + } + event.setEventDate(newEventDate); + event.setEventName(newEventName); + event.setDescription(newDescription); + } + + // Method to search for clubs by name + public List searchClubsByName(String name) { + return clubs.values().stream() + .filter(c -> c.getName().toLowerCase().contains(name.toLowerCase())) + .collect(Collectors.toList()); + } + + // Method to search for members by role + public List searchMembersByRole(String role) { + return members.values().stream() + .filter(m -> m.getRole().equalsIgnoreCase(role)) + .collect(Collectors.toList()); + } + + // Method to search for events by description + public List searchEventsByDescription(String description) { + return events.values().stream() + .filter(e -> e.getDescription().toLowerCase().contains(description.toLowerCase())) + .collect(Collectors.toList()); + } + + // Method to assign a member to a club + public void assignMemberToClub(int memberId, int clubId) { + Member member = members.get(memberId); + if (member == null) { + throw new IllegalArgumentException("Member not found"); + } + Club club = clubs.get(clubId); + if (club == null) { + throw new IllegalArgumentException("Club not found"); + } + member.setRole("Member"); // Assign default role + club.increaseMemberCount(); + } + + // Method to unassign a member from a club + public void unassignMemberFromClub(int memberId, int clubId) { + Member member = members.get(memberId); + if (member == null) { + throw new IllegalArgumentException("Member not found"); + } + Club club = clubs.get(clubId); + if (club == null) { + throw new IllegalArgumentException("Club not found"); + } + member.setRole("Inactive"); // Set inactive role + club.decreaseMemberCount(); + } + + // Method to list all members assigned to a club + public List listMembersAssignedToClub(int clubId) { + Club club = clubs.get(clubId); + if (club == null) { + throw new IllegalArgumentException("Club not found"); + } + return members.values().stream() + .filter(m -> m.getRole().equalsIgnoreCase("Member") && m.getEmail().endsWith("@club" + clubId + ".com")) + .collect(Collectors.toList()); + } + + // Method to list all clubs a member is assigned to + public List listClubsForMember(int memberId) { + Member member = members.get(memberId); + if (member == null) { + throw new IllegalArgumentException("Member not found"); + } + return clubs.values().stream() + .filter(c -> c.getMemberCount() > 0 && c.getMemberCount() < 100) + .collect(Collectors.toList()); + } + + // Method to list all events assigned to a club + public List listEventsAssignedToClub(int clubId) { + Club club = clubs.get(clubId); + if (club == null) { + throw new IllegalArgumentException("Club not found"); + } + return events.values().stream() + .filter(e -> e.getClubId() == clubId) + .collect(Collectors.toList()); + } + + // Method to list all members attending an event + public List listMembersAttendingEvent(int eventId) { + Event event = events.get(eventId); + if (event == null) { + throw new IllegalArgumentException("Event not found"); + } + return members.values().stream() + .filter(m -> m.getRole().equalsIgnoreCase("Attendee") && m.getEmail().endsWith("@event" + eventId + ".com")) + .collect(Collectors.toList()); + } + + // Method to assign a member to attend an event + public void assignMemberToAttendEvent(int memberId, int eventId) { + Member member = members.get(memberId); + if (member == null) { + throw new IllegalArgumentException("Member not found"); + } + Event event = events.get(eventId); + if (event == null) { + throw new IllegalArgumentException("Event not found"); + } + member.setRole("Attendee"); // Assign role as Attendee + member.setEmail(member.getEmail().replace("@club", "@event")); + } + + // Method to unassign a member from attending an event + public void unassignMemberFromAttendingEvent(int memberId, int eventId) { + Member member = members.get(memberId); + if (member == null) { + throw new IllegalArgumentException("Member not found"); + } + Event event = events.get(eventId); + if (event == null) { + throw new IllegalArgumentException("Event not found"); + } + member.setRole("Inactive"); // Set inactive role + member.setEmail(member.getEmail().replace("@event", "@club")); + } + + // Method to list all members who are active in any club + public List listActiveMembersInAnyClub() { + return members.values().stream() + .filter(m -> m.isActive()) + .collect(Collectors.toList()); + } + + // Method to list all events that have been held within the last month + public List listRecentEvents() { + LocalDate oneMonthAgo = LocalDate.now().minusMonths(1); + return events.values().stream() + .filter(e -> !e.getEventDate().isBefore(oneMonthAgo)) + .collect(Collectors.toList()); + } + + // Method to list all clubs with more than 10 members + public List listLargeClubs() { + return clubs.values().stream() + .filter(c -> c.getMemberCount() > 10) + .collect(Collectors.toList()); + } + + // Method to list all members who are active in clubs with more than 10 members + public List listActiveMembersInLargeClubs() { + return members.values().stream() + .filter(m -> m.isActive() && clubs.values().stream() + .anyMatch(c -> c.getMemberCount() > 10 && c.getMemberCount() < 100)) + .collect(Collectors.toList()); + } + + // Method to list all events that have been held in clubs with more than 10 members + public List listEventsInLargeClubs() { + return events.values().stream() + .filter(e -> clubs.values().stream() + .anyMatch(c -> c.getMemberCount() > 10 && c.getMemberCount() < 100 && c.getClubId() == e.getClubId())) + .collect(Collectors.toList()); + } + + // Method to list all clubs that have hosted events in the last year + public List listClubsWithRecentEvents() { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return clubs.values().stream() + .filter(c -> events.values().stream() + .anyMatch(e -> e.getClubId() == c.getClubId() && !e.getEventDate().isBefore(oneYearAgo))) + .collect(Collectors.toList()); + } + + // Method to list all members who have attended events in the last year + public List listMembersWithRecentEventAttendance() { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return members.values().stream() + .filter(m -> events.values().stream() + .anyMatch(e -> e.getClubId() == m.getClubId() && !e.getEventDate().isBefore(oneYearAgo))) + .collect(Collectors.toList()); + } + + // Method to list all events that have been held in clubs with more than 10 members in the last year + public List listEventsInLargeClubsLastYear() { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return events.values().stream() + .filter(e -> clubs.values().stream() + .anyMatch(c -> c.getMemberCount() > 10 && c.getMemberCount() < 100 && c.getClubId() == e.getClubId() + && !e.getEventDate().isBefore(oneYearAgo))) + .collect(Collectors.toList()); + } + + // Method to list all clubs that have hosted events in the last year and have more than 10 members + public List listClubsWithRecentEventsAndLargeMembership() { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return clubs.values().stream() + .filter(c -> c.getMemberCount() > 10 && c.getMemberCount() < 100 && events.values().stream() + .anyMatch(e -> e.getClubId() == c.getClubId() && !e.getEventDate().isBefore(oneYearAgo))) + .collect(Collectors.toList()); + } + + // Method to list all members who have attended events in clubs with more than 10 members in the last year + public List listMembersWithRecentEventAttendanceInLargeClubs() { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return members.values().stream() + .filter(m -> m.isActive() && clubs.values().stream() + .anyMatch(c -> c.getMemberCount() > 10 && c.getMemberCount() < 100 && c.getClubId() == m.getClubId() + && events.values().stream() + .anyMatch(e -> e.getClubId() == c.getClubId() && !e.getEventDate().isBefore(oneYearAgo))) + ).collect(Collectors.toList()); + } + +} \ No newline at end of file diff --git a/server/src/main/java/self/cases/teams/teaa/ClubManagementSystem.java b/server/src/main/java/self/cases/teams/teaa/ClubManagementSystem.java new file mode 100644 index 00000000..35634806 --- /dev/null +++ b/server/src/main/java/self/cases/teams/teaa/ClubManagementSystem.java @@ -0,0 +1,392 @@ +package self.cases.teams.teaa; + +import java.util.*; +import java.time.LocalDate; +import java.util.stream.Collectors; + +public class ClubManagementSystem { + private Map clubs; + private Map members; + private Map events; + + public ClubManagementSystem() { + clubs = new HashMap<>(); + members = new HashMap<>(); + events = new HashMap<>(); + } + + // Inner class to represent a Club + public static class Club { + private int clubId; + private String name; + private String description; + private LocalDate foundingDate; + private int memberCount; + + public Club(int clubId, String name, String description, LocalDate foundingDate) { + this.clubId = clubId; + this.name = name; + this.description = description; + this.foundingDate = foundingDate; + this.memberCount = 0; + } + + public int getClubId() { + return clubId; + } + + public String getName() { + return name; + } + + public String getDescription() { + return description; + } + + public LocalDate getFoundingDate() { + return foundingDate; + } + + public int getMemberCount() { + return memberCount; + } + + public void increaseMemberCount() { + this.memberCount++; + } + + public void decreaseMemberCount() { + if (this.memberCount > 0) { + this.memberCount--; + } + } + + @Override + public String toString() { + return "Club{" + + "clubId=" + clubId + + ", name='" + name + '\\' + + ", description='" + description + '\\' + + ", foundingDate=" + foundingDate + + ", memberCount=" + memberCount + + '}'; + } + } + + // Inner class to represent a Member + public static class Member { + private int memberId; + private String name; + private String email; + private String role; + private boolean isActive; + + public Member(int memberId, String name, String email, String role) { + this.memberId = memberId; + this.name = name; + this.email = email; + this.role = role; + this.isActive = true; + } + + public int getMemberId() { + return memberId; + } + + public String getName() { + return name; + } + + public String getEmail() { + return email; + } + + public String getRole() { + return role; + } + + public boolean isActive() { + return isActive; + } + + public void deactivate() { + this.isActive = false; + } + + @Override + public String toString() { + return "Member{" + + "memberId=" + memberId + + ", name='" + name + '\\' + + ", email='" + email + '\\' + + ", role='" + role + '\\' + + ", isActive=" + isActive + + '}'; + } + } + + // Inner class to represent an Event + public static class Event { + private int eventId; + private int clubId; + private LocalDate eventDate; + private String eventName; + private String description; + + public Event(int eventId, int clubId, LocalDate eventDate, String eventName, String description) { + this.eventId = eventId; + this.clubId = clubId; + this.eventDate = eventDate; + this.eventName = eventName; + this.description = description; + } + + public int getEventId() { + return eventId; + } + + public int getClubId() { + return clubId; + } + + public LocalDate getEventDate() { + return eventDate; + } + + public String getEventName() { + return eventName; + } + + public String getDescription() { + return description; + } + + @Override + public String toString() { + return "Event{" + + "eventId=" + eventId + + ", clubId=" + clubId + + ", eventDate=" + eventDate + + ", eventName='" + eventName + '\\' + + ", description='" + description + '\\' + + '}'; + } + } + + // Method to add a club + public void addClub(int clubId, String name, String description, LocalDate foundingDate) { + if (clubs.containsKey(clubId)) { + throw new IllegalArgumentException("Club already exists"); + } + clubs.put(clubId, new Club(clubId, name, description, foundingDate)); + } + + // Method to remove a club + public void removeClub(int clubId) { + if (!clubs.containsKey(clubId)) { + throw new IllegalArgumentException("Club not found"); + } + clubs.remove(clubId); + } + + // Method to list all clubs + public List listAllClubs() { + return new ArrayList<>(clubs.values()); + } + + // Method to find a club by ID + public Club findClubById(int clubId) { + return clubs.get(clubId); + } + + // Method to add a member + public void addMember(int memberId, String name, String email, String role) { + if (members.containsKey(memberId)) { + throw new IllegalArgumentException("Member already exists"); + } + members.put(memberId, new Member(memberId, name, email, role)); + } + + // Method to remove a member + public void removeMember(int memberId) { + if (!members.containsKey(memberId)) { + throw new IllegalArgumentException("Member not found"); + } + members.remove(memberId); + } + + // Method to list all members + public List listAllMembers() { + return new ArrayList<>(members.values()); + } + + // Method to find a member by ID + public Member findMemberById(int memberId) { + return members.get(memberId); + } + + // Method to deactivate a member + public void deactivateMember(int memberId) { + Member member = members.get(memberId); + if (member == null) { + throw new IllegalArgumentException("Member not found"); + } + member.deactivate(); + } + + // Method to add an event + public void addEvent(int eventId, int clubId, LocalDate eventDate, String eventName, String description) { + if (events.containsKey(eventId)) { + throw new IllegalArgumentException("Event already exists"); + } + events.put(eventId, new Event(eventId, clubId, eventDate, eventName, description)); + Club club = clubs.get(clubId); + if (club != null) { + club.increaseMemberCount(); + } + } + + // Method to remove an event + public void removeEvent(int eventId) { + if (!events.containsKey(eventId)) { + throw new IllegalArgumentException("Event not found"); + } + Event event = events.get(eventId); + Club club = clubs.get(event.getClubId()); + if (club != null) { + club.decreaseMemberCount(); + } + events.remove(eventId); + } + + // Method to list all events + public List listAllEvents() { + return new ArrayList<>(events.values()); + } + + // Method to find an event by ID + public Event findEventById(int eventId) { + return events.get(eventId); + } + + // Method to list events by club + public List listEventsByClub(int clubId) { + return events.values().stream() + .filter(e -> e.getClubId() == clubId) + .collect(Collectors.toList()); + } + + // Method to list events by date range + public List listEventsByDateRange(LocalDate startDate, LocalDate endDate) { + return events.values().stream() + .filter(e -> !e.getEventDate().isBefore(startDate) && !e.getEventDate().isAfter(endDate)) + .collect(Collectors.toList()); + } + + // Method to list events by name + public List listEventsByName(String eventName) { + return events.values().stream() + .filter(e -> e.getEventName().equalsIgnoreCase(eventName)) + .collect(Collectors.toList()); + } + + // Method to list events by description + public List listEventsByDescription(String description) { + return events.values().stream() + .filter(e -> e.getDescription().contains(description)) + .collect(Collectors.toList()); + } + + // Method to list events by active members + public List listEventsByActiveMembers() { + return events.values().stream() + .filter(e -> { + Club club = clubs.get(e.getClubId()); + return club != null && club.getMemberCount() > 0; + }) + .collect(Collectors.toList()); + } + + // Main method to demonstrate functionality + public static void main(String[] args) { + ClubManagementSystem system = new ClubManagementSystem(); + + // Adding clubs + system.addClub(1, "Chess Club", "A club for chess enthusiasts", LocalDate.of(2020, 1, 1)); + system.addClub(2, "Book Club", "A club for book lovers", LocalDate.of(2018, 5, 15)); + system.addClub(3, "Photography Club", "A club for photography enthusiasts", LocalDate.of(2019, 10, 1)); + + // Listing all clubs + System.out.println("\\nList of Clubs:"); + for (Club club : system.listAllClubs()) { + System.out.println(club); + } + + // Finding a club by ID + Club chessClub = system.findClubById(1); + System.out.println("\\nChess Club: " + chessClub); + + // Adding members + system.addMember(101, "Alice", "alice@example.com", "President"); + system.addMember(102, "Bob", "bob@example.com", "Secretary"); + system.addMember(103, "Charlie", "charlie@example.com", "Treasurer"); + + // Listing all members + System.out.println("\\nList of Members:"); + for (Member member : system.listAllMembers()) { + System.out.println(member); + } + + // Finding a member by ID + Member alice = system.findMemberById(101); + System.out.println("\\nAlice: " + alice); + + // Deactivating a member + system.deactivateMember(101); + + // Adding events + system.addEvent(1001, 1, LocalDate.of(2023, 1, 15), "Chess Tournament", "Annual chess tournament"); + system.addEvent(1002, 2, LocalDate.of(2023, 2, 20), "Book Discussion", "Monthly book discussion"); + system.addEvent(1003, 3, LocalDate.of(2023, 3, 10), "Photo Walk", "Monthly photo walk"); + + // Listing all events + System.out.println("\\nList of Events:"); + for (Event event : system.listAllEvents()) { + System.out.println(event); + } + + // Finding an event by ID + Event chessTournament = system.findEventById(1001); + System.out.println("\\nChess Tournament: " + chessTournament); + + // Listing events by club + System.out.println("\\nEvents by Chess Club:"); + for (Event event : system.listEventsByClub(1)) { + System.out.println(event); + } + + // Listing events by date range + System.out.println("\\nEvents between January 1 and March 31, 2023:"); + for (Event event : system.listEventsByDateRange(LocalDate.of(2023, 1, 1), LocalDate.of(2023, 3, 31))) { + System.out.println(event); + } + + // Listing events by name + System.out.println("\\nEvents named 'Book Discussion':"); + for (Event event : system.listEventsByName("Book Discussion")) { + System.out.println(event); + } + + // Listing events by description + System.out.println("\\nEvents with description containing 'Annual':"); + for (Event event : system.listEventsByDescription("Annual")) { + System.out.println(event); + } + + // Listing events by active members + System.out.println("\\nEvents with active members:"); + for (Event event : system.listEventsByActiveMembers()) { + System.out.println(event); + } + } +} diff --git a/server/src/main/java/self/cases/teams/teaa/ECommercePlatform.java b/server/src/main/java/self/cases/teams/teaa/ECommercePlatform.java new file mode 100644 index 00000000..54d129ac --- /dev/null +++ b/server/src/main/java/self/cases/teams/teaa/ECommercePlatform.java @@ -0,0 +1,422 @@ +package self.cases.teams.teaa; +import java.util.*; +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.stream.Collectors; + +public class ECommercePlatform { + private Map products; + private Map orders; + private Map users; + + public ECommercePlatform() { + products = new HashMap<>(); + orders = new HashMap<>(); + users = new HashMap<>(); + } + + // Inner class to represent a Product + public static class Product { + private String productId; + private String name; + private BigDecimal price; + private int stock; + + public Product(String productId, String name, BigDecimal price, int stock) { + this.productId = productId; + this.name = name; + this.price = price; + this.stock = stock; + } + + public String getProductId() { + return productId; + } + + public String getName() { + return name; + } + + public BigDecimal getPrice() { + return price; + } + + public int getStock() { + return stock; + } + + public void updateStock(int quantity) { + if (quantity > 0) { + stock += quantity; + } else { + throw new IllegalArgumentException("Invalid stock update quantity"); + } + } + + @Override + public String toString() { + return "Product{" + + "productId='" + productId + '\\' + + ", name='" + name + '\\' + + ", price=" + price + + ", stock=" + stock + + '}'; + } + } + + // Inner class to represent an Order + public static class Order { + private String orderId; + private String userId; + private LocalDateTime orderDate; + private List items; + + public Order(String orderId, String userId, LocalDateTime orderDate, List items) { + this.orderId = orderId; + this.userId = userId; + this.orderDate = orderDate; + this.items = items; + } + + public String getOrderId() { + return orderId; + } + + public String getUserId() { + return userId; + } + + public LocalDateTime getOrderDate() { + return orderDate; + } + + public List getItems() { + return items; + } + + public BigDecimal getTotalPrice() { + BigDecimal total = BigDecimal.ZERO; + for (OrderItem item : items) { + total = total.add(item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()))); + } + return total; + } + + @Override + public String toString() { + return "Order{" + + "orderId='" + orderId + '\\' + + ", userId='" + userId + '\\' + + ", orderDate=" + orderDate + + ", items=" + items + + ", totalPrice=" + getTotalPrice() + + '}'; + } + } + + // Inner class to represent an OrderItem + public static class OrderItem { + private String productId; + private int quantity; + private BigDecimal price; + + public OrderItem(String productId, int quantity, BigDecimal price) { + this.productId = productId; + this.quantity = quantity; + this.price = price; + } + + public String getProductId() { + return productId; + } + + public int getQuantity() { + return quantity; + } + + public BigDecimal getPrice() { + return price; + } + + @Override + public String toString() { + return "OrderItem{" + + "productId='" + productId + '\\' + + ", quantity=" + quantity + + ", price=" + price + + '}'; + } + } + + // Inner class to represent a User + public static class User { + private String userId; + private String username; + private String password; + private boolean isAdmin; + + public User(String userId, String username, String password, boolean isAdmin) { + this.userId = userId; + this.username = username; + this.password = password; + this.isAdmin = isAdmin; + } + + public String getUserId() { + return userId; + } + + public String getUsername() { + return username; + } + + public String getPassword() { + return password; + } + + public boolean isAdmin() { + return isAdmin; + } + + public void setPassword(String newPassword) { + this.password = newPassword; + } + + @Override + public String toString() { + return "User{" + + "userId='" + userId + '\\' + + ", username='" + username + '\\' + + ", password='" + password + '\\' + + ", isAdmin=" + isAdmin + + '}'; + } + } + + // Method to add a product + public void addProduct(String productId, String name, BigDecimal price, int stock) { + if (products.containsKey(productId)) { + throw new IllegalArgumentException("Product already exists"); + } + products.put(productId, new Product(productId, name, price, stock)); + } + + // Method to update product stock + public void updateProductStock(String productId, int quantity) { + Product product = products.get(productId); + if (product == null) { + throw new IllegalArgumentException("Product not found"); + } + product.updateStock(quantity); + } + + // Method to remove a product + public void removeProduct(String productId) { + if (!products.containsKey(productId)) { + throw new IllegalArgumentException("Product not found"); + } + products.remove(productId); + } + + // Method to list all products + public List listAllProducts() { + return new ArrayList<>(products.values()); + } + + // Method to find a product by ID + public Product findProductById(String productId) { + return products.get(productId); + } + + // Method to place an order + public String placeOrder(String userId, List items) { + if (!users.containsKey(userId)) { + throw new IllegalArgumentException("User not found"); + } + User user = users.get(userId); + if (!user.isAdmin()) { + throw new IllegalStateException("Only admin can place orders"); + } + String orderId = UUID.randomUUID().toString(); + LocalDateTime orderDate = LocalDateTime.now(); + Order order = new Order(orderId, userId, orderDate, items); + orders.put(orderId, order); + for (OrderItem item : items) { + Product product = products.get(item.getProductId()); + if (product == null || product.getStock() < item.getQuantity()) { + throw new IllegalArgumentException("Insufficient stock for product " + item.getProductId()); + } + product.updateStock(-item.getQuantity()); + } + return orderId; + } + + // Method to cancel an order + public void cancelOrder(String orderId) { + if (!orders.containsKey(orderId)) { + throw new IllegalArgumentException("Order not found"); + } + Order order = orders.get(orderId); + for (OrderItem item : order.getItems()) { + Product product = products.get(item.getProductId()); + if (product != null) { + product.updateStock(item.getQuantity()); + } + } + orders.remove(orderId); + } + + // Method to list all orders + public List listAllOrders() { + return new ArrayList<>(orders.values()); + } + + // Method to find an order by ID + public Order findOrderById(String orderId) { + return orders.get(orderId); + } + + // Method to list orders by user + public List listOrdersByUser(String userId) { + return orders.values().stream() + .filter(o -> o.getUserId().equals(userId)) + .collect(Collectors.toList()); + } + + // Method to list recent orders + public List listRecentOrders(int limit) { + return orders.values().stream() + .sorted((o1, o2) -> o2.getOrderDate().compareTo(o1.getOrderDate())) + .limit(limit) + .collect(Collectors.toList()); + } + + // Method to list orders by date range + public List listOrdersByDateRange(LocalDateTime startDate, LocalDateTime endDate) { + return orders.values().stream() + .filter(o -> !o.getOrderDate().isBefore(startDate) && !o.getOrderDate().isAfter(endDate)) + .collect(Collectors.toList()); + } + + // Method to add a user + public void addUser(String userId, String username, String password, boolean isAdmin) { + if (users.containsKey(userId)) { + throw new IllegalArgumentException("User already exists"); + } + users.put(userId, new User(userId, username, password, isAdmin)); + } + + // Method to remove a user + public void removeUser(String userId) { + if (!users.containsKey(userId)) { + throw new IllegalArgumentException("User not found"); + } + users.remove(userId); + } + + // Method to update user password + public void updateUserPassword(String userId, String newPassword) { + User user = users.get(userId); + if (user == null) { + throw new IllegalArgumentException("User not found"); + } + user.setPassword(newPassword); + } + + // Method to list all users + public List listAllUsers() { + return new ArrayList<>(users.values()); + } + + // Method to find a user by ID + public User findUserById(String userId) { + return users.get(userId); + } + + // Method to list users by admin status + public List listUsersByAdminStatus(boolean isAdmin) { + return users.values().stream() + .filter(u -> u.isAdmin() == isAdmin) + .collect(Collectors.toList()); + } + + // Method to list users by username + public List listUsersByUsername(String username) { + return users.values().stream() + .filter(u -> u.getUsername().equals(username)) + .collect(Collectors.toList()); + } + + // Main method to demonstrate functionality + public static void main(String[] args) { + ECommercePlatform platform = new ECommercePlatform(); + + // Adding products + platform.addProduct("P001", "Laptop", new BigDecimal("999.99"), 100); + platform.addProduct("P002", "Smartphone", new BigDecimal("499.99"), 200); + platform.addProduct("P003", "Tablet", new BigDecimal("299.99"), 150); + + // Updating product stock + platform.updateProductStock("P001", 50); + + // Removing a product + platform.removeProduct("P002"); + + // Listing all products + System.out.println("\\nList of Products:"); + for (Product product : platform.listAllProducts()) { + System.out.println(product); + } + + // Placing an order + List orderItems = Arrays.asList( + new OrderItem("P001", 2, new BigDecimal("999.99")), + new OrderItem("P003", 1, new BigDecimal("299.99")) + ); + String orderId = platform.placeOrder("U001", orderItems); + System.out.println("\\nOrder Placed: " + orderId); + + // Canceling an order + platform.cancelOrder(orderId); + System.out.println("Order Canceled"); + + // Adding users + platform.addUser("U001", "alice", "password123", false); + platform.addUser("U002", "bob", "password456", true); + + // Updating user password + platform.updateUserPassword("U001", "newpassword123"); + + // Listing all users + System.out.println("\\nList of Users:"); + for (User user : platform.listAllUsers()) { + System.out.println(user); + } + + // Listing users by admin status + System.out.println("\\nList of Admin Users:"); + for (User adminUser : platform.listUsersByAdminStatus(true)) { + System.out.println(adminUser); + } + + // Listing orders by user + System.out.println("\\nList of Orders by User U001:"); + for (Order order : platform.listOrdersByUser("U001")) { + System.out.println(order); + } + + // Listing recent orders + System.out.println("\\nRecent Orders:"); + for (Order recentOrder : platform.listRecentOrders(3)) { + System.out.println(recentOrder); + } + + // Listing orders by date range + LocalDateTime startDate = LocalDateTime.of(2023, 10, 1, 0, 0); + LocalDateTime endDate = LocalDateTime.of(2023, 10, 31, 23, 59); + System.out.println("\\nOrders Between " + startDate + " and " + endDate + ":"); + for (Order order : platform.listOrdersByDateRange(startDate, endDate)) { + System.out.println(order); + } + } +} diff --git a/server/src/main/java/self/cases/teams/teaa/Managexiu.java b/server/src/main/java/self/cases/teams/teaa/Managexiu.java new file mode 100644 index 00000000..62c69cc3 --- /dev/null +++ b/server/src/main/java/self/cases/teams/teaa/Managexiu.java @@ -0,0 +1,390 @@ +package self.cases.teams.teaa; +import java.time.Instant; +import java.util.*; +import java.time.LocalDate; +import java.util.stream.Collectors; + +public class Managexiu { + + private Map users; + + public Managexiu() { + users = new HashMap<>(); + } + + // Inner class to represent a User + public static class User { + private int userId; + private String name; + private String email; + private String password; + private LocalDate dateOfBirth; + private String address; + private String phoneNumber; + private boolean isActive; + + public User(int userId, String name, String email, String password, LocalDate dateOfBirth, String address, String phoneNumber) { + this.userId = userId; + this.name = name; + this.email = email; + this.password = password; + this.dateOfBirth = dateOfBirth; + this.address = address; + this.phoneNumber = phoneNumber; + this.isActive = true; + } + + public int getUserId() { + return userId; + } + + public String getName() { + return name; + } + + public String getEmail() { + return email; + } + + public String getPassword() { + return password; + } + + public LocalDate getDateOfBirth() { + return dateOfBirth; + } + + public String getAddress() { + return address; + } + + public String getPhoneNumber() { + return phoneNumber; + } + + public boolean isActive() { + return isActive; + } + + public void deactivate() { + this.isActive = false; + } + + @Override + public String toString() { + return "User{" + + "userId=" + userId + + ", name='" + name + '\\' + + ", email='" + email + '\\' + + ", password='" + password + '\\' + + ", dateOfBirth=" + dateOfBirth + + ", address='" + address + '\\' + + ", phoneNumber='" + phoneNumber + '\\' + + ", isActive=" + isActive + + '}'; + } + + public void setName(String newName) { + } + + public void setEmail(String newEmail) { + } + + public void setDateOfBirth(LocalDate newDateOfBirth) { + } + + public void setPassword(String newPassword) { + } + + public void setPhoneNumber(String newPhoneNumber) { + } + + public void setAddress(String newAddress) { + } + + public void setGroupName(String groupName) { + } + + public Object getGroupName() { + return null; + } + + public int getActiveFriendsCount() { + return 0; + } + + public Instant getLastLoginDate() { + return null; + } + } + + // Method to add a user + public void addUser(int userId, String name, String email, String password, LocalDate dateOfBirth, String address, String phoneNumber) { + if (users.containsKey(userId)) { + throw new IllegalArgumentException("User already exists"); + } + users.put(userId, new User(userId, name, email, password, dateOfBirth, address, phoneNumber)); + } + + // Method to remove a user + public void removeUser(int userId) { + if (!users.containsKey(userId)) { + throw new IllegalArgumentException("User not found"); + } + users.remove(userId); + } + + // Method to list all users + public List listAllUsers() { + return new ArrayList<>(users.values()); + } + + // Method to find a user by ID + public User findUserById(int userId) { + return users.get(userId); + } + + // Method to deactivate a user + public void deactivateUser(int userId) { + User user = users.get(userId); + if (user == null) { + throw new IllegalArgumentException("User not found"); + } + user.deactivate(); + } + + // Method to update user information + public void updateUser(int userId, String newName, String newEmail, String newPassword, LocalDate newDateOfBirth, String newAddress, String newPhoneNumber) { + User user = users.get(userId); + if (user == null) { + throw new IllegalArgumentException("User not found"); + } + user.setName(newName); + user.setEmail(newEmail); + user.setPassword(newPassword); + user.setDateOfBirth(newDateOfBirth); + user.setAddress(newAddress); + user.setPhoneNumber(newPhoneNumber); + } + + + + // Method to search for users by email + public List searchUsersByEmail(String email) { + return users.values().stream() + .filter(u -> u.getEmail().toLowerCase().contains(email.toLowerCase())) + .collect(Collectors.toList()); + } + + // Method to search for users by phone number + public List searchUsersByPhoneNumber(String phoneNumber) { + return users.values().stream() + .filter(u -> u.getPhoneNumber().equals(phoneNumber)) + .collect(Collectors.toList()); + } + + // Method to search for users by date of birth + public List searchUsersByDateOfBirth(LocalDate dateOfBirth) { + return users.values().stream() + .filter(u -> u.getDateOfBirth().equals(dateOfBirth)) + .collect(Collectors.toList()); + } + + // Method to search for users by address + public List searchUsersByAddress(String address) { + return users.values().stream() + .filter(u -> u.getAddress().toLowerCase().contains(address.toLowerCase())) + .collect(Collectors.toList()); + } + + // Method to search for users by active status + public List searchUsersByActiveStatus(boolean isActive) { + return users.values().stream() + .filter(u -> u.isActive() == isActive) + .collect(Collectors.toList()); + } + + // Method to assign a user to a group + public void assignUserToGroup(int userId, String groupName) { + User user = users.get(userId); + if (user == null) { + throw new IllegalArgumentException("User not found"); + } + user.setGroupName(groupName); // Assign default group + } + + // Method to unassign a user from a group + public void unassignUserFromGroup(int userId) { + User user = users.get(userId); + if (user == null) { + throw new IllegalArgumentException("User not found"); + } + user.setGroupName(null); // Set no group + } + + // Method to list all users assigned to a group + public List listUsersAssignedToGroup(String groupName) { + return users.values().stream() + .filter(u -> u.getGroupName() != null && u.getGroupName().equals(groupName)) + .collect(Collectors.toList()); + } + + // Method to list all groups a user is assigned to + public List listGroupsForMember(int userId) { + User user = users.get(userId); + if (user == null) { + throw new IllegalArgumentException("User not found"); + } + return Arrays.asList(user.getGroupName().toString()); + } + + // Method to list all users with more than 10 active friends + public List listUsersWithMoreThanTenActiveFriends() { + return users.values().stream() + .filter(u -> u.getActiveFriendsCount() > 10) + .collect(Collectors.toList()); + } + + // Method to list all users who are active in any group + public List listActiveUsersInAnyGroup() { + return users.values().stream() + .filter(u -> u.isActive()) + .collect(Collectors.toList()); + } + + // Method to list all users that have been registered within the last month + public List listRecentRegistrations() { + LocalDate oneMonthAgo = LocalDate.now().minusMonths(1); + return users.values().stream() + .filter(u -> !u.getDateOfBirth().isBefore(oneMonthAgo)) + .collect(Collectors.toList()); + } + + // Method to list all users with more than 10 active friends in the last year + public List listUsersWithMoreThanTenActiveFriendsInLastYear() { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getActiveFriendsCount() > 10 && u.getLastLoginDate().isAfter(Instant.from(oneYearAgo))) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year + public List listUsersLoggedInInLastYear() { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo))) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last month and have more than 10 active friends + public List listUsersLoggedInInLastMonthWithMoreThanTenActiveFriends() { + LocalDate oneMonthAgo = LocalDate.now().minusMonths(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneMonthAgo)) && u.getActiveFriendsCount() > 10) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriends() { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroup(String groupName) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddress(String groupName, String address) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumber(String groupName, String address, String phoneNumber) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActive(String groupName, String address, String phoneNumber) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive()) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active and have a specific name + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActiveAndSpecificName(String groupName, String address, String phoneNumber, String name) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive() && u.getName().equals(name)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active and have a specific name and email + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActiveAndSpecificNameAndEmail(String groupName, String address, String phoneNumber, String name, String email) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive() && u.getName().equals(name) && u.getEmail().equals(email)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active and have a specific name and email and password + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActiveAndSpecificNameAndEmailAndPassword(String groupName, String address, String phoneNumber, String name, String email, String password) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive() && u.getName().equals(name) && u.getEmail().equals(email) && u.getPassword().equals(password)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active and have a specific name and email and password and date of birth + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActiveAndSpecificNameAndEmailAndPasswordAndDateOfBirth(String groupName, String address, String phoneNumber, String name, String email, String password, LocalDate dateOfBirth) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive() && u.getName().equals(name) && u.getEmail().equals(email) && u.getPassword().equals(password) && u.getDateOfBirth().equals(dateOfBirth)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active and have a specific name and email and password and date of birth and address + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActiveAndSpecificNameAndEmailAndPasswordAndDateOfBirthAndAddress(String groupName, String address, String phoneNumber, String name, String email, String password, LocalDate dateOfBirth, String addressDetail) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive() && u.getName().equals(name) && u.getEmail().equals(email) && u.getPassword().equals(password) && u.getDateOfBirth().equals(dateOfBirth) && u.getAddress().equals(addressDetail)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active and have a specific name and email and password and date of birth and address and phone number + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActiveAndSpecificNameAndEmailAndPasswordAndDateOfBirthAndAddressAndPhoneNumber(String groupName, String address, String phoneNumber, String name, String email, String password, LocalDate dateOfBirth, String addressDetail, String phoneNumberDetail) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive() && u.getName().equals(name) && u.getEmail().equals(email) && u.getPassword().equals(password) && u.getDateOfBirth().equals(dateOfBirth) && u.getAddress().equals(addressDetail) && u.getPhoneNumber().equals(phoneNumberDetail)) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active and have a specific name and email and password and date of birth and address and phone number and are active + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActiveAndSpecificNameAndEmailAndPasswordAndDateOfBirthAndAddressAndPhoneNumberAndActive(String groupName, String address, String phoneNumber, String name, String email, String password, LocalDate dateOfBirth, String addressDetail, String phoneNumberDetail) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive() && u.getName().equals(name) && u.getEmail().equals(email) && u.getPassword().equals(password) && u.getDateOfBirth().equals(dateOfBirth) && u.getAddress().equals(addressDetail) && u.getPhoneNumber().equals(phoneNumberDetail) && u.isActive()) + .collect(Collectors.toList()); + } + + // Method to list all users who have logged in within the last year and have more than 10 active friends in a specific group and have a specific address and phone number and are active and have a specific name and email and password and date of birth and address and phone number and are active and have a specific name and email and password and date of birth and address and phone number + public List listUsersLoggedInInLastYearWithMoreThanTenActiveFriendsInGroupAndSpecificAddressAndPhoneNumberAndActiveAndSpecificNameAndEmailAndPasswordAndDateOfBirthAndAddressAndPhoneNumberAndActiveAndSpecificNameAndEmailAndPasswordAndDateOfBirthAndAddressAndPhoneNumber(String groupName, String address, String phoneNumber, String name, String email, String password, LocalDate dateOfBirth, String addressDetail, String phoneNumberDetail) { + LocalDate oneYearAgo = LocalDate.now().minusYears(1); + return users.values().stream() + .filter(u -> u.getLastLoginDate().isAfter(Instant.from(oneYearAgo)) && u.getActiveFriendsCount() > 10 && u.getGroupName().equals(groupName) && u.getAddress().equals(address) && u.getPhoneNumber().equals(phoneNumber) && u.isActive() && u.getName().equals(name) && u.getEmail().equals(email) && u.getPassword().equals(password) && u.getDateOfBirth().equals(dateOfBirth) && u.getAddress().equals(addressDetail) && u.getPhoneNumber().equals(phoneNumberDetail) && u.isActive() && u.getName().equals(name) && u.getEmail().equals(email) && u.getPassword().equals(password) && u.getDateOfBirth().equals(dateOfBirth) && u.getAddress().equals(addressDetail) && u.getPhoneNumber().equals(phoneNumberDetail)) + .collect(Collectors.toList()); + } +} diff --git a/server/target/classes/self/cases/teams/teaa/BankSystem$Account.class b/server/target/classes/self/cases/teams/teaa/BankSystem$Account.class new file mode 100644 index 0000000000000000000000000000000000000000..27410f995446f83b71a698cfa7b8725fc2adeb03 GIT binary patch literal 2051 zcma)7TXWk)7(FXHzE!#4+?tZ6qJ&y;+PF|I>786!2u+$mLQA;KtYyVfD@(?f6Zj?Y z0QYvssMdx*Be% z;bt1QGPs>X5AI}eH^Ol_6SjpgF z8f$5MD9|e{%WrwX!&a?qHw5y_Pvnj)xzeka)`N!QRc{LP_`9B3OqV4WEL%V<3Z!m1 zo)g>=FwN6Nr!$LFj|7qneud@z%Z_J9EjMJ@WhTGuThe_b8;*L8lgVJ)X|nBHgi%0W z@(5(XmCdHjh2nD4cDG8F_97l90Su12cl79opg$>}vUmZBb|5Gg%CGalXnQDTsW?0>8zw;mAvlUs~h46_7ezOLL}Vy>5FI zfh*lkJY~RGEEbN_U;nY33H(T2fx(c(@y>K=UEy$f!^Z#Vfmiq;Im=H|0-Ev=BTd;T zoarRaX$bn@0`mr+T<+}QJXAb@C{FJ|D_-71qBymOa2xPfxQzj8TTf*0R#mU_!G(^91X@L&Z@Ad_zc?545IF- zFgYG})1wV>H-YJ{#fg)}M%UuYxWeP2&RVB)@~0D>C%YE&Rf#p+raB4MOceUQ{Q(2T z&1Xm!EDHD|dY_|bGoLy@`VXaMB2+UUDrO=@>Vsr(o-mY>BcWCk9VI7lm1_d8b1eyN zFdOREBbZjYz0m>iRScjI0vIb$zT|h`w~vYx)n)@cdMYkbwHzZ?(ms9SLDU;--@V3h# kEiDu{1?_J&arG1tC&RgUvv?pqW}N^ literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/BankSystem$Transaction.class b/server/target/classes/self/cases/teams/teaa/BankSystem$Transaction.class new file mode 100644 index 0000000000000000000000000000000000000000..c959bb56e83c3b81edd90b7bf8811d633a56f9fc GIT binary patch literal 1260 zcmb7CT~8B16g{)uZfRL)t)Sos6h&>9()GbN4GGeafaN18!3Q7AbUT#A?ylLLn)pBb zA8KM_;)6fHA7#8VEwm|3)P1=3&g?yB&OI}~e*gFh;2ECgFoQ=~WbjypCn}UxsHos% zP|aYIVNS+8Ot>fgDBNo^6dM=(19!VT?6^%C`(fuf!|Yic1>2q%^+L&zmC;pg@nEpY z>gtCdh(z+>Jwsu@)02MJt#c`e#d_g~zT9HiFJC|8Uv}z~oRw1sb0=yGhJ3>h#bGaK ziTH%Ky0lYlL>}*+^4M4F;if6i{e%WO8BNV#?}ed=ce*@D1pTZv645<#Jx(iE3Lfal z-IqLk*Zi1B5v-5FX|Te9kmphRn8!R2QpChj=mv6Nn8Un{JPH}O z4AuX!fW{p?nxoc*@aUD0R=SqRR1*SCt;8NQ43#k4p9)S*f?rPsuS^A-li)W~!K>uLrEKF$ ocKY*#?6*_FYj|)49?fh`p6pEl8+fRXSjQ6O9MNR3f!oOb0ne}KVgLXD literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/BankSystem.class b/server/target/classes/self/cases/teams/teaa/BankSystem.class new file mode 100644 index 0000000000000000000000000000000000000000..e091561218052d4bd51d5fe5c7eb89ce66539041 GIT binary patch literal 14068 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 E0gUu6IRF3v literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/BankingSystem$Account.class b/server/target/classes/self/cases/teams/teaa/BankingSystem$Account.class new file mode 100644 index 0000000000000000000000000000000000000000..fd2a182ad707dc2cfb37be33a2d1f4ffe75b05aa GIT binary patch literal 2644 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 BDfs{Z literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/Bookstore$Book.class b/server/target/classes/self/cases/teams/teaa/Bookstore$Book.class new file mode 100644 index 0000000000000000000000000000000000000000..5172ca1a82530ddf58fd109d3053138ac935fa1c GIT binary patch literal 1111 zcma)5T~8BH5IuLh+b>tXK>-z&3hfrz7vD4_3Nax;B`M+kvRunz>6+cG&;B42HL)@A z!5`p{GM>3xL7|EE;m+LYoS8Fc?*91s?K^-+*sP<1Mh#^=kYi1bbvc?91QoOuygbf( zMqy^}RKL?FdK(hA>5lYP#WspFpP=Wz!QO(W+Zqp80?<9jXGS6cfZsMHNrYP-W5*t3MsQIYN zaSgtY>zJtEp+e(-#^O{LJ9~9>YNA|$TqyC%Kk&H6H&Eddap4FDdXCVrmQ1WA8QL6vGP2tEnpTmu!x(q z@;p78HOH9zmMjxxJ>lY5PuP^KCwx3&foYeiAYo88P&JU`A`2)>GNhFBtvwmp5u+s&*w4dG%1Fy7yPau-> z{iAXevjWC4U7|9jk{hfP>~h&H3&i)<%WmOm+OZj?L)R{<(@x85mJi%f>9LggykeI^ zFZ3i#+v5N&_q~!AE(ttHWX?7}XW_j}a+kxc_<3^ZT=z=uW~G>OgB?3pP^^5%F6`QY zC*#_s5gvFPB9fJIkV8`nDv=zzHr(*Q&u`fQB@5kvMa+FSRG+1+dLl_)oxEE4Put!^ z@+?7tRwgQ)1d@s5ISC826ZZHYF%4qbR$lM;p@qTq*@(+wl*angN0tqS!jc4;Q}lR?dZ19gNqjCF&@Q&z*w{G*EH_> z`?#{XL)QrfMw>z9Fp35jETyXP8f=2YFdu#^{|f_}oSmK~$5)mNlqCt;76?+j#P5BK zUeZQruckgjqz0~i@L%gX6>+kEp%MHQ9xX}P?)Pq+Wf=4jg034|YKWYdb!*~sROnL^V zO?Is5OED5RPF^DxmriW@6I$p*VpGRQ&e|(oy!rJl{*KAI(xp%BVUsFlDd!g7Miy~A zQ4NQfV_<}_skV@;DW>rzfh3!!SjU9+1BNcXQwR+=m1q;_qU~Yafjj8r!lJa?@o(lx B5flIb literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/Bookstore.class b/server/target/classes/self/cases/teams/teaa/Bookstore.class new file mode 100644 index 0000000000000000000000000000000000000000..ae5a0bd7818fc93fad0c453a06e9ff2f1c8e1646 GIT binary patch literal 3789 zcmb7H+kX`08Ga_&-I;6#lCI$pe;fvhk|V1~fo?b^(XuoNhafZrTPM4dWMDHBc4yIO z>!AhesamBT=vi%{2igMF4H%`^R;zf^yWaMuSN#w8q4arYhGb*t4|?;>_r3Fe&wG5{ z*}eSvyB7hh#;0+#!&NaBM+Mv})Z$Pz@+ipSRilW*vOKKfkvOU_9>=42OjN%Wr|P#w z_P8uhsCZH&u7;;Hd?&Vf>*wcp{^#gYdG}p;aYVyW4aZ`eJA)S*zNg{o*yatNjlK2H z_=YMxgJ(577svDXzUaT8;>9=`;L7p?4KE4O%W^ob;)fbuiK7{>YIse<>#{we;YafP zv8en+!%sE*OvBGb^a~NaA)s$+cuT`CRs2dpbbCH)~v}nn?jI zcy8WmkX`#m!o=3wj_qw!P}$hDhju&NECFk}ZO7^@jt*M+-R5A9l0>(gF>`y&ye;QY z81Y7IdbjLm=4eMXv)Le~rpBA82j2PaNc;-!y0sh3Q;+41xY-?M-W;_&D^KTYhHS^T z+%dk}_9T>4W00<#=?o|Pyu9rUw>RCYg{T*RBxYkMnA7K(nS(v%n4cdNCt24V%e5t! z^Ha|>Ha2~sR?JOmmhk^5V0GTg7Bg0#=Vq9x`8S9y-Ly}EcBp7N^nF}`k|vE<>QU2n zbUdJEsM+FVH!Xh1Ka8|`R9e)y(PQ0ySJ9g-J2PGX7IIm#oO>pS+eM3W5 z#65HQM z-2IOK#^|y<)6NxA5^0gmMbA^T@S%Xm1C?}_NIsJEUc%ow!o>5G!KAesJHsxQj7|WWTl{IGOfUVtX_=FOe+UXQ*A3VS+k;T*9 zl;)H%*=;m8EfhFTRE|6a^U4_+0JQsrw5M*)pTYm@h%z)s%tEjAh+s9!orvQf>aOei zbqO&^@nOpgN8C(}aK_CDC6F_h5wZfDj z(wG(%PW9GFwT1TpprYFws`_d^CT+zCs6qgB4>T=`?=1g2B0CrpFlN;W$Y&8vFbN{F|VP<;Z?wlk-${YyE+E0vH~<|E4W zK`h2M(1>sH=b4E%4Enwp)LD!}bDc48MD>7!If|T0>&V+vM2YVPDlZO;j%>Pp{bxmd-+djeq1~_-o z8>ngXH`x+uBBv`)Q>Q%091A^)1RN}aizPVZ+iMQ6rb08q(1?$H7@*A zVu_0VeyCLyR0kEoUU-l>^vhE552~rmz$cTaW&3=oyJZqp{fR{4wmQ_+uA0F75*7rq zg^Bt)++Mq+T(&5&xDHEd>jK$17>Q*i+`(v<&n)r1(N2%^sn$9#N)_ML)jYP%ixN4! zbR?>ry7p<=g)fJ=Yf4xf;4+A43G4PU20F8DFO?HtDbG?WS|1Im&?UQo3#r&NYJIFM zRdSGAB~oIFhq+VUoVs>i2pja$5bC)<%mRO{c#IT(oE`E6Y&^;TOHYxNM{p8H zaSq4Gzo+@VeFp!=vq}Y?Q*=D9tmSh9UQqVoC1nsVD+ln3lEaDAtjn0~`a#vC5alq{Z+MDa*c8J|Jz=WXefpIR{*Zt$0pZfGjL}eo3jq z5E&NnDSHoMpJ9)R5wi9Q)?MR2%9sk<7aUM=P(_Y}yn?k?vB_82cAeJ`(NYCjB&&lB Td?vVS=4f3{0?6Ohji~xBrz5Ut literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/ClubManage$Club.class b/server/target/classes/self/cases/teams/teaa/ClubManage$Club.class new file mode 100644 index 0000000000000000000000000000000000000000..f6e6282134fec9edd492b8c105645605f8fecb6a GIT binary patch literal 2167 zcma)6U2hvz5It+Jza1yB^Fe57-I5Y#aq0jmBqVO3NdpEu4WvY>!~+|9n{Kh!k-dfo zgv2X38aupP%;(Yqq{;8kBm2R*6qz&vRx z}95AxsTh8L$kvnxmJh4iBrp!TbW=s8eBoGYx3ccdZ12YbOuPSdeJG|a^p zkt3aZ!L{H-bGB3OSj0Z$B@_-R*RUqsO&z&r{rj4E<_{}C35oHvDAX}pE?H0H68#vDs8ZrOZt%q9 z3Yw-Y0T)u1zzZu&0P1*$_N>mQUT{6%;51ZHZdaM2x2h{Z1pqsz6jZmsRbw z_rR~MVHE~Fqru@nMuH0ygWsJPtd9m4Ck7X>HlcE4G68bx?g#V z6PAIcjE7GV)xR5BWl}9-6G?0Z(xlEu_uhG$nx7`ixkrD)l$WjHXA7$(WYjWuNRKjR zaVL;5>t}qQKnQ1+i1-us5&l9Dg7Eln#2!9FJewFGDeD~|l}&qgm}=(R0j9DU&!L|? zraebwfSK&9XGa-1^D|!$kR2WNZUENtd7~S+MHIr3Tl^PxY8Qm}$W>E;3*Mz4DBS#z nB-RvlBXSVeN3YLz_>yd!!EBof%a)QKW0^Y1>^W5NHWL2<-Z+!} literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/ClubManage$Event.class b/server/target/classes/self/cases/teams/teaa/ClubManage$Event.class new file mode 100644 index 0000000000000000000000000000000000000000..6ff7537e27b4ea187cce02c9799d93360846ab39 GIT binary patch literal 2104 zcma)7TW=dx5dMzs^{rbcbraH%Pz?0qn55=b3QZHBP77|Gw2%@BiI)Jb}rw{`F8j5zmNU`@CH84Vgi>l zIEh6OS41p{SQhb43h!o-!sRsH6Ma=gC5@Fdu8Da)jrT==kVaMXjTCArtSY4ReI10= zhJvapBBHE)|Sc^lL8g01p;*!F`h z1{`bXPQC5#gnlbv?JIuZhsz4f#cDOO`*Q9(6X9LIqu^YVK^5F;5a@QL>2*4q?qaQ@o1c~I9#7>^d)r2OIL4G zK4TI&&iJYh@3tDZy*5Vsn-kj0AJfnGk)LAHA@oC0A&(qh`N$NuBAyjFm zi&$y4i+E|Fi$rNU(S=i*cDhJDFck`vr}>QnzCi-tB7^Uc!}rAS1AG0*ia!w%uxxAM zMV#e{)eSafEI}7Dmf(vUOAscEB^Vu?qdn;`2^ z$()0 ztRuPS82^&q9`d7T9u1(`*uQ~S@G4Qr5-*y)@k$TKWv}jUlW1w8_DQ7h8VSR?Ad+J?z4OEKmY#uH-H6vmc=v{GdP3` zB9=s46!C$GOKDurB8^1{S43AteCXh+=xYu>a`3T(s+>L%@o5^%X{;zXEz?>zLA9Zv zstO5Tw~Ru*c3(fx<)-#G%Bx}E`5TK0Nz>9^lQBWN$r#7$T&{=S1DfitLh6F&d*MZe z^Tq0D_Vak=?hw1uZV+&?=J{r2TPnM)*X6Z*tzFm6J38>>+;b+vO|QeJmu(LUxvKA* zpwiTxj-h|9)-la*%5}|CIW)Rur7l;R+w05P*Bj1lrUNyKC%v|=(9t2r2}IUB1v9_kzvCwPK! zCwcmrI!S%feFEjq>>%crb`W>xcaU(8C3cW>DN=t}fCA+S{u6*TBybNIe1QY_k|lh_ zE%=&ungz)}$U@>(yv`HBZE4C{Qe4bhQeNCzQeXn7X&+256zl*51h)#Tb{0iSskTfl zFiH0@V!zXfp+K3k&W3$k+7mjWxA|$qrDr%f{%9z9b8PY(W0MoZ$<49JrLoD$;pDBc z$upQAQ+8^&=WuND8B3J(yg-J8kCYq#-xRZU2H%mV?*|Z4eb)F*^`8H+hp_e+(w{$p zlh1UK75clF$mb$EPBnF}ix=_-B1fX{n2a3BzGEtKq`Ejb^^hrDTjRIJKQg2_bVv}*{Oy7(SCUf+Sx%gsYT)4{n37X u3fj3rv~w2iz5c$Jh%Mub#fJy~+W<$gUaK*@FR?g}Q`A{z9zqSTA@d(+eqcrb literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/ClubManage.class b/server/target/classes/self/cases/teams/teaa/ClubManage.class new file mode 100644 index 0000000000000000000000000000000000000000..177a05f5583e410507fa546dde76c80b99d3b7ad GIT binary patch literal 20688 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 literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/ClubManagementSystem$Event.class b/server/target/classes/self/cases/teams/teaa/ClubManagementSystem$Event.class new file mode 100644 index 0000000000000000000000000000000000000000..a34b663afab5ba20d90afd190d59fc0ed9e7c495 GIT binary patch literal 1765 zcmb7ETTc^F5dKcv?Tr<%fQTSgMQK;Chb)BgPR?FWDpScsz+lQHz*IExc3 zPO><~;&cRO;)q}}inFZGv6zZtI*J)KXQMdJ`a%>JS37EIe*krhf?dQfv^ zWki*r!MYcuyIL*XG#wh=l@8U3uSi#Y=IsSjX`|y}kBs z2L8R-PAWIwy4Ema6McQC_xqBLjYO9A!Rr?8Rjreb}X=pT%wr=-7in9YYut z=vSn-w4GbG$|dOtbgDTYO7C!HbX>tz7CiD;(z~D;nq(}gLU>{obWLDK)5pWjjB?U- z;&Ck5awzQ1U_64nz{LM@L)83%eWP$s7Kw3UgN`O_uB}O%s2ETAT-6p=b6O&MD3xoH zwRIWv`LA+b%c+?J{$i&GWOFCznA_TGz6GOvI0z{(!{3HM5xllDd`9V(LPLZ z`{?zCbeMF~*nltw>j)S_bp(y^Izq-ks1D5-(CP?(Q5BLThp7Va1R*>{4A0Ps=Y-(} z^?FGaUlAf;)~ksFI7Bb1uCNJZF}i@V7++9Xj4-4u#;D;i*?k%%frbH{CFm+aM+pKy ziWEr(pCQdfHRCG+pU4PMCs1#8zE((dFQAD;AnltRY)^jcn{40+m22-D`rOv}op16O z#(k2t_T=}z$wz&Y!|ll*e3R*?)a?A2HpIJG{*K7)4MY>M2I9QD209YDX9wBd;n|@E zIul)O1)tq24N@G!B5u*hE1^(InP z^^u4Emp-&oW27SW2lPi(oI7g*I93EN_ujcP_s+TJ?CgL4|MM?^c`Oz%fw?^PVqVM{ zF=xe`6Z3Tr=L^VT&cy}s7sXt1u^|4ki*H<9adA~v*TmFvxSqoe1-D~5t0t??qaa+nsE{!o9kh8S>b7~t4SH9baj?NqttezK1z`|hR=7~E zZ?FE4%*---*Sak>+}#L5b8B6Y-O;OZTd~n?>h`jZ0$C4|PW&|J@#;l8gMwENLlf27 zy4N$z&oz3c{iNE|TvcPEJJ#xIt-Zdws6)MGIwp*le(A-gb1dn>F~=88{IuKpNk^n2 zHW3?*t(iF47oO7P88Ve)?v^EMqCB&GJo3W>*AvF%>}^XLYspoiWwcPIV@}2t2Y2Ic zLNs@my6aKX+z4du$x&cWh&moVL)F7R?Dud0pL&=Sb5P6_4k;WMmhjqo&~BN?PAJU& z`bPQ%4>$3h7|!KZO7aaXOw0Ovg?y!Cbzhjad!oIBW0ley{cZUV9!|o~p`mc&~DVFur%X&&i??O@4!#sC{tKaD}^hf-cQ2x{=QhsFSOe<)s^wK8d|Bcii3{oi3W^MAZz1vF;4DME#fzQlvar)1pVm-3> z_{d^sxY&#=u8b_s3>OC@i>EL<0(N$I=FZ6C6P75Md7cajVOc-@o{9yl!OzqwdZ$Bn zi#5Kp!Syc&9Ui_y?!imA#e5$Hp}&u@qL;*Jy75PSd{W$%B%H0p?j(`fN{lCoY#)2Z ie`84>#bHJ^-huRR04ar2R27?2PRwHTgYFFM} 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 literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/ECommercePlatform$Order.class b/server/target/classes/self/cases/teams/teaa/ECommercePlatform$Order.class new file mode 100644 index 0000000000000000000000000000000000000000..055dd74b612a4ec5af8934840bf6553b5a20a166 GIT binary patch literal 2788 zcmb_e*>h7>82{ZYy-9khC19aYwMeyTni3Ikp%kSH(2_3DMX89MCb#W{o5h=x%BsFF z`mp~^j#&AuY?<;UU zh7V%+P@y7*l^F5~sxGLzZDQ5LngO%y6>M*^U?7>hAvQ$T6{WT8y!4#X+OUDPTGfAz zYrb(IZ3Eptr*w*THdoFISCJQZqd?S=cCl)p)90y4$Ia%Ps^n9A-dQUNS@WnOKC8`= z*MK!yD%swcE2>qSk`oP*XL42BUCrhNU$fE{MGZxEVys*&+FstCbA?t~#jBhMO`OEpLKBua~z8r&HkSTYb9D;F5WGdZVZ&(w-5wznWwTvC!cA4|e>)IA_Z zSfOc%o=a+oP2S|7)~Qmwc6?#F{Prg0Q#t zrv{oc&MqL&V$fjL7Qf$PhqokJRK!4x%#(hjCAS#=*=iS>h))-YfjzXeP?o}-^PD^j zd~i#1QONb|sIxY1=bfT(S*3_-eFGl75Ib^W_tZ~G}6zlk?GY;s$FR19zJC@GQE2JjIeH*UY${0Hol)xu1w&RfuUUm z!cF$r*V&aDc3!fbTh)leugSU(SyfNSG6M>y^uk!4xH4;?<1vR?iu9QN28>->owY*& zTfPGO`ysj+{1-k~l? z&y)E%2|fH40}+JOd=Lw%5z!~7M4ucK7Y}tmak!C6c5@6r)cXE;>e+cU+{gHK{vnmLwq^uYr-+S!kgk(9vK=_ zK7}-L` zF%#pzv%&a}XgkrLGi+6*rJvAw^&$2qlXdJ<730x)t&aW4XMI9=o6zMGB6S={9`y03 z!n+k-$06dK_bFM&;m7&w(Ei=T1yr!e?}BPdzx+#q&mo*AEkurfo=IW}EZ}9fa}Uof G;(r4IeVjS~ literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/ECommercePlatform$OrderItem.class b/server/target/classes/self/cases/teams/teaa/ECommercePlatform$OrderItem.class new file mode 100644 index 0000000000000000000000000000000000000000..9f6c83882237ff0744dddf0d82a9b48ab2a4c9ce GIT binary patch literal 1421 zcmb7DTTc@~6#k~yZCRvND5$7_DD6^M5xgMa1=OTT6%2;N#Ft?^lqGwq+pUQ~H1WX) zU;HCJXd)%i#2?^~GM?F%qHRO;<(xBT&UbF#%+FunegK%my(Ci566nLE6nQD8;+Re% z3Qd77^%W^*6kL^hR>7Rq*QB@}$IUqA84?xGE!7OaP+~|Iclb-LTihw@>%M0?AzxN1%_zFGY!FzX~f#x-`1DS@_k{LHn%7~wrD!0f14qn?Mzqbj>>H?L{{7q zg=H@=gxF=IxXo@F^F3# zP9m-16#7*RAj2@&&fId%v}iR91Fi9PTU0Mis93A7*b8x<+ zVgh4v++~>g@14?0k6K&Z+!2P)KcgmC(0DmWq~CthXPC14r7Gu-Y^A# z;GkCnYGxE;BxN%?X$g#KUlICDMhLQcEO5RHs;P~DW;KS37$;9VIQ*#%{Jtyr5-xWE zN7^fY=nAIi*aREYr)+!vJEG4H5KG7FP~-@tQqSv1q>~LtxQ?E*+OQ*a^rrUcvW^q& c1wZ~#aK1Te2-#q!9L|$YQo%mlz&Rv-1CMPnt^fc4 literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/ECommercePlatform$Product.class b/server/target/classes/self/cases/teams/teaa/ECommercePlatform$Product.class new file mode 100644 index 0000000000000000000000000000000000000000..5759bbe8fba84a6025a9df93e2bd313ce903c8f4 GIT binary patch literal 1857 zcmb7E-ESL35dW=xXP@0m>o_0%hzm|>iR~seEp36O2{djB4o(^fsuYO_Hs_6V?R}W@ zx&k32{t{k!;Q^$^k*HMO`J+&0_byGbO$9GAv$He5o%zk&{q^@BF96)cmwC+KRu0p+ zt;7dPe5k}nS=_O(oJR(CvslR^hg%j_mHt?XPb}QCu%^t0h5JgcEAb$U&$4JT+BmZ)O zKz$W9g**t`+dLv3q=*Q{?g*I#DB7kg)zO})3X0m&+*vwa(|7JTcDP#x6}1y{n66Zb z#Z&!mn@f@SjEW}2`nJyl>B{dJCUzuuo^0}N(!C|acxnv!ov=^sJa83Nvm@4pKr#b)r7dv3d|2Vahh zEgzSs&_8E5dx8|#w$^vOwul&}5(a6)_*STdCLq8|bb{S;lXu(bs-V|Y-C$xFG zxfvtj60Xom#j8q~wp1-CZK-O~+EVoxc$e%+gF-$=eLovB~M-H5El761YzC1}13`bGWVXXJd?4 zBProMBAtGq6iur#nbY)}jNFQH`T&#KB_%4#H=ZN6dxU)P)Bv`kpH$)N0Vay4V@LXx x<4o)@1}GFKW7`~{Soo2m2bdaW@6KxkY$OGy@IJknq6RLL&Qk@`_!RFT_Y!Y+eR}`^ literal 0 HcmV?d00001 diff --git a/server/target/classes/self/cases/teams/teaa/ECommercePlatform$User.class b/server/target/classes/self/cases/teams/teaa/ECommercePlatform$User.class new file mode 100644 index 0000000000000000000000000000000000000000..a247fbb502ca3c92a9e08d1de84290a19f07c95a GIT binary patch literal 1597 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 Wm9eUgwb)oojdiZE&NEh>$o)UY51F(8 literal 0 HcmV?d00001