@b2y/ecommerce-common 1.1.6 → 1.1.7

package/constants/AppConstants.js

@@ -3,5 +3,13 @@ const AppConstants = {
     LAST_30DAYS: 'LAST30DAYS',
     LAST_6MONTHS: 'LAST6MONTHS',
     OLDER: 'OLDER',
+    COMPANY_NAME: 'CompanyName',
+    COMPANY_CODE: 'CompanyCode',
+    EMAIL: 'Email',
+    PHONE_NUMBER: 'PhoneNumber',
+    CUSTOMER_PORTAL_DOMAIN: 'CustomerPortalDomain',
+    ADMIN_PORTAL_DOMAIN: 'AdminPortalDomain',
+    CREATED_BY:'0000d6ab-8064-4786-a906-f458567224b8',
+    BOOLEAN:'boolean'
 }
 module.exports = AppConstants;

package/constants/StatusMessageConstants.js

@@ -1,4 +1,41 @@
 const StatusMessageConstants = {
+    SUCCESS: 'Success',
+    FAILURE: 'Failure',
+    INVALID_REQUEST: 'Invalid request parameters',
+    SERVER_ERROR: 'Internal server error',
+    // Tenant
+    TENANT_NOT_FOUND: 'Tenant not found',
+    TENANT_ID_REQUIRED_FIELD: 'TenantID is required for updating the tenant',
+    TENANT_UPDATED_SUCCESS: 'Tenant updated successfully',
+    TENANT_UPDATE_ERROR: 'Failed to update tenant',
+    TENANT_ALREADY_EXISTS: 'Tenant with this information already exists',
+    INVALID_EMAIL_FORMAT: 'Invalid email format provided',
+    INVALID_PHONE_FORMAT: 'Phone number must be 10-20 digits',
+    INVALID_COMPANY_CODE: 'Company code must be a valid positive integer',
+    INVALID_SUBSCRIPTION_STATUS: "Invalid subscription status",
+    COMPANY_NAME_EXISTS: 'Company name already exists',
+    COMPANY_CODE_EXISTS: 'Company code already exists',
+    EMAIL_EXISTS: 'Email already exists',
+    PHONE_NUMBER_EXISTS: 'Phone number already exists',
+    CUSTOMER_PORTAL_DOMAIN_EXISTS: 'Customer portal domain already exists',
+    ADMIN_PORTAL_DOMAIN_EXISTS: 'Admin portal domain already exists',
+    INVALID_START_END_DATE: 'End date can not be before start date',
+    SUBSCRIPTION_PLAN_NOT_FOUND: "Subscription plan not found",
+    INVALID_BOOLEAN_TYPE: "{field} must be boolean value",
+
+    //TenantSettings
+    TENANT_SETTINGS_NOT_FOUND: "Tenant settings not foundd",
+
+    //Location
+    STATE_CODE_COUNTRY_CODE_REQUIRE: "State code and country code are required to fetch cities",
+    CITIES_NOT_FOUND: "No cities found for given state code",
+    COUNTRY_CODE_REQUIRE: "Country code is required to fetch states",
+    STATES_NOT_FOUND: "No states found for given country code",
+    STATES_FETCH_ERROR: "Error occured while fetching states",
+    CITIES_FETCH_ERROR: "Error occurred while fetching cities",
+    COUNTRIES_FETCH_ERROR: "Error occurred while fetching countries",
+
+    // Product Variant
     PRODUCTVARIANT_INVALID_MRP: 'Invalid MRP: must be positive',
     PRODUCTVARIANT_MISSING_PRICE_OR_DISCOUNT: 'Either SellingPrice or DiscountPercentage must be provided',
     PRODUCTVARIANT_INCONSISTENT_PRICING: 'Inconsistent pricing: provided discount percentage does not match calculated value',

package/controller/LocationController.js

@@ -0,0 +1,144 @@
+const {
+  getCountries,
+  getStatesOfCountry,
+  getCitiesOfState,
+} = require("@countrystatecity/countries");
+const AppUtil = require("../utility/AppUtil");
+const StatusMessage = require("../constants/StatusMessageConstants");
+
+// Get all cities by state filters
+const getCitiesByState = (logger) => {
+return async (req, res) => {
+  try {
+    const { countryCode, stateCode } = req.params;
+    if (!countryCode || !stateCode) {
+      return AppUtil.generateResponse(
+        400,
+        StatusMessage.FAILURE,
+        StatusMessage.STATE_CODE_COUNTRY_CODE_REQUIRE,
+        null,
+        res,
+      );
+    }
+    const cities = await getCitiesOfState(countryCode, stateCode);
+    if (!cities || cities.length === 0) {
+      logger.debug("No cities found for state code:", stateCode);
+      return AppUtil.generateResponse(
+        200,
+        StatusMessage.SUCCESS,
+        StatusMessage.CITIES_NOT_FOUND,
+        null,
+        res,
+      );
+    }
+    const cityNames = cities.map((c) => ({
+      CityName: c.name,
+      latitude: c.latitude,
+      longitude: c.longitude,
+    }));
+    logger.debug("cities retrieved successfully");
+    return AppUtil.generateResponse(
+      200,
+      StatusMessage.SUCCESS,
+      null,
+      cityNames,
+      res,
+    );
+  } catch (error) {
+    logger.error("Invalid filter format:", error);
+    return AppUtil.generateResponse(
+      500,
+      StatusMessage.FAILURE,
+      StatusMessage.CITIES_FETCH_ERROR,
+      null,
+      res,
+    );
+  }
+};
+}
+
+const getStatesByCountry = (logger) => {
+return async (req, res) => {
+  try {
+    const { countryCode } = req.params;
+    if (!countryCode) {
+      return AppUtil.generateResponse(
+        400,
+        StatusMessage.FAILURE,
+        StatusMessage.COUNTRY_CODE_REQUIRE,
+        null,
+        res,
+      );
+    }
+    const states = await getStatesOfCountry(countryCode);
+    if (!states || states.length === 0) {
+      logger.debug("No states found for country code:", countryCode);
+      return AppUtil.generateResponse(
+        200,
+        StatusMessage.SUCCESS,
+        StatusMessage.STATES_NOT_FOUND,
+        null,
+        res,
+      );
+    }
+    // Transform to simpler format
+    const formattedStates = states.map((s) => ({
+      Code: s.iso2,
+      StateName: s.name,
+      StateCode: s.state_code,
+    }));
+    logger.debug("States retrieved successfully");
+    return AppUtil.generateResponse(
+      200,
+      StatusMessage.SUCCESS,
+      null,
+      formattedStates,
+      res,
+    );
+  } catch (error) {
+    logger.error("Error searching for country:", error);
+    return AppUtil.generateResponse(
+      500,
+      StatusMessage.FAILURE,
+      StatusMessage.STATES_FETCH_ERROR,
+      null,
+      res,
+    );
+  }
+};
+}
+
+//Getall countries list
+const getAllCountries = (logger) => {
+return async (req, res) => {
+  try {
+    const countries = await getCountries();
+    // transform to simpler format
+    const formattedCountries = countries.map((country) => ({
+      CountryCode: country.iso2,
+      CountryName: country.name,
+      iso3: country.iso3,
+      PhoneCode: country.phonecode,
+      flag: country.emoji,
+    }));
+    return AppUtil.generateResponse(
+      200,
+      StatusMessage.SUCCESS,
+      null,
+      formattedCountries,
+      res,
+    );
+  } catch (error) {
+    logger.error("Error fetching countries:", error);
+    return AppUtil.generateResponse(
+      500,
+      StatusMessage.FAILURE,
+      StatusMessage.COUNTRIES_FETCH_ERROR,
+      null,
+      res,
+    );
+  }
+};
+}
+
+module.exports = { getCitiesByState, getStatesByCountry, getAllCountries };

package/controller/SubscriptionAbstractController.js

@@ -0,0 +1,161 @@
+const StatusMessage = require('../constants/StatusMessageConstants');
+const AppUtil = require('../utility/AppUtil');
+const LocationUtility = require('../utility/LocationUtility');
+
+// getAllSubscriptionPlans
+const getAllSubscriptionPlans = (
+  SubscriptionPlan,
+  SubscriptionFeature,
+  logger,
+) => {
+  return async (req, res) => {
+    const { pageNumber, pageSize } = req.query;
+    const { limit, offset } = AppUtil.getPagination(pageNumber, pageSize);
+    try {
+      const { rows, count } = await SubscriptionPlan.findAndCountAll({
+        attributes: [
+          "SubscriptionPlanID",
+          "PlanName",
+          "PlanCode",
+          "Price",
+          "BillingCycle",
+          "Currency",
+          "TrialPeriodDays",
+          "IsActive",
+        ],
+        include: [
+          {
+            model: SubscriptionFeature,
+            as: "Features",
+            attributes: ["SubscriptionFeatureID", "FeatureName", "FeatureCode"],
+            through: { attributes: ["FeatureValue"] },
+          },
+        ],
+        limit,
+        offset,
+        distinct: true,
+      });
+      logger.debug("subscription plans fetched successfully");
+      return AppUtil.generateResponse(
+        200,
+        StatusMessage.SUCCESS,
+        null,
+        { rows, count, pageNumber, limit },
+        res,
+      );
+    } catch (error) {
+      logger.error("error occurred while fetching subscription plans", error);
+      return AppUtil.generateResponse(
+        500,
+        StatusMessage.FAILURE,
+        StatusMessage.SERVER_ERROR,
+        null,
+        res,
+      );
+    }
+  };
+};
+
+const getTenantSubscription = (
+  Tenant,
+  TenantSubscription,
+  SubscriptionPlan,
+  logger,
+) => {
+  return async (req, res) => {
+    try {
+      const { id } = req.params;
+
+      const tenant = await Tenant.findOne({
+        where: { TenantID: id },
+        include: [
+          {
+            model: TenantSubscription,
+            as: "CurrentSubscription",
+            attributes: [
+              "TenantSubscriptionID",
+              "Status",
+              "StartDate",
+              "EndDate",
+              "GraceEndDate",
+              "TrialEndDate",
+              "IsTrial",
+              "AutoRenew",
+            ],
+            include: [
+              {
+                model: SubscriptionPlan,
+                as: "SubscriptionPlan",
+                attributes: ["SubscriptionPlanID", "PlanName", "PlanCode"],
+              },
+            ],
+          },
+        ],
+      });
+
+      if (!tenant) {
+        return AppUtil.generateResponse(
+          404,
+          StatusMessage.FAILURE,
+          StatusMessage.TENANT_NOT_FOUND,
+          null,
+          res,
+        );
+      }
+
+      const { countryName, stateName } =
+        await LocationUtility.resolveCountryAndState(
+          tenant.CountryCode,
+          tenant.StateCode,
+          logger,
+        );
+
+      const formattedTenant = {
+        TenantID: tenant.TenantID,
+        CompanyName: tenant.CompanyName,
+        CompanyCode: tenant.CompanyCode,
+        Email: tenant.Email,
+        CountryCallingCode: tenant.CountryCallingCode,
+        PhoneNumber: tenant.PhoneNumber,
+        GSTNo: tenant.GSTNo,
+        CustomerPortalDomain: tenant.CustomerPortalDomain,
+        AdminPortalDomain: tenant.AdminPortalDomain,
+        AddressLine: tenant.AddressLine,
+        CityName: tenant.CityName,
+        StateCode: tenant.StateCode,
+        StateName: stateName,
+        CountryCode: tenant.CountryCode,
+        CountryName: countryName,
+        Zipcode: tenant.Zipcode,
+        SubscriptionPlanID: tenant.CurrentSubscription?.SubscriptionPlan?.SubscriptionPlanID,
+        PlanName: tenant.CurrentSubscription?.SubscriptionPlan?.PlanName,
+        TenantSubscriptionStatus: tenant.CurrentSubscription?.Status,
+        StartDate: tenant.CurrentSubscription?.StartDate,
+        EndDate: tenant.CurrentSubscription?.EndDate,
+        GraceEndDate: tenant.CurrentSubscription?.GraceEndDate,
+        TrialEndDate: tenant.CurrentSubscription?.TrialEndDate,
+        IsTrial: tenant.CurrentSubscription?.IsTrial,
+        AutoRenew: tenant.CurrentSubscription?.AutoRenew,
+      };
+
+      return AppUtil.generateResponse(
+        200,
+        StatusMessage.SUCCESS,
+        null,
+        formattedTenant,
+        res,
+      );
+    } catch (error) {
+      logger.error("Error fetching tenant:", error);
+      return AppUtil.generateResponse(
+        500,
+        StatusMessage.FAILURE,
+        StatusMessage.SERVER_ERROR,
+        null,
+        res,
+      );
+    }
+  };
+};
+
+module.exports = {getAllSubscriptionPlans, getTenantSubscription}

package/controller/TenantAbstractController.js

@@ -0,0 +1,349 @@
+const LocationUtility = require('../utility/LocationUtility');
+const StatusMessage = require('../constants/StatusMessageConstants');
+const AppUtil = require('../utility/AppUtil');
+const SubscriptionStatusEnum = require('../enum/SubscriptionStatusEnum');
+const AppConstants = require('../constants/AppConstants');
+
+const updateTenant = (
+  Tenant,
+  TenantSubscription,
+  SubscriptionPlan,
+  sequelize,
+  logger,
+) => {
+  return async (req, res) => {
+    let transaction;
+    try {
+      const tenantId =
+        req.params && req.params.TenantID
+          ? req.params.TenantID
+          : req.body.TenantID;
+      if (!tenantId) {
+        logger.warn("TenantID is required for update.");
+        return AppUtil.generateResponse(
+          400,
+          StatusMessage.FAILURE,
+          StatusMessage.TENANT_ID_REQUIRED_FIELD,
+          null,
+          res,
+        );
+      }
+
+      const existing = await Tenant.findOne({ where: { TenantID: tenantId } });
+      if (!existing) {
+        logger.warn("Tenant not found with ID:", tenantId);
+        return AppUtil.generateResponse(
+          404,
+          StatusMessage.FAILURE,
+          StatusMessage.TENANT_NOT_FOUND,
+          null,
+          res,
+        );
+      }
+
+      const {
+        CompanyName,
+        CompanyCode,
+        Email,
+        PhoneNumber,
+        CountryCallingCode,
+        GSTNo,
+        CustomerPortalDomain,
+        AdminPortalDomain,
+        AddressLine,
+        CityName,
+        StateCode,
+        CountryCode,
+        Zipcode,
+        SubscriptionPlanID,
+        Status,
+        StartDate,
+        EndDate,
+        AutoRenew,
+        IsTrial,
+        GraceEndDate,
+        TrialEndDate,
+      } = req.body;
+
+      // Validate optional fields when provided
+      if (Email && !AppUtil.isValidEmail(Email)) {
+        logger.warn("Invalid email format provided for update.");
+        return AppUtil.generateResponse(
+          400,
+          StatusMessage.FAILURE,
+          StatusMessage.INVALID_EMAIL_FORMAT,
+          null,
+          res,
+        );
+      }
+
+      if (PhoneNumber && !AppUtil.isValidPhone(PhoneNumber)) {
+        logger.warn("Invalid phone number format provided for update.");
+        return AppUtil.generateResponse(
+          400,
+          StatusMessage.FAILURE,
+          StatusMessage.INVALID_PHONE_FORMAT,
+          null,
+          res,
+        );
+      }
+
+      if (CompanyCode !== undefined) {
+        if (
+          !Number.isInteger(Number(CompanyCode)) ||
+          Number(CompanyCode) <= 0
+        ) {
+          logger.warn("Invalid company code provided for update.");
+          return AppUtil.generateResponse(
+            400,
+            StatusMessage.FAILURE,
+            StatusMessage.INVALID_COMPANY_CODE,
+            null,
+            res,
+          );
+        }
+      }
+
+      // Validate country code, state code and city name
+      if (CountryCode && StateCode && CityName && CountryCallingCode) {
+        const validation = await LocationUtility.validateCountryAndState(
+          CountryCode,
+          StateCode,
+          CityName,
+          CountryCallingCode,
+          logger,
+        );
+        if (!validation.isValid) {
+          return AppUtil.generateResponse(
+            400,
+            StatusMessage.FAILURE,
+            validation.error,
+            null,
+            res,
+          );
+        }
+      }
+      if (Status && !Object.values(SubscriptionStatusEnum).includes(Status)) {
+        logger.warn("Invalid Subscription status");
+        return AppUtil.generateResponse(
+          400,
+          StatusMessage.FAILURE,
+          StatusMessage.INVALID_SUBSCRIPTION_STATUS,
+          null,
+          res,
+        );
+      }
+
+      if (
+        AutoRenew !== undefined &&
+        typeof AutoRenew !== AppConstants.BOOLEAN
+      ) {
+        logger.warn("AutoRenew must be boolean type");
+        return AppUtil.generateResponse(
+          400,
+          StatusMessage.FAILURE,
+          StatusMessage.INVALID_BOOLEAN_TYPE.replace("{field}", "AutoRenew"),
+          null,
+          res,
+        );
+      }
+      if (IsTrial !== undefined && typeof IsTrial !== AppConstants.BOOLEAN) {
+        logger.warn("IsTrial must be boolean type");
+        return AppUtil.generateResponse(
+          400,
+          StatusMessage.FAILURE,
+          StatusMessage.INVALID_BOOLEAN_TYPE.replace("{field}", "IsTrial"),
+          null,
+          res,
+        );
+      }
+      transaction = await sequelize.transaction();
+      if (SubscriptionPlanID) {
+        const subscriptionPlan = await SubscriptionPlan.findOne({
+          where: {
+            SubscriptionPlanID,
+            IsActive: true,
+          },
+          transaction,
+        });
+        if (!subscriptionPlan) {
+          await transaction.rollback();
+          logger.warn("subscription plan not found");
+          return AppUtil.generateResponse(
+            404,
+            StatusMessage.FAILURE,
+            StatusMessage.SUBSCRIPTION_PLAN_NOT_FOUND,
+            null,
+            res,
+          );
+        }
+      }
+      // Build update payload only with provided fields
+      const updatePayload = {};
+      const fields = {
+        CompanyName,
+        CompanyCode,
+        Email,
+        PhoneNumber,
+        CountryCode,
+        GSTNo,
+        CustomerPortalDomain,
+        AdminPortalDomain,
+        AddressLine,
+        CityName,
+        StateCode,
+        CountryCallingCode,
+        Zipcode,
+      };
+      Object.keys(fields).forEach((k) => {
+        if (fields[k] !== undefined)
+          updatePayload[k] =
+            k === AppConstants.COMPANY_CODE ? Number(fields[k]) : fields[k];
+      });
+
+      updatePayload.UpdatedBy =
+        AppConstants.UPDATED_BY || AppConstants.CREATED_BY;
+      updatePayload.UpdatedAt = new Date();
+
+      await existing.update(updatePayload, { transaction });
+
+      // update subscription
+      const updateSubscriptionPayload = {};
+      const updateSubscriptionfields = {
+        SubscriptionPlanID,
+        Status,
+        StartDate,
+        EndDate,
+        GraceEndDate,
+        TrialEndDate,
+        IsTrial,
+        AutoRenew,
+      };
+      Object.keys(updateSubscriptionfields).forEach((k) => {
+        if (updateSubscriptionfields[k] !== undefined)
+          updateSubscriptionPayload[k] = updateSubscriptionfields[k];
+      });
+      if (Object.keys(updateSubscriptionPayload).length !== 0) {
+        updateSubscriptionPayload.UpdatedBy = AppConstants.CREATED_BY;
+        updateSubscriptionPayload.UpdatedAt = new Date();
+
+        // find the existing subscription
+        const tenantSubscription = await TenantSubscription.findOne({
+          where: {
+            TenantID: tenantId,
+          },
+          transaction,
+        });
+        if (tenantSubscription) {
+          await tenantSubscription.update(updateSubscriptionPayload, {
+            transaction,
+          });
+        } else {
+          await TenantSubscription.create(
+            {
+              TenantID: tenantId,
+              ...updateSubscriptionPayload,
+              CreatedBy: AppConstants.CREATED_BY,
+              CreatedAt: new Date(),
+            },
+            { transaction },
+          );
+        }
+      }
+      await transaction.commit();
+
+      logger.info("Tenant updated successfully with ID:", tenantId);
+      return AppUtil.generateResponse(
+        200,
+        StatusMessage.SUCCESS,
+        StatusMessage.TENANT_UPDATED_SUCCESS,
+        null,
+        res,
+      );
+    } catch (error) {
+      if (transaction) await transaction.rollback();
+
+      if (error.name === "SequelizeUniqueConstraintError") {
+        const detail = error.original?.detail || "";
+        if (detail.includes(AppConstants.COMPANY_NAME)) {
+          return AppUtil.generateResponse(
+            400,
+            StatusMessage.FAILURE,
+            StatusMessage.COMPANY_NAME_EXISTS,
+            null,
+            res,
+          );
+        } else if (detail.includes(AppConstants.COMPANY_CODE)) {
+          return AppUtil.generateResponse(
+            400,
+            StatusMessage.FAILURE,
+            StatusMessage.COMPANY_CODE_EXISTS,
+            null,
+            res,
+          );
+        } else if (detail.includes(AppConstants.EMAIL)) {
+          return AppUtil.generateResponse(
+            400,
+            StatusMessage.FAILURE,
+            StatusMessage.EMAIL_EXISTS,
+            null,
+            res,
+          );
+        } else if (detail.includes(AppConstants.PHONE_NUMBER)) {
+          return AppUtil.generateResponse(
+            400,
+            StatusMessage.FAILURE,
+            StatusMessage.PHONE_NUMBER_EXISTS,
+            null,
+            res,
+          );
+        } else if (detail.includes(AppConstants.CUSTOMER_PORTAL_DOMAIN)) {
+          return AppUtil.generateResponse(
+            400,
+            StatusMessage.FAILURE,
+            StatusMessage.CUSTOMER_PORTAL_DOMAIN_EXISTS,
+            null,
+            res,
+          );
+        } else if (detail.includes(AppConstants.ADMIN_PORTAL_DOMAIN)) {
+          return AppUtil.generateResponse(
+            400,
+            StatusMessage.FAILURE,
+            StatusMessage.ADMIN_PORTAL_DOMAIN_EXISTS,
+            null,
+            res,
+          );
+        }
+        return AppUtil.generateResponse(
+          400,
+          StatusMessage.FAILURE,
+          StatusMessage.TENANT_ALREADY_EXISTS,
+          null,
+          res,
+        );
+      } else if (error.name === "SequelizeValidationError") {
+        const details = error.errors.map((e) => e.message);
+        logger.warn(`Validation Error detected: ${details.join("; ")}`);
+        return AppUtil.generateResponse(
+          400,
+          StatusMessage.FAILURE,
+          StatusMessage.INVALID_REQUEST,
+          null,
+          res,
+        );
+      } else {
+        logger.error("Error in UpdateTenant:", error);
+        return AppUtil.generateResponse(
+          500,
+          StatusMessage.FAILURE,
+          StatusMessage.TENANT_UPDATE_ERROR,
+          null,
+          res,
+        );
+      }
+    }
+  };
+};
+
+module.exports = { updateTenant };
+

package/controller/TenantSettingsAbstractController.js

@@ -0,0 +1,70 @@
+const EntityTypeEnum = require('../enum/EntityTypeEnum');
+const StatusMessage = require('../constants/StatusMessageConstants');
+const AppUtil = require('../utility/AppUtil');
+
+const getTenantSettingsById = (TenantSettings, Document, getPublicUrl, logger) => {
+return async (req, res) => {
+    try {
+      const { id } = req.params;
+  
+      const settings = await TenantSettings.findOne({
+        where: {
+          TenantID: id
+        },
+        attributes: ["TenantSettingID", "TenantID", "ThemeColour"],
+      });
+  
+      if (!settings) {
+        return AppUtil.generateResponse(
+          404,
+          StatusMessage.FAILURE,
+          StatusMessage.TENANT_SETTINGS_NOT_FOUND,
+          null,
+          res
+        );
+      }
+  
+      const documents = await Document.findAll({
+        where: {
+          EntityType: EntityTypeEnum.TENANT_SETTINGS,
+          EntityID: settings.TenantSettingID
+        },
+        order: [["SortOrder", "ASC"]]
+      });
+  
+      const logo = await Promise.all(
+        documents.map(async (doc) => ({
+          documentId: doc.DocumentID,
+          sortOrder: doc.SortOrder,
+          documentUrl: await getPublicUrl(doc, logger)
+        }))
+      );
+      const formattedSettings = {
+        TenantSettingID: settings.TenantSettingID,
+        TenantID: settings.TenantID,
+        ThemeColour: settings.ThemeColour,
+        Logo: logo
+      };
+
+      return AppUtil.generateResponse(
+        200,
+        StatusMessage.SUCCESS,
+        null,
+        formattedSettings,
+        res
+      );
+  
+    } catch (error) {
+      logger.error("Error fetching tenant settings:", error);
+      return AppUtil.generateResponse(
+        500,
+        StatusMessage.FAILURE,
+        StatusMessage.SERVER_ERROR,
+        null,
+        res
+      );
+    }
+  }}
+
+  module.exports = {getTenantSettingsById};
+  

package/index.js

@@ -1,7 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 const initializeModels = require('./dbconnection/Connect');
-
+const SubscriptionAbstractController = require('./controller/SubscriptionAbstractController');
+const TenantAbstractController = require('./controller/TenantAbstractController');
+const TenantSettingsAbstractController = require('./controller/TenantSettingsAbstractController');
+const LocationController = require('./controller/LocationController');
 const enums = {};
 const enumDir = path.join(__dirname, 'enum');
 fs.readdirSync(enumDir).forEach((file) => {
@@ -19,4 +22,4 @@ fs.readdirSync(utilDir).forEach((file) => {
   }
 })
 
-module.exports = {initializeModels, enums, utils}
+module.exports = {initializeModels, enums, utils, SubscriptionAbstractController, TenantAbstractController, TenantSettingsAbstractController, LocationController}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b2y/ecommerce-common",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "E-commerce common library",
   "main": "index.js",
   "scripts": {