2025_105_Fintech

P2PLendingSystem/Borrower.java

@@ -0,0 +1,78 @@
+package dsa_modules;
+
+public class Borrower {
+    private int id;
+    private String name;
+    private int creditScore;
+    private int requestedAmount;
+    private double requestedRate;
+    public Borrower left, right;
+
+    /**
+     * Full constructor including all fields.
+     */
+    public Borrower(int id, String name, int creditScore, int requestedAmount, double requestedRate) {
+        this.id = id;
+        this.name = name;
+        this.creditScore = creditScore;
+        this.requestedAmount = requestedAmount;
+        this.requestedRate = requestedRate;
+        this.left = null;
+        this.right = null;
+    }
+
+    /**
+     * Constructor for DAO usage when only id, name, and creditScore are known.
+     * requestedAmount and requestedRate default to 0.
+     */
+    public Borrower(int id, String name, int creditScore) {
+        this(id, name, creditScore, 0, 0.0);
+    }
+
+    /**
+     * Constructor for in-memory creation before DB assignment of ID.
+     */
+    public Borrower(String name, int creditScore, int requestedAmount, double requestedRate) {
+        this(0, name, creditScore, requestedAmount, requestedRate);
+    }
+
+    // ID getter/setter
+    public int getId() {
+        return id;
+    }
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    // Name getter/setter
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    // Credit score getter/setter
+    public int getCreditScore() {
+        return creditScore;
+    }
+    public void setCreditScore(int creditScore) {
+        this.creditScore = creditScore;
+    }
+
+    // Requested amount getter/setter
+    public int getRequestedAmount() {
+        return requestedAmount;
+    }
+    public void setRequestedAmount(int requestedAmount) {
+        this.requestedAmount = requestedAmount;
+    }
+
+    // Requested rate getter/setter
+    public double getRequestedRate() {
+        return requestedRate;
+    }
+    public void setRequestedRate(double requestedRate) {
+        this.requestedRate = requestedRate;
+    }
+}

P2PLendingSystem/BorrowerDAO.java

@@ -0,0 +1,188 @@
+package dao;
+
+import db.DatabaseUtil;
+import dsa_modules.Borrower;
+import java.util.Map;
+import java.util.HashMap;
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class BorrowerDAO {
+
+    private Connection conn;
+
+    // Constructor
+    public BorrowerDAO(Connection connection) {
+        this.conn = connection;
+        try {
+            conn.setAutoCommit(true);
+        } catch (SQLException e) {
+            System.err.println("Failed to set auto-commit: " + e.getMessage());
+        }
+    }
+
+    // Save borrower (default status = 'active')
+    public void saveBorrower(Borrower b) {
+        String sql = "INSERT INTO borrowers (name, credit_score, requested_amount, requested_rate, status) VALUES (?, ?, ?, ?, ?)";
+        try (PreparedStatement stmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
+            stmt.setString(1, b.getName());
+            stmt.setInt(2, b.getCreditScore());
+            stmt.setInt(3, b.getRequestedAmount());
+            stmt.setDouble(4, b.getRequestedRate());
+            stmt.setString(5, "active"); // default status
+
+            stmt.executeUpdate();
+
+            try (ResultSet rs = stmt.getGeneratedKeys()) {
+                if (rs.next()) {
+                    int generatedId = rs.getInt(1);
+                    b.setId(generatedId);
+                }
+            }
+        } catch (SQLException e) {
+            System.err.println("Error saving borrower: " + e.getMessage());
+        }
+    }
+
+    // Retrieve borrower by ID
+    public Borrower getBorrowerById(int id) {
+        String sql = "SELECT * FROM borrowers WHERE borrower_id = ?";
+        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+            stmt.setInt(1, id);
+            try (ResultSet rs = stmt.executeQuery()) {
+                if (rs.next()) {
+                    return new Borrower(
+                        rs.getInt("borrower_id"),
+                        rs.getString("name"),
+                        rs.getInt("credit_score"),
+                        rs.getInt("requested_amount"),
+                        rs.getDouble("requested_rate")
+                    );
+                }
+            }
+        } catch (SQLException e) {
+            System.err.println("Error retrieving borrower: " + e.getMessage());
+        }
+        return null;
+    }
+
+    // ✅ Retrieve borrower by name
+    public Borrower getBorrowerByName(String name) {
+        String sql = "SELECT * FROM borrowers WHERE name = ?";
+        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+            stmt.setString(1, name);
+            try (ResultSet rs = stmt.executeQuery()) {
+                if (rs.next()) {
+                    return new Borrower(
+                        rs.getInt("borrower_id"),
+                        rs.getString("name"),
+                        rs.getInt("credit_score"),
+                        rs.getInt("requested_amount"),
+                        rs.getDouble("requested_rate")
+                    );
+                }
+            }
+        } catch (SQLException e) {
+            System.err.println("Error retrieving borrower by name: " + e.getMessage());
+        }
+        return null;
+    }
+
+    // Get borrower status by ID
+    public String getBorrowerStatusById(int borrowerId) {
+        String sql = "SELECT status FROM borrowers WHERE borrower_id = ?";
+        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+            stmt.setInt(1, borrowerId);
+            try (ResultSet rs = stmt.executeQuery()) {
+                if (rs.next()) {
+                    String status = rs.getString("status");
+                    return status != null ? status.trim().toLowerCase() : "active";
+                }
+            }
+        } catch (SQLException e) {
+            System.err.println("Error getting borrower status: " + e.getMessage());
+        }
+        return "active";
+    }
+
+    // Update borrower status
+    public void updateBorrowerStatus(int borrowerId, String status) {
+        String sql = "UPDATE borrowers SET status = ? WHERE borrower_id = ?";
+        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+            stmt.setString(1, status);
+            stmt.setInt(2, borrowerId);
+            stmt.executeUpdate();
+        } catch (SQLException e) {
+            System.err.println("Error updating borrower status: " + e.getMessage());
+        }
+    }
+
+    // Get all active borrowers sorted by credit score (descending)
+    public List<Borrower> getAllBorrowersSortedByCreditScore() {
+        List<Borrower> borrowers = new ArrayList<>();
+        String sql = "SELECT * FROM borrowers WHERE status = 'active'";
+        try (Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery(sql)) {
+
+            while (rs.next()) {
+                Borrower b = new Borrower(
+                    rs.getInt("borrower_id"),
+                    rs.getString("name"),
+                    rs.getInt("credit_score"),
+                    rs.getInt("requested_amount"),
+                    rs.getDouble("requested_rate")
+                );
+                borrowers.add(b);
+            }
+
+        } catch (SQLException e) {
+            System.err.println("Error retrieving borrowers: " + e.getMessage());
+        }
+
+        borrowers.sort(Comparator.comparingInt(Borrower::getCreditScore).reversed());
+        return borrowers;
+    }
+
+    // Update requested amount and rate
+    public void updateRequestedDetails(int borrowerId, int amount, double rate) throws SQLException {
+        String sql = "UPDATE borrowers SET requested_amount = ?, requested_rate = ? WHERE borrower_id = ?";
+        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+            stmt.setInt(1, amount);
+            stmt.setDouble(2, rate);
+            stmt.setInt(3, borrowerId);
+            stmt.executeUpdate();
+        }
+    }
+
+    // Load all active borrowers into a map (key = borrower name)
+    public Map<String, Borrower> loadAllBorrowersIntoMap() {
+        Map<String, Borrower> borrowerMap = new HashMap<>();
+        String sql = "SELECT * FROM borrowers WHERE status = 'active'";
+        try (Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery(sql)) {
+
+            while (rs.next()) {
+                Borrower b = new Borrower(
+                    rs.getInt("borrower_id"),
+                    rs.getString("name"),
+                    rs.getInt("credit_score"),
+                    rs.getInt("requested_amount"),
+                    rs.getDouble("requested_rate")
+                );
+                borrowerMap.put(b.getName(), b);
+            }
+
+        } catch (SQLException e) {
+            System.err.println("Error loading borrowers into map: " + e.getMessage());
+        }
+
+        return borrowerMap;
+    }
+
+}
+
+
+
+

P2PLendingSystem/CreditScoreBST.java

@@ -0,0 +1,90 @@
+package dsa_modules;
+
+import dao.BorrowerDAO;
+import dao.LenderDAO;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CreditScoreBST {
+    public Borrower root;
+    private BorrowerDAO borrowerDAO;
+
+    // Default constructor (no DB usage)
+    public CreditScoreBST() {
+        this.borrowerDAO = null;
+    }
+
+    // Constructor for DB-enabled version
+    public CreditScoreBST(BorrowerDAO borrowerDAO) {
+        this.borrowerDAO = borrowerDAO;
+    }
+
+    public void insert(Borrower b) {
+        root = insertRec(root, b);
+        System.out.println("📌 Inserted Borrower: " + b.getName() + " | Credit Score: " + b.getCreditScore() +
+                " | Requested Amount: " + b.getRequestedAmount() + " | Requested Rate: " + b.getRequestedRate());
+
+        if (borrowerDAO != null) {
+            borrowerDAO.saveBorrower(b); // Save to DB if DAO is provided
+        }
+    }
+
+    private Borrower insertRec(Borrower root, Borrower b) {
+        if (root == null) return b;
+        if (b.getCreditScore() < root.getCreditScore()) {
+            root.left = insertRec(root.left, b);
+        } else {
+            root.right = insertRec(root.right, b);
+        }
+        return root;
+    }
+
+    // In-order print (optional)
+    public void inorder(Borrower root) {
+        if (root != null) {
+            inorder(root.left);
+            System.out.println(root.getName() + ": " + root.getCreditScore());
+            inorder(root.right);
+        }
+    }
+
+    public List<Borrower> getSortedBorrowers() {
+        List<Borrower> list = new ArrayList<>();
+        inorderHelper(root, list);
+        return list;
+    }
+
+    private void inorderHelper(Borrower node, List<Borrower> list) {
+        if (node != null) {
+            inorderHelper(node.left, list);
+            list.add(node);
+            inorderHelper(node.right, list);
+        }
+    }
+
+    // 🔄 Matching logic: true if lender can support borrower's request
+    public static boolean isMatch(Lender lender, Borrower borrower) {
+        return lender.getMaxAmount() >= borrower.getRequestedAmount() &&
+               borrower.getRequestedRate() >= lender.getPreferredRate();
+    }
+
+    // 🔍 Match all borrowers in BST against a list of lenders
+    public void matchLenders(List<Lender> lenders) {
+        List<Borrower> borrowers = getSortedBorrowers();
+
+        for (Borrower borrower : borrowers) {
+            boolean foundMatch = false;
+            for (Lender lender : lenders) {
+                if (isMatch(lender, borrower)) {
+                    System.out.println("✅ Match Found: Borrower " + borrower.getName() + 
+                                       " ↔ Lender " + lender.getName());
+                    foundMatch = true;
+                    break;
+                }
+            }
+            if (!foundMatch) {
+                System.out.println("❌ No match for Borrower: " + borrower.getName());
+            }
+        }
+    }
+}