powr-sdk-api 4.3.12 → 4.3.13

package/dist/admin/activities.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+
+// Get activities
+router.get("/", async (req, res) => {
+  const {
+    projectId,
+    contentId
+  } = req.query;
+  try {
+    const query = {
+      projectId
+    };
+    if (contentId) {
+      query.contentId = contentId;
+    }
+    console.log("Filter.....:", query);
+    const activities = await getDb().collection("activities").find(query).toArray();
+    if (!activities || activities.length === 0) {
+      console.log("Data not found.");
+      return res.status(200).json({
+        success: true,
+        activities: []
+      });
+    }
+    return res.status(200).json({
+      success: true,
+      activities: activities
+    });
+  } catch (error) {
+    console.error("Error retrieving activities:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve activities."
+    });
+  }
+});
+
+// Add activity
+router.post("/", async (req, res) => {
+  const {
+    projectId,
+    contentId,
+    activity
+  } = req.body;
+  const activityData = {
+    projectId,
+    contentId,
+    activity,
+    createdAt: new Date()
+  };
+  try {
+    const result = await getDb().collection("activities").insertOne(activityData);
+    if (result && result.insertedId) {
+      console.log("Activity added with ID:", result.insertedId);
+      return res.status(200).json({
+        success: true,
+        message: "Activity added successfully.",
+        activityId: result.insertedId
+      });
+    } else {
+      console.error("Insert operation failed. Result:", result);
+      return res.status(500).json({
+        success: false,
+        message: "Activity could not be added."
+      });
+    }
+  } catch (error) {
+    console.error("Error adding activity:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to add activity due to a server error."
+    });
+  }
+});
+module.exports = router;

package/dist/admin/auth.js

@@ -0,0 +1,234 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+const {
+  ObjectId
+} = require("mongodb");
+const bcrypt = require("bcrypt");
+const {
+  generateJWTToken
+} = require("../middleware/jwtToken");
+const {
+  config
+} = require("../config");
+
+// Register User
+router.post("/register", async (req, res) => {
+  const {
+    fullName,
+    username,
+    password
+  } = req.body;
+  try {
+    if (!fullName || !username || !password) {
+      return res.status(400).json({
+        success: false,
+        message: "Full name, username and password are required"
+      });
+    }
+    const existingUser = await getDb().collection("users").findOne({
+      username: username
+    });
+    if (existingUser) {
+      return res.status(400).json({
+        success: false,
+        message: "The username is already taken"
+      });
+    }
+    const saltRounds = 10;
+    const hashedPassword = await bcrypt.hash(password, saltRounds);
+    const newUser = {
+      fullName,
+      username,
+      password: hashedPassword,
+      createdAt: new Date()
+    };
+    const result = await getDb().collection("users").insertOne(newUser);
+    return res.status(201).json({
+      success: true,
+      message: "User registered successfully",
+      userId: result.insertedId
+    });
+  } catch (error) {
+    console.error("Error creating user:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to create user."
+    });
+  }
+});
+
+// Login User
+router.post("/login", async (req, res) => {
+  const {
+    username,
+    password
+  } = req.body;
+  try {
+    if (!username || !password) {
+      return res.status(400).json({
+        success: false,
+        message: "Username and password are required"
+      });
+    }
+    const user = await getDb().collection("users").findOne({
+      username: username
+    });
+    if (!user) {
+      return res.status(401).json({
+        success: false,
+        message: "Invalid username or password."
+      });
+    }
+    const isPasswordValid = await bcrypt.compare(password, user.password);
+    if (!isPasswordValid) {
+      return res.status(401).json({
+        success: false,
+        message: "Invalid username or password."
+      });
+    }
+    const token = generateJWTToken(user);
+    const {
+      password: _,
+      ...userWithoutPassword
+    } = user;
+    return res.status(200).json({
+      success: true,
+      message: "Login successful",
+      user: userWithoutPassword,
+      token: token
+    });
+  } catch (error) {
+    console.error("Error logging in:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to login."
+    });
+  }
+});
+
+// Forgot Password
+router.post("/forgot-password", async (req, res) => {
+  const {
+    username
+  } = req.body;
+  try {
+    if (!username) {
+      return res.status(400).json({
+        success: false,
+        message: "Username is required"
+      });
+    }
+    const user = await getDb().collection("users").findOne({
+      username: username
+    });
+    if (!user) {
+      return res.status(404).json({
+        success: false,
+        message: "User not found."
+      });
+    }
+    const jwt = require('jsonwebtoken');
+    const resetPayload = {
+      userId: user._id.toString(),
+      type: 'reset',
+      iat: Math.floor(Date.now() / 1000),
+      exp: Math.floor(Date.now() / 1000) + 60 * 60
+    };
+    const resetToken = jwt.sign(resetPayload, config.jwtToken);
+    await getDb().collection("users").updateOne({
+      _id: user._id
+    }, {
+      $set: {
+        resetToken: resetToken,
+        resetTokenExpiry: new Date(Date.now() + 3600000)
+      }
+    });
+    return res.status(200).json({
+      success: true,
+      message: "Password reset token generated successfully",
+      resetToken: resetToken
+    });
+  } catch (error) {
+    console.error("Error in forgot password:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to process forgot password request."
+    });
+  }
+});
+
+// Reset Password
+router.post("/reset-password", async (req, res) => {
+  const {
+    resetToken,
+    newPassword
+  } = req.body;
+  try {
+    if (!resetToken || !newPassword) {
+      return res.status(400).json({
+        success: false,
+        message: "Reset token and new password are required"
+      });
+    }
+    const jwt = require('jsonwebtoken');
+    let decoded;
+    try {
+      decoded = jwt.verify(resetToken, config.jwtToken);
+    } catch (jwtError) {
+      return res.status(401).json({
+        success: false,
+        message: "Invalid or expired reset token"
+      });
+    }
+    if (!decoded || decoded.type !== 'reset' || !decoded.userId) {
+      return res.status(401).json({
+        success: false,
+        message: "Invalid reset token type or missing user ID"
+      });
+    }
+    const user = await getDb().collection("users").findOne({
+      _id: new ObjectId(decoded.userId),
+      resetToken: resetToken,
+      resetTokenExpiry: {
+        $gt: new Date()
+      }
+    });
+    if (!user) {
+      return res.status(401).json({
+        success: false,
+        message: "Invalid or expired reset token."
+      });
+    }
+
+    // Hash the new password
+    const saltRounds = 10;
+    const hashedPassword = await bcrypt.hash(newPassword, saltRounds);
+    await getDb().collection("users").updateOne({
+      _id: user._id
+    }, {
+      $set: {
+        password: hashedPassword
+      },
+      $unset: {
+        resetToken: "",
+        resetTokenExpiry: ""
+      }
+    });
+    return res.status(200).json({
+      success: true,
+      message: "Password reset successfully"
+    });
+  } catch (error) {
+    console.error("Error resetting password:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to reset password."
+    });
+  }
+});
+module.exports = router;

package/dist/admin/blogs.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const express = require('express');
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+router.post('/', async (req, res) => {
+  const {
+    projectId
+  } = req.query;
+  const {
+    title,
+    author,
+    date,
+    description,
+    tags,
+    imageUrl
+  } = req.body;
+  if (!projectId || !title || !author || !date || !description) {
+    return res.status(400).json({
+      success: false,
+      message: 'projectId,  title, author, date,and description are required.'
+    });
+  }
+  const blog = {
+    title,
+    author,
+    date,
+    description,
+    tags: tags || '',
+    imageUrl,
+    projectId,
+    createdAt: new Date()
+  };
+  try {
+    const result = await getDb().collection('blogs').insertOne(blog);
+    if (result && result.insertedId) {
+      return res.status(201).json({
+        success: true,
+        message: 'Blog created successfully.',
+        blogId: result.insertedId,
+        blog
+      });
+    } else {
+      return res.status(500).json({
+        success: false,
+        message: 'Blog could not be created.'
+      });
+    }
+  } catch (error) {
+    console.error('Error while creating blog:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to create blog due to a server error.'
+    });
+  }
+});
+router.get('/', async (req, res) => {
+  const {
+    projectId,
+    contentId,
+    userId
+  } = 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;
+    }
+    if (userId) {
+      query.author = userId;
+    }
+    const blogs = await getDb().collection('blogs').find(query).toArray();
+    return res.status(200).json({
+      success: true,
+      blogs: blogs
+    });
+  } catch (error) {
+    console.error('Error fetching blogs:', error);
+    return res.status(500).json({
+      success: false,
+      message: 'Failed to fetch blogs.'
+    });
+  }
+});
+module.exports = router;

package/dist/admin/comments.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const {
+  getDb
+} = require("../services/mongo");
+
+// Get comments
+router.get("/", async (req, res) => {
+  const {
+    projectId,
+    contentId
+  } = req.query;
+  try {
+    const query = {
+      projectId
+    };
+    if (contentId) {
+      query.contentId = contentId;
+    }
+    console.log("Filter.....:", query);
+    const commentData = await getDb().collection("comments").find(query).toArray();
+    if (!commentData || commentData.length === 0) {
+      console.log("Data not found.");
+      return res.status(200).json({
+        success: true,
+        comments: []
+      });
+    }
+    return res.status(200).json({
+      success: true,
+      comments: commentData
+    });
+  } catch (error) {
+    console.error("Error retrieving comments:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve comments."
+    });
+  }
+});
+
+// Add comment
+router.post("/", async (req, res) => {
+  const {
+    projectId,
+    contentId,
+    comment,
+    ...customFields
+  } = req.body;
+  const commentData = {
+    projectId,
+    contentId,
+    comment,
+    ...customFields,
+    createdAt: new Date()
+  };
+  try {
+    const result = await getDb().collection("comments").insertOne(commentData);
+    if (result && result.insertedId) {
+      console.log("Comment added with ID:", result.insertedId);
+      return res.status(200).json({
+        success: true,
+        message: "Comment added successfully.",
+        commentId: result.insertedId
+      });
+    } else {
+      console.error("Insert operation failed. Result:", result);
+      return res.status(500).json({
+        success: false,
+        message: "Comment could not be added."
+      });
+    }
+  } catch (error) {
+    console.error("Error adding comment:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to add comment due to a server error."
+    });
+  }
+});
+module.exports = router;

package/dist/admin/files.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const express = require('express');
+const multer = require('multer');
+// const { uploadToGCS, bucket } = require('../uploadToGCS')
+const {
+  bucket,
+  uploadToGCS,
+  bucketName
+} = require('../uploadToGCS.js');
+// const uploadToGCS = require('../uploadToGCS.js')
+
+const router = express.Router();
+const upload = multer();
+router.post('/', upload.single('file'), async (req, res) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({
+        status: 'error',
+        message: 'No file uploaded'
+      });
+    }
+    const url = await uploadToGCS(req.file);
+    return res.status(200).json({
+      status: 'success',
+      message: 'File uploaded successfully',
+      url
+    });
+  } catch (err) {
+    console.error('Error uploading file:', err);
+    return res.status(500).json({
+      status: 'error',
+      message: 'File upload failed',
+      error: err.message || 'Unknown error occurred'
+    });
+  }
+});
+router.get('/', async (req, res) => {
+  try {
+    const [files] = await bucket.getFiles();
+    const bucketName = bucket.name;
+    const imageUrls = files.map(file => `https://storage.googleapis.com/${bucketName}/${file.name}`);
+    return res.status(200).json({
+      message: 'Images fetched successfully',
+      images: imageUrls
+    });
+  } catch (err) {
+    console.error('Error listing files from GCS:', err);
+    return res.status(500).json({
+      status: 'error',
+      message: 'Failed to fetch images',
+      error: err.message || 'Unknown error occurred'
+    });
+  }
+});
+module.exports = router;