powr-sdk-api 2.0.2 → 2.0.4

package/dist/admin/forms.js

@@ -0,0 +1,240 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const multer = require('multer');
+const path = require('path');
+const upload = multer({
+  storage: multer.memoryStorage(),
+  fileFilter: function (req, file, cb) {
+    if (file.mimetype === 'application/json' || path.extname(file.originalname).toLowerCase() === '.json') {
+      cb(null, true);
+    } else {
+      cb(new Error('Only JSON files are allowed!'), false);
+    }
+  },
+  limits: {
+    fileSize: 5 * 1024 * 1024
+  }
+});
+
+// GET all powrForm data based on projectId
+router.get("/powrform", async (req, res) => {
+  const projectId = req.query.projectId;
+  try {
+    const collection = req.db.collection("powrForm");
+    const forms = await collection.find({
+      projectId
+    }).toArray();
+    res.status(200).json({
+      success: true,
+      message: "Fetching powrForm data",
+      count: forms.length,
+      data: forms
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: "Internal server error",
+      error: error.message
+    });
+  }
+});
+
+// GET specific form by formName and projectId
+router.get('/:formName', async (req, res) => {
+  try {
+    const {
+      formName
+    } = req.params;
+    const {
+      projectId
+    } = req.query;
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required as query parameter'
+      });
+    }
+    const collection = req.db.collection("powrForm");
+    const formData = await collection.findOne({
+      formName,
+      projectId
+    });
+    if (!formData) {
+      return res.status(404).json({
+        success: false,
+        message: 'Form not found'
+      });
+    }
+    res.status(200).json({
+      success: true,
+      message: "Form fetched successfully",
+      data: formData
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Error fetching form',
+      error: error.message
+    });
+  }
+});
+
+// POST /studentform
+router.post('/studentform', async (req, res) => {
+  try {
+    const formData = req.body;
+    const {
+      projectId
+    } = req.query;
+    const {
+      whatsapp,
+      formName,
+      email,
+      ...otherFormFields
+    } = formData;
+    const studentsFormCollection = req.db.collection('studentsForm');
+    const existingForm = await studentsFormCollection.findOne({
+      whatsapp: whatsapp,
+      projectId: projectId,
+      email: email,
+      formName: formName
+    });
+    if (existingForm) {
+      return res.status(409).json({
+        message: 'You have already submitted this form. Only one submission per form type is allowed.',
+        existingFormId: existingForm._id,
+        submittedAt: existingForm.submittedAt
+      });
+    }
+    const studentFormData = {
+      whatsapp: whatsapp,
+      formName: formName,
+      projectId: projectId,
+      email: email,
+      ...otherFormFields,
+      submittedAt: new Date()
+    };
+    const formResult = await studentsFormCollection.insertOne(studentFormData);
+    res.status(201).json({
+      success: true,
+      message: 'Student form submitted successfully',
+      submittedFormId: formResult.insertedId,
+      data: studentFormData
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Error submitting student form',
+      error: error.message
+    });
+  }
+});
+
+//get form
+router.get('/getCount/:formName', async (req, res) => {
+  try {
+    const {
+      formName
+    } = req.params;
+    const {
+      projectId
+    } = req.query;
+    const studentsFormCollection = getDb().collection('studentsForm');
+
+    // Build query object
+    let query = {
+      formName
+    };
+    if (projectId) {
+      query.projectId = projectId;
+    }
+    const submissions = await studentsFormCollection.find(query).toArray();
+    res.status(200).json({
+      success: true,
+      message: 'Submission count retrieved successfully',
+      formName: formName,
+      projectId: projectId,
+      count: submissions.length,
+      data: submissions
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Error counting form submissions',
+      error: error.message
+    });
+  }
+});
+
+// POST /create-form - Upload JSON file and store form data
+router.post('/create-form', upload.single('jsonFile'), async (req, res) => {
+  try {
+    const {
+      projectId
+    } = req.query;
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required as query parameter'
+      });
+    }
+    if (!req.file) {
+      return res.status(400).json({
+        success: false,
+        message: 'JSON file is required'
+      });
+    }
+    let formData;
+    try {
+      const fileContent = req.file.buffer.toString('utf8');
+      formData = JSON.parse(fileContent);
+    } catch (parseError) {
+      return res.status(400).json({
+        success: false,
+        message: 'Invalid JSON file format',
+        error: parseError.message
+      });
+    }
+    if (!formData.formName) {
+      return res.status(400).json({
+        success: false,
+        message: 'formName is required in JSON data'
+      });
+    }
+    const powrFormCollection = getDb().collection('powrForm');
+    const existingForm = await powrFormCollection.findOne({
+      formName: formData.formName,
+      projectId: projectId
+    });
+    if (existingForm) {
+      return res.status(409).json({
+        success: false,
+        message: 'Form with this name already exists for this project',
+        existingFormId: existingForm._id
+      });
+    }
+    const finalFormData = {
+      ...formData,
+      projectId: projectId,
+      createdAt: new Date()
+    };
+    const result = await powrFormCollection.insertOne(finalFormData);
+    res.status(201).json({
+      success: true,
+      message: 'Form created and stored successfully',
+      formId: result.insertedId,
+      formName: formData.formName,
+      projectId: projectId,
+      data: finalFormData
+    });
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: 'Error creating form',
+      error: error.message
+    });
+  }
+});
+module.exports = router;

package/dist/admin/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const express = require('express');
+
+// Import all route modules
+const commentsRoutes = require('./comments');
+// const filesRoutes = require('./files'); // Commented out for now
+const formsRoutes = require('./forms');
+const invoiceRoutes = require('./invoice');
+const likesRoutes = require('./likes');
+const plexxRoutes = require('./plexx');
+const ratingsRoutes = require('./ratings');
+const usersRoutes = require('./users');
+const waitlistsRoutes = require('./waitlists');
+const activitiesRoutes = require('./activities');
+const authRoutes = require('./auth');
+const blogsRoutes = require('./blogs');
+const slidesRoutes = require('./slides');
+const notificationsRoutes = require('./notifications');
+const createAdminRoutes = () => {
+  // Get config from environment variables
+
+  const router = express.Router();
+
+  // Mount all route modules
+  router.use('/comments', commentsRoutes);
+  // router.use('/files', filesRoutes); // Commented out for now
+  router.use('/forms', formsRoutes);
+  router.use('/invoice', invoiceRoutes);
+  router.use('/likes', likesRoutes);
+  router.use('/plexx', plexxRoutes);
+  router.use('/ratings', ratingsRoutes);
+  router.use('/users', usersRoutes);
+  router.use('/waitlists', waitlistsRoutes);
+  router.use('/activities', activitiesRoutes);
+  router.use('/auth', authRoutes);
+  router.use('/blogs', blogsRoutes);
+  router.use('/slides', slidesRoutes);
+  router.use('/notifications', notificationsRoutes);
+  return router;
+};
+module.exports = {
+  createAdminRoutes
+};

package/dist/admin/invoice.js

@@ -0,0 +1,163 @@
+"use strict";
+
+const express = require('express');
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+const {
+  ObjectId
+} = require("mongodb");
+router.get('/', async (req, res) => {
+  const {
+    projectId
+  } = req.query;
+  try {
+    const query = {
+      projectId
+    };
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required.'
+      });
+    }
+    const invoiceData = await getDb().collection("invoices").find(query).toArray();
+    return res.status(200).json({
+      success: true,
+      invoices: invoiceData
+    });
+  } catch (error) {
+    console.error("Error retrieving invoices :", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve invoices ."
+    });
+  }
+});
+router.get('/:invoiceId', async (req, res) => {
+  const {
+    invoiceId
+  } = req.params;
+  const {
+    projectId
+  } = req.query;
+  try {
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required.'
+      });
+    }
+    const _id = new ObjectId(invoiceId);
+    const invoiceData = await getDb().collection("invoices").findOne({
+      _id,
+      projectId
+    });
+    return res.status(200).json({
+      success: true,
+      invoice: invoiceData
+    });
+  } catch (error) {
+    console.error("Error retrieving invoice :", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve invoice."
+    });
+  }
+});
+router.post('/', async (req, res) => {
+  const {
+    projectId
+  } = req.query;
+  const {
+    invoiceNumber,
+    dateOfIssue,
+    paymentStatus,
+    customerInfo,
+    serviceSection,
+    paymentSection
+  } = req.body;
+  if (!projectId) {
+    return res.status(400).json({
+      success: false,
+      message: "projectId is required."
+    });
+  }
+  const invoice = {
+    invoiceNumber,
+    dateOfIssue,
+    paymentStatus,
+    customerInfo,
+    serviceSection,
+    paymentSection,
+    createdAt: new Date()
+  };
+  invoice.projectId = projectId;
+  try {
+    const result = await getDb().collection("invoices").insertOne(invoice);
+    if (result && result.insertedId) {
+      return res.status(201).json({
+        success: true,
+        message: "Invoice created successfully.",
+        invoiceId: result.insertedId,
+        invoice
+      });
+    } else {
+      return res.status(500).json({
+        success: false,
+        message: "Invoice could not be added."
+      });
+    }
+  } catch (error) {
+    console.error("Error adding invoice:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to add invoice due to a server error."
+    });
+  }
+});
+router.put('/:invoiceId', async (req, res) => {
+  const {
+    invoiceId
+  } = req.params;
+  const {
+    projectId
+  } = req.query;
+  if (!projectId) {
+    return res.status(400).json({
+      success: false,
+      message: "projectId is required."
+    });
+  }
+  let filter;
+  try {
+    filter = {
+      _id: new ObjectId(invoiceId),
+      projectId: projectId
+    };
+  } catch (e) {
+    return res.status(400).json({
+      success: false,
+      message: "Invalid invoiceId format."
+    });
+  }
+  const updateData = req.body;
+  try {
+    const result = await getDb().collection("invoices").updateOne(filter, {
+      $set: updateData
+    });
+    return res.status(200).json({
+      success: true,
+      message: "Invoice updated successfully.",
+      result: result
+    });
+  } catch (error) {
+    console.error("Error updating invoice:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to update invoice due to a server error."
+    });
+  }
+});
+module.exports = router;

package/dist/admin/likes.js

@@ -0,0 +1,126 @@
+"use strict";
+
+const express = require('express');
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+const {
+  ObjectId
+} = require("mongodb");
+
+// Like/Unlike endpoint
+router.post('/', async (req, res) => {
+  const {
+    liked
+  } = req.body;
+  const {
+    userId,
+    projectId,
+    contentId
+  } = req.query;
+  if (!userId || typeof liked !== 'boolean' || !projectId) {
+    return res.status(400).json({
+      success: false,
+      message: 'userId and projectId are required in query, liked (boolean) is required in body.'
+    });
+  }
+  try {
+    const query = {
+      userId: new ObjectId(userId),
+      projectId
+    };
+    const setObj = {
+      liked
+    };
+    if (contentId) {
+      query.contentId = contentId;
+      setObj.contentId = contentId;
+    }
+    const response = await getDb().collection('likes').updateOne(query, {
+      $set: setObj
+    }, {
+      upsert: true
+    });
+    return res.status(200).json({
+      success: true,
+      message: liked ? 'Liked.' : 'Unliked.',
+      response
+    });
+  } catch (error) {
+    console.error('Error updating like status:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to update like status.'
+    });
+  }
+});
+router.get('/', async (req, res) => {
+  const {
+    projectId,
+    contentId
+  } = req.query;
+  if (!projectId) {
+    return res.status(400).json({
+      success: false,
+      message: 'projectId is required in query.'
+    });
+  }
+  try {
+    const query = {
+      projectId
+    };
+    if (contentId) {
+      query.contentId = contentId;
+    }
+    const likes = await getDb().collection('likes').find(query).toArray();
+    const likesCount = likes.filter(like => like.liked === true).length;
+    const unlikesCount = likes.filter(like => like.liked === false).length;
+    return res.status(200).json({
+      success: true,
+      likes,
+      likesCount,
+      unlikesCount
+    });
+  } catch (error) {
+    console.error('Error fetching likes:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to fetch likes.'
+    });
+  }
+});
+router.get('/:likeId', async (req, res) => {
+  const {
+    likeId
+  } = req.params;
+  const {
+    projectId,
+    contentId
+  } = req.query;
+  try {
+    const filter = {
+      userId: new ObjectId(likeId)
+    };
+    if (projectId) filter.projectId = projectId;
+    if (contentId) filter.contentId = contentId;
+    const like = await getDb().collection('likes').findOne(filter);
+    if (!like) {
+      return res.status(404).json({
+        success: false,
+        message: 'Like not found.'
+      });
+    }
+    return res.status(200).json({
+      success: true,
+      like
+    });
+  } catch (error) {
+    console.error('Error fetching like by id:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to fetch like.'
+    });
+  }
+});
+module.exports = router;

package/dist/admin/notifications.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const express = require('express');
+const router = express.Router();
+const {
+  getDb
+} = require('../services/mongo');
+// const tokenService = require('../services/tokenService');
+
+// Get notifications
+router.get('/', async (req, res) => {
+  const {
+    projectId
+  } = req.query;
+  try {
+    const query = {
+      projectId
+    };
+    console.log("Filter.....:", query);
+    const notificationData = await getDb().collection('notifications').find(query).toArray();
+    if (!notificationData || notificationData.length === 0) {
+      console.log("Data not found.");
+      return res.status(200).json({
+        success: true,
+        notification: []
+      });
+    }
+    const sortedData = notificationData.sort((a, b) => new Date(b === null || b === void 0 ? void 0 : b.createdAt) - new Date(a === null || a === void 0 ? void 0 : a.createdAt));
+    console.log("Notifications retrieved and sorted:", sortedData);
+    return res.status(200).json({
+      success: true,
+      notification: sortedData
+    });
+  } catch (error) {
+    console.error("Error retrieving notifications:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve notifications."
+    });
+  }
+});
+
+// Send notification
+router.post('/', async (req, res) => {
+  const {
+    projectId,
+    title,
+    description,
+    filter,
+    imgurl
+  } = req.body;
+  if (typeof filter !== 'object' || Array.isArray(filter) || filter === null) {
+    return res.status(400).json({
+      success: false,
+      message: "Filter should be a valid object."
+    });
+  }
+  const notificationData = {
+    projectId,
+    filter,
+    imgurl,
+    title,
+    description,
+    createdAt: new Date()
+  };
+  try {
+    const result = await getDb().collection('notifications').insertOne(notificationData);
+    if (result && result.insertedId) {
+      console.log("Notification added with ID:", result.insertedId);
+
+      //   await tokenService.sendNotificationsToProjectUsers(projectId, notificationData);
+
+      return res.status(200).json({
+        success: true,
+        message: "Notification added and sent successfully.",
+        notificationId: result.insertedId
+      });
+    } else {
+      console.error("Insert operation failed. Result:", result);
+      return res.status(500).json({
+        success: false,
+        message: "Notification could not be added."
+      });
+    }
+  } catch (error) {
+    console.error("Error adding notification:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to add notification due to a server error."
+    });
+  }
+});
+module.exports = router;

package/dist/admin/plexx.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+const data = [{
+  age: 12
+}, {
+  age: 45
+}];
+router.get("/:route", async (req, res) => {
+  const {
+    route
+  } = req.params;
+  const {
+    name,
+    projectId
+  } = req.query;
+  if (!projectId) {
+    return res.status(400).json({
+      success: false,
+      message: 'projectId is required.'
+    });
+  }
+  const logicEntry = await getDb().collection("routes").findOne({
+    route,
+    projectId
+  });
+  if (!logicEntry) {
+    return res.status(404).json({
+      success: false,
+      message: "Logic not found"
+    });
+  }
+  const codeString = logicEntry.code;
+  try {
+    const logicFunction = new Function("age", codeString);
+    const status = logicFunction(name);
+    return res.status(200).json({
+      success: true,
+      data: status
+    });
+  } catch (err) {
+    console.error("Error executing logic:", err);
+    return res.status(500).json({
+      success: false,
+      message: "Error executing logic"
+    });
+  }
+});
+module.exports = router;