@duvdu-v1/duvdu 1.1.265 → 1.1.267

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

@@ -39,7 +39,7 @@ interface PaymobOrder {
 interface PaymobOrderItem {
     name: string;
     description: string;
-    amount_cents: number;
+    amount: number;
     quantity: number;
 }
 interface PaymobSourceData {
@@ -83,14 +83,9 @@ interface PaymobBillingData {
     floor: string;
     street: string;
     building: string;
-    city: string;
+    city?: string;
     state: string;
     country: string;
-    postal_code: string;
-}
-interface CreateOrderResult {
-    orderId: number;
-    token: string;
 }
 interface TransactionData {
     orderId: number;
@@ -138,28 +133,34 @@ interface OrderDetailsResult {
     merchant_order_id: string;
 }
 /**
- * Paymob Service Configuration
+ * Paymob Service Configuration for Flash Integration
  *
  * Required Keys:
- * - apiKey: Your Paymob API Key (used for authentication)
- * - integrationId: Your Paymob Integration ID (found in your Paymob dashboard)
- * - iframeId: Your Paymob Iframe ID (found in your Paymob dashboard)
- *
- * Note:
- * - Public Key: Used for client-side encryption (not needed for this service)
- * - Secret Key: Used for webhook signature verification (handled internally)
+ * - 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)
  */
 export declare class PaymobService {
-    private readonly apiKey;
+    private readonly secretKey;
+    private readonly publicKey;
     private readonly integrationId;
-    private readonly iframeId;
     private readonly baseUrl;
     private readonly hmacSecret;
     constructor();
-    getAuthToken(): Promise<string>;
-    createOrder(amount: number, currency?: string, items?: PaymobOrderItem[], merchant_order_id?: string): Promise<CreateOrderResult>;
-    getPaymentKey(orderId: number, token: string, amount: number, billingData: PaymobBillingData): Promise<string>;
-    createPaymentUrl(paymentKey: string): string;
+    /**
+     * 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

package/build/services/paymob.service.js

@@ -39,104 +39,74 @@ exports.PaymobService = void 0;
 const crypto = __importStar(require("crypto"));
 const axios_1 = __importDefault(require("axios"));
 /**
- * Paymob Service Configuration
+ * Paymob Service Configuration for Flash Integration
  *
  * Required Keys:
- * - apiKey: Your Paymob API Key (used for authentication)
- * - integrationId: Your Paymob Integration ID (found in your Paymob dashboard)
- * - iframeId: Your Paymob Iframe ID (found in your Paymob dashboard)
- *
- * Note:
- * - Public Key: Used for client-side encryption (not needed for this service)
- * - Secret Key: Used for webhook signature verification (handled internally)
+ * - 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 {
     constructor() {
-        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.iframeId = parseInt(process.env.PAYMOB_IFRAME_ID);
-        this.baseUrl = process.env.PAYMOB_BASE_URL;
+        this.baseUrl = process.env.PAYMOB_BASE_URL || 'https://accept.paymob.com';
         this.hmacSecret = process.env.PAYMOB_HMAC_SECRET;
         console.log('PayMob configuration:', {
             integrationId: this.integrationId,
-            iframeId: this.iframeId,
+            publicKey: this.publicKey,
             baseUrl: this.baseUrl,
         });
     }
-    getAuthToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const response = yield axios_1.default.post(`${this.baseUrl}/auth/tokens`, {
-                    api_key: this.apiKey,
-                });
-                return response.data.token;
-            }
-            catch (error) {
-                const axiosError = error;
-                throw new Error(`Failed to get Paymob auth token: ${axiosError.message}`);
-            }
-        });
-    }
-    createOrder(amount, currency = 'EGP', items = [], merchant_order_id) {
+    /**
+     * 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, billingData, items, currency = 'EGP', extras) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const authToken = yield this.getAuthToken();
-                const orderData = {
-                    auth_token: authToken,
-                    delivery_needed: false,
-                    amount_cents: amount * 100,
+                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 || {},
                 };
-                if (merchant_order_id) {
-                    orderData.merchant_order_id = merchant_order_id;
-                }
-                const response = yield axios_1.default.post(`${this.baseUrl}/ecommerce/orders`, orderData, {
+                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 {
-                    orderId: response.data.id,
-                    token: authToken,
-                };
-            }
-            catch (error) {
-                const axiosError = error;
-                console.log('PayMob order error:', (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.data);
-                throw new Error(`Failed to create Paymob order: ${axiosError.message}`);
-            }
-        });
-    }
-    getPaymentKey(orderId, token, amount, billingData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const paymentKeyRequest = {
-                    auth_token: token,
-                    amount_cents: amount * 100,
-                    expiration: 3600,
-                    order_id: orderId,
-                    billing_data: billingData,
-                    currency: 'EGP',
-                    integration_id: this.integrationId,
+                    paymentUrl,
+                    clientSecret: response.data.client_secret,
                 };
-                const response = yield axios_1.default.post(`${this.baseUrl}/acceptance/payment_keys`, paymentKeyRequest, {
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                });
-                return response.data.token;
             }
             catch (error) {
                 const axiosError = error;
-                throw new Error(`Failed to get payment key: ${axiosError.message}`);
+                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}`);
             }
         });
     }
-    createPaymentUrl(paymentKey) {
-        return `https://accept.paymob.com/api/acceptance/iframes/${this.iframeId}?payment_token=${paymentKey}`;
-    }
     /**
      * Creates a payment URL with user data and custom metadata
      * @param amount The payment amount
@@ -147,9 +117,9 @@ class PaymobService {
      * @returns The payment URL and related data
      */
     createPaymentUrlWithUserData(amount, userId, contractId, userData, serviceType) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const authToken = yield this.getAuthToken();
-            // Store custom data in merchant_order_id as JSON string
+            // Create metadata with custom data
             const customData = {
                 contractId,
                 userId,
@@ -157,23 +127,60 @@ class PaymobService {
                 booking_id: 'BOOK_' + Date.now(),
                 timestamp: new Date().toISOString(),
             };
-            const order = yield this.createOrder(amount, 'EGP', [], JSON.stringify(customData));
-            const paymentKey = yield this.getPaymentKey(order.orderId, authToken, amount, {
+            const extras = customData;
+            const billingData = {
                 first_name: userData.firstName,
                 last_name: userData.lastName,
                 email: userData.email,
                 phone_number: userData.phone,
                 apartment: '123',
-                floor: '123',
-                street: '123',
+                floor: '1',
+                street: '123 Main St',
                 building: '123',
-                city: '123',
-                state: '123',
-                country: '123',
-                postal_code: '123',
-            });
-            const paymentUrl = this.createPaymentUrl(paymentKey);
-            return { paymentUrl };
+                state: 'Cairo',
+                country: 'EGY',
+            };
+            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) {
@@ -183,7 +190,7 @@ class PaymobService {
                 .map(([key, value]) => `${key}=${value}`)
                 .join('');
             const calculatedHmac = crypto
-                .createHmac('sha512', this.apiKey)
+                .createHmac('sha512', this.secretKey)
                 .update(concatenatedString)
                 .digest('hex');
             return calculatedHmac === hmac;
@@ -299,11 +306,10 @@ class PaymobService {
     getTransactionStatus(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const authToken = yield this.getAuthToken();
-                const response = yield axios_1.default.get(`${this.baseUrl}/acceptance/transactions/${transactionId}`, {
+                const response = yield axios_1.default.get(`${this.baseUrl}/api/acceptance/transactions/${transactionId}`, {
                     headers: {
                         'Content-Type': 'application/json',
-                        Authorization: `Bearer ${authToken}`,
+                        'Authorization': `Token ${this.secretKey}`,
                     },
                 });
                 return {
@@ -323,15 +329,29 @@ class PaymobService {
      * Get order details including metadata
      */
     getOrderDetails(orderId) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const authToken = yield this.getAuthToken();
-                const response = yield axios_1.default.get(`${this.baseUrl}/ecommerce/orders/${orderId}`, {
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Authorization: `Bearer ${authToken}`,
-                    },
-                });
+                // 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,
@@ -343,6 +363,21 @@ class PaymobService {
             }
             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}`);
             }
         });

package/package.json

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