Server Added

Author: hyperloo

.gitignore

@@ -0,0 +1,26 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+**/.git
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+yarn.lock

Procfile

@@ -0,0 +1 @@
+web: node app.js

app.js

@@ -0,0 +1,81 @@
+const express = require("express");
+const mongoose = require("mongoose");
+const bodyParser = require("body-parser");
+const cors = require("cors");
+
+const url = require("./routes/api/url");
+const users = require("./routes/api/users");
+const auth = require("./routes/api/auth");
+
+const Url = require("./models/url");
+
+const app = express();
+
+app.use(bodyParser.urlencoded({ extended: false }));
+app.use(bodyParser.json());
+app.use(cors());
+
+mongoose
+  .connect(
+    `mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-jwfcs.mongodb.net/${process.env.MONGO_DB}?retryWrites=true&w=majority`,
+    {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+      useCreateIndex: true,
+    }
+  )
+  .then(() => {
+    console.log("MongoDb connected.....");
+  })
+  .catch((err) => {
+    console.log("Cannot connect to db due to " + err);
+  });
+
+app.use("/api/urls", url);
+app.use("/api/register", users);
+app.use("/api/login", auth);
+
+app.get("/:code", async (req, res) => {
+  try {
+    const url = await Url.findOne({ code: req.params.code });
+
+    if (url) {
+      if (
+        url.lastDate &&
+        url.lastDate.toISOString() < new Date().toISOString()
+      ) {
+        const user = await User.findById(url.creator);
+
+        for (let i = 0; i < user.shortenedUrl.length; i++) {
+          if (user.shortenedUrl[i].toString() === id) {
+            user.shortenedUrl.splice(i, 1);
+            break;
+          }
+        }
+        await user.save();
+        await url.deleteOne();
+        return res
+          .status(404)
+          .json({ msg: "This Compress URL does not exist any more!" });
+      }
+      if (!url.status) {
+        return res
+          .status(200)
+          .json({ msg: "This url is temporarily out of service!" });
+      }
+
+      url.clicks = url.clicks + 1;
+      url.save();
+      return res.redirect(url.longUrl);
+    } else {
+      return res.status(404).json({ msg: "No Compressed URL Found" });
+    }
+  } catch (err) {
+    console.log(err);
+    res.status(500).json({ msg: "Internal Server Error" });
+  }
+});
+
+const port = process.env.PORT || 5000;
+
+app.listen(port, () => console.log(`Server Started on port ${port}`));

middleware/auth.js

@@ -0,0 +1,20 @@
+const jwt = require("jsonwebtoken");
+
+module.exports = async (req, res, next) => {
+  const token = req.header("x-auth-token");
+
+  //Check for token
+  if (!token)
+    return res
+      .status(401)
+      .send({ msg: "Authorization denied, Login / SignUp again" });
+  try {
+    //Verify token
+    const decoded = await jwt.verify(token, process.env.JWT_SECRET);
+    //Add user from payload
+    req.user = decoded;
+    next();
+  } catch (e) {
+    return res.status(401).send({ msg: "Timeout!, Login / SignUp again" });
+  }
+};

models/url.js

@@ -0,0 +1,34 @@
+const mongoose = require("mongoose");
+const Schema = mongoose.Schema;
+
+const urlSchema = new Schema(
+  {
+    status: {
+      type: Boolean,
+      default: 1,
+    },
+    code: String,
+    longUrl: {
+      type: String,
+      required: true,
+    },
+    shortUrl: String,
+    clicks: {
+      type: Number,
+      default: 0,
+    },
+    creator: {
+      type: Schema.Types.ObjectId,
+      ref: "User",
+    },
+    lastDate: {
+      type: Date,
+      default: null,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+module.exports = mongoose.model("Url", urlSchema);

models/user.js

@@ -0,0 +1,29 @@
+const mongoose = require("mongoose");
+
+const Schema = mongoose.Schema;
+
+const userSchema = new Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+    },
+    email: {
+      type: String,
+      required: true,
+    },
+    password: {
+      type: String,
+      required: true,
+    },
+    shortenedUrl: [
+      {
+        type: Schema.Types.ObjectId,
+        ref: "Url",
+      },
+    ],
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("User", userSchema);

package.json

@@ -0,0 +1,26 @@
+{
+  "name": "hackstack-task",
+  "version": "1.0.0",
+  "description": "",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "server": "nodemon app.js",
+    "client": "npm start --prefix client"
+  },
+  "author": "Himanshu",
+  "license": "ISC",
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "body-parser": "^1.19.0",
+    "cors": "^2.8.5",
+    "express": "^4.17.1",
+    "jsonwebtoken": "^8.5.1",
+    "mongoose": "^5.9.15",
+    "shortid": "^2.2.15",
+    "valid-url": "^1.0.9"
+  },
+  "devDependencies": {
+    "nodemon": "^2.0.4"
+  }
+}

routes/api/auth.js

@@ -0,0 +1,43 @@
+const express = require("express");
+const router = express.Router();
+const bcrypt = require("bcryptjs");
+const jwt = require("jsonwebtoken");
+const auth = require("../../middleware/auth");
+
+const User = require("../../models/user");
+
+router.post("/", async (req, res) => {
+  const { name, email, password } = req.body;
+
+  if (!email || !password) {
+    return res.status(400).send({ msg: "Please enter all fields" });
+  }
+
+  const user = await User.findOne({ email });
+  if (!user) return res.status(400).send({ msg: "User Does not Exist" });
+
+  bcrypt.compare(password, user.password).then((isMatch) => {
+    if (!isMatch) return res.status(403).send({ msg: "Invalid Credentials" });
+
+    jwt.sign(
+      { id: user.id },
+      process.env.JWT_SECRET,
+      { expiresIn: 3600 },
+      (err, token) => {
+        if (err) throw err;
+        return res.json({
+          token,
+          user,
+        });
+      }
+    );
+  });
+});
+
+router.get("/user", auth, (req, res) => {
+  User.findById(req.user.id)
+    .select("-password")
+    .then((user) => res.status(200).json(user));
+});
+
+module.exports = router;

routes/api/url.js

@@ -0,0 +1,128 @@
+const express = require("express");
+const router = express.Router();
+const validUrl = require("valid-url");
+const shortId = require("shortid");
+
+const middleAuth = require("../../middleware/auth");
+
+const Url = require("../../models/url");
+const User = require("../../models/user");
+
+router.get("/", middleAuth, async (req, res) => {
+  try {
+    const user = await User.findById(req.user.id)
+      .populate("shortenedUrl")
+      .exec();
+    if (!user) {
+      return res.status(400).json({ msg: "User does not exist" });
+    } else {
+      return res
+        .status(200)
+        .json({ msg: "User found", url: user.shortenedUrl });
+    }
+  } catch (err) {
+    console.log(err);
+    res.status(500).send({ msg: "Internal Server Error" });
+  }
+});
+
+router.post("/compress", middleAuth, async (req, res) => {
+  const { longUrl, lastDate } = req.body;
+
+  // const baseUrl = "http://localhost:5000";
+  const baseUrl = process.env.BASE_URL;
+  if (!validUrl.isUri(baseUrl)) {
+    return res.status(400).send({ msg: "Invalid Base Url" });
+  }
+
+  const urlCode = shortId.generate();
+
+  if (validUrl.isUri(longUrl)) {
+    try {
+      let url = await Url.findOne({ longUrl: longUrl });
+
+      if (url) {
+        res
+          .status(400)
+          .send({ msg: "Compressed URL already exists", url: url.shortUrl });
+      } else {
+        const shortUrl = baseUrl + "/" + urlCode;
+
+        url = new Url({
+          longUrl,
+          shortUrl,
+          urlCode,
+          lastDate: lastDate,
+          code: urlCode,
+          creator: req.user.id,
+        });
+        const newUrl = await url.save();
+
+        const user = await User.findById(req.user.id);
+        await user.shortenedUrl.push(newUrl._id);
+        await user.save();
+
+        res
+          .status(200)
+          .json({ msg: "URL Compressed Successfully", url: newUrl });
+      }
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ msg: "Internal Server Error" });
+    }
+  } else {
+    res.status(401).send({ msg: "Invalid Long URL" });
+  }
+});
+
+router.delete("/:id", middleAuth, async (req, res) => {
+  const id = req.params.id;
+
+  try {
+    const url = await Url.findById(id);
+
+    if (req.user.id !== url.creator.toString()) {
+      return res.status(401).json({ msg: "Unauthorized User" });
+    }
+
+    const user = await User.findById(req.user.id);
+
+    for (let i = 0; i < user.shortenedUrl.length; i++) {
+      if (user.shortenedUrl[i].toString() === id) {
+        user.shortenedUrl.splice(i, 1);
+        break;
+      }
+    }
+    await user.save();
+    await url.deleteOne();
+
+    res.status(200).json({ msg: "Short Url Deleted Successfully" });
+  } catch (err) {
+    console.log(err);
+    res.status(500).json({ msg: "Internal Server Error" });
+  }
+});
+
+router.patch("/:id", middleAuth, async (req, res) => {
+  const id = req.params.id;
+
+  try {
+    const url = await Url.findById(id);
+
+    if (req.user.id !== url.creator.toString()) {
+      return res.status(401).json({ msg: "Unauthorized User" });
+    }
+
+    const { lastDate, status } = req.body;
+
+    url.lastDate = lastDate;
+    url.status = status;
+    const newUrl = await url.save();
+    res.status(200).json({ msg: "URL updated successfully", url: newUrl });
+  } catch (err) {
+    console.log(err);
+    res.status(500).json({ msg: "Internal Server Error" });
+  }
+});
+
+module.exports = router;