FEDEO/test/bankImport/index.mjs

import axios from "axios"
import {createClient} from "@supabase/supabase-js";

let key = process.env.SUPABASE_SERVICE_ROLE_KEY
let url = process.env.SUPABASE_URL
let interval = process.env.INTERVAL
let goCardLessBaseUrl = process.env.GOCARDLESS_URL
let goCardLessSecretId = process.env.GOCARDLESS_SECRET_ID
let goCardLessSecretKey = process.env.GOCARDLESS_SECRET_KEY

const supabase = createClient(url,key)

let accessToken = ""
let refreshToken = ""


console.log(goCardLessBaseUrl)


let currentTenant = 1

let tenantData = (await supabase.from("tenants").select().eq("id", currentTenant)).data[0]
//console.log(tenantData)


let bankConfig = tenantData.bankConfig

//console.log(bankConfig)

//console.log(goCardLessBaseUrl + "token/new/")
let tokenData = (await axios({
    url: goCardLessBaseUrl + "token/new/",
    method: "POST",
    data: {
        "secret_id": goCardLessSecretId,
        "secret_key": goCardLessSecretKey
    }
})).data

accessToken = tokenData.access
refreshToken = tokenData.access

let accounts = []

const getAccounts = async () => {
    let existingAccounts = (await supabase.from("bankAccounts").select()).data

    let requisitionData = (await axios({
        url: goCardLessBaseUrl + "requisitions/" + bankConfig.requisitions[0],
        headers: {
            Authorization: `Bearer ${accessToken}`
        },
        method: "GET",
    })).data

    requisitionData.accounts.forEach(account => {
        if (!accounts.includes(account)) {
            accounts.push(account)
        }
    })

    let supabaseAccountInserts = []

    async function getAccountData () {
        await Promise.all(accounts.map(async (account) => {
            let accountData = (await axios({
                url: goCardLessBaseUrl + "accounts/" + account,
                headers: {
                    Authorization: `Bearer ${accessToken}`
                },
                method: "GET"
            })).data

            //console.log(accountData)

            if(existingAccounts.filter(account => account.iban === accountData.iban).length === 0){
                supabaseAccountInserts.push({
                    name: "",
                    iban: accountData.iban,
                    bankId: accountData.institution_id,
                    ownerName: accountData.owner_name,
                    tenant: currentTenant,
                    accountId: accountData.id
                })
            }


        }));
    }

    await getAccountData()

    //console.log("Start Insert")

    const {data:accountInsertData,error:accountInsertError} = await supabase.from("bankAccounts").insert(supabaseAccountInserts).select()
    if(accountInsertError) {
        console.log(accountInsertError)
    } else if(accountInsertData) {
        //console.log(accountInsertData)
    }
}


const getTransactions = async () => {
    let accountsToRequest = (await supabase.from("bankAccounts").select().eq("used", true)).data
    let existingTransactions = (await supabase.from("bankStatements").select().eq("tenant", currentTenant)).data

    console.log(accountsToRequest)

    let supabaseTransactionInserts = []

    async function getAccountTransactions () {
        await Promise.all(accountsToRequest.map(async (account) => {
            let transactions = (await axios({
                url: goCardLessBaseUrl + "accounts/" + account.accountId + "/transactions",
                headers: {
                    Authorization: `Bearer ${accessToken}`
                },
                method: "GET"
            })).data.transactions.booked

            //console.log(transactions)


            transactions.forEach(transaction => {
                if(!transaction.creditorAccount) console.log(transaction)

                let transactionData = {
                    date: transaction.bookingDate,
                    amount: transaction.transactionAmount.amount,
                    credName: transaction.creditorName ? transaction.creditorName : null,
                    credIban: transaction.creditorAccount ? transaction.creditorAccount.iban : null,
                    debName: transaction.debtorName,
                    debIban: transaction.debtorAccount.iban,
                    text: transaction.remittanceInformationUnstructured,
                    gocardlessId: transaction.internalTransactionId,
                    currency: transaction.transactionAmount.currency,
                    account: account.id,
                    tenant: currentTenant
                }

                if(existingTransactions.filter(item => item.gocardlessId === transaction.internalTransactionId).length === 0){
                    supabaseTransactionInserts.push(transactionData)
                }
            })

        }));
    }

    await getAccountTransactions()

    console.log(supabaseTransactionInserts)

    const {data:transactionInsertData, error:transactionInsertError} = await supabase.from("bankStatements").insert(supabaseTransactionInserts).select()

    if(transactionInsertError) {
        console.log(transactionInsertError)
    } else if(transactionInsertData) {
        console.log(transactionInsertData)
    }


}



getAccounts()
getTransactions()