users refactor

Author: hemadnap

src/services/auth.ts

@@ -14,15 +14,13 @@ export const AuthServices = {
             username: username,
             password: password
         };
-
-        return UserServices.addUser(data)
-            .then((user: User) => {
-                const token = new Token(data);
-                return AuthServices.setToken(user, token);
-            })
+        const user = await UserServices.addUser(data)
             .catch((err: Error) => {
                 throw err;
             });
+        const token = new Token(data);
+        token.userId = user.id;
+        return AuthServices.setToken(user, token);
     },
 
     login: async (username: string, password: string): Promise<Token> => {

src/services/user.ts

@@ -7,61 +7,44 @@ import {Translation} from "../translations";
 export const UserServices = {
 
         isTokenValid: async (username: string, token: string): Promise<boolean> => {
-            return DbClient.findOne(Config.database.collections.tokens, {username: username})
-                .then((userToken: Token) => {
-                    const now = moment.utc().format();
-                    if (userToken &&
-                        userToken.hash === token &&
-                        userToken.expiration > now &&
-                        userToken.creation <= now) return true;
-                    else throw new Error(Translation[Config.language].INVALID_TOKEN);
-                });
+            const userToken: Token = await DbClient.findOne(Config.database.collections.tokens, {username: username});
+            const now = moment.utc().format();
+            if (userToken &&
+                userToken.hash === token &&
+                userToken.expiration > now &&
+                userToken.creation <= now) return true;
+            else throw new Error(Translation[Config.language].INVALID_TOKEN);
         },
 
         addUser: async (data: any): Promise<User> => {
             if (_.isNil(data) || _.isNil(data.username) || _.isNil(data.password)) throw new Error(Translation[Config.language].EMPTY_DATA);
-            const user = new User(data);
-            const password = new Password(data);
-            return DbClient.insertOneIfNotExist(Config.database.collections.users, {username: user.username}, user.store())
-                .then(() => {
-                    return DbClient.insertOneIfNotExist(Config.database.collections.passwords, {userId: user.id}, password)
-                        .then(() => {
-                            return user;
-                        });
-                });
+            let user: User = new User(data);
+            user = new User(await DbClient.insertOneIfNotExist(Config.database.collections.users, {username: user.username}, user.store()));
+            const password: Password = new Password(data);
+            password.userId = user.id;
+            await DbClient.insertOneIfNotExist(Config.database.collections.passwords, {userId: user.id}, password);
+            return user;
         },
 
-        getUsers: (): Promise<User[]> => {
-            return DbClient.find(Config.database.collections.users)
-                .then((data: any[]) => {
-                    return data.map((userData: any) => {
-                        return new User(userData);
-                    });
+        getUsers: async (): Promise<User[]> => {
+            return (await DbClient.find(Config.database.collections.users))
+                .map((userData: any) => {
+                    return new User(userData);
                 });
         },
 
-        getUser: (username: string): Promise<User> => {
-            return DbClient.findOne(Config.database.collections.users, {username: username})
-                .then((data: any) => {
-                    return new User(data);
-                });
+        getUser: async (username: string): Promise<User> => {
+            return new User((await DbClient.findOne(Config.database.collections.users, {username: username})));
         },
 
-        updateUser: (username: string, update: string): Promise<User> => {
-            return DbClient.findOneAndUpdate(Config.database.collections.users, {username: username}, update)
-                .then((data: any) => {
-                    return new User(data);
-                });
+        updateUser: async (username: string, update: string): Promise<User> => {
+            return new User(await (DbClient.findOneAndUpdate(Config.database.collections.users, {username: username}, update)))
         },
 
-        deleteUser: (username: string): Promise<void> => {
-            return DbClient.findOneAndDelete(Config.database.collections.users, {username: username})
-                .then(() => {
-                    UserServices.deletePassword(username)
-                        .then(() => {
-                            return UserServices.deleteToken(username);
-                        });
-                });
+        deleteUser: async (username: string): Promise<void> => {
+            await DbClient.findOneAndDelete(Config.database.collections.users, {username: username});
+            await UserServices.deletePassword(username);
+            await UserServices.deleteToken(username);
         },
 
         getToken: async (username: string): Promise<Token> => {