@b2y/ecommerce-common 1.1.5 → 1.1.7

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};
+