811 lines
26 KiB
JavaScript
811 lines
26 KiB
JavaScript
import express from "express";
|
|
import bodyParser from "body-parser";
|
|
import mongoose from "mongoose";
|
|
import cors from "cors";
|
|
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 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 */
|
|
const __filename = fileURLToPath(import.meta.url);
|
|
const __dirname = path.dirname(__filename);
|
|
dotenv.config();
|
|
|
|
const app = express();
|
|
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);
|
|
|
|
const odooClient = new Odoo({
|
|
url: "https://gis.pivi.com.ph",
|
|
db: "gis.pivi.com.ph",
|
|
username: "egalang@obanana.com",
|
|
password: "P@$$w0rd!",
|
|
});
|
|
const odooClient2 = new Odoo({
|
|
url: "http://localhost:8069/",
|
|
db: "Paymongo",
|
|
username: "mahipe@obanana.com",
|
|
password: "abcd123",
|
|
});
|
|
app.get("/get-assets", async (req, res) => {
|
|
try {
|
|
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 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 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,
|
|
};
|
|
}
|
|
);
|
|
// res.json({
|
|
// data: recordsArray,
|
|
// attr: attributes,
|
|
// bounds: bounds,
|
|
// images: images,
|
|
// });
|
|
res.json(asset);
|
|
}
|
|
|
|
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) => {
|
|
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; // Order ID and new state passed in the request 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.');
|
|
|
|
// Search for the order by ID
|
|
const inParams = [];
|
|
inParams.push([['id', '=', id]]); // Find the order by its 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.' });
|
|
}
|
|
|
|
// Update the state of the order
|
|
const inParamsUpdate = [];
|
|
inParamsUpdate.push(orderIds); // Order IDs to update
|
|
inParamsUpdate.push({ state: state }); // Fields to update
|
|
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 });
|
|
}
|
|
});
|
|
|
|
|
|
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.MONGO_URL)
|
|
.then(() => {
|
|
app.listen(PORT, () => console.log(`Server Port: ${PORT}`));
|
|
|
|
// /* ADD DATA ONE TIME */
|
|
})
|
|
.catch((error) => console.log(`${error} did not connect`));
|