FEDEO/tools/comServer/index.mjs

import ical, {ICalCalendarMethod} from 'ical-generator';
import express from "express"
import {createClient} from "@supabase/supabase-js";
import vCardsJS from "vcards-js"
import cors from 'cors'
import axios from "axios"
import basicAuth from "express-basic-auth"

const supabase = createClient(process.env.SUPABASE_URL,process.env.SUPABASE_SERVICE_ROLE_KEY)
const app = express();
app.use(cors())
app.use(basicAuth({
    users: {
        frontend: "Xt9Zn9RDSpdbr"
    }
}))

/*
* TODO: Implement Auth for the Endpoints
*
*
* */

let goCardlessAccessToken = null
let goCardlessRefreshToken = null
const getGoCardlessToken = async () => {
    const {data,error} = await axios({
        url: "https://bankaccountdata.gocardless.com/api/v2/token/new/",
        method: "POST",
        data: {
            secret_id: process.env.GOCARDLESS_SECRET_ID,
            secret_key: process.env.GOCARDLESS_SECRET_KEY
        }
    })

    if(error) throw error

    console.log(data)
    goCardlessRefreshToken = data.refresh
    goCardlessAccessToken = data.access
}


/*app.get("/contacts/:tenantId", async (req,res) => {
    const tenantId = req.params.tenantId
    let contacts = (await supabase.from("contacts").select().eq("tenant", tenantId)).data
    let customers = (await supabase.from("customers").select().eq("tenant", tenantId)).data
    let vendors = (await supabase.from("vendors").select().eq("tenant", tenantId)).data
    console.log(contacts)

    let cardsString = ""

    contacts.forEach(contact => {
        let vCard = vCardsJS();
        vCard.firstName = contact.firstName
        vCard.lastName = contact.lastName
        vCard.role = contact.role
        vCard.cellPhone = contact.phoneMobile
        vCard.workPhone = contact.phoneHome
        vCard.email = contact.email
        vCard.namePrefix = contact.salutation
        if(contact.customer)  vCard.organization = customers.find(i => i.id === contact.customer).name
        cardsString += vCard.getFormattedString()

    })



    //set content-type and disposition including desired filename
    res.set('Content-Type', 'text/vcard; name="enesser.vcf"');
    res.set('Content-Disposition', 'inline; filename="enesser.vcf"');

    //send the response
    res.send(cardsString);
})*/

app.get('/calendar/:userId', async (req, res) => {

    const userId = req.params.userId

    let userExisting = ((await supabase.from("profiles").select('id').eq("id", userId)).data)
    console.log(userExisting)

    if(userExisting) {
        let events = (await supabase.from("events").select()).data

        console.log(events[0].resources)

        events = events.filter(i => i.resources.filter(resource => resource.id === userId).length > 0)

        const cal = ical({
            prodId: '//spaces.software//ical-generator/r/EN',
            events: events.map(event => {
                return {
                    start: event.start,
                    end: event.end,
                    summary: event.title,
                    description: ""
                }
            })
        });

        res.writeHead(200, {
            'Content-Type': 'text/calendar; charset=utf-8',
            'Content-Disposition': 'attachment; filename="calendar.ics"'
        });

        res.end(cal.toString());
    } else {
        res.sendStatus(404)
    }
});

/*app.get("/banking/token", async (req,res) => {
    if(goCardlessAccessToken) {
        res.json({
            token: goCardlessAccessToken
        })
    } else {
        await getGoCardlessToken()
        res.json({
            token: goCardlessAccessToken
        })
    }
})*/
app.get('/banking/institutions/:bic?', async (req,res) => {



    const {data,error} = await axios({
        url:"https://bankaccountdata.gocardless.com/api/v2/institutions/?country=de",
        method: "GET",
        headers: {
            Authorization: `Bearer ${goCardlessAccessToken}`
        }
    })


    console.log(error)
    console.log(data)

    if(req.params.bic) {
        let bank = data.find(i => i.bic.toLowerCase() === req.params.bic.toLowerCase())

        if(bank) {
            res.json(bank)
        } else {
            res.sendStatus(404)
        }
    } else {
        res.json(data)
    }
})

app.post('/banking/link', async (req,res) => {

    const institutionId = req.query.institution_id
    const tenant = req.query.tenant

    console.log(institutionId)
    console.log(req.query)






    const {data,error} = await axios({
        url:"https://ob.gocardless.com/api/v2/requisitions/",
        method: "POST",
        headers: {
            Authorization: `Bearer ${goCardlessAccessToken}`,
            accept: "application/json"
        },
        data: {
            redirect: "http://localhost:3000/banking",
            institution_id: institutionId,
            user_language: "de"
        }
    })

    if(error) throw error
    console.log(data)
    console.log(error)

    const {data: createAccountData, error: createAccountError} = await supabase
        .from("bankrequisitions")
        .insert({
            tenant: tenant,
            institutionId: institutionId,
            id: data.id,
            status: data.status
        })
        .select()
        .single()

    //if(createAccountError) throw createAccountError
    console.log(createAccountData)
    console.log(createAccountError)

    res.json({
        link: data.link
    })


})

app.get("/banking/link/refresh", async (req,res) => {
    const {data,error} = await supabase.from("bankrequisitions").select()

    console.log(data)
    console.log(error)

    const {data: listReqData, error: listReqError} = await axios({
        url:"https://ob.gocardless.com/api/v2/requisitions/",
        method: "GET",
        headers: {
            Authorization: `Bearer ${goCardlessAccessToken}`,
            accept: "application/json"
        },
    })

    console.log(listReqData)
    console.log(listReqError)



    data.map(item => {
        let gcItem = listReqData.results.find(i => i.id === item.id)
        item.status = gcItem.status

        return item
    })

    for(const item of data) {
        const {data: updateReqData, error: updateReqError} = await supabase.from("bankrequisitions").update(item).eq("id",item.id)

        console.log(updateReqData)
        console.log(updateReqError)
    }

    res.sendStatus(200)
})

app.get("/banking/requisitions/:id?", async (req,res) => {
    const {data: listReqData, error: listReqError} = await axios({
        url:`https://ob.gocardless.com/api/v2/requisitions/${req.params.id ? req.params.id: ""}`,
        method: "GET",
        headers: {
            Authorization: `Bearer ${goCardlessAccessToken}`,
            accept: "application/json"
        },
    })

    console.log(listReqData)
    console.log(listReqError)




    if(listReqData){

        if(listReqData.accounts) {
            let accounts = await Promise.all(listReqData.accounts.map(async (item) => {
                const {data,error} = await axios({
                    url:"https://ob.gocardless.com/api/v2/accounts/" + item,
                    method: "GET",
                    headers: {
                        Authorization: `Bearer ${goCardlessAccessToken}`,
                        accept: "application/json"
                    },
                })

                console.log(data)

                return data


            }))
            listReqData.accounts = accounts
        }

        res.json(listReqData)
    } else {
        res.sendStatus(404)
    }

})

app.get("/banking/accounts/:id/:mode", async (req,res) => {
    const {data: listAccData, error: listAccError} = await axios({
        url:`https://ob.gocardless.com/api/v2/accounts/${req.params.id}/${req.params.mode}`,
        method: "GET",
        headers: {
            Authorization: `Bearer ${goCardlessAccessToken}`,
            accept: "application/json"
        },
    })

    console.log(listAccData)
    console.log(listAccError)

    if(listAccData){
        res.json(listAccData)
    } else {
        res.sendStatus(404)
    }

})

if(!goCardlessAccessToken) {
    getGoCardlessToken()
}

app.listen(3002);