initial commit

Author: niallam22

.DS_Store

@@ -0,0 +1,4 @@
+*.env
+.idea
+node_modules
+api/uploads/*

.gitignore

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose')
+
+const connectDB = async () => {
+  try {
+    const conn = await mongoose.connect(process.env.DB_STRING)
+    console.log(`MongoDB Connected: ${conn.connection.host}`)
+  } catch (err) {
+    console.error(err)
+    process.exit(1)
+  }
+}
+
+module.exports = connectDB

api/config/database.js

@@ -0,0 +1,3 @@
+const jwt = require('jsonwebtoken');
+
+module.exports = { jwt };

api/config/jwt.js

@@ -0,0 +1,75 @@
+const User = require('../models/User')
+const { jwt } = require('../config/jwt');
+require('dotenv').config({path: './config/.env'})
+
+// const validator = require('validator')
+const bcrypt = require('bcryptjs');
+const salt = bcrypt.genSaltSync(10);
+
+ exports.postLogin = async (req, res, next) => {
+  const {username,password} = req.body;
+  const userDoc = await User.findOne({username});
+  const passOk = bcrypt.compareSync(password, userDoc.password);
+  if (passOk) {
+    // logged in
+    jwt.sign({username,id:userDoc._id}, process.env.jwtSecret, {}, (err,token) => {
+      if (err) throw err;
+      res.cookie('token', token).json({
+        id:userDoc._id,
+        username,
+      });
+    });
+  } else {
+    res.status(400).json('wrong credentials');
+  }
+}
+
+ exports.postRegister = async (req, res, next) => {
+    const {username,password} = req.body;
+
+    const checkUserExists = (req) => {
+      const existingUser = User.findOne(//{$or: [
+        // {email: req.body.email},
+        {username: req.body.username}
+      // ]}
+      );
+      return existingUser;
+    };
+  
+    try{
+      checkUserExists(req).then(user => {
+        if(user){
+          console.log(user)
+          res.status(400).json('username is taken')
+        } else {
+            User.create({
+            username: username.toLowerCase(),
+            password:bcrypt.hashSync(password,salt),
+          }).then(userDoc => res.json(userDoc));
+        }
+      })
+    } catch(e) {
+      console.log(e);
+      res.status(400).json(e);
+    }
+  }
+
+exports.profileAuth = function(req, res, next){ //should be async
+    const {token} = req.cookies;
+    if(!token){
+      res.json({msg: 'no user'})
+    }else {
+      try {
+        jwt.verify(token, process.env.jwtSecret, {}, (err,info) => {
+          if (err) throw err;
+          res.json(info);
+        });
+      } catch (error) {
+        console.log(error)
+      }
+    }
+}
+
+exports.logout = function(req, res, next){
+  res.cookie('token', '').json('ok');
+}

api/controllers/auth.js

@@ -0,0 +1,74 @@
+const User = require('../models/User')
+const Post = require('../models/Post')
+const fs = require('fs');
+const { jwt } = require('../config/jwt');
+require('dotenv').config({path: './config/.env'})
+
+exports.createPost = async (req, res, next) => {
+    const {originalname,path} = req.file;
+    const parts = originalname.split('.');
+    const ext = parts[parts.length - 1];
+    const newPath = path+'.'+ext;
+    fs.renameSync(path, newPath);
+  
+    const {token} = req.cookies;
+    jwt.verify(token, process.env.jwtSecret, {}, async (err,info) => {
+      if (err) throw err;
+      const {title,summary,content} = req.body;
+      const postDoc = await Post.create({
+        title,
+        summary,
+        content,
+        cover:newPath,
+        author:info.id,
+      });
+      res.json(postDoc);
+    });
+}
+
+exports.updatePost = async (req, res, next) => {
+    let newPath = null;
+    if (req.file) {
+      const {originalname,path} = req.file;
+      const parts = originalname.split('.');
+      const ext = parts[parts.length - 1];
+      newPath = path+'.'+ext;
+      fs.renameSync(path, newPath);
+    }
+  
+    const {token} = req.cookies;
+    jwt.verify(token, process.env.jwtSecret, {}, async (err,info) => {
+      if (err) throw err;
+      const {id,title,summary,content} = req.body;
+      let postDoc = await Post.findById(id);
+      const isAuthor = JSON.stringify(postDoc.author) === JSON.stringify(info.id);
+      if (!isAuthor) {
+        return res.status(400).json('you are not the author');
+      }
+      postDoc = {
+        title,
+        summary,
+        content,
+        cover: newPath ? newPath : postDoc.cover,
+      }
+  
+      await Post.updateOne({_id: id}, postDoc);
+  
+      res.json(postDoc);
+    });
+}
+
+exports.getPosts = async (req, res, next) => {
+    res.json(
+        await Post.find()
+          .populate('author', ['username'])
+          .sort({createdAt: -1})
+          .limit(20)
+      );
+}
+
+exports.getPost = async (req, res, next) => {
+    const {id} = req.params;
+    const postDoc = await Post.findById(id).populate('author', ['username']);
+    res.json(postDoc);
+}

api/controllers/home.js

@@ -0,0 +1,22 @@
+const express = require('express');
+const cors = require('cors');
+const connectDB = require('./config/database')
+const app = express();
+const mainRoutes = require('./routes/main')
+const cookieParser = require('cookie-parser');
+const logger = require('morgan')
+require('dotenv').config({path: './config/.env'})
+
+connectDB()   
+
+app.use(cors({credentials:true,origin:'http://localhost:3000'}));
+app.use(express.json());
+app.use(cookieParser());
+app.use('/uploads', express.static(__dirname + '/uploads'));
+app.use(logger('dev'))
+
+app.use('/', mainRoutes)
+
+app.listen(process.env.PORT, ()=>{
+  console.log('Server is running, you better catch it!')
+})  

api/index.js

@@ -0,0 +1,16 @@
+const mongoose = require('mongoose');
+const {Schema,model} = mongoose;
+
+const PostSchema = new Schema({
+  title:String,
+  summary:String,
+  content:String,
+  cover:String,
+  author:{type:Schema.Types.ObjectId, ref:'User'},
+}, {
+  timestamps: true,
+});
+
+const PostModel = model('Post', PostSchema);
+
+module.exports = PostModel;

api/models/Post.js

@@ -0,0 +1,11 @@
+const mongoose = require('mongoose');
+const {Schema, model} = mongoose;
+
+const UserSchema = new Schema({
+  username: {type: String, required: true, min: 4, unique: true},
+  password: {type: String, required: true},
+});
+
+const UserModel = model('User', UserSchema);
+
+module.exports = UserModel;