@b2y/ecommerce-common 1.2.1 → 1.2.2

package/.idea/ecommerce-common.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/ecommerce-common.iml" filepath="$PROJECT_DIR$/.idea/ecommerce-common.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/constants/AppConstants.js

@@ -10,6 +10,7 @@ const AppConstants = {
     CUSTOMER_PORTAL_DOMAIN: 'CustomerPortalDomain',
     ADMIN_PORTAL_DOMAIN: 'AdminPortalDomain',
     CREATED_BY:'0000d6ab-8064-4786-a906-f458567224b8',
-    BOOLEAN:'boolean'
+    BOOLEAN:'boolean',
+    OBJECT: 'object'
 }
 module.exports = AppConstants;

package/constants/StatusMessageConstants.js

@@ -3,6 +3,9 @@ const StatusMessageConstants = {
     FAILURE: 'FAILURE',
     INVALID_REQUEST: 'Invalid request parameters',
     SERVER_ERROR: 'Internal server error',
+    INVALID_JSON_FORMAT: 'Invalid JSON format in request body',
+    INVALID_SORT_ORDER: 'SortOrder must be integer',
+    FILE_NOT_FOUND: 'File not found',
     // Tenant
     TENANT_NOT_FOUND: 'Tenant not found',
     TENANT_ID_REQUIRED_FIELD: 'TenantID is required for updating the tenant',
@@ -22,10 +25,15 @@ const StatusMessageConstants = {
     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",
-
+    TENANT_SETTINGS_NOT_FOUND: 'Tenant settings not found',
+    TENANT_SETTINGS_IMAGE_UPLOAD_FAILED: 'Failed to upload company logo',
+    TENANT_SETTINGS_REQUIRED_FIELD: 'TenantID is required for tenant settings updation',
+    TENANT_SETTINGS_UPDATED_SUCCESS: 'Tenant settings updated successfully',
+    TENANT_SETTINGS_ALREADY_EXISTS: 'Tenant settings already exist for this tenant',
+    INVALID_REQUEST: 'Invalid request',
+    TENANT_SETTINGS_UPDATE_ERROR: 'Failed to update tenant settings',
+    TENANT_SETTINGS_SINGLE_LOGO_ALLOWED: "Only one logo is allowed per tenant.",
     //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",

package/controller/SubscriptionAbstractController.js

@@ -1,7 +1,7 @@
 const StatusMessage = require('../constants/StatusMessageConstants');
 const AppUtil = require('../utility/AppUtil');
 const LocationUtility = require('../utility/LocationUtility');
-const EntityTypeEnum = require('../enum/EntityTypeEnum');
+
 // getAllSubscriptionPlans
 const getAllSubscriptionPlans = (
   SubscriptionPlan,
@@ -56,129 +56,5 @@ const getAllSubscriptionPlans = (
   };
 };
 
-const getTenantSubscription = (
-  Tenant,
-  TenantSubscription,
-  SubscriptionPlan,
-  TenantSettings,
-  Document,
-  getPublicUrl,
-  logger,
-) => {
-  return async (req, res) => {
-    try {
-      const { id } = req.params;
-
-      const tenant = await Tenant.findOne({
-        where: { TenantID: id },
-        include: [
-          {
-            model: TenantSettings,
-            as: 'TenantSettings',
-            attributes: ['TenantSettingID']
-          },
-          {
-            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 documents = await Document.findAll({
-        where: {
-          EntityType: EntityTypeEnum.TENANT_SETTINGS,
-          EntityID: tenant.TenantSettings.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 { 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,
-        TenantLogo: logo,
-        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}
+module.exports = {getAllSubscriptionPlans}

package/controller/TenantAbstractController.js

@@ -3,7 +3,7 @@ const StatusMessage = require('../constants/StatusMessageConstants');
 const AppUtil = require('../utility/AppUtil');
 const SubscriptionStatusEnum = require('../enum/SubscriptionStatusEnum');
 const AppConstants = require('../constants/AppConstants');
-
+const EntityTypeEnum = require('../enum/EntityTypeEnum');
 const updateTenant = (
   Tenant,
   TenantSubscription,
@@ -348,5 +348,149 @@ const updateTenant = (
   };
 };
 
-module.exports = { updateTenant };
+const getTenantById = (
+  Tenant,
+  TenantSubscription,
+  SubscriptionPlan,
+  TenantSettings,
+  Document,
+  getPublicUrl,
+  logger,
+) => {
+  return async (req, res) => {
+    try {
+      const { id } = req.params;
+
+      const tenant = await Tenant.findOne({
+        where: { TenantID: id },
+        attributes: [
+          'TenantID',
+          'CompanyName',
+          'CompanyCode',
+          'Email',
+          'CountryCallingCode',
+          'PhoneNumber',
+          'GSTNo',
+          'CustomerPortalDomain',
+          'AdminPortalDomain',
+          'AddressLine',
+          'CityName', 
+          'StateCode',
+          'CountryCode',
+          'Zipcode',
+        ],
+        include: [
+          {
+            model: TenantSettings,
+            as: 'TenantSettings',
+            attributes: ['TenantSettingID']
+          },
+          {
+            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,
+        );
+      }
+      let logo = [];
+      if(tenant.TenantSettings) {
+      const documents = await Document.findAll({
+        where: {
+          EntityType: EntityTypeEnum.TENANT_SETTINGS,
+          EntityID: tenant.TenantSettings.TenantSettingID
+        },
+        order: [["SortOrder", "ASC"]]
+      });
+  
+       logo = await Promise.all(
+        documents.map(async (doc) => ({
+          documentId: doc.DocumentID,
+          sortOrder: doc.SortOrder,
+          documentUrl: await getPublicUrl(doc, logger)
+        }))
+      );
+    }
+      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,
+        TenantLogo: logo,
+        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 = { updateTenant, getTenantById };
 

package/controller/TenantSettingsAbstractController.js

@@ -1,6 +1,7 @@
 const EntityTypeEnum = require('../enum/EntityTypeEnum');
 const StatusMessage = require('../constants/StatusMessageConstants');
 const AppUtil = require('../utility/AppUtil');
+const AppConstants = require('../constants/AppConstants')
 
 const getTenantSettingsById = (TenantSettings, Document, getPublicUrl, logger) => {
 return async (req, res) => {
@@ -66,5 +67,166 @@ return async (req, res) => {
     }
   }}
 
-  module.exports = {getTenantSettingsById};
+  const updateTenantSettings = (TenantSettings, multer, upload, FileUploadUtil, FILE_PATHS, UpdatedBy, sequelize, logger) => {
+    return async (req, res) => {
+    upload(req, res, async (err) => {
+        if (err instanceof multer.MulterError || err) {
+            logger.error('Upload Error:', err);
+            return AppUtil.generateResponse(
+                400,
+                StatusMessage.FAILURE,
+                StatusMessage.TENANT_SETTINGS_IMAGE_UPLOAD_FAILED,
+                null,
+                res
+            );
+        }
+
+        let transaction;
+        let uploadedFilePath = [];
+        try {
+            let data;
+            try {
+                data = req.body.data ? JSON.parse(req.body.data) : req.body;
+            } catch (error) {
+                logger.error('Invalid JSON in request body', error);
+                return AppUtil.generateResponse(
+                    400,
+                    StatusMessage.FAILURE,
+                    StatusMessage.INVALID_JSON_FORMAT,
+                    null,
+                    res
+                );
+            }
+
+            const {
+                TenantSettingID,
+                TenantID,
+                ThemeColour,
+                documentMetadata
+            } = data;
+
+            // Validation
+            if (!TenantSettingID && !TenantID) {
+                logger.warn('TenantSettingID or TenantID is required for update.');
+                return AppUtil.generateResponse(
+                    400,
+                    StatusMessage.FAILURE,
+                    StatusMessage.TENANT_SETTINGS_REQUIRED_FIELD,
+                    null,
+                    res
+                );
+            }
+
+            // Find existing settings
+            const whereClause = TenantSettingID ? { TenantSettingID } : { TenantID };
+            const existingSettings = await TenantSettings.findOne({ where: whereClause });
+            
+            if (!existingSettings) {
+                logger.warn('Tenant settings not found for update', whereClause);
+                return AppUtil.generateResponse(
+                    404,
+                    StatusMessage.FAILURE,
+                    StatusMessage.TENANT_SETTINGS_NOT_FOUND,
+                    null,
+                    res
+                );
+            }
+
+            // Upload new file to storage before starting transaction
+            let uploadResult = [];
+            if (documentMetadata !== undefined) {
+              if (
+                typeof documentMetadata !== AppConstants.OBJECT ||
+                Array.isArray(documentMetadata)
+              ) {
+                logger.warn(
+                  "Validation Failed: documentMetadata must be a single object for this operation.",
+                );
+                return AppUtil.generateResponse(
+                  400,
+                  StatusMessage.FAILURE,
+                  StatusMessage.TENANT_SETTINGS_SINGLE_LOGO_ALLOWED, 
+                  null,
+                  res,
+                );
+              }
+                logger.info('Uploading new files to storage before transaction');
+                uploadResult = await FileUploadUtil.uploadFilesToStorage(
+                    documentMetadata,
+                    req.files,
+                    FILE_PATHS.IMAGE_DIR
+                );
+                uploadedFilePath = uploadResult.map(r => r.path);
+            }
+
+            // Start database transaction
+            transaction = await sequelize.transaction();
+
+            // Update tenant settings
+            const updatePayload = {};
+            if (ThemeColour !== undefined) updatePayload.ThemeColour = ThemeColour;
+            updatePayload.UpdatedBy = UpdatedBy;
+            updatePayload.UpdatedAt = new Date();
+
+            await existingSettings.update(updatePayload, { transaction });
+
+            // Save/Update documents (handles both create and replace logic)
+            if (uploadResult.length > 0) {
+                logger.info('Saving document records for TenantSettingID:', existingSettings.TenantSettingID);
+                
+                await FileUploadUtil.saveDocumentRecords(
+                    uploadResult,
+                    EntityTypeEnum.TENANT_SETTINGS,
+                    existingSettings.TenantSettingID,
+                    existingSettings.TenantID,
+                    UpdatedBy,
+                    transaction
+                );
+            }
+
+            await transaction.commit();
+            logger.info('Tenant settings updated successfully');
+
+            return AppUtil.generateResponse(
+                200,
+                StatusMessage.SUCCESS,
+                StatusMessage.TENANT_SETTINGS_UPDATED_SUCCESS,
+                null,
+                res
+            );
+
+        } catch (error) {
+            if (transaction) await transaction.rollback();
+
+            // Cleanup newly uploaded files if transaction failed
+            if (uploadedFilePath.length > 0) {
+                logger.info('Cleaning up uploaded files due to error');
+                await FileUploadUtil.cleanupFiles(uploadedFilePath);
+            }
+
+            // Error handling
+            if (error.message === StatusMessage.INVALID_SORT_ORDER) {
+                return AppUtil.generateResponse(400, StatusMessage.FAILURE, StatusMessage.INVALID_SORT_ORDER, null, res);
+            }
+            if (error.message === StatusMessage.FILE_NOT_FOUND) {
+                return AppUtil.generateResponse(400, StatusMessage.FAILURE, StatusMessage.FILE_NOT_FOUND, null, res);
+            }
+            if(error.message === StatusMessage.INVALID_FILE_UPLOAD_INPUT) {
+                return AppUtil.generateResponse(400, StatusMessage.FAILURE, StatusMessage.INVALID_FILE_UPLOAD_INPUT, null, res);
+            }
+            if (error.name === 'SequelizeUniqueConstraintError') {
+                return AppUtil.generateResponse(400, StatusMessage.FAILURE, StatusMessage.TENANT_SETTINGS_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 updateTenantSettings:", error);
+                return AppUtil.generateResponse(500, StatusMessage.FAILURE, StatusMessage.TENANT_SETTINGS_UPDATE_ERROR, null, res);
+            }
+        }
+    });
+};
+  }
+  module.exports = {getTenantSettingsById, updateTenantSettings};
   

package/package.json

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