ecrs-auth-core 1.0.74 → 1.0.75

package/dist/auth.controller.js

@@ -33,8 +33,9 @@ let AuthController = class AuthController {
         const user = await this.authService.validateUser(body.email, body.password, clientIp);
         console.log(`🔐 User validation result for ${body.email}: ${user ? 'Success' : 'Failed'}`);
         if (!user) {
-            // Save failed login attempt
+            // Save failed login attempt to both tables
             await this.authService.saveLastLogin({ email: body.email }, clientIp, 'failed', 'Invalid credentials or IP not allowed', additionalData).catch(() => { }); // Ignore errors
+            await this.authService.saveLoginDetailsJson({ email: body.email }, clientIp, 'failed', 'Invalid credentials or IP not allowed', additionalData).catch(() => { }); // Ignore errors
             throw new common_1.UnauthorizedException('Login failed: email or password not matched or IP not allowed');
         }
         const requestedModuleId = Number(body.moduleId);
@@ -50,11 +51,17 @@ let AuthController = class AuthController {
             throw new common_1.UnauthorizedException('You are not authorized to access this module');
         }
         const loginResponse = await this.authService.login(user, requestedModuleId);
-        // Save successful login details with additional client data
+        console.log(`✅ User ${body.email} logged in successfully to module ${requestedModuleId}`);
+        // Save successful login details with additional client data to both tables
         await this.authService.saveLastLogin(user, clientIp, 'success', undefined, {
             ...additionalData,
             moduleId: requestedModuleId,
         }).catch(() => { }); // Ignore errors - don't block login
+        // Save to JSON-based login details table
+        await this.authService.saveLoginDetailsJson(user, clientIp, 'success', undefined, {
+            ...additionalData,
+            moduleId: requestedModuleId,
+        }).catch(() => { }); // Ignore errors - don't block login
         return loginResponse;
     }
     /**

package/dist/auth.service.d.ts

@@ -27,6 +27,7 @@ export declare class AuthService {
     private readonly screenPermissionRepo;
     private readonly ipRestrictionsRepo;
     private readonly userLastLoginRepo;
+    private readonly loginDetailsRepo;
     private readonly employeeWorkProfileRepo;
     private uploadPhotoDir;
     constructor(jwtService: JwtService, options: AuthCoreOptions);
@@ -59,6 +60,30 @@ export declare class AuthService {
         ipAddressName?: string;
         metadata?: Record<string, any>;
     }): Promise<void>;
+    /**
+     * Save login details to JSON-based table with date-wise update
+     * If a record exists for the user on the same date, update it
+     * Otherwise, create a new record
+     */
+    saveLoginDetailsJson(user: User, clientIp: string, loginStatus?: 'success' | 'failed' | 'blocked', failureReason?: string, additionalData?: {
+        browser?: string;
+        deviceType?: string;
+        operatingSystem?: string;
+        userAgent?: string;
+        location?: string;
+        moduleId?: number;
+        ipAddressName?: string;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    /**
+     * Update logout details in JSON-based login details table
+     * Finds the latest login entry for today and updates it with logout_time and session_duration
+     */
+    updateLoginLogoutDetailsJson(userId: number, logoutReason?: string): Promise<void>;
+    /**
+     * Update last login logout time (for tbl_user_last_login table)
+     */
+    updateLastLoginLogout(userId: number, logoutReason?: string): Promise<void>;
     login(user: User, selectedModuleId?: number): Promise<{
         status: boolean;
         message: string;

package/dist/auth.service.js

@@ -67,6 +67,7 @@ let AuthService = class AuthService {
         // Optional repositories
         this.ipRestrictionsRepo = repositories.ipRestrictionsRepo || null;
         this.userLastLoginRepo = repositories.userLastLoginRepo || null;
+        this.loginDetailsRepo = repositories.loginDetailsRepo || null;
         this.employeeWorkProfileRepo = repositories.employeeWorkProfileRepo || null;
     }
     async validateUser(email, password, clientIp) {
@@ -78,13 +79,13 @@ let AuthService = class AuthService {
             return null;
         // console.log(this.ipRestrictionsRepo);
         // Check IP restrictions if provided and repository is available
-        // if (clientIp && this.ipRestrictionsRepo) {
-        //   const ipAllowed = await this.validateIpRestriction(user.id, clientIp);
-        //   if (!ipAllowed) {
-        //     // IP restriction exists but doesn't match - return null to block login
-        //     return null;
-        //   }
-        // }
+        if (clientIp && this.ipRestrictionsRepo) {
+            const ipAllowed = await this.validateIpRestriction(user.id, clientIp);
+            if (!ipAllowed) {
+                // IP restriction exists but doesn't match - return null to block login
+                return null;
+            }
+        }
         return user;
     }
     /**
@@ -180,6 +181,18 @@ let AuthService = class AuthService {
             return;
         }
         try {
+            // Map camelCase keys to snake_case database column names
+            const mappedAdditionalData = {};
+            if (additionalData) {
+                mappedAdditionalData.browser = additionalData.browser;
+                mappedAdditionalData.device_type = additionalData.deviceType;
+                mappedAdditionalData.operating_system = additionalData.operatingSystem;
+                mappedAdditionalData.user_agent = additionalData.userAgent;
+                mappedAdditionalData.location = additionalData.location;
+                mappedAdditionalData.module_id = additionalData.moduleId;
+                mappedAdditionalData.ip_address_name = additionalData.ipAddressName;
+                mappedAdditionalData.metadata = additionalData.metadata;
+            }
             const lastLoginData = {
                 user_id: user.id,
                 email: user.email,
@@ -189,13 +202,20 @@ let AuthService = class AuthService {
                 login_status: loginStatus,
                 failure_reason: failureReason,
                 login_time: new Date(),
-                ...additionalData,
+                ...mappedAdditionalData,
             };
-            // Upsert: Update if exists, insert if not
-            await this.userLastLoginRepo.upsert(lastLoginData, {
-                conflictPaths: ['user_id'],
-                skipUpdateIfNoValuesChanged: true,
+            // First check if a record exists for this user
+            const existingRecord = await this.userLastLoginRepo.findOne({
+                where: { user_id: user.id },
             });
+            if (existingRecord) {
+                // Update existing record
+                await this.userLastLoginRepo.update({ user_id: user.id }, lastLoginData);
+            }
+            else {
+                // Create new record
+                await this.userLastLoginRepo.save(lastLoginData);
+            }
             console.log(`📝 Last login details saved for user ${user.id} (${loginStatus})`);
         }
         catch (error) {
@@ -203,6 +223,168 @@ let AuthService = class AuthService {
             // Don't throw error - this shouldn't block login
         }
     }
+    /**
+     * Save login details to JSON-based table with date-wise update
+     * If a record exists for the user on the same date, update it
+     * Otherwise, create a new record
+     */
+    async saveLoginDetailsJson(user, clientIp, loginStatus = 'success', failureReason, additionalData) {
+        if (!this.loginDetailsRepo) {
+            // Login details tracking not configured
+            return;
+        }
+        try {
+            const today = new Date();
+            today.setHours(0, 0, 0, 0); // Set to start of day
+            // Build login detail data
+            const loginDetailData = {
+                login_time: new Date().toISOString(),
+                status: loginStatus,
+                ip_address: clientIp,
+                browser: additionalData?.browser,
+                device_type: additionalData?.deviceType,
+                operating_system: additionalData?.operatingSystem,
+                location: additionalData?.location,
+                module_id: additionalData?.moduleId,
+                ip_address_name: additionalData?.ipAddressName,
+                failure_reason: failureReason,
+                user_agent: additionalData?.userAgent,
+                metadata: additionalData?.metadata,
+            };
+            // Check if record exists for this user and date
+            const existingRecord = await this.loginDetailsRepo.findOne({
+                where: {
+                    user_id: user.id,
+                    date: today,
+                },
+            });
+            let loginData = [];
+            let successCount = 0;
+            let failedCount = 0;
+            if (existingRecord) {
+                // Update existing record - append to login_data array
+                loginData = existingRecord.login_data || [];
+                successCount = existingRecord.successful_logins || 0;
+                failedCount = existingRecord.failed_logins || 0;
+                // Append new login detail
+                loginData.push(loginDetailData);
+                // Update counters
+                if (loginStatus === 'success') {
+                    successCount++;
+                }
+                else if (loginStatus === 'failed' || loginStatus === 'blocked') {
+                    failedCount++;
+                }
+                await this.loginDetailsRepo.update({ id: existingRecord.id }, {
+                    login_data: loginData,
+                    total_logins: loginData.length,
+                    successful_logins: successCount,
+                    failed_logins: failedCount,
+                    updated_at: new Date(),
+                });
+                console.log(`📝 Login details updated for user ${user.id} on ${today.toDateString()} (${loginStatus})`);
+            }
+            else {
+                // Create new record
+                loginData = [loginDetailData];
+                successCount = loginStatus === 'success' ? 1 : 0;
+                failedCount = loginStatus === 'failed' || loginStatus === 'blocked' ? 1 : 0;
+                const newLoginDetails = this.loginDetailsRepo.create({
+                    user_id: user.id,
+                    date: today,
+                    email: user.email,
+                    first_name: user.firstName,
+                    last_name: user.lastName,
+                    login_data: loginData,
+                    total_logins: 1,
+                    successful_logins: successCount,
+                    failed_logins: failedCount,
+                });
+                await this.loginDetailsRepo.save(newLoginDetails);
+                console.log(`📝 Login details created for user ${user.id} on ${today.toDateString()} (${loginStatus})`);
+            }
+        }
+        catch (error) {
+            console.error('Error saving login details JSON:', error);
+            // Don't throw error - this shouldn't block login
+        }
+    }
+    /**
+     * Update logout details in JSON-based login details table
+     * Finds the latest login entry for today and updates it with logout_time and session_duration
+     */
+    async updateLoginLogoutDetailsJson(userId, logoutReason) {
+        if (!this.loginDetailsRepo) {
+            return;
+        }
+        try {
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+            const record = await this.loginDetailsRepo.findOne({
+                where: {
+                    user_id: userId,
+                    date: today,
+                },
+            });
+            if (!record || !record.login_data || record.login_data.length === 0) {
+                return;
+            }
+            // Update the last login entry with logout time
+            const loginData = [...record.login_data];
+            const lastLoginIndex = loginData.length - 1;
+            const lastLogin = loginData[lastLoginIndex];
+            // Calculate session duration
+            const loginTime = new Date(lastLogin.login_time);
+            const logoutTime = new Date();
+            const sessionDurationMs = logoutTime.getTime() - loginTime.getTime();
+            // Update last login with logout info
+            loginData[lastLoginIndex] = {
+                ...lastLogin,
+                logout_time: logoutTime.toISOString(),
+                session_duration_ms: sessionDurationMs,
+                metadata: {
+                    ...(lastLogin.metadata || {}),
+                    logout_reason: logoutReason,
+                },
+            };
+            await this.loginDetailsRepo.update({ id: record.id }, {
+                login_data: loginData,
+                updated_at: new Date(),
+            });
+            console.log(`🚪 Logout details updated for user ${userId} on ${today.toDateString()}`);
+        }
+        catch (error) {
+            console.error('Error updating logout details:', error);
+            // Don't throw error - this shouldn't block logout
+        }
+    }
+    /**
+     * Update last login logout time (for tbl_user_last_login table)
+     */
+    async updateLastLoginLogout(userId, logoutReason) {
+        if (!this.userLastLoginRepo) {
+            return;
+        }
+        try {
+            const record = await this.userLastLoginRepo.findOne({
+                where: { user_id: userId },
+            });
+            if (!record || !record.login_time) {
+                return;
+            }
+            const logoutTime = new Date();
+            const sessionDurationMs = logoutTime.getTime() - new Date(record.login_time).getTime();
+            await this.userLastLoginRepo.update({ user_id: userId }, {
+                logout_time: logoutTime,
+                session_duration_ms: sessionDurationMs,
+            });
+            console.log(`🚪 Last login logout time updated for user ${userId}`);
+        }
+        catch (error) {
+            console.error('Error updating last login logout time:', error);
+            // Don't throw error - this shouldn't block logout
+        }
+    }
     async login(user, selectedModuleId) {
         const permissionTree = await this.loadPermissions(user.id);
         const role = await this.roleRepo.findOne({ where: { id: user.roleId } });

package/dist/entities/login-details.entity.d.ts

@@ -0,0 +1,34 @@
+export interface LoginDetailData {
+    login_time: string;
+    logout_time?: string;
+    status: 'success' | 'failed' | 'blocked';
+    ip_address: string;
+    browser?: string;
+    device_type?: string;
+    operating_system?: string;
+    location?: string;
+    module_id?: number;
+    ip_address_name?: string;
+    failure_reason?: string;
+    user_agent?: string;
+    session_duration_ms?: number;
+    metadata?: Record<string, any>;
+}
+export declare class LoginDetailsEntity {
+    id: number;
+    user_id: number;
+    date: Date;
+    login_data: LoginDetailData[];
+    email: string;
+    first_name: string;
+    last_name: string;
+    total_logins: number;
+    successful_logins: number;
+    failed_logins: number;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date;
+    created_by: number;
+    updated_by: number;
+    deleted_by: number;
+}

package/dist/entities/login-details.entity.js

@@ -0,0 +1,91 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginDetailsEntity = void 0;
+const typeorm_1 = require("typeorm");
+let LoginDetailsEntity = class LoginDetailsEntity {
+};
+exports.LoginDetailsEntity = LoginDetailsEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)(),
+    __metadata("design:type", Number)
+], LoginDetailsEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: false }),
+    __metadata("design:type", Number)
+], LoginDetailsEntity.prototype, "user_id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'date', nullable: false }),
+    __metadata("design:type", Date)
+], LoginDetailsEntity.prototype, "date", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        name: 'login_data',
+        type: 'json',
+        nullable: true,
+        comment: 'JSON array of login details for the date',
+    }),
+    __metadata("design:type", Array)
+], LoginDetailsEntity.prototype, "login_data", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ length: 250, nullable: true }),
+    __metadata("design:type", String)
+], LoginDetailsEntity.prototype, "email", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ length: 100, nullable: true }),
+    __metadata("design:type", String)
+], LoginDetailsEntity.prototype, "first_name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ length: 100, nullable: true }),
+    __metadata("design:type", String)
+], LoginDetailsEntity.prototype, "last_name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], LoginDetailsEntity.prototype, "total_logins", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], LoginDetailsEntity.prototype, "successful_logins", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], LoginDetailsEntity.prototype, "failed_logins", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamp' }),
+    __metadata("design:type", Date)
+], LoginDetailsEntity.prototype, "created_at", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ type: 'timestamp', nullable: true }),
+    __metadata("design:type", Date)
+], LoginDetailsEntity.prototype, "updated_at", void 0);
+__decorate([
+    (0, typeorm_1.DeleteDateColumn)({ type: 'timestamp', nullable: true }),
+    __metadata("design:type", Date)
+], LoginDetailsEntity.prototype, "deleted_at", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], LoginDetailsEntity.prototype, "created_by", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], LoginDetailsEntity.prototype, "updated_by", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], LoginDetailsEntity.prototype, "deleted_by", void 0);
+exports.LoginDetailsEntity = LoginDetailsEntity = __decorate([
+    (0, typeorm_1.Entity)('tbl_user_login_details'),
+    (0, typeorm_1.Index)(['user_id']),
+    (0, typeorm_1.Index)(['date']),
+    (0, typeorm_1.Index)(['user_id', 'date'])
+], LoginDetailsEntity);

package/dist/index.d.ts

@@ -27,5 +27,6 @@ export * from './entities/user-module-access.entity';
 export * from './entities/module-screen-permission.entity';
 export * from './entities/api-key.entity';
 export * from './entities/user-last-login.entity';
+export * from './entities/login-details.entity';
 export * from './entities/ip-access.entity';
 export * from './entities/work-profile.entity';

package/dist/index.js

@@ -50,5 +50,6 @@ __exportStar(require("./entities/user-module-access.entity"), exports);
 __exportStar(require("./entities/module-screen-permission.entity"), exports);
 __exportStar(require("./entities/api-key.entity"), exports);
 __exportStar(require("./entities/user-last-login.entity"), exports);
+__exportStar(require("./entities/login-details.entity"), exports);
 __exportStar(require("./entities/ip-access.entity"), exports);
 __exportStar(require("./entities/work-profile.entity"), exports);

package/dist/interfaces/auth-core-options.interface.d.ts

@@ -9,6 +9,7 @@ import { UserModuleAccess } from '../entities/user-module-access.entity';
 import { ModuleScreenPermission } from '../entities/module-screen-permission.entity';
 import { ApiKeyEntity } from '../entities/api-key.entity';
 import { UserLastLoginEntity } from '../entities/user-last-login.entity';
+import { LoginDetailsEntity } from '../entities/login-details.entity';
 import { EmployeeIPAccessEntity } from '../entities/ip-access.entity';
 import { EmployeeWorkProfileEntity } from '../entities/work-profile.entity';
 export interface Repositories {
@@ -23,6 +24,7 @@ export interface Repositories {
     apiKeyRepo?: Repository<ApiKeyEntity>;
     ipRestrictionsRepo?: Repository<EmployeeIPAccessEntity>;
     userLastLoginRepo?: Repository<UserLastLoginEntity>;
+    loginDetailsRepo?: Repository<LoginDetailsEntity>;
     employeeWorkProfileRepo?: Repository<EmployeeWorkProfileEntity>;
 }
 export interface AuthModuleConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ecrs-auth-core",
-  "version": "1.0.74",
+  "version": "1.0.75",
   "description": "Centralized authentication and authorization module for ECRS apps",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",