actions

export default function transactionServiceActions(kube) {
    const transactionNamespace = kube.namespace("transaction")
    const mongoNamespace = kube.namespace("mongo")
    const ibanNamespace = kube.namespace("iban")
    const transactionModel =  mongoNamespace.baseModel('transaction')
    const accountModel = mongoNamespace.baseModel('account')


    transactionNamespace.def(function fetchTransaction(_id) {
        return transactionModel.findOne({_id})
            .catch(function handleTransactionLookupError(error) {
                throw kube.errors.transactionFetchError
            })
    })

    transactionNamespace.def(function createTransaction(
        from,
        to,
        amount,
        description,
        recurring
    ) {
        kube.logger.info({from, to, amount, description, recurring}, "starting transaction creation")

        //check if the sender or receiver is in our bank
        //this prevents people trying to make rogue transactions
        //that does not involve our bank
        //from and to are both ibans
        if(!ibanNamespace.isGazpromIban(from) && !ibanNamespace.isGazpromIban(to)) {
            kube.logger.error("Trying to create transaction between two non gazprom banks")
            throw kube.errors.noGazpromTransaction
        }

        //check if both ibans are valid
        if(!ibanNamespace.isValidAccountNumber(from)) {
            kube.logger.error("Trying to create transaction with invalid sender")
            throw kube.errors.invalidTransactionSenderIban
        }

        //check if the from iban is one of the users

        if(!ibanNamespace.isValidAccountNumber(to)) {
            kube.logger.error("Trying to create transaction with invalid receiver")
            throw kube.errors.invalidTransactionReceiverIban
        }

        //at this point, the transaction is valid
        return mongoNamespace.createModel('transaction', {
            from,
            to,
            amount,
            senderBank: from.substring(4,8),
            receiverBank: to.substring(4,8),
            description,
            recurring
        })
        .save()
        .then((transact) => transactionNamespace.executeTransaction(transact))
    })

    transactionNamespace.def(function executeTransaction(transaction) {
        kube.logger.info({transaction}, "executing transaction")

        return accountModel.findOneAndUpdate({accountNumber: transaction.from}, {$inc: {balance: transaction.amount * -1}})
            .then(() => accountModel.findOneAndUpdate({accountNumber: transaction.to}, {$inc: {balance: transaction.amount}}))
            .then(() => transaction)
    })

    transactionNamespace.def(function getOutgoingTransactions(accountNumber) {
        return transactionModel.find({from: accountNumber})
            .limit(20)
            .sort({createdAt: "desc"})
            .catch(function handleGetOutgoingTransactionsError(error) {
                kube.logger.error({ error }, "Error getting outgoing transactions")
                throw kube.errors.outgoingTransactionFetchFailure
            })
    })

    transactionNamespace.def(function getIncomingTransactions(accountNumber) {
        return transactionModel.find({to: accountNumber})
            .limit(20)
            .sort({createdAt: "desc"})
            .catch(function handleGetOutgoingTransactionsError(error) {
                kube.logger.error({ error }, "Error getting incoming transactions")
                throw kube.errors.incomingTransactionFetchFailure
            })
    })
}