@hed-hog/finance 0.0.256 → 0.0.260

package/dist/finance.service.js

@@ -587,6 +587,242 @@ let FinanceService = FinanceService_1 = class FinanceService {
             periodoAberto: openPeriod,
         };
     }
+    async getAccountsReceivableCollectionsDefault() {
+        var _a;
+        const today = this.startOfDay(new Date());
+        const overdueInstallments = await this.prisma.financial_installment.findMany({
+            where: {
+                open_amount_cents: {
+                    gt: 0,
+                },
+                due_date: {
+                    lt: today,
+                },
+                financial_title: {
+                    title_type: 'receivable',
+                },
+            },
+            select: {
+                due_date: true,
+                open_amount_cents: true,
+                amount_cents: true,
+                financial_title: {
+                    select: {
+                        person_id: true,
+                        person: {
+                            select: {
+                                name: true,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const byCustomer = new Map();
+        for (const installment of overdueInstallments) {
+            const personId = installment.financial_title.person_id;
+            const personName = ((_a = installment.financial_title.person) === null || _a === void 0 ? void 0 : _a.name) || `Cliente ${personId}`;
+            const openAmount = installment.open_amount_cents > 0
+                ? installment.open_amount_cents
+                : installment.amount_cents;
+            const amount = this.fromCents(openAmount);
+            const diffDays = Math.floor((today.getTime() - this.startOfDay(installment.due_date).getTime()) /
+                86400000);
+            if (!byCustomer.has(personId)) {
+                byCustomer.set(personId, {
+                    clienteId: String(personId),
+                    cliente: personName,
+                    bucket0_30: 0,
+                    bucket31_60: 0,
+                    bucket61_90: 0,
+                    bucket90plus: 0,
+                    total: 0,
+                });
+            }
+            const customer = byCustomer.get(personId);
+            if (diffDays <= 30) {
+                customer.bucket0_30 += amount;
+            }
+            else if (diffDays <= 60) {
+                customer.bucket31_60 += amount;
+            }
+            else if (diffDays <= 90) {
+                customer.bucket61_90 += amount;
+            }
+            else {
+                customer.bucket90plus += amount;
+            }
+            customer.total += amount;
+        }
+        const agingInadimplencia = Array.from(byCustomer.values())
+            .map((item) => (Object.assign(Object.assign({}, item), { bucket0_30: Number(item.bucket0_30.toFixed(2)), bucket31_60: Number(item.bucket31_60.toFixed(2)), bucket61_90: Number(item.bucket61_90.toFixed(2)), bucket90plus: Number(item.bucket90plus.toFixed(2)), total: Number(item.total.toFixed(2)) })))
+            .sort((a, b) => b.total - a.total);
+        const contactHistory = await this.prisma.audit_log.findMany({
+            where: {
+                entity_table: {
+                    in: ['financial_collection_contact', 'financial_collection_agreement'],
+                },
+            },
+            include: {
+                user: {
+                    select: {
+                        name: true,
+                    },
+                },
+            },
+            orderBy: {
+                created_at: 'desc',
+            },
+            take: 500,
+        });
+        const historicoContatos = contactHistory.map((log) => {
+            var _a;
+            const afterData = this.parseAiJson(log.after_data || '{}');
+            return {
+                clienteId: log.entity_id,
+                tipo: this.mapCollectionActionToType(log.action, afterData === null || afterData === void 0 ? void 0 : afterData.channel),
+                data: log.created_at.toISOString(),
+                descricao: log.summary || '',
+                responsavel: ((_a = log.user) === null || _a === void 0 ? void 0 : _a.name) || 'Sistema',
+            };
+        });
+        return {
+            agingInadimplencia,
+            historicoContatos,
+        };
+    }
+    async sendCollection(personId, data, actorUserId) {
+        const person = await this.prisma.person.findUnique({
+            where: {
+                id: personId,
+            },
+            select: {
+                id: true,
+                name: true,
+            },
+        });
+        if (!person) {
+            throw new common_1.NotFoundException('Person not found');
+        }
+        const log = await this.prisma.audit_log.create({
+            data: {
+                actor_user_id: actorUserId || null,
+                action: 'collection_sent',
+                entity_table: 'financial_collection_contact',
+                entity_id: String(person.id),
+                summary: `Cobrança enviada via e-mail para ${person.name}`,
+                after_data: JSON.stringify({
+                    message: data.message,
+                    subject: data.subject || null,
+                }),
+            },
+        });
+        return {
+            id: String(log.id),
+            success: true,
+        };
+    }
+    async registerCollectionAgreement(personId, data, actorUserId) {
+        const person = await this.prisma.person.findUnique({
+            where: {
+                id: personId,
+            },
+            select: {
+                id: true,
+                name: true,
+            },
+        });
+        if (!person) {
+            throw new common_1.NotFoundException('Person not found');
+        }
+        const firstDueDate = new Date(data.first_due_date);
+        if (Number.isNaN(firstDueDate.getTime())) {
+            throw new common_1.BadRequestException('Invalid first due date');
+        }
+        const totalAmountCents = this.toCents(Number(data.amount));
+        if (totalAmountCents <= 0) {
+            throw new common_1.BadRequestException('Invalid agreement amount');
+        }
+        const baseInstallmentCents = Math.floor(totalAmountCents / data.installments);
+        const remainder = totalAmountCents % data.installments;
+        const created = await this.prisma.$transaction(async (tx) => {
+            const title = await tx.financial_title.create({
+                data: {
+                    person_id: person.id,
+                    title_type: 'receivable',
+                    status: 'open',
+                    document_number: `ACD-${Date.now()}`,
+                    description: data.notes || 'Acordo de cobrança',
+                    competence_date: firstDueDate,
+                    issue_date: new Date(),
+                    total_amount_cents: totalAmountCents,
+                    created_by_user_id: actorUserId || null,
+                },
+                select: {
+                    id: true,
+                },
+            });
+            for (let index = 0; index < data.installments; index += 1) {
+                const dueDate = this.addMonths(firstDueDate, index);
+                const amountCents = baseInstallmentCents + (index === data.installments - 1 ? remainder : 0);
+                await tx.financial_installment.create({
+                    data: {
+                        title_id: title.id,
+                        installment_number: index + 1,
+                        competence_date: dueDate,
+                        due_date: dueDate,
+                        amount_cents: amountCents,
+                        open_amount_cents: amountCents,
+                        status: this.resolveInstallmentStatus(amountCents, amountCents, dueDate, 'open'),
+                        notes: data.notes || null,
+                    },
+                });
+            }
+            const log = await tx.audit_log.create({
+                data: {
+                    actor_user_id: actorUserId || null,
+                    action: 'collection_agreement_registered',
+                    entity_table: 'financial_collection_agreement',
+                    entity_id: String(person.id),
+                    summary: `Acordo registrado para ${person.name}: ${data.installments}x`,
+                    after_data: JSON.stringify({
+                        title_id: title.id,
+                        installments: data.installments,
+                        amount: data.amount,
+                        first_due_date: data.first_due_date,
+                        notes: data.notes || null,
+                    }),
+                },
+                select: {
+                    id: true,
+                },
+            });
+            return {
+                titleId: title.id,
+                auditLogId: log.id,
+            };
+        });
+        return {
+            success: true,
+            titleId: String(created.titleId),
+            auditLogId: String(created.auditLogId),
+        };
+    }
+    mapCollectionActionToType(action, channel) {
+        if (action === 'collection_agreement_registered') {
+            return 'Acordo';
+        }
+        if (channel) {
+            const normalized = String(channel).toLowerCase();
+            if (normalized === 'email')
+                return 'E-mail';
+            if (normalized === 'whatsapp')
+                return 'WhatsApp';
+            if (normalized === 'sms')
+                return 'SMS';
+        }
+        return 'Contato';
+    }
     calculateDashboardKpis(payables, receivables, bankAccounts) {
         const today = this.startOfDay(new Date());
         const day7 = this.addDays(today, 7);
@@ -637,6 +873,11 @@ let FinanceService = FinanceService_1 = class FinanceService {
         next.setDate(next.getDate() + days);
         return next;
     }
+    addMonths(date, months) {
+        const next = new Date(date);
+        next.setMonth(next.getMonth() + months);
+        return next;
+    }
     async listAccountsPayableInstallments(paginationParams, status) {
         return this.listTitles('payable', paginationParams, status);
     }
@@ -882,6 +1123,184 @@ let FinanceService = FinanceService_1 = class FinanceService {
         });
         return bankAccounts.map((bankAccount) => this.mapBankAccountToFront(bankAccount));
     }
+    async listTransfers(filters) {
+        var _a;
+        const search = (_a = filters === null || filters === void 0 ? void 0 : filters.search) === null || _a === void 0 ? void 0 : _a.trim();
+        const parsedBankAccountId = (filters === null || filters === void 0 ? void 0 : filters.bank_account_id)
+            ? Number.parseInt(filters.bank_account_id, 10)
+            : undefined;
+        const bankAccountId = parsedBankAccountId && !Number.isNaN(parsedBankAccountId)
+            ? parsedBankAccountId
+            : undefined;
+        let transferKeys;
+        if (search || bankAccountId) {
+            const filteredLines = await this.prisma.bank_statement_line.findMany({
+                where: Object.assign(Object.assign({ external_id: {
+                        startsWith: 'transfer:',
+                    } }, (search
+                    ? {
+                        description: {
+                            contains: search,
+                            mode: 'insensitive',
+                        },
+                    }
+                    : {})), (bankAccountId ? { bank_account_id: bankAccountId } : {})),
+                select: {
+                    external_id: true,
+                },
+            });
+            transferKeys = Array.from(new Set(filteredLines
+                .map((line) => line.external_id)
+                .filter((externalId) => !!externalId)));
+            if (transferKeys.length === 0) {
+                return [];
+            }
+        }
+        const transferLines = await this.prisma.bank_statement_line.findMany({
+            where: Object.assign({}, (transferKeys
+                ? {
+                    external_id: {
+                        in: transferKeys,
+                    },
+                }
+                : {
+                    external_id: {
+                        startsWith: 'transfer:',
+                    },
+                })),
+            select: {
+                id: true,
+                external_id: true,
+                bank_account_id: true,
+                posted_date: true,
+                amount_cents: true,
+                description: true,
+            },
+            orderBy: [{ posted_date: 'desc' }, { id: 'desc' }],
+        });
+        const groupedByTransfer = new Map();
+        for (const line of transferLines) {
+            const transferKey = line.external_id;
+            if (!transferKey) {
+                continue;
+            }
+            const current = groupedByTransfer.get(transferKey) || [];
+            current.push(line);
+            groupedByTransfer.set(transferKey, current);
+        }
+        const transfers = Array.from(groupedByTransfer.entries())
+            .map(([transferKey, lines]) => {
+            const sourceLine = lines.find((line) => line.amount_cents < 0);
+            const destinationLine = lines.find((line) => line.amount_cents > 0);
+            if (!sourceLine || !destinationLine) {
+                return null;
+            }
+            return {
+                id: transferKey.replace('transfer:', ''),
+                contaOrigemId: String(sourceLine.bank_account_id),
+                contaDestinoId: String(destinationLine.bank_account_id),
+                data: sourceLine.posted_date.toISOString(),
+                valor: this.fromCents(Math.abs(sourceLine.amount_cents)),
+                descricao: sourceLine.description || destinationLine.description || '',
+            };
+        })
+            .filter(Boolean);
+        return transfers;
+    }
+    async createTransfer(data, userId) {
+        var _a;
+        const sourceAccountId = Number(data.source_account_id);
+        const destinationAccountId = Number(data.destination_account_id);
+        const amount = Number(data.amount);
+        const postedDate = new Date(data.date);
+        if (Number.isNaN(sourceAccountId) ||
+            Number.isNaN(destinationAccountId) ||
+            sourceAccountId <= 0 ||
+            destinationAccountId <= 0) {
+            throw new common_1.BadRequestException('Invalid bank account ids');
+        }
+        if (sourceAccountId === destinationAccountId) {
+            throw new common_1.BadRequestException('Source and destination accounts must be different');
+        }
+        if (Number.isNaN(amount) || amount <= 0) {
+            throw new common_1.BadRequestException('amount must be greater than zero');
+        }
+        if (Number.isNaN(postedDate.getTime())) {
+            throw new common_1.BadRequestException('Invalid transfer date');
+        }
+        const accounts = await this.prisma.bank_account.findMany({
+            where: {
+                id: {
+                    in: [sourceAccountId, destinationAccountId],
+                },
+            },
+            select: {
+                id: true,
+            },
+        });
+        if (accounts.length !== 2) {
+            throw new common_1.NotFoundException('Bank account not found');
+        }
+        const amountCents = this.toCents(amount);
+        const description = ((_a = data.description) === null || _a === void 0 ? void 0 : _a.trim()) || 'Transferência bancária';
+        const transferReference = `transfer:${Date.now()}-${Math.round(Math.random() * 1000000)}`;
+        await this.prisma.$transaction(async (tx) => {
+            const sourceStatement = await tx.bank_statement.create({
+                data: {
+                    bank_account_id: sourceAccountId,
+                    source_type: 'manual',
+                    imported_at: new Date(),
+                    imported_by_user_id: userId,
+                    idempotency_key: `${transferReference}:source`,
+                    period_start: postedDate,
+                    period_end: postedDate,
+                },
+            });
+            const destinationStatement = await tx.bank_statement.create({
+                data: {
+                    bank_account_id: destinationAccountId,
+                    source_type: 'manual',
+                    imported_at: new Date(),
+                    imported_by_user_id: userId,
+                    idempotency_key: `${transferReference}:destination`,
+                    period_start: postedDate,
+                    period_end: postedDate,
+                },
+            });
+            await tx.bank_statement_line.create({
+                data: {
+                    bank_statement_id: sourceStatement.id,
+                    bank_account_id: sourceAccountId,
+                    external_id: transferReference,
+                    posted_date: postedDate,
+                    amount_cents: -Math.abs(amountCents),
+                    description,
+                    status: 'reconciled',
+                    dedupe_key: `${transferReference}:source`,
+                },
+            });
+            await tx.bank_statement_line.create({
+                data: {
+                    bank_statement_id: destinationStatement.id,
+                    bank_account_id: destinationAccountId,
+                    external_id: transferReference,
+                    posted_date: postedDate,
+                    amount_cents: Math.abs(amountCents),
+                    description,
+                    status: 'reconciled',
+                    dedupe_key: `${transferReference}:destination`,
+                },
+            });
+        });
+        return {
+            id: transferReference.replace('transfer:', ''),
+            contaOrigemId: String(sourceAccountId),
+            contaDestinoId: String(destinationAccountId),
+            data: postedDate.toISOString(),
+            valor: amount,
+            descricao: description,
+        };
+    }
     async listCostCenters() {
         const costCenters = await this.prisma.cost_center.findMany({
             orderBy: [{ code: 'asc' }, { name: 'asc' }],
@@ -1035,9 +1454,17 @@ let FinanceService = FinanceService_1 = class FinanceService {
         });
         return Object.assign(Object.assign({}, paginated), { data: (paginated.data || []).map((period) => this.mapPeriodCloseToFront(period)) });
     }
-    async listBankStatements(bankAccountId) {
+    async listBankStatements(bankAccountId, search) {
+        const trimmedSearch = search === null || search === void 0 ? void 0 : search.trim();
         const statements = await this.prisma.bank_statement_line.findMany({
-            where: Object.assign({}, (bankAccountId ? { bank_account_id: bankAccountId } : {})),
+            where: Object.assign(Object.assign({}, (bankAccountId ? { bank_account_id: bankAccountId } : {})), (trimmedSearch
+                ? {
+                    description: {
+                        contains: trimmedSearch,
+                        mode: 'insensitive',
+                    },
+                }
+                : {})),
             include: {
                 bank_account: {
                     select: {
@@ -1057,8 +1484,74 @@ let FinanceService = FinanceService_1 = class FinanceService {
             statusConciliacao: this.mapStatementStatusToPt(statement.status),
         }));
     }
-    async exportBankStatementsCsv(bankAccountId) {
-        const statements = await this.listBankStatements(bankAccountId);
+    async getBankReconciliationSummary(bankAccountId) {
+        const pendingStatements = await this.prisma.bank_statement_line.findMany({
+            where: {
+                bank_account_id: bankAccountId,
+                status: {
+                    in: ['pending', 'imported'],
+                },
+            },
+            select: {
+                amount_cents: true,
+            },
+        });
+        const openInstallments = await this.prisma.financial_installment.findMany({
+            where: {
+                open_amount_cents: {
+                    gt: 0,
+                },
+                status: {
+                    in: ['open', 'partial', 'overdue'],
+                },
+                financial_title: {
+                    status: {
+                        in: ['open', 'partial', 'overdue'],
+                    },
+                    title_type: {
+                        in: ['payable', 'receivable'],
+                    },
+                },
+            },
+            select: {
+                open_amount_cents: true,
+                financial_title: {
+                    select: {
+                        title_type: true,
+                    },
+                },
+            },
+        });
+        const payableAmounts = new Set();
+        const receivableAmounts = new Set();
+        for (const installment of openInstallments) {
+            const amount = Math.abs(installment.open_amount_cents);
+            if (installment.financial_title.title_type === 'payable') {
+                payableAmounts.add(amount);
+            }
+            else if (installment.financial_title.title_type === 'receivable') {
+                receivableAmounts.add(amount);
+            }
+        }
+        let discrepancyCount = 0;
+        let differenceCents = 0;
+        for (const statement of pendingStatements) {
+            const normalizedAmount = Math.abs(statement.amount_cents);
+            differenceCents += statement.amount_cents;
+            const hasPossibleMatch = statement.amount_cents < 0
+                ? payableAmounts.has(normalizedAmount)
+                : receivableAmounts.has(normalizedAmount);
+            if (!hasPossibleMatch) {
+                discrepancyCount += 1;
+            }
+        }
+        return {
+            discrepancies: discrepancyCount,
+            difference: this.fromCents(differenceCents),
+        };
+    }
+    async exportBankStatementsCsv(bankAccountId, search) {
+        const statements = await this.listBankStatements(bankAccountId, search);
         const headers = [
             'id',
             'data',
@@ -1089,6 +1582,66 @@ let FinanceService = FinanceService_1 = class FinanceService {
             fileName,
         };
     }
+    async createBankStatementAdjustment(data, userId) {
+        var _a;
+        const bankAccountId = Number(data.bank_account_id);
+        const amount = Number(data.amount);
+        const postedAt = data.date ? new Date(data.date) : new Date();
+        if (Number.isNaN(bankAccountId) || bankAccountId <= 0) {
+            throw new common_1.BadRequestException('bank_account_id is required');
+        }
+        if (Number.isNaN(amount) || amount <= 0) {
+            throw new common_1.BadRequestException('amount must be greater than zero');
+        }
+        if (Number.isNaN(postedAt.getTime())) {
+            throw new common_1.BadRequestException('Invalid adjustment date');
+        }
+        const bankAccount = await this.prisma.bank_account.findUnique({
+            where: { id: bankAccountId },
+            select: { id: true },
+        });
+        if (!bankAccount) {
+            throw new common_1.NotFoundException('Bank account not found');
+        }
+        const adjustedAmountCents = -Math.abs(this.toCents(amount));
+        const description = ((_a = data.description) === null || _a === void 0 ? void 0 : _a.trim()) || `Ajuste: ${data.type}`;
+        const reference = `adjustment:${Date.now()}-${Math.round(Math.random() * 1000000)}`;
+        const created = await this.prisma.$transaction(async (tx) => {
+            const statement = await tx.bank_statement.create({
+                data: {
+                    bank_account_id: bankAccountId,
+                    source_type: 'manual',
+                    imported_at: new Date(),
+                    imported_by_user_id: userId,
+                    idempotency_key: reference,
+                    period_start: postedAt,
+                    period_end: postedAt,
+                },
+            });
+            const line = await tx.bank_statement_line.create({
+                data: {
+                    bank_statement_id: statement.id,
+                    bank_account_id: bankAccountId,
+                    external_id: reference,
+                    posted_date: postedAt,
+                    amount_cents: adjustedAmountCents,
+                    description,
+                    status: 'adjusted',
+                    dedupe_key: reference,
+                },
+            });
+            return line;
+        });
+        return {
+            id: String(created.id),
+            contaBancariaId: String(created.bank_account_id),
+            data: created.posted_date.toISOString(),
+            descricao: created.description,
+            valor: this.fromCents(created.amount_cents),
+            tipo: created.amount_cents >= 0 ? 'entrada' : 'saida',
+            statusConciliacao: this.mapStatementStatusToPt(created.status),
+        };
+    }
     async importBankStatements(bankAccountId, file, locale, userId) {
         if (!file) {
             throw new common_1.BadRequestException('File is required');
@@ -2327,6 +2880,67 @@ let FinanceService = FinanceService_1 = class FinanceService {
                         created_by_user_id: userId,
                     },
                 });
+                let reconciliationId = null;
+                if (data.bank_statement_line_id) {
+                    const statementLine = await tx.bank_statement_line.findUnique({
+                        where: {
+                            id: data.bank_statement_line_id,
+                        },
+                        select: {
+                            id: true,
+                            bank_account_id: true,
+                            amount_cents: true,
+                            status: true,
+                        },
+                    });
+                    if (!statementLine) {
+                        throw new common_1.NotFoundException('Bank statement line not found');
+                    }
+                    if (data.bank_account_id &&
+                        statementLine.bank_account_id !== data.bank_account_id) {
+                        throw new common_1.ConflictException('Bank statement line does not belong to informed bank account');
+                    }
+                    if (Math.abs(statementLine.amount_cents) !== amountCents) {
+                        throw new common_1.ConflictException('Bank statement amount and settlement amount must match');
+                    }
+                    const hasReconciliation = await tx.bank_reconciliation.findFirst({
+                        where: {
+                            bank_statement_line_id: statementLine.id,
+                            status: 'reconciled',
+                        },
+                        select: {
+                            id: true,
+                        },
+                    });
+                    if (hasReconciliation) {
+                        throw new common_1.ConflictException('Bank statement line already reconciled');
+                    }
+                    const createdReconciliation = await tx.bank_reconciliation.create({
+                        data: {
+                            bank_statement_line_id: statementLine.id,
+                            settlement_id: settlement.id,
+                            status: 'reconciled',
+                            matched_at: settledAt,
+                            reconciled_at: settledAt,
+                            matched_by_user_id: userId || null,
+                            reconciled_by_user_id: userId || null,
+                        },
+                        select: {
+                            id: true,
+                        },
+                    });
+                    reconciliationId = createdReconciliation.id;
+                    if (statementLine.status !== 'reconciled') {
+                        await tx.bank_statement_line.update({
+                            where: {
+                                id: statementLine.id,
+                            },
+                            data: {
+                                status: 'reconciled',
+                            },
+                        });
+                    }
+                }
                 await tx.settlement_allocation.create({
                     data: {
                         settlement: {
@@ -2404,6 +3018,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
                         title_status: nextTitleStatus,
                         installment_open_amount_cents: updatedInstallment.open_amount_cents,
                         settlement_id: settlement.id,
+                        bank_reconciliation_id: reconciliationId,
                     }),
                 });
                 const updatedTitle = await tx.financial_title.findFirst({
@@ -2419,9 +3034,12 @@ let FinanceService = FinanceService_1 = class FinanceService {
                 return {
                     title: updatedTitle,
                     settlementId: settlement.id,
+                    reconciliationId,
                 };
             });
-            return Object.assign(Object.assign({}, this.mapTitleToFront(result.title)), { settlementId: String(result.settlementId) });
+            return Object.assign(Object.assign({}, this.mapTitleToFront(result.title)), { settlementId: String(result.settlementId), reconciliationId: result.reconciliationId
+                    ? String(result.reconciliationId)
+                    : null });
         }
         catch (error) {
             const message = String((error === null || error === void 0 ? void 0 : error.message) || '');
@@ -2923,7 +3541,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
         });
     }
     mapTitleToFront(title, paymentChannelOverride) {
-        var _a;
+        var _a, _b, _c;
         const allocations = title.financial_installment.flatMap((installment) => installment.installment_allocation);
         const firstCostCenter = (_a = allocations[0]) === null || _a === void 0 ? void 0 : _a.cost_center_id;
         const tags = [
@@ -2978,8 +3596,14 @@ let FinanceService = FinanceService_1 = class FinanceService {
                 : '', valorTotal: this.fromCents(title.total_amount_cents), status: this.mapStatusToPt(title.status), criadoEm: title.created_at.toISOString(), categoriaId: title.finance_category_id ? String(title.finance_category_id) : null, centroCustoId: firstCostCenter ? String(firstCostCenter) : null, anexos: attachmentDetails.map((attachment) => attachment.nome), anexosDetalhes: attachmentDetails, tags, parcelas: mappedInstallments, canal: this.mapPaymentMethodToPt(channelFromSettlement) ||
                 paymentChannelOverride ||
                 'transferencia' }, (title.title_type === 'payable'
-            ? { fornecedorId: String(title.person_id) }
-            : { clienteId: String(title.person_id) }));
+            ? {
+                fornecedorId: String(title.person_id),
+                fornecedor: ((_b = title.person) === null || _b === void 0 ? void 0 : _b.name) || '',
+            }
+            : {
+                clienteId: String(title.person_id),
+                cliente: ((_c = title.person) === null || _c === void 0 ? void 0 : _c.name) || '',
+            }));
     }
     defaultTitleInclude() {
         return {