update

controllers/collection.js

@@ -2,14 +2,9 @@ import Collection from "../models/Collection.js";
 
 export const createCollection = async (req, res, next) => {
   const newCollection = new Collection({
-    full_name: req.body.full_name,
+    name: req.body.name,
-    date_of_birth: req.body.date_of_birth,
+    created_by: req.body.created_by,
-    userRef: req.body.userRef,
+    header: req.body.header,
-    id_num: req.body.id_num,
-    address: req.body.address,
-    images: req.body.images,
-    selfie: req.body.selfie,
-    status: req.body.status,
   });
   console.log(req.body);
   try {
@@ -18,7 +13,7 @@ export const createCollection = async (req, res, next) => {
     console.log(savedCollection);
   } catch (err) {
     // console.log(req.body);
-
+ 
     res.status(400).json({ message: err.message });
 
     next(err);

controllers/endpoint.js

@@ -0,0 +1,96 @@
+import Endpoint from "../models/Endpoint.js";
+
+export const createEndpoint = async (req, res, next) => {
+  const newEndpoint = new Endpoint({
+    name: req.body.name,
+    endpoint: req.body.endpoint,
+    method: req.body.method,
+    collection_id: req.body.collection_id,
+    created_by: req.body.created_by,
+    body_json: req.body.body_json,
+    form_data: req.body.form_data,
+    header: req.body.header,
+    params: req.body.params,
+  });
+  console.log(req.body);
+  try {
+    const savedEndpoint = await newEndpoint.save();
+    res.status(200).json(savedEndpoint);
+    console.log(savedEndpoint);
+  } catch (err) {
+    // console.log(req.body);
+
+    res.status(400).json({ message: err.message });
+
+    next(err);
+  }
+};
+
+export const updateEndpoint = async (req, res, next) => {
+  try {
+    console.log(req.params.id);
+    const updatedEndpoint = await Endpoint.findByIdAndUpdate(
+      req.params.id,
+      { $set: req.body },
+      { new: true }
+    );
+    if (updatedEndpoint) {
+      res.status(200).json(updatedEndpoint);
+    } else {
+      res.status(200).json("Endpoint does not exist.");
+    }
+  } catch (err) {
+    next(err);
+  }
+};
+
+export const deleteEndpoint = async (req, res, next) => {
+  try {
+    const getEndpoint = await Endpoint.findByIdAndDelete(req.params.id);
+    if (getEndpoint) {
+      res.status(200).json("Endpoint has been deleted.");
+    } else {
+      res.status(404).json("Endpoint does not exist.");
+    }
+  } catch (err) {
+    res.status(404).json({ message: err.message });
+
+    next(err);
+  }
+};
+export const getEndpoints = async (req, res, next) => {
+  try {
+    const getEndpoint = await Endpoint.find();
+    // const Endpoint = getEndpoint.reverse();
+    if (getEndpoint) {
+      res.status(200).json(getEndpoint);
+    } else {
+      res.status(404).json("Endpoint does not exist.");
+    }
+  } catch (err) {
+    res.status(404).json({ message: err.message });
+
+    next(err);
+  }
+};
+export const getEndpoint = async (req, res, next) => {
+  try {
+    const foundEndpoint = await Endpoint.findById(req.params.id)
+      .populate({
+        path: "userRef",
+        model: "User",
+        // select: "fName lName username photo",
+      })
+
+      .exec();
+
+    if (foundEndpoint) {
+      res.status(200).json(foundEndpoint);
+    } else {
+      res.status(404).json("Endpoint does not exist.");
+    }
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+    next(err);
+  }
+};

index.js

@@ -10,7 +10,8 @@ import path from "path";
 import { fileURLToPath } from "url";
 import authRoutes from "./routes/auth.js";
 import userRoutes from "./routes/users.js";
-import transactionRoutes from "./routes/collection.js";
+import collectionRoutes from "./routes/collection.js";
+import endpointRoutes from "./routes/endpoint.js";
 
 // import webemailRoutes from "./routes/webemail.js";
 import axios from "axios";
@@ -70,7 +71,8 @@ const upload = multer({ storage });
 /* ROUTES */
 app.use("/api/auth", authRoutes);
 app.use("/api/users", userRoutes);
-app.use("/api/transactions", transactionRoutes);
+app.use("/api/collections", collectionRoutes);
+app.use("/api/endpoints", endpointRoutes);
 
 // app.use("/api/web-emails", webemailRoutes);
 app.post("/api/upload_images", upload.single("image"), async (req, res) => {
@@ -142,11 +144,20 @@ function sendEmail(req, res, next) {
 app.post("/api/send-email/", sendEmail);
 /* MONGOOSE SETUP */
 const PORT = process.env.PORT || 3000;
+// 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, {
+  .connect(process.env.MONGO_URL)
-    useNewUrlParser: true,
-    useUnifiedTopology: true,
-  })
   .then(() => {
     app.listen(PORT, () => console.log(`Server Port: ${PORT}`));
 

middleware/log.js

@@ -7,7 +7,7 @@ const logApiCall = async (req, res, next) => {
 
     // Create a log entry
     const logEntry = new Log({
-      userId: userId,
+      userId: req.body.created_by,
       method: req.method,
       endpoint: req.originalUrl,
       body: req.body,

models/Collection.js

@@ -2,47 +2,25 @@ import mongoose from "mongoose";
 
 const CollectionSchema = mongoose.Schema(
   {
-    full_name: {
+    name: {
       type: String,
-      // required: true,
+      // required: true, 
     },
-    date_of_birth: {
+    created_by: {
-      type: String,
-      // required: true,
-    },
-    userRef: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",
     },
-    id_num: {
+    header: [
-      type: String,
-      // required: true,
-    },
-    address: {
-      type: String,
-      // required: true,
-    },
-    images: [
       {
-        link: {
+        key: {
+          type: String,
+        },
+        value: {
           type: String,
         },
         //required: true,
       },
     ],
-    selfie: {
-      type: String,
-      //required: true,
-    },
-    reason: {
-      type: String,
-      //required: true,
-    },
-    status: {
-      type: String,
-      default: "new",
-      // required: true,
-    },
   },
   { timestamps: true }
 );

models/Endpoint.js

@@ -0,0 +1,67 @@
+import mongoose from "mongoose";
+
+const EndpointSchema = mongoose.Schema(
+  {
+    endpoint: {
+      type: String,
+      // required: true,
+    },
+    name: {
+      type: String, 
+      // required: true,
+    },
+    method: {
+      type: String,
+      // required: true,
+    },
+    collection_id: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Collection",
+    },
+    created_by: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+    },
+    body_json: {
+      type: String,
+    },
+    form_data: [
+      {
+        key: {
+          type: String,
+        },
+        value: {
+          type: String,
+        },
+        //required: true,
+      },
+    ],
+    header: [
+      {
+        key: {
+          type: String,
+        },
+        value: {
+          type: String,
+        },
+        //required: true,
+      },
+    ],
+    params: [
+      {
+        key: {
+          type: String,
+        },
+        value: {
+          type: String,
+        },
+        //required: true,
+      },
+    ],
+  },
+  { timestamps: true }
+);
+
+const Endpoint = mongoose.model("Endpoint", EndpointSchema);
+
+export default Endpoint;

routes/collection.js

@@ -12,12 +12,35 @@ import logApiCall from "../middleware/log.js";
 const router = express.Router();
 
 /* READ */
-router.get("/", verifyToken, logApiCall, getCollections);
+router.get(
-router.get("/:id", verifyToken, logApiCall, getCollection);
+  "/",
+  // verifyToken,
+  getCollections
+);
+router.get(
+  "/:id",
+  // verifyToken,
+  getCollection
+);
 
-router.post("/create", verifyToken, logApiCall, createCollection);
+router.post(
-router.patch("/update/:id", verifyToken, logApiCall, updateCollection);
+  "/create",
+  // verifyToken,
+  logApiCall,
+  createCollection
+);
+router.patch(
+  "/update/:id",
+  // verifyToken,
+  logApiCall,
+  updateCollection
+);
 
-router.delete("/:id/delete", verifyToken, logApiCall, deleteCollection);
+router.delete(
+  "/:id/delete",
+  // verifyToken,
+  logApiCall,
+  deleteCollection
+);
 
 export default router;

routes/endpoint.js

@@ -0,0 +1,48 @@
+import express from "express";
+import {
+  getEndpoint,
+  getEndpoints,
+  deleteEndpoint,
+  createEndpoint,
+  updateEndpoint,
+} from "../controllers/endpoint.js";
+import { verifyToken } from "../middleware/auth.js";
+import logApiCall from "../middleware/log.js";
+
+const router = express.Router();
+
+/* READ */
+router.get(
+  "/",
+  // verifyToken,
+ 
+  getEndpoints
+);
+router.get(
+  "/:id",
+  // verifyToken,
+ 
+  getEndpoint
+);
+
+router.post(
+  "/create",
+  // verifyToken,
+  logApiCall,
+  createEndpoint
+);
+router.patch(
+  "/update/:id",
+  // verifyToken,
+  logApiCall,
+  updateEndpoint
+);
+
+router.delete(
+  "/:id/delete",
+  // verifyToken,
+  logApiCall,
+  deleteEndpoint
+);
+
+export default router;

routes/users.js

@@ -25,22 +25,67 @@ const upload = multer({
   },
 });
 /* READ */
-router.get("/", verifyToken, getUsers);
+router.get(
-router.get("/:id", verifyToken, getUser);
+  "/",
-router.get("/id/:id", verifyToken, getUserId);
+  // verifyToken,
+  getUsers
+);
+router.get(
+  "/:id",
+  // verifyToken,
+  getUser
+);
+router.get(
+  "/id/:id",
+  // verifyToken,
+  getUserId
+);
 
 router.post("/send-otp", sendOtpEmail);
 router.post("/confirm-otp", confirmOtp);
 
-router.patch("/:id", verifyToken, upload.single("picture"), updateUser);
+router.patch(
-router.patch("/:id/sub", verifyToken, updateUserSub);
+  "/:id",
-router.patch("/:id/password", verifyToken, updateUserPass);
+  // verifyToken,
-router.patch("/:id/photo", verifyToken, updateUserPhoto);
+  upload.single("picture"),
+  updateUser
+);
+router.patch(
+  "/:id/sub",
+  // verifyToken,
+  updateUserSub
+);
+router.patch(
+  "/:id/password",
+  // verifyToken,
+  updateUserPass
+);
+router.patch(
+  "/:id/photo",
+  // verifyToken,
+  updateUserPhoto
+);
 
-router.patch("/:id/friends", verifyToken, updateUserFriends);
+router.patch(
-router.patch("/:id/friends/:friendId", verifyToken, updateUserFriendData);
+  "/:id/friends",
+  // verifyToken,
+  updateUserFriends
+);
+router.patch(
+  "/:id/friends/:friendId",
+  // verifyToken,
+  updateUserFriendData
+);
 
-router.delete("/:id/friends/:friendId", verifyToken, deleteUserFriend);
+router.delete(
-router.delete("/:id", verifyToken, deleteUser);
+  "/:id/friends/:friendId",
+  // verifyToken,
+  deleteUserFriend
+);
+router.delete(
+  "/:id",
+  // verifyToken,
+  deleteUser
+);
 
 export default router;