Merge pull request #8 from kfnawaz/feat/endpoints-1

Feat: Endpoints

src/config/auth.js

@@ -1,53 +0,0 @@
-const jwt = require("jsonwebtoken");
-const { JWT_SECRET } = require("./env");
-const User = require("../models/User");
-const constants = require("./constants");
-
-const authenticate = async (token) => {
-  const decodedToken = jwt.verify(token, JWT_SECRET);
-  if (decodedToken) {
-    return await User.findById(decodedToken.id)
-      .populate({ path: "roles", populate: "permissions" })
-      .populate("permissions");
-  }
-};
-
-const authorize = async (
-  user,
-  requiredRoles = [],
-  requiredPermissions = []
-) => {
-  const userRoles = user.roles.map((_) => _._id);
-  const userPermissions = [
-    ...user.permissions.map((_) => _._id),
-    ...userRoles.map((_) => _.permissions).flat(),
-  ];
-
-  return (
-    user != undefined &&
-    requiredRoles.every((_) => userRoles.includes(_)) &&
-    requiredPermissions.every((_) => userPermissions.includes(_))
-  );
-};
-
-module.exports = {
-  AuthenticateMiddleware: async (req, res, next) => {
-    try {
-      const token = req.headers.authorization || "";
-      if (token) {
-        const user = authenticate(token);
-        res.locals.user = user;
-        next();
-      }
-    } catch (error) {
-      res
-        .status(401)
-        .send({
-          success: false,
-          error: constants.AUTHENTICATION_FAILURE_ERROR_MESSAGE,
-        });
-    }
-  },
-
-  AuthorizeUser: authorize,
-};

src/controller/dashboard.controller.js

@@ -0,0 +1,328 @@
+const mongoose = require("mongoose");
+
+const Warehouse = require("../models/Warehouse");
+const Zone = require("../models/Zone");
+const Area = require("../models/Area");
+const Row = require("../models/Row");
+const Bay = require("../models/Bay");
+const Level = require("../models/Level");
+const Sublevel = require("../models/Sublevel");
+const Inventory = require("../models/Inventory");
+const Material = require("../models/Material");
+const Item = require("../models/Item");
+
+const createWarehouse = async ({ name, address, specs, company_id }) => {
+  if (!(name && address)) {
+    return;
+  }
+
+  return await Warehouse.create({
+    name,
+    address,
+    specs,
+    company_id: mongoose.Types.ObjectId(company_id),
+  });
+};
+
+const createZones = async (zones, warehouse) => {
+  const zonesArr = [];
+  for (const zone of zones) {
+    const { name, type, specs } = zone;
+
+    const zoneObj = new Zone({
+      name,
+      type,
+      specs,
+      warehouse_id: mongoose.Types.ObjectId(warehouse._id),
+    });
+
+    await zoneObj.save();
+
+    if (zone.areas) {
+      zoneObj.areas = await createAreas(zone.areas, zoneObj);
+    }
+
+    zonesArr.push(zoneObj);
+  }
+  return zonesArr;
+};
+
+const createAreas = async (areas, zone) => {
+  const areasArr = [];
+  for (const area of areas) {
+    const { name, type, specs } = area;
+    const areaObj = new Area({
+      name,
+      type,
+      specs,
+      zone_id: mongoose.Types.ObjectId(zone._id),
+    });
+
+    await areaObj.save();
+    if (area.rows) {
+      areaObj.rows = await createRows(zone.areas, area);
+    }
+    areasArr.push(areaObj);
+  }
+  return areasArr;
+};
+
+const createRows = async (rows, area) => {
+  const rowsArr = [];
+  for (const row of rows) {
+    const { name, number, specs } = row;
+    const rowObj = new Row({
+      name,
+      number: parseInt(number),
+      specs,
+      area_id: mongoose.Types.ObjectId(area._id),
+    });
+
+    await rowObj.save();
+    if (row.bays) {
+      rowObj.bays = await createBays(row.bays, row);
+    }
+    rowsArr.push(rowObj);
+  }
+  return rowsArr;
+};
+
+const createBays = async (bays, row) => {
+  const baysArr = [];
+  for (const bay of bays) {
+    const { name, number, type, specs } = bay;
+    const bayObj = new Bay({
+      name,
+      number: parseInt(number),
+      type,
+      specs,
+      row_id: mongoose.Types.ObjectId(row._id),
+    });
+
+    await bayObj.save();
+    if (bay.levels) {
+      bayObj.levels = await createLevels(bay.levels, bay);
+    }
+    baysArr.push(bayObj);
+  }
+  return baysArr;
+};
+
+const createLevels = async (levels, bay) => {
+  const levelsArr = [];
+  for (const level of levels) {
+    const { name, number, specs } = level;
+    const levelObj = new Level({
+      name,
+      number: parseInt(number),
+      specs,
+      row_id: mongoose.Types.ObjectId(bay._id),
+    });
+
+    await levelObj.save();
+    if (level.levels) {
+      levelObj.subLevels = await createSublevels(level.subLevels, level);
+    }
+    levelsArr.push(levelObj);
+  }
+  return levelsArr;
+};
+
+const createSublevels = async (
+  subLevels,
+  level,
+  parent = undefined,
+  depth = 0
+) => {
+  const subLevelsArr = [];
+  for (const subLevel of subLevels) {
+    const subLevelObj = await Sublevel.create({
+      name: subLevel.name,
+      type: subLevel.type,
+      specs: subLevel.specs,
+      main_level_id: level._id,
+      current_depth: depth,
+      parent_subLevel_id: parent ? parent._id : undefined,
+      has_inventory: subLevel.has_inventory,
+      inventory: subLevel.inventory,
+    });
+
+    if (subLevel.sub_levels) {
+      const subSubLevels = await createSublevels(
+        subLevel.sub_levels,
+        level,
+        subLevelObj,
+        depth + 1
+      );
+
+      subLevelObj.sub_levels = subSubLevels.map((_) => {
+        return {
+          type: _.type,
+          depth: _.depth,
+          sub_level_id: _._id,
+        };
+      });
+
+      await subLevelObj.save();
+    }
+
+    subLevelsArr.push(subLevelObj);
+  }
+  return subLevelsArr;
+};
+
+const createInventory = async ({ name, type }) => {
+  if (!(name && type)) {
+    return;
+  }
+
+  return await Inventory.create({
+    name,
+    type,
+  });
+};
+
+const createItems = async (items, material) => {
+  const itemsArray = [];
+  for (const itemData of items) {
+    const item = {
+      commonName: itemData.commonName,
+      formalName: itemData.formalName,
+      description: itemData.description,
+      manufacturer: itemData.manufacturer,
+      size: itemData.size,
+      color: itemData.color,
+      type: itemData.type,
+      unitOfMaterial: itemData.unitOfMaterial,
+      unitCost: itemData.unitCost,
+      packageCount: itemData.packageCount,
+      countPerPallet: itemData.countPerPallet,
+      countPerPalletPackage: itemData.countPerPalletPackage,
+      customAttributes: itemData.customAttributes,
+      material,
+    };
+
+    if (Object.values(item).every((_) => _)) {
+      const itemObj = await Item.create(item);
+      itemsArray.push(itemObj);
+    }
+  }
+  return itemsArray;
+};
+
+const createMaterials = async (materials, inventory, parent = undefined) => {
+  const materialsData = [];
+  for (const materialData of materials) {
+    const material = await Material.create({
+      name,
+      parent,
+      inventory,
+    });
+
+    let materialFamily;
+    if (materialData.family) {
+      materialFamily = await createMaterials(
+        materialData.family,
+        inventory,
+        material
+      );
+    }
+
+    let items;
+    if (materialData.items) {
+      items = await createItems(materialData.items, material);
+    }
+
+    materialsData.push({
+      material,
+      family: materialFamily,
+      items,
+    });
+  }
+
+  return materialsData;
+};
+
+module.exports = {
+  createWarehouseSchema: async (req, res, next) => {
+    try {
+      const warehouseSchema = {};
+      if (!req.body.warehouse) {
+        res.status(400).send({
+          success: false,
+          message: "Creation of Warehouse Failed, missing params",
+        });
+        return;
+      }
+
+      const warehouse = await createWarehouse(req.body.warehouse);
+      if (!warehouse) {
+        res.status(400).send({
+          success: false,
+          message: "Creation of Warehouse Failed, invalid/missing params",
+        });
+        return;
+      }
+
+      warehouseSchema.warehouse = warehouse;
+      if (!req.body.warehouse.zones) {
+        const zones = createZones(req.body.warehouse.zones, warehouse);
+        if (!zones) {
+          res.status(400).send({
+            success: false,
+            message: "Creation of Zones Failed, invalid/missing params",
+          });
+          return;
+        }
+
+        warehouseSchema.warehouse.zones = zones;
+      }
+      res.send({ success: true, data: warehouseSchema });
+    } catch (error) {
+      next(error);
+    }
+  },
+  createInventorySchema: async (req, res, next) => {
+    try {
+      const inventorySchema = {};
+      if (!req.body.inventory) {
+        res.status(400).send({
+          success: false,
+          message: "Creation of Inventory Failed, missing params",
+        });
+        return;
+      }
+
+      const inventory = await createInventory(req.body.inventory);
+
+      if (!inventory) {
+        res.status(400).send({
+          success: false,
+          message: "Creation of Inventory Failed, invalid/missing params",
+        });
+        return;
+      }
+      inventorySchema.inventory = inventory;
+
+      if (req.body.inventory.materials) {
+        const materials = createMaterials(
+          req.body.inventory.materials,
+          inventory
+        );
+        if (!materials) {
+          res.status(400).send({
+            success: false,
+            message: "Creation of Materials Failed, invalid/missing params",
+          });
+          return;
+        }
+
+        inventorySchema.inventory.materials = materials;
+      }
+
+      res.send({ success: true, data: inventorySchema });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

src/controller/dashboard.router.js

@@ -0,0 +1,14 @@
+const router = require("express").Router();
+const controller = require("./dashboard.controller");
+
+/**
+ * @route /dashboard/create-warehouse-schema
+ */
+router.post("/create-warehouse-schema", controller.createWarehouseSchema);
+
+/**
+ * @route /dashboard/create-inventory-schema
+ */
+router.post("/create-inventory-schema", controller.createInventorySchema);
+
+module.exports = router;

src/controller/index.js

@@ -2,7 +2,7 @@ const router = require("express").Router();
 const userRouter = require("./user.router");
 const userRoleRouter = require("./userRole.router");
 const userPermissionRouter = require("./userPermission.router");
-const { AuthenticateMiddleware } = require("../config/auth");
+const { AuthenticateMiddleware } = require("./utils/authorize");
 
 const companyRouter = require("./company.router");
 const warehouseRouter = require("./warehouse.router");
@@ -11,6 +11,7 @@ const areaRouter = require("./area.router");
 const bayRouter = require("./bay.router");
 const rowRouter = require("./row.router");
 const levelRouter = require("./level.router");
+const dashboardRouter = require("./dashboard.router");
 
 router.use("/user-role", AuthenticateMiddleware, userRoleRouter);
 router.use("/user-permission", AuthenticateMiddleware, userPermissionRouter);
@@ -22,7 +23,7 @@ router.use("/area", areaRouter);
 router.use("/bay", bayRouter);
 router.use("/row", rowRouter);
 router.use("/level", levelRouter);
-
+router.use("/dashboard", dashboardRouter);
 
 router.get("/", (req, res) => {
   res.send({ success: true, message: "Hello world" });

src/controller/inventory.controller.js

@@ -0,0 +1,89 @@
+const Inventory = require("../models/Inventory");
+
+module.exports = {
+  /**
+   * Gets the Inventory data by `id`
+   */
+  getInventoryByID: async (req, res, next) => {
+    const { id } = req.params;
+
+    if (!id) {
+      res.status(400).send("Missing id param");
+      return;
+    }
+
+    try {
+      const inventoryData = await Inventory.findById(id);
+      if (!inventoryData) {
+        res.status(404);
+        return;
+      }
+      req.send({ success: true, data: inventoryData });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  /**
+   * Create a Inventory
+   */
+  createInventory: async (req, res, next) => {
+    const { name, type } = req.body;
+
+    if (!(name && type)) {
+      res.status(400).send("Missing params param");
+      return;
+    }
+
+    try {
+      const inventoryData = new Inventory({
+        name,
+        type,
+      });
+
+      await inventoryData.save();
+      if (!inventoryData) {
+        res.status(404);
+        return;
+      }
+      req.send({ success: true, data: inventoryData });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  /**
+   * Update a Inventory detail
+   */
+  updateInventoryByID: async (req, res, next) => {
+    const { id } = req.params;
+
+    if (!id) {
+      res.status(400).send("Missing id param");
+      return;
+    }
+
+    const { name, type } = req.body;
+
+    if (!(name || type)) {
+      res.status(400).send("Missing data in body");
+      return;
+    }
+
+    try {
+      const inventoryData = await Inventory.findById(id);
+      if (!inventoryData) {
+        res.status(404);
+        return;
+      }
+
+      if (name) inventoryData.name = name;
+      if (type) inventoryData.type = type;
+
+      await inventoryData.save();
+      req.send({ success: true, data: inventoryData });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

src/controller/inventory.router.js

@@ -0,0 +1,19 @@
+const router = require("express").Router();
+const controller = require("./inventory.controller");
+
+/**
+ * @route /inventory/:id
+ */
+router.get("/:id", controller.getInventoryByID);
+
+/**
+ * @route /inventory/
+ */
+router.post("/", controller.createInventory);
+
+/**
+ * @route /inventory/
+ */
+router.patch("/:id", controller.updateInventoryByID);
+
+module.exports = router;

src/controller/item.controller.js

@@ -0,0 +1,119 @@
+const mongoose = require("mongoose");
+const Item = require("../models/Item");
+const Material = require("../models/Material");
+
+module.exports = {
+  /**
+   * Gets the Item data by `id`
+   */
+  getItemByID: async (req, res, next) => {
+    const { id } = req.params;
+
+    if (!id) {
+      res.status(400).send("Missing id param");
+      return;
+    }
+
+    try {
+      const itemData = await Item.findById(id);
+      if (!itemData) {
+        res.status(404);
+        return;
+      }
+      req.send({ success: true, data: itemData });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  /**
+   * Create a Item
+   */
+  createItem: async (req, res, next) => {
+    let material;
+    if (req.body.materialId && mongoose.isValidObjectId(req.body.materialId)) {
+      material = await Material.findById(material);
+    }
+    const item = {
+      commonName: req.body.commonName,
+      formalName: req.body.formalName,
+      description: req.body.description,
+      manufacturer: req.body.manufacturer,
+      size: req.body.size,
+      color: req.body.color,
+      type: req.body.type,
+      unitOfMaterial: req.body.unitOfMaterial,
+      unitCost: req.body.unitCost,
+      packageCount: req.body.packageCount,
+      countPerPallet: req.body.countPerPallet,
+      countPerPalletPackage: req.body.countPerPalletPackage,
+      customAttributes: req.body.customAttributes,
+      material,
+    };
+
+    if (Object.values(item).every((_) => _)) {
+      res.status(400).send("Missing params param");
+      return;
+    }
+
+    try {
+      const itemData = new Item(item);
+
+      await itemData.save();
+      if (!itemData) {
+        res.status(404);
+        return;
+      }
+      req.send({ success: true, data: itemData });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  /**
+   * Update a Item detail
+   */
+  updateItemByID: async (req, res, next) => {
+    const { id } = req.params;
+
+    if (!id) {
+      res.status(400).send("Missing id param");
+      return;
+    }
+
+    const item = {
+      commonName: req.body.commonName,
+      formalName: req.body.formalName,
+      description: req.body.description,
+      manufacturer: req.body.manufacturer,
+      size: req.body.size,
+      color: req.body.color,
+      type: req.body.type,
+      unitOfMaterial: req.body.unitOfMaterial,
+      unitCost: req.body.unitCost,
+      packageCount: req.body.packageCount,
+      countPerPallet: req.body.countPerPallet,
+      countPerPalletPackage: req.body.countPerPalletPackage,
+      customAttributes: req.body.customAttributes,
+    };
+
+    try {
+      const itemData = await Item.findById(id);
+      if (!itemData) {
+        res.status(404);
+        return;
+      }
+
+      for (const key of Object.keys(item)) {
+        if (item[key] !== undefined) {
+          itemData[key] = item[key];
+        }
+      }
+
+      await itemData.save();
+      req.send({ success: true, data: itemData });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

src/controller/item.router.js

@@ -0,0 +1,19 @@
+const router = require("express").Router();
+const controller = require("./item.controller");
+
+/**
+ * @route /item/:id
+ */
+router.get("/:id", controller.getItemByID);
+
+/**
+ * @route /item/
+ */
+router.post("/", controller.createItem);
+
+/**
+ * @route /item/
+ */
+router.patch("/:id", controller.updateItemByID);
+
+module.exports = router;

src/controller/material.controller.js

@@ -0,0 +1,122 @@
+const mongoose = require("mongoose");
+const Material = require("../models/Material");
+const Inventory = require("../models/Inventory");
+
+module.exports = {
+  /**
+   * Gets the Material data by `id`
+   */
+  getMaterialByID: async (req, res, next) => {
+    const { id } = req.params;
+
+    if (!id) {
+      res.status(400).send("Missing id param");
+      return;
+    }
+
+    try {
+      const materialData = await Material.findById(id);
+      if (!materialData) {
+        res.status(404);
+        return;
+      }
+      req.send({ success: true, data: materialData });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  /**
+   * Create a Material
+   */
+  createMaterial: async (req, res, next) => {
+    const { name, parentId, inventoryId } = req.body;
+
+    try {
+      let parent;
+      if (parentId && mongoose.isValidObjectId(parentId)) {
+        parent = await Material.findById(parent);
+      } else if (parentId && !mongoose.isValidObjectId(parentId)) {
+        res.status(400).send("Invalid params parentId");
+        return;
+      }
+
+      let inventory;
+      if (inventoryId && mongoose.isValidObjectId(inventoryId)) {
+        inventory = await Inventory.findById(inventoryId);
+      } else {
+        res.status(400).send("Invalid params inventoryId");
+        return;
+      }
+
+      const materialData = new Material({
+        name,
+        parent,
+        inventory,
+      });
+
+      await materialData.save();
+      if (!materialData) {
+        res.status(404);
+        return;
+      }
+      req.send({ success: true, data: materialData });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  /**
+   * Update a Material detail
+   */
+  updateMaterialByID: async (req, res, next) => {
+    const { id } = req.params;
+
+    if (!id) {
+      res.status(400).send("Missing id param");
+      return;
+    }
+
+    const { name, parentId, inventoryId } = req.body;
+
+    if (!(name || parentId || inventoryId)) {
+      res.status(400).send("Missing data in body");
+      return;
+    }
+
+    try {
+      const materialData = await Material.findById(id);
+      if (!materialData) {
+        res.status(404);
+        return;
+      }
+
+      if (name) {
+        materialData.name = name;
+      }
+
+      let parent;
+      if (parentId && mongoose.isValidObjectId(parentId)) {
+        parent = await Material.findById(parent);
+        materialData.parent = parent;
+      } else if (parentId && !mongoose.isValidObjectId(parentId)) {
+        res.status(400).send("Invalid params parentId");
+        return;
+      }
+
+      let inventory;
+      if (inventoryId && mongoose.isValidObjectId(inventoryId)) {
+        inventory = await Inventory.findById(inventoryId);
+        materialData.inventory = inventory;
+      } else {
+        res.status(400).send("Invalid params inventoryId");
+        return;
+      }
+
+      await materialData.save();
+      req.send({ success: true, data: materialData });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

src/controller/material.router.js

@@ -0,0 +1,19 @@
+const router = require("express").Router();
+const controller = require("./material.controller");
+
+/**
+ * @route /material/:id
+ */
+router.get("/:id", controller.getMaterialByID);
+
+/**
+ * @route /material/
+ */
+router.post("/", controller.createMaterial);
+
+/**
+ * @route /material/
+ */
+router.patch("/:id", controller.updateMaterialByID);
+
+module.exports = router;

src/controller/user.router.js

@@ -1,7 +1,6 @@
 const router = require("express").Router();
 const controller = require("./user.controller");
-const { AuthenticateMiddleware } = require("../config/auth");
-const { SuperAdminCheck } = require("./utils/authorize");
+const { SuperAdminCheck, AuthenticateMiddleware } = require("./utils/authorize");
 
 router.post("/register", controller.registerUser);
 router.post("/login", controller.loginUser);

src/controller/utils/authorize.js

@@ -1,11 +1,44 @@
+const jwt = require("jsonwebtoken");
+const User = require("../../models/User");
 const UserRole = require("../../models/UserRole");
-const { AuthorizeUser } = require("../../config/auth");
-const { SUPER_ADMIN_ROLE, AUTHORIZATION_FAILURE_ERROR_MESSAGE } = require("../../config/constants");
+const {
+  SUPER_ADMIN_ROLE,
+  AUTHORIZATION_FAILURE_ERROR_MESSAGE,
+} = require("../../config/constants");
+const { JWT_SECRET } = require("../../config/env");
+const constants = require("../../config/constants");
+
+const authenticate = async (token) => {
+  const decodedToken = jwt.verify(token, JWT_SECRET);
+  if (decodedToken) {
+    return await User.findById(decodedToken.id)
+      .populate({ path: "roles", populate: "permissions" })
+      .populate("permissions");
+  }
+};
+
+const authorize = async (
+  user,
+  requiredRoles = [],
+  requiredPermissions = []
+) => {
+  const userRoles = user.roles.map((_) => _._id);
+  const userPermissions = [
+    ...user.permissions.map((_) => _._id),
+    ...userRoles.map((_) => _.permissions).flat(),
+  ];
+
+  return (
+    user != undefined &&
+    requiredRoles.every((_) => userRoles.includes(_)) &&
+    requiredPermissions.every((_) => userPermissions.includes(_))
+  );
+};
 
 module.exports = {
   SuperAdminCheck: async (req, res, next) => {
     const SuperAdmin = await UserRole.findOne({ name: SUPER_ADMIN_ROLE });
-    if (AuthorizeUser(req.locals.user, [SuperAdmin.id])) {
+    if (authorize(req.locals.user, [SuperAdmin.id])) {
       next();
     } else {
       res
@@ -13,4 +46,23 @@ module.exports = {
         .send({ success: false, error: AUTHORIZATION_FAILURE_ERROR_MESSAGE });
     }
   },
+  AuthenticateMiddleware: async (req, res, next) => {
+    try {
+      const token = req.headers.authorization || "";
+      if (token) {
+        const user = authenticate(token);
+        res.locals.user = user;
+        next();
+      } else {
+        throw new Error("Not Authenticated user!");
+      }
+    } catch (error) {
+      res.status(401).send({
+        success: false,
+        error: constants.AUTHENTICATION_FAILURE_ERROR_MESSAGE,
+      });
+    }
+  },
+
+  AuthorizeUser: authorize,
 };

src/models/Item.js

@@ -18,6 +18,11 @@ const schema = new mongoose.Schema(
       required: true,
       trim: true,
     },
+    material: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Material",
+      required: true,
+    },
     manufacturer: {
       type: String,
       required: true,
@@ -47,10 +52,6 @@ const schema = new mongoose.Schema(
       type: Number,
       required: true,
     },
-    unitQuantity: {
-      type: Number,
-      required: true,
-    },
     packageCount: {
       type: Number,
       required: true,

src/models/Material.js

@@ -7,21 +7,15 @@ const schema = new mongoose.Schema(
       required: true,
       trim: true,
     },
-    family: [
-      {
-        name: {
-          type: String,
-          required: true,
-          trim: true,
-        },
-        depth: {
-          type: Number,
-          required: true,
-          min: 1,
-          max: 10
-        },
-      },
-    ],
+    parent: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Material",
+    },
+    inventory: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Inventory",
+      required: true
+    },
   },
   {
     timestamps: true,

src/models/Sublevel.js

@@ -68,6 +68,7 @@ const schema = new mongoose.Schema(
   }
 );
 
-const SubLevel = mongoose.model("SubLevel", schema);
+const Sublevel = mongoose.model("Sublevel", schema);
+
+module.exports = Sublevel;
 
-module.exports = SubLevel;