part7 all done

Author: YBCS

part7/bloglist-backend/.env

@@ -0,0 +1,4 @@
+MONGODB_URI='mongodb+srv://fullstack:guwahati@cluster0-wsqxa.mongodb.net/blog-app?retryWrites=true&w=majority'
+TEST_MONGODB_URI='mongodb+srv://fullstack:guwahati@cluster0-wsqxa.mongodb.net/blog-app-test?retryWrites=true&w=majority'
+PORT=3001
+SECRET=imlazy

part7/bloglist-backend/.eslintrc.js

@@ -0,0 +1,40 @@
+// /blogs-backend/_eslintrc.js
+module.exports = {
+  'env': {
+      'commonjs': true,
+      'es6': true,
+      'node': true,
+      "jest": true
+  },
+  'extends': 'eslint:recommended',
+  'globals': {
+      'Atomics': 'readonly',
+      'SharedArrayBuffer': 'readonly'
+  },
+  'parserOptions': {
+      'ecmaVersion': 2018
+  },
+  'rules': {
+      'indent': [
+          'error',
+          2
+      ],
+      'quotes': [
+          'error',
+          'single'
+      ],
+      'semi': [
+          'error',
+          'never'
+      ],
+      'eqeqeq': 'error',
+      'no-trailing-spaces': 'error',
+      'object-curly-spacing': [
+          'error', 'always'
+      ],
+      'arrow-spacing': [
+          'error', { 'before': true, 'after': true }
+      ],
+      'no-console': 0
+  }
+}

part7/bloglist-backend/app.js

@@ -0,0 +1,42 @@
+// /blogs-backend/app.js
+const config = require('./utils/config')
+const express = require('express')
+require('express-async-errors')
+const cors = require('cors')
+const logger = require('./utils/logger')
+const middleware = require('./utils/middleware')
+const blogsRouter = require('./controllers/blogs')
+const usersRouter = require('./controllers/users')
+const loginRouter = require('./controllers/login')
+const mongoose = require('mongoose')
+
+const app = express()
+
+mongoose.set('useCreateIndex', true)
+
+mongoose.connect(config.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true })
+  .then(() => {
+    logger.info('connected to MongoDB')
+  })
+  .catch((error) => {
+    logger.error('error connection to MongoDB:', error.message)
+  })
+mongoose.set('useFindAndModify', false)
+
+app.use(cors())
+app.use(express.json())
+app.use(middleware.requestLogger)
+app.use(middleware.tokenExtractor)
+
+app.use('/api/blogs', blogsRouter)
+app.use('/api/users', usersRouter)
+app.use('/api/login', loginRouter)
+
+if(process.env.NODE_ENV === 'test') {
+  const testingRouter = require('./controllers/testing')
+  app.use('/api/testing', testingRouter)
+}
+
+app.use(middleware.errorHandler)
+
+module.exports = app

part7/bloglist-backend/controllers/blogs.js

@@ -0,0 +1,86 @@
+// /blogs-backend/controllers/blogs.js
+const router = require('express').Router()
+const jwt = require('jsonwebtoken')
+const Blog = require('../models/blog')
+const User = require('../models/user')
+const Comment = require('../models/comment')
+
+router.get('/', async (request, response) => {
+  const blogs = await Blog
+    .find({})
+    .populate('user', { username: 1, name: 1 })
+    .populate('comment')
+
+  response.json(blogs)
+})
+
+router.delete('/:id', async (request, response) => {
+  const decodedToken = jwt.verify(request.token, process.env.SECRET)
+
+  if (!request.token || !decodedToken.id) {
+    return response.status(401).json({ error: 'token missing or invalid' })
+  }
+
+  const user = await User.findById(decodedToken.id)
+  const blog = await Blog.findById(request.params.id)
+  if (blog.user.toString() !== user.id.toString()) {
+    return response.status(401).json({ error: 'only the creator can delete blogs' })
+  }
+
+  await blog.remove()
+  user.blogs = user.blogs.filter(b => b.id.toString() !== request.params.id.toString())
+  await user.save()
+  response.status(204).end()
+})
+
+router.put('/:id', async (request, response) => {
+  const blog = request.body
+
+  const updatedBlog = await Blog
+    .findByIdAndUpdate(request.params.id, blog, { new: true })
+    .populate('user', { username: 1, name: 1 })
+  response.json(updatedBlog.toJSON())
+})
+
+// fix it : also populate in user the comment
+router.post('/:id/comments', async (request, response) => {
+  const comment = new Comment(request.body)
+  const blog = await Blog.findById(request.params.id)
+
+  // later you'll have to use an update query
+  const savedComment = await comment.save()
+  blog.comment = blog.comment.concat(savedComment._id)
+  await blog.save()
+
+  response.json(savedComment)
+} )
+
+router.post('/', async (request, response) => {
+  const blog = new Blog(request.body)
+
+  const decodedToken = jwt.verify(request.token, process.env.SECRET)
+
+  if (!request.token || !decodedToken.id) {
+    return response.status(401).json({ error: 'token missing or invalid' })
+  }
+
+  const user = await User.findById(decodedToken.id)
+
+  if (!blog.url || !blog.title) {
+    return response.status(400).send({ error: 'title or url missing ' })
+  }
+
+  if (!blog.likes) {
+    blog.likes = 0
+  }
+
+  blog.user = user
+  const savedBlog = await blog.save()
+
+  user.blogs = user.blogs.concat(savedBlog._id)
+  await user.save()
+
+  response.status(201).json(savedBlog)
+})
+
+module.exports = router

part7/bloglist-backend/controllers/login.js

@@ -0,0 +1,34 @@
+// /blogs-backend/controllers/login.js
+const jwt = require('jsonwebtoken')
+const bcrypt = require('bcrypt')
+const router = require('express').Router()
+const User = require('../models/user')
+
+router.post('/', async (request, response) => {
+  const body = request.body
+
+  const user = await User.findOne({ username: body.username })
+
+  const passwordCorrect = user === null
+    ? false
+    : await bcrypt.compare(body.password, user.passwordHash)
+
+  if (!(user && passwordCorrect)) {
+    return response.status(401).json({
+      error: 'invalid username or password'
+    })
+  }
+
+  const userForToken = {
+    username: user.username,
+    id: user._id,
+  }
+
+  const token = jwt.sign(userForToken, process.env.SECRET)
+
+  response
+    .status(200)
+    .send({ token, username: user.username, name: user.name })
+})
+
+module.exports = router

part7/bloglist-backend/controllers/testing.js

@@ -0,0 +1,14 @@
+// define route to clear the db state
+
+const router = require('express').Router()
+const Blog = require('../models/blog')
+const User = require('../models/user')
+
+router.post('/reset', async (request, response) => {
+  await Blog.deleteMany({})
+  await User.deleteMany({})
+
+  response.status(204).end()
+})
+
+module.exports = router

part7/bloglist-backend/controllers/users.js

@@ -0,0 +1,37 @@
+// /blogs-backend/controllers/users.js
+const bcrypt = require('bcrypt')
+const router = require('express').Router()
+const User = require('../models/user')
+
+router.get('/', async (request, response) => {
+  const users = await User
+    .find({})
+    .populate('blogs', { title: 1, url: 1,  likes: 1, author: 1, comment: 1 })
+    // .populate('blogs.comment')
+
+  response.json(users.map(u => u.toJSON()))
+})
+
+router.post('/', async (request, response) => {
+  const { password, name, username } = request.body
+
+  if ( !password || password.length<3 ) {
+    return response.status(400).send({
+      error: 'password must min length 3'
+    })
+  }
+
+  const saltRounds = 10
+  const passwordHash = await bcrypt.hash(password, saltRounds)
+
+  const user = new User({
+    username, name,
+    passwordHash,
+  })
+
+  const savedUser = await user.save()
+
+  response.json(savedUser)
+})
+
+module.exports = router

part7/bloglist-backend/index.js

@@ -0,0 +1,11 @@
+// /blogs-backend/index.js
+const app = require('./app')
+const http = require('http')
+const config = require('./utils/config')
+const logger = require('./utils/logger')
+
+const server = http.createServer(app)
+
+server.listen(config.PORT, () => {
+  logger.info(`Server running on port ${config.PORT}`)
+})

part7/bloglist-backend/jest.config.js

@@ -0,0 +1,4 @@
+// /blogs-backend/jest.config.js
+module.exports = {
+  testEnvironment: 'node'
+}

part7/bloglist-backend/models/blog.js

@@ -0,0 +1,29 @@
+// /blogs-backend/models/blog.js
+const mongoose = require('mongoose')
+
+const blogSchema = mongoose.Schema({
+  title: String,
+  author: String,
+  url: String,
+  likes: Number,
+  user:  {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User'
+  },
+  comment: [
+    {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Comment'
+    }
+  ]
+})
+
+blogSchema.set('toJSON', {
+  transform: (document, returnedObject) => {
+    returnedObject.id = returnedObject._id.toString()
+    delete returnedObject._id
+    delete returnedObject.__v
+  }
+})
+
+module.exports = mongoose.model('Blog', blogSchema)

part7/bloglist-backend/models/comment.js

@@ -0,0 +1,19 @@
+const mongoose = require('mongoose')
+
+const commentSchema = mongoose.Schema({
+  content: String,
+  blog:  {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Blog'
+  },
+})
+
+commentSchema.set('toJSON', {
+  transform: (document, returnedObject) => {
+    returnedObject.id = returnedObject._id.toString()
+    delete returnedObject._id
+    delete returnedObject.__v
+  }
+})
+
+module.exports = mongoose.model('Comment', commentSchema)

part7/bloglist-backend/models/user.js

@@ -0,0 +1,34 @@
+// /blogs-backend/models/user.js
+const mongoose = require('mongoose')
+const uniqueValidator = require('mongoose-unique-validator')
+
+const userSchema = mongoose.Schema({
+  username: {
+    type: String,
+    minlength: 3,
+    unique: true
+  },
+  name: String,
+  passwordHash: String,
+  blogs: [
+    {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Blog'
+    }
+  ],
+})
+
+userSchema.set('toJSON', {
+  transform: (document, returnedObject) => {
+    returnedObject.id = returnedObject._id.toString()
+    delete returnedObject._id
+    delete returnedObject.__v
+    delete returnedObject.passwordHash
+  }
+})
+
+userSchema.plugin(uniqueValidator)
+
+const User = mongoose.model('User', userSchema)
+
+module.exports = User