powr-sdk-api 2.1.0 → 2.2.1

package/dist/routes/forms.js

@@ -0,0 +1,242 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const multer = require('multer');
+const path = require('path');
+const {
+  getDb
+} = require('../services/dbService');
+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.projectId;
+  try {
+    const db = await getDb();
+    const collection = 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.projectId;
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required'
+      });
+    }
+    const db = await getDb();
+    const collection = 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.projectId;
+    const {
+      whatsapp,
+      formName,
+      email,
+      ...otherFormFields
+    } = formData;
+    const db = await getDb();
+    const studentsFormCollection = 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/routes/index.js

@@ -1,75 +1,53 @@
 "use strict";
 
-// Main routes index for powr-sdk-api
-// This file exports all route handlers for easy integration
+const express = require('express');
 
-const {
-  createAdminRoutes
-} = require('./admin');
-const createRoutes = (app, options = {}) => {
+// 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 createPowrRoutes = () => {
+  // Get config from environment variables
   const {
-    projectId,
-    baseUrl = '/api',
-    authMiddleware = null,
-    logger = console,
-    mongoUrl = process.env.MONGODB_URI || 'mongodb://localhost:27017/powrbase'
-  } = options;
+    getConfig
+  } = require('../config');
+  const config = getConfig();
+  const router = express.Router();
 
-  // Apply auth middleware if provided
-  if (authMiddleware) {
-    app.use(`${baseUrl}/admin`, authMiddleware);
-  }
-
-  // Initialize admin routes
-  createAdminRoutes(app, {
-    projectId,
-    apiUrl: `${baseUrl}/admin`,
-    authMiddleware,
-    logger,
-    mongoUrl
-  });
-
-  // Health check endpoint
-  app.get(`${baseUrl}/health`, (req, res) => {
-    res.json({
-      success: true,
-      message: 'API is running',
-      projectId,
-      timestamp: new Date().toISOString()
-    });
+  // Middleware to inject projectId into all requests
+  router.use((req, res, next) => {
+    req.projectId = config.projectId;
+    next();
   });
 
-  // Project info endpoint
-  app.get(`${baseUrl}/info`, (req, res) => {
-    res.json({
-      success: true,
-      projectId,
-      version: '2.0.1',
-      features: ['forms', 'waitlists', 'slides', 'invoices', 'notifications']
-    });
-  });
-  logger.info('All routes initialized for project:', projectId);
-  return app;
-};
-
-// Utility function to get available routes
-const getAvailableRoutes = () => {
-  return {
-    admin: {
-      forms: ['GET', 'POST', 'PUT', 'DELETE'],
-      waitlists: ['GET', 'POST'],
-      slides: ['GET', 'POST', 'PUT', 'DELETE'],
-      invoices: ['GET', 'POST', 'PUT'],
-      notifications: ['GET', 'POST', 'PUT']
-    },
-    utility: {
-      health: ['GET'],
-      info: ['GET']
-    }
-  };
+  // 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 = {
-  createRoutes,
-  createAdminRoutes,
-  getAvailableRoutes
+  createPowrRoutes
 };

package/dist/routes/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/routes/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;