@b2y/ecommerce-common 1.0.4 → 1.0.6

package/utility/QueryUtil.js

@@ -1,262 +1,262 @@
-
-const AppUtil = require('../utility/AppUtil');
-const StatusMessage = require('../constants/StatusMessageConstants');
-const DateUtil = require('../utility/DateUtil');
-const {Sequelize} = require('sequelize');
-class QueryUtil {
-  static parseId(idParam) {
-      if (!idParam) return null;
-      if (Array.isArray(idParam))
-        return idParam.map((id) => id.toString().trim()).filter((id) => id);
-      return idParam
-        .toString()
-        .split(",")
-        .map((id) => id.trim())
-        .filter((id) => id);
-    };
-
-  static storeWhereClause(filters, tenantID, logger) {
-    const { startDate, endDate, IsActive, searchText } = filters;
-    let storeWhereClause = {};
-    // Date range filter
-    if (startDate && !DateUtil.isValidDate(startDate)) {
-      logger.warn("invalid start date");
-      throw new Error(StatusMessage.INVALID_START_DATE);
-    }
-    if (endDate && !DateUtil.isValidDate(endDate)) {
-      logger.warn("invalid end date");
-      throw new Error(StatusMessage.INVALID_END_DATE);
-    }
-    if (startDate && endDate) {
-      storeWhereClause.CreatedAt = {
-        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
-      };
-    } else if (startDate) {
-      storeWhereClause.CreatedAt = { [Sequelize.Op.gte]: new Date(startDate) };
-    } else if (endDate) {
-      storeWhereClause.CreatedAt = { [Sequelize.Op.lte]: new Date(endDate) };
-    }
-    if (IsActive) {
-      const isActiveValue = AppUtil.parseIsActive(IsActive);
-      if (isActiveValue === undefined) {
-        logger.warn("invalid IsActive status");
-        throw new Error(StatusMessage.INVALID_ISACTIVE_STATUS);
-      }
-      storeWhereClause.IsActive = isActiveValue;
-    }
-    // Tenant ID
-    if (tenantID) storeWhereClause.TenantID = tenantID;
-    if (searchText) {
-      storeWhereClause[Sequelize.Op.or] = [
-        { StoreName: { [Sequelize.Op.iLike]: `%${searchText}%` } },
-        { AddressLine1: { [Sequelize.Op.iLike]: `%${searchText}%` } },
-        { AddressLine2: { [Sequelize.Op.iLike]: `%${searchText}%` } },
-        { "$City.CityName$": { [Sequelize.Op.iLike]: `%${searchText}%` } },
-      ];
-    }
-
-    return storeWhereClause;
-  }
-  static orderWhereClause(filters, tenantID, logger) {
-    const { startDate, endDate, searchText, paymentStatusId, storeId } = filters;
-    let orderWhereClause = {};
-    let paymentStatusWhere = {};
-    let storeWhereClause = {};
-    if (tenantID) orderWhereClause.TenantID = tenantID;
-    if (startDate && !DateUtil.isValidDate(startDate)) {
-      logger.warn("invalid start date");
-      throw new Error(StatusMessage.INVALID_START_DATE);
-    }
-    if (endDate && !DateUtil.isValidDate(endDate)) {
-      logger.warn("invalid end date");
-      throw new Error(StatusMessage.INVALID_END_DATE);
-    }
-    if (searchText) {
-      orderWhereClause[Sequelize.Op.or] = [
-        { OrderRefID: { [Sequelize.Op.iLike]: `%${searchText}%` } },
-        { "$Customer.FirstName$": { [Sequelize.Op.iLike]: `%${searchText}%` } },
-      ];
-    }
-    if (paymentStatusId) {
-      const paymentStatusIDs = this.parseId(paymentStatusId);
-      paymentStatusWhere.PaymentStatusID = {[Sequelize.Op.in] : paymentStatusIDs};
-    }
-    if(storeId) {
-     const storeIDs = this.parseId(storeId);
-      storeWhereClause.StoreID = {[Sequelize.Op.in] : storeIDs}
-    }
-    if (startDate && endDate) {
-      orderWhereClause.OrderDate = {
-        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
-      };
-    } else if (startDate) {
-      orderWhereClause.OrderDate = { [Sequelize.Op.gte]: new Date(startDate) };
-    } else if (endDate) {
-      orderWhereClause.OrderDate = { [Sequelize.Op.lte]: new Date(endDate) };
-    }
-    return { orderWhereClause, includeWhere: { paymentStatusWhere, storeWhereClause } };
-  }
-  static paymentWhereClause(filters, tenantID, logger) {
-    const {
-      paymentStatusId,
-      searchText,
-      paymentTypeId,
-      paymentMethodId,
-      storeId,
-      startDate,
-      endDate,
-    } = filters;
-    let paymentWhereClause = {};
-    let paymentStatusWhere = {};
-    let paymentTypeWhere = {};
-    let paymentMethodWhere = {};
-    let storeWhereClause = {};
-    if (tenantID) paymentWhereClause.TenantID = tenantID;
-    if (startDate && !DateUtil.isValidDate(startDate)) {
-      logger.warn("invalid start date");
-      throw new Error(StatusMessage.INVALID_START_DATE);
-    }
-    if (endDate && !DateUtil.isValidDate(endDate)) {
-      logger.warn("invalid end date");
-      throw new Error(StatusMessage.INVALID_END_DATE);
-    }
-    if (searchText) {
-      paymentWhereClause[Sequelize.Op.or] = [
-        { "$Order.OrderRefID$": { [Sequelize.Op.iLike]: `%${searchText}%` } },
-        { PaymentRefID: { [Sequelize.Op.iLike]: `%${searchText}%` } },
-      ];
-    }
-    if (paymentStatusId) {
-      const paymentStatusIDs = this.parseId(paymentStatusId)
-      paymentStatusWhere.PaymentStatusID = {[Sequelize.Op.in] : paymentStatusIDs};
-    }
-    if (paymentTypeId) {
-      const paymentTypeIDs = this.parseId(paymentTypeId)
-      paymentTypeWhere.PaymentTypeID = {[Sequelize.Op.in] : paymentTypeIDs};
-    }
-    if (paymentMethodId) {
-      const paymentMethodIDs = this.parseId(paymentMethodId);
-      paymentMethodWhere.PaymentMethodID = {[Sequelize.Op.in] : paymentMethodIDs};
-    }
-    if(storeId) {
-      const storeIDs = this.parseId(storeId);
-      storeWhereClause.StoreID = {[Sequelize.Op.in]: storeIDs}
-    }
-    if (startDate && endDate) {
-      paymentWhereClause.PaymentDate = {
-        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
-      };
-    } else if (startDate) {
-      paymentWhereClause.PaymentDate = { [Sequelize.Op.gte]: new Date(startDate) };
-    } else if (endDate) {
-      paymentWhereClause.PaymentDate = { [Sequelize.Op.lte]: new Date(endDate) };
-    }
-    return {
-      paymentWhereClause,
-      includeWhere: {
-        paymentStatusWhere,
-        paymentMethodWhere,
-        paymentTypeWhere,
-        storeWhereClause
-      },
-    };
-  }
-  static customerWhereClause(filters, tenantID, logger) {
-    const { searchText, startDate, endDate } = filters;
-    let customerWhereClause = {};
-    if (startDate && !DateUtil.isValidDate(startDate)) {
-      logger.warn("invalid start date")
-      throw new Error(StatusMessage.INVALID_START_DATE);
-    }
-    if (endDate && !DateUtil.isValidDate(endDate)) {
-      logger.warn("invalid end date");
-      throw new Error(StatusMessage.INVALID_END_DATE);
-    }
-    if (startDate && endDate) {
-      customerWhereClause.CreatedAt = {
-        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
-      };
-    } else if (startDate) {
-      customerWhereClause.CreatedAt = { [Sequelize.Op.gte]: new Date(startDate) };
-    } else if (endDate) {
-      customerWhereClause.CreatedAt = { [Sequelize.Op.lte]: new Date(endDate) };
-    }
-    if (tenantID) customerWhereClause.TenantID = tenantID;
-    if (searchText) {
-      customerWhereClause[Sequelize.Op.or] = [
-        { FirstName: { [Sequelize.Op.iLike]: `%${searchText}%` } },
-        { LastName: { [Sequelize.Op.iLike]: `%${searchText}%` } },
-      ];
-    }
-    return customerWhereClause;
-  }
-  static productWhereClause(filters, tenantID, logger) {
-    const { brandId, categoryId, storeId, IsActive, searchText, startDate, endDate } =
-      filters;
-    const brandWhere = {};
-    const categoryWhere = {};
-    const storeWhere = {};
-    const productWhereClause = {};
-    if (tenantID) {
-      productWhereClause.TenantID = tenantID;
-      brandWhere.TenantID = tenantID;
-      categoryWhere.TenantID = tenantID;
-    }
-
-    if (startDate && !DateUtil.isValidDate(startDate)) {
-      logger.warn("invalid start date");
-      throw new Error(StatusMessage.INVALID_START_DATE);
-    }
-    if (endDate && !DateUtil.isValidDate(endDate)) {
-      logger.warn("invalid end date");
-      throw new Error(StatusMessage.INVALID_END_DATE);
-    }
-    if (startDate && endDate) {
-      productWhereClause.CreatedAt = {
-        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
-      };
-    } else if (startDate) {
-      productWhereClause.CreatedAt = { [Sequelize.Op.gte]: new Date(startDate) };
-    } else if (endDate) {
-      productWhereClause.CreatedAt = { [Sequelize.Op.lte]: new Date(endDate) };
-    }
-    if (searchText) {
-      productWhereClause[Sequelize.Op.or] = [
-        { ProductName: { [Sequelize.Op.iLike]: `%${searchText}%` } },
-      ];
-    }
-    if (IsActive) {
-      const isActiveValue = AppUtil.parseIsActive(IsActive);
-      if (isActiveValue === undefined) {
-        logger.warn("invalid IsActive status");
-        throw new Error(StatusMessage.INVALID_ISACTIVE_STATUS);
-      }
-      productWhereClause.IsActive = isActiveValue;
-    }
-    if (brandId) {
-      const brandIds = this.parseId(brandId);
-      brandWhere.BrandID = { [Sequelize.Op.in]: brandIds };
-    }
-    if (categoryId) {
-      const categoryIds = this.parseId(categoryId);
-      categoryWhere.CategoryID = { [Sequelize.Op.in]: categoryIds };
-    }
-    if(storeId) {
-      const storeIds = this.parseId(storeId);
-      storeWhere.StoreID = { [Sequelize.Op.in]: storeIds };
-    }
-    return {
-      productWhereClause,
-      includeWhere: { brandWhere, categoryWhere, storeWhere },
-    };
-  }
-
-  static getDefaultOptions(whereClause, order = [['CreatedAt', 'DESC']]) {
-    return {
-      where: whereClause,
-      order: order
-    };
-  }
-}
-
+
+const AppUtil = require('../utility/AppUtil');
+const StatusMessage = require('../constants/StatusMessageConstants');
+const DateUtil = require('../utility/DateUtil');
+const {Sequelize} = require('sequelize');
+class QueryUtil {
+  static parseId(idParam) {
+      if (!idParam) return null;
+      if (Array.isArray(idParam))
+        return idParam.map((id) => id.toString().trim()).filter((id) => id);
+      return idParam
+        .toString()
+        .split(",")
+        .map((id) => id.trim())
+        .filter((id) => id);
+    };
+
+  static storeWhereClause(filters, tenantID, logger) {
+    const { startDate, endDate, IsActive, searchText } = filters;
+    let storeWhereClause = {};
+    // Date range filter
+    if (startDate && !DateUtil.isValidDate(startDate)) {
+      logger.warn("invalid start date");
+      throw new Error(StatusMessage.INVALID_START_DATE);
+    }
+    if (endDate && !DateUtil.isValidDate(endDate)) {
+      logger.warn("invalid end date");
+      throw new Error(StatusMessage.INVALID_END_DATE);
+    }
+    if (startDate && endDate) {
+      storeWhereClause.CreatedAt = {
+        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
+      };
+    } else if (startDate) {
+      storeWhereClause.CreatedAt = { [Sequelize.Op.gte]: new Date(startDate) };
+    } else if (endDate) {
+      storeWhereClause.CreatedAt = { [Sequelize.Op.lte]: new Date(endDate) };
+    }
+    if (IsActive) {
+      const isActiveValue = AppUtil.parseIsActive(IsActive);
+      if (isActiveValue === undefined) {
+        logger.warn("invalid IsActive status");
+        throw new Error(StatusMessage.INVALID_ISACTIVE_STATUS);
+      }
+      storeWhereClause.IsActive = isActiveValue;
+    }
+    // Tenant ID
+    if (tenantID) storeWhereClause.TenantID = tenantID;
+    if (searchText) {
+      storeWhereClause[Sequelize.Op.or] = [
+        { StoreName: { [Sequelize.Op.iLike]: `%${searchText}%` } },
+        { AddressLine1: { [Sequelize.Op.iLike]: `%${searchText}%` } },
+        { AddressLine2: { [Sequelize.Op.iLike]: `%${searchText}%` } },
+        { "$City.CityName$": { [Sequelize.Op.iLike]: `%${searchText}%` } },
+      ];
+    }
+
+    return storeWhereClause;
+  }
+  static orderWhereClause(filters, tenantID, logger) {
+    const { startDate, endDate, searchText, paymentStatusId, storeId } = filters;
+    let orderWhereClause = {};
+    let paymentStatusWhere = {};
+    let storeWhereClause = {};
+    if (tenantID) orderWhereClause.TenantID = tenantID;
+    if (startDate && !DateUtil.isValidDate(startDate)) {
+      logger.warn("invalid start date");
+      throw new Error(StatusMessage.INVALID_START_DATE);
+    }
+    if (endDate && !DateUtil.isValidDate(endDate)) {
+      logger.warn("invalid end date");
+      throw new Error(StatusMessage.INVALID_END_DATE);
+    }
+    if (searchText) {
+      orderWhereClause[Sequelize.Op.or] = [
+        { OrderRefID: { [Sequelize.Op.iLike]: `%${searchText}%` } },
+        { "$Customer.FirstName$": { [Sequelize.Op.iLike]: `%${searchText}%` } },
+      ];
+    }
+    if (paymentStatusId) {
+      const paymentStatusIDs = this.parseId(paymentStatusId);
+      paymentStatusWhere.PaymentStatusID = {[Sequelize.Op.in] : paymentStatusIDs};
+    }
+    if(storeId) {
+     const storeIDs = this.parseId(storeId);
+      storeWhereClause.StoreID = {[Sequelize.Op.in] : storeIDs}
+    }
+    if (startDate && endDate) {
+      orderWhereClause.OrderDate = {
+        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
+      };
+    } else if (startDate) {
+      orderWhereClause.OrderDate = { [Sequelize.Op.gte]: new Date(startDate) };
+    } else if (endDate) {
+      orderWhereClause.OrderDate = { [Sequelize.Op.lte]: new Date(endDate) };
+    }
+    return { orderWhereClause, includeWhere: { paymentStatusWhere, storeWhereClause } };
+  }
+  static paymentWhereClause(filters, tenantID, logger) {
+    const {
+      paymentStatusId,
+      searchText,
+      paymentTypeId,
+      paymentMethodId,
+      storeId,
+      startDate,
+      endDate,
+    } = filters;
+    let paymentWhereClause = {};
+    let paymentStatusWhere = {};
+    let paymentTypeWhere = {};
+    let paymentMethodWhere = {};
+    let storeWhereClause = {};
+    if (tenantID) paymentWhereClause.TenantID = tenantID;
+    if (startDate && !DateUtil.isValidDate(startDate)) {
+      logger.warn("invalid start date");
+      throw new Error(StatusMessage.INVALID_START_DATE);
+    }
+    if (endDate && !DateUtil.isValidDate(endDate)) {
+      logger.warn("invalid end date");
+      throw new Error(StatusMessage.INVALID_END_DATE);
+    }
+    if (searchText) {
+      paymentWhereClause[Sequelize.Op.or] = [
+        { "$Order.OrderRefID$": { [Sequelize.Op.iLike]: `%${searchText}%` } },
+        { PaymentRefID: { [Sequelize.Op.iLike]: `%${searchText}%` } },
+      ];
+    }
+    if (paymentStatusId) {
+      const paymentStatusIDs = this.parseId(paymentStatusId)
+      paymentStatusWhere.PaymentStatusID = {[Sequelize.Op.in] : paymentStatusIDs};
+    }
+    if (paymentTypeId) {
+      const paymentTypeIDs = this.parseId(paymentTypeId)
+      paymentTypeWhere.PaymentTypeID = {[Sequelize.Op.in] : paymentTypeIDs};
+    }
+    if (paymentMethodId) {
+      const paymentMethodIDs = this.parseId(paymentMethodId);
+      paymentMethodWhere.PaymentMethodID = {[Sequelize.Op.in] : paymentMethodIDs};
+    }
+    if(storeId) {
+      const storeIDs = this.parseId(storeId);
+      storeWhereClause.StoreID = {[Sequelize.Op.in]: storeIDs}
+    }
+    if (startDate && endDate) {
+      paymentWhereClause.PaymentDate = {
+        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
+      };
+    } else if (startDate) {
+      paymentWhereClause.PaymentDate = { [Sequelize.Op.gte]: new Date(startDate) };
+    } else if (endDate) {
+      paymentWhereClause.PaymentDate = { [Sequelize.Op.lte]: new Date(endDate) };
+    }
+    return {
+      paymentWhereClause,
+      includeWhere: {
+        paymentStatusWhere,
+        paymentMethodWhere,
+        paymentTypeWhere,
+        storeWhereClause
+      },
+    };
+  }
+  static customerWhereClause(filters, tenantID, logger) {
+    const { searchText, startDate, endDate } = filters;
+    let customerWhereClause = {};
+    if (startDate && !DateUtil.isValidDate(startDate)) {
+      logger.warn("invalid start date")
+      throw new Error(StatusMessage.INVALID_START_DATE);
+    }
+    if (endDate && !DateUtil.isValidDate(endDate)) {
+      logger.warn("invalid end date");
+      throw new Error(StatusMessage.INVALID_END_DATE);
+    }
+    if (startDate && endDate) {
+      customerWhereClause.CreatedAt = {
+        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
+      };
+    } else if (startDate) {
+      customerWhereClause.CreatedAt = { [Sequelize.Op.gte]: new Date(startDate) };
+    } else if (endDate) {
+      customerWhereClause.CreatedAt = { [Sequelize.Op.lte]: new Date(endDate) };
+    }
+    if (tenantID) customerWhereClause.TenantID = tenantID;
+    if (searchText) {
+      customerWhereClause[Sequelize.Op.or] = [
+        { FirstName: { [Sequelize.Op.iLike]: `%${searchText}%` } },
+        { LastName: { [Sequelize.Op.iLike]: `%${searchText}%` } },
+      ];
+    }
+    return customerWhereClause;
+  }
+  static productWhereClause(filters, tenantID, logger) {
+    const { brandId, categoryId, storeId, IsActive, searchText, startDate, endDate } =
+      filters;
+    const brandWhere = {};
+    const categoryWhere = {};
+    const storeWhere = {};
+    const productWhereClause = {};
+    if (tenantID) {
+      productWhereClause.TenantID = tenantID;
+      brandWhere.TenantID = tenantID;
+      categoryWhere.TenantID = tenantID;
+    }
+
+    if (startDate && !DateUtil.isValidDate(startDate)) {
+      logger.warn("invalid start date");
+      throw new Error(StatusMessage.INVALID_START_DATE);
+    }
+    if (endDate && !DateUtil.isValidDate(endDate)) {
+      logger.warn("invalid end date");
+      throw new Error(StatusMessage.INVALID_END_DATE);
+    }
+    if (startDate && endDate) {
+      productWhereClause.CreatedAt = {
+        [Sequelize.Op.between]: [new Date(startDate), new Date(endDate)],
+      };
+    } else if (startDate) {
+      productWhereClause.CreatedAt = { [Sequelize.Op.gte]: new Date(startDate) };
+    } else if (endDate) {
+      productWhereClause.CreatedAt = { [Sequelize.Op.lte]: new Date(endDate) };
+    }
+    if (searchText) {
+      productWhereClause[Sequelize.Op.or] = [
+        { ProductName: { [Sequelize.Op.iLike]: `%${searchText}%` } },
+      ];
+    }
+    if (IsActive) {
+      const isActiveValue = AppUtil.parseIsActive(IsActive);
+      if (isActiveValue === undefined) {
+        logger.warn("invalid IsActive status");
+        throw new Error(StatusMessage.INVALID_ISACTIVE_STATUS);
+      }
+      productWhereClause.IsActive = isActiveValue;
+    }
+    if (brandId) {
+      const brandIds = this.parseId(brandId);
+      brandWhere.BrandID = { [Sequelize.Op.in]: brandIds };
+    }
+    if (categoryId) {
+      const categoryIds = this.parseId(categoryId);
+      categoryWhere.CategoryID = { [Sequelize.Op.in]: categoryIds };
+    }
+    if(storeId) {
+      const storeIds = this.parseId(storeId);
+      storeWhere.StoreID = { [Sequelize.Op.in]: storeIds };
+    }
+    return {
+      productWhereClause,
+      includeWhere: { brandWhere, categoryWhere, storeWhere },
+    };
+  }
+
+  static getDefaultOptions(whereClause, order = [['CreatedAt', 'DESC']]) {
+    return {
+      where: whereClause,
+      order: order
+    };
+  }
+}
+
 module.exports = QueryUtil;

package/utility/Razorpay.js

@@ -1,66 +1,66 @@
-const crypto = require('crypto');
-const StatusMessage = require('../constants/StatusMessageConstants');
-class RazorpayUtil {
-    constructor(razorpayKeys, logger, Razorpay) {
-        this.logger = logger;
-        this.instance = new Razorpay({
-            key_id: razorpayKeys.keyId,
-            key_secret: razorpayKeys.keySecret
-        });
-    }
-
-    async createOrder(amount, currency, receipt = null) {
-        try {
-            const options = {
-                amount: amount * 100,
-                currency,
-                receipt: receipt
-            };
-
-            const order = await this.instance.orders.create(options);
-            return {
-                razorpayOrderId: order.id,
-                amount: order.amount,
-                currency: order.currency,
-                created_at:order.created_at,
-                status: order.status
-            };
-        } catch (error) {
-            this.logger.error('Razorpay order creation error:', error);
-            throw new Error(StatusMessage.ORDER_CREATION_FAILED);
-        }
-    }
-
-    async verifyPayment(paymentId, orderId, signature, razorpaySecret) {
-        try {
-            const payment = await this.instance.payments.fetch(paymentId);
-
-            const expectedSignature = crypto
-                .createHmac('sha256', razorpaySecret)
-                .update(`${orderId}|${paymentId}`)
-                .digest('hex');
-            if (expectedSignature.trim() !== signature.trim()) {
-                throw new Error(StatusMessage.PAYMENT_SIGNATURE_VERIFICATION_FAILED);
-            }
-
-            return {
-                paymentId: payment.id,
-                orderId: payment.order_id,
-                amount: payment.amount,
-                currency: payment.currency,
-                status: payment.status,
-                method: payment.method,
-                cardId: payment.card_id,
-                card_last4: payment.card ? payment.card.last4 : null,
-                bank: payment.bank,
-                email: payment.email,
-                created_at: payment.created_at
-            };
-        } catch (error) {
-            console.log('Razorpay payment verification error:', error);
-            throw new Error(StatusMessage.PAYMENT_VERIFICATION_FAILED);
-        }
-    }
-}
-
+const crypto = require('crypto');
+const StatusMessage = require('../constants/StatusMessageConstants');
+class RazorpayUtil {
+    constructor(razorpayKeys, logger, Razorpay) {
+        this.logger = logger;
+        this.instance = new Razorpay({
+            key_id: razorpayKeys.keyId,
+            key_secret: razorpayKeys.keySecret
+        });
+    }
+
+    async createOrder(amount, currency, receipt = null) {
+        try {
+            const options = {
+                amount: amount * 100,
+                currency,
+                receipt: receipt
+            };
+
+            const order = await this.instance.orders.create(options);
+            return {
+                razorpayOrderId: order.id,
+                amount: order.amount,
+                currency: order.currency,
+                created_at:order.created_at,
+                status: order.status
+            };
+        } catch (error) {
+            this.logger.error('Razorpay order creation error:', error);
+            throw new Error(StatusMessage.ORDER_CREATION_FAILED);
+        }
+    }
+
+    async verifyPayment(paymentId, orderId, signature, razorpaySecret) {
+        try {
+            const payment = await this.instance.payments.fetch(paymentId);
+
+            const expectedSignature = crypto
+                .createHmac('sha256', razorpaySecret)
+                .update(`${orderId}|${paymentId}`)
+                .digest('hex');
+            if (expectedSignature.trim() !== signature.trim()) {
+                throw new Error(StatusMessage.PAYMENT_SIGNATURE_VERIFICATION_FAILED);
+            }
+
+            return {
+                paymentId: payment.id,
+                orderId: payment.order_id,
+                amount: payment.amount,
+                currency: payment.currency,
+                status: payment.status,
+                method: payment.method,
+                cardId: payment.card_id,
+                card_last4: payment.card ? payment.card.last4 : null,
+                bank: payment.bank,
+                email: payment.email,
+                created_at: payment.created_at
+            };
+        } catch (error) {
+            console.log('Razorpay payment verification error:', error);
+            throw new Error(StatusMessage.PAYMENT_VERIFICATION_FAILED);
+        }
+    }
+}
+
 module.exports = RazorpayUtil;