serverpreconfigured 2.1.9 → 2.2.1

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/logs/logs.d.ts

@@ -0,0 +1,25 @@
+import { Request } from 'express';
+export declare const BASE_LOG_PATH = "./logs";
+export declare enum LogSeverity {
+    danger = "danger",
+    servere = "severe",
+    moderate = "moderate",
+    info = "info"
+}
+export interface SaveLogOptions {
+    userId?: number;
+    data: string;
+    severity: LogSeverity;
+    penTestSuspcion?: boolean;
+    req?: Request;
+    ip?: string;
+    url?: string;
+}
+export declare function saveInternalErrorLog(req: Request, error: any, options?: {
+    penTestSuspcion?: boolean;
+    severity?: LogSeverity;
+}): Promise<void>;
+export declare function saveLog(options: SaveLogOptions): {
+    fileName: string;
+    basePath: string;
+};

package/dist/logs/logs.js

@@ -0,0 +1,109 @@
+"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 });
+exports.saveLog = exports.saveInternalErrorLog = exports.LogSeverity = exports.BASE_LOG_PATH = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.BASE_LOG_PATH = './logs';
+var LogSeverity;
+(function (LogSeverity) {
+    LogSeverity["danger"] = "danger";
+    LogSeverity["servere"] = "severe";
+    LogSeverity["moderate"] = "moderate";
+    LogSeverity["info"] = "info";
+})(LogSeverity = exports.LogSeverity || (exports.LogSeverity = {}));
+function stringfyError(err) {
+    const type = typeof (err);
+    if (type !== 'object')
+        return err.toString();
+    let ret = {};
+    for (let key of Object.keys(err)) {
+        let value = err[key];
+        ret[key] = typeof (value) == 'object' ? 'Is Object' : value.toString();
+    }
+    let retData = "";
+    try {
+        retData = JSON.stringify(ret);
+    }
+    catch (e) {
+        retData = "error on stringfy error data";
+    }
+    return retData;
+}
+function saveInternalErrorLog(req, error, options) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const ip = req.ip;
+            const url = req.url;
+            //@ts-ignore
+            const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+            let errorString = stringfyError(error);
+            saveLog({
+                ip: ip,
+                url: url,
+                userId: userId,
+                data: errorString,
+                severity: (options === null || options === void 0 ? void 0 : options.severity) || LogSeverity.info,
+                penTestSuspcion: options === null || options === void 0 ? void 0 : options.penTestSuspcion,
+            });
+        }
+        catch (e) {
+            console.log("Error ON Save Log", e);
+        }
+    });
+}
+exports.saveInternalErrorLog = saveInternalErrorLog;
+function saveLog(options) {
+    if (!fs_1.default.existsSync(exports.BASE_LOG_PATH)) {
+        fs_1.default.mkdirSync(exports.BASE_LOG_PATH);
+    }
+    let basePath = exports.BASE_LOG_PATH;
+    if (options.userId) {
+        basePath = path_1.default.join(basePath, options.userId.toString());
+    }
+    else {
+        basePath = path_1.default.join(basePath, "unlogged");
+    }
+    if (!fs_1.default.existsSync(basePath)) {
+        fs_1.default.mkdirSync(basePath);
+    }
+    let fileName = path_1.default.join(basePath, `${getDateString(new Date())}.csv`);
+    let data = "";
+    if (fs_1.default.existsSync(fileName)) {
+        data = fs_1.default.readFileSync(fileName).toString() + "\n";
+    }
+    if (!data) {
+        data = 'Data;Severidade;Usuário;Dados;IP;URL;Supeita de Ataque\n';
+    }
+    data += `${new Date()};${options.severity};${options.userId || "Deslogado"};${options.data};${options.ip || "Não Informado"};${options.url || "Não Informado"};${options.penTestSuspcion ? "SIM" : "NÃO"}`;
+    fs_1.default.writeFileSync(fileName, data);
+    return {
+        fileName,
+        basePath,
+    };
+}
+exports.saveLog = saveLog;
+function getDateString(d) {
+    const year = d.getFullYear();
+    const month = zerof(d.getMonth() + 1);
+    const day = zerof(d.getDate());
+    const hour = zerof(d.getHours());
+    return `${year}_${month}_${day}_${hour}`;
+    function zerof(n) {
+        if (n > 9)
+            return n.toString();
+        return `0${n}`;
+    }
+}

package/dist/middlewares/auth.js

@@ -8,20 +8,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
 exports.setUserDataMiddleware = void 0;
 const server_1 = require("../server");
 const server_2 = require("../server");
 const server_3 = require("../server");
-const env_1 = __importDefault(require("../settings/env"));
-const DEBUG = env_1.default.NODE_ENV === 'development' ? true : false;
+const response_1 = require("../utils/response");
 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 user = yield server_1.User.findOne({ where: { email: dealerEmail, is_active: true } });
@@ -32,10 +28,7 @@ function setUserDataMiddleware(req, res, next) {
             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,32 +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);
             yield (0, users_1.updateUserLastAction)(user);
-            return res.status(200).send((0, response_1.JSONResponse)(true, LoginErrorCode.NoError, "Login Ok"));
+            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* () {
@@ -89,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/utils/response.d.ts

@@ -1,2 +1,8 @@
-export declare function JSONResponse(is_ok: boolean, error_code?: number, error_message?: string, data?: any): string;
+import { LogSeverity } from "../logs/logs";
+export declare function JSONResponse(data: any, error?: any): string;
+export interface SendIErrorOptions {
+    severity?: LogSeverity;
+    penTestSuspcion?: boolean;
+}
+export declare function sendIError(req: any, res: any, error?: any, options?: SendIErrorOptions): any;
 export declare function WSResponse(isOK: boolean, message?: string, errorMessage?: string, data?: any): string;

package/dist/utils/response.js

@@ -1,16 +1,21 @@
 "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;
+const logs_1 = require("../logs/logs");
+function JSONResponse(data, error) {
+    return JSON.stringify({
+        data,
+        hasError: Boolean(error),
+        error,
+    });
 }
 exports.JSONResponse = JSONResponse;
+;
+function sendIError(req, res, error, options) {
+    (0, logs_1.saveInternalErrorLog)(req, error, options);
+    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/package.json

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

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/logs/logs.ts

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+import { Request } from 'express';
+export const BASE_LOG_PATH='./logs';
+export enum LogSeverity{
+    danger='danger',
+    servere='severe',
+    moderate='moderate',
+    info='info',
+}
+export interface SaveLogOptions{
+    userId?:number;
+    data:string;
+    severity:LogSeverity;
+    penTestSuspcion?:boolean;
+    req?:Request;
+    ip?:string;
+    url?:string;
+}
+
+
+function stringfyError(err:any):string{
+   const type=typeof(err);
+   if(type!=='object')
+      return err.toString();
+   let ret:any={};
+   for(let key of Object.keys(err)){
+       let value=err[key];
+       ret[key]=typeof(value)=='object'?'Is Object':value.toString();
+   }
+   let retData="";
+   try{
+      retData=JSON.stringify(ret);
+   }catch(e){
+      retData="error on stringfy error data";
+   }
+   return retData;
+}
+export async function saveInternalErrorLog(req:Request,error:any,options?:{penTestSuspcion?:boolean,severity?:LogSeverity}){
+     try{
+         const ip=req.ip;
+         const url=req.url;
+         //@ts-ignore
+         const userId=req.user?.id;
+         let errorString=stringfyError(error);
+         saveLog({
+            ip:ip,
+            url:url,
+            userId:userId,
+            data:errorString,
+            severity:options?.severity||LogSeverity.info,
+            penTestSuspcion:options?.penTestSuspcion,
+         });
+     }catch(e){
+        console.log("Error ON Save Log",e);
+     }
+}
+export function saveLog(options:SaveLogOptions){
+    if(!fs.existsSync(BASE_LOG_PATH)){
+        fs.mkdirSync(BASE_LOG_PATH);
+    }
+    let basePath=BASE_LOG_PATH;
+    if(options.userId){
+         basePath=path.join(basePath,options.userId.toString());
+    }else{
+        basePath=path.join(basePath,"unlogged");
+    } 
+    if(!fs.existsSync(basePath)){
+        fs.mkdirSync(basePath);
+    }
+    let fileName=path.join(basePath,`${getDateString(new Date())}.csv`);
+    let data="";
+    if(fs.existsSync(fileName)){
+        data=fs.readFileSync(fileName).toString()+"\n";
+    }
+    if(!data){
+        data='Data;Severidade;Usuário;Dados;IP;URL;Supeita de Ataque\n';
+    }
+    data+=`${new Date()};${options.severity};${options.userId||"Deslogado"};${options.data};${options.ip||"Não Informado"};${options.url||"Não Informado"};${options.penTestSuspcion?"SIM":"NÃO"}`;
+    fs.writeFileSync(fileName,data);
+    return {
+        fileName,
+        basePath,
+    };
+}
+function getDateString(d:Date){
+  const year=d.getFullYear();
+  const month=zerof(d.getMonth()+1);
+  const day=zerof(d.getDate());
+  const hour=zerof(d.getHours());
+  return `${year}_${month}_${day}_${hour}`;
+  function zerof(n:number){
+       if(n>9)
+         return n.toString();
+       return `0${n}`; 
+  }
+}

package/src/middlewares/auth.ts

@@ -1,12 +1,11 @@
 import { User, updateUserLastAction, userIsLogged } from "../server";
 import { JSONResponse } from "../server";
 import { getUserSessionData } from "../server";
+import { sendIError } from "../utils/response";
 
-import ENV from "../settings/env";
-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 user=await User.findOne({where:{email:dealerEmail,is_active:true}});
@@ -16,9 +15,6 @@ export async function setUserDataMiddleware(req:any,res:any,next:any){
         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/utils/response.ts

@@ -1,11 +1,19 @@
-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);
+import { LogSeverity, saveInternalErrorLog } from "../logs/logs";
+export function JSONResponse(data:any,error?:any){
+    return JSON.stringify({
+        data,
+        hasError:Boolean(error),
+        error,
+    });
+};
+export interface SendIErrorOptions{
+   severity?:LogSeverity,
+   penTestSuspcion?:boolean;
+}
+
+export function sendIError(req:any,res:any,error?:any,options?:SendIErrorOptions){
+     saveInternalErrorLog(req,error,options);
+     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,91 +0,0 @@
-import  express  from "express";
-import { JSONResponse } 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 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);
-         await updateUserLastAction(user)
-         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;