path: root/src/index.js

import 'dotenv/config'
import * as sdk from 'matrix-js-sdk'
import db from './db.js'

// Initialize database
db.init()

// Prepare Matrix client
const botUserId = process.env.MATRIX_USERID
const matrixClient = sdk.createClient({
    baseUrl: process.env.MATRIX_BASEURL,
    accessToken: process.env.MATRIX_ACCESS_TOKEN,
    userId: botUserId,
})

// Prepare Matrix functions
const _sendMessage = (roomId, message, formattedMessage) => {
    let content = {
        body: message,
        msgtype: 'm.text',
    }

    if (formattedMessage) {
        content.format = 'org.matrix.custom.html'
        content.formatted_body = formattedMessage
    }

    matrixClient.sendEvent(
        roomId,
        'm.room.message',
        content,
        '',
        (err, res) => {
            console.log(err)
        }
    )
}

// Prepare local utility functions 
const _findUserIdInFormattedMessage = (name, formattedMessage) => {
    let userId = null

    if (!formattedMessage) {
        return null
    }

    const re = /href="https:\/\/matrix.to\/#\/(.*)">(.*)<\/a>/

    formattedMessage.split(' ').forEach(element => {
        if (userId) {
            return
        }

        const match = element.match(re)

        if (match && match[2] === name) {
            userId = decodeURIComponent(match[1])
        }
    })

    return userId
}

// Automatically join new rooms
matrixClient.on('RoomMember.membership', function (event, member) {
    if (member.membership === 'invite' && member.userId === botUserId) {
        matrixClient.joinRoom(member.roomId).then(function () {
            console.log('Auto-joined %s', member.roomId)
        })
    }
})

// Listen for new messages
matrixClient.on('Room.timeline', async (event, room, toStartOfTimeline) => {
    // Don't print paginated results
    if (toStartOfTimeline) {
        return
    }

    // Ignore non-messages
    if (event.getType() !== 'm.room.message') {
        return
    }

    // Ignore own messages
    if (event.getSender() === botUserId) {
        return
    }

    // Ignore old messages
    if (event.getAge() && event.getAge() > 10 * 1000) {
        // in milliseconds
        return
    }

    // Get the message
    const message = `${event.getContent().body}`
    const formattedMessage = event.getContent().formatted_body || null

    // Log the message
    console.log('(%s) %s :: %s', room.name, event.getSender(), message)

    // Try and find a command in the message
    const match = message.match(/^!([a-zA-Z]*)(?: (.*))?/)
    if (match) {
        const command = match[1]
        const args = (match[2] || '').split(' ')

        let users = await db.getUsers(room.roomId)

        let from
        let potentialFrom
        let to
        let amount
        let description

        switch (command) {
            case 'h':
            case 'help':
                _sendMessage(
                    room.roomId,
                    '!hi: introduce yourself to Seb',
                    '<b>!hi</b>: introduce yourself to Seb'
                )
                _sendMessage(
                    room.roomId,
                    '!e 42: add a new expense',
                    '<b>!e 42</b>: add a new expense'
                )
                _sendMessage(
                    room.roomId,
                    '!e 42 Saturday market: describe the expense',
                    '<b>!e 42 Saturday market</b>: describe the expense'
                )
                _sendMessage(
                    room.roomId,
                    '!e @zaphod 42: delegate the expense',
                    '<b>!e @zaphod 42</b>: delegate the expense'
                )
                _sendMessage(
                    room.roomId,
                    '!e 10 @trillian: transfer to a fellow user',
                    '<b>!e 10 @trillian</b>: transfer to a fellow user'
                )
                _sendMessage(
                    room.roomId,
                    '!b: get the balance',
                    '<b>!b</b>: get the balance'
                )
                _sendMessage(
                    room.roomId,
                    '!u: get the list of users',
                    '<b>!u</b>: get the list of users'
                )
                _sendMessage(
                    room.roomId,
                    '!l: list the last 4 actions',
                    '<b>!l</b>: list the last 4 actions'
                )
                _sendMessage(
                    room.roomId,
                    '!l 6: request a specific number of actions',
                    '<b>!l 6</b>: request a specific number of actions'
                )
                _sendMessage(
                    room.roomId,
                    '!undo: undo the last action',
                    '<b>!undo</b>: undo the last action'
                )
                _sendMessage(
                    room.roomId,
                    '!reset: remove all expenses and transactions (cannot be undone!)',
                    '<b>!reset</b>: remove all expenses and transactions (cannot be undone!)'
                )
                _sendMessage(
                    room.roomId,
                    '!fullreset: remove all data (cannot be undone!)',
                    '<b>!fullreset</b>: remove all data (cannot be undone!)'
                )
                break

            case 'hi':
                from = args[0] || event.getSender()
                if (users.includes(from)) {
                    _sendMessage(room.roomId, `👋 We've already met, ${from}`)
                    return
                }

                db.write({
                    type: 'introduction',
                    timestamp: event.getDate(),
                    roomId: room.roomId,
                    userId: event.getSender(),
                    data: {
                        userId: from,
                    },
                })
                    .then(() => {
                        _sendMessage(
                            room.roomId,
                            `👋 Pleased to meet you, ${from}`
                        )
                    })
                    .catch((e) => {
                        _sendMessage(
                            room.roomId,
                            `❌ Whoops, something went wrong (${e})`
                        )
                    })
                break

            case 'u':
            case 'users':
                if (users.length === 0) {
                    _sendMessage(
                        room.roomId,
                        "🤷 I don't know anyone here. Do say !hi to get started"
                    )
                }
                users.forEach((user) => {
                    _sendMessage(room.roomId, user)
                })
                break

            case 'l':
            case 'log':
            case 'list':
                ;(await db.getEventLog(room.roomId, parseInt(args[0]))).forEach(
                    (event) => {
                        const ts = new Date(event.timestamp)
                        const formattedTs = `${ts
                            .getDate()
                            .toString()
                            .padStart(2, '0')}-${(ts.getMonth() + 1)
                            .toString()
                            .padStart(2, '0')}-${ts
                            .getFullYear()
                            .toString()} ${ts
                            .getHours()
                            .toString()
                            .padStart(2, '0')}:${ts
                            .getMinutes()
                            .toString()
                            .padStart(2, '0')}`

                        switch (event.type) {
                            case 'introduction':
                                _sendMessage(
                                    room.roomId,
                                    `⌚ ${formattedTs} → ${event.type}\n    👋 ${event.userId}`
                                )
                                break

                            case 'expense':
                                _sendMessage(
                                    room.roomId,
                                    `⌚ ${formattedTs} → ${
                                        event.type
                                    }\n    🪙 ${event.data.currency} ${
                                        event.data.amount
                                    }\n    🧑 ${event.userId}\n    📜 ${
                                        event.data.description ||
                                        'No description'
                                    }`
                                )
                                break

                            default:
                                break
                        }
                    }
                )
                break

            case 'e':
            case 'exp':
            case 'expense':
                potentialFrom = _findUserIdInFormattedMessage(args[0], formattedMessage)
                console.log(potentialFrom);

                if (potentialFrom && users.includes(potentialFrom)) {
                    // Use delegated sender
                    from = potentialFrom
                    amount = parseFloat(args[1])
                    description = args
                        .slice(2)
                        .filter((a) => {
                            return a[0] !== '?'
                        })
                        .join(' ')
                } else {
                    // Use event sender
                    from = event.getSender()
                    amount = parseFloat(args[0])
                    description = args
                        .slice(1)
                        .filter((a) => {
                            return a[0] !== '?'
                        })
                        .join(' ')
                }

                // Check amount
                if (!amount) {
                    _sendMessage(
                        room.roomId,
                        '❌ That expense is invalid, need !help ?'
                    )
                    return
                }

                db.write({
                    type: 'expense',
                    timestamp: event.getDate(),
                    roomId: room.roomId,
                    userId: event.getSender(),
                    data: {
                        from: from,
                        amount: amount,
                        currency: 'EUR',
                        description: description,
                    },
                })
                    .then(() => {
                        _sendMessage(room.roomId, '👍 Expense noted')
                    })
                    .catch((e) => {
                        _sendMessage(
                            room.roomId,
                            `❌ Whoops, something went wrong (${e})`
                        )
                    })
                break

            case 't':
            case 'transfer':
                potentialFrom = _findUserIdInFormattedMessage(args[0], formattedMessage)

                if (potentialFrom && users.includes(potentialFrom)) {
                    // Use delegated sender
                    from = potentialFrom
                    amount = parseFloat(args[1])
                    to = _findUserIdInFormattedMessage(args[2], formattedMessage)
                    description = args
                        .slice(3)
                        .filter((a) => {
                            return a[0] !== '?'
                        })
                        .join(' ')
                } else {
                    // Use event sender
                    from = event.getSender()
                    amount = parseFloat(args[0])
                    to = _findUserIdInFormattedMessage(args[1], formattedMessage)
                    description = args
                        .slice(2)
                        .filter((a) => {
                            return a[0] !== '?'
                        })
                        .join(' ')
                }

                // Check amount
                if (!amount) {
                    _sendMessage(
                        room.roomId,
                        '❌ That expense is invalid, need !help ?'
                    )
                    return
                }

                // Check recipient
                if (!users.includes(to)) {
                    _sendMessage(
                        room.roomId,
                        `❌ I don't know any "${to}", please try !users`
                    )
                    return
                }

                db.write({
                    type: 'transfer',
                    timestamp: event.getDate(),
                    roomId: room.roomId,
                    userId: event.getSender(),
                    data: {
                        from: from,
                        to: to,
                        amount: amount,
                        currency: 'EUR',
                        description: description,
                    },
                })
                    .then(() => {
                        _sendMessage(room.roomId, '👍 Transfer noted')
                    })
                    .catch((e) => {
                        _sendMessage(
                            room.roomId,
                            `❌ Whoops, something went wrong (${e})`
                        )
                    })
                break

            case 'b':
            case 'balance':
                if (users.length === 0) {
                    _sendMessage(
                        room.roomId,
                        '🤷 No users to make a balance for'
                    )
                }
                let balance = await db.getBalance(room.roomId)

                // number of combinations = (n^2 + n)/2
                for (let index = 0; index < balance.userIds.length; index++) {
                    const userId1 = balance.userIds[index]

                    for (
                        let index2 = index + 1;
                        index2 < balance.userIds.length;
                        index2++
                    ) {
                        const userId2 = balance.userIds[index2]

                        const diff =
                            (balance[userId2].spentForUserId[userId1] || 0) -
                            (balance[userId1].spentForUserId[userId2] || 0) +
                            (balance[userId2].sentToUserId[userId1] || 0) -
                            (balance[userId1].sentToUserId[userId2] || 0)

                        _sendMessage(
                            room.roomId,
                            `${userId1} ${
                                diff == 0 ? '=' : diff > 0 ? '→' : '←'
                            } ${userId2}: ${Math.abs(diff).toFixed(2)}`
                        )
                    }
                }
                break

            case 'undo':
                db.undo(room.roomId)
                    .then(() => {
                        _sendMessage(room.roomId, '👍 Last action was undone')
                    })
                    .catch((e) => {
                        _sendMessage(
                            room.roomId,
                            `❌ Whoops, something went wrong (${e})`
                        )
                    })
                break

            case 'reset':
                db.reset(room.roomId)
                    .then(() => {
                        _sendMessage(
                            room.roomId,
                            '👍 All expenses and transactions have been erased'
                        )
                    })
                    .catch((e) => {
                        _sendMessage(
                            room.roomId,
                            `❌ Whoops, something went wrong (${e})`
                        )
                    })
                break

            case 'fullreset':
                db.fullreset(room.roomId)
                    .then(() => {
                        _sendMessage(room.roomId, '👍 All data has been erased')
                    })
                    .catch((e) => {
                        _sendMessage(
                            room.roomId,
                            `❌ Whoops, something went wrong (${e})`
                        )
                    })
                break

            default:
                _sendMessage(
                    room.roomId,
                    '🤷 Not sure what you are asking for. Need !help ?'
                )
                break
        }
        return
    }

    // Reply to cookie
    if (message.toLowerCase().includes('cookie')) {
        _sendMessage(room.roomId, 'Did someone say cookie?')
        return
    }
})

// Start the Matrix client
matrixClient.startClient()