full server

Author: LokeshKumar-Dev

coinstrikeServer/.gitignore

@@ -0,0 +1,25 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+*.env

coinstrikeServer/Middleware/AuthMiddleware.js

@@ -0,0 +1,49 @@
+const jwt = require("jsonwebtoken");
+const asyncHandler = require("express-async-handler");
+const User = require("../Models/userModel.js");
+
+const protect = asyncHandler(async (req, res, next) => {
+  let token;
+
+  if (
+    req.headers.authorization &&
+    req.headers.authorization.startsWith("Bearer")
+  ) {
+    try {
+      token = req.headers.authorization.split(" ")[1];
+
+      const decoded = jwt.verify(token, process.env.JWT_SECRET);
+
+      req.user = await User.findById(decoded.id).select("-password");
+      next();
+    } catch (error) {
+      console.error(error);
+      res.status(401);
+      throw new Error("Not authorized, token failed");
+    }
+  }
+  if (!token) {
+    res.status(401);
+    throw new Error("Not authorized, no token");
+  }
+});
+
+const admin = (req, res, next) => {
+  if (req.user && req.user.isAdmin) {
+    next();
+  } else {
+    res.status(401);
+    throw new Error("Not authorized as an Admin");
+  }
+};
+
+const vendor = (req, res, next) => {
+  if (req.user && req.user.isVendor) {
+    next();
+  } else {
+    res.status(401);
+    throw new Error("Not authorized as an Vendor");
+  }
+};
+
+module.exports = { protect, admin, vendor };

coinstrikeServer/Middleware/Errors.js

@@ -0,0 +1,16 @@
+const notFound = (req, res, next) => {
+  const error = new Error(`Not found - ${req.originalUrl}`);
+  res.status(404);
+  next(error);
+};
+
+const errorHandler = (err, req, res, next) => {
+  const statusCode = res.statusCode === 200 ? 500 : res.statusCode;
+  res.status(statusCode);
+  res.json({
+    message: err.message,
+    stack: process.env.NODE_ENV === "production" ? null : err.stack,
+  });
+};
+
+module.exports = { notFound, errorHandler };

coinstrikeServer/Models/transactionModel.js

@@ -0,0 +1,59 @@
+const mongoose = require("mongoose");
+
+// Creating the schema for the transaction model fields of user id, name, description, amount, category, type, cycle, status, auto, and date
+const transactionSchema = mongoose.Schema(
+  {
+    user: {
+      type: mongoose.Schema.ObjectId,
+      required: true,
+      ref: "User",
+    },
+    name: {
+      type: String,
+      required: true,
+    },
+    description: {
+      type: String,
+    },
+    amount: {
+      type: Number,
+      required: true,
+    },
+    category: {
+      type: String,
+    },
+    type: {
+      type: String,
+      required: true,
+      enum: ["income", "expense", "subscription"],
+    },
+    cycle: {
+      type: String,
+      enum: ["monthly", "quarterly", "annual"],
+    },
+    status: {
+      type: Boolean,
+    },
+    auto: {
+      type: Boolean,
+    },
+    date: {
+      type: Date,
+      required: true,
+      set: function (value) {
+        // Extracting the date portion
+        const [year, month, day, hour, minute, second] = value.split(":");
+        const newDate = new Date(year, month, day, hour, minute, second);
+
+        return newDate;
+      },
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Transaction = mongoose.model("Entry", transactionSchema);
+
+module.exports = Transaction;

coinstrikeServer/Models/userModel.js

@@ -0,0 +1,85 @@
+const mongoose = require("mongoose");
+const bcrypt = require("bcryptjs");
+
+const userSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+    },
+    lastname: {
+      type: String,
+    },
+    date: {
+      type: Date,
+    },
+    salary: {
+      type: Number,
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    image: {
+      type: String,
+    },
+    password: {
+      type: String,
+      required: true,
+    },
+    currency: {
+      type: String,
+      default: "INR",
+    },
+    expense: {
+      type: Number,
+      default: 0,
+    },
+    expenseList: {
+      type: Array,
+      default: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    },
+    income: {
+      type: Number,
+      default: 0,
+    },
+    incomeList: {
+      type: Array,
+      default: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    },
+    otp: {
+      type: String,
+      default: "",
+    },
+    isVerified: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Login
+userSchema.methods.matchPassword = async function (enterPassword) {
+  return await bcrypt.compare(enterPassword, this.password);
+};
+
+// Login
+userSchema.methods.matchOtp = async function (otpEnter) {
+  return await bcrypt.compare(otpEnter, this.otp);
+};
+
+// Register
+userSchema.pre("save", async function (next) {
+  if (!this.isModified("password")) {
+    next();
+  }
+  const salt = await bcrypt.genSalt(10);
+  this.password = await bcrypt.hash(this.password, salt);
+});
+
+const User = mongoose.model("User", userSchema);
+
+module.exports = User;

coinstrikeServer/dbConfig.js

@@ -0,0 +1,27 @@
+const mongoose = require("mongoose");
+
+const cluster = "clusterdb.ok95nts";
+const dbname = "coin";
+
+const url = `mongodb+srv://${process.env.db_USERNAME}:${process.env.db_PASSWORD}@${cluster}.mongodb.net/${dbname}?retryWrites=true&w=majority`;
+
+async function connectDB() {
+  try {
+    await mongoose.connect(url, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    console.log("Connected to MongoDB");
+
+    //verification
+    const db = mongoose.connection;
+    db.on("error", console.error.bind(console, "connection error: "));
+    db.once("open", function () {
+      console.log("Connected successfully");
+    });
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+module.exports = connectDB;

coinstrikeServer/lib/PaytmChecksum.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var crypto = require("crypto");
+
+class PaytmChecksum {
+  static encrypt(input, key) {
+    var cipher = crypto.createCipheriv("AES-128-CBC", key, PaytmChecksum.iv);
+    var encrypted = cipher.update(input, "binary", "base64");
+    encrypted += cipher.final("base64");
+    return encrypted;
+  }
+  static decrypt(encrypted, key) {
+    var decipher = crypto.createDecipheriv(
+      "AES-128-CBC",
+      key,
+      PaytmChecksum.iv
+    );
+    var decrypted = decipher.update(encrypted, "base64", "binary");
+    try {
+      decrypted += decipher.final("binary");
+    } catch (e) {
+      console.log(e);
+    }
+    return decrypted;
+  }
+  static generateSignature(params, key) {
+    if (typeof params !== "object" && typeof params !== "string") {
+      var error = "string or object expected, " + typeof params + " given.";
+      return Promise.reject(error);
+    }
+    if (typeof params !== "string") {
+      params = PaytmChecksum.getStringByParams(params);
+    }
+    return PaytmChecksum.generateSignatureByString(params, key);
+  }
+
+  static verifySignature(params, key, checksum) {
+    if (typeof params !== "object" && typeof params !== "string") {
+      var error = "string or object expected, " + typeof params + " given.";
+      return Promise.reject(error);
+    }
+    if (params.hasOwnProperty("CHECKSUMHASH")) {
+      delete params.CHECKSUMHASH;
+    }
+    if (typeof params !== "string") {
+      params = PaytmChecksum.getStringByParams(params);
+    }
+    return PaytmChecksum.verifySignatureByString(params, key, checksum);
+  }
+
+  static async generateSignatureByString(params, key) {
+    var salt = await PaytmChecksum.generateRandomString(4);
+    return PaytmChecksum.calculateChecksum(params, key, salt);
+  }
+
+  static verifySignatureByString(params, key, checksum) {
+    var paytm_hash = PaytmChecksum.decrypt(checksum, key);
+    var salt = paytm_hash.substr(paytm_hash.length - 4);
+    return paytm_hash === PaytmChecksum.calculateHash(params, salt);
+  }
+
+  static generateRandomString(length) {
+    return new Promise(function (resolve, reject) {
+      crypto.randomBytes((length * 3.0) / 4.0, function (err, buf) {
+        if (!err) {
+          var salt = buf.toString("base64");
+          resolve(salt);
+        } else {
+          console.log("error occurred in generateRandomString: " + err);
+          reject(err);
+        }
+      });
+    });
+  }
+
+  static getStringByParams(params) {
+    var data = {};
+    Object.keys(params)
+      .sort()
+      .forEach(function (key, value) {
+        data[key] =
+          params[key] !== null && params[key].toLowerCase() !== "null"
+            ? params[key]
+            : "";
+      });
+    return Object.values(data).join("|");
+  }
+
+  static calculateHash(params, salt) {
+    var finalString = params + "|" + salt;
+    return crypto.createHash("sha256").update(finalString).digest("hex") + salt;
+  }
+  static calculateChecksum(params, key, salt) {
+    var hashString = PaytmChecksum.calculateHash(params, salt);
+    return PaytmChecksum.encrypt(hashString, key);
+  }
+}
+PaytmChecksum.iv = "@@@@&&&&####$$$$";
+module.exports = PaytmChecksum;

coinstrikeServer/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "coinstrike",
+  "version": "1.0.0",
+  "description": "",
+  "main": "server.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}