serverpreconfigured 2.1.8 → 2.2.0

package/dist/database/models/User.d.ts

@@ -1,8 +1,10 @@
 import { Model } from "sequelize";
 export declare class User extends Model {
+    id: number;
     email: string;
     first_name?: string;
     is_active: boolean;
     password_hash: string;
+    last_action: Date;
     static init(sequelize: any): void;
 }

package/dist/database/models/User.js

@@ -10,6 +10,7 @@ class User extends sequelize_1.Model {
             email: sequelize_2.DataTypes.STRING,
             is_active: sequelize_2.DataTypes.BOOLEAN,
             password_hash: sequelize_2.DataTypes.STRING,
+            last_action: sequelize_2.DataTypes.DATE,
         }, {
             sequelize: sequelize,
             tableName: 'spc_users',

package/dist/expressServer.d.ts

@@ -4,14 +4,16 @@ import { Express } from "express";
 import { Server } from "http";
 export default class ExpressServer {
     app: Express;
-    authBaseUrl: string;
+    authUserBaseUrl: string;
+    registerUserBaseUrl: string;
     usePort: number;
     server?: Server;
     wsAuthBaseUrl: string;
     constructor();
     listen(port?: any): void;
     initModules(): void;
-    initAuthSystem(baseUrl?: string): void;
+    initUserAuthSystem(baseUrl?: string): void;
+    initUserRegisterSystem(baseUrl?: string): void;
     initWSAuthSystem(wsBaseUrl?: string): void;
     getApp(): express.Express;
     getServer(): Server | undefined;

package/dist/expressServer.js

@@ -8,12 +8,14 @@ const sessions_1 = require("./modules/sessions");
 const postreader_1 = require("./modules/postreader");
 const initcors_1 = require("./modules/initcors");
 const env_1 = __importDefault(require("./settings/env"));
-const users_1 = __importDefault(require("./routes/users"));
+const userauth_1 = __importDefault(require("./routes/userauth"));
 const wsauth_1 = require("./routes/wsauth");
+const userresgister_1 = __importDefault(require("./routes/userresgister"));
 class ExpressServer {
     constructor() {
-        this.authBaseUrl = "";
+        this.authUserBaseUrl = "";
         this.wsAuthBaseUrl = "";
+        this.registerUserBaseUrl = "";
         this.usePort = env_1.default.PORT;
         this.app = (0, express_1.default)();
         this.initModules();
@@ -28,9 +30,13 @@ class ExpressServer {
         (0, postreader_1.initPostReader)(this.app);
         (0, initcors_1.initCors)(this.app);
     }
-    initAuthSystem(baseUrl = '/user') {
-        this.authBaseUrl = baseUrl;
-        this.app.use(this.authBaseUrl, users_1.default);
+    initUserAuthSystem(baseUrl = '/user') {
+        this.authUserBaseUrl = baseUrl;
+        this.app.use(this.authUserBaseUrl, userauth_1.default);
+    }
+    initUserRegisterSystem(baseUrl = '/userregister') {
+        this.registerUserBaseUrl = baseUrl;
+        this.app.use(this.registerUserBaseUrl, userresgister_1.default);
     }
     initWSAuthSystem(wsBaseUrl = '/ws') {
         this.wsAuthBaseUrl = wsBaseUrl;

package/dist/middlewares/auth.js

@@ -16,24 +16,24 @@ exports.setUserDataMiddleware = void 0;
 const server_1 = require("../server");
 const server_2 = require("../server");
 const server_3 = require("../server");
-const server_4 = require("../server");
 const env_1 = __importDefault(require("../settings/env"));
+const response_1 = require("../utils/response");
 const DEBUG = env_1.default.NODE_ENV === 'development' ? true : false;
 function setUserDataMiddleware(req, res, next) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!(0, server_1.userIsLogged)(req))
-            return res.status(401).send((0, server_2.JSONResponse)(false, undefined, "User Must Be Logged"));
+            return res.status(401).send((0, server_2.JSONResponse)({}, "User Must Be Logged"));
         try {
             const dealerEmail = (0, server_3.getUserSessionData)(req);
-            const dealerId = yield (0, server_4.getUserIdByUserEmail)(dealerEmail);
-            req.user = { email: dealerEmail, id: dealerId };
+            const user = yield server_1.User.findOne({ where: { email: dealerEmail, is_active: true } });
+            if (!user)
+                throw "Unknown user";
+            req.user = { email: dealerEmail, id: user.id };
+            yield (0, server_1.updateUserLastAction)(user);
             next();
         }
         catch (e) {
-            let more = null;
-            if (DEBUG)
-                more = e;
-            return res.status(500).send((0, server_2.JSONResponse)(false, undefined, "Get dealer data error", more));
+            return (0, response_1.sendIError)(req, res, e);
         }
     });
 }

package/dist/routes/userauth.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/userauth.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const response_1 = require("../utils/response");
+const auth_1 = require("../auth/auth");
+const meta_sanitizer_1 = __importDefault(require("meta-sanitizer"));
+const users_1 = require("../users/users");
+const auth_2 = require("../middlewares/auth");
+const auth_3 = require("../auth/auth");
+const auth_4 = require("../auth/auth");
+const server_1 = require("../server");
+const router = express_1.default.Router();
+router.post('/logout', (req, res) => {
+    let is_ok = false;
+    if ((0, auth_1.userIsLogged)(req)) {
+        (0, auth_4.logoutUser)(req);
+        is_ok = true;
+    }
+    res.send((0, response_1.JSONResponse)("OK"));
+});
+router.post('/login', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    let email = "";
+    let password = "";
+    try {
+        email = meta_sanitizer_1.default.sanitizeEmail(req.body.email);
+        password = meta_sanitizer_1.default.queryProtector(req.body.password);
+    }
+    catch (e) {
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Must have 'email' and 'password' params"));
+    }
+    if (password == "" || email == "")
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Must have 'email' and 'password' params"));
+    email = email.toLocaleLowerCase();
+    try {
+        const checkPass = yield (0, users_1.checkUserPassword)(email, password);
+        if (checkPass) {
+            const user = yield server_1.User.findOne({ where: { email: email } });
+            if (!user)
+                throw "Dont find User";
+            if (!user.is_active) {
+                return res.status(403).send((0, response_1.JSONResponse)({}, "User deleted"));
+            }
+            (0, auth_3.setUserLogged)(req, email);
+            yield (0, users_1.updateUserLastAction)(user);
+            return res.status(200).send((0, response_1.JSONResponse)("Login Ok"));
+        }
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Invalid Password"));
+    }
+    catch (e) {
+        return (0, response_1.sendIError)(req, res, e);
+    }
+}));
+router.post('/getuser', auth_2.setUserDataMiddleware, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    res.send((0, response_1.JSONResponse)({}, { email: req.user.email, id: req.user.id }));
+}));
+exports.default = router;

package/dist/routes/userresgister.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/userresgister.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const email_1 = require("../utils/validators/email");
+const server_1 = require("../server");
+const server_2 = require("../server");
+const response_1 = require("../utils/response");
+const meta_sanitizer_1 = __importDefault(require("meta-sanitizer"));
+const router = (0, express_1.Router)();
+router.post('/register', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let email = meta_sanitizer_1.default.sanitizeEmail(req.body.email || '');
+        let password = meta_sanitizer_1.default.queryProtector(req.body.password || '');
+        let name = meta_sanitizer_1.default.SanitizerEngine(req.body.name || '', true, false, [' ']).sanitizedData;
+        if (email == "" || password == "" || name == "")
+            return res.send((0, server_2.JSONResponse)({}, "Invalid params"));
+        email = email.toLocaleLowerCase();
+        if (!(0, email_1.checkEmail)(email)) {
+            return res.status(403).send((0, server_2.JSONResponse)({}, "Invalid Email"));
+        }
+        yield (0, server_1.createUser)({ first_name: name, email: email, password_string: password });
+        return res.send((0, server_2.JSONResponse)("REGISTER OK"));
+    }
+    catch (e) {
+        if (e === "User exist")
+            return res.send((0, server_2.JSONResponse)({}, "User Exist"));
+        return (0, response_1.sendIError)(req, res, e);
+    }
+}));
+exports.default = router;

package/dist/routes/users.js

@@ -19,25 +19,10 @@ const meta_sanitizer_1 = __importDefault(require("meta-sanitizer"));
 const users_1 = require("../users/users");
 const users_2 = require("../users/users");
 const auth_2 = require("../middlewares/auth");
-const env_1 = __importDefault(require("../settings/env"));
 const auth_3 = require("../auth/auth");
 const auth_4 = require("../auth/auth");
 const server_1 = require("../server");
-const DEBUG = env_1.default.NODE_ENV === 'development' ? true : false;
-var LoginErrorCode;
-(function (LoginErrorCode) {
-    LoginErrorCode[LoginErrorCode["NoError"] = 0] = "NoError";
-    LoginErrorCode[LoginErrorCode["InvalidParams"] = 1] = "InvalidParams";
-    LoginErrorCode[LoginErrorCode["InvalidPassword"] = 2] = "InvalidPassword";
-    LoginErrorCode[LoginErrorCode["InternalError"] = 3] = "InternalError";
-})(LoginErrorCode || (LoginErrorCode = {}));
-var RegisterUserErrorCode;
-(function (RegisterUserErrorCode) {
-    RegisterUserErrorCode[RegisterUserErrorCode["NoError"] = 0] = "NoError";
-    RegisterUserErrorCode[RegisterUserErrorCode["InvalidParams"] = 1] = "InvalidParams";
-    RegisterUserErrorCode[RegisterUserErrorCode["UserExist"] = 2] = "UserExist";
-    RegisterUserErrorCode[RegisterUserErrorCode["InternalError"] = 3] = "InternalError";
-})(RegisterUserErrorCode || (RegisterUserErrorCode = {}));
+const email_1 = require("../utils/validators/email");
 const router = express_1.default.Router();
 router.post('/logout', (req, res) => {
     let is_ok = false;
@@ -45,7 +30,7 @@ router.post('/logout', (req, res) => {
         (0, auth_4.logoutUser)(req);
         is_ok = true;
     }
-    res.send((0, response_1.JSONResponse)(is_ok, 0, is_ok ? "" : "User Must be logged", {}));
+    res.send((0, response_1.JSONResponse)("OK"));
 });
 router.post('/login', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
     let email = "";
@@ -55,31 +40,28 @@ router.post('/login', (req, res) => __awaiter(void 0, void 0, void 0, function*
         password = meta_sanitizer_1.default.queryProtector(req.body.password);
     }
     catch (e) {
-        return res.status(403).send((0, response_1.JSONResponse)(false, LoginErrorCode.InvalidParams, "Must have 'email' and 'password' params"));
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Must have 'email' and 'password' params"));
     }
     if (password == "" || email == "")
-        return res.status(403).send((0, response_1.JSONResponse)(false, LoginErrorCode.InvalidParams, "Must have 'email' and 'password' params"));
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Must have 'email' and 'password' params"));
     email = email.toLocaleLowerCase();
     try {
         const checkPass = yield (0, users_1.checkUserPassword)(email, password);
         if (checkPass) {
             const user = yield server_1.User.findOne({ where: { email: email } });
-            if (!user) {
-                return res.status(500).send((0, response_1.JSONResponse)(false, 0, "I_E"));
-            }
+            if (!user)
+                throw "Dont find User";
             if (!user.is_active) {
-                return res.status(400).send((0, response_1.JSONResponse)(false, 0, "User deleted"));
+                return res.status(403).send((0, response_1.JSONResponse)({}, "User deleted"));
             }
             (0, auth_3.setUserLogged)(req, email);
-            return res.status(200).send((0, response_1.JSONResponse)(true, LoginErrorCode.NoError, "Login Ok"));
+            yield (0, users_1.updateUserLastAction)(user);
+            return res.status(200).send((0, response_1.JSONResponse)("Login Ok"));
         }
-        return res.status(403).send((0, response_1.JSONResponse)(false, LoginErrorCode.InvalidPassword, "Invalid Password"));
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Invalid Password"));
     }
     catch (e) {
-        let more = null;
-        if (DEBUG)
-            more = e;
-        return res.status(500).send((0, response_1.JSONResponse)(false, LoginErrorCode.InternalError, "I-Error", more));
+        return (0, response_1.sendIError)(req, res, e);
     }
 }));
 router.post('/register', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
@@ -88,18 +70,21 @@ router.post('/register', (req, res) => __awaiter(void 0, void 0, void 0, functio
         let password = meta_sanitizer_1.default.queryProtector(req.body.password || '');
         let name = meta_sanitizer_1.default.SanitizerEngine(req.body.name || '', true, false, [' ']).sanitizedData;
         if (email == "" || password == "" || name == "")
-            return res.send((0, response_1.JSONResponse)(false, RegisterUserErrorCode.InvalidParams, "Invalid params"));
+            return res.send((0, response_1.JSONResponse)({}, "Invalid params"));
         email = email.toLocaleLowerCase();
+        if (!(0, email_1.checkEmail)(email)) {
+            return res.status(403).send((0, response_1.JSONResponse)({}, "Invalid Email"));
+        }
         yield (0, users_2.createUser)({ first_name: name, email: email, password_string: password });
-        return res.send((0, response_1.JSONResponse)(true, RegisterUserErrorCode.NoError, "", "REGISTER OK"));
+        return res.send((0, response_1.JSONResponse)("REGISTER OK"));
     }
     catch (e) {
         if (e === "User exist")
-            return res.send((0, response_1.JSONResponse)(false, RegisterUserErrorCode.UserExist, "User Exist"));
-        return res.send((0, response_1.JSONResponse)(false, RegisterUserErrorCode.InternalError, "I-Error"));
+            return res.send((0, response_1.JSONResponse)({}, "User Exist"));
+        return (0, response_1.sendIError)(req, res, e);
     }
 }));
 router.post('/getuser', auth_2.setUserDataMiddleware, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
-    res.send((0, response_1.JSONResponse)(true, 0, "", { email: req.user.email, id: req.user.id }));
+    res.send((0, response_1.JSONResponse)({}, { email: req.user.email, id: req.user.id }));
 }));
 exports.default = router;

package/dist/routes/wsauth.js

@@ -16,30 +16,18 @@ exports.router = void 0;
 const express_1 = __importDefault(require("express"));
 const response_1 = require("../utils/response");
 const wsauth_1 = require("../wsauth/wsauth");
-const env_1 = __importDefault(require("../settings/env"));
 const auth_1 = require("../middlewares/auth");
 exports.router = express_1.default.Router();
-const DEBUG = env_1.default.NODE_ENV === 'development' ? true : false;
-var GenerateTokenError;
-(function (GenerateTokenError) {
-    GenerateTokenError[GenerateTokenError["UserMustBeLogged"] = 1] = "UserMustBeLogged";
-    GenerateTokenError[GenerateTokenError["GetUserError"] = 2] = "GetUserError";
-    GenerateTokenError[GenerateTokenError["InternalError"] = 3] = "InternalError";
-})(GenerateTokenError || (GenerateTokenError = {}));
-;
 exports.router.post('/gettoken', auth_1.setUserDataMiddleware, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         let userId = req.user.id;
         let n = yield (0, wsauth_1.setWSAuthDataNewToken)(userId);
-        return res.send((0, response_1.JSONResponse)(true, 0, "", { token: n.dataValues.token,
+        return res.send((0, response_1.JSONResponse)({ token: n.dataValues.token,
             expiration: n.dataValues.expiration,
             userId: userId
         }));
     }
     catch (e) {
-        let more = null;
-        if (DEBUG)
-            more = e;
-        return res.status(500).send((0, response_1.JSONResponse)(false, GenerateTokenError.InternalError, "I-Error", more));
+        return (0, response_1.sendIError)(req, res, e);
     }
 }));

package/dist/users/users.d.ts

@@ -1,5 +1,6 @@
 import { User } from "./../database/models/User";
 import { UserCreateInterface } from "./types";
+export declare function updateUserLastAction(user: User): Promise<User>;
 export declare function getUserSessionData(req: any): string;
 export declare function getUserById(id: Number): Promise<any>;
 export declare function getUserByEmail(email: string): Promise<any>;

package/dist/users/users.js

@@ -9,13 +9,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkUserPassword = exports.changeUserPassword = exports.createUser = exports.isUserExist = exports.deleteUserById = exports.getUserIdByUserEmail = exports.getUserByEmail = exports.getUserById = exports.getUserSessionData = void 0;
+exports.checkUserPassword = exports.changeUserPassword = exports.createUser = exports.isUserExist = exports.deleteUserById = exports.getUserIdByUserEmail = exports.getUserByEmail = exports.getUserById = exports.getUserSessionData = exports.updateUserLastAction = void 0;
 const database_1 = require("./../database/database");
 const User_1 = require("./../database/models/User");
 const password_1 = require("./password");
 const config_1 = require("../auth/config");
 const secureget_1 = require("../sessions/secureget");
 User_1.User.init(database_1.dataBase);
+function updateUserLastAction(user) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            user.last_action = new Date();
+            yield user.save();
+            return user;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.updateUserLastAction = updateUserLastAction;
 function getUserSessionData(req) {
     return (0, secureget_1.getSessionValue)(req, config_1.SESSION_LOGGED_DATA);
 }

package/dist/utils/response.d.ts

@@ -1,2 +1,3 @@
-export declare function JSONResponse(is_ok: boolean, error_code?: number, error_message?: string, data?: any): string;
+export declare function JSONResponse(data: any, error?: any): string;
+export declare function sendIError(req: any, res: any, error?: any): any;
 export declare function WSResponse(isOK: boolean, message?: string, errorMessage?: string, data?: any): string;

package/dist/utils/response.js

@@ -1,16 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WSResponse = exports.JSONResponse = void 0;
-function JSONResponse(is_ok, error_code = 0, error_message = '', data = {}) {
-    const ret_data = {
-        is_ok: is_ok,
-        error_code: error_code,
-        error_message: error_message,
-        data: data,
-    };
-    return JSON.stringify(ret_data);
+exports.WSResponse = exports.sendIError = exports.JSONResponse = void 0;
+function JSONResponse(data, error) {
+    return JSON.stringify({
+        data,
+        hasError: Boolean(error),
+        error,
+    });
 }
 exports.JSONResponse = JSONResponse;
+;
+function sendIError(req, res, error) {
+    console.log(error);
+    return res.status(500).send(JSONResponse("", "I-E"));
+}
+exports.sendIError = sendIError;
 function WSResponse(isOK, message = '', errorMessage = "", data = {}) {
     return JSON.stringify({
         is_ok: isOK,

package/dist/utils/validators/email.d.ts

@@ -0,0 +1 @@
+export declare function checkEmail(email: string): boolean;

package/dist/utils/validators/email.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEmail = void 0;
+function checkEmail(email) {
+    const atIndex = email.indexOf("@");
+    if (atIndex < 1)
+        return false;
+    const after = email.slice(atIndex + 1);
+    if (after.length < 3)
+        return false;
+    if (after.indexOf('@') >= 0)
+        return false;
+    const periodIndex = after.indexOf('.');
+    if (periodIndex < 1 || periodIndex >= after.length - 1)
+        return false;
+    return true;
+}
+exports.checkEmail = checkEmail;

package/migrations/20231109185205-serverpreconfigured-user-last-action.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports = {
+  async up (queryInterface, Sequelize) {
+    return await queryInterface.addColumn('spc_users','last_action',{
+      type:Sequelize.DATE,
+      allowNull:false,
+      defaultValue:'2016-01-01T00:00:00-00:00'
+    }
+   );
+  },
+
+  async down (queryInterface, Sequelize) {
+    return await queryInterface.removeColumn('spc_users','last_action');
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverpreconfigured",
-  "version": "2.1.8",
+  "version": "2.2.0",
   "description": "\"Pre-configured server with authentication system and database integration\"",
   "main": "dist/server.js",
   "keywords": [

package/src/database/models/User.ts

@@ -2,16 +2,19 @@ import { Model } from "sequelize";
 import { DataTypes } from "sequelize";
 
 export class User extends Model{
+    declare id:number;
     declare email:string;
     declare first_name?:string;
     declare is_active:boolean;
     declare password_hash:string;
+    declare last_action:Date;
     static init(sequelize:any){
         super.init({
             first_name:DataTypes.STRING,
             email:DataTypes.STRING,
             is_active:DataTypes.BOOLEAN,
             password_hash:DataTypes.STRING,
+            last_action:DataTypes.DATE,
         },
         { 
           sequelize:sequelize,  

package/src/expressServer.ts

@@ -4,18 +4,21 @@ import { initSessions } from "./modules/sessions";
 import { initPostReader } from "./modules/postreader";
 import { initCors } from "./modules/initcors";
 import  ENV  from "./settings/env";
-import authRouter from "./routes/users";
+import authUserRouter from "./routes/userauth";
 import { router as wsAuthRoter } from "./routes/wsauth";
 import { Server } from "http";
+import userRegisterRouter from "./routes/userresgister";
 export default class ExpressServer{
     app:Express;
-    authBaseUrl:string;
+    authUserBaseUrl:string;
+    registerUserBaseUrl:string;
     usePort:number;
     server?:Server;
     wsAuthBaseUrl:string;
     constructor(){
-       this.authBaseUrl="";
+       this.authUserBaseUrl="";
        this.wsAuthBaseUrl="";
+       this.registerUserBaseUrl="";
        this.usePort=ENV.PORT;
        this.app=express();
        this.initModules();
@@ -31,9 +34,13 @@ export default class ExpressServer{
       initPostReader(this.app);
       initCors(this.app);
     }
-    initAuthSystem(baseUrl:string='/user'){
-       this.authBaseUrl=baseUrl;
-       this.app.use(this.authBaseUrl,authRouter);
+    initUserAuthSystem(baseUrl:string='/user'){
+       this.authUserBaseUrl=baseUrl;
+       this.app.use(this.authUserBaseUrl,authUserRouter);
+    }
+    initUserRegisterSystem(baseUrl:string='/userregister'){
+        this.registerUserBaseUrl=baseUrl;
+        this.app.use(this.registerUserBaseUrl,userRegisterRouter)
     }
     initWSAuthSystem(wsBaseUrl:string='/ws'){
        this.wsAuthBaseUrl=wsBaseUrl;

package/src/middlewares/auth.ts

@@ -1,21 +1,22 @@
-import { userIsLogged } from "../server";
+import { User, updateUserLastAction, userIsLogged } from "../server";
 import { JSONResponse } from "../server";
 import { getUserSessionData } from "../server";
-import { getUserIdByUserEmail } from "../server";
+
 import ENV from "../settings/env";
+import { sendIError } from "../utils/response";
 const DEBUG=ENV.NODE_ENV==='development'?true:false;
 export async function setUserDataMiddleware(req:any,res:any,next:any){
     if(!userIsLogged(req))
-      return res.status(401).send(JSONResponse(false,undefined,"User Must Be Logged"));
+      return res.status(401).send(JSONResponse({},"User Must Be Logged"));
     try{
         const dealerEmail=getUserSessionData(req);
-        const dealerId=await getUserIdByUserEmail(dealerEmail);
-        req.user={email:dealerEmail,id:dealerId};
+        const user=await User.findOne({where:{email:dealerEmail,is_active:true}});
+        if(!user)
+          throw "Unknown user";
+        req.user={email:dealerEmail,id:user.id};
+        await updateUserLastAction(user);
         next();
      }catch(e){
-       let more=null;
-       if(DEBUG)
-         more=e;  
-       return res.status(500).send(JSONResponse(false,undefined,"Get dealer data error",more));
+       return sendIError(req,res,e);
      }  
 }

package/src/routes/userauth.ts

@@ -0,0 +1,57 @@
+import  express  from "express";
+import { JSONResponse, sendIError } from "../utils/response";
+import { userIsLogged } from "../auth/auth";
+import meta_sanitizer from 'meta-sanitizer';
+import { checkUserPassword, updateUserLastAction } from "../users/users";
+import { createUser } from "../users/users";
+import { setUserDataMiddleware } from "../middlewares/auth";
+import { setUserLogged } from "../auth/auth";
+import { logoutUser } from "../auth/auth";
+import { User } from "../server";
+
+
+const router=express.Router();
+router.post('/logout',(req,res)=>{
+   let is_ok=false;
+   if(userIsLogged(req)){
+       logoutUser(req)
+       is_ok=true;
+   }
+   res.send(JSONResponse("OK"));
+});
+router.post('/login',async (req,res)=>{
+    let email="";
+    let password="";
+    try{
+      email=meta_sanitizer.sanitizeEmail(req.body.email);
+      password=meta_sanitizer.queryProtector(req.body.password);
+    }catch(e){
+      return res.status(403).send(JSONResponse({},"Must have 'email' and 'password' params"))
+    }
+    if(password==""||email=="")
+      return res.status(403).send(JSONResponse({},"Must have 'email' and 'password' params"));
+    email=email.toLocaleLowerCase();
+    try{
+      const checkPass=await checkUserPassword(email,password);
+      if(checkPass){
+         const user:User=await User.findOne({where:{email:email}});
+         if(!user)
+            throw "Dont find User";
+         if(!user.is_active){
+             return res.status(403).send(JSONResponse({},"User deleted"));
+         }
+         setUserLogged(req,email);
+         await updateUserLastAction(user)
+         return res.status(200).send(JSONResponse("Login Ok"));
+      }
+      return res.status(403).send(JSONResponse({},"Invalid Password"));
+    }catch(e){
+      return sendIError(req,res,e);
+    }  
+    
+});
+
+router.post('/getuser',setUserDataMiddleware,async (req:any,res)=>{
+    res.send(JSONResponse({},{email:req.user.email,id:req.user.id}));
+});
+export default router;

package/src/routes/userresgister.ts

@@ -0,0 +1,28 @@
+import { Router } from "express";
+import { checkEmail } from "../utils/validators/email";
+import { createUser } from "../server";
+import { JSONResponse } from "../server";
+import { sendIError } from "../utils/response";
+import meta_sanitizer from "meta-sanitizer";
+const router=Router();
+router.post('/register',async (req,res)=>{
+    try{
+      let email=meta_sanitizer.sanitizeEmail(req.body.email||'');
+      let password=meta_sanitizer.queryProtector(req.body.password||'');
+      let name=meta_sanitizer.SanitizerEngine(req.body.name||'',true,false,[' ']).sanitizedData;
+      if(email=="" || password=="" || name=="")
+        return res.send(JSONResponse({},"Invalid params"));
+      email=email.toLocaleLowerCase();  
+      if(!checkEmail(email)){
+        return res.status(403).send(JSONResponse({},"Invalid Email"));
+      }
+      await createUser({first_name:name,email:email,password_string:password});
+      return res.send(JSONResponse("REGISTER OK"));
+    }catch(e){
+       if(e==="User exist")
+         return res.send(JSONResponse({},"User Exist"));
+       return sendIError(req,res,e); 
+    }
+});
+
+export default router;

package/src/routes/wsauth.ts

@@ -1,27 +1,18 @@
 import  express  from "express";
-import { JSONResponse } from "../utils/response";
+import { JSONResponse, sendIError } from "../utils/response";
 import { setWSAuthDataNewToken } from "../wsauth/wsauth";
-import ENV from "../settings/env";
 import { setUserDataMiddleware } from "../middlewares/auth";
 export const router=express.Router();
-const DEBUG=ENV.NODE_ENV==='development'?true:false;
-enum GenerateTokenError{
-   UserMustBeLogged=1,
-   GetUserError,
-   InternalError,
-};
+
 router.post('/gettoken',setUserDataMiddleware,async (req:any,res:any)=>{
    try{
        let userId:number=req.user.id;
        let n=await setWSAuthDataNewToken(userId);
-       return res.send(JSONResponse(true,0,"",{token:n.dataValues.token,
+       return res.send(JSONResponse({token:n.dataValues.token,
                                                expiration:n.dataValues.expiration,
                                                userId:userId
                                                }));
    }catch(e){
-      let more=null;
-      if(DEBUG)
-         more=e;
-      return res.status(500).send(JSONResponse(false,GenerateTokenError.InternalError,"I-Error",more));
+      return sendIError(req,res,e);
    }
 });

package/src/users/users.ts

@@ -6,6 +6,16 @@ import {SESSION_LOGGED_DATA} from "../auth/config";
 import {getSessionValue} from "../sessions/secureget";
 User.init(dataBase);
 
+export async function updateUserLastAction(user:User){
+     try{
+         user.last_action=new Date();
+         await user.save();
+         return user;
+     }catch(e){
+          throw e;
+     }
+}
+
 export function getUserSessionData(req:any):string{
    return getSessionValue(req,SESSION_LOGGED_DATA);
 }

package/src/utils/response.ts

@@ -1,11 +1,14 @@
-export function JSONResponse(is_ok:boolean,error_code:number=0,error_message:string='',data:any={}){
-    const ret_data={
-        is_ok:is_ok,
-        error_code:error_code,
-        error_message:error_message,
-        data:data,
-    };
-    return JSON.stringify(ret_data);
+export function JSONResponse(data:any,error?:any){
+    return JSON.stringify({
+        data,
+        hasError:Boolean(error),
+        error,
+    });
+};
+
+export function sendIError(req:any,res:any,error?:any){
+     console.log(error);
+     return res.status(500).send(JSONResponse("","I-E"));
 }
 export function WSResponse(isOK:boolean,message:string='',errorMessage:string="",data:any={}):string{
     return JSON.stringify({

package/src/utils/validators/email.ts

@@ -0,0 +1,14 @@
+export function checkEmail(email:string){
+    const atIndex=email.indexOf("@");
+    if(atIndex<1)
+       return false;
+    const after=email.slice(atIndex+1);
+    if(after.length<3)
+      return false;
+    if(after.indexOf('@')>=0)
+      return false;
+    const periodIndex=after.indexOf('.');
+    if(periodIndex<1||periodIndex>=after.length-1)
+       return false;
+    return true;
+}

package/src/routes/users.ts

@@ -1,92 +0,0 @@
-import  express  from "express";
-import { deleteSessionValue ,setSessionValue} from "../sessions/secureset";
-import { SESSION_LOGGED_DATA } from "../auth/config";
-import { JSONResponse } from "../utils/response";
-import { userIsLogged } from "../auth/auth";
-import meta_sanitizer from 'meta-sanitizer';
-import { checkUserPassword } from "../users/users";
-import { createUser } from "../users/users";
-import { setUserDataMiddleware } from "../middlewares/auth";
-import ENV from "../settings/env";
-import { setUserLogged } from "../auth/auth";
-import { logoutUser } from "../auth/auth";
-import { User } from "../server";
-
-const DEBUG=ENV.NODE_ENV==='development'?true:false;
-enum LoginErrorCode{
-    NoError=0,
-    InvalidParams,
-    InvalidPassword,
-    InternalError,
-
-}
-enum RegisterUserErrorCode{
-   NoError=0,
-   InvalidParams,
-   UserExist,
-   InternalError
-}
-const router=express.Router();
-router.post('/logout',(req,res)=>{
-   let is_ok=false;
-   if(userIsLogged(req)){
-       logoutUser(req)
-       is_ok=true;
-   }
-   res.send(JSONResponse(is_ok,0,is_ok?"":"User Must be logged",{}));
-});
-router.post('/login',async (req,res)=>{
-    let email="";
-    let password="";
-    try{
-      email=meta_sanitizer.sanitizeEmail(req.body.email);
-      password=meta_sanitizer.queryProtector(req.body.password);
-    }catch(e){
-      return res.status(403).send(JSONResponse(false,LoginErrorCode.InvalidParams,"Must have 'email' and 'password' params"))
-    }
-    if(password==""||email=="")
-      return res.status(403).send(JSONResponse(false,LoginErrorCode.InvalidParams,"Must have 'email' and 'password' params"));
-    email=email.toLocaleLowerCase();
-    try{
-      const checkPass=await checkUserPassword(email,password);
-      if(checkPass){
-         const user:User=await User.findOne({where:{email:email}});
-         if(!user){
-            return res.status(500).send(JSONResponse(false,0,"I_E"));
-         }
-         if(!user.is_active){
-             return res.status(400).send(JSONResponse(false,0,"User deleted"));
-         }
-         setUserLogged(req,email);
-         return res.status(200).send(JSONResponse(true,LoginErrorCode.NoError,"Login Ok"));
-      }
-      return res.status(403).send(JSONResponse(false,LoginErrorCode.InvalidPassword,"Invalid Password"));
-    }catch(e){
-      let more=null;
-      if(DEBUG)
-        more=e;
-      return res.status(500).send(JSONResponse(false,LoginErrorCode.InternalError,"I-Error",more));
-    }  
-    
-});
-router.post('/register',async (req,res)=>{
-    try{
-      let email=meta_sanitizer.sanitizeEmail(req.body.email||'');
-      let password=meta_sanitizer.queryProtector(req.body.password||'');
-      let name=meta_sanitizer.SanitizerEngine(req.body.name||'',true,false,[' ']).sanitizedData;
-      if(email=="" || password=="" || name=="")
-        return res.send(JSONResponse(false,RegisterUserErrorCode.InvalidParams,"Invalid params"));
-      email=email.toLocaleLowerCase();  
-      await createUser({first_name:name,email:email,password_string:password});
-      return res.send(JSONResponse(true,RegisterUserErrorCode.NoError,"","REGISTER OK"));
-    }catch(e){
-       if(e==="User exist")
-         return res.send(JSONResponse(false,RegisterUserErrorCode.UserExist,"User Exist"));
-       return res.send(JSONResponse(false,RegisterUserErrorCode.InternalError,"I-Error"));  
-    }
-});
-
-router.post('/getuser',setUserDataMiddleware,async (req:any,res)=>{
-    res.send(JSONResponse(true,0,"",{email:req.user.email,id:req.user.id}));
-});
-export default router;