@placeshakr/config 10.29.4 → 10.31.0-alpha.2

package/src/billing/prefill.ts

@@ -0,0 +1,309 @@
+import * as articho from '../types';
+
+/** Cualquiera de las cinco entidades a las que Articho puede facturar. */
+export type BillableEntityRecord =
+  | articho.Client
+  | articho.Pro
+  | articho.Seller
+  | articho.Provider
+  | articho.MaterialsProvider;
+
+const first = (...values: Array<string | undefined | null>): string =>
+  values.find((value) => !!value && !!value.trim())?.trim() ?? '';
+
+const SIREN_OR_SIRET = /^\d{9}(\d{5})?$/;
+
+/**
+ * Deduce el tipo de tercero SOLO cuando hay prueba.
+ *
+ * Un identificador fiscal con formato válido es prueba de empresa: nadie que
+ * no lo sea tiene uno. La ausencia, en cambio, no prueba nada —la mayoría de
+ * las fichas antiguas nunca lo rellenaron—, así que se devuelve `undefined` y
+ * lo pregunta el formulario. Adivinar «particular» por un hueco convertiría en
+ * personas a media base de datos.
+ *
+ * @param {articho.BillIssuedEntity} entity A quién va dirigida la factura.
+ * @param {Record<string, any>} record Ficha del tercero.
+ * @param {articho.BillingIdentity} existing Datos de facturación ya guardados.
+ * @return {articho.BillingLegalType | undefined} Tipo, o undefined si no consta.
+ */
+const inferLegalType = (
+  entity: articho.BillIssuedEntity,
+  record: Record<string, any>,
+  existing?: articho.BillingIdentity
+): articho.BillingLegalType | undefined => {
+  // Lo que alguien haya elegido a mano manda sobre cualquier deducción.
+  if (existing?.legalType) return existing.legalType;
+
+  // Sous-traitants, apporteurs y proveedores son empresa por definición.
+  if (
+    entity !== articho.BillIssuedEntity.CLIENT &&
+    entity !== articho.BillIssuedEntity.OTHER
+  ) {
+    return 'company';
+  }
+
+  const identifier = first(
+    existing?.registrationNumber,
+    record.siret,
+    record.siren
+  ).replace(/\s/g, '');
+
+  const vat = first(existing?.vatNumber, record.tvaNumber).replace(/\s/g, '');
+
+  // Si tiene SIRET/SIREN, N° de TVA intracomunitario o nombre comercial, es empresa.
+  if (
+    SIREN_OR_SIRET.test(identifier) ||
+    identifier ||
+    vat ||
+    first(record.commercialName)
+  ) {
+    return 'company';
+  }
+
+  // Un cliente sin datos de empresa es un particular por defecto.
+  if (entity === articho.BillIssuedEntity.CLIENT) {
+    return 'individual';
+  }
+
+  return undefined;
+};
+
+/**
+ * Intenta extraer código postal (5 dígitos) y ciudad de una dirección francesa en texto libre.
+ */
+const extractPostalCodeAndCity = (
+  rawAddress: string
+): { postalCode?: string; city?: string } => {
+  if (!rawAddress) return {};
+  const match = rawAddress.match(
+    /\b(\d{5})\b\s+([A-Za-zÀ-ÿ\s-]+?)(?:,?\s*(?:France|FR))?$/i
+  );
+  if (match) {
+    return {
+      postalCode: match[1],
+      city: match[2].trim(),
+    };
+  }
+  return {};
+};
+
+/**
+ * Construye un borrador de datos de facturación a partir de lo que ya hay en
+ * la ficha del tercero.
+ *
+ * Sirve para que el modal no pida de cero lo que ya sabemos. Lo que no se
+ * puede derivar —código postal, ciudad y país— se deja vacío a propósito:
+ * las direcciones de Articho son texto libre y adivinar el desglose de una
+ * dirección francesa falla lo bastante como para acabar en la contabilidad.
+ *
+ * @param {articho.BillIssuedEntity} entity A quién va dirigida la factura.
+ * @param {BillableEntityRecord} record Ficha del tercero.
+ * @param {articho.EntityData} entityData Datos copiados en la factura, si los hay.
+ * @return {articho.BillingIdentity} Borrador para el formulario.
+ */
+export const buildBillingDraft = (
+  entity: articho.BillIssuedEntity,
+  record?: BillableEntityRecord,
+  entityData?: articho.EntityData
+): articho.BillingIdentity => {
+  const anyRecord = (record ?? {}) as Record<string, any>;
+  const existing = anyRecord.billing as articho.BillingIdentity | undefined;
+  const legalType = inferLegalType(entity, anyRecord, existing);
+
+  // En un sous-traitant la razon social es el nombre comercial; en un
+  // cliente particular, el nombre del perfil. Por eso el orden cambia.
+  const legalName =
+    entity === articho.BillIssuedEntity.PRO
+      ? first(
+          existing?.legalName,
+          anyRecord.commercialName,
+          anyRecord.displayName,
+          entityData?.name
+        )
+      : first(
+          existing?.legalName,
+          anyRecord.commercialName,
+          anyRecord.name,
+          anyRecord.displayName,
+          entityData?.name
+        );
+
+  const rawAddress = first(
+    existing?.address?.address,
+    anyRecord.address,
+    anyRecord.deliveryAddress,
+    entityData?.address
+  );
+
+  const parsedGeo = extractPostalCodeAndCity(rawAddress);
+
+  const postalCode = first(
+    existing?.address?.postalCode,
+    anyRecord.postalCode,
+    anyRecord.zipCode,
+    parsedGeo.postalCode
+  );
+
+  const city = first(existing?.address?.city, anyRecord.city, parsedGeo.city);
+
+  const countryAlpha2 =
+    first(
+      existing?.address?.countryAlpha2,
+      anyRecord.country,
+      anyRecord.countryAlpha2
+    ) || 'FR';
+
+  const registrationNumber = first(
+    existing?.registrationNumber,
+    anyRecord.siret,
+    anyRecord.siren,
+    entityData?.siret
+  ).replace(/\s/g, '');
+
+  const vatNumber = first(
+    existing?.vatNumber,
+    anyRecord.tvaNumber,
+    entityData?.tva
+  ).replace(/\s/g, '');
+
+  const emails = existing?.emails?.length
+    ? existing.emails
+    : [
+        first(anyRecord.email, anyRecord.contact?.email, entityData?.email),
+        ...((
+          anyRecord.additionalEmails as articho.ExtraEmail[] | undefined
+        )?.map((extra) => extra?.email) ?? []),
+      ].filter((email): email is string => !!email);
+
+  const phone = first(
+    existing?.phone,
+    anyRecord.mainPhone,
+    Array.isArray(anyRecord.phone)
+      ? anyRecord.phone[0]?.number
+      : anyRecord.phone
+  );
+
+  let firstName = first(existing?.firstName, anyRecord.firstName);
+  let lastName = first(existing?.lastName, anyRecord.lastName);
+
+  const rawPersonName = first(
+    existing?.firstName && existing?.lastName ? '' : undefined,
+    anyRecord.displayName,
+    anyRecord.name,
+    entityData?.name,
+    existing?.legalName
+  );
+
+  if ((!firstName || !lastName) && rawPersonName) {
+    const trimmed = rawPersonName.trim();
+    const firstSpaceIdx = trimmed.indexOf(' ');
+    if (firstSpaceIdx > 0) {
+      if (!firstName) firstName = trimmed.slice(0, firstSpaceIdx);
+      if (!lastName) lastName = trimmed.slice(firstSpaceIdx + 1).trim();
+    } else if (!firstName) {
+      firstName = trimmed;
+    }
+  }
+
+  // Lo ya guardado manda: si alguien lo rellenó, no lo pisamos con conjeturas.
+  // Pero si algún dato fiscal o de contacto faltaba en billing y sí existe en la
+  // ficha del cliente (siret, tvaNumber, etc.), lo enriquecemos.
+  const complete =
+    !!existing?.address?.postalCode &&
+    !!existing?.address?.city &&
+    !!existing?.address?.address &&
+    (existing?.legalType === 'individual'
+      ? !!existing?.firstName && !!existing?.lastName
+      : !!existing?.legalName);
+
+  if (complete) {
+    return {
+      ...existing,
+      ...(legalType ? { legalType } : {}),
+      firstName: existing?.firstName || firstName || undefined,
+      lastName: existing?.lastName || lastName || undefined,
+      registrationNumber:
+        existing?.registrationNumber || registrationNumber || undefined,
+      vatNumber: existing?.vatNumber || vatNumber || undefined,
+      address: {
+        address: existing?.address?.address || rawAddress,
+        postalCode: existing?.address?.postalCode || postalCode,
+        city: existing?.address?.city || city,
+        countryAlpha2: existing?.address?.countryAlpha2 || countryAlpha2,
+      },
+      phone: existing?.phone || phone || undefined,
+      emails: existing?.emails?.length
+        ? existing.emails
+        : emails.length
+          ? [...new Set(emails)]
+          : undefined,
+    } as articho.BillingIdentity;
+  }
+
+  return {
+    ...existing,
+    ...(legalType ? { legalType } : {}),
+    firstName: firstName || undefined,
+    lastName: lastName || undefined,
+    legalName:
+      legalName ||
+      (legalType === 'individual'
+        ? [firstName, lastName].filter(Boolean).join(' ')
+        : '') ||
+      '',
+    address: {
+      address: rawAddress,
+      postalCode,
+      city,
+      countryAlpha2,
+    },
+    ...(registrationNumber ? { registrationNumber } : {}),
+    ...(vatNumber ? { vatNumber } : {}),
+    ...(emails.length ? { emails: [...new Set(emails)] } : {}),
+    ...(phone ? { phone } : {}),
+    language: existing?.language ?? articho.BillingLanguage.FR,
+    paymentConditions:
+      existing?.paymentConditions ?? articho.BillingPaymentConditions.DAYS_30,
+  };
+};
+
+/**
+ * De dónde salen y a dónde vuelven los datos de facturación según a quién se
+ * factura.
+ *
+ * No todos los destinatarios tienen ficha. Solo CLIENT y PRO (perfiles de
+ * usuario) y PROVIDER (apporteur d'affaires) apuntan a un documento real; para
+ * "fournisseur de matériaux", "fournisseur de services" y "personnalisé",
+ * Articho solo guarda un nombre escrito a mano en la propia factura
+ * (`useGetEntityData` en `app-admin/utils/accounting.utils.ts`). En esos casos
+ * los datos de facturación viven en la factura: no hay tercero que actualizar.
+ *
+ * @param {articho.BillIssuedEntity} entity Tipo de destinatario.
+ * @return {'userProfile' | 'provider' | 'bill'} Dónde vive el dato.
+ */
+export const getBillingRecordSource = (
+  entity: articho.BillIssuedEntity
+): 'userProfile' | 'provider' | 'bill' => {
+  switch (entity) {
+    case articho.BillIssuedEntity.CLIENT:
+    case articho.BillIssuedEntity.PRO:
+      return 'userProfile';
+    case articho.BillIssuedEntity.PROVIDER:
+      return 'provider';
+    default:
+      // MATERIAL_PROVIDER, SERVICE_PROVIDER y OTHER no tienen ficha propia.
+      return 'bill';
+  }
+};
+
+/**
+ * ¿Los datos de facturación se guardan en una ficha reutilizable?
+ * Si no, se quedan en la factura y habrá que volver a escribirlos la próxima
+ * vez que se facture a ese mismo destinatario.
+ * @param {articho.BillIssuedEntity} entity Tipo de destinatario.
+ * @return {boolean} true si hay ficha que actualizar.
+ */
+export const hasReusableBillingRecord = (
+  entity: articho.BillIssuedEntity
+): boolean => getBillingRecordSource(entity) !== 'bill';

package/src/billing/types.ts

@@ -0,0 +1,32 @@
+import * as articho from '../types';
+
+/**
+ * Un campo de facturación que falta o es inválido.
+ *
+ * `path` usa notación de punto (`address.postalCode`) para que el formulario
+ * pueda resaltar exactamente el input que falla, y `tkey` es la clave de
+ * traducción, no el texto: quien pinta decide el idioma.
+ */
+export type MissingBillingField = {
+  path: string;
+  tkey: string;
+  /** true = imprescindible para poder facturar. false = recomendable. */
+  required: boolean;
+};
+
+/** De dónde salen los datos de facturación según a quién va dirigida la factura. */
+export type BillingEntitySource = {
+  entity: articho.BillIssuedEntity;
+  /** Id del documento de origen (userId para perfiles, id para providers). */
+  id: string;
+  /** Nombre legible, para la cabecera del modal. */
+  displayName: string;
+  billing?: articho.BillingIdentity;
+};
+
+export type BillingCompleteness = {
+  complete: boolean;
+  missing: MissingBillingField[];
+  /** Campos que no son obligatorios pero conviene rellenar. */
+  warnings: MissingBillingField[];
+};

package/src/billing/validate.ts

@@ -0,0 +1,198 @@
+import * as articho from '../types';
+import { MissingBillingField, BillingCompleteness } from './types';
+
+const SIREN_OR_SIRET = /^\d{9}(\d{5})?$/;
+const VAT_NUMBER = /^[A-Z]{2}[0-9A-Z]{2,13}$/;
+const COUNTRY_ALPHA2 = /^[A-Z]{2}$/;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+const isBlank = (value?: string | null) => !value || !value.trim();
+
+/**
+ * Entidades que son siempre una persona jurídica.
+ *
+ * Un sous-traitant, un apporteur d'affaires o un proveedor de materiales tienen
+ * SIREN por definición: si no lo tuvieran no podrían facturarnos a nosotros.
+ * Solo el destinatario de tipo CLIENT —y el genérico OTHER— puede ser una
+ * persona física.
+ */
+const ALWAYS_COMPANY: articho.BillIssuedEntity[] = [
+  articho.BillIssuedEntity.PRO,
+  articho.BillIssuedEntity.PROVIDER,
+  articho.BillIssuedEntity.MATERIAL_PROVIDER,
+  articho.BillIssuedEntity.SERVICE_PROVIDER,
+];
+
+/**
+ * Resuelve si hay que tratar al destinatario como empresa.
+ *
+ * El `legalType` de la ficha manda, porque es lo que ha dicho una persona. Solo
+ * cuando falta se recurre al tipo de destinatario, y ahí la única lectura
+ * segura es la de las cuatro entidades que son empresa por definición: para un
+ * CLIENT sin `legalType` no se puede suponer nada, y forzarlo a empresa es
+ * justamente el fallo que hacía imposible facturar a un particular.
+ *
+ * @param {articho.BillIssuedEntity} entity A quién va dirigida la factura.
+ * @param {articho.BillingIdentity} billing Datos de facturación.
+ * @return {articho.BillingLegalType | undefined} Tipo resuelto, o undefined si no se sabe.
+ */
+export const resolveLegalType = (
+  entity: articho.BillIssuedEntity,
+  billing?: articho.BillingIdentity
+): articho.BillingLegalType | undefined => {
+  if (billing?.legalType) return billing.legalType;
+  if (ALWAYS_COMPANY.includes(entity)) return 'company';
+  return undefined;
+};
+
+/**
+ * Nombre que se imprime en la factura.
+ *
+ * En una empresa es la razón social. En un particular se compone de nombre y
+ * apellidos, para que no haya dos campos guardando lo mismo.
+ *
+ * @param {articho.BillingIdentity} billing Datos de facturación.
+ * @return {string} Nombre para mostrar e imprimir.
+ */
+export const billingDisplayName = (billing?: articho.BillingIdentity): string => {
+  if (!billing) return '';
+
+  if (billing.legalType === 'individual') {
+    const composed = [billing.firstName, billing.lastName]
+      .map((part) => part?.trim())
+      .filter(Boolean)
+      .join(' ');
+
+    return composed || (billing.legalName ?? '').trim();
+  }
+
+  return (billing.legalName ?? '').trim();
+};
+
+/**
+ * Comprueba si los datos de facturación de un tercero permiten emitirle una
+ * factura.
+ *
+ * Esta función es la única fuente de verdad sobre qué datos hacen falta. La
+ * usa el modal de confirmación para saber qué pedir y la Cloud Function para
+ * rechazar lo que llegue incompleto. Si divergieran, el usuario rellenaría un
+ * formulario y aun así le rebotaría el envío.
+ *
+ * @param {articho.BillIssuedEntity} entity A quién va dirigida la factura.
+ * @param {articho.BillingIdentity} billing Datos de facturación actuales.
+ * @return {BillingCompleteness} Qué falta y qué conviene.
+ */
+export const checkBillingIdentity = (
+  entity: articho.BillIssuedEntity,
+  billing?: articho.BillingIdentity
+): BillingCompleteness => {
+  const missing: MissingBillingField[] = [];
+  const warnings: MissingBillingField[] = [];
+
+  const require = (path: string, tkey: string) =>
+    missing.push({ path, tkey, required: true });
+  const suggest = (path: string, tkey: string) =>
+    warnings.push({ path, tkey, required: false });
+
+  if (!billing) {
+    return {
+      complete: false,
+      missing: [
+        { path: 'legalType', tkey: 'billing.field.legalType', required: true },
+        { path: 'address.address', tkey: 'billing.field.address', required: true },
+        { path: 'address.postalCode', tkey: 'billing.field.postalCode', required: true },
+        { path: 'address.city', tkey: 'billing.field.city', required: true },
+        { path: 'address.countryAlpha2', tkey: 'billing.field.country', required: true },
+      ],
+      warnings: [],
+    };
+  }
+
+  const legalType = resolveLegalType(entity, billing);
+
+  // --- empresa o particular -----------------------------------------------
+  // Sin esto no se puede validar el resto: los campos obligatorios de una
+  // sociedad y los de una persona no se solapan.
+  if (!legalType) require('legalType', 'billing.field.legalType');
+
+  // --- identidad ----------------------------------------------------------
+  if (legalType === 'individual') {
+    if (isBlank(billing.firstName)) require('firstName', 'billing.field.firstName');
+    if (isBlank(billing.lastName)) require('lastName', 'billing.field.lastName');
+  } else {
+    // Empresa, o todavía sin decidir: en ambos casos la razón social hace falta.
+    if (isBlank(billing.legalName)) require('legalName', 'billing.field.legalName');
+  }
+
+  // --- dirección de facturación ------------------------------------------
+  // Los cuatro campos son obligatorios: PennyLane rechaza la dirección entera
+  // si falta uno, y no hay forma de derivarlos del `address` de texto libre.
+  // Aplica igual a empresas y a particulares.
+  if (isBlank(billing.address?.address)) require('address.address', 'billing.field.address');
+  if (isBlank(billing.address?.postalCode)) {
+    require('address.postalCode', 'billing.field.postalCode');
+  }
+  if (isBlank(billing.address?.city)) require('address.city', 'billing.field.city');
+
+  if (isBlank(billing.address?.countryAlpha2)) {
+    require('address.countryAlpha2', 'billing.field.country');
+  } else if (!COUNTRY_ALPHA2.test(billing.address.countryAlpha2.toUpperCase())) {
+    require('address.countryAlpha2', 'billing.field.countryInvalid');
+  }
+
+  // --- identificación fiscal ---------------------------------------------
+  // Solo para empresas. Un particular no tiene SIREN ni número de TVA, y su
+  // factura queda fuera de la facturación electrónica: no hay a quién
+  // transmitirla por la red ni identidad que declarar.
+  const registrationNumber = billing.registrationNumber?.replace(/\s/g, '') ?? '';
+  const vatNumber = billing.vatNumber?.replace(/\s/g, '').toUpperCase() ?? '';
+
+  if (legalType === 'individual') {
+    // Un número aquí es casi siempre un error de captura, no un dato de más.
+    if (registrationNumber) {
+      suggest('registrationNumber', 'billing.field.registrationNumberOnIndividual');
+    }
+  } else {
+    if (!registrationNumber) {
+      // Sin `legalType` todavía no se bloquea por esto: primero hay que saber
+      // qué es. Marcarlo como obligatorio antes de elegir confunde.
+      if (legalType === 'company') {
+        require('registrationNumber', 'billing.field.registrationNumber');
+      } else {
+        suggest('registrationNumber', 'billing.field.registrationNumber');
+      }
+    } else if (!SIREN_OR_SIRET.test(registrationNumber)) {
+      require('registrationNumber', 'billing.field.registrationNumberInvalid');
+    }
+
+    if (vatNumber && !VAT_NUMBER.test(vatNumber)) {
+      require('vatNumber', 'billing.field.vatNumberInvalid');
+    } else if (!vatNumber && legalType === 'company') {
+      // No lo bloquea: hay empresas en franchise de TVA sin número intracom.
+      suggest('vatNumber', 'billing.field.vatNumber');
+    }
+  }
+
+  // --- contacto -----------------------------------------------------------
+  const emails = billing.emails?.filter((email) => !isBlank(email)) ?? [];
+
+  if (!emails.length) {
+    suggest('emails', 'billing.field.emails');
+  } else {
+    const invalid = emails.find((email) => !EMAIL.test(email.trim()));
+    if (invalid) require('emails', 'billing.field.emailsInvalid');
+  }
+
+  return { complete: missing.length === 0, missing, warnings };
+};
+
+/**
+ * Atajo para saber si se puede facturar sin pedir nada más.
+ * @param {articho.BillIssuedEntity} entity Destinatario.
+ * @param {articho.BillingIdentity} billing Datos actuales.
+ * @return {boolean} true si no falta nada obligatorio.
+ */
+export const isBillingComplete = (
+  entity: articho.BillIssuedEntity,
+  billing?: articho.BillingIdentity
+): boolean => checkBillingIdentity(entity, billing).complete;

package/src/environment/base.ts

@@ -51,6 +51,9 @@ const productionEnvironment: Environment = {
       bills: 'enterprises/{enterpriseId}/projects/{projectId}/bills',
       counters: 'counters',
       invoices: 'enterprises/{enterpriseId}/invoices',
+      importedBills: 'enterprises/{enterpriseId}/importedBills',
+      importedBillEvents:
+        'enterprises/{enterpriseId}/importedBills/{importedBillId}/events',
       materialsProvider: 'enterprises/{enterpriseId}/materialsProvider',
       materials:
         'enterprises/{enterpriseId}/materialsProvider/{materialsProviderId}/materials',
@@ -160,6 +163,9 @@ const productionEnvironment: Environment = {
       configuration:
         'enterprises/{enterpriseId}/configurations/{configurationId}',
       log: 'enterprises/{enterpriseId}/logs/{logId}',
+      importedBill: 'enterprises/{enterpriseId}/importedBills/{importedBillId}',
+      importedBillEvent:
+        'enterprises/{enterpriseId}/importedBills/{importedBillId}/events/{eventId}',
       systemVersion: 'systemVersions/{systemVersionId}',
       evaluationConfig:
         'enterprises/{enterpriseId}/evaluationsConfig/{evaluationConfigId}',
@@ -201,6 +207,7 @@ const productionEnvironment: Environment = {
       estimations: 'estimations', // 14
       nomenclatures: 'nomenclatures', // 15
       workOrders: 'workOrders', // 16
+      importedBills: 'imported-bills', // 17
       // used only for managment
       systemMaterials: 'system-materials', // 17
       systemOperations: 'system-operations', // 18
@@ -542,6 +549,29 @@ const productionEnvironment: Environment = {
       maxValuesPerFacet: 1000,
       maxFacetHits: 100,
     },
+    importedBills: {
+      searchableAttributes: [
+        'counterparty.name',
+        'invoice.reference',
+        'references.projectRef',
+        'references.devisRef',
+        'assignment.projectName',
+        'assignment.projectReference',
+        'assignment.devisName',
+        'counterparty.regNo',
+      ],
+      attributesForFaceting: [
+        'searchable(scope)',
+        'searchable(enterpriseId)',
+        'status',
+        'direction',
+        'source',
+        'invoice.isPaid',
+      ],
+      ranking: ['desc(invoice.date)', 'desc(createdAt)'],
+      maxValuesPerFacet: 1000,
+      maxFacetHits: 100,
+    },
     // used only for managment
     systemMaterials: {
       searchableAttributes: ['name', 'unitPrice'],

package/src/environment/decorators.ts

@@ -39,6 +39,7 @@ const test: EnvironmentDecorator = (base: Environment) => ({
       nomenclatures: 'nomenclatures',
       operationsGroups: 'operations-groups',
       workOrders: 'work-orders',
+      importedBills: 'tests-imported-bills',
       // used only for managment
       systemMaterials: 'system-materials',
       systemOperations: 'system-operations',
@@ -80,6 +81,7 @@ const emulator: EnvironmentDecorator = (base: Environment) => ({
       nomenclatures: 'nomenclatures',
       operationsGroups: 'operations-groups',
       workOrders: 'work-orders',
+      importedBills: 'emulator-imported-bills',
       // used only for managment
       systemMaterials: 'system-materials',
       systemOperations: 'system-operations',

package/src/environment/types.ts

@@ -51,6 +51,7 @@ export interface Environment {
       estimations: string;
       nomenclatures: string;
       workOrders: string;
+      importedBills: string;
       // used only for management - 7
       systemMaterials: string;
       systemOperations: string;
@@ -112,6 +113,8 @@ export interface Environment {
       marketplaceNotifications: string;
       filesOfWorksExecuted: string;
       emailsEvents: string;
+      importedBills: string;
+      importedBillEvents: string;
     };
     docs: {
       user: string;
@@ -168,6 +171,8 @@ export interface Environment {
       devisCandidateTemplate: string;
       filesOfWorksExecuted: string;
       emailsEvent: string;
+      importedBill: string;
+      importedBillEvent: string;
     };
   };
 

package/src/helpers/index.ts

@@ -13,6 +13,7 @@ export interface Helpers {
   medias: FactoryCreate<articho.Media>;
   materials: FactoryCreate<articho.Material>;
   bills: FactoryCreate<articho.Bill>;
+  importedBills: FactoryCreate<articho.ImportedBill>;
   billsIssued: FactoryCreate<articho.BillIssued>;
   billsReceived: FactoryCreate<articho.BillReceived>;
   devis: FactoryCreate<articho.Devis>;
@@ -90,6 +91,7 @@ const helpers: Helpers = {
   events: FactoryCreateFunction(),
   orders: FactoryCreateFunction(),
   bills: FactoryCreateFunction(),
+  importedBills: FactoryCreateFunction(),
   billsIssued: FactoryCreateFunction(),
   billsReceived: FactoryCreateFunction(),
   materialsProvider: FactoryCreateFunction(),

package/src/index.ts

@@ -10,6 +10,7 @@ import {
   ProductEntry,
 } from './plans/types';
 import * as articho from './types';
+import * as billing from './billing';
 import { flatten } from './utils/flatten';
 import { AppEvent, EventMetadata, createEvent } from './events';
 import * as WhatsApp from './whatsapp';
@@ -26,6 +27,7 @@ export {
   Environment,
   Environments,
   articho,
+  billing,
   security,
   SecurityContext,
   ROLE,