├── .vscode
    └── launch.json
├── Display.js
├── README.md
├── SplitWise.js
├── Transaction.js
├── User.js
├── UserTransaction.js
├── Utils.js
├── constant.js
└── index.js


/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "configurations": [
 3 |         {
 4 |             "name": "Launch Program",
 5 |             "program": "${workspaceFolder}/index.js",
 6 |             "request": "launch",
 7 |             "skipFiles": [
 8 |                 "<node_internals>/**"
 9 |             ],
10 |             "type": "pwa-node"
11 |         },
12 |     ]
13 | }
14 | 


--------------------------------------------------------------------------------
/Display.js:
--------------------------------------------------------------------------------
 1 | 
 2 | class Display {
 3 |     static showUser(users) {
 4 |         console.log("\n==========Users=============")
 5 |         console.log("UID", "Name", "Email", "Phone")
 6 |         for (const [key, value] of Object.entries(users)) {
 7 |             console.log(key, "=>", value.ID, value.Name, value.Email, value.Phone)
 8 |         }
 9 |     }
10 | 
11 |     static showTransaction(transactions) {
12 |         console.log("\n==========Transactions=============")
13 |         console.log("TD", "Payer ID", "Exp.Type", "Amount", "Payee")
14 |         for (const [key, value] of Object.entries(transactions)) {
15 |             console.log(key, value.PayerId, value.ExpenseType, value.Amount, value.Payee)
16 |         }
17 |     }
18 | 
19 |     static showUserTransaction(transactions) {
20 |         console.log("\n==========User Transactions=============")
21 |         console.log("UTID", "TID", "Type", "UID", "Amount")
22 |         for (const [key, value] of Object.entries(transactions)) {
23 |             console.log(key, value.TransactionId, value.TransactionType, value.UserId, value.Amount)
24 |         }
25 |     }
26 | }
27 | 
28 | module.exports.Display = Display


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Splitwise App
 2 | 
 3 | 
 4 | ## Problem Statement
 5 | Create an expense sharing application.
 6 | 
 7 | An expense sharing application is where you can add your expenses and split it among different people. The app keeps balances between people as in who owes how much to whom.
 8 | 
 9 | Example
10 | ```
11 | You live with 3 other friends.
12 | You: User1 (id: u1)
13 | Flatmates: User2 (u2), User3 (u3), User4 (u4)
14 | 
15 | This month's electricity bill was Rs. 1000.
16 | Now you can just go to the app and add that you paid 1000,
17 | select all the 4 people and then select split equally.
18 | Input: u1 1000 4 u1 u2 u3 u4 EQUAL
19 | 
20 | For this transaction, everyone owes 250 to User1.
21 | The app should update the balances in each of the profiles accordingly.
22 | 
23 | User2 owes User1: 250 (0+250)
24 | User3 owes User1: 250 (0+250)
25 | User4 owes User1: 250 (0+250)
26 | 
27 | ---
28 | 
29 | Now, It is the BBD sale on Flipkart and there is an offer on your card.
30 | You buy a few stuffs for User2 and User3 as they asked you to.
31 | The total amount for each person is different.
32 | Input: u1 1250 2 u2 u3 EXACT 370 880
33 | 
34 | For this transaction, User2 owes 370 to User1 and User3 owes 880 to User1.
35 | 
36 | The app should update the balances in each of the profiles accordingly.
37 | User2 owes User1: 620 (250+370)
38 | User3 owes User1: 1130 (250+880)
39 | User4 owes User1: 250 (250+0)
40 | 
41 | ---
42 | 
43 | Now, you go out with your flatmates and take your brother/sister along with you.
44 | User4 pays and everyone splits equally. You owe for 2 people.
45 | Input: u4 1200 4 u1 u2 u3 u4 PERCENT 40 20 20 20
46 | 
47 | For this transaction, User1 owes 480 to User4, User2 owes 240 to User4 and User3 owes 240 to User4.
48 | 
49 | The app should update the balances in each of the profiles accordingly.
50 | User1 owes User4: 230 (250-480)
51 | User2 owes User1: 620 (620+0)
52 | User2 owes User4: 240 (0+240)
53 | User3 owes User1: 1130 (1130+0)
54 | User3 owes User4: 240 (0+240)
55 |     
56 | ```
57 | 
58 | ## Requirements
59 | * User: Each user should have a userId, name, email, mobile number.
60 | * Expense: Could either be EQUAL, EXACT or PERCENT
61 | * Users can add any amount, select any type of expense and split with any of the available users.
62 | * The percent and amount provided could have decimals upto two decimal places.
63 | * In case of percent, you need to verify if the total sum of percentage shares is 100 or not.
64 | * In case of exact, you need to verify if the total sum of shares is equal to the total amount or not.
65 | * The application should have a capability to show expenses for a single user as well as balances for everyone.
66 | * When asked to show balances, the application should show balances of a user with all the users where there is a non-zero balance.
67 | * The amount should be rounded off to two decimal places. Say if User1 paid 100 and amount is split equally among 3 people. Assign 33.34 to first person and 33.33 to others.
68 | 
69 | 
70 | 
71 | Detail problem statement can be read at: https://workat.tech/machine-coding/practice/splitwise-problem-0kp2yneec2q2
72 | 


--------------------------------------------------------------------------------
/SplitWise.js:
--------------------------------------------------------------------------------
  1 | var Transaction = require('./Transaction').Transaction
  2 | var UserTransaction = require('./UserTransaction').UserTransaction
  3 | var User = require('./User').User
  4 | var Utils = require('./Utils').Utils
  5 | 
  6 | var {
  7 |     TRANSACTION_TYPE_CREDIT, 
  8 |     TRANSACTION_TYPE_DEBIT, 
  9 | } = require('./constant')
 10 | 
 11 | class SplitWise {
 12 |     #users
 13 |     #transactions
 14 |     #user_transactions
 15 | 
 16 |     constructor() {
 17 |         this.#users = {}
 18 |         this.#transactions = {}
 19 |         this.#user_transactions = {}
 20 |     }
 21 | 
 22 |     get Users() {
 23 |         return this.#users
 24 |     }
 25 | 
 26 |     get Transactions() {
 27 |         return this.#transactions
 28 |     }
 29 | 
 30 |     get UserTransactions() {
 31 |         return this.#user_transactions
 32 |     }
 33 | 
 34 |     set Users(users) {
 35 |         this.#users = users
 36 |     }
 37 | 
 38 |     set Transactions(transactions) {
 39 |         this.#transactions = transactions
 40 |     }
 41 | 
 42 |     set UserTransactions(user_transactions) {
 43 |         this.#user_transactions = user_transactions
 44 |     }
 45 | 
 46 |     addUser(name, email, phone) {
 47 |         try {
 48 |             var user = User.createUser(name, email, phone)
 49 | 
 50 |             this.Users = {
 51 |                 ...this.Users,
 52 |                 [user.Phone] : user
 53 |             }
 54 | 
 55 |             return Utils.success(user)
 56 |         } catch(err) {
 57 |             return Utils.failed(err)    
 58 |         }
 59 |     }
 60 | 
 61 |     addTransaction(payerPhone, expense_type, amount, payee) {
 62 |         try {
 63 |             var payer = this.findUser(payerPhone)
 64 |             var tran = Transaction.createTransaction(payer.ID, expense_type, amount, payee)
 65 |             
 66 |             this.Transactions = {
 67 |                 ...this.Transactions,
 68 |                 [tran.ID]: tran
 69 |             }
 70 | 
 71 |             var ut = UserTransaction.createUserTransaction(tran.ID, payer.ID, TRANSACTION_TYPE_DEBIT, amount)
 72 |             this.UserTransactions = {
 73 |                 ...this.UserTransactions,
 74 |                 [ut.ID] : ut
 75 |             }
 76 | 
 77 |             for(let i=0; i<payee.length; i++) {
 78 |                 let phone = payee[i]
 79 |                 let user = this.findUser(phone)
 80 |                 let share = Utils.getShare(payee, amount, expense_type)
 81 |                 let t = UserTransaction.createUserTransaction(tran.ID, user.ID, TRANSACTION_TYPE_CREDIT, share)
 82 | 
 83 |                 this.UserTransactions = {
 84 |                     ...this.UserTransactions,
 85 |                     [t.ID] : t
 86 |                 }
 87 |             }
 88 | 
 89 |             return Utils.success(tran)
 90 |         } catch(err) {
 91 |             return Utils.failed(err)
 92 |         }
 93 |     }
 94 | 
 95 |     findUser(phone) {
 96 |         if(this.Users[phone] === undefined) {
 97 |             throw "User not found"
 98 |         }
 99 | 
100 |         return this.Users[phone]
101 |     }
102 | }
103 | 
104 | 
105 | module.exports.SplitWise = SplitWise
106 | 
107 | 
108 | 


--------------------------------------------------------------------------------
/Transaction.js:
--------------------------------------------------------------------------------
 1 | var { 
 2 |     TRANSACTION, 
 3 |     EXPENSE_TYPE_EQUAL,
 4 |     EXPENSE_TYPE_PERCENT,
 5 |     EXPENSE_TYPE_EXACT
 6 | } = require('./constant')
 7 | 
 8 | class Transaction {
 9 |     #id
10 |     #payer_id
11 |     #expense_type
12 |     #amount
13 |     #payee
14 | 
15 |     constructor() {
16 |         this.#id = TRANSACTION++
17 |     }
18 | 
19 |     get ID() {
20 |         return this.#id
21 |     }
22 | 
23 |     get PayerId() {
24 |         return this.#payer_id
25 |     }
26 | 
27 |     get ExpenseType() {
28 |         return this.#expense_type
29 |     }
30 | 
31 |     get Amount() {
32 |         return this.#amount
33 |     }
34 | 
35 |     get Payee() {
36 |         return this.#payee
37 |     }
38 | 
39 |     set PayerId(payer_id) {
40 |         if(payer_id === "" || payer_id === undefined) {
41 |             throw "invalid user id"
42 |         }
43 | 
44 |         this.#payer_id = payer_id
45 |     }
46 | 
47 |     set ExpenseType(expense_type) {
48 |         if(expense_type != EXPENSE_TYPE_EQUAL && 
49 |             expense_type != EXPENSE_TYPE_EXACT &&
50 |             expense_type != EXPENSE_TYPE_PERCENT) {
51 |                 throw "Invalid expense type"
52 |         }
53 | 
54 |         this.#expense_type = expense_type
55 |     }
56 | 
57 |     set Amount(amount) {
58 |         if(amount < 0) {
59 |             throw "Invalid amount"
60 |         }
61 | 
62 |         this.#amount = amount
63 |     }
64 | 
65 |     set Payee(payee) {
66 |         if(!Array.isArray(payee)) {
67 |             throw "Payee must be an array"
68 |         }
69 | 
70 |         this.#payee = payee
71 |     }
72 | 
73 | 
74 |     static createTransaction(payer_id, expense_type, amount, payee) {
75 |         var t = new Transaction()
76 |         t.PayerId = payer_id
77 |         t.ExpenseType = expense_type
78 |         t.Amount = amount
79 |         t.Payee = payee
80 | 
81 |         return t
82 |     }
83 | }
84 | 
85 | 
86 | module.exports.Transaction = Transaction


--------------------------------------------------------------------------------
/User.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var USER_ID = 0
 3 | 
 4 | class User {
 5 |     #id
 6 |     #name
 7 |     #email
 8 |     #phone
 9 | 
10 |     constructor(){
11 |         this.#id = USER_ID++
12 |     }
13 | 
14 |     get Name() {
15 |         return this.#name
16 |     }
17 | 
18 |     get Email() {
19 |         return this.#email
20 |     }
21 | 
22 |     get Phone() {
23 |         return this.#phone
24 |     }
25 | 
26 |     get ID() {
27 |         return this.#id
28 |     }
29 | 
30 |     set Name(name) {
31 |         if(name === "" || name === undefined) {
32 |             throw "name can't be empty"
33 |         }
34 | 
35 |         this.#name = name
36 |     }
37 | 
38 |     set Email(email) {
39 |         if(email === "" || email === undefined) {
40 |             throw "name can't be empty"
41 |         }
42 | 
43 |         this.#email = email
44 |     }
45 | 
46 |     set Phone(phone) {
47 |         if(phone === "" || phone === undefined) {
48 |             throw "name can't be empty"
49 |         }
50 | 
51 |         this.#phone = phone
52 |     }
53 | 
54 |     static createUser(name, email, phone) {
55 |         var user = new User()
56 |         user.Name = name
57 |         user.Email = email
58 |         user.Phone = phone
59 | 
60 |         return user
61 |     }
62 | }
63 | 
64 | 
65 | 
66 | module.exports.User = User


--------------------------------------------------------------------------------
/UserTransaction.js:
--------------------------------------------------------------------------------
 1 | var {
 2 |     USER_TRANSACTION, 
 3 |     TRANSACTION_TYPE_CREDIT, 
 4 |     TRANSACTION_TYPE_DEBIT
 5 | } = require('./constant')
 6 | 
 7 | class UserTransaction {
 8 |     #id
 9 |     #user_id
10 |     #transaction_type
11 |     #transaction_id
12 |     #amount
13 | 
14 |     constructor() {
15 |         this.#id = USER_TRANSACTION ++
16 |     }
17 | 
18 |     get ID() {
19 |         return this.#id
20 |     }
21 | 
22 |     get UserId() {
23 |         return this.#user_id
24 |     }
25 | 
26 |     get TransactionType() {
27 |         return this.#transaction_type
28 |     }
29 |     
30 |     get TransactionId() {
31 |         return this.#transaction_id
32 |     }
33 | 
34 |     get Amount() {
35 |         return this.#amount
36 |     }
37 | 
38 |     set UserId(user_id) {
39 |         if(user_id === "" || user_id === undefined) {
40 |             throw "Invalid user id"
41 |         }
42 | 
43 |         this.#user_id = user_id
44 |     }
45 |     
46 |     set TransactionType(transaction_type) {
47 |         if(transaction_type != TRANSACTION_TYPE_CREDIT && transaction_type != TRANSACTION_TYPE_DEBIT) {
48 |             throw "Invalid transaction type"
49 |         }
50 | 
51 |         this.#transaction_type = transaction_type
52 |     }
53 | 
54 | 
55 |     set TransactionId(transaction_id) {
56 |         if(transaction_id === "" || transaction_id === undefined) {
57 |             throw "Invalid transaction_id"
58 |         }
59 | 
60 |         this.#transaction_id = transaction_id
61 |     }
62 | 
63 |     set Amount(amount) {
64 |         if(amount < 0) {
65 |             throw "Invalid amount"
66 |         }
67 | 
68 |         this.#amount = amount
69 |     }
70 | 
71 |     static createUserTransaction(tran_id, user_id, tran_type, amount) {
72 |         var ut = new UserTransaction()
73 |         ut.Amount = amount
74 |         ut.UserId = user_id
75 |         ut.TransactionId = tran_id
76 |         ut.TransactionType = tran_type
77 | 
78 |         return ut
79 |     }
80 | }
81 | 
82 | 
83 | module.exports.UserTransaction = UserTransaction


--------------------------------------------------------------------------------
/Utils.js:
--------------------------------------------------------------------------------
 1 | var {
 2 |     EXPENSE_TYPE_EXACT, 
 3 |     EXPENSE_TYPE_EQUAL
 4 | } = require('./constant')
 5 | 
 6 | class Utils {
 7 | 
 8 |     static failed(err) {
 9 |         return {
10 |             code: "failed",
11 |             err
12 |         }
13 |     }
14 | 
15 |     static success(data) {
16 |         return {
17 |             code: "succes",
18 |             data: data
19 |         }
20 |     }
21 | 
22 |     static getShare(payee, amount, expense_type)  {
23 |         if(expense_type === EXPENSE_TYPE_EXACT) {
24 |             return amount
25 |         }
26 | 
27 |         if(expense_type === EXPENSE_TYPE_EQUAL) {
28 |             return (amount/payee.length).toFixed(2)
29 |         }
30 |     }
31 | }
32 | 
33 | module.exports.Utils = Utils


--------------------------------------------------------------------------------
/constant.js:
--------------------------------------------------------------------------------
 1 | 
 2 | module.exports = {
 3 |     USER: 0,
 4 |     TRANSACTION: 0,
 5 |     USER_TRANSACTION: 0,
 6 |     
 7 |     EXPENSE_TYPE_EQUAL: "EQUAL",
 8 |     EXPENSE_TYPE_EXACT: "EXACT",
 9 |     TRANSACTION_TYPE_CREDIT: "CREDIT",
10 |     TRANSACTION_TYPE_DEBIT: "DEBIT"
11 | }


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | // Driver file
 2 | 
 3 | var SplitWise = require('./SplitWise').SplitWise
 4 | var Display = require('./Display').Display
 5 | 
 6 | var { 
 7 |     EXPENSE_TYPE_EQUAL,
 8 |     EXPENSE_TYPE_EXACT
 9 | } = require('./constant')
10 | 
11 | var app = new SplitWise()
12 | 
13 | var res = app.addUser("temp1", "temp1@gmail.com", 1234567890)
14 | console.log(res)
15 | 
16 | 
17 | var res = app.addUser("tmp2", "tmp2@gmail.com", 2345678901)
18 | console.log(res)
19 | 
20 | 
21 | var res = app.addUser("temp3", "temp3@gmail.com", 3456789012)
22 | console.log(res)
23 | 
24 | var res = app.addUser("temp3", "temp3@gmail.com", 4567890123)
25 | console.log(res)
26 | 
27 | var res = app.addTransaction(1234567890, EXPENSE_TYPE_EQUAL, 100, [
28 |     2345678901, 3456789012, 4567890123
29 | ])
30 | console.log(res)
31 | 
32 | 
33 | var res = app.addTransaction(4567890123, EXPENSE_TYPE_EQUAL, 1000, [
34 |     2345678901, 1234567890, 3456789012
35 | ])
36 | console.log(res)
37 | 
38 | var res = app.addTransaction(3456789012, EXPENSE_TYPE_EXACT, 100, [1234567890])
39 | console.log(res)
40 | 
41 | Display.showUser(app.Users)
42 | Display.showTransaction(app.Transactions)
43 | Display.showUserTransaction(app.UserTransactions)


--------------------------------------------------------------------------------