Changes between Version 4 and Version 5 of WikiStart/Development

Timestamp:

03/24/25 22:10:43 (2 weeks ago)

Author:

203206

Comment:

mk2

WikiStart/Development

@@ -8 +8 @@
 
 [[Image(upgrade2.png, width=900, height=700)]]
+
+== Функции во Java Spring services
+
+{{{
+
+
+package com.example.bankapp.service;
+
+import com.example.bankapp.model.Account;
+import com.example.bankapp.model.Transaction;
+import com.example.bankapp.repository.AccountRepository;
+import com.example.bankapp.repository.TransactionRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+@Service
+public class AccountService implements UserDetailsService {
+
+    @Autowired
+    PasswordEncoder passwordEncoder;
+
+    @Autowired
+    private AccountRepository accountRepository;
+
+    @Autowired
+    private TransactionRepository transactionRepository;
+
+
+    public Account findAccountByUsername(String username) {
+        return accountRepository.findByUsername(username).orElseThrow(() -> new RuntimeException("Account not found"));
+    }
+
+    public Account registerAccount(String username,String email, String password) {
+        if (accountRepository.findByUsername(username).isPresent()) {
+            throw new RuntimeException("Username already exists");
+        }
+
+        Account account = new Account();
+        account.setUsername(username);
+        account.setEmail(email);
+        account.setPassword(passwordEncoder.encode(password)); // Encrypt password
+        account.setBalance(BigDecimal.ZERO); // Initial balance set to 0
+        return accountRepository.save(account);
+    }
+
+
+    public void deposit(Account account, BigDecimal amount) {
+        account.setBalance(account.getBalance().add(amount));
+        accountRepository.save(account);
+
+        Transaction transaction = new Transaction(
+                amount,
+                "(MKD)",
+                "Deposit",
+                LocalDateTime.now(),
+                account
+        );
+        transactionRepository.save(transaction);
+    }
+
+    public void withdraw(Account account, BigDecimal amount) {
+        if (account.getBalance().compareTo(amount) < 0) {
+            throw new RuntimeException("Insufficient funds");
+        }
+        account.setBalance(account.getBalance().subtract(amount));
+        accountRepository.save(account);
+
+        Transaction transaction = new Transaction(
+                amount,
+                "(MKD)",
+                "Withdrawal",
+                LocalDateTime.now(),
+                account
+        );
+        transactionRepository.save(transaction);
+    }
+
+    public List<Transaction> getTransactionHistory(Account account) {
+        return transactionRepository.findByAccountId(account.getId());
+    }
+
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+
+        Account account = findAccountByUsername(username);
+        if (account == null) {
+            throw new UsernameNotFoundException("Username or Password not found");
+        }
+        return new Account(
+                account.getUsername(),
+                account.getEmail(),
+                account.getPassword(),
+                account.getBalance(),
+                account.getTransactions(),
+                authorities());
+    }
+
+    public Collection<? extends GrantedAuthority> authorities() {
+        return Arrays.asList(new SimpleGrantedAuthority("USER"));
+    }
+
+
+    public void transferAmount(Account fromAccount, String toUsername, BigDecimal amount, String currency) {
+
+        if(fromAccount.getUsername().compareTo(toUsername) == 0){
+            throw new RuntimeException("No transaction allowed to yourself");
+        }
+
+        Account toAccount = accountRepository.findByUsername(toUsername)
+                .orElseThrow(() -> new RuntimeException("Recipient account not found"));
+
+
+        if(currency.compareTo("(MKD)")==0){
+            if (fromAccount.getBalance().compareTo(amount) < 0) {
+                throw new RuntimeException("Insufficient funds");
+            }
+            else{
+                // Deduct from sender's account
+                fromAccount.setBalance(fromAccount.getBalance().subtract(amount));
+                accountRepository.save(fromAccount);
+
+                // Add to recipient's account
+                toAccount.setBalance(toAccount.getBalance().add(amount));
+                accountRepository.save(toAccount);
+
+                // Create transaction records for both accounts
+                Transaction debitTransaction = new Transaction(
+                        amount,
+                        currency,
+                        "(MKD) Transfer Out to " + toAccount.getUsername(),
+                        LocalDateTime.now(),
+                        fromAccount
+                );
+                transactionRepository.save(debitTransaction);
+
+                Transaction creditTransaction = new Transaction(
+                        amount,
+                        currency,
+                        "(MKD) Transfer In from " + fromAccount.getUsername(),
+                        LocalDateTime.now(),
+                        toAccount
+                );
+                transactionRepository.save(creditTransaction);
+            }
+        }
+
+        if(currency.compareTo("(EUR)")==0){
+            if (fromAccount.getBalance().compareTo(amount.multiply(BigDecimal.valueOf(60.00))) < 0) {
+                throw new RuntimeException("Insufficient funds");
+            }
+            else{
+                    // Deduct from sender's account
+                    fromAccount.setBalance(fromAccount.getBalance().subtract(amount.multiply(BigDecimal.valueOf(60.00))));
+                    accountRepository.save(fromAccount);
+
+                    // Add to recipient's account
+                    toAccount.setBalance(toAccount.getBalance().add(amount.multiply(BigDecimal.valueOf(60.00))));
+                    accountRepository.save(toAccount);
+
+                    // Create transaction records for both accounts
+                    Transaction debitTransaction = new Transaction(
+                            amount,
+                            currency,
+                            "(EUR) Transfer Out to " + toAccount.getUsername(),
+                            LocalDateTime.now(),
+                            fromAccount
+                    );
+
+                    transactionRepository.save(debitTransaction);
+
+                    Transaction creditTransaction = new Transaction(
+                        amount,
+                        currency,
+                        "(EUR) Transfer In from " + fromAccount.getUsername(),
+                        LocalDateTime.now(),
+                        toAccount
+                    );
+                    transactionRepository.save(creditTransaction);
+            }
+        }
+
+        if(currency.compareTo("(USD)")==0){
+            if (fromAccount.getBalance().compareTo(amount.multiply(BigDecimal.valueOf(60.00))) < 0) {
+                throw new RuntimeException("Insufficient funds");
+            }
+            else{
+                // Deduct from sender's account
+                fromAccount.setBalance(fromAccount.getBalance().subtract(amount.multiply(BigDecimal.valueOf(60.00))));
+                accountRepository.save(fromAccount);
+
+                // Add to recipient's account
+                toAccount.setBalance(toAccount.getBalance().add(amount.multiply(BigDecimal.valueOf(60.00))));
+                accountRepository.save(toAccount);
+
+                // Create transaction records for both accounts
+                Transaction debitTransaction = new Transaction(
+                        amount,
+                        currency,
+                  "(USD) Transfer Out to " + toAccount.getUsername(),
+                        LocalDateTime.now(),
+                         fromAccount
+                );
+                transactionRepository.save(debitTransaction);
+
+                Transaction creditTransaction = new Transaction(
+                        amount,
+                        currency,
+                        "(USD) Transfer In from " + fromAccount.getUsername(),
+                        LocalDateTime.now(),
+                        toAccount
+                );
+                transactionRepository.save(creditTransaction);
+            }
+        }
+
+        if(currency.compareTo("(GBP)")==0){
+            if (fromAccount.getBalance().compareTo(amount.multiply(BigDecimal.valueOf(70.00))) < 0) {
+                throw new RuntimeException("Insufficient funds");
+            }
+            else{
+                    // Deduct from sender's account
+                    fromAccount.setBalance(fromAccount.getBalance().subtract(amount.multiply(BigDecimal.valueOf(70.00))));
+                    accountRepository.save(fromAccount);
+
+                    // Add to recipient's account
+                    toAccount.setBalance(toAccount.getBalance().add(amount.multiply(BigDecimal.valueOf(70.00))));
+                    accountRepository.save(toAccount);
+
+                    // Create transaction records for both accounts
+                    Transaction debitTransaction = new Transaction(
+                            amount,
+                            currency,
+                            "(GBP) Transfer Out to " + toAccount.getUsername(),
+                            LocalDateTime.now(),
+                            fromAccount
+                    );
+                    transactionRepository.save(debitTransaction);
+
+                    Transaction creditTransaction = new Transaction(
+                            amount,
+                            currency,
+                            "(GBP) Transfer In from " + fromAccount.getUsername(),
+                            LocalDateTime.now(),
+                            toAccount
+                    );
+                    transactionRepository.save(creditTransaction);
+            }
+        }
+
+    }
+
+}
+
+}}}