POS_node/index.js

import express from "express";
import bodyParser from "body-parser";
import mongoose from "mongoose";
import cors from "cors";
import atob from "atob";

import dotenv from "dotenv";
import multer from "multer";
import helmet from "helmet";
import morgan from "morgan";
import path from "path";
import { fileURLToPath } from "url";
import authRoutes from "./routes/auth.js";
import userRoutes from "./routes/users.js";
import kdsRoutes from "./routes/kds.js";
import http from 'http';
import Odoo from "odoo-xmlrpc";

// import webemailRoutes from "./routes/webemail.js";
import axios from "axios";
import WebSocket, { WebSocketServer } from "ws";

// import nodemailer from "nodemailer";
// export const ws = new WebSocket("ws://192.168.50.15:4028/sT1eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY2NDE3OTI4MmE3M2ZlZWQ3MjgyM2ViOCIsImlhdCI6MTcxNTY2ODI4Nn0.ziEOLreXbCJRlyjRyIVLDsJNpeIvk73rf3kU7_HtO8E"
//  );
// ws.onopen = () => {
//   console.log("WebSocket connected------------------------------------------");

//   // You can send initial messages after the connection is established if needed
//   // ws.send("Hello, server!");
//   // const userId = "meeeee2";
//   ws.send(JSON.stringify({ type: "join", userId: "obnPay_test" }));

//   // ws.send(encryptedMessage2);
// };
// ws.onclose = () => {
//   console.log("Connection closed");
// };
/* CONFIGURATIONS */
let cachedOrders = []; // Cache for storing the last fetched orders

function fetchTodayOrders() {
  // Connect to Odoo server
  odooClient2.connect(function (err) {
    if (err) {
      console.log("Connection Error:", err);
      return; // Handle connection error
    }

    console.log("Connected to Odoo server.");

    // Get today's date range
    const today = new Date();
    const startOfDay = new Date(today.setHours(0, 0, 0, 0));
    const endOfDay = new Date(today.setHours(23, 59, 59, 999));

    // Fetch order IDs for today
    const inParams = [];
    inParams.push([["date_order", ">=", startOfDay], ["date_order", "<=", endOfDay]]);
    const params = [inParams];
 
    // Search for today's orders
    odooClient2.execute_kw("pos.order", "search", params, function (err, ids) {
      if (err) {
        console.log("Search Error:", err);
        return; // Handle search error
      }

      // If no orders found for today
      if (ids.length === 0) {
        console.log("No orders found for today.");
        return; // No orders found
      }

      // Fetch order records
      const inParamsRead = [ids]; // IDs
      const paramsRead = [inParamsRead];

      odooClient2.execute_kw("pos.order", "read", paramsRead, function (err2, records) {
        if (err2) {
          console.log("Read Error:", err2);
          return; // Handle read error
        } else {
          const newOrders = records; // New orders fetched from Odoo

          // Check for new orders against cached orders
          if (JSON.stringify(newOrders) !== JSON.stringify(cachedOrders)) {
            cachedOrders = newOrders; // Update cache

            // Notify WebSocket clients of the new data
            const messageContent = {
              type: "new_order",
              content: {
                message: "The KDS has been updated with new data"
              }
            };
          console.log("New orders:");


            // Broadcast the message to all WebSocket clients
            broadcastMessage(messageContent);
          }

        }
      });
    });
  });
}

const orderCheckInterval = setInterval(fetchTodayOrders, 3000);

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
dotenv.config();

const app = express();
let wss;

app.use(express.json());
app.use(helmet());
app.use(helmet.crossOriginResourcePolicy({ policy: "cross-origin" }));
app.use(morgan("common"));
app.use(bodyParser.json({ limit: "30mb", extended: true }));
app.use(bodyParser.urlencoded({ limit: "30mb", extended: true }));
app.use(cors());
app.use("/assets", express.static(path.join(__dirname, "upload_files")));

/* FILE STORAGE */
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    const category = req.body.category;
    // if (category == "message") {
    //   cb(null, "message_uploads");
    // } else if (category == "user") {
    //   cb(null, "user_uploads");
    // } else {
    cb(null, "upload_files");
    // }
  },
  filename: (req, file, cb) => {
    const image_id = req.body.image_id;
    cb(null, image_id + "-" + file.originalname);
  },
});

const upload = multer({ storage });

/* ROUTES */
app.use("/api/auth", authRoutes);
app.use("/api/users", userRoutes);
app.use("/api/kds", kdsRoutes);

// app.use("/api/web-emails", webemailRoutes);
app.post("/api/upload_images", upload.single("image"), async (req, res) => {
  try {
    const { filename } = req.file;

    const { image_id, category } = req.body;

    res.status(201).send({ filename, category, image_id });
  } catch (error) {
    res.status(400).send(error);
  }
});
function sendEmail(req, res, next) {
  const apiKey =
    "ODA4MDc4ZThjMDA4NjVhYzU4MTcyNDJjNTMxY2JlZGU6MGQ4ODg3ZTdiZjY1ZWNkMmQ0NzdiOWJhZGIyYTJhY2Q=";
  const apiUrl = "https://api.mailjet.com/v3.1/send";

  // const otp = generateOTP(6); // You should have a function to generate the OTP
  const email2 = "kramblooda@gmail.com";
  const min = 100000; // Minimum 6-digit number
  const max = 999999; // Maximum 6-digit number
  const randomNumber = Math.floor(Math.random() * (max - min + 1)) + min;
  const requestData = {
    Messages: [
      {
        From: {
          Email: "webdev@obanana.com",
          Name: "Obanana B2B",
        },
        To: [
          {
            Email: req.body.email,
            Name: "Subscriber",
          },
        ],
        Subject: "Obanana OTP",
        TextPart: "Greetings from Obanana!",
        HTMLPart: req.body.html,
      },
    ],
  };

  const config = {
    headers: {
      "Content-Type": "application/json",
      Authorization: `Basic ${apiKey}`,
    },     
  }; 
        
  axios 
    .post(apiUrl, requestData, config)
    .then((response) => {
      // const status = response.data.Messages[0].Status;
      // console.log(response.data.Messages[0].Status);
      // console.log(randomNumber);
      // setotpSent(randomNumber);
      res.status(200).json(response.data);

      // return `${status},${randomNumber}`;
    })
    .catch((error) => {
      res.status(404).json({ message: error });

      // console.error("Error sending OTP email:", error);
      // Handle the error here
    });
}
app.post("/api/send-email/", sendEmail);
app.post('/odoo-webhook', (req, res) => {
  const newOrder = req.body;
  console.log('New POS order received:', newOrder);

  // Process the order data as needed
  // For example, send it to a WebSocket, log it, or store it in a database

  res.status(200).send('Webhook received');
});
// const odooClient = new Odoo({
//   url: "http://192.168.50.15:8070",
//   db: "gis.pivi.com.ph",
//   username: "egalang@obanana.com",
//   password: "P@$$w0rd!",
// }); 
const odooClient2 = new Odoo({  
  url: "http://192.168.50.15:8071",
  db: "pos.obanana.com", 
  username: "mahipe@obanana.com",
  password: "P@$$w0rd!",
});

app.get("/get-orders", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0); //offset
      inParams.push(parseInt(req.query.limit) || 0); //Limit
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "pos.order",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "pos.order",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
app.get("/get-products", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0); //offset
      inParams.push(parseInt(req.query.limit) || 0); //Limit
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "product.template",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          inParamsRead.push(["id", "name"]);
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "product.template",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
app.get("/get-product_ordered", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0); //offset
      inParams.push(parseInt(req.query.limit) || 0); //Limit
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "pos.order.line",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          // inParamsRead.push([
          //   "id",
          //   "name",

          // ]);
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "pos.order.line",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
app.get("/get-stages", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0);
      inParams.push(parseInt(req.query.limit) || 0); 
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "kds.stages",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          // inParamsRead.push([
          //   "id",
          //   "name",

          // ]);
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "kds.stages",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
 
app.post('/update-order-state', async (req, res) => {
  const { id, state } = req.body; 
  if (!id || !state) {
    return res.status(400).json({ error: 'Order ID and state are required.' });
  }

  try {
    odooClient2.connect(function (err) {
      if (err) {
        console.log(err);
        return res.status(500).json({ error: 'Connection Error: ' + err.message });
      }
      console.log('Connected to Odoo server.');

      const inParams = [];
      inParams.push([['id', '=', id]]); 
      const params = [inParams];

      odooClient2.execute_kw('pos.order', 'search', params, function (err, orderIds) {
        if (err) {
          console.log(err);
          return res.status(500).json({ error: 'Search Error: ' + err.message });
        }

        if (orderIds.length === 0) {
          return res.status(404).json({ error: 'Order not found.' });
        }

        const inParamsUpdate = [];
        inParamsUpdate.push(orderIds);
        inParamsUpdate.push({ state: state }); 
        const paramsUpdate = [inParamsUpdate];

        odooClient2.execute_kw('pos.order', 'write', paramsUpdate, function (err2, result) {
          if (err2) {
            console.log(err2);
            return res.status(500).json({ error: 'Update Error: ' + err2.message });
          }

          if (result) {
            return res.json({ success: true, message: `Order ID ${id} updated to state: ${state}` });
          } else {
            return res.status(500).json({ error: 'Failed to update order state.' });
          }
        });
      });
    });
  } catch (error) {
    console.error('Error:', error);
    return res.status(500).json({ error: 'Update Error: ' + error.message });
  }
});
app.get("/get-tables", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0);
      inParams.push(parseInt(req.query.limit) || 0); 
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "restaurant.table",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          // inParamsRead.push([
          //   "id",
          //   "name",

          // ]);
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "restaurant.table",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});

// function fetchOdooData(model, method, params) {
//   return new Promise((resolve, reject) => {
//     odooClient.execute_kw(model, method, params, (err, data) => {
//       if (err) return reject(err);
//       resolve(data);
//     });
//   });
// }

/* MONGOOSE SETUP */
const PORT = process.env.PORT || 3002;
// mongoose
//   .connect(process.env.MONGO_URL, {
//     useNewUrlParser: true,
//     useUnifiedTopology: true,
//   })
//   .then(() => {
//     app.listen(PORT, () => console.log(`Server Port: ${PORT}`));

//     // /* ADD DATA ONE TIME */
//   })
//   .catch((error) => console.log(`${error} did not connect`));

// mongoose
//   .connect(process.env.DATABASE_URL)
//   .then(() => {
//     app.listen(PORT, () => console.log(`Server Port: ${PORT}`));

//     // /* ADD DATA ONE TIME */
//   })
//   .catch((error) => console.log(`${error} did not connect`));


mongoose.connect(process.env.DATABASE_URL)
  .then(() => {
    const server = http.createServer(app);
    
    try {

      wss = new WebSocketServer({ server });
     
     wss.on('connection', (ws) => {
       console.log('A user connected');
 
       ws.on('message', (message) => {
         console.log('Received from client: ', message);
       });
 
       ws.on('close', () => {
         console.log('A user disconnected');
       });
      });
      wss.on('listening', () => {
        console.log('WebSocket server is running and ready to accept connections');
    }); 
    }catch(error){
      console.log(`Server failed on port ${PORT}`);

    }
    // Start the server and WebSocket
    server.listen(PORT, () => {
      console.log(`Server is running on port ${PORT}`);
    });
  })
  .catch((error) => console.log(`${error} did not connect`));
  export const broadcastMessage = (message) => {
    wss.clients.forEach((client) => {
      if (client.readyState === client.OPEN) {
        client.send(JSON.stringify(message)); 
      }
    });
  };