Splitwise Code changes

src/main/java/Constants.java

@@ -0,0 +1,4 @@
+public class Constants {
+
+    public static final Integer SUCCESS_CODE = 0;
+}

src/main/java/SplitwiseApplication.java

@@ -0,0 +1,6 @@
+public class SplitwiseApplication {
+
+    public static void main(String[] args) {
+
+    }
+}

src/main/java/handlers/EqualComputeHandler.java

@@ -0,0 +1,59 @@
+package handlers;
+
+import impl.UserServiceImpl;
+import interfaces.ComputeHandler;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import models.SplitwiseAddRequest;
+import models.User;
+
+import java.util.HashMap;
+import java.util.List;
+
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class EqualComputeHandler implements ComputeHandler {
+
+    private UserServiceImpl userService;
+
+    @Override
+    public void compute(SplitwiseAddRequest request, HashMap<String, Double> balancesList) {
+        List<User> participants = userService.fetchUserByIds(request.getParticipants());
+        compute(participants, request.getRequestAdderId(), request.getAmount().getValue(), balancesList);
+    }
+
+
+    private void compute(List<User> participants, String requesterId, Double totalValue, HashMap<String, Double> balancesList) {
+
+        Double equalShare = totalValue / participants.size();
+        // For the rest of the users also the same has to be updated
+        participants
+                .forEach(
+                        participant -> {
+                            if (!participant.getUserId().equals(requesterId)) {
+                                Double newBalance = computeParticipantsBalance(participant.getTotalBalance(), equalShare);
+                                participant.setTotalBalance(newBalance);
+                                balancesList.put(participant.getUserId(), newBalance);
+                            } else {
+                                Double updatedRequestorBalance = computeRequestorBalance(participant.getTotalBalance(), equalShare, participants.size());
+                                participant.setTotalBalance(updatedRequestorBalance);
+                                balancesList.put(participant.getUserId(), updatedRequestorBalance);
+                            }
+                        }
+                );
+
+    }
+
+    private Double computeRequestorBalance(Double balance, Double equalShare, Integer totalNumberOfParticipants) {
+        return (balance != null ? balance : 0.0) + equalShare * (totalNumberOfParticipants - 1);
+    }
+
+    private Double computeParticipantsBalance(Double totalbalance, Double equalShare) {
+        return (totalbalance != null ? totalbalance : 0.0) + -1 * equalShare;
+    }
+}

src/main/java/handlers/ExactComputeHandler.java

@@ -0,0 +1,54 @@
+package handlers;
+
+import impl.UserServiceImpl;
+import interfaces.ComputeHandler;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import models.SplitwiseAddRequest;
+import models.User;
+
+import java.util.HashMap;
+import java.util.List;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class ExactComputeHandler implements ComputeHandler {
+
+    private UserServiceImpl userService;
+
+
+    @Override
+    public void compute(SplitwiseAddRequest request, HashMap<String, Double> balancesList) {
+        List<User> participants = userService.fetchUserByIds(request.getParticipants());
+        compute(participants, request.getRequestAdderId(), request.getAmount().getValue(), request.getValues(), balancesList);
+    }
+
+
+    private void compute(List<User> participants, String requesterId,
+                         Double totalValue, List<Double> values, HashMap<String, Double> balancesList) {
+
+        int exactCountIndex = 0;
+        for (User participant : participants) {
+            Double newBalance = computeParticipantsBalance(participant.getTotalBalance(), values.get(exactCountIndex++));
+            participant.setTotalBalance(newBalance);
+            balancesList.put(participant.getUserId(), newBalance);
+        }
+        User requestor = userService.fetchUserById(requesterId);
+        Double newBalance = computeRequestorBalance(requestor.getTotalBalance(), totalValue);
+        requestor.setTotalBalance(newBalance);
+        balancesList.put(requestor.getUserId(), newBalance);
+
+    }
+
+    private Double computeParticipantsBalance(Double totalbalance, Double equalShare) {
+        return (totalbalance != null ? totalbalance : 0.0) + -1 * equalShare;
+    }
+
+    private Double computeRequestorBalance(Double balance, Double equalShare) {
+        return (balance != null ? balance : 0.0) + equalShare;
+    }
+}

src/main/java/handlers/PercentComputeHandler.java

@@ -0,0 +1,63 @@
+package handlers;
+
+import impl.UserServiceImpl;
+import interfaces.ComputeHandler;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import models.SplitwiseAddRequest;
+import models.User;
+
+import java.util.HashMap;
+import java.util.List;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class PercentComputeHandler implements ComputeHandler {
+    private UserServiceImpl userService;
+
+
+    @Override
+    public void compute(SplitwiseAddRequest request, HashMap<String, Double> balancesList) {
+        List<User> participants = userService.fetchUserByIds(request.getParticipants());
+        compute(participants, request.getRequestAdderId(), request.getAmount().getValue(), request.getValues(), request.getParticipants(), balancesList);
+
+    }
+
+    private void compute(List<User> participants, String requesterId,
+                         Double totalValue, List<Double> values, List<String> requestParticipants, HashMap<String, Double> balancesList) {
+
+        int percentCount = 0;
+        //Based on the share each of them will have a value and then it is the almost exact
+        // For the rest of the users also the same has to be updated
+        for (User participant : participants) {
+            Double valueSpent = values.get(percentCount) / 100 * totalValue;
+            String userId = requestParticipants.get(percentCount);
+            percentCount++;
+
+            if (userId.equals(requesterId)) {
+                Double newBalance = computeRequestorBalance(participant.getTotalBalance(), totalValue - valueSpent);
+                participant.setTotalBalance(newBalance);
+                balancesList.put(participant.getUserId(), newBalance);
+
+            } else {
+                Double newBalance = computeParticipantsBalance(participant.getTotalBalance(), valueSpent);
+
+                participant.setTotalBalance(newBalance);
+                balancesList.put(participant.getUserId(), newBalance);
+            }
+        }
+    }
+
+    private Double computeParticipantsBalance(Double totalbalance, Double equalShare) {
+        return (totalbalance != null ? totalbalance : 0.0) + -1 * equalShare;
+    }
+
+    private Double computeRequestorBalance(Double balance, Double equalShare) {
+        return (balance != null ? balance : 0.0) + equalShare;
+    }
+
+}

src/main/java/handlers/ShareComputeHandler.java

@@ -0,0 +1,45 @@
+package handlers;
+
+import impl.UserServiceImpl;
+import interfaces.ComputeHandler;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import models.SplitwiseAddRequest;
+import models.User;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class ShareComputeHandler implements ComputeHandler {
+
+
+    private ExactComputeHandler exactComputeHandler;
+
+    // This is more like ratio pay
+    // 2 1 1 1 -> 1200
+    // 2/5*1200 1/5*1200 1/5*1200 1/5*1200
+    // This is subset of exact Pay Where Values are computed based on share
+
+    @Override
+    public void compute(SplitwiseAddRequest request, HashMap<String, Double> balancesList) {
+        List<Double> values = request.getValues();
+        // Modify the values and call Exact handler
+        Double total = values.stream().mapToDouble(Double::doubleValue).sum();
+
+        values = values.stream()
+                .map(value -> value * request.getAmount().getValue() / total)
+                .collect(Collectors.toList());
+        request.setValues(values);
+        exactComputeHandler.compute(request, balancesList);
+
+    }
+
+
+}