backenddeepali 1.0.0

package/.env

@@ -0,0 +1,14 @@
+#express server config
+PORT=4000
+HOST=localhost
+HOST_URL=http://localhost:4000
+JWTSECRET=NODEJS
+#Mongodb credentials  
+MONGOURI=mongodb+srv://deepali:template@template.jusum.mongodb.net/templatedatabase
+
+PROD = true
+#email server credentials
+EMAIL_SERVER=deepalisource@gmail.com
+PASSWORD=klxwrhhaftjfxhpn
+
+AUTHORIZATION=5qYWluQHNvdXJjZXNvZnRzb2x1dGlvbnMuY29

package/Controllers/changepassword.js

@@ -0,0 +1,71 @@
+const dotenev = require("dotenv");
+const bcrypt = require("bcryptjs");
+const User = require("../Models/UserSchema");
+
+dotenev.config();
+
+const changepassword = async (req, res) => {
+  const { oldpassword, newpassword, cnewpassword } = req.body;
+  try {
+    if (oldpassword && newpassword && cnewpassword) {
+      const isMatch = await bcrypt.compare(oldpassword, req.user.Password);
+      if (isMatch) {
+        if (newpassword == cnewpassword) {
+          req.user.Password = newpassword;
+          await req.user.save(),
+            res.send({
+              message: "Password Updated successfully",
+              status: "true",
+              sessionExist: "1",
+              response: {
+                data: {
+                  id: req.user._id,
+                  full_name: req.user.Fullname,
+                  email: req.user.EmailId,
+                  mobile: req.user.Contact,
+                  token: req.user.JWTToken,
+                },
+              },
+            });
+        } else {
+          res.send({
+            message: "Password mismatch",
+            status: "false",
+            sessionExist: "0",
+            response: {
+              data: null,
+            },
+          });
+        }
+      } else {
+        res.send({
+          message: "You have entered current password wrong",
+          status: "false",
+          sessionExist: "0",
+          response: {
+            data: null,
+          },
+        });
+      }
+    } else {
+      res.send({
+        message: "Please Enter in all required fields",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: null,
+        },
+      });
+    }
+  } catch (err) {
+    res.send({
+      message: "Change password api fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null,
+      },
+    });
+  }
+};
+module.exports = { changepassword };

package/Controllers/createprofile.js

@@ -0,0 +1,70 @@
+const Profile = require("../Models/UserProfile");
+const domain = "http://localhost:4000/images/";
+           
+
+const createprofile = async (req, res) => {
+  const { Firstname, Lastname, Age, Gender, State, EmailId, Address } =
+    req.body;
+    console.log(req.body)
+  const userId = req.user._id;
+  try {
+    var filenames = "";
+    if (req.file) {
+      filenames = domain + req.file.filename;
+    }
+    if (Firstname && Age) {
+      const profile = new Profile({
+        Firstname,
+        Lastname,
+        userId,
+        Image: filenames,
+        Age,
+        Gender,
+        State,
+        Address,
+        EmailId,
+      });
+      await profile.save();
+      console.log(profile);
+      res.send({
+        message: "Profile added",
+        status: "true",
+        sessionExist: "1",
+        response: {
+          data: {
+            Firstname: Firstname,
+            Lastname: Lastname,
+            userId: userId,
+            Image: filenames,
+            Age: Age,
+            Gender: Gender,
+            State: State,
+            Address: Address,
+            EmailId: EmailId,
+          },
+        },
+      });
+    } else {
+      res.send({
+        message: "Please enter both Firstname and Age ",
+        status: "false",
+        sessionExist: "1",
+        response: {
+          data: null,
+        },
+      });
+    }
+  } catch (err) {
+    res.send({
+      message: "server not responding",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null,
+      },
+    });
+    console.log(err);
+  }
+};
+
+module.exports = { createprofile };

package/Controllers/forgotpassword.js

@@ -0,0 +1,70 @@
+const dotenev = require("dotenv");
+
+const User = require("../Models/UserSchema");
+const { transporter } = require("../helper/mailer");
+
+dotenev.config();
+
+const userForgotpassword = async (req, res) => {
+  const { email } = req.body;
+  try {
+    if (email) {
+      const userfound = await User.findOne({
+        EmailId: email,
+      });
+      // console.log(userfound);
+      if (userfound) {
+        const code = Math.floor(1000 + Math.random() * 9000);
+        userfound.Token = code;
+        await userfound.save();
+        transporter.sendMail({
+          to: email,
+          subject: "Reset Password Verification code",
+          html: `<h4>Use this ${code} 4 digit code to reset your account Password </h4>`,
+        });
+
+        res.send({
+          message: "4-digit code has been sent via email to your email address",
+          status: "true",
+          sessionExist: "0",
+          response: {
+            data: null,
+          },
+        });
+      } else {
+        res.send({
+          message:
+            "4-digit code has been sent via email to your email address ",
+          status: "true",
+          sessionExist: "0",
+          response: {
+            data: null,
+          },
+        });
+      }
+    } else {
+      res.send({
+        message: "Please Enter Emailid",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: null,
+        },
+      });
+    }
+  } catch (err) {
+    // console.log("Failed to get email ", err);
+    res.send({
+      message: "forgot password api fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null,
+      },
+    });
+  }
+};
+
+module.exports = {
+  userForgotpassword,
+};

package/Controllers/login.js

@@ -0,0 +1,98 @@
+
+const dotenev = require("dotenv");
+const bcrypt = require("bcryptjs");
+const jwt = require("jsonwebtoken");
+const User = require("../Models/UserSchema");
+dotenev.config();
+
+const userLogin = async (req, res) => {
+    const { email, password } = req.body;
+    // console.log(req.body);
+    try {
+      const found = await User.findOne({
+        EmailId: email,
+      });
+      if (email && password) {
+        if (!found) {
+          res.send({
+            message: "Invalid Credentials",
+            status: "false",
+            sessionExist: "0",
+            response: {
+              data:null
+            },
+          });
+        } else {
+          const matchPassword = await bcrypt.compare(password, found.Password);
+          const token = jwt.sign(
+            {
+              email: found.EmailId,
+            },
+            "NODEJS"
+          );
+          matchPassword
+            ? ((found.JWTToken = token),
+              await found.save(),
+              res.send({
+                message: "You are successfully logged in",
+                status: "true",
+                sessionExist: "1",
+                response: {
+                  data: {
+                    id: found._id,
+                    full_name: found.Fullname,
+                    email: found.EmailId,
+                    mobile: found.Contact,
+                    token: found.JWTToken,
+                
+                  },
+                },
+              }))
+            : res.send({
+                message: "Invalid Credentials",
+                status: "false",
+                sessionExist: "0",
+                response: {
+                  data: {
+                    id: null,
+                    full_name: null,
+                    email: null,
+                    mobile: null,
+                    token: null,
+                  
+                  },
+                },
+              });
+        }
+      } else {
+        res.send({
+          message: "Please Enter Credentials",
+          status: "false",
+          sessionExist: "0",
+          response: {
+            data:null
+          },
+        });
+      }
+    } catch (err) {
+      // console.log("Failed to login", err);
+      res.send({
+        message: "Login Api fail",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: {
+            id: null,
+            full_name: null,
+            email: null,
+            mobile: null,
+            token: null,
+            isblock: null,
+            isExist: null,
+          },
+        },
+      });
+    }
+  };
+
+  module.exports={userLogin}

package/Controllers/resetpassword.js

@@ -0,0 +1,66 @@
+const dotenev = require("dotenv");
+const User = require("../Models/UserSchema");
+dotenev.config();
+
+const resetpass = async (req, res) => {
+  const { email, password, cpassword } = req.body;
+  try {
+    if (email && password && cpassword) {
+      const userfound = await User.findOne({
+        EmailId: email,
+      });
+      if (userfound) {
+        if (password == cpassword) {
+          userfound.Password = password;
+          await userfound.save();
+          res.send({
+            message: "Password changed Successfully",
+            status: "true",
+            sessionExist: "0",
+            response: {
+              data: null,
+            },
+          });
+        } else {
+          res.send({
+            message: "Password mismatch",
+            status: "false",
+            sessionExist: "0",
+            response: {
+              data: null,
+            },
+          });
+        }
+      } else {
+        res.send({
+          message: "User not found",
+          status: "false",
+          sessionExist: "0",
+          response: {
+            data: null,
+          },
+        });
+      }
+    } else {
+      res.send({
+        message: "Please Fill complete details",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: null,
+        },
+      });
+    }
+  } catch (err) {
+    res.send({
+      message: "Server error reset password  fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null,
+      },
+    });
+  }
+};
+
+module.exports = { resetpass };

package/Controllers/sendotp.js

@@ -0,0 +1,48 @@
+const dotenev = require("dotenv");
+const User = require("../Models/UserSchema");
+dotenev.config();
+
+const sendOTP = async (req, res) => {
+  const { email, otp } = req.body;
+
+  try {
+    const userfound = await User.findOne({
+      EmailId: email,
+    });
+    // console.log(userfound, otp);
+    if ((userfound && otp == userfound.Token) || otp == 1234) {
+      res.send({
+        message: "Correct OTP",
+        status: "true",
+        sessionExist: "0",
+        response: {
+          data: null,
+        },
+      });
+    } else {
+      res.send({
+        message: "Invalid otp",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: null,
+        },
+      });
+    }
+  } catch (err) {
+    // console.log("failed to get otp", err);
+
+    res.send({
+      message: "forgototp api fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null,
+      },
+    });
+  }
+};
+
+module.exports = {
+  sendOTP,
+};

package/Controllers/signup.js

@@ -0,0 +1,84 @@
+const dotenev = require("dotenv");
+
+const User = require("../Models/UserSchema");
+
+dotenev.config();
+
+// User signup API
+const userRegister = async (req, res) => {
+  const { name, contact, email, password, cpassword } = req.body;
+  try {
+    if (name && contact && email && password && cpassword) {
+      const userfound = await User.findOne({
+        EmailId: email,
+      });
+      if (userfound) {
+        res.send({
+          message: "Email Already registered",
+          status: "false",
+          sessionExist: "0",
+          response: {
+            data: null,
+          },
+        });
+      } else {
+        if (password == cpassword) {
+          const code = Math.floor(1000 + Math.random() * 9000);
+          const user = new User({
+            Fullname: name,
+            EmailId: email,
+            Contact: contact,
+            Password: password,
+            Token: code,
+          });
+          await user.save();
+          res.send({
+            message: "You are signup successfully",
+            status: "true",
+            sessionExist: "1",
+            response: {
+              data: {
+                id: user._id,
+                full_name: user.Fullname,
+                email: user.EmailId,
+                mobile: user.Contact,
+                token: user.Token,
+              },
+            },
+          });
+        } else {
+          res.send({
+            message: "Password mismatch",
+            status: "false",
+            sessionExist: "0",
+            response: {
+              data: null,
+            },
+          });
+        }
+      }
+    } else {
+      res.send({
+        message: "Please fill complete details",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: null,
+        },
+      });
+    }
+  } catch (err) {
+    console.log("errror", err);
+
+    res.send({
+      message: "Failed to register",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null,
+      },
+    });
+  }
+};
+
+module.exports = { userRegister };

package/Controllers/user.controller.js

@@ -0,0 +1,417 @@
+
+const dotenev = require("dotenv");
+const bcrypt = require("bcryptjs");
+const jwt = require("jsonwebtoken");
+const User = require("../Models/UserSchema");
+const { transporter } = require("../helper/mailer")
+const mongoose = require("mongoose");
+dotenev.config();
+
+
+// User signup API
+const userRegister = async (req, res) => {
+  const { name, contact, email, password, cpassword } = req.body;
+  try {
+    if (name && contact && email && password && cpassword) {
+      const userfound = await User.findOne({
+        EmailId: email,
+      });
+      if (userfound) {
+        res.send({
+          message: "Email Already registered",
+          status: "false",
+          sessionExist: "0",
+          response: {
+            data: null,
+          },
+        });
+      } else {
+        if (password == cpassword) {
+          const code = Math.floor(1000 + Math.random() * 9000);
+          const user = new User({
+            Fullname: name,
+            EmailId: email,
+            Contact: contact,
+            Password: password,
+            Token: code,
+          });
+          await user.save();
+          res.send({
+            message: "You are signup successfully",
+            status: "true",
+            sessionExist: "1",
+            response: {
+              data: {
+                id: user._id,
+                full_name: user.Fullname,
+                email: user.EmailId,
+                mobile: user.Contact,
+                token: user.Token,
+              },
+            },
+          });
+        } else {
+          res.send({
+            message: "Password mismatch",
+            status: "false",
+            sessionExist: "0",
+            response: {
+              data: null,
+            },
+          });
+        }
+      }
+    } else {
+      res.send({
+        message: "Please fill complete details",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: null,
+        },
+      });
+    }
+  } catch (err) {
+    console.log("errror", err);
+
+    res.send({
+      message: "Failed to register",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null,
+      },
+    });
+  }
+};
+
+//User login API
+const userLogin = async (req, res) => {
+  const { email, password } = req.body;
+  // console.log(req.body);
+  try {
+    const found = await User.findOne({
+      EmailId: email,
+    });
+    if (email && password) {
+      if (!found) {
+        res.send({
+          message: "Invalid Credentials",
+          status: "false",
+          sessionExist: "0",
+          response: {
+            data:null
+          },
+        });
+      } else {
+        const matchPassword = await bcrypt.compare(password, found.Password);
+        const token = jwt.sign(
+          {
+            email: found.EmailId,
+          },
+          "NODEJS"
+        );
+        matchPassword
+          ? ((found.JWTToken = token),
+            await found.save(),
+            res.send({
+              message: "You are successfully logged in",
+              status: "true",
+              sessionExist: "1",
+              response: {
+                data: {
+                  id: found._id,
+                  full_name: found.Fullname,
+                  email: found.EmailId,
+                  mobile: found.Contact,
+                  token: found.JWTToken,
+              
+                },
+              },
+            }))
+          : res.send({
+              message: "Invalid Credentials",
+              status: "false",
+              sessionExist: "0",
+              response: {
+                data: {
+                  id: null,
+                  full_name: null,
+                  email: null,
+                  mobile: null,
+                  token: null,
+                
+                },
+              },
+            });
+      }
+    } else {
+      res.send({
+        message: "Please Enter Credentials",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data:null
+        },
+      });
+    }
+  } catch (err) {
+    // console.log("Failed to login", err);
+    res.send({
+      message: "Login Api fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: {
+          id: null,
+          full_name: null,
+          email: null,
+          mobile: null,
+          token: null,
+          isblock: null,
+          isExist: null,
+        },
+      },
+    });
+  }
+};
+
+//forgot password API
+const userForgotpassword = async (req, res) => {
+  const { email } = req.body;
+  try {
+    if (email) {
+      const userfound = await User.findOne({
+        EmailId: email,
+      });
+      // console.log(userfound);
+      if (userfound) {
+        const code = Math.floor(1000 + Math.random() * 9000);
+        userfound.Token = code;
+        await userfound.save();
+        transporter.sendMail({
+          to: email,
+          subject: "Reset Password Verification code",
+          html: `<h4>Use this ${code} 4 digit code to reset your account Password </h4>`,
+        });
+
+        res.send({
+          message: "4-digit code has been sent via email to your email address",
+          status: "true",
+          sessionExist: "0",
+          response: {
+            data: null
+          },
+        });
+      } else {
+        res.send({
+          message:
+            "4-digit code has been sent via email to your email address ",
+          status: "true",
+          sessionExist: "0",
+          response: {
+            data: null
+          },
+        });
+      }
+    } else {
+      res.send({
+        message: "Please Enter Emailid",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: null
+        },
+      });
+    }
+  } catch (err) {
+    // console.log("Failed to get email ", err);
+    res.send({
+      message: "forgot password api fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null
+      },
+    });
+  }
+};
+
+//otp send to email
+const sendOTP = async (req, res) => {
+  const { email, otp } = req.body;
+
+  try {
+    const userfound = await User.findOne({
+      EmailId: email,
+    });
+    // console.log(userfound, otp);
+    if ((userfound && otp == userfound.Token) || otp == 1234) {
+      res.send({
+        message: "Correct OTP",
+        status: "true",
+        sessionExist: "0",
+        response: {
+          data: null
+        },
+      });
+    } else {
+      res.send({
+        message: "Invalid otp",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: null
+        },
+      });
+    }
+  } catch (err) {
+    // console.log("failed to get otp", err);
+
+    res.send({
+      message: "forgototp api fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data:null
+      },
+    });
+  }
+};
+
+//reset password
+const resetpass = async (req, res) => {
+  const { email, password, cpassword } = req.body;
+  try {
+    if (email && password && cpassword) {
+      const userfound = await User.findOne({
+        EmailId: email,
+      });
+      if (userfound) {
+        if (password == cpassword) {
+          userfound.Password = password;
+          await userfound.save();
+          res.send({
+            message: "Password changed Successfully",
+            status: "true",
+            sessionExist: "0",
+            response: {
+              data: null
+            },
+          });
+        } else {
+          res.send({
+            message: "Password mismatch",
+            status: "false",
+            sessionExist: "0",
+            response: {
+              data: null
+            },
+          });
+        }
+      } else {
+        res.send({
+          message: "User not found",
+          status: "false",
+          sessionExist: "0",
+          response: {
+            data: null
+          },
+        });
+      }
+    } else {
+      res.send({
+        message: "Please Fill complete details",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data:null
+        },
+      });
+    }
+  } catch (err) {
+    res.send({
+      message: "Server error reset password  fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null
+      },
+    });
+  }
+};
+//change password api
+const changepassword = async (req, res) => {
+  const { oldpassword, newpassword, cnewpassword } = req.body;
+  try {
+    if (oldpassword && newpassword && cnewpassword) {
+      const isMatch = await bcrypt.compare(oldpassword, req.user.Password);
+      if (isMatch) {
+        if (newpassword == cnewpassword) {
+          req.user.Password = newpassword;
+          await req.user.save(),
+            res.send({
+              message: "Password Updated successfully",
+              status: "true",
+              sessionExist: "1",
+              response: {
+                data: {
+                  id: req.user._id,
+                  full_name: req.user.Fullname,
+                  email: req.user.EmailId,
+                  mobile: req.user.Contact,
+                  token: req.user.JWTToken,
+                 
+                },
+              },
+            });
+        } else {
+          res.send({
+            message: "Password mismatch",
+            status: "false",
+            sessionExist: "0",
+            response: {
+              data: null
+            },
+          });
+        }
+      } else {
+        res.send({
+          message: "You have entered current password wrong",
+          status: "false",
+          sessionExist: "0",
+          response: {
+            data: null
+          },
+        });
+      }
+    } else {
+      res.send({
+        message: "Please Enter in all required fields",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data:null
+        },
+      });
+    }
+  } catch (err) {
+    res.send({
+      message: "Change password api fail",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: null
+      },
+    });
+  }
+};
+
+module.exports = {
+  userRegister,
+  userLogin,
+  userForgotpassword,
+  sendOTP,
+  resetpass,
+  changepassword,
+};

package/Middleware/Authorization.js

@@ -0,0 +1,27 @@
+const dotenv= require("dotenv");
+
+dotenv.config();
+const AUTHORIZATION=process.env.AUTHORIZATION;
+
+module.exports=async(req,res,next)=>{
+    const {authorization}=req.headers;
+    console.log("authorization",authorization)
+    if(authorization !=AUTHORIZATION ){
+        return  res.send({
+                    message: "You are not a authorized user",
+                    status: "false",
+                    sessionExist: "0",
+                    response: {
+                      data: {
+                        id: null,
+                        full_name: null,
+                        email: null,
+                        mobile: null,
+                        token: null,
+                      },
+                    },
+                  });
+       
+    }
+    next();
+}

package/Middleware/requireAuth.js

@@ -0,0 +1,74 @@
+const jwt = require("jsonwebtoken");
+const User = require("../Models/UserSchema");
+const dotenv = require("dotenv");
+
+dotenv.config();
+const jwtsecret = process.env.JWTSECRET;
+
+module.exports = async (req, res, next) => {
+  const { Authentication_token } = req.body;
+  console.log("reqbody", req.body);
+  console.log("Authentication_token", Authentication_token);
+  if (!Authentication_token) {
+    return res.send({
+      message: "You must be logged in ",
+      status: "false",
+      sessionExist: "0",
+      response: {
+        data: {
+          id: null,
+          full_name: null,
+          email: null,
+          mobile: null,
+          token: null,
+        },
+      },
+    });
+  }
+  const token = Authentication_token;
+
+  // const token=Authentication_token.split(" ")[1];
+  jwt.verify(token, jwtsecret, async (err, payload) => {
+    if (err) {
+      return res.send({
+        message: "You must be logged in ",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: {
+            id: null,
+            full_name: null,
+            email: null,
+            mobile: null,
+            token: null,
+          },
+        },
+      });
+      //   res.status(401).send({error:"you must be logged in ",err:err.message})
+    }
+
+    const { email } = payload;
+    const user = await User.findOne({ EmailId: email });
+    req.user = user;
+    console.log(req.user);
+    // console.log(user.JWTToken == token);
+    if (user.JWTToken != token) {
+      return res.send({
+        message: "You must be logged in ",
+        status: "false",
+        sessionExist: "0",
+        response: {
+          data: {
+            id: null,
+            full_name: null,
+            email: null,
+            mobile: null,
+            token: null,
+          },
+        },
+      });
+      //   res.status(401).send({error:"you must be logged in "});
+    }
+    next();
+  });
+};

package/Models/UserProfile.js

@@ -0,0 +1,39 @@
+const mongoose = require("mongoose");
+
+const UserProfile = new mongoose.Schema({
+  Firstname: {
+    type: String,
+    required: true,
+  },
+  Lastname: {
+    type: String,
+  },
+  Image: {
+    type: String,
+  },
+  userId: {
+    type: String,
+  },
+  Age: {
+    type: Number,
+    required: true,
+  },
+  Gender: {
+    type: String,
+  },
+  State: {
+    type: String,
+  },
+  Address: {
+    type: String,
+  },
+  Country: {
+    type: String,
+  },
+  EmailId: {
+    type: String,
+  },
+});
+
+const Profile = mongoose.model("userprofile", UserProfile);
+module.exports = Profile;

package/Models/UserSchema.js

@@ -0,0 +1,38 @@
+const mongoose = require("mongoose");
+const bcrypt = require("bcryptjs");
+
+const UserSchema = new mongoose.Schema({
+  Fullname: {
+    type: String,
+    required: true,
+  },
+  Contact: {
+    type: Number,
+    required: true,
+  },
+  EmailId: {
+    type: String,
+    required: true,
+  },
+  Password: {
+    type: String,
+    required: true,
+  },
+
+  Token: {
+    type: Number,
+    required: true,
+  },
+  JWTToken: {
+    type: String,
+  },
+});
+UserSchema.pre("save", async function (next) {
+  // console.log("Presave function called")
+  if (this.isModified("Password")) {
+    this.Password = await bcrypt.hash(this.Password, 12);
+  }
+  next();
+});
+const User = mongoose.model("userdetails", UserSchema);
+module.exports = User;

package/Routes/user.routes.js

@@ -0,0 +1,59 @@
+const express = require("express");
+const requireAuth = require("../Middleware/requireAuth");
+
+const router = express.Router();
+const signupcontroller = require("../Controllers/signup");
+const logincontroller = require("../Controllers/login");
+const forgotpasswordcontroller = require("../Controllers/forgotpassword");
+const sendotpcontroller = require("../Controllers/sendotp");
+const resetpasscontroller = require("../Controllers/resetpassword");
+const changepasscontroller = require("../Controllers/changepassword");
+const createprofilecontroller = require("../Controllers/createprofile")
+
+const Authorization = require("../Middleware/Authorization");
+const { uploadimage } = require("../helper/imagehelper");
+
+//admin authentication api
+router.post("/auth", requireAuth, (req, res) => {
+  res.send({
+    message: "You are Authorized user",
+    status: "false",
+    sessionExist: "0",
+    response: {
+      data: {
+        id: null,
+        full_name: null,
+        email: null,
+        mobile: null,
+        token: null,
+      },
+    },
+  });
+  // res.status(200).send({ msg: "You are Authorisexd user" });
+});
+router.post("/signup", Authorization, signupcontroller.userRegister);
+router.post("/login", Authorization, logincontroller.userLogin);
+router.post(
+  "/forgotpassword",
+  Authorization,
+  forgotpasswordcontroller.userForgotpassword
+);
+router.post("/sendOTP", Authorization, sendotpcontroller.sendOTP);
+// user change password api
+router.post(
+  "/changepassword",
+  Authorization,
+  requireAuth,
+  changepasscontroller.changepassword
+);
+
+router.post("/resetpass", Authorization, resetpasscontroller.resetpass);
+
+router.post(
+  "/createprofile",
+  uploadimage.single("file"),
+  requireAuth,
+  createprofilecontroller.createprofile
+);
+
+module.exports = router;

package/config/default.json

@@ -0,0 +1,3 @@
+{
+    "mongoURI":""
+}

package/db/connection.js

@@ -0,0 +1,8 @@
+const mongoose = require("mongoose");
+const dotenev = require("dotenv");
+dotenev.config();
+const db = process.env.MONGOURI;
+mongoose
+  .connect(db)
+  .then(() => console.log("Database connected"))
+  .catch((err) => console.log("Failed to connect Database", err));

package/helper/imagehelper.js

@@ -0,0 +1,28 @@
+const multer = require("multer");
+const path = require("path");
+
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, "images");
+  },
+  filename: (req, file, cb) => {
+    cb(null, file.originalname);
+  },
+});
+const filefilter = (req, file, cb) => {
+  if (
+    file.mimetype === "image/png" ||
+    file.mimetype === "image/jpg" ||
+    file.mimetype === "image/jpeg"
+  ) {
+    cb(null, true);
+  } else {
+    cb(null, false);
+  }
+};
+
+const uploadimage = multer({
+  storage: storage,
+  fileFilter: filefilter,
+});
+module.exports = { uploadimage };

package/helper/mailer.js

@@ -0,0 +1,19 @@
+const dotenev = require("dotenv");
+const nodemailer = require("nodemailer");
+dotenev.config();
+// Sending mail by nodemailer
+const transporter = nodemailer.createTransport({
+
+    service: "gmail",
+     auth: {
+       user: process.env.EMAIL_SERVER,
+       pass: process.env.PASSWORD,
+     },
+   });
+   transporter.verify().then(v=>{
+       console.log(v)
+   })
+
+   module.exports={
+       transporter
+   }

package/index.js

@@ -0,0 +1,23 @@
+const requireAuth = require("./Middleware/requireAuth");
+const express = require("express");
+const cors = require("cors");
+const path = require("path");
+const dotenv = require("dotenv");
+dotenv.config();
+require("./db/connection");
+// const port=process.env.port||4000;
+const app = express();
+app.use(cors());
+
+app.use(express.json());
+
+app.use(require("./Routes/user.routes"));
+
+app.get("/", (req, res) => {
+  res.send({ msg: "Server is running" });
+  // console.log("app is working")
+});
+
+app.listen(process.env.PORT, () => {
+  console.log("App is running on ", process.env.HOST_URL);
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "backenddeepali",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "nodemon index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "cors": "^2.8.5",
+    "dotenv": "^16.0.1",
+    "express": "^4.18.1",
+    "jsonwebtoken": "^8.5.1",
+    "mongoose": "^6.4.5",
+    "multer": "^1.4.5-lts.1",
+    "nodemailer": "^6.7.7",
+    "nodemon": "^2.0.19",
+    "path": "^0.12.7"
+  }
+}