feat: added dashboard controllers

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 Inventory Failed, missing params",
+        });
+        return;
+      }
+
+      const warehouse = await createWarehouse(req.body.warehouse);
+      if (!warehouse) {
+        res.status(400).send({
+          success: false,
+          message: "Creation of Inventory 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);
+    }
+  },
+};