Merge pull request #467 from tcet-opensource/457-Create-Application-M…

…odel-and-full-Endpoint

457-Create-Application-Model-and-full-Endpoint

controller/application.js

@@ -0,0 +1,78 @@
+import {
+    addNewApplication,
+    deleteApplicationById,
+    updateApplicationById,
+    getApplication,
+  } from "#services/application";
+  import { logger } from "#util";
+
+  async function addApplication(req, res) {
+    const {
+        ERPID,
+        type,
+        data,
+        collection,
+    } = req.body;
+    try {
+      const application = await addNewApplication(
+        ERPID,
+        type,
+        data,
+        collection,
+      );
+      res.json({
+        res: `added application ${application.ERPID}`,
+        id: application.id,
+      });
+    } catch (error) {
+      logger.error("Error while inserting", error);
+      res.status(500);
+      res.json({ err: "Error while inserting in DB" });
+    }
+  }
+  async function deleteApplication(req, res) {
+    const { id } = req.params;
+    try {
+      await deleteApplicationById(id);
+      res.json({ res: "Application deleted successfully" });
+    } catch (error) {
+      logger.error("Error while deleting", error);
+      res.status(500);
+      res.json({ err: "Error while deleting from DB" });
+    }
+  }
+
+  async function updateApplication(req, res) {
+    const { id } = req.params;
+    const { ...data } = req.body;
+
+    try {
+      await updateApplicationById(id, data);
+      res.json({ res: `${id} application updated` });
+    } catch (error) {
+      logger.error("Error while inserting", error);
+      res.status(500);
+      res.json({ err: "Error while inserting in DB" });
+    }
+  }
+
+  async function showApplication(req, res) {
+    try {
+      const filter = req.body;
+      const { limit, page } = req.query;
+      const application = await getApplication(filter, limit, page);
+      return res.json({ res: application });
+    } catch (error) {
+      logger.error("Error while fetching", error);
+      res.status(500);
+      return res.json({ err: "Error while fetching the data" });
+    }
+  }
+
+  export default {
+    addApplication,
+    updateApplication,
+    deleteApplication,
+    showApplication,
+  };
+

models/application.js

@@ -0,0 +1,87 @@
+import connector from "#models/databaseUtil";
+
+const applicationSchema = {
+  ERPID: { type: String, required: true },
+  type: {
+    type: String,
+    enum: ["insert", "update", "delete"],
+    required: true,
+  },
+  data: {
+    type: connector.Schema.Types.ObjectId,
+    ref: "Data",
+    required: "true",
+  },
+  collection: { type: String, required: true },
+};
+const Application = connector.model("Application",applicationSchema );
+
+//crud operation
+async function create(applicationData) {
+    const {
+      ERPID,
+      type,
+      data,
+      collection,
+    } = applicationData;
+    const application = new Application({
+      ERPID,
+      type,
+      data,
+      collection,
+    });
+    const applicationDoc = await application.save();
+    return applicationDoc;
+  }
+
+  async function createMultiple(applicationDataArray) {
+    const applications = applicationDataArray.map(
+      ({
+        ERPID,
+        type,
+        data,
+        collection,
+      }) =>
+        Application({
+        ERPID,
+        type,
+        data,
+        collection,
+        }),
+    );
+
+    const applicationDocs = await Application.insertMany(applications);
+    return applicationDocs;
+  }
+
+  async function read(filter, limit = 0, page = 1) {
+    const applicationDoc = await Application.find(filter)
+      .limit(limit)
+      .skip((page - 1) * limit)
+      .exec();
+    const count = await Application.count();
+    const totalPages = Math.ceil(count / limit);
+    return { totalPages, data: applicationDoc };
+  }
+
+  async function update(filter, updateObject, options = { multi: true }) {
+    const updateApplication = await Application.updateMany(
+      filter,
+      { $set: updateObject },
+      options,
+    );
+    return updateApplication.acknowledged;
+  }
+
+  async function remove(filter) {
+    const deleteApplication = await Application.deleteMany(filter).exec();
+    return deleteApplication.acknowledged;
+  }
+
+  export default {
+    create,
+    read,
+    update,
+    remove,
+    createMultiple,
+  };

services/application.js

@@ -0,0 +1,44 @@
+import Application from "#models/application";
+import databaseError from "#error/database";
+
+export async function addNewApplication(
+  ERPID,
+  type,
+  data,
+  collection,
+) {
+  const newApplication = await Application.create({
+    ERPID,
+    type,
+    data,
+    collection,
+  });
+  if (String(newApplication.ERPID) === ERPID) {
+    return newApplication;
+  }
+  throw new databaseError.DataEntryError("Add Application");
+}
+
+export async function getApplication(filter, limit, page) {
+  const applications = await Application.read(filter, limit, page);
+  if (applications) {
+    return applications;
+  }
+  throw new databaseError.DataNotFoundError("Application");
+}
+
+export async function deleteAppliactionById(applicationId) {
+  const deleted = await Application.remove({ _id: applicationId });
+  if (deleted) {
+    return deleted;
+  }
+  throw new databaseError.DataDeleteError("Application");
+}
+
+export async function updateApplicationById(id, data) {
+  const updated = await Application.update({ _id: id }, data);
+  if (updated) {
+    return updated;
+  }
+  throw new databaseError.DataEntryError("Application");
+}