backend initiated and user model done

Author: shrey7ansh07

.gitignore

@@ -0,0 +1,2 @@
+backend/node_modules
+backend/.env

backend/app.js

@@ -0,0 +1,20 @@
+import express from "express"
+import cookieParser from "cookie-parser"
+import cors from "cors"
+
+const app = express()
+app.use(cors({
+    origin: process.env.CORS_ORIGIN,
+    credentials: true, //* credentials can be accessed over here
+}))
+app.use(express.json({ limit: "30kb" }))
+app.use(express.urlencoded({ extended: true, limit: "30kb" })) //* providing objects withing objects using url data transfer
+app.use(express.static("public")) //* using it to access static resources
+app.use(cookieParser()) //* cookies sent to the server via the browser are also parsed 
+
+
+
+
+
+
+export { app }

backend/database/dbconnect.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+export const connectDB = async () => {
+    try {
+        const connectionSuccess = await mongoose.connect(`${process.env.MONGODB_URL}`)
+        //* it takes some time to connect hence await
+        console.log(`DATABASE connected Successfully`)
+    }
+    catch (error) {
+        // console.error("ERROR occured while connecting to database")
+        console.error(error)
+
+        process.exit(1) //* to exit the process that is going on currently via node
+    }
+}

backend/index.js

@@ -0,0 +1,13 @@
+import dotenv from "dotenv";
+import { connectDB } from "./database/dbconnect.js";
+import { app } from "./app.js";
+dotenv.config({
+    path: './.env'
+});
+connectDB()
+    .then(() => {
+        app.listen(process.env.PORT, () => { console.log(`serving is running at ${process.env.PORT}`) })
+    })
+    .catch((error) => {
+        console.log("MONGODB connection failed", error)
+    })

backend/models/Assets.model.js

@@ -0,0 +1,61 @@
+import mongoose from "mongoose";
+import bcrypt from "bcryptjs";
+
+const UserAssets = mongoose.Schema({
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+    monthlyincome: {
+        type: Number,
+        required: true,
+        default: 0,
+    },
+    currentbankamount: {
+        type: Number,
+        required: true,
+        default: 0,
+    },
+    currentsavings: {
+        type: Number,
+        required: true,
+        default: 0,
+    }
+})
+
+UserAssets.pre("save", async function (next) {
+    if (!this.isModified("monthlyincome")) return next();
+    try {
+        this.monthlyincome = await bcrypt.hash(this.monthlyincome, 10);
+        next();
+    }
+    catch (error) {
+        next(error)
+    }
+})
+
+UserAssets.pre("save", async function (next) {
+    if (!this.isModified("currentbankamount")) return next();
+    try {
+        this.currentbankamount = await bcrypt.hash(this.currentbankamount, 10);
+        next();
+    }
+    catch (error) {
+        next(error)
+    }
+})
+
+UserAssets.pre("save", async function (next) {
+    if (!this.isModified("currentsavings")) return next();
+    try {
+        this.currentsavings = await bcrypt.hash(this.currentsavings, 10);
+        next();
+    }
+    catch (error) {
+        next(error)
+    }
+})
+
+export const Assets = mongoose.model("Assets", UserAssets)
+

backend/models/Liabilities.model.js

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+import bcrypt from "bcryptjs";
+
+const UserLiabilities = mongoose.Schema({
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+})
+

backend/models/User.model.js

@@ -0,0 +1,90 @@
+import mongoose from "mongoose";
+import bcrypt from "bcryptjs"
+import jwt from "jsonwebtoken";
+
+const UserSchema = mongoose.Schema(
+    {
+        username: {
+            type: String,
+            required: true,
+            unique: true,
+            index: true,
+            trim: true
+        },
+        email: {
+            type: String,
+            required: true,
+            unique: true,
+            trim: true,
+            lowercase: true
+        },
+        fullname: {
+            type: String,
+            required: true,
+            lowercase: true,
+            trim: true
+        },
+        coverimage: {
+            type: String, //* url from cloudinary
+        },
+
+        //* these consist of the id's of the blogs he read
+        password: {
+            type: String, //* because we will decrypt the password before storing it 
+            required: [true, "password is required"],
+
+        },
+        familysize: {
+            type: Number,
+            default: 1,
+        },
+        contactno: {
+            type: Number,
+        },
+
+
+        refreshToken: {
+            type: String,
+        }
+    },
+    {
+        timestamps: true
+    }
+)
+
+UserSchema.pre("save", async function (next) {
+    if (!this.isModified("password")) return next();
+    try {
+        this.password = await bcrypt.hash(this.password, 10);
+        next();
+    }
+    catch (error) {
+        next(error)
+    }
+})
+UserSchema.methods.isPasswordCorrect = async function (password) {
+    return await bcrypt.compare(password, this.password)
+}
+
+UserSchema.methods.generateAccessToken = function () {
+    return jwt.sign({
+        _id: this._id,
+        email: this.email,
+        username: this.username,
+        fullname: this.fullname
+    },
+        process.env.ACCESS_TOKEN_SECRET,
+        { expiresIn: process.env.ACCESS_TOKEN_EXPIRY }
+    )
+}
+UserSchema.methods.generateRefreshToken = function () {
+    return jwt.sign(
+        {
+            _id: this._id,
+        },
+        process.env.REFRESH_TOKEN_SECRET,
+        { expiresIn: process.env.REFRESH_TOKEN_EXPIRY }
+    )
+}
+
+export const User = mongoose.model("User", UserSchema)