@shyntech-proximity/inventories 1.0.2 → 1.0.3

package/index.js

@@ -0,0 +1,537 @@
+import express from "express";
+/*import { DeviceScan } from "../models/DeviceScan.js";
+import { Vendor } from "../models/Vendor.js";
+
+const router = express.Router();
+router.proximityCache = {};
+/**
+ * Browser client calls this endpoint.
+ * Server finds last scan from same IP and returns matching vendor inventories.
+ */
+/*
+// 🧠 Fallback Matching Logic
+function findProximityKey(req) {
+  const ip = req.headers["public_ip"];
+  const deviceSig = req.headers["x-device-sig"];
+  const token = req.headers["x-ws-token"];
+  console.log("Device: ", deviceSig);
+  if (deviceSig) return deviceSig;
+  if (ip) return ip;
+  if (token) return token;
+  return null;
+}
+
+
+
+
+
+
+router.get("/inventory/:itemId", async (req, res) => {
+  try {
+    const itemId = req.params.itemId;
+
+    // Find the vendor that contains the inventory item
+    const vendor = await Vendor.findOne(
+      { "inventory.item_id": itemId },
+      { "inventory.$": 1, vendor_info: 1 } // project only the matching inventory item and vendor_info
+    ).lean();
+
+    if (!vendor || !vendor.inventory || vendor.inventory.length === 0) {
+      return res.status(404).json({ error: "Inventory item not found" });
+    }
+
+    res.json({
+      vendor: vendor.vendor_info,
+      item: vendor.inventory[0]
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+router.get("/search", async (req, res) => {
+  try {
+    const { query } = req.query;
+
+    if (!query || query.trim() === "") {
+      return res.status(400).json({ error: "Query parameter is required" });
+    }
+
+    const regex = new RegExp(query, "i"); // case-insensitive fuzzy match
+
+    // Search inventory items
+    const vendors = await Vendor.find({
+      $or: [
+        { "vendor_info.name": regex },
+        { "vendor_info.address": regex },
+        { "inventory.name": regex },
+        { "inventory.category": regex },
+        { "inventory.tags": regex }
+      ]
+    }).lean();
+
+    const results = vendors.map(vendor => {
+      // Filter inventory items in vendor that match the query
+      const matchingItems = vendor.inventory.filter(item => 
+        regex.test(item.name) ||
+        regex.test(item.category) ||
+        item.tags.some(tag => regex.test(tag))
+      );
+
+      return {
+        vendor_id: vendor.vendor_info.vendor_id,
+        vendor_name: vendor.vendor_info.name,
+        address: vendor.vendor_info.address,
+        inventory: matchingItems
+      };
+    }).filter(vendor => vendor.inventory.length > 0 || regex.test(vendor.vendor_name) || regex.test(vendor.address));
+
+    res.json({
+      query,
+      results
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+router.get("/inventory", async (req, res) => {
+  const deviceId = findProximityKey(req)|| req.socket.remoteAddress;
+
+  try {
+    const lastScan = await DeviceScan.findOne({ device_id: deviceId })
+      .sort({ timestamp: -1 })
+      .lean();
+    if (!lastScan) {
+      return res.status(404).json({ message: "No recent proximity data found for this IP" });
+    }
+    const ssids = lastScan?.detected_wifi.map(w => w.ssid);
+    console.log(ssids)
+    const vendors = await Vendor.find({ ssid: { $in: ssids } }).lean();
+    console.log(vendors);
+    res.json(vendors);
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+// =========================
+// Get vendor by phoneNumber
+// =========================
+router.get("/vendor", async (req, res) => {
+  try {
+    const { phoneNumber } = req.query;
+    console.log(phoneNumber);
+    if (!phoneNumber) {
+      return res
+        .status(400)
+        .json({ error: "phoneNumber query parameter is required" });
+    }
+
+    // Find vendor using vendor_info.phoneNumber
+    const vendor = await Vendor.findOne({ "phoneNumber": phoneNumber })
+      .lean();
+
+    if (!vendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json(vendor);
+
+  } catch (error) {
+    console.error("Error fetching vendor by phoneNumber:", error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+// Get inventory for a specific vendor
+router.get("/vendor/:vendorId/inventory", async (req, res) => {
+  try {
+    const vendorId = req.params.vendorId;
+    // Find the vendor by vendor_info.vendor_id
+    const vendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId })
+      .select("inventory") // only return inventory and vendor_info
+      .lean();
+
+    if (!vendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json(vendor.inventory);
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+
+// STORE MANAGEMENT STARTS HERE 
+router.get("/vendor/:vendorId", async (req, res) => {
+  try {
+    const vendorId = req.params.vendorId;
+    // vendor_id is inside vendor_info
+    const vendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId }).lean();
+
+    if (!vendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json(vendor);
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+// POST /vendor
+// body: { vendor_id, name, address, contact, gps_location, opening_hours, inventory }
+router.post("/vendor", async (req, res) => {
+  try {
+    const vendorData = req.body;
+
+    // Check if vendor already exists
+    const existing = await Vendor.findOne({ vendor_id: vendorData.vendor_id });
+    if (existing) {
+      return res.status(400).json({ error: "Vendor with this ID already exists" });
+    }
+
+    const newVendor = await Vendor.create(vendorData);
+    res.status(201).json({
+      message: "Vendor created successfully",
+      vendor: newVendor,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+// body: fields to update: { name, address, contact, gps_location, opening_hours, inventory }
+// PUT /vendor/:vendorId
+router.put("/vendor/:vendorId", async (req, res) => {
+  try {
+    const { vendorId } = req.params;
+    const updateData = req.body;
+
+    // Check if a vendor with this vendor_id exists
+    const existingVendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId });
+    if (!existingVendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    // Flatten nested updateData to update specific fields (so we don’t overwrite everything)
+    const setFields = {};
+    for (const [key, value] of Object.entries(updateData)) {
+      setFields[`vendor_info.${key}`] = value;
+    }
+
+    // Update vendor info
+    const updatedVendor = await Vendor.findOneAndUpdate(
+      { "vendor_info.vendor_id": vendorId },
+      { $set: setFields },
+      { new: true }
+    ).lean();
+
+    res.json({
+      message: "Vendor updated successfully",
+      vendor: updatedVendor,
+    });
+  } catch (error) {
+    console.error("Error updating vendor:", error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+// DELETE /vendor/:vendorId
+router.delete("/vendor/:vendorId", async (req, res) => {
+  try {
+    const { vendorId } = req.params;
+
+    const deletedVendor = await Vendor.findOneAndDelete({ vendor_id: vendorId }).lean();
+
+    if (!deletedVendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json({
+      message: "Vendor deleted successfully",
+      vendor: deletedVendor,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+//INVENTORY STARTS HERE
+
+
+
+// Add a single inventory item to a vendor
+router.post("/vendor/:vendorId/inventory", async (req, res) => {
+  try {
+    const vendorId = req.params.vendorId;
+    const newItem = req.body; // e.g., { item_id, name, category, price, ... }
+
+    const updatedVendor = await Vendor.findOneAndUpdate(
+      { vendor_id: vendorId },
+      { $push: { inventory: newItem } },
+      { new: true, projection: { inventory: 1, vendor_info: 1 } }
+    ).lean();
+
+    if (!updatedVendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json({
+      message: "Inventory item added successfully",
+      vendor: updatedVendor.vendor_info,
+      item: newItem,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+
+// Add multiple inventory items to a vendor
+router.post("/vendor/:vendorId/inventory/bulk", async (req, res) => {
+  try {
+    const vendorId = req.params.vendorId;
+    const newItems = req.body.items; // e.g., [{ item_id, name, ... }, {...}]
+
+    if (!Array.isArray(newItems) || newItems.length === 0) {
+      return res.status(400).json({ error: "Items array is required" });
+    }
+
+    const updatedVendor = await Vendor.findOneAndUpdate(
+      { vendor_id: vendorId },
+      { $push: { inventory: { $each: newItems } } },
+      { new: true, projection: { inventory: 1, vendor_info: 1 } }
+    ).lean();
+
+    if (!updatedVendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json({
+      message: `${newItems.length} inventory items added successfully`,
+      vendor: updatedVendor.vendor_info,
+      items: newItems,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+router.put("/inventory/:itemId", async (req, res) => {
+  try {
+    const itemId = req.params.itemId;
+    const updateData = req.body; // e.g., { price: 300, quantity_available: 50 }
+
+    // Find the vendor containing the item and update the matching inventory element
+    const result = await Vendor.findOneAndUpdate(
+      { "inventory.item_id": itemId },
+      { $set: Object.fromEntries(
+          Object.entries(updateData).map(([key, value]) => [`inventory.$.${key}`, value])
+        )
+      },
+      { new: true, projection: { "inventory.$": 1, vendor_info: 1 } } // return updated item
+    ).lean();
+
+    if (!result || !result.inventory || result.inventory.length === 0) {
+      return res.status(404).json({ error: "Inventory item not found" });
+    }
+
+    res.json({
+      message: "Inventory item updated successfully",
+      vendor: result.vendor_info,
+      item: result.inventory[0],
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+
+router.put("/inventory/:vendorId/bulk", async (req, res) => {
+  try {
+    const { vendorId } = req.params;
+    const itemsToUpdate = req.body;
+
+    if (!Array.isArray(itemsToUpdate) || itemsToUpdate.length === 0) {
+      return res.status(400).json({ error: "Items array is required" });
+    }
+
+    // Validate the vendor first
+    const vendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId });
+    if (!vendor) {
+      return res.status(404).json({ error: `Vendor ${vendorId} not found` });
+    }
+
+    // Perform updates in parallel
+    const updateResults = await Promise.all(
+      itemsToUpdate.map(async (item) => {
+        const { item_id, ...updates } = item;
+        const updateQuery = {};
+
+        // Dynamically build the update fields
+        for (const [key, value] of Object.entries(updates)) {
+          updateQuery[`inventory.$.${key}`] = value;
+        }
+
+        const result = await Vendor.updateOne(
+          { "vendor_info.vendor_id": vendorId, "inventory.item_id": item_id },
+          { $set: updateQuery }
+        );
+
+        return { item_id, matched: result.matchedCount, modified: result.modifiedCount };
+      })
+    );
+
+    // Fetch the fresh vendor document after updates
+    const updatedVendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId }).lean();
+
+
+    console.log(updateResults)
+
+    res.json({
+      message: `${updateResults.filter(r => r.modified > 0).length} of ${itemsToUpdate.length} items updated successfully`,
+      updateResults,
+      vendor: updatedVendor?.vendor_info,
+      inventory: updatedVendor?.inventory,
+    });
+
+  } catch (error) {
+    console.error("Bulk update error:", error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+// DELETE /inventory/:itemId
+router.delete("/inventory/:itemId", async (req, res) => {
+  try {
+    const { itemId } = req.params;
+
+    const result = await Vendor.findOneAndUpdate(
+      { "inventory.item_id": itemId },
+      { $pull: { inventory: { item_id: itemId } } },
+      { new: true, projection: { vendor_info: 1 } }
+    ).lean();
+
+    if (!result) {
+      return res.status(404).json({ error: "Inventory item not found" });
+    }
+
+    res.json({
+      message: "Inventory item deleted successfully",
+      vendor: result.vendor_info,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+// DELETE /inventory
+// body: { itemIds: ["INV001", "INV002", ...] }
+router.delete("/inventory", async (req, res) => {
+  try {
+    const { itemIds } = req.body;
+
+    if (!Array.isArray(itemIds) || itemIds.length === 0) {
+      return res.status(400).json({ error: "itemIds array is required" });
+    }
+
+    const result = await Vendor.updateMany(
+      { "inventory.item_id": { $in: itemIds } },
+      { $pull: { inventory: { item_id: { $in: itemIds } } } }
+    );
+
+    res.json({
+      message: "Inventory items deleted successfully",
+      deletedCount: result.modifiedCount,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+*/
+
+const router = express.Router();
+router.proximityCache = {};
+
+export default router;
+
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shyntech-proximity/inventories",
-  "version": "1.0.2",
-  "main": "src/index.js",
+  "version": "1.0.3",
+  "main": "index.js",
   "files": [
     "dist",
     "src"