Linted all user files.

seasoned_api/src/user/token.js

@@ -2,37 +2,36 @@ const User = require('src/user/user');
 const jwt = require('jsonwebtoken');
 
 class Token {
+   constructor(user) {
+      this.user = user;
+   }
 
-  constructor(user) {
+   /**
-    this.user = user;
+    * Generate a new token.
-  }
+    * @param {String} secret a cipher of the token
+    * @returns {String}
+    */
+   toString(secret) {
+      return jwt.sign({ username: this.user.username }, secret);
+   }
 
-  /**
+   /**
-   * Generate a new token.
-   * @param {String} secret a cipher of the token
-   * @returns {String}
-   */
-  toString(secret) {
-    return jwt.sign({ username: this.user.username }, secret);
-  }
-
-  /**
    * Decode a token.
    * @param {Token} jwtToken an encrypted token
    * @param {String} secret a cipher of the token
    * @returns {Token}
    */
-  static fromString(jwtToken, secret) {
+   static fromString(jwtToken, secret) {
-    let username = null;
+      let username = null;
 
-    try {
+      try {
-      username = jwt.verify(jwtToken, secret).username;
+         username = jwt.verify(jwtToken, secret).username;
-    } catch (error) {
+      } catch (error) {
-      throw new Error('The token is invalid.');
+         throw new Error('The token is invalid.');
-    }
+      }
-    const user = new User(username);
+      const user = new User(username);
-    return new Token(user);
+      return new Token(user);
-  }
+   }
 }
 
 module.exports = Token;

seasoned_api/src/user/user.js

@@ -1,8 +1,8 @@
 class User {
-  constructor(username, email) {
+   constructor(username, email) {
-    this.username = username;
+      this.username = username;
-    this.email = email;
+      this.email = email;
-  }
+   }
 }
 
-module.exports = User;
+module.exports = User;

seasoned_api/src/user/userRepository.js

@@ -2,58 +2,56 @@ const assert = require('assert');
 const establishedDatabase = require('src/database/database');
 
 class UserRepository {
+   constructor(database) {
+      this.database = database || establishedDatabase;
+      this.queries = {
+         read: 'select * from user where lower(user_name) = lower(?)',
+         create: 'insert into user (user_name, email) values(?, ?)',
+         change: 'update user set password = ? where user_name = ?',
+         retrieveHash: 'select * from user where user_name = ?',
+      };
+   }
 
-  constructor(database) {
+   /**
-    this.database = database || establishedDatabase;
-    this.queries = {
-      read: 'select * from user where lower(user_name) = lower(?)',
-      create: 'insert into user (user_name, email) values(?, ?)',
-      change: 'update user set password = ? where user_name = ?',
-      retrieveHash: 'select * from user where user_name = ?',
-    };
-  }
-
-  /**
    * Create a user in a database.
    * @param {User} user the user you want to create
    * @returns {Promise}
    */
-  create(user) {
+   create(user) {
-    return Promise.resolve()
+      return Promise.resolve()
-    .then(() => this.database.get(this.queries.read, user.username))
+         .then(() => this.database.get(this.queries.read, user.username))
-    .then(row => assert.equal(row, undefined))
+         .then(row => assert.equal(row, undefined))
-    .then(() => this.database.run(this.queries.create, [user.username, user.email]))
+         .then(() => this.database.run(this.queries.create, [user.username, user.email]))
-    .catch((error) => {
+         .catch((error) => {
-      if (error.message.endsWith('email')) {
+            if (error.message.endsWith('email')) {
-        throw new Error('That email is already taken');
+               throw new Error('That email is already taken');
-      } else if (error.name === 'AssertionError' || error.message.endsWith('user_name')) {
+            } else if (error.name === 'AssertionError' || error.message.endsWith('user_name')) {
-        throw new Error('That username is already taken');
+               throw new Error('That username is already taken');
-      }
+            }
-    });
+         });
-  }
+   }
 
-  /**
+   /**
    * Retrieve a password from a database.
    * @param {User} user the user you want to retrieve the password
    * @returns {Promise}
    */
-  retrieveHash(user) {
+   retrieveHash(user) {
-    return this.database.get(this.queries.retrieveHash, user.username).then((row) => {
+      return this.database.get(this.queries.retrieveHash, user.username).then((row) => {
-      assert(row, 'The user does not exist.');
+         assert(row, 'The user does not exist.');
-      return row.password;
+         return row.password;
-    });
+      });
-  }
+   }
 
-  /**
+   /**
    * Change a user's password in a database.
    * @param {User} user the user you want to create
    * @param {String} password the new password you want to change
    * @returns {Promise}
    */
-  changePassword(user, password) {
+   changePassword(user, password) {
-    return this.database.run(this.queries.change, [password, user.username]);
+      return this.database.run(this.queries.change, [password, user.username]);
-  }
+   }
-
 }
 
 module.exports = UserRepository;

seasoned_api/src/user/userSecurity.js

@@ -2,75 +2,74 @@ const bcrypt = require('bcrypt-nodejs');
 const UserRepository = require('src/user/userRepository');
 
 class UserSecurity {
+   constructor(database) {
+      this.userRepository = new UserRepository(database);
+   }
 
-  constructor(database) {
+   /**
-    this.userRepository = new UserRepository(database);
-  }
-
-  /**
    * Create a new user in PlanFlix.
    * @param {User} user the new user you want to create
    * @param {String} clearPassword a password of the user
    * @returns {Promise}
    */
-  createNewUser(user, clearPassword) {
+   createNewUser(user, clearPassword) {
-    if (user.username.trim() === '') {
+      if (user.username.trim() === '') {
-      throw new Error('The username is empty.');
+         throw new Error('The username is empty.');
-    } else if (user.email.trim() === '') {
+      } else if (user.email.trim() === '') {
-      throw new Error('The email is empty.');
+         throw new Error('The email is empty.');
-    } else if (clearPassword.trim() === '') {
+      } else if (clearPassword.trim() === '') {
-      throw new Error('The password is empty.');
+         throw new Error('The password is empty.');
-    } else {
+      } else {
-      return Promise.resolve()
+         return Promise.resolve()
-      .then(() => this.userRepository.create(user))
+            .then(() => this.userRepository.create(user))
-      .then(() => UserSecurity.hashPassword(clearPassword))
+            .then(() => UserSecurity.hashPassword(clearPassword))
-      .then(hash => this.userRepository.changePassword(user, hash));
+            .then(hash => this.userRepository.changePassword(user, hash));
-    }
+      }
-  }
+   }
 
-  /**
+   /**
    * Login into PlanFlix.
    * @param {User} user the user you want to login
    * @param {String} clearPassword the user's password
    * @returns {Promise}
    */
-  login(user, clearPassword) {
+   login(user, clearPassword) {
-    return Promise.resolve()
+      return Promise.resolve()
-      .then(() => this.userRepository.retrieveHash(user))
+         .then(() => this.userRepository.retrieveHash(user))
-      .then(hash => UserSecurity.compareHashes(hash, clearPassword))
+         .then(hash => UserSecurity.compareHashes(hash, clearPassword))
-      .catch(() => { throw new Error('Wrong username or password.'); });
+         .catch(() => { throw new Error('Wrong username or password.'); });
-  }
+   }
 
-  /**
+   /**
    * Compare between a password and a hash password from database.
    * @param {String} hash the hash password from database
    * @param {String} clearPassword the user's password
    * @returns {Promise}
    */
-  static compareHashes(hash, clearPassword) {
+   static compareHashes(hash, clearPassword) {
-    return new Promise((resolve, reject) => {
+      return new Promise((resolve, reject) => {
-      bcrypt.compare(clearPassword, hash, (error, matches) => {
+         bcrypt.compare(clearPassword, hash, (error, matches) => {
-        if (matches === true) {
+            if (matches === true) {
-          resolve();
+               resolve();
-        } else {
+            } else {
-          reject();
+               reject();
-        }
+            }
+         });
       });
-    });
+   }
-  }
 
-  /**
+   /**
    * Hashes a password.
    * @param {String} clearPassword the user's password
    * @returns {Promise}
    */
-  static hashPassword(clearPassword) {
+   static hashPassword(clearPassword) {
-    return new Promise((resolve) => {
+      return new Promise((resolve) => {
-      bcrypt.hash(clearPassword, null, null, (error, hash) => {
+         bcrypt.hash(clearPassword, null, null, (error, hash) => {
-        resolve(hash);
+            resolve(hash);
+         });
       });
-    });
+   }
-  }
 }
 
 module.exports = UserSecurity;