client-core-services 1.0.0

package/esm2020/lib/services/api/auth/auth-guard.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../storage/storage.service";
+import * as i2 from "@angular/router";
+import * as i3 from "./auth.service";
+export class AuthGuard {
+    constructor(storageService, router, authService) {
+        this.storageService = storageService;
+        this.router = router;
+        this.authService = authService;
+    }
+    canActivate(route, state) {
+        // return this.dataShareService.getAuthentication().pipe(
+        //   map((data:boolean) =>{
+        //     return data;
+        //   })
+        // );
+        const childWindowUrl = this.storageService.getChildWindowUrl();
+        if (state.url.startsWith("/browse") && (childWindowUrl == undefined || childWindowUrl == '/')) {
+            this.storageService.setRedirectUrl(state.url);
+        }
+        var isAuthenticated = this.authService.checkIdTokenStatus().status;
+        if (!isAuthenticated) {
+            this.authService.redirectToSignPage();
+        }
+        return isAuthenticated;
+    }
+}
+AuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthGuard, deps: [{ token: i1.StorageService }, { token: i2.Router }, { token: i3.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.StorageService }, { type: i2.Router }, { type: i3.AuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/api/auth/auth.service.mjs

@@ -0,0 +1,500 @@
+import { Injectable } from '@angular/core';
+import { StorageTokenStatus } from '../../../shared/enums/storage-token-status.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../env/env.service";
+import * as i3 from "../api.service";
+import * as i4 from "../../storage/storage.service";
+import * as i5 from "@angular/router";
+import * as i6 from "../../encryption/encryption.service";
+import * as i7 from "../../common-utils/common-function.service";
+import * as i8 from "../../common-utils/core-function/core-function.service";
+import * as i9 from "../../data-share/auth-data-share/auth-data-share.service";
+import * as i10 from "./../../api/api-call/api-call.service";
+export class AuthService {
+    constructor(http, envService, apiService, storageService, router, encryptionService, commonFunctionService, coreFunctionService, authDataShareService, apiCallService) {
+        this.http = http;
+        this.envService = envService;
+        this.apiService = apiService;
+        this.storageService = storageService;
+        this.router = router;
+        this.encryptionService = encryptionService;
+        this.commonFunctionService = commonFunctionService;
+        this.coreFunctionService = coreFunctionService;
+        this.authDataShareService = authDataShareService;
+        this.apiCallService = apiCallService;
+    }
+    ngOnInit() {
+    }
+    Logout(payload) {
+        this.resetData();
+        this.logOutRedirection();
+        this.authDataShareService.restSettingModule('logged_out');
+    }
+    SessionExpired(payload) {
+        let response = {
+            status: '',
+            class: '',
+            msg: ''
+        };
+        this.resetData();
+        this.logOutRedirection();
+        response.class = "bg-info";
+        response.status = "success";
+        response.msg = "Session Expired, Kindly Login Again.";
+        this.authDataShareService.setSessionExpired(response);
+        if (this.storageService.checkPlatForm() != 'mobile') {
+            this.authDataShareService.restSettingModule('logged_out');
+        }
+    }
+    resetData() {
+        this.storageService.removeDataFormStorage();
+        this.apiService.resetMenuData();
+        this.apiService.resetTempData();
+        this.apiService.resetGridData();
+        this.envService.setRequestType('PUBLIC');
+        this.apiCallService.getApplicationAllSettings();
+    }
+    logOutRedirection() {
+        if (this.envService.checkRedirectionUrl()) {
+            window.location.href = this.envService.checkRedirectionUrl();
+        }
+        else {
+            this.redirectToSignPage();
+        }
+    }
+    gotToSigninPage() {
+        this.resetData();
+        this.redirectToSignPage();
+    }
+    GetUserInfoFromToken(payload, loginRedirect) {
+        let response = {
+            status: '',
+            class: '',
+            msg: ''
+        };
+        let api = "";
+        let reqBody = {};
+        if (payload && payload.roleName && payload.roleName != '') {
+            api = this.envService.getAuthApi('GET_USER_PERMISSION') + "/" + payload.roleName;
+            reqBody = { key: payload.token };
+        }
+        else {
+            api = this.envService.getAuthApi('GET_USER_PERMISSION') + "/" + null;
+            reqBody = { key: payload };
+        }
+        this.http.post(api, reqBody).subscribe((respData) => {
+            if (respData && respData.user) {
+                let modifyData = this.coreFunctionService.getModulesFromMapObject(respData);
+                this.storageService.SetUserInfo(modifyData);
+                this.storageService.GetUserInfo();
+                this.envService.setRequestType('PRIVATE');
+                this.apiCallService.getApplicationAllSettings();
+                this.authDataShareService.restSettingModule('logged_in');
+                this.apiService.gitVersion('');
+                this.apiCallService.getUserPrefrerence(respData.user);
+                // this.apiCallService.getUserNotification(1);
+                this.redirectionWithMenuType(loginRedirect);
+                response.status = "success";
+                this.authDataShareService.setUserInfo(response);
+            }
+            else {
+                this.envService.setRequestType('PUBLIC');
+                this.redirectToSignPage();
+            }
+        }, (error) => {
+            if (error.status == 403) {
+                this.envService.setRequestType('PUBLIC');
+                this.redirectToSignPage();
+            }
+            else {
+                if (error && error.status == 403) {
+                    response.msg = 'Username password does not match.';
+                }
+                else if (error && error.error && error.error.message) {
+                    response.msg = error.error.message;
+                }
+                else {
+                    response.msg = error.message;
+                }
+                response.status = 'error';
+                response.class = 'bg-danger';
+                this.authDataShareService.setUserInfo(response);
+            }
+        });
+    }
+    redirectionWithMenuType(loginRedirectUrl) {
+        const menuType = this.storageService.GetMenuType();
+        const redirectUrl = this.storageService.getRedirectUrl();
+        const childWindowUrl = this.storageService.getChildWindowUrl();
+        let route = '/dashboard';
+        if (menuType == 'Horizontal') {
+            route = '/home';
+        }
+        if (redirectUrl && redirectUrl != '' && redirectUrl != '/') {
+            route = redirectUrl;
+        }
+        else if (childWindowUrl && childWindowUrl != '' && childWindowUrl != '/') {
+            route = childWindowUrl;
+        }
+        else if (loginRedirectUrl && loginRedirectUrl != '' && loginRedirectUrl != '/') {
+            route = loginRedirectUrl;
+        }
+        this.router.navigate([route]);
+    }
+    redirectToSignPage() {
+        this.router.navigate(['/signin']);
+    }
+    Signin(payload) {
+        let response = {
+            status: '',
+            class: '',
+            msg: '',
+            message: '',
+            wrongLoginAttempt: 0
+        };
+        let api = this.envService.getAuthApi('AU_SIGNIN');
+        this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe((respData) => {
+            if (respData && respData['token']) {
+                const cognitoIdToken = respData['token'];
+                const cognitoExpiresIn = 86400;
+                // const cognitoExpiresIn = 420;
+                this.storageService.setExpiresIn(cognitoExpiresIn);
+                this.storageService.SetIdToken(cognitoIdToken);
+                response.status = 'success';
+                response.class = 'bg-success';
+                response.msg = 'Login  Successful.';
+                if (respData['message']) {
+                    response.message = respData['message'];
+                }
+                this.authDataShareService.setAuthentication(true);
+            }
+            else if (respData && respData['message']) {
+                response.status = 'error';
+                response.class = 'bg-danger';
+                response.msg = respData['message'];
+                response.wrongLoginAttempt = respData?.wrongLoginAttempt;
+            }
+            else if (respData.hasOwnProperty('error')) {
+                if (respData["error"] == "not_confirmed") {
+                    response.msg = 'User Not Confirmed ';
+                }
+                else if (respData["error"] == "user_name_password_does_not_match") {
+                    response.msg = 'Username password does not match ';
+                }
+                else {
+                    response.msg = 'Username password does not match ';
+                }
+                response.status = 'error';
+                response.class = 'bg-danger';
+                response.wrongLoginAttempt = respData?.wrongLoginAttempt;
+            }
+            this.authDataShareService.setSigninResponse(response);
+        }, (error) => {
+            if (error && error.status == 403) {
+                console.log("Sign In first error handling." + JSON.stringify(error));
+                response.msg = 'Username password does not match.';
+            }
+            else if (error && error.error && error.error.message) {
+                console.log("Sign In Secong error handling." + JSON.stringify(error));
+                response.msg = error.error.message;
+                response.wrongLoginAttempt = error.error?.wrongLoginAttempt;
+            }
+            else {
+                console.log("Sign In Third error handling." + JSON.stringify(error));
+                response.msg = error.message;
+                response.wrongLoginAttempt = error?.wrongLoginAttempt;
+            }
+            response.status = 'error';
+            response.class = 'bg-danger';
+            this.authDataShareService.setSigninResponse(response);
+        });
+    }
+    Signup(payload) {
+        let response = {
+            status: '',
+            class: '',
+            msg: '',
+            appPresentAlert: false,
+            autoLogin: false,
+            payload: {}
+        };
+        let newPayload = '';
+        let isHybridPlatform = false;
+        if (this.storageService.checkPlatForm() == 'mobile') {
+            isHybridPlatform = true;
+            newPayload = payload.data;
+        }
+        else {
+            newPayload = payload;
+        }
+        let api = this.envService.getAuthApi('AU_SIGNUP');
+        this.http.post(api, this.encryptionService.encryptRequest(newPayload)).subscribe((respData) => {
+            if (respData && respData['message'] == 'User registered successfully') {
+                if (payload.autologin && isHybridPlatform) {
+                    response.msg = 'Successfully Registered.';
+                    response.autoLogin = payload.autologin;
+                    response.payload = { userId: newPayload.userId, password: newPayload.password };
+                    // this.Signin(appPayload);
+                }
+                else {
+                    if (this.envService.getVerifyType() == 'mobile') {
+                        response.msg = 'OTP has been sent to your registered Mobile no.';
+                        response.payload = { userId: newPayload.userId, password: newPayload.password };
+                        if (isHybridPlatform) {
+                            response.appPresentAlert = true;
+                            // this.router.navigate([payload.redirection +'/'+payload.data.userId]);
+                        }
+                        else {
+                            // this.router.navigate(['otp_varify'+'/'+payload.userId]);
+                        }
+                    }
+                    else {
+                        if (newPayload.admin) {
+                            response.msg = 'A verification link has been sent to your email account. If not received, please connect to admin to verify your email.';
+                        }
+                        else {
+                            response.msg = 'A verification link has been sent to your email account. please click on the link to verify your email and continue the registration process.';
+                        }
+                        response.appPresentAlert = true;
+                    }
+                }
+            }
+            else if (respData && respData['message']) {
+                response.msg = respData['message'];
+            }
+            response.status = 'success';
+            response.class = 'bg-success';
+            this.authDataShareService.setSignUpResponse(response);
+        }, (error) => {
+            if (error && error.error && error.error.message) {
+                console.log("Sign In Secong error handling." + JSON.stringify(error));
+                response.msg = error.error.message;
+            }
+            else {
+                console.log("Sign In Third error handling." + JSON.stringify(error));
+                response.msg = error.message;
+            }
+            response.status = 'error';
+            response.class = 'bg-danger';
+            this.authDataShareService.setSignUpResponse(response);
+        });
+    }
+    TryForgotPassword(payload) {
+        let response = {
+            status: '',
+            class: '',
+            msg: ''
+        };
+        let api = this.envService.getAuthApi('AUTH_FORGET_PASSWORD');
+        this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe((respData) => {
+            if (respData && respData['message']) {
+                response.status = 'success';
+                response.class = 'bg-success';
+                response.msg = respData['message'];
+            }
+            this.authDataShareService.setForgot(response);
+        }, (error) => {
+            if (error && error.error && error.error.message) {
+                response.msg = error.error.message;
+            }
+            else {
+                response.msg = error.message;
+            }
+            response.status = 'error';
+            response.class = 'bg-danger';
+            this.authDataShareService.setForgot(response);
+        });
+    }
+    SaveNewPassword(payload) {
+        let response = {
+            status: '',
+            class: '',
+            msg: ''
+        };
+        let api = this.envService.getAuthApi('AUTH_RESET_PASSWORD');
+        this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe((respData) => {
+            if (respData && respData['message']) {
+                response.status = 'success';
+                response.class = 'bg-success';
+                response.msg = respData['message'];
+            }
+            this.authDataShareService.resetPassword(response);
+        }, (error) => {
+            if (error && error.error && error.error.message) {
+                response.msg = error.error.message;
+            }
+            else {
+                response.msg = error.message;
+            }
+            response.status = 'error';
+            response.class = 'bg-danger';
+            this.authDataShareService.resetPassword(response);
+        });
+    }
+    ResetPass(payload) {
+        let api = this.envService.getAuthApi('RESET_PASSWORD');
+        this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe((respData) => {
+            if (respData && respData.hasOwnProperty('success')) {
+                // this.notificationService.notify("bg-success", " New Password Set  Successfully.");
+                this.router.navigate(['/admin']);
+            }
+            else if (respData.hasOwnProperty('error')) {
+                if (respData["error"] == "not_confirmed") {
+                    // this.notificationService.notify("bg-danger", "User Not Confirmed ");
+                }
+                else if (respData["error"] == "user_name_password_does_not_match") {
+                    // this.notificationService.notify("bg-danger", "Username password does not match ");
+                }
+            }
+        }, (error) => {
+            // this.notificationService.notify("bg-danger", error.message);
+        });
+    }
+    TryVerify(payload) {
+        console.log(payload);
+    }
+    changePassword(payload) {
+        let response = {
+            status: '',
+            class: '',
+            msg: ''
+        };
+        let api = this.envService.getAuthApi('AUTH_CHANGE_PASSWORD');
+        this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe((respData) => {
+            if (respData && respData['message']) {
+                response.status = 'success';
+                response.class = 'bg-success';
+                response.msg = respData['message'];
+            }
+            this.authDataShareService.setChangePwd(response);
+        }, (error) => {
+            if (error && error.status == 403) {
+                response.msg = "Invalid current password.";
+            }
+            else if (error && error.error && error.error.message) {
+                response.msg = error.error.message;
+            }
+            else {
+                response.msg = error.message;
+            }
+            response.status = 'error';
+            response.class = 'bg-danger';
+            this.authDataShareService.setChangePwd(response);
+        });
+    }
+    userVarify(payload) {
+        let response = {
+            status: '',
+            class: '',
+            msg: '',
+            autoLogin: false,
+        };
+        let newPayload = '';
+        let isHybridPlatform = false;
+        if (this.storageService.checkPlatForm() == 'mobile') {
+            isHybridPlatform = true;
+            newPayload = payload.data;
+        }
+        else {
+            newPayload = payload;
+        }
+        let api = this.envService.getAuthApi('USER_VARIFY');
+        this.http.post(api, this.encryptionService.encryptRequest(newPayload)).subscribe((respData) => {
+            if (respData && respData['message'] == "User has been verified successfully") {
+                response.msg = respData['message'];
+                if (payload.autologin) {
+                    response.autoLogin = payload.autologin;
+                }
+                // if(this.storageService.getVerifyType() == 'mobile'){
+                // }
+            }
+            else if (respData && respData['message']) {
+                response.msg = respData['message'];
+            }
+            response.status = 'success';
+            response.class = 'bg-success';
+            this.authDataShareService.setOtpResponse(response);
+        }, (error) => {
+            if (error && error.error && error.error.message) {
+                response.msg = error.error.message;
+            }
+            else {
+                response.msg = error.message;
+            }
+            response.status = 'error';
+            response.class = 'bg-danger';
+            this.authDataShareService.setOtpResponse(response);
+        });
+    }
+    checkIdTokenStatus() {
+        let statusWithMsg = {
+            "status": false,
+            "msg": ""
+        };
+        if (this.storageService != null && this.storageService.GetIdToken() != null) {
+            if (this.storageService.GetIdTokenStatus() == StorageTokenStatus.ID_TOKEN_ACTIVE) {
+                statusWithMsg.status = true;
+            }
+            else {
+                statusWithMsg.status = false;
+                this.SessionExpired();
+            }
+        }
+        else {
+            statusWithMsg.status = false;
+            statusWithMsg.msg = "Your are already logout !!!";
+        }
+        return statusWithMsg;
+    }
+    checkApplicationSetting() {
+        let exists = false;
+        let applicationSetting = this.storageService.getApplicationSetting();
+        if (applicationSetting) {
+            exists = true;
+        }
+        else {
+            exists = false;
+        }
+        return exists;
+    }
+    authenticateUser(payload) {
+        let response = {
+            status: '',
+            class: '',
+            msg: '',
+            message: ''
+        };
+        let api = this.envService.getAuthApi('TWO_FACTOR_AUTHENTICATION');
+        this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe((respData) => {
+            if (respData && respData['token']) {
+                const cognitoIdToken = respData['token'];
+                const cognitoExpiresIn = 86400;
+                this.storageService.setExpiresIn(cognitoExpiresIn);
+                this.storageService.SetIdToken(cognitoIdToken);
+                response.status = 'success';
+                response.class = 'bg-success';
+                response.msg = 'Login  Successful.';
+                if (respData['message']) {
+                    response.message = respData['message'];
+                }
+                this.authDataShareService.setAuthentication(true);
+                this.authDataShareService.setAuthenticationResponce(response);
+            }
+        }, (error) => {
+            response.msg = error.message;
+            response.status = 'error';
+            response.class = 'bg-danger';
+            this.authDataShareService.setAuthenticationResponce(response);
+        });
+    }
+}
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthService, deps: [{ token: i1.HttpClient }, { token: i2.EnvService }, { token: i3.ApiService }, { token: i4.StorageService }, { token: i5.Router }, { token: i6.EncryptionService }, { token: i7.CommonFunctionService }, { token: i8.CoreFunctionService }, { token: i9.AuthDataShareService }, { token: i10.ApiCallService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EnvService }, { type: i3.ApiService }, { type: i4.StorageService }, { type: i5.Router }, { type: i6.EncryptionService }, { type: i7.CommonFunctionService }, { type: i8.CoreFunctionService }, { type: i9.AuthDataShareService }, { type: i10.ApiCallService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../../projects/client-core/src/lib/services/api/auth/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiCallService } from './../../api/api-call/api-call.service';\r\nimport { Injectable,OnInit} from '@angular/core';\r\nimport { EnvService } from '../../env/env.service';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { StorageService } from '../../storage/storage.service';\r\nimport { StorageTokenStatus } from '../../../shared/enums/storage-token-status.enum';\r\nimport { Router } from '@angular/router';\r\nimport { EncryptionService } from '../../encryption/encryption.service';\r\nimport { CommonFunctionService } from '../../common-utils/common-function.service';\r\nimport { ApiService } from '../api.service';\r\nimport { CoreFunctionService } from '../../common-utils/core-function/core-function.service';\r\nimport { AuthDataShareService } from '../../data-share/auth-data-share/auth-data-share.service';\r\n\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuthService implements OnInit{\r\n\r\n\r\n  constructor(\r\n    private http:HttpClient,\r\n    private envService:EnvService,\r\n    private apiService:ApiService,\r\n    private storageService:StorageService,\r\n    private router:Router,\r\n    private encryptionService:EncryptionService,\r\n    private commonFunctionService:CommonFunctionService,\r\n    private coreFunctionService:CoreFunctionService,\r\n    private authDataShareService: AuthDataShareService,\r\n    private apiCallService:ApiCallService\r\n    ) { }\r\n\r\n\r\n  ngOnInit(){\r\n\r\n  }\r\n\r\n  Logout(payload:any){\r\n    this.resetData();\r\n    this.logOutRedirection();\r\n    this.authDataShareService.restSettingModule('logged_out');\r\n  }\r\n  SessionExpired(payload?:any){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: ''\r\n    };\r\n    this.resetData();\r\n    this.logOutRedirection();\r\n    response.class = \"bg-info\";\r\n    response.status = \"success\";\r\n    response.msg = \"Session Expired, Kindly Login Again.\";\r\n    this.authDataShareService.setSessionExpired(response);\r\n    if(this.storageService.checkPlatForm() != 'mobile'){\r\n      this.authDataShareService.restSettingModule('logged_out');\r\n    }\r\n  }\r\n  resetData(){\r\n    this.storageService.removeDataFormStorage();\r\n    this.apiService.resetMenuData();\r\n    this.apiService.resetTempData();\r\n    this.apiService.resetGridData();\r\n    this.envService.setRequestType('PUBLIC');\r\n    this.apiCallService.getApplicationAllSettings();\r\n  }\r\n  logOutRedirection(){\r\n    if (this.envService.checkRedirectionUrl()) {\r\n      window.location.href = this.envService.checkRedirectionUrl();\r\n    }else{\r\n      this.redirectToSignPage();\r\n    }\r\n  }\r\n  gotToSigninPage(){\r\n    this.resetData()\r\n    this.redirectToSignPage();\r\n  }\r\n\r\n  GetUserInfoFromToken(payload:any, loginRedirect?:string){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: ''\r\n    };\r\n    let api = \"\";\r\n    let reqBody = {};\r\n    if(payload && payload.roleName && payload.roleName != ''){\r\n      api = this.envService.getAuthApi('GET_USER_PERMISSION')+\"/\"+payload.roleName;\r\n      reqBody = { key: payload.token };\r\n    }else{\r\n      api = this.envService.getAuthApi('GET_USER_PERMISSION')+\"/\"+null;\r\n      reqBody = { key: payload };\r\n    }\r\n\r\n    this.http.post(api, reqBody).subscribe(\r\n      (respData:any) =>{\r\n        if (respData && respData.user) {\r\n          let modifyData = this.coreFunctionService.getModulesFromMapObject(respData);\r\n          this.storageService.SetUserInfo(modifyData);\r\n          this.storageService.GetUserInfo();\r\n          this.envService.setRequestType('PRIVATE');\r\n          this.apiCallService.getApplicationAllSettings();\r\n          this.authDataShareService.restSettingModule('logged_in');\r\n          this.apiService.gitVersion('');\r\n          this.apiCallService.getUserPrefrerence(respData.user);\r\n          // this.apiCallService.getUserNotification(1);\r\n          this.redirectionWithMenuType(loginRedirect);\r\n          response.status = \"success\";\r\n          this.authDataShareService.setUserInfo(response);\r\n        } else {\r\n            this.envService.setRequestType('PUBLIC');\r\n            this.redirectToSignPage();\r\n        }\r\n      },\r\n      (error)=>{\r\n        if(error.status == 403){\r\n          this.envService.setRequestType('PUBLIC');\r\n          this.redirectToSignPage();\r\n        }else{\r\n          if(error && error.status == 403){\r\n            response.msg = 'Username password does not match.';\r\n          }else if(error && error.error && error.error.message){\r\n            response.msg = error.error.message;\r\n          }else{\r\n            response.msg = error.message;\r\n          }\r\n          response.status = 'error';\r\n          response.class = 'bg-danger';\r\n          this.authDataShareService.setUserInfo(response);\r\n        }\r\n      }\r\n    )\r\n  }\r\n  redirectionWithMenuType(loginRedirectUrl?:string){\r\n    const menuType = this.storageService.GetMenuType();\r\n    const redirectUrl = this.storageService.getRedirectUrl();\r\n    const childWindowUrl = this.storageService.getChildWindowUrl();\r\n    let route = '/dashboard';\r\n    if(menuType == 'Horizontal'){\r\n      route = '/home';\r\n    }\r\n    if(redirectUrl && redirectUrl != '' && redirectUrl != '/'){\r\n      route = redirectUrl;\r\n    }else if(childWindowUrl && childWindowUrl != '' && childWindowUrl != '/'){\r\n      route = childWindowUrl;\r\n    }else if(loginRedirectUrl && loginRedirectUrl != '' && loginRedirectUrl != '/'){\r\n      route = loginRedirectUrl;\r\n    }\r\n    this.router.navigate([route]);\r\n  }\r\n  redirectToSignPage(){\r\n    this.router.navigate(['/signin']);\r\n  }\r\n  Signin(payload:any){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: '',\r\n      message:'',\r\n      wrongLoginAttempt:0\r\n    };\r\n    let api = this.envService.getAuthApi('AU_SIGNIN');\r\n    this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe(\r\n      (respData:any) =>{\r\n        if(respData && respData['token']){\r\n            const cognitoIdToken = respData['token'];\r\n            const cognitoExpiresIn = 86400;\r\n            // const cognitoExpiresIn = 420;\r\n            this.storageService.setExpiresIn(cognitoExpiresIn);\r\n            this.storageService.SetIdToken(cognitoIdToken);\r\n            response.status = 'success';\r\n            response.class = 'bg-success';\r\n            response.msg = 'Login  Successful.';\r\n            if(respData['message']){\r\n              response.message = respData['message'];\r\n            }\r\n            this.authDataShareService.setAuthentication(true);\r\n        } else if(respData && respData['message']){\r\n          response.status = 'error';\r\n          response.class = 'bg-danger';\r\n          response.msg = respData['message'];\r\n          response.wrongLoginAttempt = respData?.wrongLoginAttempt;\r\n        }else if (respData.hasOwnProperty('error')) {\r\n            if (respData[\"error\"] == \"not_confirmed\") {\r\n                response.msg = 'User Not Confirmed ';\r\n            } else if (respData[\"error\"] == \"user_name_password_does_not_match\") {\r\n                response.msg = 'Username password does not match ';\r\n            }else {\r\n              response.msg = 'Username password does not match ';\r\n            }\r\n            response.status = 'error';\r\n            response.class = 'bg-danger';\r\n            response.wrongLoginAttempt = respData?.wrongLoginAttempt;\r\n        }\r\n        this.authDataShareService.setSigninResponse(response);\r\n      },\r\n      (error)=>{\r\n        if(error && error.status == 403){\r\n          console.log(\"Sign In first error handling.\" + JSON.stringify(error));\r\n          response.msg = 'Username password does not match.';\r\n        }else if(error && error.error && error.error.message){\r\n          console.log(\"Sign In Secong error handling.\" + JSON.stringify(error));\r\n          response.msg = error.error.message;\r\n          response.wrongLoginAttempt = error.error?.wrongLoginAttempt;\r\n        }else{\r\n          console.log(\"Sign In Third error handling.\" + JSON.stringify(error));\r\n          response.msg = error.message;\r\n          response.wrongLoginAttempt = error?.wrongLoginAttempt;\r\n        }\r\n        response.status = 'error';\r\n        response.class = 'bg-danger';\r\n\r\n        this.authDataShareService.setSigninResponse(response);\r\n      }\r\n    )\r\n  }\r\n  Signup(payload:any){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: '',\r\n      appPresentAlert: false,\r\n      autoLogin:false,\r\n      payload: {}\r\n    };\r\n    let newPayload :any = '';\r\n    let isHybridPlatform = false;\r\n    if(this.storageService.checkPlatForm() == 'mobile'){\r\n      isHybridPlatform = true;\r\n      newPayload = payload.data;\r\n    }else{\r\n      newPayload = payload;\r\n    }\r\n    let api = this.envService.getAuthApi('AU_SIGNUP');\r\n    this.http.post(api, this.encryptionService.encryptRequest(newPayload)).subscribe(\r\n      (respData:any) =>{\r\n        if(respData && respData['message'] == 'User registered successfully'){\r\n          if(payload.autologin && isHybridPlatform){\r\n            response.msg = 'Successfully Registered.';\r\n            response.autoLogin = payload.autologin;\r\n            response.payload = { userId: newPayload.userId, password: newPayload.password };\r\n            // this.Signin(appPayload);\r\n          }else{\r\n            if(this.envService.getVerifyType() == 'mobile'){\r\n                response.msg = 'OTP has been sent to your registered Mobile no.';\r\n                response.payload = { userId: newPayload.userId, password: newPayload.password };\r\n                if(isHybridPlatform){\r\n                  response.appPresentAlert = true;\r\n                  // this.router.navigate([payload.redirection +'/'+payload.data.userId]);\r\n                }else{\r\n                  // this.router.navigate(['otp_varify'+'/'+payload.userId]);\r\n                }\r\n            }else{\r\n              if(newPayload.admin){\r\n                response.msg = 'A verification link has been sent to your email account. If not received, please connect to admin to verify your email.';\r\n              }else{\r\n                response.msg = 'A verification link has been sent to your email account. please click on the link to verify your email and continue the registration process.';\r\n              }\r\n              response.appPresentAlert = true;\r\n            }\r\n          }\r\n        } else if(respData && respData['message']){\r\n          response.msg = respData['message'];\r\n        }\r\n        response.status = 'success';\r\n        response.class = 'bg-success';\r\n        this.authDataShareService.setSignUpResponse(response);\r\n      },\r\n      (error)=>{\r\n        if(error && error.error && error.error.message){\r\n          console.log(\"Sign In Secong error handling.\" + JSON.stringify(error));\r\n          response.msg = error.error.message;\r\n        }else{\r\n          console.log(\"Sign In Third error handling.\" + JSON.stringify(error));\r\n          response.msg = error.message;\r\n        }\r\n        response.status = 'error';\r\n        response.class = 'bg-danger';\r\n        this.authDataShareService.setSignUpResponse(response);\r\n      }\r\n    )\r\n  }\r\n  TryForgotPassword(payload:any){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: ''\r\n    };\r\n    let api = this.envService.getAuthApi('AUTH_FORGET_PASSWORD');\r\n    this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe(\r\n      (respData:any) =>{\r\n        if(respData && respData['message']){\r\n          response.status = 'success';\r\n          response.class = 'bg-success';\r\n          response.msg = respData['message'];\r\n        }\r\n        this.authDataShareService.setForgot(response);\r\n      },\r\n      (error)=>{\r\n        if(error && error.error && error.error.message){\r\n          response.msg = error.error.message;\r\n        }else{\r\n          response.msg = error.message;\r\n        }\r\n        response.status = 'error';\r\n        response.class = 'bg-danger';\r\n        this.authDataShareService.setForgot(response);\r\n      }\r\n    )\r\n  }\r\n  SaveNewPassword(payload:any){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: ''\r\n    };\r\n    let api = this.envService.getAuthApi('AUTH_RESET_PASSWORD');\r\n    this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe(\r\n      (respData:any) =>{\r\n        if(respData && respData['message']){\r\n          response.status = 'success';\r\n          response.class = 'bg-success';\r\n          response.msg = respData['message'];\r\n        }\r\n        this.authDataShareService.resetPassword(response);\r\n      },\r\n      (error)=>{\r\n        if(error && error.error && error.error.message){\r\n          response.msg = error.error.message;\r\n        }else{\r\n          response.msg = error.message;\r\n        }\r\n        response.status = 'error';\r\n        response.class = 'bg-danger';\r\n        this.authDataShareService.resetPassword(response);\r\n      }\r\n    )\r\n  }\r\n  ResetPass(payload:any){\r\n    let api = this.envService.getAuthApi('RESET_PASSWORD');\r\n    this.http.post(api,this.encryptionService.encryptRequest(payload)).subscribe(\r\n      (respData:any) =>{\r\n        if (respData && respData.hasOwnProperty('success')) {\r\n            // this.notificationService.notify(\"bg-success\", \" New Password Set  Successfully.\");\r\n            this.router.navigate(['/admin']);\r\n        } else if (respData.hasOwnProperty('error')) {\r\n            if (respData[\"error\"] == \"not_confirmed\") {\r\n                // this.notificationService.notify(\"bg-danger\", \"User Not Confirmed \");\r\n            } else if (respData[\"error\"] == \"user_name_password_does_not_match\") {\r\n                // this.notificationService.notify(\"bg-danger\", \"Username password does not match \");\r\n            }\r\n        }\r\n      },\r\n      (error)=>{\r\n        // this.notificationService.notify(\"bg-danger\", error.message);\r\n      }\r\n    )\r\n  }\r\n  TryVerify(payload:object){\r\n    console.log(payload);\r\n  }\r\n  changePassword(payload:any){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: ''\r\n    };\r\n    let api = this.envService.getAuthApi('AUTH_CHANGE_PASSWORD')\r\n    this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe(\r\n      (respData:any) => {\r\n        if(respData && respData['message']){\r\n          response.status = 'success';\r\n          response.class = 'bg-success';\r\n          response.msg = respData['message'];\r\n        }\r\n        this.authDataShareService.setChangePwd(response);\r\n      },\r\n      (error) => {\r\n        if(error && error.status == 403){\r\n          response.msg = \"Invalid current password.\";\r\n        }else if(error && error.error && error.error.message){\r\n          response.msg =  error.error.message;\r\n        }else{\r\n          response.msg = error.message;\r\n        }\r\n        response.status = 'error';\r\n        response.class = 'bg-danger';\r\n        this.authDataShareService.setChangePwd(response);\r\n      }\r\n    )\r\n  }\r\n  userVarify(payload:any){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: '',\r\n      autoLogin:false,\r\n    };\r\n    let newPayload :any = '';\r\n    let isHybridPlatform = false;\r\n    if(this.storageService.checkPlatForm() == 'mobile'){\r\n      isHybridPlatform = true;\r\n      newPayload = payload.data;\r\n    }else{\r\n      newPayload = payload;\r\n    }\r\n    let api = this.envService.getAuthApi('USER_VARIFY');\r\n    this.http.post(api, this.encryptionService.encryptRequest(newPayload)).subscribe(\r\n      (respData:any) =>{\r\n        if(respData && respData['message'] == \"User has been verified successfully\"){\r\n          response.msg = respData['message'];\r\n          if(payload.autologin){\r\n            response.autoLogin = payload.autologin;\r\n          }\r\n          // if(this.storageService.getVerifyType() == 'mobile'){\r\n          // }\r\n        }else if(respData && respData['message']){\r\n          response.msg = respData['message'];\r\n        }\r\n        response.status = 'success';\r\n        response.class = 'bg-success';\r\n        this.authDataShareService.setOtpResponse(response);\r\n      },\r\n      (error)=>{\r\n        if(error && error.error && error.error.message){\r\n          response.msg = error.error.message;\r\n        }else{\r\n          response.msg = error.message;\r\n        }\r\n        response.status = 'error';\r\n        response.class = 'bg-danger';\r\n        this.authDataShareService.setOtpResponse(response);\r\n      }\r\n    )\r\n  }\r\n  checkIdTokenStatus(){\r\n    let statusWithMsg={\r\n      \"status\":false,\r\n      \"msg\" : \"\"\r\n    };\r\n    if (this.storageService != null && this.storageService.GetIdToken() != null) {\r\n      if(this.storageService.GetIdTokenStatus() == StorageTokenStatus.ID_TOKEN_ACTIVE){\r\n        statusWithMsg.status = true;\r\n      }else{\r\n        statusWithMsg.status = false;\r\n          this.SessionExpired();\r\n      }\r\n    }else{\r\n      statusWithMsg.status=false;\r\n      statusWithMsg.msg=\"Your are already logout !!!\";\r\n    }\r\n    return statusWithMsg;\r\n  }\r\n  checkApplicationSetting(){\r\n    let exists = false;\r\n    let applicationSetting = this.storageService.getApplicationSetting();\r\n    if(applicationSetting){\r\n      exists = true;\r\n    }else{\r\n      exists = false;\r\n    }\r\n    return exists;\r\n  }\r\n\r\n  authenticateUser(payload:any){\r\n    let response = {\r\n      status: '',\r\n      class: '',\r\n      msg: '',\r\n      message:''\r\n    };\r\n    let api = this.envService.getAuthApi('TWO_FACTOR_AUTHENTICATION');\r\n    this.http.post(api, this.encryptionService.encryptRequest(payload)).subscribe(\r\n      (respData:any) =>{\r\n        if(respData && respData['token']){\r\n            const cognitoIdToken = respData['token'];\r\n            const cognitoExpiresIn = 86400;\r\n            this.storageService.setExpiresIn(cognitoExpiresIn);\r\n            this.storageService.SetIdToken(cognitoIdToken);\r\n            response.status = 'success';\r\n            response.class = 'bg-success';\r\n            response.msg = 'Login  Successful.';\r\n            if(respData['message']){\r\n              response.message = respData['message'];\r\n            }\r\n            this.authDataShareService.setAuthentication(true);\r\n            this.authDataShareService.setAuthenticationResponce(response);\r\n        }\r\n      },\r\n      (error)=>{\r\n        response.msg = error.message;\r\n        response.status = 'error';\r\n        response.class = 'bg-danger';\r\n        this.authDataShareService.setAuthenticationResponce(response);\r\n      }\r\n    )\r\n  }\r\n}\r\n"]}