prow-authority 3.6.3

package/src/v1/controllers/billing/billing-controller.ts

@@ -0,0 +1,805 @@
+import { Date2, Formats, Unit } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Requester } from "@beseif-solutions/utility-functions/dist/utils/http-utils";
+import { Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import _ from "lodash";
+import APIError, { StatusCodes } from "../../../helpers/api-error";
+import authority, { InvoiceEmitted, NotificationEventNames, TrialEnded, TrialEndingSoon } from "../../../helpers/authority";
+import nconf from "../../../helpers/config";
+import holded from "../../../helpers/holded";
+import stripe from "../../../helpers/stripe";
+import { getAccountingSeatsSchema, getInvoicesSchema, invoiceEmittedSchema, invoicePaidSchema, generateOrganizationInvoiceSchema as invoicesSchema, updateInvoiceSchema } from "../../schemas/billing/billing-schemas";
+import { AccountingSeat } from "../../types/admin/accounting-seat-types";
+import { BillingCycle } from "../../types/admin/billing-cycle-types";
+import { Invoice, InvoiceConcept, InvoiceStatus } from "../../types/admin/invoice-types";
+import { LicenseType } from "../../types/admin/license-types";
+import { OrganizationLicense } from "../../types/admin/organization-license-types";
+import { Organization, OrganizationStatus } from "../../types/admin/organization-types";
+import { Billing_GetAccountingSeats_Params, Billing_GetInvoices_Params, Billing_InvoiceEmitted_Params, Billing_InvoicePaid_Params, Billing_PendingLicenses_Params as Billing_Invoices_Params, Billing_UpdateInvoice_Params, PublicAccountingSeat, PublicInvoice } from "../../types/billing/billing-types";
+import { UE_Country, UE_VAT, UE_VAT_Item } from "../../types/billing/ue-types";
+import accountingSeatController from "../admin/accounting-seat-controller";
+import billingCycleController from "../admin/billing-cycle-controller";
+import invoiceController from "../admin/invoice-controller";
+import organizationController from "../admin/organization-controller";
+import organizationLicenseController from "../admin/organization-license-controller";
+import paymentMethodController from "../admin/payment-method-controller";
+import serviceController from "../admin/service-controller";
+import publicOrganizationController from "../organizations/public-organization-controller";
+
+class BillingController {
+
+  public readonly generateCycle = async (organization: Organization, params: Billing_Invoices_Params = {}): Promise<any> => {
+    try {
+      Validator.validate(invoicesSchema, params);
+      const { cycle } = await this.cycleContext(organization, params.current_date);
+
+      return cycle;
+    } catch (e) { throw e; }
+  };
+
+  public readonly generateLicensesInvoice = async (organization: Organization, params: Billing_Invoices_Params = {}): Promise<{ generated: boolean, uuid?: string }> => {
+    try {
+      Validator.validate(invoicesSchema, params);
+
+      const { cycle, now, licenses } = await this.licenseContext(organization, params.current_date);
+
+      // get generated invoices - order by date
+      const invoices = await invoiceController.list({
+        organization: organization.id,
+        date: { gte: new Date(cycle.start_date) as any, lte: new Date(now) as any },
+      }, { order: { by: `date`, direction: `ascendent` } });
+
+      const lastBilledInvoice = _.last(invoices.filter((i) => i.status !== InvoiceStatus.Pending));
+      let pendingInvoice = invoices.find((i) => i.status === InvoiceStatus.Pending);
+
+      // billed licenses = licenses starting after last billed invoice
+      const billed = lastBilledInvoice ?
+        _.remove(licenses, (l) => new Date2(l.start_date).isBefore(new Date2(lastBilledInvoice.date)))
+        : [];
+
+      const concepts = await this.licensesToConcepts(cycle, licenses, billed);
+
+      if (concepts.length === 0 || cycle.internal.initial) { return { generated: false }; }
+
+      // calculate VAT and VIES
+      const { code, percentage } = await this.getOrganizationTaxConfiguration(organization);
+
+      if (!pendingInvoice) {
+        pendingInvoice = (await invoiceController.add({
+          organization: organization.id,
+          date: now.format(Formats.ISO),
+          tax_code: code,
+          tax_percentage: percentage,
+          concepts: concepts,
+          billing: organization.billing,
+          invoice: null,
+          payment: null,
+          method: null,
+          status: InvoiceStatus.Pending,
+          metadata: {},
+          internal: {},
+        }))[0];
+      } else {
+        const equal =
+          pendingInvoice.tax_code === code &&
+          pendingInvoice.tax_percentage === percentage &&
+          !_.some(concepts, (c) => !pendingInvoice.concepts.find((oc) => `${oc.name}#${oc.description}#${oc.price}` === `${c.name}#${c.description}#${c.price}`));
+
+        if (!equal) {
+          pendingInvoice = (await invoiceController.update(pendingInvoice.id, {
+            date: now.format(Formats.ISO),
+            tax_code: code,
+            tax_percentage: percentage,
+            concepts: concepts,
+            billing: organization.billing,
+          }))[0];
+        }
+      }
+
+      return { generated: true, uuid: pendingInvoice.uuid };
+    } catch (e) { throw e; }
+  };
+
+  public readonly getInvoices = async (data: Billing_GetInvoices_Params): Promise<PublicInvoice[]> => {
+    try {
+      Validator.validate(getInvoicesSchema, data);
+
+      const now = (data.current_date ? new Date2(data.current_date) : Date2.current()).format(Formats.ISO);
+
+      const invoices = await invoiceController.list({
+        date: { lte: new Date(now) as any },
+        status: data.status,
+      });
+
+      const response = await this.parseInvoices(invoices);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly updateInvoice = async (uuid: string, data: Billing_UpdateInvoice_Params): Promise<void> => {
+    try {
+      Validator.validate(updateInvoiceSchema, data);
+
+      const invoice = (await invoiceController.list({ uuid: uuid }))[0];
+      if (!invoice) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Invoice ${uuid} not found`,
+        });
+      }
+
+      await invoiceController.update(invoice.id, data);
+    } catch (e) { throw e; }
+  };
+
+  public readonly invoiceEmitted = async (uuid: string, data: Billing_InvoiceEmitted_Params): Promise<void> => {
+    try {
+      const invoice = (await invoiceController.list({
+        uuid: uuid,
+        status: InvoiceStatus.Pending,
+      }))[0];
+      if (!invoice) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Pending invoice ${uuid} not found`,
+        });
+      }
+
+      const organization = (await organizationController.get(invoice.organization))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Organization ${invoice.organization} not found`,
+        });
+      }
+
+      const { cycle } = await this.cycleContext(organization, invoice.date);
+
+      if (cycle.trial && invoice.amount > 0) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Cannot emit invoice with amount greater than 0 during trial period`,
+        });
+      }
+
+      // validate depending on invoice amount
+      Validator.validate(invoiceEmittedSchema(invoice.amount === 0), data);
+
+      // if an external invoice id is provided, fetch its document data from Holded
+      let number: string;
+      if (data.invoice) {
+        try {
+          const holdedInvoice = await holded.getInvoice(data.invoice);
+          number = holdedInvoice.docNumber;
+        } catch (e) {
+          console.log(e?.response?.data || e);
+          throw new Error(`Holded invoice ${data.invoice} not found`);
+        }
+      }
+
+      await invoiceController.update(invoice.id, {
+        invoice: data.invoice || null,
+        // store external document number (if available)
+        number: number,
+        // if trial period no payment required
+        status: InvoiceStatus.Emitted,
+      });
+
+      if (data.invoice) {
+        setImmediate(async () => {
+          try {
+            const { data: pdf } = await holded.getInvoicePDF(data.invoice);
+
+            await authority.notify<InvoiceEmitted>(organization.uuid, {
+              event: NotificationEventNames.InvoiceEmitted,
+              data: {
+                organization: organization,
+                invoice: { number: number, amount: invoice.amount },
+                cta: {
+                  preferences: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:USER_PREF_LIST`),
+                },
+              },
+              attachments: [
+                {
+                  name: `${number}.pdf`,
+                  type: `application/pdf`,
+                  content: pdf,
+                },
+              ],
+            });
+          } catch (e) {
+            console.log(`Error sending notification:`, e);
+          }
+        });
+      }
+
+      if (invoice.amount > 0) {
+        // generate seats for accounting
+        await this.generateAccountingSeats(organization, cycle, invoice);
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly invoicePaid = async (uuid: string, data: Billing_InvoicePaid_Params): Promise<void> => {
+    try {
+      const invoice = (await invoiceController.list({
+        uuid: uuid,
+        status: InvoiceStatus.Emitted,
+      }))[0];
+      if (!invoice) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Emitted invoice ${uuid} not found`,
+        });
+      }
+
+      // validate depending on invoice amount
+      Validator.validate(invoicePaidSchema(invoice.amount === 0), data);
+
+      const organization = (await organizationController.get(invoice.organization))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Organization ${invoice.organization} not found`,
+        });
+      }
+
+      let methodID: number;
+      if (data.method) {
+        const method = (await paymentMethodController.list({
+          organization: organization.id,
+          internal: { payment_method_id: data.method },
+        }))[0];
+        if (!method) {
+          throw new APIError({
+            code: StatusCodes.NOT_FOUND,
+            detail: `Payment method ${data.method} not found`,
+          });
+        }
+
+        methodID = method.id;
+
+        // check in stripe
+        try {
+          const intent = await stripe.paymentIntents.retrieve(data.payment);
+          if (intent.status !== `succeeded`) { throw new Error(`Payment intent is ${intent.status}`); }
+        } catch (e) {
+          console.log(e);
+          throw new Error(`Stripe payment ${data.payment} not found or not successful`);
+        }
+      }
+
+      await invoiceController.update(invoice.id, {
+        payment: data.payment || null,
+        method: methodID || null,
+        status: InvoiceStatus.Paid,
+      });
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+  };
+
+  public readonly getAccountingSeats = async (data: Billing_GetAccountingSeats_Params): Promise<PublicAccountingSeat[]> => {
+    try {
+      Validator.validate(getAccountingSeatsSchema, data);
+
+      const now = (data.current_date ? new Date2(data.current_date) : Date2.current()).format(Formats.ISO);
+
+      const invoices = await accountingSeatController.list({
+        date: { lte: new Date(now) as any },
+        done: data.done,
+      });
+
+      const response = await this.parseAccountingSeats(invoices);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly accountingSeatDone = async (uuid: string): Promise<void> => {
+    try {
+      const seat = (await accountingSeatController.list({ uuid: uuid }))[0];
+      if (!seat) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Accounting seat ${uuid} not found`,
+        });
+      }
+
+      await accountingSeatController.update(seat.id, { done: true });
+    } catch (e) { throw e; }
+  };
+
+  private readonly generateAccountingSeats = async (organization: Organization, cycle: BillingCycle, invoice: Invoice): Promise<void> => {
+    try {
+      const dates: string[] = [];
+
+      let start = new Date2(invoice.date);
+      const end = new Date2(cycle.end_date);
+      do {
+        dates.push(start.format(Formats.ISO));
+        start = start.add(1, Unit.Months);
+      } while (start.isBefore(end));
+
+      const perSeat = invoice.base / dates.length;
+
+      for (const date of dates) {
+        // create a seat
+        await accountingSeatController.add({
+          organization: organization.id,
+          invoice: invoice.id,
+          date: date,
+          amount: perSeat,
+          done: false,
+          metadata: {},
+          internal: {},
+        });
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly organizationAccountingData = async (uuid: string): Promise<{ contact: string }> => {
+    try {
+      const organization = (await organizationController.list({
+        uuid: uuid,
+        status: OrganizationStatus.Active,
+      }))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Organization ${uuid} not found`,
+        });
+      }
+
+      // if (!organization.internal.contact) {
+      const { id } = await publicOrganizationController.configureHoldedContact(organization);
+      organization.internal.contact = id;
+      // }
+
+      return {
+        contact: organization.internal.contact,
+      };
+    } catch (e) { throw e; }
+  };
+
+  public readonly organizationPaymentData = async (uuid: string): Promise<{ customer: string, method: string }> => {
+    try {
+      const organization = (await organizationController.list({
+        uuid: uuid,
+        status: OrganizationStatus.Active,
+      }))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Organization ${uuid} not found`,
+        });
+      }
+
+      if (!organization.internal.customer) {
+        const { id } = await publicOrganizationController.configureStripeCustomer(organization);
+        organization.internal.customer = id;
+      }
+
+      const method = (await paymentMethodController.list({
+        organization: organization.id,
+        enabled: true,
+      }))[0];
+      if (!method) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `No enabled payment method configured for organization ${organization.id} - does it have any payment method?`,
+        });
+      }
+
+      return {
+        customer: organization.internal.customer,
+        method: method.internal.payment_method_id,
+      };
+    } catch (e) { throw e; }
+  };
+
+  public readonly blockOrganization = async (uuid: string): Promise<void> => {
+    try {
+      const organization = (await organizationController.list({
+        uuid: uuid,
+        status: OrganizationStatus.Active,
+      }))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Organization ${uuid} not found`,
+        });
+      }
+
+      await organizationController.update(organization.id, { status: OrganizationStatus.Blocked });
+    } catch (e) { throw e; }
+  };
+
+  public readonly unblockOrganization = async (uuid: string): Promise<void> => {
+    try {
+      const organization = (await organizationController.list({
+        uuid: uuid,
+        status: OrganizationStatus.Blocked,
+      }))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Organization ${uuid} not found`,
+        });
+      }
+
+      await organizationController.update(organization.id, { status: OrganizationStatus.Active });
+    } catch (e) { throw e; }
+  };
+
+  public readonly cycleContext = async (organization: Organization, currentDate?: string): Promise<{ cycle: BillingCycle, now: Date2 }> => {
+    try {
+      const now = currentDate ? new Date2(currentDate) : Date2.current();
+
+      const cycles = await billingCycleController.list({
+        organization: organization.id,
+        start_date: { lte: now as any },
+        end_date: { gt: now as any },
+      });
+      if (cycles.length > 2) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Multiple billing cycles found for organization ${organization.id} on ${now}`,
+        });
+      }
+
+      let cycle = cycles[0];
+      if (!cycle) {
+        const base = await this.getBaseLicense(organization);
+        if (base.billing === `lifetime`) { throw new Error(`No base cycle found`); }
+
+        const previous = (await billingCycleController.list({
+          end_date: { lte: now as any },
+          organization: organization.id,
+        }, {
+          order: { by: `end_date`, direction: `descendent` },
+          limit: { count: `1` },
+        }))[0];
+        if (!previous) { throw new Error(`No previous cycle found`); }
+
+        let end = new Date2(previous.end_date);
+        do {
+          end = end.add(1, base.billing === `monthly` ? Unit.Months : Unit.Years);
+
+          cycle = (await billingCycleController.add({
+            organization: organization.id,
+            trial: false,
+            start_date: cycle ? cycle.end_date : previous.end_date,
+            end_date: end.toMoment().startOf(`day`).format(Formats.ISO),
+            metadata: {},
+            internal: {},
+          }))[0];
+        } while (end.isBefore(now));
+
+        if (previous.trial && !previous.internal?.trial_ended_sent) {
+          try {
+            await authority.notify<TrialEnded>(organization.uuid, {
+              event: NotificationEventNames.TrialEnded,
+              data: {
+                organization: organization,
+                cta: {
+                  subscription: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_USAGE`),
+                  billing: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_BILLING`),
+                  preferences: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:USER_PREF_LIST`),
+                },
+              },
+            });
+            await billingCycleController.update(previous.id, { internal: { trial_ended_sent: true } });
+          } catch (e) {
+            console.log(`Error sending trial ended notification:`, e);
+          }
+        }
+      }
+
+      return {
+        now: now,
+        cycle: cycle,
+      };
+    } catch (e) { throw e; }
+  };
+
+  public readonly trialWarningCheck = async (organization: Organization, currentDate?: string): Promise<void> => {
+    try {
+      const now = currentDate ? new Date2(currentDate) : Date2.current();
+      const warningDays = Number(nconf.get(`SERVICES:AUTHORITY:BILLING:TRIAL_WARNING_DAYS`));
+
+      // find the active trial cycle (if any)
+      const cycle = (await billingCycleController.list({
+        organization: organization.id,
+        trial: true,
+        start_date: { lte: now.format(Formats.ISO) },
+        end_date: { gt: now.format(Formats.ISO) },
+      }))[0];
+      if (!cycle) { return; }
+
+      // only notify once per trial cycle
+      if (cycle.internal?.trial_warning_sent) { return; }
+
+      // days remaining until the trial ends (calendar days)
+      const daysRemaining = new Date2(cycle.end_date).toMoment().startOf(`day`).diff(now.toMoment().startOf(`day`), `days`);
+
+      // notify only and exclusively when exactly the configured days remain
+      if (daysRemaining !== warningDays) { return; }
+
+      try {
+        await authority.notify<TrialEndingSoon>(organization.uuid, {
+          event: NotificationEventNames.TrialEndingSoon,
+          data: {
+            organization: organization,
+            end_date: new Date2(cycle.end_date).format(Formats.ReadableFormat),
+            cta: {
+              subscription: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_USAGE`),
+              billing: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_BILLING`),
+              preferences: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:USER_PREF_LIST`),
+            },
+          },
+        });
+        await billingCycleController.update(cycle.id, { internal: { trial_warning_sent: true } });
+      } catch (e) {
+        console.log(`Error sending trial warning notification:`, e);
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly licenseContext = async (organization: Organization, currentDate?: string) => {
+    try {
+      const { now, cycle } = await this.cycleContext(organization, currentDate);
+
+      const licensesInCycle = await organizationLicenseController.list({
+        organization: organization.id,
+        start_date: { lte: now as any },
+        end_date: [
+          { is: null },
+          { gt: new Date(cycle.start_date) as any, lte: new Date(cycle.end_date) as any },
+        ],
+      });
+
+      return {
+        now: now,
+        cycle: cycle,
+        licenses: licensesInCycle,
+      };
+    } catch (e) { throw e; }
+  };
+
+  private readonly licensesToConcepts = async (cycle: BillingCycle, records: OrganizationLicense[], billed: OrganizationLicense[] = []): Promise<InvoiceConcept[]> => {
+    try {
+      const all = _.orderBy([...billed, ...records], (r) => new Date(r.start_date), `asc`);
+
+      const missingAssociatedIDs = _.compact(records.map((r) => r.associated).filter((id) => !all.some((l) => l.id === id)));
+
+      if (missingAssociatedIDs.length > 0) {
+        const associated = await organizationLicenseController.list({ id: { in: missingAssociatedIDs } });
+        all.push(...associated);
+      }
+
+      const services = await serviceController.list({ id: { in: all.map((r) => r.service) } });
+
+      const response: InvoiceConcept[] = [];
+      for (const record of _.orderBy(records, (r) => new Date(r.start_date), `asc`)) {
+        const service = services.find((s) => s.id === record.service);
+
+        const priceKey = record.billing === `annual` ? `annual_price` : `monthly_price`;
+        const parsed: InvoiceConcept = {
+          name: `${service.properties.name} - ${record.billing === `annual` ? `Annual` : `Monthly`} ${record.type === LicenseType.Base ? `plan` : `power-up`}`,
+          description: record.type === LicenseType.Base ?
+            `${record.properties.name} license`
+            : record.properties.name,
+          price: record[priceKey] || 0,
+        };
+
+        const associated = record.associated ? all.find((l) => l.id === record.associated) : null;
+        const isBaseLicense = service.uuid === authority.configuration.uuid && record.type === LicenseType.Base;
+
+        if (associated) {
+          // associated licenses
+          const associatedService = services.find((s) => s.id === associated.service);
+          const associatedName = `${associatedService.properties.name} ${associated.properties.name} license`;
+
+          parsed.description = `${parsed.description} - Included in ${associatedName}`;
+        } else if (isBaseLicense) {
+          // base license
+          parsed.description = `${parsed.description} - Included`;
+        }
+
+        // charge difference in upgraded licenses
+        const upgradeFrom = record.type === LicenseType.Base ?
+          _.last(all.filter((r) =>
+            r.type === LicenseType.Base
+            && r.id !== record.id
+            && r.service === record.service
+            && r.end_date
+            && (!record.end_date || new Date2(r.end_date).isBefore(new Date2(record.end_date)))
+          )) : null;
+
+        if (upgradeFrom) {
+          parsed.description = `${parsed.description} - Upgrade`;
+          parsed.price = parsed.price - (upgradeFrom[priceKey] || 0);
+        }
+
+        // charge 0€ for trial period
+        if (cycle.trial) {
+          parsed.description = `${parsed.description} (Free trial)`;
+          parsed.price = 0;
+        }
+
+        response.push(parsed);
+      }
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly getBaseLicense = async (organization: Organization): Promise<OrganizationLicense> => {
+    try {
+      // get base license
+      const service = (await serviceController.list({ uuid: authority.configuration.uuid }))[0];
+      if (!service) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not find service.`,
+        });
+      }
+
+      const base = (await organizationLicenseController.list({
+        organization: organization.id,
+        service: service.id,
+        type: LicenseType.Base,
+        enabled: true,
+      }))[0];
+      if (!base) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not find base license.`,
+        });
+      }
+
+      return base;
+    } catch (e) { throw e; }
+  };
+
+  private readonly parseInvoices = async (records: Invoice[]): Promise<PublicInvoice[]> => {
+    try {
+      const response: PublicInvoice[] = [];
+
+      const [organizations, methods] = await Promise.all([
+        organizationController.list({ id: { in: _.compact(records.map(r => r.organization)) } }),
+        paymentMethodController.list({ id: { in: _.compact(records.map(r => r.method)) } }),
+      ]);
+      const [parsedOrganizations, parsedMethods] = await Promise.all([
+        publicOrganizationController.parse(null, organizations),
+        publicOrganizationController.parsePaymentMethods(null, methods),
+      ]);
+
+      const mapOrganizations = Object.assign({}, ...organizations.map((o) => ({ [o.id]: parsedOrganizations.find((p) => p.uuid === o.uuid) })));
+      const mapMethods = Object.assign({}, ...methods.map((m) => ({ [m.id]: parsedMethods.find((p) => p.uuid === m.uuid) })));
+
+      for (const record of records) {
+        const organization = record.organization ? mapOrganizations[record.organization] : null;
+        if (!organization) { continue; }
+
+        const method = record.method ? mapMethods[record.method] : null;
+
+        const parsed: PublicInvoice = {
+          uuid: record.uuid,
+          organization: organization,
+          date: record.date,
+          base: record.base,
+          tax_code: record.tax_code,
+          tax_percentage: record.tax_percentage,
+          tax: record.tax,
+          amount: record.amount,
+          concepts: _.orderBy(record.concepts, (c) => c.price, `desc`),
+          billing: record.billing,
+          invoice: record.invoice,
+          number: record.number || null,
+          payment: record.payment,
+          method: method || null,
+          status: record.status,
+          metadata: record.metadata,
+        };
+        response.push(parsed);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  private readonly parseAccountingSeats = async (records: AccountingSeat[]): Promise<PublicAccountingSeat[]> => {
+    try {
+      const response: PublicAccountingSeat[] = [];
+
+      const invoices = await invoiceController.list({ id: { in: _.compact(records.map(r => r.invoice)) } });
+      const parsedInvoices = await this.parseInvoices(invoices);
+      const mapMethods = Object.assign({}, ...invoices.map((m) => ({ [m.id]: parsedInvoices.find((p) => p.uuid === m.uuid) })));
+
+      for (const record of records) {
+        const invoice = mapMethods[record.invoice];
+
+        const parsed: PublicAccountingSeat = {
+          uuid: record.uuid,
+          date: record.date,
+          amount: record.amount,
+          invoice: invoice,
+          done: record.done,
+          metadata: record.metadata,
+        };
+        response.push(parsed);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  private readonly UE_ES = `ES`;
+  private readonly getOrganizationTaxConfiguration = async (organization: Organization): Promise<{ code: string, percentage: number }> => {
+    try {
+      const { address: { country, province }, document } = organization.billing;
+
+      const { countries } = await Requester.get(`https://ec.europa.eu/taxation_customs/tedb/rest-api/configurations`) as { countries: UE_Country[] };
+
+      const ueCountry = countries.find((c) => c.defaultCountryCode === country.toUpperCase());
+
+      if (ueCountry) {
+        if (ueCountry.defaultCountryCode !== this.UE_ES) {
+          const { isValid: inVIES } = await Requester.get(`https://ec.europa.eu/taxation_customs/vies/rest-api/ms/${ueCountry.defaultCountryCode}/vat/${encodeURIComponent(document)}`);
+          if (inVIES) {
+            // art. 44 directiva 2006/112/ce
+            return { code: `s_iva_intras`, percentage: 0 };
+          }
+        } else if ([`LAS PALMAS`, `SANTA CRUZ DE TENERIFE`, `CEUTA`, `MELILLA`].includes(province.toUpperCase())) {
+          // art. 69 ley 37/1992
+          return { code: `s_iva_nosujeto`, percentage: 0 };
+        }
+
+        // get country VAT percentage
+        const { result: vatOptions } = await Requester.post(`https://ec.europa.eu/taxation_customs/tedb/rest-api/simpleSearch`, {
+          searchForm: {
+            selectedTaxTypes: [`VAT`],
+            selectedMemberStates: [ueCountry.id],
+            historized: false,
+          },
+        }) as { result: UE_VAT_Item[] };
+
+        const genericVAT = (vatOptions || []).find((v) => v.genericName === `VAT`);
+        if (!genericVAT) { throw new Error(`Could not get generic country VAT percentage (${ueCountry.defaultCountryCode})`); }
+
+        const rates = await Requester.get(`https://ec.europa.eu/taxation_customs/tedb/rest-api/tax/rate?taxId=${genericVAT.taxId}&versionDate=${genericVAT.versionDate}&isEuro=true`) as UE_VAT;
+        const percentage = parseFloat(rates.vatRateStructure.standardRate.rate.value);
+        if (typeof percentage === `undefined`) { throw new Error(`Could not get country VAT percentage (${ueCountry.defaultCountryCode})`); }
+
+        return {
+          code: ueCountry.defaultCountryCode === this.UE_ES ?
+            `s_iva_${percentage}` :
+            `s_iva_${ueCountry.defaultCountryCode.toLowerCase()}_${percentage}`,
+          percentage: percentage,
+        };
+      } else {
+        // art. 69 liva
+        return { code: `s_iva_export`, percentage: 0 };
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly isBillable = async (organization: Organization): Promise<boolean> => {
+    try {
+      // check if billing information is defined
+      if (!organization.billing?.document) { return false; }
+
+      // check if a payment method is enabled
+      const defaultMethod = (await paymentMethodController.list({
+        organization: organization.id,
+        enabled: true,
+      }))[0];
+      if (!defaultMethod) { return false; }
+
+      return true;
+    } catch (e) { throw e; }
+  };
+}
+
+const billingController = new BillingController();
+export default billingController;