diff --git a/src/app.js b/src/app.js
index f9e035a..cfac678 100644
--- a/src/app.js
+++ b/src/app.js
@@ -10,7 +10,8 @@ import {User} from './models/user/user';
 init();
 async function init() {
     Logger.SetLevel(Logger.VERBOSE_LOGS);
-    
+    Logger.SetDialect('SQLITE');
+
     await Config.load();
     await Database.init();
     await Database.testConnection();
diff --git a/src/controllers/loginController.js b/src/controllers/loginController.js
index 434d448..699a54e 100644
--- a/src/controllers/loginController.js
+++ b/src/controllers/loginController.js
@@ -27,9 +27,11 @@ export class LoginController extends ControllerHandler {
         if (!username /*If they're loging in with email*/) {
             user = await Database.users.getUser('email', email);
             if (user == -1) errors.addError(422, 'Unprocessable entity', 'There is no user with that email');
+            username = user.username;
         } else {
             user = await Database.users.getUser('username', username);
             if (user == -1) errors.addError(422, 'Unprocessable entity', 'There is no user with that username');
+            email = user.email;
         }
 
         if (errors.count() > 0) {
@@ -48,7 +50,20 @@ export class LoginController extends ControllerHandler {
             return;
         }
 
-        res.end('Welcome')
+        let response = new API.user(res, user.id, username, email, new Date(parseInt(user.lastupdated)).toLocaleString());
+
+        let token = await Database.auth.getTokenByID(user.id);
+        
+        if (token == -1) {
+            let encryptedPass = await User.Password.gen(password);
+            password = null; // Cleaning password from memory
+            let status = response.getStatus;
+            token = User.Token.gen(status, user.id, encryptedPass);
+            Database.auth.newToken(user.id, token, encryptedPass);
+        } 
+        response.Token = token.token;
+        
+        response.endpoint();
         next();
     }
 }
diff --git a/src/controllers/routes/router.js b/src/controllers/routes/router.js
index 95f1e41..2774f76 100644
--- a/src/controllers/routes/router.js
+++ b/src/controllers/routes/router.js
@@ -14,8 +14,8 @@ export class Router {
 
         app.get('/', [MiddleWare.RateLimits.request, Router.frontPage]);
         
-        app.get('/user/:id', [MiddleWare.RateLimits.request]);
-        app.delete('/user/:id', [MiddleWare.RateLimits.request]);
+        // app.get('/user/:id', [MiddleWare.RateLimits.request]);
+        // app.delete('/user/:id', [MiddleWare.RateLimits.request]);
         app.post('/user', [MiddleWare.RateLimits.request, Controllers.UserController.newUser]);
         
         app.post('/login', [MiddleWare.RateLimits.request, Controllers.LoginController.authenticate])
diff --git a/src/controllers/userController.js b/src/controllers/userController.js
index b9c90bf..49ac008 100644
--- a/src/controllers/userController.js
+++ b/src/controllers/userController.js
@@ -24,8 +24,8 @@ export class UserController extends ControllerHandler {
         if (!UserController.isPasswordValid(password)) errors.addError(422, 'Unprocessaable entity', 'Invalid password has spaces');
         if (password.length < 7) errors.addError(422, 'Unprocessaable entity', 'Invalid password less than 7 charicters');
 
-        if (await Database.users.getID('username', username) != -1) errors.addError(422, 'Unprocessable entity', 'A user with that username allready exists');
-        if (await Database.users.getID('email', email) != -1) errors.addError(422, 'Unprocessable entity', 'A user with that email allready exists');
+        if (await Database.users.getUser('username', username) != -1) errors.addError(422, 'Unprocessable entity', 'A user with that username allready exists');
+        if (await Database.users.getUser('email', email) != -1) errors.addError(422, 'Unprocessable entity', 'A user with that email allready exists');
 
         if (errors.count() > 0) {
             errors.endpoint();
@@ -35,16 +35,14 @@ export class UserController extends ControllerHandler {
         
         let response = new API.user(res, id, username, email, new Date().toLocaleString());
 
-
         let encryptedPass = await User.Password.gen(password);
         password = null; // Cleaning password from memory
 
-        console.log(encryptedPass);
-
         let status = response.getStatus;
         
         let id = new Date().getTime();
         let token = await User.Token.gen(status, id, encryptedPass);
+        await Database.auth.newToken(id, token, encryptedPass);
         response.Token = token;
 
         let user = new User(id, username, encryptedPass, email, ip, 1234);
diff --git a/src/models/database/sqlite/database.sqlite b/src/models/database/sqlite/database.sqlite
index 1365933..786de92 100644
Binary files a/src/models/database/sqlite/database.sqlite and b/src/models/database/sqlite/database.sqlite differ
diff --git a/src/models/database/tokens.js b/src/models/database/tokens.js
index 6ff6468..9166d06 100644
--- a/src/models/database/tokens.js
+++ b/src/models/database/tokens.js
@@ -23,23 +23,66 @@ export class TokenTools extends BaseDatabase {
         }
     }
 
+    static async delete(id) {
+        let Auth = BaseDatabase.Auth;
+
+        try {
+            await Auth.destroy({where: {id: id}});
+            return 1;
+        } catch (e) {
+            Logger.error(`An error occured while deleting id ${id}: ${e}`);
+            return -1;
+        }
+    }
+
     static async getTokenByID(id) {
         let Auth = BaseDatabase.Auth;
 
+        try {
+            let auth = await Auth.findOne({where: {id: id}});
+            if (auth == null) return -1;
+            return auth;
+        } catch (e) {
+            Logger.error(`An error occured while querying for id ${id}: ${e}`);
+            return -1;
+        }
     }
 
     static async getIDByToken(token) {
         let Auth = BaseDatabase.Auth;
 
+        try {
+            let auth = await Auth.findOne({where: {token: token}});
+            if (auth == null) return -1;
+            return auth;
+        } catch (e) {
+            Logger.error(`An error occured while querying for token ${token}: ${e}`);
+            return -1;
+        }
     }
 
     static async getTokenByPassHash(hash) {
         let Auth = BaseDatabase.Auth;
 
+        try {
+            let auth = await Auth.findOne({where: {passhash: hash}});
+            if (auth == null) return -1;
+            return auth;
+        } catch (e) {
+            Logger.error(`An error occured while querying for hash ${hash}: ${e}`);
+            return -1;
+        }
     }
 
     static async updateToken(id, newToken) {
         let Auth = BaseDatabase.Auth;
 
+        try {
+            await Auth.update({token: newToken}, {where: {id: id}});
+            return 1;
+        } catch (e) {
+            Logger.error(`An error occured while updating for id ${id}: ${e}`);
+            return -1;
+        }
     }
 }
diff --git a/src/models/logger.js b/src/models/logger.js
index e147b53..60b4d29 100644
--- a/src/models/logger.js
+++ b/src/models/logger.js
@@ -1,11 +1,17 @@
 const colours = require('colors/safe');
 
 let LogLevel = 1;
+let Dialect = 'SQLITE';
+
 export class Logger {
     static SetLevel(level) {
         LogLevel = level;
     }
 
+    static SetDialect(dialect) {
+        Dialect = dialect;
+    }
+
     static get VERBOSE_LOGS() {return 0;}
     static get DEBUG_LOGS() {return 1;}
     static get INFO_LOGS() {return 2;}
@@ -15,7 +21,7 @@ export class Logger {
         if (LogLevel > 0) return; 
         let d = new Date();
         console.log('[' + d.toLocaleString() + '] [' 
-            + colours.magenta('SQLITE') + '] ' + message);
+            + colours.magenta(Dialect) + '] ' + message);
     }
 
     static middleware(message) {