@accounter/server 0.0.9-alpha-20251216144137-dc7316f892e1fcf0e350cfbbaa9ca0746e1c6c50 → 0.0.9-alpha-20251216161545-668306e40cf3aed663f444e0004246489fbec6d4

package/src/modules/green-invoice/resolvers/green-invoice.resolvers.ts

@@ -1,26 +1,471 @@
+import { addMonths, endOfMonth, format, startOfMonth, subMonths } from 'date-fns';
 import { GraphQLError } from 'graphql';
 import type { _DOLLAR_defs_Document } from '@accounter/green-invoice-graphql';
+import type { BillingCycle, ResolversTypes } from '../../../__generated__/types.js';
+import { Currency, DocumentType } from '../../../shared/enums.js';
+import { dateToTimelessDateString } from '../../../shared/helpers/index.js';
 import { GreenInvoiceClientProvider } from '../../app-providers/green-invoice-client.js';
+import {
+  getChargeBusinesses,
+  getChargeDocumentsMeta,
+} from '../../charges/helpers/common.helper.js';
+import { ChargesProvider } from '../../charges/providers/charges.provider.js';
+import { ContractsProvider } from '../../contracts/providers/contracts.provider.js';
+import { IGetContractsByIdsResult } from '../../contracts/types.js';
+import { DocumentsProvider } from '../../documents/providers/documents.provider.js';
 import { IssuedDocumentsProvider } from '../../documents/providers/issued-documents.provider.js';
+import { normalizeDocumentType } from '../../documents/resolvers/common.js';
 import type {
   IGetAllIssuedDocumentsResult,
+  IGetIssuedDocumentsByIdsResult,
   IInsertDocumentsResult,
   IUpdateIssuedDocumentParams,
 } from '../../documents/types.js';
 import { validateClientIntegrations } from '../../financial-entities/helpers/clients.helper.js';
+import { BusinessesProvider } from '../../financial-entities/providers/businesses.provider.js';
 import { ClientsProvider } from '../../financial-entities/providers/clients.provider.js';
+import { TransactionsProvider } from '../../transactions/providers/transactions.provider.js';
+import { convertContractToDraft } from '../helpers/contract-to-draft.helper.js';
 import {
-  convertGreenInvoiceDocumentToDocumentDraft,
+  convertDocumentInputIntoGreenInvoiceInput,
+  convertGreenInvoiceDocumentToLocalDocumentInfo,
+  getGreenInvoiceDocumentNameFromType,
   getGreenInvoiceDocuments,
   getLinkedDocuments,
-  greenInvoiceCountryToCountryCode,
   greenInvoiceToDocumentStatus,
   insertNewDocumentFromGreenInvoice,
 } from '../helpers/green-invoice.helper.js';
+import {
+  deduceVatTypeFromBusiness,
+  executeDocumentIssue,
+  filterAndHandleSwiftTransactions,
+  getDocumentDateOutOfTransactions,
+  getIncomeFromDocuments,
+  getLinkedDocumentsAttributes,
+  getPaymentsFromTransactions,
+  getTypeFromDocumentsAndTransactions,
+} from '../helpers/issue-document.helper.js';
 import type { GreenInvoiceModule } from '../types.js';
 
 export const greenInvoiceResolvers: GreenInvoiceModule.Resolvers = {
   Query: {
+    newDocumentInfoDraftByCharge: async (
+      _,
+      { chargeId },
+      {
+        injector,
+        adminContext: {
+          defaultCryptoConversionFiatCurrency,
+          financialAccounts: { swiftBusinessId },
+          locality,
+        },
+      },
+    ) => {
+      if (!chargeId) {
+        throw new GraphQLError('Charge ID is required to fetch document draft');
+      }
+
+      const chargePromise = injector.get(ChargesProvider).getChargeByIdLoader.load(chargeId);
+      const documentsPromise = injector
+        .get(DocumentsProvider)
+        .getDocumentsByChargeIdLoader.load(chargeId);
+      const transactionsPromise = injector
+        .get(TransactionsProvider)
+        .transactionsByChargeIDLoader.load(chargeId)
+        .then(res => filterAndHandleSwiftTransactions(res, swiftBusinessId));
+
+      const [charge, documents, transactions, { documentsCurrency }, { mainBusinessId }] =
+        await Promise.all([
+          chargePromise,
+          documentsPromise,
+          transactionsPromise,
+          getChargeDocumentsMeta(chargeId, injector),
+          getChargeBusinesses(chargeId, injector),
+        ]);
+
+      if (!charge) {
+        throw new GraphQLError(`Charge with ID "${chargeId}" not found`);
+      }
+
+      const businessMatchPromise = mainBusinessId
+        ? injector.get(ClientsProvider).getClientByIdLoader.load(mainBusinessId)
+        : Promise.resolve(undefined);
+
+      const openIssuedDocumentsPromise = injector
+        .get(IssuedDocumentsProvider)
+        .getIssuedDocumentsByIdLoader.loadMany(documents.map(d => d.id))
+        .then(
+          res =>
+            res.filter(r => {
+              if (!r) return false;
+
+              if (r instanceof Error) {
+                console.error('Failed to fetch issued document', r);
+                return false;
+              }
+
+              if (r.status !== 'OPEN') {
+                return false;
+              }
+
+              return true;
+            }) as IGetIssuedDocumentsByIdsResult[],
+        );
+
+      const paymentPromise = getPaymentsFromTransactions(injector, transactions);
+
+      const vatTypePromise = deduceVatTypeFromBusiness(injector, locality, mainBusinessId);
+
+      const [businessMatch, openIssuedDocuments, payment, vatType] = await Promise.all([
+        businessMatchPromise,
+        openIssuedDocumentsPromise,
+        paymentPromise,
+        vatTypePromise,
+      ]);
+
+      const greenInvoiceDocuments = await Promise.all(
+        openIssuedDocuments.map(doc =>
+          injector
+            .get(GreenInvoiceClientProvider)
+            .documentLoader.load(doc.external_id)
+            .then(res => {
+              if (!res) {
+                console.error('Failed to fetch document from Green Invoice', doc.external_id);
+                return null;
+              }
+              return res;
+            }),
+        ),
+      ).then(res => res.filter(Boolean) as _DOLLAR_defs_Document[]);
+
+      const greenInvoiceClientId = validateClientIntegrations(
+        businessMatch?.integrations ?? {},
+      ).greenInvoiceId;
+      if (!greenInvoiceClientId) {
+        throw new GraphQLError(
+          `Green invoice integration missing for business ID="${mainBusinessId}"`,
+        );
+      }
+
+      const income = getIncomeFromDocuments(
+        openIssuedDocuments.map(doc => ({
+          document: documents.find(d => d.id === doc.id)!,
+          issuedDocument: doc,
+          greenInvoiceDocument: greenInvoiceDocuments.find(gd => gd.id === doc.external_id)!,
+        })),
+      );
+
+      if (income.length === 0 && transactions.length > 0) {
+        income.push(
+          ...transactions.map(transaction => ({
+            description: transaction.source_description ?? '',
+            quantity: 1,
+            price: Number(transaction.amount),
+            currency: transaction.currency as Currency,
+            currencyRate: undefined,
+            vatType,
+          })),
+        );
+      }
+
+      const type = getTypeFromDocumentsAndTransactions(greenInvoiceDocuments, transactions);
+
+      const linkedDocsAttributes = getLinkedDocumentsAttributes(
+        openIssuedDocuments,
+        type === DocumentType.CreditInvoice,
+      );
+
+      let remarks = charge.user_description;
+      if (greenInvoiceDocuments.length) {
+        remarks = greenInvoiceDocuments.map(doc => doc.remarks).join(', ');
+        switch (type) {
+          case DocumentType.Receipt:
+          case DocumentType.InvoiceReceipt:
+            remarks = `${getGreenInvoiceDocumentNameFromType(type)} for ${greenInvoiceDocuments.map(doc => `${getGreenInvoiceDocumentNameFromType(doc.type)} ${doc.number}`).join(', ')}`;
+            break;
+        }
+      } else if (businessMatch?.remark) {
+        remarks = businessMatch.remark;
+      }
+
+      const documentDate = getDocumentDateOutOfTransactions(transactions);
+
+      const transactionsCurrencies = Array.from(new Set(transactions.map(t => t.currency)));
+      const transactionsCurrency =
+        transactionsCurrencies.length === 1 ? transactionsCurrencies[0] : undefined;
+
+      return {
+        remarks,
+        // description: ____,
+        // footer: ____,
+        type,
+        date: documentDate,
+        dueDate: dateToTimelessDateString(endOfMonth(new Date())),
+        lang: 'ENGLISH',
+        currency: (transactionsCurrency ||
+          documentsCurrency ||
+          defaultCryptoConversionFiatCurrency) as Currency,
+        vatType,
+        rounding: false,
+        signed: true,
+        client: greenInvoiceClientId,
+        income,
+        payment,
+        // linkedPaymentId: ____,
+        // maxPayments: _____,
+        // discount: _____,
+        ...linkedDocsAttributes,
+      };
+    },
+    newDocumentInfoDraftByDocument: async (
+      _,
+      { documentId },
+      {
+        injector,
+        adminContext: {
+          defaultCryptoConversionFiatCurrency,
+          financialAccounts: { swiftBusinessId },
+          locality,
+        },
+      },
+    ) => {
+      if (!documentId) {
+        throw new GraphQLError('Document ID is required to fetch document draft');
+      }
+
+      const document = await injector
+        .get(DocumentsProvider)
+        .getDocumentsByIdLoader.load(documentId);
+
+      if (!document) {
+        throw new GraphQLError(`Document with ID "${documentId}" not found`);
+      }
+
+      const chargePromise = document.charge_id
+        ? injector.get(ChargesProvider).getChargeByIdLoader.load(document.charge_id)
+        : Promise.resolve(undefined);
+      const transactionsPromise = document.charge_id
+        ? injector
+            .get(TransactionsProvider)
+            .transactionsByChargeIDLoader.load(document.charge_id)
+            .then(res => filterAndHandleSwiftTransactions(res, swiftBusinessId))
+        : Promise.resolve(undefined);
+      const chargeBusinessIdPromise = document.charge_id
+        ? getChargeBusinesses(document.charge_id, injector).then(res => res.mainBusinessId)
+        : Promise.resolve(undefined);
+
+      const [charge, transactions, chargeBusinessId] = await Promise.all([
+        chargePromise,
+        transactionsPromise,
+        chargeBusinessIdPromise,
+      ]);
+
+      if (!charge) {
+        throw new GraphQLError(`Charge with ID "${document.charge_id}" not found`);
+      }
+
+      const businessMatchPromise = chargeBusinessId
+        ? injector.get(ClientsProvider).getClientByIdLoader.load(chargeBusinessId)
+        : Promise.resolve(undefined);
+
+      const openIssuedDocumentPromise = injector
+        .get(IssuedDocumentsProvider)
+        .getIssuedDocumentsByIdLoader.load(document.id);
+
+      const vatTypePromise = deduceVatTypeFromBusiness(injector, locality, chargeBusinessId);
+
+      const [businessMatch, openIssuedDocument, vatType] = await Promise.all([
+        businessMatchPromise,
+        openIssuedDocumentPromise,
+        vatTypePromise,
+      ]);
+
+      if (!openIssuedDocument) {
+        throw new GraphQLError(
+          `Document with ID "${document.id}" doesn't seem like a document we issued`,
+        );
+      }
+
+      if (openIssuedDocument.status !== 'OPEN') {
+        throw new GraphQLError(`Document with ID "${document.id}" is closed`);
+      }
+
+      const greenInvoiceDocumentPromise: Promise<_DOLLAR_defs_Document | null> = injector
+        .get(GreenInvoiceClientProvider)
+        .documentLoader.load(openIssuedDocument.external_id)
+        .then(res => {
+          if (!res) {
+            console.error(
+              'Failed to fetch document from Green Invoice',
+              openIssuedDocument.external_id,
+            );
+            return null;
+          }
+          return res;
+        });
+
+      const paymentPromise = getPaymentsFromTransactions(injector, transactions ?? []);
+
+      const greenInvoiceClientId = validateClientIntegrations(
+        businessMatch?.integrations ?? {},
+      ).greenInvoiceId;
+      if (!greenInvoiceClientId) {
+        throw new GraphQLError(
+          `Green invoice integration missing for business ID="${chargeBusinessId}"`,
+        );
+      }
+
+      const [greenInvoiceDocument, payment, { documentsCurrency }] = await Promise.all([
+        greenInvoiceDocumentPromise,
+        paymentPromise,
+        getChargeDocumentsMeta(charge.id, injector),
+      ]);
+
+      if (!greenInvoiceDocument) {
+        throw new GraphQLError(
+          `Document with ID "${document.id}" doesn't have a Green Invoice matching document`,
+        );
+      }
+
+      const income = getIncomeFromDocuments([
+        {
+          document,
+          issuedDocument: openIssuedDocument,
+          greenInvoiceDocument,
+        },
+      ]);
+
+      const type = getTypeFromDocumentsAndTransactions([greenInvoiceDocument], transactions ?? []);
+
+      const linkedDocsAttributes = getLinkedDocumentsAttributes(
+        [openIssuedDocument],
+        type === DocumentType.CreditInvoice,
+      );
+
+      let remarks = greenInvoiceDocument.remarks;
+      switch (type) {
+        case DocumentType.Receipt:
+        case DocumentType.InvoiceReceipt:
+          remarks = `${getGreenInvoiceDocumentNameFromType(type)} for ${getGreenInvoiceDocumentNameFromType(greenInvoiceDocument.type)} ${greenInvoiceDocument.number}`;
+          break;
+      }
+
+      if (!remarks && businessMatch?.remark) {
+        remarks = businessMatch.remark;
+      }
+
+      const documentDate = getDocumentDateOutOfTransactions(transactions ?? []);
+
+      return {
+        remarks,
+        // description: ____,
+        // footer: ____,
+        type,
+        date: documentDate,
+        dueDate: dateToTimelessDateString(endOfMonth(new Date())),
+        lang: 'ENGLISH',
+        currency: (documentsCurrency || defaultCryptoConversionFiatCurrency) as Currency,
+        vatType,
+        rounding: false,
+        signed: true,
+        client: greenInvoiceClientId,
+        income,
+        payment,
+        // linkedPaymentId: ____,
+        // maxPayments: _____,
+        // discount: _____,
+        ...linkedDocsAttributes,
+      };
+    },
+    clientMonthlyChargesDrafts: async (_, { issueMonth }, { injector }) => {
+      const openContracts = await injector.get(ContractsProvider).getAllOpenContracts();
+      const monthlyBillingCycle: BillingCycle = 'MONTHLY';
+      const monthlyContracts = openContracts.filter(
+        contract => contract.billing_cycle.toLocaleUpperCase() === monthlyBillingCycle,
+      );
+      const drafts = await Promise.all(
+        monthlyContracts.map(async contract =>
+          convertContractToDraft(contract, injector, issueMonth),
+        ),
+      );
+
+      return drafts;
+    },
+    clientChargesDraftsByContracts: async (_, { issueMonth, contractIds }, { injector }) => {
+      const contracts = await injector
+        .get(ContractsProvider)
+        .getContractsByIdLoader.loadMany(contractIds)
+        .then(res => res.filter(c => !!c && !(c instanceof Error)) as IGetContractsByIdsResult[]);
+
+      const drafts = await Promise.all(
+        contracts.map(async contract => convertContractToDraft(contract, injector, issueMonth)),
+      );
+
+      return drafts;
+    },
+    clientMonthlyChargeDraft: async (_, { clientId, issueMonth }, { injector }) => {
+      const openContracts = await injector.get(ContractsProvider).getAllOpenContracts();
+      const contract = openContracts.find(openContract => openContract.client_id === clientId);
+
+      if (!contract) {
+        throw new GraphQLError(`Contract not found for client ID="${clientId}"`);
+      }
+
+      const businessPromise = injector
+        .get(BusinessesProvider)
+        .getBusinessByIdLoader.load(contract.client_id);
+      const clientPromise = injector
+        .get(ClientsProvider)
+        .getClientByIdLoader.load(contract.client_id);
+      const [business, client] = await Promise.all([businessPromise, clientPromise]);
+
+      if (!business) {
+        throw new GraphQLError(`Business ID="${contract.client_id}" not found`);
+      }
+
+      if (!client) {
+        throw new GraphQLError(`Client not found for business ID="${contract.client_id}"`);
+      }
+
+      const greenInvoiceId = validateClientIntegrations(client.integrations)?.greenInvoiceId;
+
+      if (!greenInvoiceId) {
+        throw new GraphQLError(
+          `Green invoice match not found for business ID="${contract.client_id}"`,
+        );
+      }
+
+      const today = issueMonth ? addMonths(new Date(issueMonth), 1) : new Date();
+      const monthStart = dateToTimelessDateString(startOfMonth(today));
+      const monthEnd = dateToTimelessDateString(endOfMonth(today));
+      const year = today.getFullYear() + (today.getMonth() === 0 ? -1 : 0);
+      const month = format(subMonths(today, 1), 'MMMM');
+
+      const draft: ResolversTypes['NewDocumentInfo'] = {
+        remarks: `${contract.purchase_orders[0] ? `PO: ${contract.purchase_orders[0]}${contract.remarks ? ', ' : ''}` : ''}${contract.remarks ?? ''}`,
+        description: `GraphQL Hive Enterprise License - ${month} ${year}`,
+        type: normalizeDocumentType(contract.document_type),
+        date: monthStart,
+        dueDate: monthEnd,
+        lang: 'ENGLISH',
+        currency: contract.currency as Currency,
+        vatType: 'EXEMPT',
+        rounding: false,
+        signed: true,
+        client: greenInvoiceId,
+        income: [
+          {
+            description: `GraphQL Hive Enterprise License - ${month} ${year}`,
+            quantity: 1,
+            price: contract.amount,
+            currency: contract.currency as Currency,
+            vatType: 'EXEMPT',
+          },
+        ],
+      };
+
+      return draft;
+    },
     greenInvoiceClient: async (_, { clientId }, { injector }) => {
       try {
         const client = await injector.get(ClientsProvider).getClientByIdLoader.load(clientId);
@@ -42,7 +487,7 @@ export const greenInvoiceResolvers: GreenInvoiceModule.Resolvers = {
     },
   },
   Mutation: {
-    syncGreenInvoiceDocuments: async (
+    fetchIncomeDocuments: async (
       _,
       { ownerId: inputOwnerId, singlePageLimit = true },
       { injector, adminContext: { defaultAdminBusinessId } },
@@ -146,6 +591,74 @@ export const greenInvoiceResolvers: GreenInvoiceModule.Resolvers = {
 
       return addedDocs;
     },
+    issueGreenInvoiceDocuments: async (
+      _,
+      { generateDocumentsInfo },
+      { injector, adminContext: { defaultAdminBusinessId } },
+    ) => {
+      const errors: string[] = [];
+
+      await Promise.all(
+        generateDocumentsInfo.map(document => {
+          executeDocumentIssue(
+            injector,
+            defaultAdminBusinessId,
+            document,
+            undefined,
+            true,
+            undefined,
+            true,
+          ).catch(e => {
+            console.error(e);
+            errors.push(
+              `${document.client?.name ?? document.client?.greenInvoiceId}: ${e.message}`,
+            );
+          });
+        }),
+      );
+
+      return {
+        success: true,
+        errors,
+      };
+    },
+    previewGreenInvoiceDocument: async (_, { input: initialInput }, { injector }) => {
+      const input = await convertDocumentInputIntoGreenInvoiceInput(initialInput, injector);
+      const document = await injector.get(GreenInvoiceClientProvider).previewDocuments({ input });
+
+      if (!document) {
+        throw new GraphQLError('Failed to generate document preview');
+      }
+
+      if ('errorMessage' in document) {
+        console.error('Failed to generate document preview', document);
+        throw new GraphQLError(
+          `Failed to generate document preview, Green Invoice returned: ${document.errorMessage}`,
+        );
+      }
+
+      if ('file' in document && document.file) {
+        return document.file;
+      }
+
+      console.error('Document preview does not contain a file', document);
+      throw new GraphQLError('Document preview does not contain a file');
+    },
+    issueGreenInvoiceDocument: async (
+      _,
+      { input: initialInput, emailContent, attachment, chargeId, sendEmail = false },
+      { injector, adminContext: { defaultAdminBusinessId } },
+    ) => {
+      return executeDocumentIssue(
+        injector,
+        defaultAdminBusinessId,
+        initialInput,
+        emailContent ?? undefined,
+        attachment ?? undefined,
+        chargeId ?? undefined,
+        sendEmail ?? false,
+      );
+    },
   },
   IssuedDocumentInfo: {
     originalDocument: async (info, _, { injector }) => {
@@ -159,7 +672,7 @@ export const greenInvoiceResolvers: GreenInvoiceModule.Resolvers = {
         if (!document) {
           throw new GraphQLError('Original document not found');
         }
-        return await convertGreenInvoiceDocumentToDocumentDraft(document, injector);
+        return convertGreenInvoiceDocumentToLocalDocumentInfo(document);
       } catch (error) {
         console.error('Error fetching original document:', error);
         throw new GraphQLError('Error fetching original document');
@@ -187,7 +700,9 @@ export const greenInvoiceResolvers: GreenInvoiceModule.Resolvers = {
         .clientLoader.load(clientId)
         .then(client => {
           if (client?.country) {
-            return greenInvoiceCountryToCountryCode(client.country);
+            // TODO: use Country for server responses
+            // greenInvoiceCountryToCountryCode(client.country)
+            return client.country;
           }
           return null;
         });