Merge branch 'main' of https://github.com/codinghack0810/scope-backend

Author: codinghack30

README.md

@@ -1 +1,20 @@
-# Express + MySQL
+# The Backend Server
+
+This is stage in Developement.
+
+Run Command Prompt or Terminal in director of project.
+
+1. `npm install` or `yarn install`
+
+2. Install XAMPP and Start Apache and MySQL for database in XAMPP Control Panel.
+
+3. Create the database(`db_scope`) for server in XAMPP Apache server[http://localhost/phpmyadmin/].
+
+4. `npm start` or `yarn start`
+
+5. The server is running on http://localhost:5000
+
+6. We get the url(https) for server from ngrok[https://dashboard.ngrok.com].
+
+7. Final, we use this url for server.
+    ex: `https://singularly-hot-cod.ngrok-free.app` 

src/config/db.config.js

@@ -1,24 +1,29 @@
 const dotenv = require("dotenv");
 
+// Load environment variables from .env file
 dotenv.config();
 
+// Parse integer values for database pool configuration from environment variables
 const max = parseInt(process.env.DB_POOL_MAX);
 const min = parseInt(process.env.DB_POOL_MIN);
 const acquire = parseInt(process.env.DB_POOL_ACQUIRE);
 const idle = parseInt(process.env.DB_POOL_IDLE);
 
+// Database connection configuration object
 const config = {
-    HOST: process.env.DB_HOST,
-    USER: process.env.DB_USER,
-    PASSWORD: process.env.DB_PASSWORD,
-    DB: process.env.DB_DATABASE,
-    dialect: process.env.DB_DIALECT,
+    HOST: process.env.DB_HOST, // Database host address
+    USER: process.env.DB_USER, // Database user
+    PASSWORD: process.env.DB_PASSWORD, // Database user's password
+    DB: process.env.DB_DATABASE, // Name of the database
+    dialect: process.env.DB_DIALECT, // SQL dialect (e.g., 'mysql', 'postgres')
     pool: {
-        max: max,
-        min: min,
-        acquire: acquire,
-        idle: idle,
+        // Pool configuration for managing database connections
+        max: max, // Maximum number of connections in pool
+        min: min, // Minimum number of connections in pool
+        acquire: acquire, // Maximum time (ms) that pool will try to get connection before throwing error
+        idle: idle, // Maximum time (ms) that a connection can be idle before being released
     },
 };
 
+// Export the configuration object for use in other parts of the application
 module.exports = config;

src/controllers/service.controller.js

@@ -63,6 +63,7 @@ const update = async (req, res) => {
         const userId = req.user.id;
         const { content, amount, service } = req.body;
 
+        // Check if ServiceProvider exists
         const serviceProvider = await ServiceProvider.findOne({
             where: { name: service },
         });
@@ -86,6 +87,7 @@ const update = async (req, res) => {
         // Update transaction
         transaction.amount = amount;
         await transaction.save();
+
         res.status(200).json({
             msg: "Transaction updated successfully.",
             transaction,
@@ -101,12 +103,14 @@ const deleteTrans = async (req, res) => {
         const userId = req.user.id;
         const { service } = req.body;
 
+        // Check if ServiceProvider exists
         const serviceProvider = await ServiceProvider.findOne({
             where: { name: service },
         });
         if (!serviceProvider) {
             return res.status(404).json({ msg: "ServiceProvider not found." });
         }
+
         const serviceId = serviceProvider.id;
 
         // Check if transaction exists

src/controllers/transaction.controller.js

@@ -227,6 +227,7 @@ const search = async (req, res) => {
     try {
         const { key } = req.query;
 
+        // Check if the service exists
         const searchedService = await ServiceProvider.findAll({
             where: {
                 servicesProvided: {

src/controllers/user.controller.js

@@ -10,9 +10,8 @@ const sendCode = async (req, res) => {
     try {
         const { email } = req.body;
 
-        const userAccount = await UserAccount.findOne({ where: { email } });
-
         // Check if the user exists
+        const userAccount = await UserAccount.findOne({ where: { email } });
         if (!userAccount) {
             return res.status(404).json({ msg: "User did not signup. Please signup." });
         }
@@ -37,6 +36,8 @@ const sendCode = async (req, res) => {
                 pass: process.env.SMTP_PASSWORD,
             },
         });
+
+        // Defined transport object
         const mailOptions = {
             from: `${process.env.APP_NAME} <${process.env.EMAIL_FROM}>`,
             to: email,
@@ -47,6 +48,8 @@ const sendCode = async (req, res) => {
             <h1 style="padding: 12px; border-left: 4px solid #d0d0d0; font-style: italic;">${code}</h1>
             <p>Best wishes,<br>Scope Inc.</p>`,
         };
+
+        // send mail with defined transport object
         transporter.sendMail(mailOptions, (error, info) => {
             if (error) {
                 res.status(500).json({ msg: error.message });

src/controllers/verify.controller.js

@@ -8,28 +8,34 @@ const secretOrKey = process.env.JWT_ACCESS_TOKEN_SECRET_PRIVATE;
 
 module.exports = async (req, res, next) => {
     try {
+        // Check if the user is authenticated
         if (!req.headers.authorization) {
             return res.status(401).json({ msg: "No authentication." });
         }
+
+        // Check if the token is existed.
         const token = req.headers.authorization;
         if (!token) {
             return res
                 .status(401)
                 .json({ msg: "No token, authentication denied." });
         }
+
+        // Verify token
         jwt.verify(token, secretOrKey, async (error, decoded) => {
             if (error) {
                 return res.status(401).json({ msg: "Token is not valid." });
             }
 
+            // Check if the user exists
             const userAccount = await UserAccount.findOne({
                 where: { email: decoded.email },
             });
-
             if (!userAccount) {
                 return res.status(404).json({ msg: "User does not exist." });
             }
 
+            // Add user to request
             req.user = userAccount;
             await next();
         });

src/middlewares/requiredAdmin.js

@@ -1,7 +1,8 @@
-const dbConfig = require("../config/db.config.js");
+const dbConfig = require("../config/db.config.js"); // Import database configuration
 
 const Sequelize = require("sequelize");
 
+// Initialize Sequelize instance with database credentials and pool settings
 const sequelize = new Sequelize(dbConfig.DB, dbConfig.USER, dbConfig.PASSWORD, {
     host: dbConfig.HOST,
     dialect: dbConfig.dialect,
@@ -20,6 +21,7 @@ const db = {};
 db.Sequelize = Sequelize;
 db.sequelize = sequelize;
 
+// Import and initialize all models
 db.useraccount = require("./useraccount.model.js")(sequelize, Sequelize);
 db.user = require("./user.model.js")(sequelize, Sequelize);
 db.serviceprovider = require("./serviceprovider.model.js")(
@@ -30,40 +32,49 @@ db.profile = require("./profile.model.js")(sequelize, Sequelize);
 db.review = require("./review.model.js")(sequelize, Sequelize);
 db.transaction = require("./transaction.model.js")(sequelize, Sequelize);
 
+// Define associations between models
+
+// One-to-One relationship: UserAccount -> User
 db.useraccount.hasOne(db.user, { foreignKey: "userAccountId" });
 db.user.belongsTo(db.useraccount, {
     foreignKey: "userAccountId",
     onDelete: "CASCADE",
 });
 
-db.user.hasMany(db.profile, { foreginKey: "userId" });
-db.profile.belongsTo(db.user, { foreginKey: "userId", onDelete: "CASCADE" });
+// One-to-Many relationship: User -> Profile
+db.user.hasMany(db.profile, { foreignKey: "userId" });
+db.profile.belongsTo(db.user, { foreignKey: "userId", onDelete: "CASCADE" });
 
-db.user.hasMany(db.review, { foreginKey: "userId" });
-db.review.belongsTo(db.user, { foreginKey: "userId", onDelete: "CASCADE" });
+// One-to-Many relationship: User -> Review
+db.user.hasMany(db.review, { foreignKey: "userId" });
+db.review.belongsTo(db.user, { foreignKey: "userId", onDelete: "CASCADE" });
 
-db.user.hasMany(db.transaction, { foreginKey: "userId" });
+// One-to-Many relationship: User -> Transaction
+db.user.hasMany(db.transaction, { foreignKey: "userId" });
 db.transaction.belongsTo(db.user, {
-    foreginKey: "userId",
+    foreignKey: "userId",
     onDelete: "CASCADE",
 });
 
-db.serviceprovider.hasMany(db.profile, { foreginKey: "serviceProviderId" });
+// One-to-Many relationship: ServiceProvider -> Profile
+db.serviceprovider.hasMany(db.profile, { foreignKey: "serviceProviderId" });
 db.profile.belongsTo(db.serviceprovider, {
     foreignKey: "serviceProviderId",
     onDelete: "CASCADE",
 });
 
-db.serviceprovider.hasMany(db.review, { foreginKey: "serviceProviderId" });
+// One-to-Many relationship: ServiceProvider -> Review
+db.serviceprovider.hasMany(db.review, { foreignKey: "serviceProviderId" });
 db.review.belongsTo(db.serviceprovider, {
     foreignKey: "serviceProviderId",
     onDelete: "CASCADE",
 });
 
-db.serviceprovider.hasMany(db.transaction, { foreginKey: "serviceProviderId" });
+// One-to-Many relationship: ServiceProvider -> Transaction
+db.serviceprovider.hasMany(db.transaction, { foreignKey: "serviceProviderId" });
 db.transaction.belongsTo(db.serviceprovider, {
     foreignKey: "serviceProviderId",
     onDelete: "CASCADE",
 });
 
-module.exports = db;
+module.exports = db; // Export the configured `db` object for use in other parts of the application

src/middlewares/requiredAuth.js

@@ -41,21 +41,24 @@ module.exports = (sequelize, Sequelize) => {
         },
     });
 
+    // Define a beforeCreate hook on the UserAccount model
     UserAccount.beforeCreate(async (userAccount, options) => {
+        // Check if password is provided and hash it using bcrypt
         if (userAccount.password) {
-            const salt = await bcrypt.genSalt(10);
+            const salt = await bcrypt.genSalt(10); // Generate salt with 10 rounds
             userAccount.password = await bcrypt.hash(
                 userAccount.password,
                 salt
-            );
+            ); // Hash the password with the generated salt
         }
 
+        // Check if securityAnswer is provided and hash it using bcrypt
         if (userAccount.securityAnswer) {
-            const salt = await bcrypt.genSalt(10);
+            const salt = await bcrypt.genSalt(10); // Generate salt with 10 rounds
             userAccount.securityAnswer = await bcrypt.hash(
                 userAccount.securityAnswer,
                 salt
-            );
+            ); // Hash the security answer with the generated salt
         }
     });