storemw-core-api 1.0.17 → 1.0.18

package/dist/controllers/item/itemController.js

@@ -54,6 +54,141 @@ const createItem = async (req, res, next) => {
         let response = {};
         let reqScope = req.body.scope;
         let reqPayload = req.body.payload;
+        if (requestItemType === "product") {
+            let request = payload_1.schemaItemProductCreatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action
+                },
+                payload: {
+                    product: {
+                        itemName: reqPayload.product.item_name,
+                        productCode: reqPayload.product.product_code,
+                        model: reqPayload.product.model,
+                        description: reqPayload.product.description,
+                        categoryId: reqPayload.product.category_id,
+                        brandId: reqPayload.product.brand_id,
+                        summary: reqPayload.product.summary,
+                        status: reqPayload.product.status,
+                    },
+                    item: {
+                        productId: reqPayload.item.product_id,
+                        code: reqPayload.item.code,
+                        skuCode: reqPayload.item.sku_code,
+                        uomId: reqPayload.item.uom_id,
+                        status: reqPayload.item.status,
+                        isPackage: reqPayload.item.is_package,
+                        itemDescription: reqPayload.item.item_description,
+                        remark: reqPayload.item.remark,
+                        cost: reqPayload.item.cost,
+                        uomPrice: reqPayload.item.uom_price,
+                        floorPrice: reqPayload.item.floor_price,
+                        grossWeight: reqPayload.item.gross_weight,
+                        volumeWeight: reqPayload.item.volume_weight,
+                        netWeight: reqPayload.item.net_weight,
+                        dimensionWidth: reqPayload.item.dimension_width,
+                        dimensionHeight: reqPayload.item.dimension_height,
+                        dimensionLength: reqPayload.item.dimension_length,
+                        cbm: reqPayload.item.cbm,
+                    }
+                }
+            });
+            let payload = {
+                itemType: requestItemType,
+                data: {
+                    product: {
+                        itemName: request.payload.product.itemName,
+                        brandId: request.payload.product.brandId,
+                        categoryId: request.payload.product.categoryId,
+                        model: request.payload.product.model,
+                        description: request.payload.product.description,
+                        productCode: request.payload.product.productCode,
+                        status: Boolean(request.payload.product.status),
+                        summary: request.payload.product.summary,
+                    },
+                    item: {
+                        code: request.payload.item.code,
+                        skuCode: request.payload.item.skuCode,
+                        uomId: request.payload.item.uomId,
+                        status: Boolean(request.payload.item.status),
+                        isPackage: Boolean(request.payload.item.isPackage),
+                        itemDescription: request.payload.item.itemDescription,
+                        remark: request.payload.item.remark,
+                        cost: request.payload.item.cost,
+                        uomPrice: request.payload.item.uomPrice,
+                        floorPrice: request.payload.item.floorPrice,
+                        grossWeight: request.payload.item.grossWeight,
+                        volumeWeight: request.payload.item.volumeWeight,
+                        netWeight: request.payload.item.netWeight,
+                        dimensionWidth: request.payload.item.dimensionWidth,
+                        dimensionHeight: request.payload.item.dimensionHeight,
+                        dimensionLength: request.payload.item.dimensionLength,
+                        cbm: request.payload.item.cbm,
+                    }
+                }
+            };
+            response = {
+                [`${getRootName(requestItemType, true)}`]: await itemService.createItem(payload)
+            };
+        }
+        if (requestItemType === "item") {
+            let request = payload_1.schemaItemItemCreatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action
+                },
+                payload: {
+                    item: {
+                        productId: reqPayload.item.product_id,
+                        code: reqPayload.item.code,
+                        skuCode: reqPayload.item.sku_code,
+                        uomId: reqPayload.item.uom_id,
+                        status: reqPayload.item.status,
+                        isPackage: reqPayload.item.is_package,
+                        itemDescription: reqPayload.item.item_description,
+                        remark: reqPayload.item.remark,
+                        cost: reqPayload.item.cost,
+                        uomPrice: reqPayload.item.uom_price,
+                        floorPrice: reqPayload.item.floor_price,
+                        grossWeight: reqPayload.item.gross_weight,
+                        volumeWeight: reqPayload.item.volume_weight,
+                        netWeight: reqPayload.item.net_weight,
+                        dimensionWidth: reqPayload.item.dimension_width,
+                        dimensionHeight: reqPayload.item.dimension_height,
+                        dimensionLength: reqPayload.item.dimension_length,
+                        cbm: reqPayload.item.cbm,
+                    }
+                }
+            });
+            let payload = {
+                itemType: requestItemType,
+                data: {
+                    item: {
+                        productId: request.payload.item.productId,
+                        code: request.payload.item.code,
+                        skuCode: request.payload.item.skuCode,
+                        uomId: request.payload.item.uomId,
+                        status: Boolean(request.payload.item.status),
+                        isPackage: Boolean(request.payload.item.isPackage),
+                        itemDescription: request.payload.item.itemDescription,
+                        remark: request.payload.item.remark,
+                        cost: request.payload.item.cost,
+                        uomPrice: request.payload.item.uomPrice,
+                        floorPrice: request.payload.item.floorPrice,
+                        grossWeight: request.payload.item.grossWeight,
+                        volumeWeight: request.payload.item.volumeWeight,
+                        netWeight: request.payload.item.netWeight,
+                        dimensionWidth: request.payload.item.dimensionWidth,
+                        dimensionHeight: request.payload.item.dimensionHeight,
+                        dimensionLength: request.payload.item.dimensionLength,
+                        cbm: request.payload.item.cbm,
+                    }
+                }
+            };
+            response = {
+                [`${getRootName(requestItemType, true)}`]: await itemService.createItem(payload)
+            };
+        }
         if (requestItemType === "category") {
             let request = payload_1.schemaItemCategoryCreatePayload.parse({
                 scope: {
@@ -165,6 +300,104 @@ const updateItem = async (req, res, next) => {
         let response = {};
         let reqScope = req.body.scope;
         let reqPayload = req.body.payload;
+        if (requestItemType === "product") {
+            let request = payload_1.schemaItemProductUpdatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action
+                },
+                payload: {
+                    product: {
+                        itemName: reqPayload.product.item_name,
+                        productCode: reqPayload.product.product_code,
+                        model: reqPayload.product.model,
+                        description: reqPayload.product.description,
+                        categoryId: reqPayload.product.category_id,
+                        brandId: reqPayload.product.brand_id,
+                        summary: reqPayload.product.summary,
+                        status: reqPayload.product.status,
+                    }
+                }
+            });
+            let payload = {
+                id: Number(itemId),
+                itemType: requestItemType,
+                data: {
+                    product: {
+                        itemName: request.payload.product.itemName,
+                        brandId: request.payload.product.brandId,
+                        categoryId: request.payload.product.categoryId,
+                        model: request.payload.product.model,
+                        description: request.payload.product.description,
+                        productCode: request.payload.product.productCode,
+                        status: Boolean(request.payload.product.status),
+                        summary: request.payload.product.summary,
+                    }
+                }
+            };
+            response = {
+                [`${getRootName(requestItemType, true)}`]: await itemService.updateItem(payload)
+            };
+        }
+        if (requestItemType === "item") {
+            let request = payload_1.schemaItemItemUpdatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action
+                },
+                payload: {
+                    item: {
+                        // productId: reqPayload.item.product_id,
+                        // uomId: reqPayload.item.uom_id,
+                        code: reqPayload.item.code,
+                        skuCode: reqPayload.item.sku_code,
+                        status: reqPayload.item.status,
+                        isPackage: reqPayload.item.is_package,
+                        itemDescription: reqPayload.item.item_description,
+                        remark: reqPayload.item.remark,
+                        cost: reqPayload.item.cost,
+                        uomPrice: reqPayload.item.uom_price,
+                        floorPrice: reqPayload.item.floor_price,
+                        grossWeight: reqPayload.item.gross_weight,
+                        volumeWeight: reqPayload.item.volume_weight,
+                        netWeight: reqPayload.item.net_weight,
+                        dimensionWidth: reqPayload.item.dimension_width,
+                        dimensionHeight: reqPayload.item.dimension_height,
+                        dimensionLength: reqPayload.item.dimension_length,
+                        cbm: reqPayload.item.cbm,
+                    }
+                }
+            });
+            let payload = {
+                id: Number(itemId),
+                itemType: requestItemType,
+                data: {
+                    item: {
+                        // productId: request.payload.item.productId,
+                        // uomId: request.payload.item.uomId,
+                        code: request.payload.item.code,
+                        skuCode: request.payload.item.skuCode,
+                        status: Boolean(request.payload.item.status),
+                        isPackage: Boolean(request.payload.item.isPackage),
+                        itemDescription: request.payload.item.itemDescription,
+                        remark: request.payload.item.remark,
+                        cost: request.payload.item.cost,
+                        uomPrice: request.payload.item.uomPrice,
+                        floorPrice: request.payload.item.floorPrice,
+                        grossWeight: request.payload.item.grossWeight,
+                        volumeWeight: request.payload.item.volumeWeight,
+                        netWeight: request.payload.item.netWeight,
+                        dimensionWidth: request.payload.item.dimensionWidth,
+                        dimensionHeight: request.payload.item.dimensionHeight,
+                        dimensionLength: request.payload.item.dimensionLength,
+                        cbm: request.payload.item.cbm,
+                    }
+                }
+            };
+            response = {
+                [`${getRootName(requestItemType, true)}`]: await itemService.updateItem(payload)
+            };
+        }
         if (requestItemType === "category") {
             let request = payload_1.schemaItemCategoryUpdatePayload.parse({
                 scope: {

package/dist/controllers/location/locationController.js

@@ -98,64 +98,88 @@ const createLocation = async (req, res, next) => {
                 }
             };
             response = {
-                country: await locationService.createLocation(payload)
+                [`${getRootName(requestLocationType, true)}`]: await locationService.createLocation(payload)
+            };
+        }
+        if (requestLocationType === "rack") {
+            let request = payload_1.schemaLocationRackCreatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action,
+                },
+                payload: {
+                    rack: {
+                        locationId: reqPayload.rack.location_id,
+                        rackType: reqPayload.rack.rack_type,
+                        rackName: reqPayload.rack.rack_name,
+                        sequence: reqPayload.rack.sequence,
+                        isDefault: Boolean(reqPayload.rack.is_default),
+                        status: Boolean(reqPayload.rack.status)
+                    },
+                    slots: reqPayload.slots.map((i) => ({
+                        // rackId: i.rack_id,
+                        slotName: i.name,
+                        sequence: i.sequence,
+                        isDefault: Boolean(i.is_default),
+                        status: Boolean(i.status)
+                    }))
+                }
+            });
+            let payload = {
+                locationType: requestLocationType,
+                data: {
+                    rack: {
+                        locationId: request.payload.rack.locationId,
+                        rackName: request.payload.rack.rackName,
+                        rackSequence: request.payload.rack.sequence,
+                        rackType: request.payload.rack.rackType,
+                        status: Boolean(request.payload.rack.status),
+                        isDefault: Boolean(request.payload.rack.isDefault)
+                    },
+                    slots: request.payload.slots.map(i => ({
+                        slotName: i.slotName,
+                        slotSequence: i.sequence,
+                        isDefault: i.isDefault,
+                        status: i.status
+                    }))
+                }
+            };
+            response = {
+                [`${getRootName(requestLocationType, true)}`]: await locationService.createLocation(payload)
+            };
+        }
+        if (requestLocationType === "slot") {
+            let request = payload_1.schemaLocationSlotCreatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action,
+                },
+                payload: {
+                    slot: {
+                        rackId: reqPayload.slot.rack_id,
+                        slotName: reqPayload.slot.slot_name,
+                        sequence: reqPayload.slot.sequence,
+                        isDefault: Boolean(reqPayload.slot.is_default),
+                        status: Boolean(reqPayload.slot.status)
+                    }
+                }
+            });
+            let payload = {
+                locationType: requestLocationType,
+                data: {
+                    slot: {
+                        rackId: request.payload.slot.rackId,
+                        slotName: request.payload.slot.slotName,
+                        slotSequence: request.payload.slot.sequence,
+                        status: Boolean(request.payload.slot.status),
+                        isDefault: Boolean(request.payload.slot.isDefault)
+                    }
+                }
+            };
+            response = {
+                [`${getRootName(requestLocationType, true)}`]: await locationService.createLocation(payload)
             };
         }
-        // if (requestLocationType === "state") {
-        //     let request = schemaRegionStateCreatePayload.parse({
-        //         state: {
-        //             countryId: req.body.payload.state?.country_id,
-        //             stateName: req.body.payload.state?.state_name,
-        //             status: req.body.payload.state?.status,
-        //         },
-        //         areas: req.body.payload?.area_items ? req.body.payload.area_items.map((i: any) => ({
-        //             areaName: i.area_name,
-        //             postcodeString: i.postcode_string,
-        //             status: i?.status
-        //         })) : []
-        //     })
-        //     let payload: LocationCreateProps = {
-        //         locationType: requestLocationType,
-        //         data: {
-        //             state: {
-        //                 countryId: Number(request.state.countryId),
-        //                 stateName: request.state.stateName,
-        //                 status: Boolean(request.state.status)
-        //             },
-        //             areas: request.areas.length ? request.areas.map(i => ({
-        //                 areaName: i.areaName,
-        //                 postcodeString: i.postcodeString,
-        //                 status: Boolean(i.status)
-        //             })) : []
-        //         }
-        //     }
-        //     response = {
-        //         state: await locationService.createLocation(payload)
-        //     }
-        // }
-        // if (requestLocationType === "area") {
-        //     let request = schemaRegionAreaCreatePayload.parse({
-        //         area: {
-        //             stateId: req.body?.payload?.area?.state_id,
-        //             areaName: req.body?.payload?.area?.area_name,
-        //             postcodeString: req.body?.payload?.area?.postcode_string,
-        //             status: req.body?.payload?.area?.status
-        //         }
-        //     })
-        //     let payload: LocationCreateProps = {
-        //         locationType: requestLocationType,
-        //         data: {
-        //             area: {
-        //                 areaName: request.area.areaName,
-        //                 postcodeString: request.area.postcodeString,
-        //                 status: Boolean(request.area.status)
-        //             }
-        //         }
-        //     }
-        //     response = {
-        //         state: await locationService.createLocation(payload)
-        //     }
-        // }
         (0, utils_1.sendSuccess)(res, response, `Location(${requestLocationType}) created successfully`);
     }
     catch (error) {
@@ -223,69 +247,91 @@ const updateLocation = async (req, res, next) => {
                 }
             };
             response = {
-                country: await locationService.updateLocation(payload)
+                [`${getRootName(requestLocationType, true)}`]: await locationService.updateLocation(payload)
+            };
+        }
+        if (requestLocationType === "rack") {
+            let request = payload_1.schemaLocationRackUpdatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action,
+                },
+                payload: {
+                    rack: {
+                        // locationId: reqPayload.rack.location_id,
+                        rackType: reqPayload.rack.rack_type,
+                        rackName: reqPayload.rack.rack_name,
+                        sequence: reqPayload.rack.sequence,
+                        isDefault: Boolean(reqPayload.rack.is_default),
+                        status: Boolean(reqPayload.rack.status)
+                    },
+                    slots: reqPayload.slots.map((i) => ({
+                        ...(i?.slot_id ? { locationSlotId: i?.slot_id } : {}),
+                        slotName: i.name,
+                        sequence: i.sequence,
+                        isDefault: Boolean(i.is_default),
+                        status: Boolean(i.status)
+                    }))
+                }
+            });
+            let payload = {
+                id: Number(id),
+                locationType: requestLocationType,
+                data: {
+                    rack: {
+                        // locationId: request.payload.rack.locationId,
+                        rackName: request.payload.rack.rackName,
+                        rackSequence: request.payload.rack.sequence,
+                        rackType: request.payload.rack.rackType,
+                        status: Boolean(request.payload.rack.status),
+                        isDefault: Boolean(request.payload.rack.isDefault)
+                    },
+                    slots: request.payload.slots.map(i => ({
+                        ...(i.locationSlotId ? { locationSlotId: i.locationSlotId } : {}),
+                        slotName: i.slotName,
+                        slotSequence: i.sequence,
+                        isDefault: i.isDefault,
+                        status: i.status
+                    }))
+                }
+            };
+            response = {
+                [`${getRootName(requestLocationType, true)}`]: await locationService.updateLocation(payload)
+            };
+        }
+        if (requestLocationType === "slot") {
+            let request = payload_1.schemaLocationSlotUpdatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action,
+                },
+                payload: {
+                    slot: {
+                        rackId: reqPayload.slot.rack_id,
+                        slotName: reqPayload.slot.slot_name,
+                        sequence: reqPayload.slot.sequence,
+                        isDefault: Boolean(reqPayload.slot.is_default),
+                        status: Boolean(reqPayload.slot.status)
+                    }
+                }
+            });
+            let payload = {
+                id: Number(id),
+                locationType: requestLocationType,
+                data: {
+                    slot: {
+                        // rackId: request.payload.slot.rackId,
+                        slotName: request.payload.slot.slotName,
+                        slotSequence: request.payload.slot.sequence,
+                        status: Boolean(request.payload.slot.status),
+                        isDefault: Boolean(request.payload.slot.isDefault)
+                    }
+                }
+            };
+            response = {
+                [`${getRootName(requestLocationType, true)}`]: await locationService.updateLocation(payload)
             };
         }
-        // if (requestLocationType === "state") {
-        //     let request = schemaRegionStateUpdatePayload.parse({
-        //         state: {
-        //             // countryId: req.body.payload.state?.country_id,
-        //             stateName: req.body.payload.state?.state_name,
-        //             status: req.body.payload.state?.status,
-        //         },
-        //         areas: req.body.payload?.area_items ? req.body.payload.area_items.map((i: any) => ({
-        //             areaId: i?.area_id ?? "",
-        //             areaName: i.area_name,
-        //             postcodeString: i.postcode_string,
-        //             status: i?.status
-        //         })) : []
-        //     })
-        //     let payload: LocationUpdateProps = {
-        //         id: Number(id),
-        //         locationType: requestLocationType,
-        //         data: {
-        //             state: {
-        //                 // countryId: Number(request.state.countryId),
-        //                 stateName: request.state.stateName,
-        //                 status: Boolean(request.state.status)
-        //             },
-        //             areas: request.areas.length ? request.areas.map(i => ({
-        //                 ...(i?.areaId ? { areaId: Number(i.areaId) } : {}),
-        //                 areaName: i.areaName,
-        //                 postcodeString: i.postcodeString,
-        //                 status: Boolean(i.status)
-        //             })) : []
-        //         }
-        //     }
-        //     response = {
-        //         state: await locationService.updateLocation(payload)
-        //     }
-        // }
-        // if (requestLocationType === "area") {
-        //     let request = schemaRegionAreaUpdatePayload.parse({
-        //         area: {
-        //             id,
-        //             stateId: req.body?.payload?.area?.state_id,
-        //             areaName: req.body?.payload?.area?.area_name,
-        //             postcodeString: req.body?.payload?.area?.postcode_string,
-        //             status: req.body?.payload?.area?.status
-        //         }
-        //     })
-        //     let payload: LocationUpdateProps = {
-        //         id: Number(id),
-        //         locationType: requestLocationType,
-        //         data: {
-        //             area: {
-        //                 areaName: request.area.areaName,
-        //                 postcodeString: request.area.postcodeString,
-        //                 status: Boolean(request.area.status)
-        //             }
-        //         }
-        //     }
-        //     response = {
-        //         state: await locationService.updateLocation(payload)
-        //     }
-        // }
         (0, utils_1.sendSuccess)(res, response, `Location(${requestLocationType}) updated successfully`);
     }
     catch (error) {

package/dist/controllers/user/userController.js

@@ -13,6 +13,9 @@ const getRootName = (requestUserType, toSingular) => {
         case "customer":
             rootName = toSingular ? "customer" : "customers";
             break;
+        case "retailer":
+            rootName = toSingular ? "retailer" : "retailers";
+            break;
         case "worker":
             rootName = toSingular ? "worker" : "workers";
             break;
@@ -208,6 +211,60 @@ const createUser = async (req, res, next) => {
                 [`${getRootName(requestUserType, true)}`]: await userService.createUser(payload)
             };
         }
+        if (requestUserType === "retailer") {
+            let request = payload_1.schemaUserRetailerCreatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action
+                },
+                payload: {
+                    credential: {
+                        username: reqPayload.credential.username,
+                        password: reqPayload.credential.password,
+                        firstname: reqPayload.credential.firstname,
+                        lastname: reqPayload.credential.lastname,
+                        contact: reqPayload.credential.contact,
+                        email: reqPayload.credential.email,
+                        address: reqPayload.credential.address,
+                        status: reqPayload.credential.status
+                    },
+                    retailer: {
+                        code: reqPayload.retailer.code,
+                        accountCode: reqPayload.retailer.account_code,
+                        companyName: reqPayload.retailer.company_name,
+                        regNo: reqPayload.retailer.reg_no,
+                        gstNo: reqPayload.retailer.gst_no,
+                        remark: reqPayload.retailer.remark,
+                    }
+                }
+            });
+            let payload = {
+                userType: requestUserType,
+                data: {
+                    user: {
+                        loginUsername: request.payload.credential.username,
+                        loginPassword: request.payload.credential.password,
+                        address: request.payload.credential.address,
+                        contact: request.payload.credential.contact,
+                        email: request.payload.credential.email,
+                        firstname: request.payload.credential.firstname,
+                        lastname: request.payload.credential.lastname,
+                        status: request.payload.credential.status === 1
+                    },
+                    retailer: {
+                        code: request.payload.retailer.code,
+                        accountCode: request.payload.retailer.accountCode,
+                        companyName: request.payload.retailer.companyName,
+                        regNo: request.payload.retailer.regNo,
+                        remark: request.payload.retailer.remark,
+                        gstNo: request.payload.retailer.gstNo
+                    }
+                }
+            };
+            response = {
+                [`${getRootName(requestUserType, true)}`]: await userService.createUser(payload)
+            };
+        }
         (0, utils_1.sendSuccess)(res, response, `User(${requestUserType}) created successfully`);
     }
     catch (error) {
@@ -390,6 +447,61 @@ const updateUser = async (req, res, next) => {
                 [`${getRootName(requestUserType, true)}`]: await userService.updateUser(payload)
             };
         }
+        if (requestUserType === "retailer") {
+            let request = payload_1.schemaUserRetailerUpdatePayload.parse({
+                scope: {
+                    target: reqScope.target,
+                    action: reqScope.action
+                },
+                payload: {
+                    credential: {
+                        // username: reqPayload.credential.username,
+                        password: reqPayload.credential.password,
+                        firstname: reqPayload.credential.firstname,
+                        lastname: reqPayload.credential.lastname,
+                        contact: reqPayload.credential.contact,
+                        email: reqPayload.credential.email,
+                        address: reqPayload.credential.address,
+                        status: reqPayload.credential.status
+                    },
+                    retailer: {
+                        code: reqPayload.retailer.code,
+                        accountCode: reqPayload.retailer.account_code,
+                        companyName: reqPayload.retailer.company_name,
+                        regNo: reqPayload.retailer.reg_no,
+                        gstNo: reqPayload.retailer.gst_no,
+                        remark: reqPayload.retailer.remark,
+                    }
+                }
+            });
+            let payload = {
+                id: Number(userId),
+                userType: requestUserType,
+                data: {
+                    user: {
+                        loginUsername: request.payload.credential.username,
+                        ...(request.payload.credential.password ? { loginPassword: request.payload.credential.password } : {}),
+                        address: request.payload.credential.address,
+                        contact: request.payload.credential.contact,
+                        email: request.payload.credential.email,
+                        firstname: request.payload.credential.firstname,
+                        lastname: request.payload.credential.lastname,
+                        status: request.payload.credential.status === 1
+                    },
+                    retailer: {
+                        code: request.payload.retailer.code,
+                        accountCode: request.payload.retailer.accountCode,
+                        companyName: request.payload.retailer.companyName,
+                        regNo: request.payload.retailer.regNo,
+                        remark: request.payload.retailer.remark,
+                        gstNo: request.payload.retailer.gstNo
+                    }
+                }
+            };
+            response = {
+                [`${getRootName(requestUserType, true)}`]: await userService.updateUser(payload)
+            };
+        }
         (0, utils_1.sendSuccess)(res, response, `User(${requestUserType}) updated successfully`);
     }
     catch (error) {