Obanana.Corporation
/
POS_node
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

up

This commit is contained in:
JunBarroga 2024-11-06 14:05:34 +08:00
parent 0d6bd655de
commit 54c893dc9d
2 changed files with 141 additions and 561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
controllers/kds.js
View File

@ -1,3 +1,4 @@
import { broadcastMessage } from "../index.js";
import KDSModel from "../models/KDS.js"; import KDSModel from "../models/KDS.js";
// Resolver to create a new KDS document // Resolver to create a new KDS document
@ -64,6 +65,16 @@ export const updateKDS = async (req, res, next) => {
{ new: true } { new: true }
); );
if (updatedKDS) { if (updatedKDS) {
const messageContent = {
type: "kds_update",
content: {
message: "The KDS has been updated with new data",
value:JSON.stringify(updatedKDS)
}
};
// Broadcast the message to all WebSocket clients
broadcastMessage(messageContent);
res.status(200).json(updatedKDS); res.status(200).json(updatedKDS);
} else { } else {
res.status(404).json("KDS does not exist."); res.status(404).json("KDS does not exist.");

691
index.js
View File

@ -13,7 +13,7 @@ import { fileURLToPath } from "url";
import authRoutes from "./routes/auth.js"; import authRoutes from "./routes/auth.js";
import userRoutes from "./routes/users.js"; import userRoutes from "./routes/users.js";
import kdsRoutes from "./routes/kds.js"; import kdsRoutes from "./routes/kds.js";
import http from 'http';
import Odoo from "odoo-xmlrpc"; import Odoo from "odoo-xmlrpc";
// import webemailRoutes from "./routes/webemail.js"; // import webemailRoutes from "./routes/webemail.js";
@ -37,11 +37,85 @@ import WebSocket, { WebSocketServer } from "ws";
// console.log("Connection closed"); // console.log("Connection closed");
// }; // };
/* CONFIGURATIONS */ /* 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 __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename); const __dirname = path.dirname(__filename);
dotenv.config(); dotenv.config();
const app = express(); const app = express();
let wss;
app.use(express.json()); app.use(express.json());
app.use(helmet()); app.use(helmet());
app.use(helmet.crossOriginResourcePolicy({ policy: "cross-origin" })); app.use(helmet.crossOriginResourcePolicy({ policy: "cross-origin" }));
@ -144,7 +218,15 @@ function sendEmail(req, res, next) {
}); });
} }
app.post("/api/send-email/", sendEmail); 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({ // const odooClient = new Odoo({
// url: "http://192.168.50.15:8070", // url: "http://192.168.50.15:8070",
// db: "gis.pivi.com.ph", // db: "gis.pivi.com.ph",
@ -157,360 +239,7 @@ const odooClient2 = new Odoo({
username: "mahipe@obanana.com", username: "mahipe@obanana.com",
password: "P@$$w0rd!", password: "P@$$w0rd!",
}); });
app.get("/get-assets", async (req, res) => {
try {
const authHeader = req.headers.authorization;
if (!authHeader || !authHeader.startsWith('Basic ')) {
return res.status(400).json({ error: 'Authorization header is missing or invalid.' });
}
const base64Credentials = authHeader.split(' ')[1];
const decodedCredentials = atob(base64Credentials);
const [email, password] = decodedCredentials.split(':');
if (!email || !password) {
return res.status(400).json({ error: 'Invalid credentials format.' });
}
// console.log(email,password)
const odooClient = new Odoo({
url: "http://192.168.50.15:8070",
db: "gis.pivi.com.ph",
username: email,
password: password
});
odooClient.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 = [];
odooClient.execute_kw(
"pivi_assets.pivi_assets",
"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];
odooClient.execute_kw(
"pivi_assets.pivi_assets",
"read",
paramsRead,
async function (err2, records) {
if (err2) {
console.log(err2);
return res
.status(500)
.json({ error: "Read Error: " + err2.message });
} else {
recordsArray = records;
odooClient.execute_kw(
"pivi_assets.attributes",
"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",
"value",
"asset",
"__last_update",
"display_name",
"create_uid",
"create_date",
"write_uid",
"write_date",
]);
const paramsRead = [inParamsRead];
odooClient.execute_kw(
"pivi_assets.attributes",
"read",
paramsRead,
async function (err2, attr) {
if (err2) {
console.log(err2);
return res
.status(500)
.json({ error: "Read Error: " + err2.message });
} else {
attributes = attr;
odooClient.execute_kw(
"pivi_assets.bounds",
"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",
"longitude",
"latitude",
"asset",
"__last_update",
"display_name",
"create_uid",
"create_date",
"write_uid",
"write_date",
]);
const paramsRead = [inParamsRead];
odooClient.execute_kw(
"pivi_assets.bounds",
"read",
paramsRead,
async function (err2, bound) {
if (err2) {
console.log(err2);
return res.status(500).json({
error: "Read Error: " + err2.message,
});
} else {
bounds = bound;
odooClient.execute_kw(
"ir.attachment",
"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",
"local_url",
"res_id",
]);
const paramsRead = [inParamsRead];
odooClient.execute_kw(
"ir.attachment",
"read",
paramsRead,
async function (err2, image) {
if (err2) {
console.log(err2);
return res.status(500).json({
error:
"Read Error: " + err2.message,
});
} else {
images = image;
const inParams = [];
inParams.push([["related_asset", "!=", false]]);
inParams.push(parseInt(req.query.offset) || 0); //offset
inParams.push(parseInt(req.query.limit) || 0); //Limit
const params1 = [inParams];
odooClient.execute_kw(
"pivi_assets.related",
"search",
params1,
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",
"related_asset",
"asset",
]);
const paramsRead = [inParamsRead];
odooClient.execute_kw(
"pivi_assets.related",
"read",
paramsRead,
async function (err2, related) {
if (err2) {
console.log(err2);
return res.status(500).json({
error:
"Read Error: " + err2.message,
});
} else {
let relateds
relateds = related;
const asset = recordsArray.map(
(item) => {
// Find matching attributes based on the numeric part of attr.assets
const matchedAttr =
attributes.filter(
(attribute) =>
item.attributes.some(
(attrId) =>
attrId ===
attribute.id
) // Compare to the first element of attr.assets
);
// Find matching bounds based on the numeric part of bounds.assets
const matchedBounds =
bounds.filter(
(bound) =>
item.bounds.some(
(boundId) =>
boundId === bound.id
) // Compare to the first element of bounds.assets
);
// Find matching bounds based on the numeric part of bounds.assets
const matchedRelated =
relateds.filter(
(related) =>
item.related.some(
(relatedId) =>
relatedId === related.id
)
);
// Find matching images based on data.id == images.res_id
const matchedImages =
images.filter(
(image) =>
image.res_id === item.id
);
// Construct the asset object for this item
return {
attr: matchedAttr,
bounds: matchedBounds,
data: item,
images: matchedImages,
related: matchedRelated
};
}
);
// res.json({
// data: recordsArray,
// attr: attributes,
// bounds: bounds,
// images: images,
// });
res.json(asset);
}
let pendingRequests =
records.length;
}
);
}
);
}
let pendingRequests =
records.length;
}
);
}
);
}
}
);
}
);
}
}
);
}
);
}
let pendingRequests = records.length;
}
);
}
);
});
} catch (error) {
console.error("Error:", error);
res.status(500).json({ error: "Data Fetch Error: " + error.message });
}
});
app.get("/get-orders", async (req, res) => { app.get("/get-orders", async (req, res) => {
try { try {
odooClient2.connect(async function (err) { odooClient2.connect(async function (err) {
@ -936,208 +665,6 @@ app.get("/get-tables", async (req, res) => {
} }
}); });
app.post('/create-asset-bounds', async (req, res) => {
try {
const postData = req.body;
if (!postData || postData.length === 0) {
return res.status(200).json({ error: 'No data provided.' });
}
const authHeader = req.headers.authorization;
if (!authHeader || !authHeader.startsWith('Basic ')) {
return res.status(400).json({ error: 'Authorization header is missing or invalid.' });
}
const base64Credentials = authHeader.split(' ')[1];
const decodedCredentials = Buffer.from(base64Credentials, 'base64').toString('ascii'); // safer than `atob`
const [email, password] = decodedCredentials.split(':');
if (!email || !password) {
return res.status(400).json({ error: 'Invalid credentials format.' });
}
const odooClient = new Odoo({
url: "http://192.168.50.15:8070",
db: "gis.pivi.com.ph",
username: email,
password: password
});
odooClient.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.');
// Use Promise.all to wait for all async operations to finish
try {
const createdIds = await Promise.all(
postData.map(async (data, index) => {
const { asset, name, longitude, latitude } = data;
if (!asset || !name || !longitude || !latitude) {
throw new Error(`Missing required fields in entry ${index + 1}`);
}
const params = [
{
asset: asset,
name: name,
longitude: longitude,
latitude: latitude,
}
];
// Return a promise for each create operation
return new Promise((resolve, reject) => {
odooClient.execute_kw('pivi_assets.bounds', 'create', [params], function (err2, id) {
if (err2) {
console.log('Create Error:', err2);
return reject(new Error('Create Error: ' + err2.message));
}
resolve(id);
});
});
})
);
return res.json({ success: true, createdIds });
} catch (error) {
return res.status(500).json({ error: error.message });
}
});
} catch (error) {
console.error('Error:', error);
return res.status(500).json({ error: 'Server Error: ' + error.message });
}
});
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');
});
app.delete('/delete-asset-bounds', async (req, res) => {
try {
const assetId = req.query.asset;
console.log(assetId)
if (!assetId) {
return res.status(400).json({ error: 'Asset ID is required.' });
}
const authHeader = req.headers.authorization;
if (!authHeader || !authHeader.startsWith('Basic ')) {
return res.status(400).json({ error: 'Authorization header is missing or invalid.' });
}
const base64Credentials = authHeader.split(' ')[1];
const decodedCredentials = atob(base64Credentials);
const [email, password] = decodedCredentials.split(':');
if (!email || !password) {
return res.status(400).json({ error: 'Invalid credentials format.' });
}
// console.log(email,password)
const odooClient = new Odoo({
url: "http://192.168.50.15:8070",
db: "gis.pivi.com.ph",
username: email,
password: password
});
odooClient.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', '=', assetId]]);
const searchParamsAsset = [inParams];
// const searchParamsAsset = [
// [['id', '=', assetId]]
// ];
odooClient.execute_kw('pivi_assets.pivi_assets', 'search', searchParamsAsset, function (err2, assetIds) {
if (err2) {
console.log(assetIds+" id")
console.log('Search Error:', err2);
return res.status(500).json({ error: 'Search Asset Error: ' + err2.message });
}
if (assetIds.length === 0) {
return res.status(404).json({ error: 'Asset not found.' });
}
odooClient.execute_kw('pivi_assets.pivi_assets', 'read', [assetIds], function (err3, assets) {
if (err3) {
console.log('Read Error:', err3);
return res.status(500).json({ error: 'Read Error: ' + err3.message });
}
const assetName = assets[0].name;
// const searchParamsBounds = [
// [['asset', '=', assetName]]
// ];
const inParams = [];
inParams.push([['asset', '=', assetName]]);
const searchParamsBounds = [inParams];
odooClient.execute_kw('pivi_assets.bounds', 'search', searchParamsBounds, function (err4, boundIds) {
if (err4) {
console.log('Search Bounds Error:', err4);
return res.status(500).json({ error: 'Search Bounds Error: ' + err4.message });
}
if (boundIds.length === 0) {
return res.status(200).json({ error: 'No bounds found for this asset.' });
}
odooClient.execute_kw('pivi_assets.bounds', 'read', [[boundIds]], function (err5, bounds) {
if (err5) {
console.log('Read Bounds Error:', err5);
return res.status(500).json({ error: 'Read Bounds Error: ' + err5.message });
}
const deletedIds = [];
bounds.forEach((bound, index) => {
const boundId = bound.id;
odooClient.execute_kw('pivi_assets.bounds', 'unlink', [[boundId]], function (err6) {
if (err6) {
console.log('Unlink Error:', err6);
return res.status(500).json({ error: 'Unlink Error: ' + err6.message });
}
deletedIds.push(boundId);
if (deletedIds.length === bounds.length) {
return res.json({ success: true, deletedIds });
}
});
});
});
});
});
});
});
} catch (error) {
console.error('Error:', error);
return res.status(500).json({ error: 'Server Error: ' + error.message });
}
});
// function fetchOdooData(model, method, params) { // function fetchOdooData(model, method, params) {
// return new Promise((resolve, reject) => { // return new Promise((resolve, reject) => {
// odooClient.execute_kw(model, method, params, (err, data) => { // odooClient.execute_kw(model, method, params, (err, data) => {
@ -1161,11 +688,53 @@ const PORT = process.env.PORT || 3002;
// }) // })
// .catch((error) => console.log(`${error} did not connect`)); // .catch((error) => console.log(`${error} did not connect`));
mongoose // mongoose
.connect(process.env.DATABASE_URL) // .connect(process.env.DATABASE_URL)
.then(() => { // .then(() => {
app.listen(PORT, () => console.log(`Server Port: ${PORT}`)); // app.listen(PORT, () => console.log(`Server Port: ${PORT}`));
// /* ADD DATA ONE TIME */ // // /* 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`)); .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));
}
});
};