@misterhomer1992/miit-bot-payment 1.1.6 → 2.0.4

package/src/modules/payments/service.ts

@@ -0,0 +1,365 @@
+import moment from 'moment';
+import { Logger } from '../logger/types';
+import { PaymentRepository } from './repository';
+import { PaymentEntity, IPaymentRepository, IPaymentService, SignatureValidationResult } from './types';
+import { createPaymentAPI, createTokenPackPaymentAPI, createUpgradePaymentAPI } from './api';
+import { WayForPayService } from './wayforpay.service';
+import type { IWayForPayService, WayForPayCallbackData } from './wayforpay.types';
+
+export class PaymentService implements IPaymentService {
+    private readonly logger: Logger;
+    private readonly repository: IPaymentRepository;
+    private readonly wayForPayService: IWayForPayService;
+
+    constructor({
+        logger,
+        repository,
+        wayForPayService,
+    }: {
+        logger: Logger;
+        repository?: IPaymentRepository;
+        wayForPayService?: IWayForPayService;
+    }) {
+        this.logger = logger;
+        this.repository = repository || new PaymentRepository();
+        this.wayForPayService = wayForPayService || new WayForPayService({ logger });
+    }
+
+    public async getByOrderReference(orderReference: string): Promise<PaymentEntity | null> {
+        try {
+            return await this.repository.getByOrderReference(orderReference);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service getByOrderReference',
+                payload: {
+                    orderReference,
+                    error: JSON.stringify(error),
+                },
+            });
+            return null;
+        }
+    }
+
+    public async getByUser(params: {
+        userId: string;
+        platform: string;
+        status?: PaymentEntity['status'];
+    }): Promise<PaymentEntity[]> {
+        try {
+            return await this.repository.getByUser(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service getByUser',
+                payload: {
+                    userId: params.userId,
+                    platform: params.platform,
+                    status: params.status,
+                    error: JSON.stringify(error),
+                },
+            });
+            return [];
+        }
+    }
+
+    public async create(paymentData: Omit<PaymentEntity, 'id'>): Promise<PaymentEntity> {
+        try {
+            return await this.repository.create(paymentData);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service create',
+                payload: {
+                    orderReference: paymentData.orderReference,
+                    userId: paymentData.userId,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+
+    public async updateStatus({ id, status }: { id: string; status: PaymentEntity['status'] }): Promise<void> {
+        try {
+            await this.repository.updateFields({
+                id,
+                fields: [['status', status]],
+            });
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service updateStatus',
+                payload: {
+                    id,
+                    status,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+
+    public async changeStatus({ id, status }: { id: string; status: PaymentEntity['status'] }): Promise<void> {
+        return this.updateStatus({ id, status });
+    }
+
+    public async getExpiredPendingPayments(
+        params: {
+            hoursOld?: number;
+        } = {},
+    ): Promise<PaymentEntity[]> {
+        try {
+            return await this.repository.getExpiredPendingPayments(params);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service getExpiredPendingPayments',
+                payload: {
+                    hoursOld: params.hoursOld,
+                    error: JSON.stringify(error),
+                },
+            });
+            return [];
+        }
+    }
+
+    public async createPaymentIntent(params: {
+        userId: string;
+        platform: string;
+        planId: string;
+        productName: string;
+        productPrice: number;
+        currency: 'UAH' | 'USD';
+        regularCount?: number;
+        regularMode?: 'daily' | 'weekly' | 'monthly' | 'yearly';
+        language?: string;
+    }): Promise<PaymentEntity> {
+        const { userId, platform, planId, productName, productPrice, currency, regularCount, regularMode, language } =
+            params;
+
+        try {
+            // Step 1: Create payment URL from Wayforpay API
+            // This also generates a unique order reference
+            const paymentResponse = await createPaymentAPI({
+                userId,
+                platform,
+                productName,
+                productPrice,
+                planId,
+                currency,
+                regularCount,
+                regularMode,
+                language,
+            });
+
+            if (!paymentResponse?.url || !paymentResponse?.orderReference) {
+                throw new Error('Failed to get payment URL or order reference from Wayforpay');
+            }
+
+            // Step 2: Create payment record in database
+            const paymentEntity = await this.repository.create({
+                orderReference: paymentResponse.orderReference,
+                userId,
+                status: 'pending',
+                paymentLink: paymentResponse.url,
+                planId,
+                paymentType: 'subscription',
+                amount: productPrice,
+                currency,
+                createdAt: moment.utc().toISOString(),
+                platform: platform,
+                provider: 'wayforpay',
+            });
+
+            return paymentEntity;
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service createPaymentIntent',
+                payload: {
+                    userId,
+                    platform,
+                    planId,
+                    productName,
+                    productPrice,
+                    currency,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+
+    public async createTokenPackPaymentIntent(params: {
+        userId: string;
+        platform: string;
+        packId: string;
+        productName: string;
+        productPrice: number;
+        currency: 'UAH' | 'USD';
+        language?: string;
+        returnUrl?: string;
+    }): Promise<PaymentEntity> {
+        const { userId, platform, packId, productName, productPrice, currency, language, returnUrl } = params;
+
+        try {
+            // Step 1: Create payment URL from Wayforpay API for token pack
+            const paymentResponse = await createTokenPackPaymentAPI({
+                userId,
+                platform,
+                productName,
+                productPrice,
+                packId,
+                currency,
+                language,
+                returnUrl,
+            });
+
+            if (!paymentResponse?.url || !paymentResponse?.orderReference) {
+                throw new Error('Failed to get payment URL or order reference from Wayforpay for token pack');
+            }
+
+            // Step 2: Create payment record in database
+            const paymentEntity = await this.repository.create({
+                orderReference: paymentResponse.orderReference,
+                userId,
+                status: 'pending',
+                paymentLink: paymentResponse.url,
+                planId: packId,
+                paymentType: 'token_pack',
+                amount: productPrice,
+                currency,
+                createdAt: moment.utc().toISOString(),
+                platform: platform,
+                provider: 'wayforpay',
+            });
+
+            return paymentEntity;
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service createTokenPackPaymentIntent',
+                payload: {
+                    userId,
+                    platform,
+                    packId,
+                    productName,
+                    productPrice,
+                    currency,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+
+    public validateSignature(callbackData: {
+        merchantAccount: string;
+        orderReference: string;
+        amount: number;
+        currency: string;
+        authCode: string;
+        cardPan: string;
+        transactionStatus: string;
+        reasonCode: string | number;
+        merchantSignature: string;
+    }): SignatureValidationResult {
+        try {
+            const result = this.wayForPayService.verifyCallbackSignature(callbackData as WayForPayCallbackData);
+            return {
+                isValid: result.isValid,
+                error: result.error,
+            };
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service validateSignature',
+                payload: {
+                    orderReference: callbackData.orderReference,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            return {
+                isValid: false,
+                error: 'Error validating signature',
+            };
+        }
+    }
+
+    public async createUpgradePaymentIntent(params: {
+        userId: string;
+        platform: string;
+        currentPlanId: string;
+        newPlanId: string;
+        productName: string;
+        upgradeCost: number;
+        currency: 'UAH' | 'USD';
+        regularMode?: 'daily' | 'monthly' | 'yearly';
+        regularCount?: number;
+        language?: string;
+    }): Promise<PaymentEntity> {
+        const {
+            userId,
+            platform,
+            currentPlanId,
+            newPlanId,
+            productName,
+            upgradeCost,
+            currency,
+            regularMode,
+            regularCount,
+            language,
+        } = params;
+
+        try {
+            // Step 1: Create payment URL from Wayforpay API for upgrade
+            const paymentResponse = await createUpgradePaymentAPI({
+                userId,
+                platform,
+                currentPlanId,
+                newPlanId,
+                productName,
+                productPrice: upgradeCost,
+                currency,
+                regularMode,
+                regularCount,
+                language,
+            });
+
+            if (!paymentResponse?.url || !paymentResponse?.orderReference) {
+                throw new Error('Failed to get payment URL or order reference from Wayforpay for upgrade');
+            }
+
+            // Step 2: Create payment record in database
+            const paymentEntity = await this.repository.create({
+                orderReference: paymentResponse.orderReference,
+                userId,
+                status: 'pending',
+                paymentLink: paymentResponse.url,
+                planId: newPlanId,
+                paymentType: 'subscription_upgrade',
+                amount: upgradeCost,
+                currency,
+                createdAt: moment.utc().toISOString(),
+                platform: platform,
+                provider: 'wayforpay',
+            });
+
+            return paymentEntity;
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in payment service createUpgradePaymentIntent',
+                payload: {
+                    userId,
+                    platform,
+                    currentPlanId,
+                    newPlanId,
+                    productName,
+                    upgradeCost,
+                    currency,
+                    error: JSON.stringify(error),
+                },
+            });
+
+            throw error;
+        }
+    }
+}