@b2y/ecommerce-common 1.0.0

package/utility/QueryUtil.js

@@ -0,0 +1,262 @@
+
+const AppUtil = require('../utility/AppUtil');
+const StatusMessage = require('../constants/StatusMessageConstants');
+const DateUtil = require('../utility/DateUtil');
+const PaymentStatusEnum = require('../enum/PaymentStatusEnum');
+const PaymentTypeEnum = require('../enum/PaymentTypeEnum');
+const PaymentMethodEnum = require('../enum/PaymentMethodEnum');
+class QueryUtil {
+  static storeWhereClause(filters, tenantID, Sequelize, 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, Sequelize, logger) {
+    const { startDate, endDate, searchText, paymentStatus } = filters;
+    let orderWhereClause = {};
+    let paymentStatusWhere = {};
+    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 (paymentStatus) {
+      const validPaymentStatus = new Set(Object.values(PaymentStatusEnum));
+      if (!validPaymentStatus.has(paymentStatus)) {
+        logger.warn("invalid payment status")
+        throw new Error(StatusMessage.INVALID_PAYMENT_STATUS);
+      }
+      paymentStatusWhere.PaymentStatusName = paymentStatus;
+    }
+    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 } };
+  }
+  static paymentWhereClause(filters, tenantID, Sequelize, logger) {
+    const {
+      paymentStatus,
+      searchText,
+      paymentType,
+      paymentMethod,
+      startDate,
+      endDate,
+    } = filters;
+    let paymentWhereClause = {};
+    let paymentStatusWhere = {};
+    let paymentTypeWhere = {};
+    let paymentMethodWhere = {};
+    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 (paymentStatus) {
+      const validPaymentStatus = new Set(Object.values(PaymentStatusEnum));
+      if (!validPaymentStatus.has(paymentStatus)) {
+        logger.warn("invalid payment status");
+        throw new Error(StatusMessage.PAYMENT_STATUS_INVALID);
+      }
+      paymentStatusWhere.PaymentStatusName = paymentStatus;
+    }
+    if (paymentType) {
+      const validPaymentType = new Set(Object.values(PaymentTypeEnum));
+      if (!validPaymentType.has(paymentType)) {
+        logger.warn("invalid payment type");
+        throw new Error(StatusMessage.PAYMENT_TYPE_INVALID);
+      }
+      paymentTypeWhere.PaymentTypeName = paymentType;
+    }
+    if (paymentMethod) {
+      const validPaymentMethod = new Set(Object.values(PaymentMethodEnum));
+      if (!validPaymentMethod.has(paymentMethod)) {
+        logger.warn("invalid payment method")
+        throw new Error(StatusMessage.PAYMENT_METHOD_INVALID);
+      }
+      paymentMethodWhere.PaymentMethodName = paymentMethod;
+    }
+    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,
+      },
+    };
+  }
+  static customerWhereClause(filters, tenantID, Sequelize, 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, Sequelize, logger) {
+    const { brandId, categoryId, IsActive, searchText, startDate, endDate } =
+      filters;
+    const brandWhere = {};
+    const categoryWhere = {};
+    const productWhereClause = {};
+    const parseIds = (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);
+    };
+    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 = parseIds(brandId);
+      brandWhere.BrandID = { [Sequelize.Op.in]: brandIds };
+    }
+    if (categoryId) {
+      const categoryIds = parseIds(categoryId);
+      categoryWhere.CategoryID = { [Sequelize.Op.in]: categoryIds };
+    }
+    return {
+      productWhereClause,
+      includeWhere: { brandWhere, categoryWhere },
+    };
+  }
+
+  static getDefaultOptions(whereClause, order = [['CreatedAt', 'DESC']]) {
+    return {
+      where: whereClause,
+      order: order
+    };
+  }
+}
+
+module.exports = QueryUtil;

package/utility/Razorpay.js

@@ -0,0 +1,67 @@
+const Razorpay = require('razorpay');
+const crypto = require('crypto');
+const StatusMessage = require('../constants/StatusMessageConstants');
+class RazorpayUtil {
+    constructor(razorpayKeys, logger) {
+        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;

package/utility/VariantPriceUtil.js

@@ -0,0 +1,55 @@
+const StatusMessage = require('../constants/StatusMessageConstants');
+const VariantPriceUtil = async function (
+    variantData
+  ) {
+    const { MRP, SellingPrice, DiscountPercentage } = variantData;
+
+    if (!MRP || MRP <= 0) {
+      throw new Error(StatusMessage.PRODUCTVARIANT_INVALID_MRP);
+    }
+
+    if (SellingPrice == null && DiscountPercentage == null) {
+      throw new Error(StatusMessage.PRODUCTVARIANT_MISSING_PRICE_OR_DISCOUNT);
+    }
+
+    let calculatedSellingPrice = SellingPrice;
+    let calculatedDiscountPercentage = DiscountPercentage;
+
+    if (SellingPrice != null && DiscountPercentage != null) {
+      // Consistency check when both are provided
+      const expectedDiscount = ((MRP - SellingPrice) / MRP) * 100;
+      if (Math.abs(expectedDiscount - DiscountPercentage) > 0.01) {
+        // Tolerance for floating point
+        throw new Error(StatusMessage.PRODUCTVARIANT_INCONSISTENT_PRICING);
+      }
+      // Use provided values since they are consistent
+      calculatedDiscountPercentage = DiscountPercentage;
+      calculatedSellingPrice = SellingPrice;
+    } else if (SellingPrice != null) {
+      if (SellingPrice > MRP) {
+        throw new Error(StatusMessage.PRODUCTVARIANT_SELLING_PRICE_EXCEEDS_MRP);
+      }
+      if (SellingPrice < 0) {
+        throw new Error(StatusMessage.PRODUCTVARIANT_INVALID_SELLING_PRICE);
+      }
+      calculatedDiscountPercentage = ((MRP - SellingPrice) / MRP) * 100;
+      calculatedDiscountPercentage = parseFloat(
+        calculatedDiscountPercentage.toFixed(2)
+      );
+    } else if (DiscountPercentage != null) {
+      if (DiscountPercentage < 0 || DiscountPercentage > 100) {
+        throw new Error(
+          StatusMessage.PRODUCTVARIANT_INVALID_DISCOUNT_PERCENTAGE
+        );
+      }
+      calculatedSellingPrice = MRP * (1 - DiscountPercentage / 100);
+      calculatedSellingPrice = parseFloat(calculatedSellingPrice.toFixed(2));
+    }
+
+    return {
+      ...variantData,
+      SellingPrice: calculatedSellingPrice,
+      DiscountPercentage: calculatedDiscountPercentage,
+    };
+  }
+  module.exports = VariantPriceUtil;