Add new project

Author: Alesyaa103

.eslintrc.js

@@ -0,0 +1,18 @@
+module.exports = {
+  env: {
+    browser: true,
+    es6: true,
+  },
+  extends: [
+    'airbnb-base',
+  ],
+  globals: {
+    Atomics: 'readonly',
+    SharedArrayBuffer: 'readonly',
+  },
+  parserOptions: {
+    ecmaVersion: 2018,
+  },
+  rules: {
+  },
+};

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+config/

README.md

@@ -0,0 +1 @@
+https://server-koa.herokuapp.com/

controllers/index.js

@@ -0,0 +1,91 @@
+const passport = require('koa-passport');
+const config = require('config');
+const jwt = require('jwt-simple'); // аутентификация по JWT для hhtp
+const User = require('../models/User');
+
+module.exports = {
+  async signIn(ctx, next) {
+    await passport.authenticate('local', (err, user) => {
+      if (user) {
+        const payload = {
+          id: user._id,
+        };
+        ctx.body = {
+          token: jwt.encode(payload, config.get('jwtSecret')),
+        };
+      } else {
+        console.log(err);
+      }
+    })(ctx, next);
+  },
+  async signUp(ctx) {
+    const {
+      firstname,
+      lastname,
+      email,
+      username,
+      password,
+    } = ctx.request.body;
+    try {
+      const Find = await User.find({
+        email,
+      });
+      if (Find.length !== 0) {
+        ctx.body = {
+          msg: 'same person already exist',
+        };
+      } else {
+        const newUser = new User({
+          firstname,
+          lastname,
+          username,
+          email,
+          password,
+        });
+        const res = await User.create(newUser);
+        ctx.response.status = 200;
+      }
+    } catch (err) {
+      throw err;
+    }
+  },
+  async reset1(ctx, next) {
+    const {
+      email,
+    } = ctx.request.body;
+    try {
+      const Find = await User.find({
+        email,
+      });
+      if (Find.length === 0) {
+        console.log('there is no such person');
+      } else {
+        ctx.response.status = 200;
+      }
+    } catch (err) {
+      throw err;
+    }
+  },
+  async reset2(ctx, next) {
+    const {
+      email,
+      password,
+    } = ctx.request.body;
+    try {
+      const Find = await User.find({
+        email,
+      });
+      console.log(Find);
+      user = Find[0];
+      user.password = password;
+      await user.save();
+      ctx.response.status = 200;
+    } catch (err) {
+      throw err;
+    }
+  },
+  async getPersonal(ctx) {
+    ctx.body = 'Secret content';
+  },
+
+};

index.js

@@ -0,0 +1,48 @@
+const Koa = require('koa');
+const KoaRouter = require('koa-router');
+// const serve = require('koa-static');
+const logger = require('koa-logger');
+const bodyParser = require('koa-bodyparser');
+const cors = require('koa2-cors');
+const passport = require('./libs/passport/index');
+require('./libs/mongoose');
+
+passport.initialize();
+
+const app = new Koa();
+const router = new KoaRouter();
+app.use(cors({
+  origin() {
+    return '*';
+  },
+}));
+
+app.use(async (ctx, next) => {
+  try {
+    console.log('Request', ctx.request);
+    await next();
+  } catch (err) {
+    console.log('Global error: ', err);
+    ctx.status = 500;
+    ctx.body = {
+      error: true,
+    };
+  }
+});
+app.use(logger());
+app.use(bodyParser());
+
+app.use(passport.initialize());
+
+const auth = require('./routes/auth').routes();
+
+router.use('/api/', auth);
+app.use(router.routes())
+  .use(router.allowedMethods());
+
+
+const PORT = process.env.PORT || 7070;
+app.listen(PORT, (error) => {
+  if (error) console.log('error');
+  else console.log(`server on port ${PORT}`);
+});

libs/mongoose.js

@@ -0,0 +1,10 @@
+const config = require('config');
+const mongoose = require('mongoose'); // стандартная прослойка для работы с MongoDB
+
+mongoose.Promise = Promise; // Просим Mongoose использовать стандартные Промисы
+mongoose.set('debug', true); // Просим Mongoose писать все запросы к базе в консоль
+ mongoose.connect( config.get('databaseUrl'),
+ { useNewUrlParser: true, useFindAndModify:  false, useCreateIndex: true },
+(err) => { if (err) throw new Error('Connected with db is faild'); console.log('connected'); });
+
+module.exports = mongoose;

libs/passport/index.js

@@ -0,0 +1,6 @@
+const passport = require('koa-passport');
+
+passport.use(require('./jwtStrategy'));
+passport.use(require('./localStrategy'));
+
+module.exports = passport;

libs/passport/jwtStrategy.js

@@ -0,0 +1,23 @@
+const JwtStrategy = require('passport-jwt').Strategy;
+const ExtractJwt = require('passport-jwt').ExtractJwt; // авторизация через JWT
+const config = require('config');
+
+const User = require('../../models/User');
+
+let opts = {
+  jwtFromRequest: ExtractJwt.fromAuthHeaderWithScheme('JWT'),
+  secretOrKey: config.get('jwtSecret'),
+};
+
+module.exports = new JwtStrategy(opts, (jwtPayload, done) => {
+  User.findById(jwtPayload.id, (err, user) => {
+    if (err) {
+      return done(err, false);
+    }
+    if (user) {
+      return done(null, user);
+    } 
+    return done(null, false);
+  });
+});
+

libs/passport/localStrategy.js

@@ -0,0 +1,25 @@
+const LocalStrategy = require('passport-local');
+const User = require('../../models/User');
+// локальная стратегия авторизации
+
+const opts = {
+  usernameField: 'email',
+  passwordField: 'password',
+  passReqToCallback: true,
+  session: false
+};
+
+module.exports = new LocalStrategy(opts, (req, email, password, done) => {
+  User.findOne({ email: email }, (err, user) => {
+    if (err) {
+      return done(err);
+    }
+    if (!user) {
+      return done('User doesn\'t exist!', false);
+    }
+    if (!user.checkPassword(password)) {
+      return done('Incorrect password!', false);
+    }
+    return done(null, user);
+  });
+});

models/User.js

@@ -0,0 +1,82 @@
+const mongoose = require('mongoose');
+const config = require('config');
+const crypto = require('crypto');
+// const beautifyUnique = require('mongoose-beautiful-unique-validation');
+
+const User = mongoose.Schema;
+const UserSchema = new User({
+  firstname: String,
+  lastname: String,
+  username: {
+    type: String,
+    // unique: 'Two users cannot share the same username ({VALUE})',
+    required: 'add username',
+  },
+  email: {
+    type: String,
+    // unique: 'Two users cannot share the same email ({VALUE})',
+    required: 'add e-mail',
+    validate: {
+      validator: function checkEmail(value) {
+        const re = /^(\S+)@([a-z0-9-]+)(\.)([a-z]{2,4})(\.?)([a-z]{0,4})+$/;
+        return re.test(value);
+      },
+      message: props => `${props.value} is not a valid email.`,
+    },
+  },
+  photo: {
+    type: String,
+    default: config.get('defaultUserPhoto'),
+  },
+  token: String,
+  passwordHash: String,
+  salt: String,
+}, {
+  timestamps: true,
+});
+UserSchema.virtual('password')
+  .set(function (password) {
+    if (!password) {
+      this.invalidate('password', 'Password can\'t be empty!');
+    }
+
+    if (password !== undefined) {
+      if (password.length < 6) {
+        this.invalidate('password', 'Password can\'t be less than 6 symbols!');
+      }
+    }
+
+    this._plainPassword = password;
+
+    if (password) {
+      this.salt = crypto.randomBytes(config.get('crypto').hash.length).toString('base64');
+      this.passwordHash = crypto.pbkdf2Sync(
+        password,
+        this.salt,
+        config.get('crypto').hash.iterations,
+        config.get('crypto').hash.length,
+        'sha512',
+      ).toString('base64');
+    } else {
+      this.salt = undefined;
+      this.passwordHash = undefined;
+    }
+  })
+
+  .get(function () {
+    return this._plainPassword;
+  });
+
+UserSchema.methods.checkPassword = function (password) {
+  if (!password) return false;
+  if (!this.passwordHash) return false;
+  return crypto.pbkdf2Sync(
+    password,
+    this.salt,
+    config.get('crypto').hash.iterations,
+    config.get('crypto').hash.length,
+    'sha512',
+  ).toString('base64') === this.passwordHash;
+};
+
+module.exports = mongoose.model('User', UserSchema);