powr-sdk-api 2.0.2 → 2.0.3

package/dist/admin/ratings.js

@@ -0,0 +1,185 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+const {
+  ObjectId
+} = require("mongodb");
+
+//add ratings
+router.post("/", async (req, res) => {
+  const {
+    projectId,
+    itemId,
+    rating,
+    review,
+    userId
+  } = req.body;
+  if (!rating || !review) {
+    return res.status(400).json({
+      success: false,
+      message: "All fields are required."
+    });
+  }
+  const ratingData = {
+    projectId,
+    itemId,
+    rating,
+    review,
+    userId,
+    createdAt: new Date()
+  };
+  try {
+    const result = await getDb().collection("ratings").insertOne(ratingData);
+    if (result && result.insertedId) {
+      console.log("ratings added with ID:", result.insertedId);
+      return res.status(200).json({
+        success: true,
+        message: "rating added successfully.",
+        ratingId: result.insertedId
+      });
+    } else {
+      console.error("Insert operation failed. Result:", result);
+      return res.status(500).json({
+        success: false,
+        message: "ratings/reviews could not be added."
+      });
+    }
+  } catch (error) {
+    console.error("Error adding ratings:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to add ratings/reviews due to a server error."
+    });
+  }
+});
+
+//get ratings
+router.get("/", async (req, res) => {
+  const {
+    projectId,
+    itemId,
+    userId
+  } = req.query;
+  if (!projectId) {
+    return res.status(400).json({
+      success: false,
+      message: "projectId is required in query params."
+    });
+  }
+  try {
+    const query = {
+      projectId
+    };
+    if (itemId) query.itemId = itemId;
+    if (userId) query.userId = userId;
+    console.log("Filter....:", query);
+    const ratingData = await getDb().collection("ratings").find(query).toArray();
+    if (!ratingData || ratingData.length === 0) {
+      console.log("Data not found.");
+      return res.status(200).json({
+        success: true,
+        ratings: []
+      });
+    }
+    return res.status(200).json({
+      success: true,
+      ratings: ratingData
+    });
+  } catch (error) {
+    console.error("Error retrieving ratings:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve ratings."
+    });
+  }
+});
+
+// delete ratings
+router.delete("/", async (req, res) => {
+  const {
+    ratingId,
+    projectId
+  } = req.query;
+  if (!ratingId || !projectId) {
+    return res.status(400).json({
+      success: false,
+      message: "Both ratingId and projectId are required to delete a rating."
+    });
+  }
+  try {
+    const result = await getDb().collection("ratings").deleteOne({
+      _id: new ObjectId(ratingId),
+      projectId: projectId
+    });
+    if (result.deletedCount === 0) {
+      return res.status(404).json({
+        success: false,
+        message: "Rating not found for the given ratingId and projectId."
+      });
+    }
+    return res.status(200).json({
+      success: true,
+      message: "Rating deleted successfully."
+    });
+  } catch (error) {
+    console.error("Error deleting rating:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to delete rating due to a server error."
+    });
+  }
+});
+
+// Calculate average rating
+router.get("/average", async (req, res) => {
+  const {
+    projectId,
+    itemId
+  } = req.query;
+  if (!projectId || !itemId) {
+    return res.status(400).json({
+      success: false,
+      message: "Both projectId and itemId are required."
+    });
+  }
+  try {
+    const result = await getDb().collection("ratings").aggregate([{
+      $match: {
+        projectId,
+        itemId
+      }
+    }, {
+      $group: {
+        _id: null,
+        averageRating: {
+          $avg: "$rating"
+        },
+        totalRatings: {
+          $sum: 1
+        }
+      }
+    }]).toArray();
+    if (result.length === 0) {
+      return res.status(404).json({
+        success: false,
+        message: "No ratings found for the given projectId and itemId."
+      });
+    }
+    return res.status(200).json({
+      success: true,
+      averageRating: result[0].averageRating.toFixed(2),
+      totalRatings: result[0].totalRatings
+    });
+  } catch (error) {
+    console.error("Error calculating average rating:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to calculate average rating."
+    });
+  }
+});
+module.exports = router;

package/dist/admin/routes.js

@@ -0,0 +1,132 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/dbService");
+
+// Get all routes entries
+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 routesData = await getDb().collection("routes").find(query).toArray();
+    return res.status(200).json({
+      success: true,
+      allroutes: routesData
+    });
+  } catch (error) {
+    console.error("Error retrieving routes entries:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve routes entries."
+    });
+  }
+});
+
+// Create a new route 
+router.post('/', async (req, res) => {
+  try {
+    const {
+      projectId
+    } = req.query;
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required.'
+      });
+    }
+    const newRoute = req.body;
+    newRoute.projectId = projectId;
+    if (!newRoute || Object.keys(newRoute).length === 0) {
+      return res.status(400).json({
+        success: false,
+        message: 'Request body is empty or invalid.'
+      });
+    }
+    const result = await getDb().collection('routes').insertOne(newRoute);
+    return res.status(201).json({
+      success: true,
+      entry: result.ops ? result.ops[0] : newRoute
+    });
+  } catch (error) {
+    console.error('Error inserting route entry:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to insert route entry.'
+    });
+  }
+});
+
+// Update route code
+router.put('/:route', async (req, res) => {
+  try {
+    const {
+      route
+    } = req.params;
+    const {
+      code
+    } = req.body;
+    const {
+      projectId
+    } = req.query;
+    if (!projectId) {
+      return res.status(400).json({
+        success: false,
+        message: 'projectId is required.'
+      });
+    }
+    if (!code) {
+      return res.status(400).json({
+        success: false,
+        message: 'Code field is required.'
+      });
+    }
+    const query = {
+      route,
+      projectId
+    };
+    const existingRoute = await getDb().collection('routes').findOne(query);
+    if (!existingRoute) {
+      return res.status(404).json({
+        success: false,
+        message: 'Route not found.'
+      });
+    }
+    const result = await getDb().collection('routes').updateOne(query, {
+      $set: {
+        code
+      }
+    });
+    if (result.matchedCount === 0) {
+      return res.status(404).json({
+        success: false,
+        message: 'Route not found.'
+      });
+    }
+    const updatedRoute = await getDb().collection('routes').findOne(query);
+    return res.status(200).json({
+      success: true,
+      entry: updatedRoute
+    });
+  } catch (error) {
+    console.error('Error updating route code:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to update route code.',
+      error: error.message
+    });
+  }
+});
+module.exports = router;

package/dist/admin/slides.js

@@ -0,0 +1,101 @@
+"use strict";
+
+const express = require('express');
+const router = express.Router();
+const {
+  getDb
+} = require('../services/mongo');
+
+// Get slides
+router.get('/', async (req, res) => {
+  const {
+    projectId,
+    tag
+  } = req.query;
+  try {
+    const query = {
+      projectId
+    };
+    if (tag) {
+      query.tag = tag;
+    }
+    console.log("Filter.....:", query);
+    const slidesData = await getDb().collection('slides').find(query).toArray();
+    if (!slidesData || slidesData.length === 0) {
+      console.log("Data not found.");
+      return res.status(200).json({
+        success: true,
+        slides: []
+      });
+    }
+    const sortedData = slidesData.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("Slides retrieved and sorted:", sortedData);
+    return res.status(200).json({
+      success: true,
+      slides: sortedData
+    });
+  } catch (error) {
+    console.error("Error retrieving slides:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve slides."
+    });
+  }
+});
+
+// Add slide
+router.post('/', async (req, res) => {
+  const {
+    projectId,
+    tag,
+    city,
+    url,
+    title,
+    description,
+    expiry
+  } = req.body;
+  if (!url || !title || !description || !expiry) {
+    return res.status(400).json({
+      success: false,
+      message: "All fields are required."
+    });
+  }
+  const slideData = {
+    projectId,
+    url,
+    title,
+    description,
+    expiry,
+    createdAt: new Date()
+  };
+  if (city) {
+    slideData.city = city;
+  }
+  if (tag) {
+    slideData.tag = tag;
+  }
+  try {
+    const result = await getDb().collection('slides').insertOne(slideData);
+    if (result && result.insertedId) {
+      console.log("Slide added with ID:", result.insertedId);
+      return res.status(200).json({
+        success: true,
+        message: "Slide added successfully.",
+        slideId: result.insertedId
+      });
+    } else {
+      console.error("Insert operation failed. Result:", result);
+      return res.status(500).json({
+        success: false,
+        message: "Slide could not be added."
+      });
+    }
+  } catch (error) {
+    console.error("Error adding slide:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to add slide due to a server error."
+    });
+  }
+});
+module.exports = router;

package/dist/admin/users.js

@@ -0,0 +1,175 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+const {
+  ObjectId
+} = require("mongodb");
+router.post("/", async (req, res) => {
+  const {
+    projectId,
+    phoneNumber,
+    email,
+    ...userData
+  } = req.body;
+  if (!phoneNumber && !email) {
+    return res.status(400).json({
+      success: false,
+      message: "phoneNumber or email is required."
+    });
+  }
+  const user = {
+    projectId,
+    phoneNumber,
+    email,
+    ...userData,
+    createdAt: new Date()
+  };
+  try {
+    const usersCollection = getDb().collection("users");
+    if (phoneNumber) {
+      const existingByPhone = await usersCollection.findOne({
+        projectId,
+        phoneNumber
+      });
+      if (existingByPhone) {
+        return res.status(409).json({
+          success: false,
+          message: "Phone number already exists."
+        });
+      }
+    }
+    if (email) {
+      const existingByEmail = await usersCollection.findOne({
+        projectId,
+        email
+      });
+      if (existingByEmail) {
+        return res.status(409).json({
+          success: false,
+          message: "Email already exists."
+        });
+      }
+    }
+    const result = await getDb().collection("users").insertOne(user);
+    return res.status(200).json({
+      success: true,
+      message: "User created successfully.",
+      userId: result.insertedId
+    });
+  } catch (error) {
+    console.error("Error creating user:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Internal server error."
+    });
+  }
+});
+router.get("/", async (req, res) => {
+  const {
+    projectId,
+    _id,
+    phoneNumber,
+    email
+  } = req.query;
+  if (!_id && !phoneNumber && !email) {
+    return res.status(400).json({
+      success: false,
+      message: "no filters provided.",
+      users: []
+    });
+  }
+  const filter = {
+    projectId
+  };
+  if (_id) {
+    try {
+      filter._id = new ObjectId(_id);
+    } catch (e) {
+      return res.status(400).json({
+        success: false,
+        message: "Invalid _id format."
+      });
+    }
+  }
+  if (phoneNumber) {
+    filter.phoneNumber = phoneNumber;
+  }
+  if (email) {
+    filter.email = email;
+  }
+  try {
+    const users = await getDb().collection("users").find(filter).toArray();
+    return res.status(200).json({
+      success: true,
+      message: "Users fetched successfully.",
+      users
+    });
+  } catch (error) {
+    console.error("Error fetching users:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Internal server error."
+    });
+  }
+});
+router.post("/getOrCreate", async (req, res) => {
+  const {
+    projectId,
+    phoneNumber,
+    email,
+    ...userData
+  } = req.body;
+  if (!phoneNumber && !email) {
+    return res.status(400).json({
+      success: false,
+      message: "phoneNumber or email is required."
+    });
+  }
+  const user = {
+    projectId,
+    phoneNumber,
+    email,
+    ...userData,
+    createdAt: new Date()
+  };
+  try {
+    const usersCollection = getDb().collection("users");
+    let existingUser = null;
+    if (phoneNumber) {
+      existingUser = await usersCollection.findOne({
+        projectId,
+        phoneNumber
+      });
+    }
+    if (!existingUser && email) {
+      existingUser = await usersCollection.findOne({
+        projectId,
+        email
+      });
+    }
+    if (existingUser) {
+      return res.status(200).json({
+        success: true,
+        message: "User already exists.",
+        userId: existingUser._id
+      });
+    }
+    const result = await usersCollection.insertOne(user);
+    return res.status(200).json({
+      success: true,
+      message: "User created successfully.",
+      userId: result.insertedId
+    });
+  } catch (error) {
+    console.error("Error creating or fetching user:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Internal server error."
+    });
+  }
+});
+module.exports = router;

package/dist/admin/waitlists.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+
+// Get waitlist entries
+router.get('/', async (req, res) => {
+  const {
+    projectId
+  } = req.query;
+  try {
+    const query = {
+      projectId
+    };
+    console.log("Filter.....:", query);
+    const waitlistData = await getDb().collection("waitlists").find(query).toArray();
+    if (!waitlistData || waitlistData.length === 0) {
+      console.log("Data not found.");
+      return res.status(200).json({
+        success: true,
+        entries: []
+      });
+    }
+    const sortedData = waitlistData.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("Waitlist entries retrieved and sorted:", sortedData);
+    return res.status(200).json({
+      success: true,
+      entries: sortedData
+    });
+  } catch (error) {
+    console.error("Error retrieving waitlist entries:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve waitlist entries."
+    });
+  }
+});
+
+// Original POST endpoint for adding to waitlist
+router.post("/", async (req, res) => {
+  const {
+    projectId,
+    email
+  } = req.body;
+  try {
+    const existingEntry = await getDb().collection("waitlists").findOne({
+      projectId,
+      email
+    });
+    if (existingEntry) {
+      return res.status(400).json({
+        success: false,
+        message: "You are already in the waitlist "
+      });
+    }
+  } catch (error) {
+    console.error("Error checking waitlist:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to check waitlist due to a server error."
+    });
+  }
+  const waitListData = {
+    projectId,
+    email,
+    createdAt: new Date()
+  };
+  try {
+    const result = await getDb().collection("waitlists").insertOne(waitListData);
+    if (result && result.insertedId) {
+      return res.status(200).json({
+        success: true,
+        message: "you are added in the waitist",
+        userId: result.insertedId
+      });
+    } else {
+      console.error("Insert operation failed. Result:", result);
+      return res.status(500).json({
+        success: false,
+        message: "user could not be added."
+      });
+    }
+  } catch (error) {
+    console.error("Error adding user:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to add user due to a server error."
+    });
+  }
+});
+module.exports = router;

package/dist/config.js

@@ -0,0 +1,23 @@
+"use strict";
+
+// Config for powr-sdk-api
+// Uses environment variables from host project
+
+const getConfig = () => {
+  const config = {
+    mongoUri: process.env.MONGODB_URI,
+    jwtToken: process.env.JWT_TOKEN
+  };
+
+  // Validate required configs
+  if (!config.mongoUri) {
+    throw new Error('MONGODB_URI environment variable is required');
+  }
+  if (!config.jwtToken) {
+    throw new Error('JWT_TOKEN environment variable is required');
+  }
+  return config;
+};
+module.exports = {
+  getConfig
+};