@duvdu-v1/duvdu 1.1.267 → 1.1.269

package/build/services/paymob.service.d.ts

@@ -1,203 +1,21 @@
-interface PaymobMerchant {
-    id: number;
-    created_at: string;
-    phones: string[];
-    company_emails: string[];
-    company_name: string;
-    state: string;
-    country: string;
-    city: string;
-    postal_code: string;
-    street: string;
-}
-interface PaymobOrder {
-    id: number;
-    created_at: string;
-    delivery_needed: boolean;
-    merchant: PaymobMerchant;
-    collector: null;
-    amount_cents: number;
-    shipping_data: null;
-    currency: string;
-    is_payment_locked: boolean;
-    is_return: boolean;
-    is_cancel: boolean;
-    is_returned: boolean;
-    is_canceled: boolean;
-    merchant_order_id: string;
-    wallet_notification: null;
-    paid_amount_cents: number;
-    notify_user_with_email: boolean;
-    items: PaymobOrderItem[];
-    order_url: string;
-    commission_fee: number;
-    delivery_fee_cents: number;
-    delivery_voucher_cost: number;
-    discount: number;
-    metadata: Record<string, any>;
-}
-interface PaymobOrderItem {
-    name: string;
-    description: string;
-    amount: number;
-    quantity: number;
-}
-interface PaymobSourceData {
-    type: string;
-    pan: string;
-    sub_type: string;
-}
-interface PaymobWebhookData {
-    obj: {
-        id: number;
-        amount_cents: number;
-        success: boolean;
-        is_refunded: boolean;
-        is_captured: boolean;
-        is_voided: boolean;
-        is_standalone_payment: boolean;
-        is_void: boolean;
-        is_refund: boolean;
-        is_3d_secure: boolean;
-        integration_id: number;
-        profile_id: number;
-        has_parent_transaction: boolean;
-        order: PaymobOrder;
-        created_at: string;
-        transaction_processed_callback_responses: null;
-        currency: string;
-        source_data: PaymobSourceData;
-        api_source: string;
-        terminal_id: string;
-        merchant_commission: number;
-        merchant_staff_tag: null;
-        hmac: string;
-    };
-}
-interface PaymobBillingData {
-    first_name: string;
-    last_name: string;
-    email: string;
-    phone_number: string;
-    apartment: string;
-    floor: string;
-    street: string;
-    building: string;
-    city?: string;
-    state: string;
-    country: string;
-}
-interface TransactionData {
-    orderId: number;
-    amount: number;
-    success: boolean;
-    currency: string;
-    transactionId: number;
-    createdAt: string;
-    isRefunded: boolean;
-    isCaptured: boolean;
-    isVoided: boolean;
-    metadata: Record<string, any>;
-}
-interface WebhookQueryTransactionData extends TransactionData {
-    isAuth: boolean;
-    isStandalone: boolean;
-    is3dSecure: boolean;
-    sourceData: {
-        type: string;
-        pan: string;
-        subType: string;
-    };
-    responseCode: string;
-    message: string;
-}
-interface WebhookQueryWithItemsTransactionData extends WebhookQueryTransactionData {
-    items: PaymobOrderItem[];
-}
-interface WebhookResult<T> {
-    isValid: boolean;
-    transactionData: T | null;
-}
-interface TransactionStatusResult {
-    success: boolean;
-    status: string;
-    amount: number;
-    currency: string;
-}
-interface OrderDetailsResult {
-    id: number;
-    amount_cents: number;
-    currency: string;
-    items: PaymobOrderItem[];
-    created_at: string;
-    merchant_order_id: string;
-}
-/**
- * Paymob Service Configuration for Flash Integration
- *
- * Required Keys:
- * - secretKey: Your Paymob Secret Key (for API authentication)
- * - publicKey: Your Paymob Public Key (for client-side)
- * - integrationId: Your Paymob Integration ID
- * - hmacSecret: Your Paymob HMAC Secret (for webhook verification)
- */
+import { PaymobWebhookData, WebhookResult, TransactionData, WebhookQueryTransactionData, OrderDetailsResult, TransactionStatusResult, PaymentIntentionResult, UserPaymentData, PaymobBillingData, PaymobOrderItem, WebhookQueryWithItemsTransactionData } from '../types/paymob.types';
 export declare class PaymobService {
-    private readonly secretKey;
-    private readonly publicKey;
-    private readonly integrationId;
-    private readonly baseUrl;
-    private readonly hmacSecret;
+    private readonly config;
+    private readonly auth;
+    private readonly webhookHandler;
+    private readonly orderManager;
+    private readonly paymentProcessor;
     constructor();
-    /**
-     * Creates a payment intention using the Flash API
-     * @param amount The payment amount
-     * @param billingData The user data for billing
-     * @param items The order items
-     * @param currency The currency code (default: EGP)
-     * @param extras Custom metadata
-     * @returns The payment URL and client secret
-     */
-    createPaymentIntention(amount: number, billingData: PaymobBillingData, items: PaymobOrderItem[], currency?: string, extras?: Record<string, any>): Promise<{
-        paymentUrl: string;
-        clientSecret: string;
-    }>;
-    /**
-     * Creates a payment URL with user data and custom metadata
-     * @param amount The payment amount
-     * @param userId The user ID
-     * @param contractId The contract ID
-     * @param userData The user data for billing
-     * @param serviceType The service type identifier
-     * @returns The payment URL and related data
-     */
-    createPaymentUrlWithUserData(amount: number, userId: string, contractId: string, userData: {
-        firstName: string;
-        lastName: string;
-        email: string;
-        phone: string;
-    }, serviceType: string): Promise<{
+    createPaymentIntention(amount: number, billingData: PaymobBillingData, items: PaymobOrderItem[], currency?: string, extras?: Record<string, any>): Promise<PaymentIntentionResult>;
+    createPaymentUrlWithUserData(amount: number, userId: string, contractId: string, userData: UserPaymentData, serviceType: string): Promise<{
         paymentUrl: string;
     }>;
     verifyPayment(hmac: string, data: Record<string, any>): Promise<boolean>;
-    /**
-     * Verify webhook HMAC signature for query parameters
-     * Uses the correct field order as per Paymob documentation
-     */
     verifyWebhookHmac(queryParams: Record<string, string>): boolean;
     handleWebhook(webhookData: PaymobWebhookData): Promise<WebhookResult<TransactionData>>;
-    /**
-     * Handle webhook with query parameters (GET request)
-     * This is for webhooks that come as URL query parameters instead of JSON body
-     */
     handleWebhookQuery(queryParams: Record<string, string>): WebhookResult<WebhookQueryTransactionData>;
+    handleWebhookQueryWithItems(queryParams: Record<string, string>): Promise<WebhookResult<WebhookQueryWithItemsTransactionData>>;
     getTransactionStatus(transactionId: number): Promise<TransactionStatusResult>;
-    /**
-     * Get order details including metadata
-     */
     getOrderDetails(orderId: number): Promise<OrderDetailsResult>;
-    /**
-     * Handle webhook query and fetch items from order
-     */
-    handleWebhookQueryWithItems(queryParams: Record<string, string>): Promise<WebhookResult<WebhookQueryWithItemsTransactionData>>;
+    getAuthToken(): Promise<string>;
 }
-export {};

package/build/services/paymob.service.js

@@ -38,171 +38,108 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaymobService = void 0;
 const crypto = __importStar(require("crypto"));
 const axios_1 = __importDefault(require("axios"));
-/**
- * Paymob Service Configuration for Flash Integration
- *
- * Required Keys:
- * - secretKey: Your Paymob Secret Key (for API authentication)
- * - publicKey: Your Paymob Public Key (for client-side)
- * - integrationId: Your Paymob Integration ID
- * - hmacSecret: Your Paymob HMAC Secret (for webhook verification)
- */
-class PaymobService {
+class PaymobConfig {
     constructor() {
+        this.validateEnvironmentVariables();
+        this.apiKey = process.env.PAYMOB_API_KEY;
         this.secretKey = process.env.PAYMOB_SECRET_KEY;
         this.publicKey = process.env.PAYMOB_PUBLIC_KEY;
         this.integrationId = parseInt(process.env.PAYMOB_INTEGRATION_ID);
         this.baseUrl = process.env.PAYMOB_BASE_URL || 'https://accept.paymob.com';
         this.hmacSecret = process.env.PAYMOB_HMAC_SECRET;
-        console.log('PayMob configuration:', {
+        this.logConfiguration();
+    }
+    /**
+     * Validates that all required environment variables are present
+     */
+    validateEnvironmentVariables() {
+        const requiredVars = [
+            'PAYMOB_API_KEY',
+            'PAYMOB_SECRET_KEY',
+            'PAYMOB_PUBLIC_KEY',
+            'PAYMOB_INTEGRATION_ID',
+            'PAYMOB_HMAC_SECRET',
+        ];
+        const missingVars = requiredVars.filter((varName) => !process.env[varName]);
+        if (missingVars.length > 0) {
+            throw new Error(`Missing required environment variables: ${missingVars.join(', ')}`);
+        }
+    }
+    /**
+     * Logs configuration details (without sensitive data)
+     */
+    logConfiguration() {
+        console.log('PayMob configuration initialized:', {
             integrationId: this.integrationId,
             publicKey: this.publicKey,
             baseUrl: this.baseUrl,
         });
     }
+}
+// ===========================
+// AUTHENTICATION CLASS
+// ===========================
+/**
+ * Handles Paymob authentication operations
+ */
+class PaymobAuth {
+    constructor(config) {
+        this.config = config;
+    }
     /**
-     * Creates a payment intention using the Flash API
-     * @param amount The payment amount
-     * @param billingData The user data for billing
-     * @param items The order items
-     * @param currency The currency code (default: EGP)
-     * @param extras Custom metadata
-     * @returns The payment URL and client secret
+     * Authenticate with Paymob to get Bearer token
+     * @returns Promise<string> Authentication token
      */
-    createPaymentIntention(amount, billingData, items, currency = 'EGP', extras) {
-        var _a;
+    getAuthToken() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const intentionData = {
-                    amount,
-                    currency,
-                    payment_methods: [this.integrationId, 'card'],
-                    items,
-                    billing_data: billingData,
-                    customer: {
-                        first_name: billingData.first_name,
-                        last_name: billingData.last_name,
-                        email: billingData.email,
-                        extras: extras || {},
-                    },
-                    extras: extras || {},
-                };
-                const response = yield axios_1.default.post(`${this.baseUrl}/v1/intention/`, intentionData, {
-                    headers: {
-                        'Authorization': `Token ${this.secretKey}`,
-                        'Content-Type': 'application/json',
-                    },
+                const response = yield axios_1.default.post(`${this.config.baseUrl}/api/auth/tokens`, {
+                    api_key: this.config.apiKey,
                 });
-                // Create the payment URL for Flash Checkout
-                const paymentUrl = `${this.baseUrl}/unifiedcheckout/?publicKey=${this.publicKey}&clientSecret=${response.data.client_secret}`;
-                return {
-                    paymentUrl,
-                    clientSecret: response.data.client_secret,
-                };
+                return response.data.token;
             }
             catch (error) {
                 const axiosError = error;
-                console.log('PayMob intention error:', (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.data);
-                throw new Error(`Failed to create Paymob payment intention: ${axiosError.message}`);
+                throw new Error(`Failed to get Paymob auth token: ${axiosError.message}`);
             }
         });
     }
     /**
-     * Creates a payment URL with user data and custom metadata
-     * @param amount The payment amount
-     * @param userId The user ID
-     * @param contractId The contract ID
-     * @param userData The user data for billing
-     * @param serviceType The service type identifier
-     * @returns The payment URL and related data
+     * Get authorization headers for API requests
+     * @returns Promise<Record<string, string>> Headers object
      */
-    createPaymentUrlWithUserData(amount, userId, contractId, userData, serviceType) {
-        var _a;
+    getAuthHeaders() {
         return __awaiter(this, void 0, void 0, function* () {
-            // Create metadata with custom data
-            const customData = {
-                contractId,
-                userId,
-                service_type: serviceType,
-                booking_id: 'BOOK_' + Date.now(),
-                timestamp: new Date().toISOString(),
-            };
-            const extras = customData;
-            const billingData = {
-                first_name: userData.firstName,
-                last_name: userData.lastName,
-                email: userData.email,
-                phone_number: userData.phone,
-                apartment: '123',
-                floor: '1',
-                street: '123 Main St',
-                building: '123',
-                state: 'Cairo',
-                country: 'EGY',
+            return {
+                Authorization: `Token ${this.config.secretKey}`,
+                'Content-Type': 'application/json',
             };
-            const items = [
-                {
-                    name: `${serviceType} Payment`,
-                    description: `Payment for contract ${contractId}`,
-                    amount,
-                    quantity: 1,
-                },
-            ];
-            // For Flash Integration, we need to create a modified intention request
-            // that includes merchant_order_id
-            const intentionData = {
-                amount,
-                currency: 'EGP',
-                payment_methods: [this.integrationId, 'card'],
-                items,
-                billing_data: billingData,
-                customer: {
-                    first_name: billingData.first_name,
-                    last_name: billingData.last_name,
-                    email: billingData.email,
-                    extras: extras || {},
-                },
-                extras: extras || {},
-                merchant_order_id: JSON.stringify(customData), // Store custom data here
-            };
-            try {
-                const response = yield axios_1.default.post(`${this.baseUrl}/v1/intention/`, intentionData, {
-                    headers: {
-                        'Authorization': `Token ${this.secretKey}`,
-                        'Content-Type': 'application/json',
-                    },
-                });
-                // Create the payment URL for Flash Checkout
-                const paymentUrl = `${this.baseUrl}/unifiedcheckout/?publicKey=${this.publicKey}&clientSecret=${response.data.client_secret}`;
-                return { paymentUrl };
-            }
-            catch (error) {
-                const axiosError = error;
-                console.log('PayMob intention error:', (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.data);
-                throw new Error(`Failed to create Paymob payment intention: ${axiosError.message}`);
-            }
         });
     }
-    verifyPayment(hmac, data) {
+    /**
+     * Get bearer token headers for API requests
+     * @returns Promise<Record<string, string>> Headers object with bearer token
+     */
+    getBearerHeaders() {
         return __awaiter(this, void 0, void 0, function* () {
-            const concatenatedString = Object.entries(data)
-                .sort()
-                .map(([key, value]) => `${key}=${value}`)
-                .join('');
-            const calculatedHmac = crypto
-                .createHmac('sha512', this.secretKey)
-                .update(concatenatedString)
-                .digest('hex');
-            return calculatedHmac === hmac;
+            const authToken = yield this.getAuthToken();
+            return {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${authToken}`,
+            };
         });
     }
-    /**
-     * Verify webhook HMAC signature for query parameters
-     * Uses the correct field order as per Paymob documentation
-     */
-    verifyWebhookHmac(queryParams) {
-        // Define the exact order of fields for HMAC calculation as per Paymob docs
-        const orderedFields = [
+}
+// ===========================
+// WEBHOOK HANDLER CLASS
+// ===========================
+/**
+ * Handles Paymob webhook operations and verification
+ */
+class PaymobWebhookHandler {
+    constructor(config) {
+        this.config = config;
+        this.WEBHOOK_FIELD_ORDER = [
             'amount_cents',
             'created_at',
             'currency',
@@ -224,36 +161,53 @@ class PaymobService {
             'source_data.type',
             'success',
         ];
-        // Concatenate values in the exact order (no keys, just values)
-        const concatenatedString = orderedFields.map((field) => queryParams[field] || '').join('');
-        // Calculate HMAC using the secret key
+    }
+    /**
+     * Verify payment using HMAC signature
+     * @param hmac HMAC signature to verify
+     * @param data Payment data to verify
+     * @returns Promise<boolean> Verification result
+     */
+    verifyPayment(hmac, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const concatenatedString = Object.entries(data)
+                .sort()
+                .map(([key, value]) => `${key}=${value}`)
+                .join('');
+            const calculatedHmac = crypto
+                .createHmac('sha512', this.config.secretKey)
+                .update(concatenatedString)
+                .digest('hex');
+            return calculatedHmac === hmac;
+        });
+    }
+    /**
+     * Verify webhook HMAC signature for query parameters
+     * Uses the correct field order as per Paymob documentation
+     * @param queryParams Query parameters from webhook
+     * @returns boolean Verification result
+     */
+    verifyWebhookHmac(queryParams) {
+        const concatenatedString = this.WEBHOOK_FIELD_ORDER.map((field) => queryParams[field] || '').join('');
         const calculatedHmac = crypto
-            .createHmac('sha512', this.hmacSecret)
+            .createHmac('sha512', this.config.hmacSecret)
             .update(concatenatedString)
             .digest('hex');
         return calculatedHmac === queryParams.hmac;
     }
+    /**
+     * Handle webhook with JSON data (POST request)
+     * @param webhookData Webhook data from Paymob
+     * @returns Promise<WebhookResult<TransactionData>> Webhook processing result
+     */
     handleWebhook(webhookData) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                // Verify the webhook signature
                 const isValid = yield this.verifyPayment(webhookData.obj.hmac, webhookData.obj);
                 if (!isValid) {
                     return { isValid: false, transactionData: null };
                 }
-                // Extract relevant transaction data
-                const transactionData = {
-                    orderId: webhookData.obj.order.id,
-                    amount: webhookData.obj.amount_cents / 100, // Convert from cents to actual currency
-                    success: webhookData.obj.success,
-                    currency: webhookData.obj.currency,
-                    transactionId: webhookData.obj.id,
-                    createdAt: webhookData.obj.created_at,
-                    isRefunded: webhookData.obj.is_refunded,
-                    isCaptured: webhookData.obj.is_captured,
-                    isVoided: webhookData.obj.is_voided,
-                    metadata: webhookData.obj.order.metadata || {},
-                };
+                const transactionData = this.extractTransactionData(webhookData);
                 return { isValid: true, transactionData };
             }
             catch (error) {
@@ -264,38 +218,16 @@ class PaymobService {
     }
     /**
      * Handle webhook with query parameters (GET request)
-     * This is for webhooks that come as URL query parameters instead of JSON body
+     * @param queryParams Query parameters from webhook URL
+     * @returns WebhookResult<WebhookQueryTransactionData> Webhook processing result
      */
     handleWebhookQuery(queryParams) {
         try {
-            // Verify the webhook HMAC signature
             const isValid = this.verifyWebhookHmac(queryParams);
             if (!isValid) {
                 return { isValid: false, transactionData: null };
             }
-            // Extract and parse transaction data from query parameters
-            const transactionData = {
-                orderId: parseInt(queryParams.order || '0'),
-                amount: parseInt(queryParams.amount_cents || '0') / 100, // Convert from cents
-                success: queryParams.success === 'true',
-                currency: queryParams.currency || 'EGP',
-                transactionId: parseInt(queryParams.id || '0'),
-                createdAt: queryParams.created_at || '',
-                isRefunded: queryParams.is_refunded === 'true',
-                isCaptured: queryParams.is_capture === 'true',
-                isVoided: queryParams.is_voided === 'true',
-                isAuth: queryParams.is_auth === 'true',
-                isStandalone: queryParams.is_standalone_payment === 'true',
-                is3dSecure: queryParams.is_3d_secure === 'true',
-                sourceData: {
-                    type: queryParams['source_data.type'] || '',
-                    pan: queryParams['source_data.pan'] || '',
-                    subType: queryParams['source_data.sub_type'] || '',
-                },
-                responseCode: queryParams.txn_response_code || '',
-                message: queryParams['data.message'] || '',
-                metadata: {}, // Adding the missing metadata property
-            };
+            const transactionData = this.extractQueryTransactionData(queryParams);
             return { isValid: true, transactionData };
         }
         catch (error) {
@@ -303,15 +235,99 @@ class PaymobService {
             throw new Error(`Failed to handle webhook query: ${errorMessage}`);
         }
     }
+    /**
+     * Extract transaction data from webhook JSON data
+     * @private
+     */
+    extractTransactionData(webhookData) {
+        return {
+            orderId: webhookData.obj.order.id,
+            amount: webhookData.obj.amount_cents / 100,
+            success: webhookData.obj.success,
+            currency: webhookData.obj.currency,
+            transactionId: webhookData.obj.id,
+            createdAt: webhookData.obj.created_at,
+            isRefunded: webhookData.obj.is_refunded,
+            isCaptured: webhookData.obj.is_captured,
+            isVoided: webhookData.obj.is_voided,
+            metadata: webhookData.obj.order.metadata || {},
+        };
+    }
+    /**
+     * Extract transaction data from webhook query parameters
+     * @private
+     */
+    extractQueryTransactionData(queryParams) {
+        return {
+            orderId: parseInt(queryParams.order || '0'),
+            amount: parseInt(queryParams.amount_cents || '0') / 100,
+            success: queryParams.success === 'true',
+            currency: queryParams.currency || 'EGP',
+            transactionId: parseInt(queryParams.id || '0'),
+            createdAt: queryParams.created_at || '',
+            isRefunded: queryParams.is_refunded === 'true',
+            isCaptured: queryParams.is_capture === 'true',
+            isVoided: queryParams.is_voided === 'true',
+            isAuth: queryParams.is_auth === 'true',
+            isStandalone: queryParams.is_standalone_payment === 'true',
+            is3dSecure: queryParams.is_3d_secure === 'true',
+            sourceData: {
+                type: queryParams['source_data.type'] || '',
+                pan: queryParams['source_data.pan'] || '',
+                subType: queryParams['source_data.sub_type'] || '',
+            },
+            responseCode: queryParams.txn_response_code || '',
+            message: queryParams['data.message'] || '',
+            metadata: {},
+        };
+    }
+}
+// ===========================
+// ORDER MANAGER CLASS
+// ===========================
+/**
+ * Handles Paymob order operations
+ */
+class PaymobOrderManager {
+    constructor(config, auth) {
+        this.config = config;
+        this.auth = auth;
+    }
+    /**
+     * Get order details including metadata
+     * @param orderId Order ID to fetch details for
+     * @returns Promise<OrderDetailsResult> Order details
+     */
+    getOrderDetails(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.auth.getBearerHeaders();
+                const response = yield axios_1.default.get(`${this.config.baseUrl}/api/ecommerce/orders/${orderId}`, { headers });
+                return {
+                    id: response.data.id,
+                    amount_cents: response.data.amount_cents,
+                    currency: response.data.currency,
+                    items: response.data.items || [],
+                    created_at: response.data.created_at,
+                    merchant_order_id: response.data.merchant_order_id,
+                };
+            }
+            catch (error) {
+                const axiosError = error;
+                throw new Error(`Failed to get order details: ${axiosError.message}`);
+            }
+        });
+    }
+    /**
+     * Get transaction status by transaction ID
+     * @param transactionId Transaction ID to check status for
+     * @returns Promise<TransactionStatusResult> Transaction status
+     */
     getTransactionStatus(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const response = yield axios_1.default.get(`${this.baseUrl}/api/acceptance/transactions/${transactionId}`, {
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Token ${this.secretKey}`,
-                    },
-                });
+                const headers = yield this.auth.getAuthHeaders();
+                const response = yield axios_1.default.get(`${this.config.baseUrl}/api/acceptance/transactions/${transactionId}`, { headers });
                 return {
                     success: response.data.success,
                     status: response.data.status,
@@ -325,77 +341,203 @@ class PaymobService {
             }
         });
     }
+}
+// ===========================
+// PAYMENT PROCESSOR CLASS
+// ===========================
+/**
+ * Handles Paymob payment processing operations
+ */
+class PaymobPaymentProcessor {
+    constructor(config, auth) {
+        this.config = config;
+        this.auth = auth;
+    }
     /**
-     * Get order details including metadata
+     * Create payment intention with Paymob
+     * @param amount Payment amount
+     * @param billingData Customer billing information
+     * @param items Order items
+     * @param currency Payment currency (default: EGP)
+     * @param extras Additional metadata
+     * @returns Promise<PaymentIntentionResult> Payment URL and client secret
      */
-    getOrderDetails(orderId) {
-        var _a, _b, _c;
+    createPaymentIntention(amount, billingData, items, currency = 'EGP', extras) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                // Try the Flash Integration API endpoint first
-                let response;
-                try {
-                    response = yield axios_1.default.get(`${this.baseUrl}/v1/intention/orders/${orderId}`, {
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Token ${this.secretKey}`,
-                        },
-                    });
-                }
-                catch (flashError) {
-                    console.log('Flash API failed, trying legacy API...');
-                    // Fallback to legacy API endpoint
-                    response = yield axios_1.default.get(`${this.baseUrl}/api/ecommerce/orders/${orderId}`, {
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Token ${this.secretKey}`,
-                        },
-                    });
-                }
-                return {
-                    id: response.data.id,
-                    amount_cents: response.data.amount_cents,
-                    currency: response.data.currency,
-                    items: response.data.items || [],
-                    created_at: response.data.created_at,
-                    merchant_order_id: response.data.merchant_order_id,
-                };
+                const intentionData = this.buildIntentionRequest(amount, billingData, items, currency, extras);
+                const headers = yield this.auth.getAuthHeaders();
+                const response = yield axios_1.default.post(`${this.config.baseUrl}/v1/intention/`, intentionData, { headers });
+                return this.buildPaymentResult(response.data.client_secret);
             }
             catch (error) {
                 const axiosError = error;
-                console.error('Order details error response:', (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.data);
-                console.error('Order details error status:', (_b = axiosError.response) === null || _b === void 0 ? void 0 : _b.status);
-                // If still failing, provide a fallback that returns minimal data
-                if (((_c = axiosError.response) === null || _c === void 0 ? void 0 : _c.status) === 401) {
-                    console.log('Authentication failed, using fallback approach...');
-                    // Return a minimal response that won't break the webhook
-                    return {
-                        id: orderId,
-                        amount_cents: 0,
-                        currency: 'EGP',
-                        items: [],
-                        created_at: new Date().toISOString(),
-                        merchant_order_id: '', // Empty merchant_order_id will trigger fallback logic
-                    };
-                }
-                throw new Error(`Failed to get order details: ${axiosError.message}`);
+                console.log('=======================');
+                console.log('axiosError', error);
+                console.log('=======================');
+                throw new Error(`Failed to create Paymob payment intention: ${axiosError.message}`);
+            }
+        });
+    }
+    /**
+     * Create payment URL with user data for contracts
+     * @param amount Payment amount
+     * @param userId User ID
+     * @param contractId Contract ID
+     * @param userData User data for billing
+     * @param serviceType Type of service being paid for
+     * @returns Promise<{paymentUrl: string}> Payment URL
+     */
+    createPaymentUrlWithUserData(amount, userId, contractId, userData, serviceType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const customData = this.buildCustomMetadata(contractId, userId, serviceType);
+            const billingData = this.buildBillingDataFromUser(userData);
+            const items = this.buildOrderItems(userId, contractId, serviceType, amount);
+            try {
+                const intentionData = this.buildIntentionRequest(amount, billingData, items, 'EGP', customData);
+                console.log('=======================');
+                console.log('intentionData', intentionData);
+                console.log('=======================');
+                const headers = yield this.auth.getAuthHeaders();
+                const response = yield axios_1.default.post(`${this.config.baseUrl}/v1/intention/`, intentionData, { headers });
+                const paymentUrl = this.buildPaymentUrl(response.data.client_secret);
+                return { paymentUrl };
+            }
+            catch (error) {
+                const axiosError = error;
+                console.log('=======================');
+                console.log('axiosError', error);
+                console.log('=======================');
+                throw new Error(`Failed to create Paymob payment intention: ${axiosError.message}`);
             }
         });
     }
     /**
-     * Handle webhook query and fetch items from order
+     * Build payment intention request data
+     * @private
+     */
+    buildIntentionRequest(amount, billingData, items, currency, extras) {
+        const amountInCents = amount * 100;
+        return {
+            amount: amountInCents,
+            currency,
+            payment_methods: [this.config.integrationId, 'card'],
+            items,
+            billing_data: billingData,
+            customer: {
+                first_name: billingData.first_name,
+                last_name: billingData.last_name,
+                email: billingData.email,
+                extras: extras || {},
+            },
+            extras: extras || {},
+        };
+    }
+    /**
+     * Build custom metadata for contract payments
+     * @private
      */
+    buildCustomMetadata(contractId, userId, serviceType) {
+        return {
+            contractId,
+            userId,
+            service_type: serviceType,
+            booking_id: 'BOOK_' + Date.now(),
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Build billing data from user data
+     * @private
+     */
+    buildBillingDataFromUser(userData) {
+        return {
+            first_name: userData.firstName,
+            last_name: userData.lastName,
+            email: userData.email,
+            phone_number: userData.phone,
+            apartment: '123',
+            floor: '1',
+            street: '123 Main St',
+            building: '123',
+            state: 'Cairo',
+            country: 'EGY',
+        };
+    }
+    /**
+     * Build order items for contract payment
+     * @private
+     */
+    buildOrderItems(userId, contractId, serviceType, amount) {
+        return [
+            {
+                name: `${userId}-${contractId}`,
+                description: serviceType,
+                amount: amount * 100,
+                quantity: 1,
+            },
+        ];
+    }
+    /**
+     * Build payment URL from client secret
+     * @private
+     */
+    buildPaymentUrl(clientSecret) {
+        return `${this.config.baseUrl}/unifiedcheckout/?publicKey=${this.config.publicKey}&clientSecret=${clientSecret}`;
+    }
+    /**
+     * Build payment result with URL and client secret
+     * @private
+     */
+    buildPaymentResult(clientSecret) {
+        return {
+            paymentUrl: this.buildPaymentUrl(clientSecret),
+            clientSecret,
+        };
+    }
+}
+class PaymobService {
+    constructor() {
+        this.config = new PaymobConfig();
+        this.auth = new PaymobAuth(this.config);
+        this.webhookHandler = new PaymobWebhookHandler(this.config);
+        this.orderManager = new PaymobOrderManager(this.config, this.auth);
+        this.paymentProcessor = new PaymobPaymentProcessor(this.config, this.auth);
+    }
+    createPaymentIntention(amount, billingData, items, currency = 'EGP', extras) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.paymentProcessor.createPaymentIntention(amount, billingData, items, currency, extras);
+        });
+    }
+    createPaymentUrlWithUserData(amount, userId, contractId, userData, serviceType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.paymentProcessor.createPaymentUrlWithUserData(amount, userId, contractId, userData, serviceType);
+        });
+    }
+    verifyPayment(hmac, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.webhookHandler.verifyPayment(hmac, data);
+        });
+    }
+    verifyWebhookHmac(queryParams) {
+        return this.webhookHandler.verifyWebhookHmac(queryParams);
+    }
+    handleWebhook(webhookData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.webhookHandler.handleWebhook(webhookData);
+        });
+    }
+    handleWebhookQuery(queryParams) {
+        return this.webhookHandler.handleWebhookQuery(queryParams);
+    }
     handleWebhookQueryWithItems(queryParams) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                // First verify the webhook
-                const webhookResult = this.handleWebhookQuery(queryParams);
+                const webhookResult = this.webhookHandler.handleWebhookQuery(queryParams);
                 if (!webhookResult.isValid || !webhookResult.transactionData) {
                     return { isValid: false, transactionData: null };
                 }
-                // Fetch order details to get items
-                const orderDetails = yield this.getOrderDetails(webhookResult.transactionData.orderId);
-                // Combine webhook data with items
+                const orderDetails = yield this.orderManager.getOrderDetails(webhookResult.transactionData.orderId);
                 const transactionData = Object.assign(Object.assign({}, webhookResult.transactionData), { items: orderDetails.items });
                 return { isValid: true, transactionData };
             }
@@ -405,5 +547,20 @@ class PaymobService {
             }
         });
     }
+    getTransactionStatus(transactionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.orderManager.getTransactionStatus(transactionId);
+        });
+    }
+    getOrderDetails(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.orderManager.getOrderDetails(orderId);
+        });
+    }
+    getAuthToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.auth.getAuthToken();
+        });
+    }
 }
 exports.PaymobService = PaymobService;

package/build/types/paymob.types.d.ts

@@ -0,0 +1,222 @@
+export interface PaymobMerchant {
+    id: number;
+    created_at: string;
+    phones: string[];
+    company_emails: string[];
+    company_name: string;
+    state: string;
+    country: string;
+    city: string;
+    postal_code: string;
+    street: string;
+}
+export interface PaymobOrderDetailsResponse {
+    id: number;
+    amount_cents: number;
+    currency: string;
+    items: PaymobOrderItem[];
+    created_at: string;
+    merchant_order_id: string;
+}
+export interface PaymobOrder {
+    id: number;
+    created_at: string;
+    delivery_needed: boolean;
+    merchant: PaymobMerchant;
+    collector: null;
+    amount_cents: number;
+    shipping_data: null;
+    currency: string;
+    is_payment_locked: boolean;
+    is_return: boolean;
+    is_cancel: boolean;
+    is_returned: boolean;
+    is_canceled: boolean;
+    merchant_order_id: string;
+    wallet_notification: null;
+    paid_amount_cents: number;
+    notify_user_with_email: boolean;
+    items: PaymobOrderItem[];
+    order_url: string;
+    commission_fee: number;
+    delivery_fee_cents: number;
+    delivery_voucher_cost: number;
+    discount: number;
+    metadata: Record<string, any>;
+}
+export interface PaymobOrderItem {
+    name: string;
+    description: string;
+    amount: number;
+    quantity: number;
+}
+export interface PaymobSourceData {
+    type: string;
+    pan: string;
+    sub_type: string;
+}
+export interface PaymobWebhookData {
+    obj: {
+        id: number;
+        amount_cents: number;
+        success: boolean;
+        is_refunded: boolean;
+        is_captured: boolean;
+        is_voided: boolean;
+        is_standalone_payment: boolean;
+        is_void: boolean;
+        is_refund: boolean;
+        is_3d_secure: boolean;
+        integration_id: number;
+        profile_id: number;
+        has_parent_transaction: boolean;
+        order: PaymobOrder;
+        created_at: string;
+        transaction_processed_callback_responses: null;
+        currency: string;
+        source_data: PaymobSourceData;
+        api_source: string;
+        terminal_id: string;
+        merchant_commission: number;
+        merchant_staff_tag: null;
+        hmac: string;
+    };
+}
+export interface PaymobIntentionResponse {
+    id: string;
+    amount: number;
+    currency: string;
+    payment_methods: any[];
+    items: PaymobOrderItem[];
+    billing_data: PaymobBillingData;
+    customer: PaymobCustomer;
+    extras: Record<string, any>;
+    client_secret: string;
+    status: string;
+    created_at: string;
+}
+export interface PaymobTransactionStatusResponse {
+    success: boolean;
+    status: string;
+    amount_cents: number;
+    currency: string;
+}
+export interface PaymobIntentionRequest {
+    amount: number;
+    currency: string;
+    payment_methods: (string | number)[];
+    items: PaymobOrderItem[];
+    billing_data: PaymobBillingData;
+    customer?: PaymobCustomer;
+    extras?: Record<string, any>;
+    merchant_order_id?: string;
+}
+export interface PaymobBillingData {
+    first_name: string;
+    last_name: string;
+    email: string;
+    phone_number: string;
+    apartment: string;
+    floor: string;
+    street: string;
+    building: string;
+    city?: string;
+    state: string;
+    country: string;
+}
+export interface PaymobCustomer {
+    first_name: string;
+    last_name: string;
+    email: string;
+    extras?: Record<string, any>;
+}
+export interface PaymobAuthResponse {
+    token: string;
+}
+export interface TransactionData {
+    orderId: number;
+    amount: number;
+    success: boolean;
+    currency: string;
+    transactionId: number;
+    createdAt: string;
+    isRefunded: boolean;
+    isCaptured: boolean;
+    isVoided: boolean;
+    metadata: Record<string, any>;
+}
+export interface WebhookQueryTransactionData extends TransactionData {
+    isAuth: boolean;
+    isStandalone: boolean;
+    is3dSecure: boolean;
+    sourceData: {
+        type: string;
+        pan: string;
+        subType: string;
+    };
+    responseCode: string;
+    message: string;
+}
+export interface WebhookQueryWithItemsTransactionData extends WebhookQueryTransactionData {
+    items: PaymobOrderItem[];
+}
+export interface WebhookResult<T> {
+    isValid: boolean;
+    transactionData: T | null;
+}
+export interface TransactionStatusResult {
+    success: boolean;
+    status: string;
+    amount: number;
+    currency: string;
+}
+export interface OrderDetailsResult {
+    id: number;
+    amount_cents: number;
+    currency: string;
+    items: PaymobOrderItem[];
+    created_at: string;
+    merchant_order_id: string;
+}
+export interface PaymentIntentionResult {
+    paymentUrl: string;
+    clientSecret: string;
+}
+export interface UserPaymentData {
+    firstName: string;
+    lastName: string;
+    email: string;
+    phone: string;
+}
+export interface PaymobConfigOptions {
+    apiKey?: string;
+    secretKey?: string;
+    publicKey?: string;
+    integrationId?: number;
+    baseUrl?: string;
+    hmacSecret?: string;
+}
+export declare class PaymobError extends Error {
+    readonly code?: string | undefined;
+    readonly details?: any;
+    constructor(message: string, code?: string | undefined, details?: any);
+}
+export declare class PaymobWebhookError extends PaymobError {
+    constructor(message: string, details?: any);
+}
+export declare class PaymobAuthError extends PaymobError {
+    constructor(message: string, details?: any);
+}
+export declare class PaymobPaymentError extends PaymobError {
+    constructor(message: string, details?: any);
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+}
+export interface PaymentValidationRules {
+    minAmount?: number;
+    maxAmount?: number;
+    allowedCurrencies?: string[];
+    requiredBillingFields?: string[];
+}

package/build/types/paymob.types.js

@@ -0,0 +1,39 @@
+"use strict";
+// ===========================
+// PAYMOB TYPE DEFINITIONS
+// ===========================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymobPaymentError = exports.PaymobAuthError = exports.PaymobWebhookError = exports.PaymobError = void 0;
+// ===========================
+// ERROR TYPES
+// ===========================
+class PaymobError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'PaymobError';
+    }
+}
+exports.PaymobError = PaymobError;
+class PaymobWebhookError extends PaymobError {
+    constructor(message, details) {
+        super(message, 'WEBHOOK_ERROR', details);
+        this.name = 'PaymobWebhookError';
+    }
+}
+exports.PaymobWebhookError = PaymobWebhookError;
+class PaymobAuthError extends PaymobError {
+    constructor(message, details) {
+        super(message, 'AUTH_ERROR', details);
+        this.name = 'PaymobAuthError';
+    }
+}
+exports.PaymobAuthError = PaymobAuthError;
+class PaymobPaymentError extends PaymobError {
+    constructor(message, details) {
+        super(message, 'PAYMENT_ERROR', details);
+        this.name = 'PaymobPaymentError';
+    }
+}
+exports.PaymobPaymentError = PaymobPaymentError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duvdu-v1/duvdu",
-  "version": "1.1.267",
+  "version": "1.1.269",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [