@lomray/microservice-payment-stripe/services/dispute.js

Stripe payment microservice based on NodeJS & inverted json.

'use strict';

var tslib = require('tslib');
var microserviceHelpers = require('@lomray/microservice-helpers');
var microserviceNodejsLib = require('@lomray/microservice-nodejs-lib');
var Event = require('@lomray/microservices-client-api/constants/events/payment-stripe');
var remote = require('../config/remote.js');
var disputeStatus = require('../constants/dispute-status.js');
var dispute = require('../entities/dispute.js');
var transaction = require('../entities/transaction.js');
var parser = require('./parser.js');

/**
 * Dispute
 */
class Dispute {
    /**
     * Update dispute entity by Stripe dispute
     */
    static update(disputeEntity, { evidence_details: evidenceDetails, amount, status, reason, is_charge_refundable: isChargeRefundable, metadata, balance_transactions: balanceTransactions, }, manager) {
        var _a, _b, _c;
        return tslib.__awaiter(this, void 0, void 0, function* () {
            disputeEntity.amount = amount;
            disputeEntity.metadata = metadata;
            disputeEntity.params.balanceTransactionId = (_a = balanceTransactions === null || balanceTransactions === void 0 ? void 0 : balanceTransactions[0]) === null || _a === void 0 ? void 0 : _a.id;
            disputeEntity.params.isChargeRefundable = isChargeRefundable;
            disputeEntity.evidenceDetails.submissionCount = evidenceDetails.submission_count;
            disputeEntity.evidenceDetails.isPastBy = evidenceDetails.past_due;
            disputeEntity.evidenceDetails.hasEvidence = evidenceDetails.has_evidence;
            disputeEntity.reason = parser.parseStripeDisputeReason(reason);
            const disputeStatus$1 = parser.parseStripeDisputeStatus(status);
            // Stripe can send under review status after won or lost dispute
            if (![disputeStatus.LOST, disputeStatus.WON].includes(disputeEntity.status)) {
                disputeEntity.status = disputeStatus$1;
            }
            if (evidenceDetails.due_by) {
                disputeEntity.evidenceDetails.dueBy = new Date(evidenceDetails.due_by * 1000);
            }
            const { chargedFees, chargedAmount, netWorth } = Dispute.getChargedAmounts(balanceTransactions);
            disputeEntity.chargedFees = chargedFees;
            disputeEntity.chargedAmount = chargedAmount;
            disputeEntity.netWorth = netWorth;
            disputeEntity.params.currentDisputeFee =
                // If dispute is injury fees will not be charged
                chargedFees || ((_c = (_b = (yield remote())) === null || _b === void 0 ? void 0 : _b.fees) === null || _c === void 0 ? void 0 : _c.stableDisputeFeeUnit) || 0;
            yield manager.getRepository(dispute).save(disputeEntity);
            yield Dispute.updateTransactionsDisputeStatus(manager, disputeEntity.transactionId);
        });
    }
    /**
     * Returns total dispute charged amounts
     */
    static getChargedAmounts(balanceTransactions) {
        return balanceTransactions.reduce((acc, transaction) => {
            acc.chargedFees = (acc.chargedFees || 0) + transaction.fee;
            acc.chargedAmount = (acc.chargedAmount || 0) + transaction.amount;
            acc.netWorth = (acc.netWorth || 0) + transaction.net;
            return acc;
        }, { chargedFees: 0, chargedAmount: 0, netWorth: 0 });
    }
    /**
     * Handle after create
     */
    static handleAfterCreate(entity, manager) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            yield Promise.all([
                Dispute.updateTransactionsDisputeStatus(manager, entity.transactionId),
                microserviceNodejsLib.Microservice.eventPublish(Event.DisputeCreated, entity),
            ]);
        });
    }
    /**
     * Handle after update
     */
    static handleAfterUpdate(entity) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            yield microserviceNodejsLib.Microservice.eventPublish(Event.DisputeUpdated, entity);
        });
    }
    /**
     * Update transactions dispute status
     */
    static updateTransactionsDisputeStatus(manager, transactionId) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            if (!transactionId) {
                return;
            }
            const transactionRepository = manager.getRepository(transaction);
            const transactions = yield transactionRepository.find({
                where: {
                    transactionId,
                },
            });
            if (!transactions.length) {
                microserviceHelpers.Log.error('Failed to update transaction dispute status. Transactions were not found.');
                return;
            }
            let isUpdated = false;
            transactions.forEach((transaction) => {
                if (transaction.isDisputed) {
                    return;
                }
                transaction.isDisputed = true;
                isUpdated = true;
            });
            if (!isUpdated) {
                return;
            }
            yield transactionRepository.save(transactions);
        });
    }
}

module.exports = Dispute;