@thetradeengineorg1/snova-shell-module 0.0.1

package/esm2015/lib/shell-components/components/header-side/header-side.component.js

@@ -0,0 +1,1642 @@
+import { __awaiter } from "tslib";
+import { FetchTimeSheetButtonDetails, RolesFetchTriggered } from './../../store/actions/authentication.actions';
+import { Component, Inject, Input, ViewChild, Output, EventEmitter, ViewChildren } from "@angular/core";
+import { ReceiveMessageTriggered, PresenceEventTriggered, InitalStateOfUsersTriggered, MessageActionTypes, ReceiveChannelUpdateModelTriggered, ReceiveSignalTriggered, } from "../../store/actions/chat.actions";
+import { select } from "@ngrx/store";
+import { Subject } from "rxjs";
+import { takeUntil, tap } from "rxjs/operators";
+import { GetUserStoreIdTriggered, AuthenticationActionTypes } from "../../store/actions/authentication.actions";
+import { ClearAllUnreadNotificationsTriggered, ClearUnreadNotificationsTriggered, NewNotificationReceived, NotificationsActionTypes, UpsertUnreadNotificationsTriggered } from "../../store/actions/notifications.actions";
+import * as sharedModuleReducers from "../../store/reducers/index";
+import '../../../globaldependencies/helpers/fontawesome-icons';
+import { ConfirmationDialogComponent } from "../confirmation-dialog/confirmation-dialog.component";
+import { ofType } from "@ngrx/effects";
+import { LocalStorageProperties } from '../../../globaldependencies/constants/localstorage-properties';
+import { ChannelNames } from '../../constants/channel-names';
+import { WINDOW } from '../../../globaldependencies/helpers/window.helper';
+import { CustomAppBaseComponent } from '../../../globaldependencies/components/componentbase';
+import { AppNotification } from '../../models/AppNotification';
+import { StoreSearchModel } from '../../models/store-search-model';
+import { WorkItemsDialogComponent } from '../all-work-items-dialog/all-work-items-dialog.component';
+import { FeedTimeDialogComponent } from '../feed-time/feed-time-dialog.component';
+import { NotificationTypeIds } from '../../constants/notification-type-ids';
+import { UserStoryAssignedNotification } from '../../models/UserStoryAssignedNotification';
+import { ChannelRoutes } from '../../constants/notification-routes';
+import { RoleUpdatedNotification } from '../../models/RoleUpdatedNotification';
+import { ReportSubmittedNotification } from '../../models/ReportSubmittedNotification';
+import { ReportConfigAssignedNotification } from '../../models/ReportConfigAssignedNotification';
+import { MultipleChartsScheduling } from '../../models/multiChartsScheduling';
+import { AssetAssignedNotification } from '../../models/AssetAssignedNotificationModel';
+import { NewProjectCreatedNotificationModel } from '../../models/NewProjectCreatedNotificationModel';
+import { GoalApprovedNotificationModel } from '../../models/goalApprovedNotificationModel';
+import { UserStoryUpdateNotificationModel } from '../../models/userStoryUpdateNotificationModel';
+import { UserStoryCommentNotificationModel } from '../../models/userStoryCommentNotificationModel';
+import { SprintStartedNotificationModel } from '../../models/sprintStartedNotificationModel';
+import { SprintReplanStartedNotificationModel } from '../../models/sprintReplanRequestedModel';
+import { animate, style, transition, trigger } from '@angular/animations';
+import { SPINNER } from 'ngx-ui-loader';
+import { NewProjectFeatureCreatedNotificationModel } from '../../models/NewProjectFeatureNotificationModel';
+import { UserStoryArchiveNotificationModel } from '../../models/archiveUserStoryModel';
+import { UserStoryParkNotificationModel } from '../../models/parkUserStoryInputModel';
+import { ExportConfigurationDialogComponent } from '../export-import-configuration/export-configuration.component';
+import { FileResultModel } from '@snovasys/snova-document-management';
+// import { ConstantVariables } from "../constants/constant-variables";
+import Resumable from "resumablejs";
+import { ApiUrls } from '../../constants/api-urls';
+import { AvailableLangs } from '../../constants/available-languages';
+import { ImportConfigurationModel } from '../../models/import-configuration-model';
+import { MessageTypingDetails } from '../../models/MessageTypingDetails';
+import { IntroModel } from "../../models/IntroModel";
+import { LeaveApplicationNotification } from '../../models/leaveApplicationNotifiction';
+import * as i0 from "@angular/core";
+import * as i1 from "ng-push-ivy";
+import * as i2 from "../../services/theme.service";
+import * as i3 from "ngx-ui-loader";
+import * as i4 from "../../services/layout.service";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "@angular/router";
+import * as i7 from "ngx-cookie-service";
+import * as i8 from "@angular/material/dialog";
+import * as i9 from "../../services/common-used.service";
+import * as i10 from "@ngrx/store";
+import * as i11 from "pubnub-angular2";
+import * as i12 from "../../services/authentication.service";
+import * as i13 from "@ngrx/effects";
+import * as i14 from "ngx-toastr";
+import * as i15 from "@snovasys/snova-document-management";
+import * as i16 from "../../services/shell.modules.service";
+import * as i17 from "../../services/chat.service";
+import * as i18 from "../../services/signalr.service";
+import * as i19 from "@angular/material/toolbar";
+import * as i20 from "../menu/menu.component";
+import * as i21 from "@angular/material/select";
+import * as i22 from "@snovasys/snova-avatar";
+import * as i23 from "@angular/material/form-field";
+import * as i24 from "@angular/material/icon";
+import * as i25 from "@angular/material/core";
+import * as i26 from "@angular/material/button";
+import * as i27 from "@angular/material/menu";
+import * as i28 from "../notifications/notifications.component";
+import * as i29 from "@ncstate/sat-popover";
+import * as i30 from "../feed-time/feed-time.component";
+import * as i31 from "@angular/material/divider";
+import * as i32 from "../submit-feedback/submit-feedback.component";
+import * as i33 from "@angular/material/list";
+import * as i34 from "@angular/material/card";
+import * as i35 from "@fortawesome/angular-fontawesome";
+import * as i36 from "ngx-dropzone";
+import * as i37 from "@angular/material/progress-bar";
+import * as i38 from "../notifications/announcement-dialog.component";
+import * as i39 from "@angular/flex-layout/flex";
+import * as i40 from "@angular/flex-layout/extended";
+import * as i41 from "@angular/common";
+import * as i42 from "@angular/forms";
+import * as i43 from "@angular/material/tooltip";
+import * as i44 from "@angular/material/input";
+import * as i45 from "../../../globaldependencies/pipes/removeSpecialCharacters.pipe";
+import * as i46 from "../../../globaldependencies/pipes/fetchSizedAndCachedImage.pipe";
+import * as i47 from "../../../globaldependencies/pipes/softlabels.pipes";
+/** @dynamic */
+export class HeaderSideComponent extends CustomAppBaseComponent {
+    constructor(pushNotifications, themeService, ngxService, layout, translate, router, cookieService, dialog, commonService, store, pubnub, authService, actionUpdates$, cdRef, toastr, storeManagementService, ShellModulesService, chatService, signalr, window) {
+        super();
+        this.pushNotifications = pushNotifications;
+        this.themeService = themeService;
+        this.ngxService = ngxService;
+        this.layout = layout;
+        this.translate = translate;
+        this.router = router;
+        this.cookieService = cookieService;
+        this.dialog = dialog;
+        this.commonService = commonService;
+        this.store = store;
+        this.pubnub = pubnub;
+        this.authService = authService;
+        this.actionUpdates$ = actionUpdates$;
+        this.cdRef = cdRef;
+        this.toastr = toastr;
+        this.storeManagementService = storeManagementService;
+        this.ShellModulesService = ShellModulesService;
+        this.chatService = chatService;
+        this.signalr = signalr;
+        this.window = window;
+        this.opened = new EventEmitter();
+        this.spinnerType = SPINNER.circle;
+        this.availableLangs = AvailableLangs.languages;
+        this.availableLangsMobile = [
+            {
+                name: "En",
+                code: "en"
+            },
+            {
+                name: "Te",
+                code: "te"
+            },
+            {
+                name: "Ko",
+                code: "ko"
+            },
+            {
+                name: "Ar",
+                code: "ar"
+            }
+        ];
+        this.ngDestroyed$ = new Subject();
+        this.dashboardFilters = {
+            projectId: null,
+            userId: null,
+            goalId: null,
+            isDailogue: true
+        };
+        this.timePunchCardShow = false;
+        this.showTrailPeriod = false;
+        this.companiesList = [];
+        this.selectedStoreId = "";
+        this.isRecording = false;
+        this.projectRoleText = 'Project role configuration';
+        this.loggedInUserId = "";
+        this.showDeleteIcon = false;
+        this.showDelete = false;
+        this.isStoreAccess = true;
+        this.files = [];
+        this.moduleTypeId = 9;
+        this.fileIndex = 0;
+        this.fileCounter = 1;
+        this.uploadedFileNames = [];
+        this.isFileUploadCompleted = false;
+        this.isFolderUploadCompleted = false;
+        this.searchText = null;
+        this.logInUserId = this.cookieService.get("CurrentUserId");
+        this.newNotificationsCount = 0;
+        // this.signalr.initializeSignalRConnection();
+        this.signalr.notifications$.subscribe((data) => this.newNotificationsCount = data && data.length ? data.length : 0);
+        this.pushNotifications.requestPermission();
+        this.isRecording = false;
+        // this.getActTrackerRecorder();
+        if ((localStorage.getItem(LocalStorageProperties.UserModel) != null && localStorage.getItem(LocalStorageProperties.UserModel) != undefined)) {
+            this.loadNotifications();
+        }
+        let currentCulture = this.cookieService.get(LocalStorageProperties.CurrentCulture);
+        const companylan = JSON.parse(this.cookieService.get(LocalStorageProperties.CompanyDetails));
+        let currentCulturelan = companylan.lanCode;
+        if (currentCulture == '' || currentCulture == null || currentCulture == undefined || currentCulture === 'null' || currentCulture === 'undefined') {
+            if (currentCulturelan == '' || currentCulturelan == null || currentCulturelan == undefined || currentCulturelan === 'null' || currentCulturelan === 'undefined') {
+                currentCulture = 'en';
+            }
+            else {
+                currentCulture = currentCulturelan;
+            }
+        }
+        this.currentLang = currentCulture;
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        this.cookieService.set(LocalStorageProperties.CurrentCulture, this.currentLang, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+        this.actionUpdates$
+            .pipe(takeUntil(this.ngDestroyed$), ofType(AuthenticationActionTypes.UserDetailsFetchedAfterCompanyLogin), tap(() => {
+            this.reload = true;
+            // this.chatService.getRecentChannelMessages().subscribe((recentChannelMessages: any) => {
+            //   recentChannelMessages.data.forEach(element => {
+            //     this.messagesUnreadCount += element.unreadMessageCount;
+            //   });
+            // });
+            // this.chatService.getRecentIndividualMessages().subscribe((recentColleagueMessages: any) => {
+            //   var uniq = {};
+            //   recentColleagueMessages.data = recentColleagueMessages.data.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));
+            //   recentColleagueMessages.data.forEach(element => {
+            //     if(element.id != this.loggedInUserId){
+            //     this.messagesUnreadCount += element.unreadMessageCount;
+            //     }
+            //   });
+            // });
+            this.getIntroDetails();
+            this.ngOnInit();
+            this.getNotifications();
+            this.getTeamMembers();
+            var DefaultDashboardIdForLoggedInUser = this.cookieService.check(LocalStorageProperties.DefaultDashboard) ? JSON.parse(this.cookieService.get(LocalStorageProperties.DefaultDashboard)) : null;
+            const userReference = localStorage.getItem(LocalStorageProperties.UserReferenceId);
+            if (!DefaultDashboardIdForLoggedInUser) {
+                this.router.navigate([this.returnUrl]);
+            }
+            else if (userReference != "null" && userReference != null) {
+                this.router.navigateByUrl("dashboard-management/dashboard/" + DefaultDashboardIdForLoggedInUser + "/form/" + userReference);
+            }
+            else {
+                this.router.navigateByUrl("dashboard-management/dashboard/" + DefaultDashboardIdForLoggedInUser);
+            }
+        }))
+            .subscribe();
+        this.actionUpdates$
+            .pipe(takeUntil(this.ngDestroyed$), ofType(AuthenticationActionTypes.UserDetailsFetchedAfterLogin), tap(() => {
+            setTimeout(() => {
+                if (this.cookieService.check(LocalStorageProperties.CurrentUserId)) {
+                    const CurrentUserId = this.cookieService.get(LocalStorageProperties.CurrentUserId);
+                    // Subscribe to Task Assignment Notificaitons here.
+                    const taskAssignmentChannelToSubscribeInto = ChannelNames.Channel_TaskAssignments + CurrentUserId;
+                    const tastatusReportSubmissionChannelToSubscribeInto = ChannelNames.Channel_StatusReportSubmission + CurrentUserId;
+                    const tastatusConfigAssignChannelToSubscribeInto = ChannelNames.Channel_StatusConfigAssign + CurrentUserId;
+                    const multiChartsSchedulingChannelToSubscribeInto = ChannelNames.Channel_MultiChartsScheduling + CurrentUserId;
+                    const assetsAssignedChannelToSubscribeInto = ChannelNames.Channel_AssetAssignment + CurrentUserId;
+                    const projectCreatedChannelToSubscribeInto = ChannelNames.Channel_NewProject + CurrentUserId;
+                    const projectAccessToMemberChannelToSubscribeInto = ChannelNames.Channel_ProjectMemberRole + CurrentUserId;
+                    const goalApprovedChannelToSubscribeInto = ChannelNames.Channel_GoalApprovedFromReplan + CurrentUserId;
+                    const userStoryUpdateChannelToSubscribeInto = ChannelNames.Channel_UserStoryUpdateNotification + CurrentUserId;
+                    const AnnouncementChannelToSubscribeInto = ChannelNames.Channel_AnnouncementNotification + CurrentUserId;
+                    const purchaseExecutionAssignedChannelToSubscribeInto = ChannelNames.Channel_PurchaseExecutionAssignToEmployeeNotification + CurrentUserId;
+                    console.log("subscribing to " + taskAssignmentChannelToSubscribeInto);
+                    console.log("subscribing to " + tastatusReportSubmissionChannelToSubscribeInto);
+                    console.log("subscribing to " + tastatusConfigAssignChannelToSubscribeInto);
+                    console.log("subscribing to" + assetsAssignedChannelToSubscribeInto);
+                    console.log("subscribing to" + projectCreatedChannelToSubscribeInto);
+                    console.log("subscribing to" + projectAccessToMemberChannelToSubscribeInto);
+                    console.log("subscribing to" + goalApprovedChannelToSubscribeInto);
+                    console.log("subscribing to" + userStoryUpdateChannelToSubscribeInto);
+                    console.log("subscribing to" + AnnouncementChannelToSubscribeInto);
+                    console.log("subscribing to" + purchaseExecutionAssignedChannelToSubscribeInto);
+                    pubnub.subscribe({
+                        channels: [taskAssignmentChannelToSubscribeInto, tastatusReportSubmissionChannelToSubscribeInto,
+                            tastatusConfigAssignChannelToSubscribeInto, multiChartsSchedulingChannelToSubscribeInto,
+                            assetsAssignedChannelToSubscribeInto, projectCreatedChannelToSubscribeInto, ,
+                            projectAccessToMemberChannelToSubscribeInto, goalApprovedChannelToSubscribeInto,
+                            userStoryUpdateChannelToSubscribeInto, AnnouncementChannelToSubscribeInto, purchaseExecutionAssignedChannelToSubscribeInto]
+                    });
+                    // Add other subscriptions here.
+                }
+                else {
+                    console.log("User not logged in yet to be able to subscribe.");
+                }
+                var roleUpdatesChannelToSubscribeInto = ChannelNames.Channel_RoleUpdates + "19B6F9FC-7370-4B9C-A05C-3B8D819EEEAF";
+                console.log("subscribing to " + roleUpdatesChannelToSubscribeInto);
+                pubnub.subscribe({
+                    channels: [roleUpdatesChannelToSubscribeInto]
+                });
+            }, 3000);
+        })).subscribe();
+        this.actionUpdates$
+            .pipe(takeUntil(this.ngDestroyed$), ofType(NotificationsActionTypes.ClearAllUnreadNotificationsCompleted), tap(() => {
+            this.notifications$ = this.store.pipe(select(sharedModuleReducers.getNotificationAll));
+            this.notifications$.subscribe(x => {
+                this.notifications = x;
+                const index = this.notifications.findIndex((p) => JSON.parse(p.notificationJson).NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.Announcement_Received.toString().toLowerCase());
+                if (index > -1) {
+                    //this.announceNotificationId = JSON.parse(this.notifications[index].notificationJson).notificationId;
+                    this.announceNotificationId = this.notifications[index].notificationId;
+                    this.openAnnouncementDialog(JSON.parse(this.notifications[index].notificationJson));
+                }
+            });
+        }))
+            .subscribe();
+        // this.actionUpdates$
+        //   .pipe(
+        //     takeUntil(this.ngDestroyed$),
+        //     ofType(MessageActionTypes.CountCompleted),
+        //     tap((result: any) => {
+        //       this.messagesUnreadCount = result.messageCount;
+        //       this.cdRef.detectChanges();
+        //     })
+        //   )
+        //   .subscribe();
+        this.actionUpdates$
+            .pipe(takeUntil(this.ngDestroyed$), ofType(MessageActionTypes.RequestingStateOfUsersCompleted), tap((result) => {
+            this.subScribingToPresenceChannel();
+        }))
+            .subscribe();
+        this.actionUpdates$
+            .pipe(takeUntil(this.ngDestroyed$), ofType(MessageActionTypes.MessageCompleted), tap((result) => {
+            var messageDetails = result['messageDetails'];
+            this.publishingMessageOfUser = messageDetails;
+            this.publishingMessage();
+        }))
+            .subscribe();
+        this.actionUpdates$
+            .pipe(takeUntil(this.ngDestroyed$), ofType(MessageActionTypes.SendChannelUpdateModelCompleted), tap((result) => {
+            var channelUpdateModel = result['channelUpdateModel'];
+            var loginCompanyId = this.cookieService.get("CompanyId");
+            this.pubnub.publish({
+                channel: [(loginCompanyId + '-' + channelUpdateModel.channelId)],
+                message: JSON.stringify(channelUpdateModel)
+            }, function (status, resopnse) {
+                // console.log(status)
+                // console.log(resopnse)
+            });
+        }))
+            .subscribe();
+        this.actionUpdates$
+            .pipe(takeUntil(this.ngDestroyed$), ofType(MessageActionTypes.SendingSignalCompleted), tap((result) => {
+            var messageTypingDetails = result.messageTypingDetails;
+            var signalMessage = new MessageTypingDetails();
+            signalMessage.state = messageTypingDetails.state;
+            console.log(messageTypingDetails, signalMessage);
+            // this.pubnub.signal({
+            //   channel:[messageTypingDetails.pubnubChannelNameOfMessage],
+            //   message : JSON.stringify(signalMessage)
+            // })
+        }))
+            .subscribe();
+        const storeListner = (message) => {
+            console.log("---------Received pubnub message---------");
+            //this.toastr.info(message.message.Summary);
+            try {
+                //Receiving the User Story Assigned Notification
+                if (typeof (message.message) == 'string') {
+                    var indexOfCurrentTopic;
+                    var messageDetailsObject = JSON.parse(message.message);
+                    if (messageDetailsObject.textMessage || messageDetailsObject.filePath || messageDetailsObject.messageType) {
+                        this.store.dispatch(new ReceiveMessageTriggered(messageDetailsObject));
+                    }
+                    else if (messageDetailsObject.isFromChannelArchive == true ||
+                        messageDetailsObject.isFromRemoveMember == true ||
+                        messageDetailsObject.refreshChannels == true || messageDetailsObject.isFromAddMember == true) {
+                        this.chatService.getUserChannels().subscribe((channels) => {
+                            this.channelList = channels.data;
+                            var loginCompanyId = this.cookieService.get("CompanyId");
+                            var channelName = loginCompanyId + '-' + messageDetailsObject.channelId;
+                            var index = this.channelList.findIndex(x => x.id == messageDetailsObject.channelId);
+                            if (index != -1 && (messageDetailsObject.refreshChannels == true || messageDetailsObject.isFromAddMember == true)) {
+                                this.pubnub.subscribe({
+                                    channels: [channelName]
+                                });
+                            }
+                            else {
+                                if (index == -1) {
+                                    this.pubnub.unsubscribe({
+                                        channels: [channelName]
+                                    });
+                                }
+                            }
+                            this.store.dispatch(new ReceiveChannelUpdateModelTriggered(messageDetailsObject));
+                        });
+                    }
+                    if (this.router.routerState.snapshot.url != "/chat" && messageDetailsObject.messageType != "Reaction" && messageDetailsObject.body != null && messageDetailsObject.title != null && (messageDetailsObject.isPinned == null || messageDetailsObject.isPinned == undefined) && (messageDetailsObject.isStarred == null || messageDetailsObject.isStarred == undefined) && messageDetailsObject.senderUserId != this.logInUserId) {
+                        if (messageDetailsObject.channelId) {
+                            this.chatService.getUserChannels().subscribe((channels) => {
+                                this.channelList = channels.data;
+                                indexOfCurrentTopic = this.channelList.findIndex(x => x.id == messageDetailsObject.channelId);
+                                if (indexOfCurrentTopic != -1) {
+                                    // this.notificationOfChat(messageDetailsObject);
+                                }
+                            });
+                        }
+                        else {
+                            // this.notificationOfChat(messageDetailsObject);
+                        }
+                    }
+                }
+                else if (message.message.NotificationTypeGuid == NotificationTypeIds.Notification_WorkItemAssignedToUser) {
+                    var userStoryAssignedNotification = new UserStoryAssignedNotification();
+                    userStoryAssignedNotification.loadFromCaseInsensitiveObject(message.message);
+                    userStoryAssignedNotification.route = ChannelRoutes.ViewWorkItem + userStoryAssignedNotification.notificationId;
+                    this.store.dispatch(new NewNotificationReceived(userStoryAssignedNotification));
+                }
+                else if (message.message.NotificationTypeGuid == NotificationTypeIds.GenericNotificationActivity) {
+                    var userStoryAssignedNotification = new UserStoryAssignedNotification();
+                    userStoryAssignedNotification.loadFromCaseInsensitiveObject(message.message);
+                    // userStoryAssignedNotification.route = ChannelRoutes.ViewWorkItem + userStoryAssignedNotification.notificationId;
+                    this.store.dispatch(new NewNotificationReceived(userStoryAssignedNotification));
+                }
+                else if (message.message.NotificationTypeGuid == NotificationTypeIds.Notification_RoleUpdated) {
+                    var roleUpdatedNotification = new RoleUpdatedNotification();
+                    roleUpdatedNotification.loadFromCaseInsensitiveObject(message.message);
+                    roleUpdatedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(roleUpdatedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid == NotificationTypeIds.Status_Report_Sumitted) {
+                    var reportSubmittedNotification = new ReportSubmittedNotification();
+                    reportSubmittedNotification.loadFromCaseInsensitiveObject(message.message);
+                    reportSubmittedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(reportSubmittedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid == NotificationTypeIds.Status_Report_Config_Created) {
+                    var reportConfigAssignedNotification = new ReportConfigAssignedNotification();
+                    reportConfigAssignedNotification.loadFromCaseInsensitiveObject(message.message);
+                    reportConfigAssignedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(reportConfigAssignedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid == NotificationTypeIds.Multiple_Charts_Scheduling_created) {
+                    var multipleChartsScheduling = new MultipleChartsScheduling();
+                    multipleChartsScheduling.loadFromCaseInsensitiveObject(message.message);
+                    multipleChartsScheduling.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(multipleChartsScheduling));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid == NotificationTypeIds.Assets_Assignment) {
+                    const assetAssignedNotification = new AssetAssignedNotification();
+                    assetAssignedNotification.loadFromCaseInsensitiveObject(message.message);
+                    assetAssignedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(assetAssignedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.Reminder_Notification.toString().toLowerCase()) {
+                    const assetAssignedNotification = new AssetAssignedNotification();
+                    assetAssignedNotification.loadFromCaseInsensitiveObject(message.message);
+                    assetAssignedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(assetAssignedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.Announcement_Received.toString().toLowerCase()) {
+                    const assetAssignedNotification = new AssetAssignedNotification();
+                    assetAssignedNotification.loadFromCaseInsensitiveObject(message.message);
+                    assetAssignedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(assetAssignedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                    // if (message.message.Id != this.announceNotificationId) {
+                    //   this.announceNotificationId = message.message.Id;
+                    //   this.openAnnouncementDialog(message.message);
+                    // }
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.Performance_Received.toString().toLowerCase() || message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ProjectMemberRoleAddedNotificationId.toString().toLowerCase()) {
+                    const newProjectCreatedNotification = new NewProjectCreatedNotificationModel();
+                    newProjectCreatedNotification.loadFromCaseInsensitiveObject(message.message);
+                    newProjectCreatedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(newProjectCreatedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.NewProjectCreatedNotificationId.toString().toLowerCase() || message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ProjectMemberRoleAddedNotificationId.toString().toLowerCase()) {
+                    const newProjectCreatedNotification = new NewProjectCreatedNotificationModel();
+                    newProjectCreatedNotification.loadFromCaseInsensitiveObject(message.message);
+                    newProjectCreatedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(newProjectCreatedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.GoalApprovedFromReplan.toString().toLowerCase()) {
+                    const goalApprovedNotificationModel = new GoalApprovedNotificationModel();
+                    goalApprovedNotificationModel.loadFromCaseInsensitiveObject(message.message);
+                    goalApprovedNotificationModel.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(goalApprovedNotificationModel));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.USerStoryUpdateNotificationId.toString().toLowerCase()) {
+                    const userStoryUpdateNotificationModel = new UserStoryUpdateNotificationModel();
+                    userStoryUpdateNotificationModel.loadFromCaseInsensitiveObject(message.message);
+                    userStoryUpdateNotificationModel.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(userStoryUpdateNotificationModel));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PushNotificationForUserStoryComment.toString().toLowerCase()) {
+                    const userStoryCommentNotificationModel = new UserStoryCommentNotificationModel();
+                    userStoryCommentNotificationModel.loadFromCaseInsensitiveObject(message.message);
+                    userStoryCommentNotificationModel.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(userStoryCommentNotificationModel));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.SprintStarted.toString().toLowerCase()) {
+                    const sprintStartedNotificationModel = new SprintStartedNotificationModel();
+                    sprintStartedNotificationModel.loadFromCaseInsensitiveObject(message.message);
+                    sprintStartedNotificationModel.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(sprintStartedNotificationModel));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.SprintRequestdForREplan.toString().toLowerCase()) {
+                    const sprintReplanStartedNotificationModel = new SprintReplanStartedNotificationModel();
+                    sprintReplanStartedNotificationModel.loadFromCaseInsensitiveObject(message.message);
+                    sprintReplanStartedNotificationModel.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(sprintReplanStartedNotificationModel));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ProjectFeature.toString().toLowerCase()) {
+                    const newProjectFeatureCreatedNotification = new NewProjectFeatureCreatedNotificationModel();
+                    newProjectFeatureCreatedNotification.loadFromCaseInsensitiveObject(message.message);
+                    newProjectFeatureCreatedNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(newProjectFeatureCreatedNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.UserStoryArchive.toString().toLowerCase()) {
+                    const newUserStoryArchiveModel = new UserStoryArchiveNotificationModel();
+                    newUserStoryArchiveModel.loadFromCaseInsensitiveObject(message.message);
+                    newUserStoryArchiveModel.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(newUserStoryArchiveModel));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.UserStoryPark.toString().toLowerCase()) {
+                    const newUserStoryParkModel = new UserStoryParkNotificationModel();
+                    newUserStoryParkModel.loadFromCaseInsensitiveObject(message.message);
+                    newUserStoryParkModel.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(newUserStoryParkModel));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.LeaveApplication.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ApproveLeaveApplication.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.RejectLeaveApplication.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ResignationNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ResignationApprovalNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ResignationRejectionNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.AutoTimeSheetSubmissionNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ProbationAssignNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ReviewAssignToEmployeeNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ReviewSubmittedByEmployeeNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ReviewInvitationNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PerformanceReviewSubmittedByEmployeeNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PerformanceReviewInvitationNotificationModel.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PerformanceReviewAssignToEmployeeNotification.toString().toLowerCase()) {
+                    const leaveApplicationNotification = new LeaveApplicationNotification();
+                    leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);
+                    leaveApplicationNotification.route = ChannelRoutes.ViewAccount;
+                    this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PurchaseShipmentNotificationId.toString().toLowerCase()) {
+                    const purchaseExecutionNotification = new LeaveApplicationNotification();
+                    purchaseExecutionNotification.loadFromCaseInsensitiveObject(message.message);
+                    purchaseExecutionNotification.route = ChannelRoutes.EditPurchaseExecution;
+                    this.store.dispatch(new NewNotificationReceived(purchaseExecutionNotification));
+                    this.store.dispatch(new RolesFetchTriggered());
+                }
+                else {
+                    // TODO: Send these errors onto server for further processing
+                    console.log("Found undetected notification type. " + message.message.NotificationTypeGuid);
+                }
+                // Add other notifications here.
+            }
+            catch (exception) {
+                // TODO: Send these exceptions onto server for further processing
+                console.log("Exception Occured" + exception.message);
+            }
+        };
+        const statusOfUser = (presenceEvent) => {
+            this.store.dispatch(new PresenceEventTriggered(presenceEvent));
+        };
+        const typingStatus = (signalEvent) => {
+            this.store.dispatch(new ReceiveSignalTriggered(signalEvent));
+        };
+        this.chatService.getPubnubKeys().subscribe((keys) => {
+            this.pubnub.init({
+                publishKey: keys.data.publishKey,
+                subscribeKey: keys.data.subscribeKey,
+                uuid: this.logInUserId
+            });
+            this.chatService.getAllUsersForSlackApp().subscribe((colleagues) => {
+                this.colleaguesList = colleagues.data;
+                this.chatService.getUserChannels().subscribe((channels) => {
+                    this.channelList = channels.data;
+                    this.signOutUserChannels();
+                    var loginCompanyId = this.cookieService.get("CompanyId");
+                    if (this.channelList != undefined || this.channelList != null) {
+                        for (var index1 = 0; index1 < this.channelList.length; index1++) {
+                            this.pubnub.subscribe({
+                                channels: [(loginCompanyId + '-' + this.channelList[index1].id)]
+                            });
+                        }
+                    }
+                    this.pubnub.subscribe({
+                        channels: [('ChannelUpdates-' + loginCompanyId)]
+                    });
+                    this.pubnub.subscribe({
+                        channels: [('UserUpdates-' + loginCompanyId)]
+                    });
+                    var index12 = this.colleaguesList.findIndex(x => x.userId == this.logInUserId);
+                    if (index12 > -1) {
+                        var name = this.colleaguesList[index12].fullName;
+                        name = name.trim();
+                        name = this.replaceAll(name, " ", "");
+                        this.loginUserchannelName = (name + '-' + this.logInUserId);
+                        this.pubnub.subscribe({
+                            channels: [this.loginUserchannelName]
+                        });
+                    }
+                });
+            });
+            this.pubnub.addListener({
+                status: st => {
+                    if (st.category === "PNUnknownCategory") {
+                        var newState = {
+                            new: "error"
+                        };
+                        this.pubnub.setState({
+                            state: newState
+                        }
+                        // function (status) {
+                        //   console.log(st.errorData.message);
+                        // }
+                        );
+                    }
+                },
+                signal: signalEvent => {
+                    typingStatus(signalEvent);
+                },
+                presence: presenceEvent => {
+                    statusOfUser(presenceEvent);
+                },
+                message: message => {
+                    console.log("subscribed to " + message);
+                    storeListner(message);
+                }
+            });
+        });
+    }
+    signOutUserChannels() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pubnub.unsubscribe({ channels: [this.loginUserchannelName] });
+            var loginCompanyId = this.cookieService.get("CompanyId");
+            if (this.channelList != undefined || this.channelList != null) {
+                for (var index = 0; index < this.channelList.length; index++) {
+                    this.pubnub.unsubscribe({
+                        channels: [(loginCompanyId + '-' + this.channelList[index].id)]
+                    });
+                }
+            }
+            this.pubnub.unsubscribe({
+                channels: [('ChannelUpdates-' + loginCompanyId)]
+            });
+            this.pubnub.unsubscribe({
+                channels: [('UserUpdates-' + loginCompanyId)]
+            });
+        });
+    }
+    subScribingToPresenceChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var loginCompanyId = this.cookieService.get("CompanyId");
+            var presenceChannel = "MessengerPresence-" + loginCompanyId;
+            yield this.pubnub.subscribe({
+                channels: [presenceChannel],
+                withPresence: true
+            });
+            this.pubnub.hereNow({
+                channels: [presenceChannel],
+                includeUUIDs: true,
+                includeState: true
+            }, (status, response) => {
+                this.store.dispatch(new InitalStateOfUsersTriggered(response));
+            });
+        });
+    }
+    publishingMessage() {
+        if (this.publishingMessageOfUser.pubnubChannelNameOfMessage.length > 0) {
+            this.publishingMessageOfUser.pubnubChannelNameOfMessage.forEach(channelName => {
+                this.pubnub.publish({
+                    channel: [channelName],
+                    message: JSON.stringify(this.publishingMessageOfUser)
+                }, function (status, resopnse) {
+                    // console.log(status)
+                    // console.log(resopnse)
+                });
+            });
+        }
+    }
+    openAnnouncementDialog(announced) {
+        this.dialog.closeAll();
+        let dialogId = "annoucement-dialog";
+        const dialogRef = this.dialog.open(this.openAnnoucementDialogComponent, {
+            minWidth: "60vw",
+            maxWidth: "60vw",
+            minHeight: "50vh",
+            maxHeight: "80vh",
+            disableClose: true,
+            id: dialogId,
+            data: {
+                dialogId: dialogId,
+                announcementId: announced.AnnouncementId,
+                announcement: announced.Announcement,
+                announcedBy: announced.AnnouncedBy,
+                announcedById: announced.AnnouncedById,
+                announcedByUserImage: announced.AnnouncedByUserImage,
+                announcedOn: announced.AnnouncedOn
+            }
+        });
+        dialogRef.afterClosed().subscribe((result) => {
+            const index = this.notifications.findIndex((p) => p.notificationId.toString().toLowerCase() == this.announceNotificationId.toString().toLowerCase());
+            if (index > -1) {
+                this.upsertReadNotification(this.notifications[index]);
+            }
+        });
+    }
+    // notificationOfChat(messageDetailsObject) {
+    //   if(this.previousMessage != messageDetailsObject){
+    //   this.messagesUnreadCount += 1;
+    //   var imageforNotification: any;
+    //   if (messageDetailsObject.senderProfileImage == null) {
+    //     imageforNotification = "https://pngimage.net/wp-content/uploads/2018/05/avatar-png-images-1.png";
+    //   }
+    //   else {
+    //     imageforNotification = messageDetailsObject.senderProfileImage;
+    //   }
+    //   let options = {
+    //     body: messageDetailsObject.body,
+    //     icon: imageforNotification,
+    //     data: {
+    //       senderUserId: messageDetailsObject.senderUserId,
+    //       channelId: messageDetailsObject.channelId
+    //     }
+    //   }
+    //   this.pushNotifications.create(messageDetailsObject.title, options).subscribe(
+    //     res => {
+    //       if (res.event.type === 'click') {
+    //         window.focus();
+    //         if (this.router.url != '/chat') {
+    //           if (res.notification.data.channelId != null && res.notification.data.channelId != undefined) {
+    //             localStorage.setItem(LocalStorageProperties.ChatId, res.notification.data.channelId);
+    //           } else {
+    //             localStorage.setItem(LocalStorageProperties.ChatId, res.notification.data.senderUserId);
+    //           }
+    //           this.router.navigate(["/chat"]);
+    //         }
+    //       }
+    //     },
+    //     err => console.log(err)
+    //   );
+    //   this.previousMessage = messageDetailsObject
+    //   }
+    // }
+    upsertReadNotification(selectedNotification) {
+        const notifications = [];
+        notifications.push(selectedNotification);
+        const notiifcationmodel = JSON.parse(selectedNotification.notificationJson);
+        if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.NewProjectCreatedNotificationId.toString().toLowerCase() ||
+            selectedNotification.notificationTypeId.toString().toLowerCase() ==
+                NotificationTypeIds.ProjectMemberRoleAddedNotificationId.toString().toLowerCase()) {
+            this.router.navigate(["projects/projectstatus/" + notiifcationmodel.ProjectGuid + "/active-goals"]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.GoalApprovedFromReplan.toString().toLowerCase()) {
+            this.router.navigate(["projects/goal/" + notiifcationmodel.GoalGuid]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.Notification_WorkItemAssignedToUser.toString().toLowerCase()) {
+            this.router.navigate(["projects/workitem/" + notiifcationmodel.UserStoryGuid]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.USerStoryUpdateNotificationId.toString().toLowerCase()) {
+            this.router.navigate(["projects/workitem/" + notiifcationmodel.UserStoryId]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.SprintStarted.toString().toLowerCase()) {
+            this.router.navigate(["projects/sprint/" + notiifcationmodel.SprintGuid]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.PushNotificationForUserStoryComment.toString().toLowerCase()) {
+            this.router.navigate(["projects/workitem/" + notiifcationmodel.UserStoryGuid]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.GoalRequestdForREplan.toString().toLowerCase()) {
+            this.router.navigate(["projects/goal/" + notiifcationmodel.GoalGuid]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.SprintRequestdForREplan.toString().toLowerCase()) {
+            this.router.navigate(["projects/sprint/" + notiifcationmodel.SprintGuid]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.Notification_AdhocWorkItemAssignedToUser.toString().toLowerCase()) {
+            this.router.navigate(["dashboard/adhoc-workitem/" + notiifcationmodel.UserStoryGuid]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.AdhocUSerStoryUpdateNotificationId.toString().toLowerCase()) {
+            this.router.navigate(["dashboard/adhoc-workitem/" + notiifcationmodel.UserStoryId]);
+        }
+        else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==
+            NotificationTypeIds.PurchaseShipmentNotificationId.toString().toLowerCase()) {
+            this.router.navigate(["client/purchase-execution/" + notiifcationmodel.PurchaseGuid]);
+        }
+        this.store.dispatch(new UpsertUnreadNotificationsTriggered(notifications));
+    }
+    loadNotifications() {
+        const CurrentUserId = this.cookieService.get(LocalStorageProperties.CurrentUserId);
+        // Subscribe to Task Assignment Notificaitons here.
+        const taskAssignmentChannelToSubscribeInto = ChannelNames.Channel_TaskAssignments + CurrentUserId;
+        const tastatusReportSubmissionChannelToSubscribeInto = ChannelNames.Channel_StatusReportSubmission + CurrentUserId;
+        const tastatusConfigAssignChannelToSubscribeInto = ChannelNames.Channel_StatusConfigAssign + CurrentUserId;
+        const multiChartsSchedulingChannelToSubscribeInto = ChannelNames.Channel_MultiChartsScheduling + CurrentUserId;
+        const assetsAssignedChannelToSubscribeInto = ChannelNames.Channel_AssetAssignment + CurrentUserId;
+        const projectCreatedChannelToSubscribeInto = ChannelNames.Channel_NewProject + CurrentUserId;
+        const projectAccessToMemberChannelToSubscribeInto = ChannelNames.Channel_ProjectMemberRole + CurrentUserId;
+        const goalApprovedChannelToSubscribeInto = ChannelNames.Channel_GoalApprovedFromReplan + CurrentUserId;
+        const userStoryUpdateChannelToSubscribeInto = ChannelNames.Channel_UserStoryUpdateNotification + CurrentUserId;
+        const AnnouncementChannelToSubscribeInto = ChannelNames.Channel_AnnouncementNotification + CurrentUserId;
+        const ReminderChannelToSubscribeInto = ChannelNames.Channel_ReminderNotification + CurrentUserId;
+        const PerformanceChannelToSubscribeInto = ChannelNames.Channel_PeroformanceNotification + CurrentUserId;
+        const userStoryCommentChannelToSubscribeInto = ChannelNames.Channel_UserStoryComment + CurrentUserId;
+        const sprintStartedChannelToSubscribeInto = ChannelNames.Channel_SprintStarted + CurrentUserId;
+        const sprintReplanChannelToSubscribeInto = ChannelNames.Channel_SprintRequestedToReplan + CurrentUserId;
+        const projectFeatureChannelToSubscribeInto = ChannelNames.Channel_ProjectFeature + CurrentUserId;
+        const userStoryArchiveChannelToSubscribeInto = ChannelNames.Channel_UserStoryArchive + CurrentUserId;
+        const userStoryParkChannelToSubscribeInto = ChannelNames.Channel_UserStoryPark + CurrentUserId;
+        const genericActivityNotificationChannelToSubscribeInto = ChannelNames.Channel_GenericActivityNotification + CurrentUserId;
+        const purchaseExecutionAssignedChannelToSubscribeInto = ChannelNames.Channel_GenericActivityNotification + CurrentUserId;
+        console.log("subscribing to " + taskAssignmentChannelToSubscribeInto);
+        console.log("subscribing to " + tastatusReportSubmissionChannelToSubscribeInto);
+        console.log("subscribing to " + tastatusConfigAssignChannelToSubscribeInto);
+        console.log("subscribing to" + assetsAssignedChannelToSubscribeInto);
+        console.log("subscribing to" + projectCreatedChannelToSubscribeInto);
+        console.log("subscribing to" + projectAccessToMemberChannelToSubscribeInto);
+        console.log("subscribing to" + goalApprovedChannelToSubscribeInto);
+        console.log("subscribing to" + userStoryUpdateChannelToSubscribeInto);
+        console.log("subscribing to" + AnnouncementChannelToSubscribeInto);
+        console.log("subscribing to" + userStoryCommentChannelToSubscribeInto);
+        console.log("subscribing to" + sprintStartedChannelToSubscribeInto);
+        console.log("subscribing to" + sprintReplanChannelToSubscribeInto);
+        console.log("subscribing to" + ReminderChannelToSubscribeInto);
+        console.log("subscribing to" + PerformanceChannelToSubscribeInto);
+        console.log("subscribing to" + projectFeatureChannelToSubscribeInto);
+        console.log("subscribing to" + userStoryArchiveChannelToSubscribeInto);
+        console.log("subscribing to" + userStoryParkChannelToSubscribeInto);
+        console.log("subscribing to" + genericActivityNotificationChannelToSubscribeInto);
+        console.log("subscribing to" + purchaseExecutionAssignedChannelToSubscribeInto);
+        this.pubnub.subscribe({
+            channels: [taskAssignmentChannelToSubscribeInto, tastatusReportSubmissionChannelToSubscribeInto,
+                tastatusConfigAssignChannelToSubscribeInto, multiChartsSchedulingChannelToSubscribeInto,
+                assetsAssignedChannelToSubscribeInto, projectCreatedChannelToSubscribeInto, ,
+                projectAccessToMemberChannelToSubscribeInto, goalApprovedChannelToSubscribeInto,
+                userStoryUpdateChannelToSubscribeInto, AnnouncementChannelToSubscribeInto, ReminderChannelToSubscribeInto,
+                userStoryCommentChannelToSubscribeInto, sprintStartedChannelToSubscribeInto,
+                sprintReplanChannelToSubscribeInto,
+                PerformanceChannelToSubscribeInto,
+                projectFeatureChannelToSubscribeInto,
+                userStoryArchiveChannelToSubscribeInto,
+                userStoryParkChannelToSubscribeInto, genericActivityNotificationChannelToSubscribeInto, purchaseExecutionAssignedChannelToSubscribeInto]
+        });
+        var roleUpdatesChannelToSubscribeInto = ChannelNames.Channel_RoleUpdates + "19B6F9FC-7370-4B9C-A05C-3B8D819EEEAF";
+        console.log("subscribing to " + roleUpdatesChannelToSubscribeInto);
+        this.pubnub.subscribe({
+            channels: [roleUpdatesChannelToSubscribeInto]
+        });
+    }
+    replaceAll(str, find, replace) {
+        var escapedFind = find.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
+        return str.replace(new RegExp(escapedFind, 'g'), replace);
+    }
+    ngOnInit() {
+        this.signalr.getNotificationsFromApi().subscribe();
+        this.getSoftLabels();
+        if (this.cookieService.check(LocalStorageProperties.DisplayWelComeNote) && this.cookieService.get(LocalStorageProperties.DisplayWelComeNote) == 'true') {
+            if ((localStorage.getItem(LocalStorageProperties.UserModel) != null && localStorage.getItem(LocalStorageProperties.UserModel) != undefined)) {
+                this.userFullName = JSON.parse(localStorage.getItem(LocalStorageProperties.UserModel)).fullName;
+            }
+            var count = this.cookieService.check(LocalStorageProperties.UserLoggedInCount);
+            if (count && this.cookieService.get(LocalStorageProperties.UserLoggedInCount) != 'null'
+                && this.cookieService.get(LocalStorageProperties.UserLoggedInCount) != 'undefined') {
+                this.loggedInCount = this.cookieService.get(LocalStorageProperties.UserLoggedInCount);
+                if (this.loggedInCount == '1' || this.loggedInCount == '2') {
+                    this.displayWelcomeNote = true;
+                    setTimeout(() => {
+                        this.displayWelcomeNote = false;
+                        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+                        this.cookieService.set(LocalStorageProperties.DisplayWelComeNote, 'false', null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+                    }, 8000);
+                }
+            }
+        }
+        let currentCulture = this.cookieService.get(LocalStorageProperties.CurrentCulture);
+        const companylan = JSON.parse(this.cookieService.get(LocalStorageProperties.CompanyDetails));
+        let currentCulturelan = companylan.lanCode;
+        if (currentCulture == '' || currentCulture == null || currentCulture == undefined || currentCulture === 'null' || currentCulture === 'undefined') {
+            if (currentCulturelan == '' || currentCulturelan == null || currentCulturelan == undefined || currentCulturelan === 'null' || currentCulturelan === 'undefined') {
+                currentCulture = 'en';
+            }
+            else {
+                currentCulture = currentCulturelan;
+            }
+        }
+        this.currentLang = currentCulture;
+        super.ngOnInit();
+        this.loadingInProgress$ = this.store.pipe(select(sharedModuleReducers.isTimeSheetFetching));
+        this.timeSheetButtonDetails$ = this.store.pipe(select(sharedModuleReducers.getTimeShettButtonDetails));
+        this.timeSheetButtonDetails$
+            .subscribe(data => {
+            this.timesheetDisableorEnable = data;
+        });
+        //this.getTimeSheetButtons();
+        //this.getUserStore();
+        this.showTrailPeriod = false;
+        this.egretThemes = this.themeService.egretThemes;
+        this.layoutConf = this.layout.layoutConf;
+        // this.themeModel$ = this.store.pipe(select(sharedModuleReducers.getThemeModel));
+        //this.store.dispatch(new InitializeAfterLoginData());
+        var user = JSON.parse(localStorage.getItem(LocalStorageProperties.UserModel));
+        if (user != null) {
+            this.monitorCompanyrelatedDetails(user);
+        }
+        this.loggedInUserId = this.cookieService.get(LocalStorageProperties.CurrentUserId);
+        this.getEmployeeIdByUserId();
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        this.applicationVersion = environment.version;
+        this.menuType = "Main";
+        this.selectedLangName = this.availableLangs.find(x => x.code == this.currentLang).name;
+        this.userStoreId$ = this.store.pipe(select(sharedModuleReducers.getUserStoreId));
+        this.userStoreId$.subscribe(result => {
+            this.userStoreId = result;
+        });
+    }
+    showHideDeleteButton(data) {
+        this.showDeleteIcon = data.isDemoDataCleared ? false : data.isToShowDeleteIcon;
+    }
+    monitorCompanyrelatedDetails(user) {
+        this.authenticatedUserRecord = user;
+        this.showHideDeleteButton(user);
+        this.companiesList = user.companiesList;
+        this.getCompanyDetails(user.companyId);
+        var company = this.companiesList.filter(x => x.companyId.toLowerCase() == this.cookieService.get(LocalStorageProperties.CompanyId).toLowerCase());
+        this.selectedCompany = company ? company[0] : null;
+        this.selectedCompanyName = company ? company[0] ? company[0].companyName : null : null;
+    }
+    navigateToDashboards() {
+        const userReference = localStorage.getItem(LocalStorageProperties.UserReferenceId);
+        this.defaultDashboardId = this.cookieService.check(LocalStorageProperties.DefaultDashboard) ? JSON.parse(this.cookieService.get(LocalStorageProperties.DefaultDashboard)) : null;
+        if (this.defaultDashboardId && userReference != "null" && userReference != null) {
+            this.router.navigateByUrl("dashboard-management/dashboard/" + this.defaultDashboardId + "/form/" + userReference);
+        }
+        else if (this.defaultDashboardId) {
+            this.router.navigateByUrl("dashboard-management/dashboard/" + this.defaultDashboardId);
+        }
+    }
+    isOpened(event) {
+        this.opened.emit(event);
+    }
+    getSoftLabels() {
+        this.softLabels = JSON.parse(localStorage.getItem('SoftLabels'));
+    }
+    onSignout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.reload = false;
+            const CurrentUserId = this.cookieService.get(LocalStorageProperties.CurrentUserId);
+            const taskAssignmentChannelToSubscribeInto = ChannelNames.Channel_TaskAssignments
+                + this.cookieService.get(LocalStorageProperties.CurrentUserId);
+            const tastatusReportSubmissionChannelToSubscribeInto = ChannelNames.Channel_StatusReportSubmission
+                + this.cookieService.get(LocalStorageProperties.CurrentUserId);
+            const tastatusConfigAssignChannelToSubscribeInto = ChannelNames.Channel_StatusConfigAssign
+                + this.cookieService.get(LocalStorageProperties.CurrentUserId);
+            const multiChartsSchedulingChannelToSubscribeInto = ChannelNames.Channel_MultiChartsScheduling + CurrentUserId;
+            const assetsAssignedChannelToSubscribeInto = ChannelNames.Channel_AssetAssignment + CurrentUserId;
+            const projectCreatedChannelToSubscribeInto = ChannelNames.Channel_NewProject + CurrentUserId;
+            const projectAccessToMemberChannelToSubscribeInto = ChannelNames.Channel_ProjectMemberRole + CurrentUserId;
+            const goalApprovedChannelToSubscribeInto = ChannelNames.Channel_GoalApprovedFromReplan + CurrentUserId;
+            const userStoryUpdateChannelToSubscribeInto = ChannelNames.Channel_UserStoryUpdateNotification + CurrentUserId;
+            const AnnouncementChannelToSubscribeInto = ChannelNames.Channel_AnnouncementNotification + CurrentUserId;
+            const userStoryCommentChannelToSubscribeInto = ChannelNames.Channel_UserStoryComment + CurrentUserId;
+            const sprintStartedChannelToSubscribeInto = ChannelNames.Channel_SprintStarted + CurrentUserId;
+            const sprintReplanChannelToSubscribeInto = ChannelNames.Channel_SprintRequestedToReplan + CurrentUserId;
+            const PerformanceChannelToSubscribeInto = ChannelNames.Channel_PeroformanceNotification + CurrentUserId;
+            const ReminderChannelToSubscribeInto = ChannelNames.Channel_ReminderNotification + CurrentUserId;
+            const projectFeatureChannelToSubscribeInto = ChannelNames.Channel_ProjectFeature + CurrentUserId;
+            const userStoryArchiveChannelToSubscribeInto = ChannelNames.Channel_UserStoryArchive + CurrentUserId;
+            const userStoryParkChannelToSubscribeInto = ChannelNames.Channel_UserStoryPark + CurrentUserId;
+            const genericActivityNotificationChannelToSubscribeInto = ChannelNames.Channel_GenericActivityNotification + CurrentUserId;
+            const purchaseExecutionAssignedChannelToSubscribeInto = ChannelNames.Channel_PurchaseExecutionAssignToEmployeeNotification + CurrentUserId;
+            this.pubnub.unsubscribe({ channels: [taskAssignmentChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [tastatusReportSubmissionChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [tastatusConfigAssignChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [multiChartsSchedulingChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [assetsAssignedChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [projectCreatedChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [projectAccessToMemberChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [goalApprovedChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [userStoryUpdateChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [AnnouncementChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [userStoryCommentChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [sprintStartedChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [sprintReplanChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [PerformanceChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [ReminderChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [projectFeatureChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [userStoryArchiveChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [userStoryParkChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [purchaseExecutionAssignedChannelToSubscribeInto] });
+            this.pubnub.unsubscribe({ channels: [this.loginUserchannelName] });
+            // var loginCompanyId = this.cookieService.get("CompanyId");
+            // var presenceChannel = "MessengerPresence-" + loginCompanyId;
+            // this.pubnub.unsubscribe({
+            //   channels: [presenceChannel],
+            // });
+            // if (this.channelList != undefined || this.channelList != null) {
+            //   for (var index = 0; index < this.channelList.length; index++) {
+            //     this.pubnub.unsubscribe({
+            //       channels: [(loginCompanyId + '-' + this.channelList[index].id)]
+            //     });
+            //   }
+            // }
+            // this.pubnub.unsubscribe({
+            //   channels: [('ChannelUpdates-' + loginCompanyId)]
+            // });
+            // this.pubnub.unsubscribe({
+            //   channels: [('UserUpdates-' + loginCompanyId)]
+            // });
+            this.pubnub.unsubscribe({ channels: [genericActivityNotificationChannelToSubscribeInto] });
+            // this.pubnub.unsubscribeAll();
+            // this.pubnub.removeAllListeners();
+            let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+            let companyName = this.cookieService.get(LocalStorageProperties.CompanyDetails);
+            let companyId = this.cookieService.get(LocalStorageProperties.CompanyId);
+            let companyDetails = this.cookieService.get(LocalStorageProperties.CompanyDetails);
+            let companyTheme = this.cookieService.get(LocalStorageProperties.CompanyTheme);
+            let UserLoggedInCount = this.cookieService.get(LocalStorageProperties.UserLoggedInCount);
+            let currentCulture = this.cookieService.get(LocalStorageProperties.CurrentCulture);
+            this.cookieService.deleteAll(environment.cookiePath);
+            this.cookieService.delete("selectedProjectsTab");
+            this.cookieService.set(LocalStorageProperties.UserLoggedInCount, UserLoggedInCount, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.CurrentCulture, currentCulture, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.CurrentUser, null, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.CurrentUserId, null, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.CompanyName, companyName, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.CompanyId, companyId, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.DefaultDashboard, null, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.CompanyDetails, companyDetails, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.CompanyTheme, companyTheme, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.SearchClick, null, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.UserModel, null, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.cookieService.set(LocalStorageProperties.EnableTeamDashboard, null, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            localStorage.setItem(LocalStorageProperties.Dashboards, null);
+            localStorage.setItem(LocalStorageProperties.UserReferenceId, null);
+            localStorage.setItem(LocalStorageProperties.RoleFeatures, null);
+            localStorage.removeItem(LocalStorageProperties.UserRoleFeatures);
+            localStorage.removeItem(LocalStorageProperties.RedirectionUrl);
+            localStorage.removeItem(LocalStorageProperties.SideBarMenuItems);
+            localStorage.removeItem(LocalStorageProperties.IntroModules);
+            this.cookieService.set(LocalStorageProperties.AddOrEditCustomAppIsRequired, null, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            this.router.navigate(["/sessions/signin"]);
+            return false;
+        });
+    }
+    setLang() {
+        this.translate.use(this.currentLang);
+        console.log(this.window.location.hostname);
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        this.cookieService.set(LocalStorageProperties.CurrentCulture, this.currentLang, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+        this.selectedLangName = this.availableLangs.find(x => x.code == this.currentLang).name;
+    }
+    changeTheme(theme) {
+        this.themeService.changeTheme(theme);
+    }
+    toggleNotific() {
+        // this.getUnreadNotifications();
+    }
+    toggleRecording() {
+        this.getActTrackerRecorder();
+        var user = JSON.parse(localStorage.getItem(LocalStorageProperties.UserModel));
+        if (user != null) {
+            this.monitorCompanyrelatedDetails(user);
+        }
+    }
+    getNotifications() {
+        const notificationSearchModel = new AppNotification();
+        this.store.dispatch(new ClearAllUnreadNotificationsTriggered(notificationSearchModel));
+        this.unreadCountOfNotifications$ = this.store.pipe(select(sharedModuleReducers.getNotificationUnreadTotal));
+    }
+    getUnreadNotifications() {
+        const notificationSearchModel = new AppNotification();
+        this.store.dispatch(new ClearUnreadNotificationsTriggered(notificationSearchModel));
+        this.unreadCountOfNotifications$ = this.store.pipe(select(sharedModuleReducers.getNotificationUnreadTotal));
+    }
+    getActTrackerRecorder() {
+        this.commonService.getActTrackerRecorder().subscribe((response) => {
+            if (response.success) {
+                this.isRecording = response.data;
+            }
+        });
+    }
+    clearDemoData() {
+        const dialogRef = this.dialog.open(ConfirmationDialogComponent, {
+            height: "30%",
+            width: "30%",
+            hasBackdrop: true,
+            direction: "ltr",
+            data: {},
+            disableClose: true
+        });
+        dialogRef.afterClosed().subscribe(() => {
+            console.log("The dialog was closed");
+        });
+    }
+    exportConfigurationDialogData() {
+        const dialogRef = this.dialog.open(ExportConfigurationDialogComponent, {
+            height: "45%",
+            width: "40%",
+            hasBackdrop: true,
+            direction: "ltr",
+            data: {},
+            disableClose: true
+        });
+        dialogRef.afterClosed().subscribe(() => {
+            console.log("The dialog was closed");
+        });
+    }
+    toggleSidenav() {
+        if (this.layoutConf.sidebarStyle === "closed") {
+            return this.layout.publishLayoutChange({
+                sidebarStyle: "full"
+            });
+        }
+        this.layout.publishLayoutChange({
+            sidebarStyle: "closed"
+        });
+        setTimeout(() => { window.dispatchEvent(new Event("resize")); }, 250);
+    }
+    toggleCollapse() {
+        // compact --> full
+        if (this.layoutConf.sidebarStyle === "compact") {
+            return this.layout.publishLayoutChange({
+                sidebarStyle: "full"
+            }, { transitionClass: true });
+        }
+        // * --> compact
+        this.layout.publishLayoutChange({
+            sidebarStyle: "compact"
+        }, { transitionClass: true });
+    }
+    getTimeSheetButtons() {
+        //this.loadingInProgress = true;
+        // this.commonService.getTimeSheetEnabledInformation().pipe(takeUntil(this.ngDestroyed$))
+        //   .subscribe((data: any) => {
+        //     if (data === "" || data === undefined) {
+        //       return;
+        //     }
+        //     this.timesheetDisableorEnable = JSON.parse(data);
+        //     this.loadingInProgress = false;
+        //   });
+        this.store.dispatch(new FetchTimeSheetButtonDetails());
+    }
+    closeFeedTimeSheet() {
+        this.feedTimeSheetPopover.close();
+        this.isFeedTimeSheet = false;
+    }
+    openTimeSheet() {
+        const projectDialog = this.dialog.open(FeedTimeDialogComponent, {
+            minWidth: '30vw',
+            height: '35vh',
+            data: !this.isFeedTimeSheet
+            //disableClose: true
+        });
+        projectDialog.afterClosed().subscribe(() => {
+            this.closeFeedTimeSheet();
+        });
+        this.getTimeSheetButtons();
+        // this.isFeedTimeSheet = !this.isFeedTimeSheet;
+    }
+    // getAllMenuItems() {
+    //   this.store.dispatch(new GetAllMenuItemsTriggered(MenuCategories.Main));
+    // }
+    changeMenuType(type) {
+        this.menuType = type;
+    }
+    openFeedBackDialog() {
+        this.isFeedBackDialog = true;
+    }
+    closeFeedBacklogDialog() {
+        this.isFeedBackDialog = false;
+        this.feedBackPopOver.close();
+    }
+    getCompanyDetails(companyId) {
+        if (this.cookieService.check(LocalStorageProperties.CompanyDetails) && this.cookieService.check(LocalStorageProperties.CompanyId)) {
+            this.company = JSON.parse(this.cookieService.get(LocalStorageProperties.CompanyDetails));
+        }
+        if (!this.company) {
+            this.commonService.getCompanyById(companyId).subscribe((response) => {
+                this.company = response.data;
+                if (this.company.isRemoteAccess == 1 && this.company.trailDays > 0) {
+                    this.showTrailPeriod = true;
+                    // this.noOfDays=this.company.noOfDays;
+                }
+                if (this.company.isDemoData == true) {
+                    this.showDelete = true;
+                }
+                else {
+                    this.showDelete = false;
+                }
+                if (this.company.isDemoData == false || this.company.isDemoData == null) {
+                    this.showDelete = false;
+                }
+                if (this.company != null && this.company != undefined && this.company.industryId.toUpperCase() == '7499F5E3-0EF2-4044-B840-2411B68302F9')
+                    this.isStoreAccess = false;
+                else
+                    this.isStoreAccess = true;
+            });
+        }
+        else {
+            if (this.company.isRemoteAccess == 1 && this.company.trailDays > 0) {
+                this.showTrailPeriod = true;
+                // this.noOfDays=this.company.noOfDays;
+            }
+            if (this.company.isDemoData == true) {
+                this.showDelete = true;
+            }
+            if (this.company.isDemoData == false || this.company.isDemoData == null) {
+                this.showDelete = false;
+            }
+            if (this.company != null && this.company != undefined && this.company.industryId.toUpperCase() == '7499F5E3-0EF2-4044-B840-2411B68302F9')
+                this.isStoreAccess = false;
+            else
+                this.isStoreAccess = true;
+        }
+    }
+    getUserStore() {
+        let storeSearchModel = new StoreSearchModel();
+        storeSearchModel.isArchived = false;
+        storeSearchModel.isDefault = true;
+        storeSearchModel.isCompany = false;
+        this.store.dispatch(new GetUserStoreIdTriggered(storeSearchModel));
+    }
+    goToUserStore() {
+        if (this.cookieService.get(LocalStorageProperties.CurrentUserId))
+            this.router.navigate(["document/store", this.userStoreId, this.cookieService.get(LocalStorageProperties.CurrentUserId).toLowerCase()]);
+    }
+    selectAfterlogin(e) {
+        this.companyId = e.companyId;
+        this.selectedCompanyName = e.companyName;
+        this.selectedCompany = e;
+    }
+    selectCompany(e) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cookieService.get(LocalStorageProperties.CompanyId).toLowerCase() != e.companyId.toString().toLowerCase()) {
+                this.reload = false;
+                console.log(e);
+                this.companyId = e.companyId;
+                this.selectedCompanyName = e.companyName;
+                this.selectedCompany = e;
+                this.loading = true;
+                this.searchText = null;
+                this.ngxService.start();
+                this.authService.companyLogin(this.selectedCompany).subscribe((userToken) => __awaiter(this, void 0, void 0, function* () {
+                    if (userToken.success) {
+                        yield this.onSignout();
+                        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+                        this.cookieService.set(LocalStorageProperties.CurrentUser, e.authToken, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+                        this.cookieService.set(LocalStorageProperties.CurrentUserId, e.userId, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+                        this.cookieService.set(LocalStorageProperties.CurrentUser, userToken.data.authToken, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+                        this.cookieService.set("DefaultDashboard", userToken.data.defaultDashboardId ? JSON.stringify(userToken.data.defaultDashboardId.workspaceId) : null, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+                        this.cookieService.set('CompanyDetails', JSON.stringify(userToken.data.companyDetails));
+                        this.cookieService.set('CompaniesList', JSON.stringify(userToken.data.usersModel.companiesList)),
+                            localStorage.setItem('RoleFeatures', JSON.stringify(userToken.data.roleFeatures));
+                        localStorage.setItem("UserModel", JSON.stringify(userToken.data.usersModel));
+                        localStorage.setItem('SoftLabels', JSON.stringify(userToken.data.softLabels));
+                        localStorage.setItem("CompanySettings", JSON.stringify(userToken.data.companySettings));
+                        localStorage.setItem("FromLogIn", JSON.stringify(true));
+                        this.cookieService.set(LocalStorageProperties.CompanyName, userToken.data.usersModel.companyName, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+                        this.cookieService.set(LocalStorageProperties.CompanyId, userToken.data.usersModel.companyId, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+                        //this.store.dispatch(new UserDetailsFetchedAfterCompanyLogin(userToken.data.usersModel));
+                        this.setDafaultLanguage();
+                    }
+                    this.loading = false;
+                    this.ngxService.stop();
+                }));
+            }
+        });
+    }
+    setDafaultLanguage() {
+        const company = JSON.parse(this.cookieService.get(LocalStorageProperties.CompanyDetails));
+        let currentCulture = company.lanCode;
+        if (currentCulture == null || currentCulture == undefined || currentCulture === 'null' || currentCulture === 'undefined') {
+            currentCulture = 'en';
+        }
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        this.cookieService.set(LocalStorageProperties.CurrentCulture, currentCulture, null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+        this.currentLang = currentCulture;
+        this.translate.use(this.currentLang);
+    }
+    getEmployeeIdByUserId() {
+    }
+    navigateToProfile() {
+        this.commonService.getUserById(this.cookieService.get(LocalStorageProperties.CurrentUserId).toLowerCase()).subscribe((response) => {
+            if (response.success == true) {
+                this.employeeId = response.data.employeeId;
+                if (this.employeeId) {
+                    this.router.navigate(["dashboard/profile", this.cookieService.get(LocalStorageProperties.CurrentUserId).toLowerCase(), "overview"]);
+                }
+                else {
+                    this.router.navigate(["dashboard/myProfile", this.cookieService.get(LocalStorageProperties.CurrentUserId).toLowerCase()]);
+                }
+            }
+        });
+    }
+    navigateToMessenger() {
+        this.router.navigate(["/chat"]);
+    }
+    navigateToStatusReport() {
+        const projectDialog = this.dialog.open(WorkItemsDialogComponent, {
+            minWidth: '82vw',
+            height: '82vh',
+            data: { dashboardFilters: this.dashboardFilters },
+            disableClose: true
+        });
+        projectDialog.afterClosed().subscribe(() => { });
+    }
+    navigateToSettings() {
+        this.router.navigate(["/settings"]);
+    }
+    alternateSignIn() {
+        this.router.navigate(["/sessions/generic-signin"]);
+    }
+    navigateToRoles() {
+        this.router.navigate(["/rolemanagement/rolemanagement"]);
+    }
+    navigateToUrl(workspaceId) {
+        const userReference = localStorage.getItem(LocalStorageProperties.UserReferenceId);
+        if (userReference != "null" && userReference != null) {
+            this.router.navigateByUrl("dashboard-management/dashboard/" + workspaceId + "/form/" + userReference);
+        }
+        else {
+            this.router.navigateByUrl("dashboard-management/dashboard/" + workspaceId);
+        }
+    }
+    addUploadFilePopupOpen(fileUploadDropzonePopup) {
+        fileUploadDropzonePopup.openPopover();
+    }
+    setLabelNameForDropzone(fileName) {
+        return fileName.substring(0, 20) + "...";
+    }
+    onRemove(event) {
+        this.files.splice(this.files.indexOf(event), 1);
+        if (this.files.length > 0) {
+            this.filesPresent = true;
+        }
+        else {
+            this.filesPresent = false;
+        }
+    }
+    removeAllFiles() {
+        this.filesPresent = false;
+        this.files = [];
+    }
+    filesSelected(event) {
+        this.files.push(...event.addedFiles);
+        if (this.files.length > 0) {
+            this.filesPresent = true;
+        }
+    }
+    closeUploadFilePopup() {
+        this.fileUploadDropzonePopup.forEach((p) => p.closePopover());
+        this.files = [];
+        this.fileResultModel = [];
+    }
+    saveFiles() {
+        this.anyOperationInProgress = true;
+        const formData = new FormData();
+        this.files.forEach((file) => {
+            this.fileIndex = this.fileIndex + 1;
+            const fileKeyName = "file" + this.fileIndex.toString();
+            formData.append(fileKeyName, file);
+        });
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        this.UploaderOnInit(environment.apiURL + ApiUrls.UploadFileChunks);
+    }
+    UploaderOnInit(url) {
+        let progress = 0;
+        const r = new Resumable({
+            target: url,
+            chunkSize: 1 * 1024 * 1024,
+            query: { moduleTypeId: this.moduleTypeId },
+            headers: {
+                "Authorization": `Bearer ${this.cookieService.get(LocalStorageProperties.CurrentUser)}`
+            },
+        });
+        r.addFiles(this.files);
+        r.on('fileAdded', (file, event) => {
+            if (!this.fileResultModel || this.fileResultModel.length > 0) {
+                this.fileResultModel = [];
+                this.cdRef.detectChanges();
+            }
+            r.upload();
+        });
+        r.on('complete', (event) => {
+            r.files.pop();
+            this.progressValue = 0;
+            this.filesPresent = false;
+            this.uploadedFileNames = [];
+            this.fileCounter = 1;
+            this.fileIndex = 0;
+            this.anyOperationInProgress = false;
+        });
+        r.on('progress', () => {
+            progress = Math.round(r.progress() * 100);
+            this.progressValue = progress;
+            this.cdRef.detectChanges();
+        });
+        r.on('fileSuccess', (file, response) => {
+            if (file && file.fileName) {
+                if (!this.uploadedFileNames.find(x => x == file.fileName)) {
+                    this.uploadedFileNames.push(file.fileName);
+                    this.fileCounter = this.uploadedFileNames.length;
+                    let result = JSON.parse(response);
+                    if (result && result.length > 0) {
+                        if (!this.fileResultModel) {
+                            this.fileResultModel = [];
+                        }
+                        let fileResult = new FileResultModel();
+                        fileResult.fileExtension = result[0].FileExtension;
+                        fileResult.fileName = result[0].FileName;
+                        fileResult.filePath = result[0].FilePath;
+                        fileResult.fileSize = result[0].FileSize;
+                        this.fileResultModel.push(fileResult);
+                        if (result[0].FilePath != null && result[0].FilePath != "")
+                            this.importDynamicJson(result[0].FilePath);
+                        else
+                            this.closeUploadFilePopup();
+                    }
+                    this.cdRef.detectChanges();
+                }
+            }
+        });
+    }
+    importDynamicJson(configuredJsonURL) {
+        var importConfigurationModel = new ImportConfigurationModel();
+        importConfigurationModel.configurationUrl = configuredJsonURL;
+        this.importingInProgress = true;
+        this.commonService.SystemImportConfiguration(importConfigurationModel).subscribe((response) => {
+            if (response.success === true) {
+                this.closeUploadFilePopup();
+                this.toastr.success("Data imported successfully");
+            }
+            else {
+                this.toastr.error(response.apiResponseMessages[0].message);
+            }
+            this.importingInProgress = false;
+        });
+    }
+    closeSearch() {
+        this.searchText = null;
+    }
+    searchCompanies(companies, search) {
+        if (search == null || search == '') {
+            return companies;
+        }
+        else if (search != null) {
+            search = search.toLowerCase();
+            search = search.trim();
+            const temp = companies.filter(data => data.companyName.toString().toLowerCase().indexOf(search) > -1);
+            return temp;
+        }
+    }
+    ngOnDestroy() {
+        // this.pubnub.unsubscribe({ channels: [this.loginUserchannelName] });
+        // var loginCompanyId = this.cookieService.get("CompanyId");
+        // if (this.channelList != undefined || this.channelList != null) {
+        //   for (var index = 0; index < this.channelList.length; index++) {
+        //     this.pubnub.unsubscribe({
+        //       channels: [(loginCompanyId + '-' + this.channelList[index].id)]
+        //     });
+        //   }
+        // }
+        //  this.pubnub.unsubscribe({
+        //   channels: [('ChannelUpdates-' + loginCompanyId)]
+        // });
+        // this.pubnub.unsubscribe({
+        //   channels: [('UserUpdates-' + loginCompanyId)]
+        // });
+        this.ngDestroyed$.next();
+        this.ngDestroyed$.complete();
+    }
+    onNavigateToBillingScreen() {
+        this.router.navigate(["/shell/Accounts"]);
+    }
+    onNavigateToPricingScreen() {
+        this.router.navigate(["/shell/payments-plans"]);
+    }
+    getIntroDetails() {
+        var intro = new IntroModel();
+        intro.userId = this.cookieService.get(LocalStorageProperties.CurrentUserId);
+        this.commonService.getIntroDetails(intro).subscribe((responseData) => {
+            if (responseData.success == false) {
+                this.validationMessage = responseData.apiResponseMessages[0].message;
+                this.anyOperationInProgress = false;
+                this.toastr.error(this.validationMessage);
+            }
+            else if (responseData.success == true) {
+                let intro = JSON.parse(localStorage.getItem(LocalStorageProperties.IntroModules));
+                if (!intro)
+                    localStorage.setItem(LocalStorageProperties.IntroModules, JSON.stringify(responseData.data));
+            }
+        });
+    }
+    getTeamMembers() {
+        var teamMemberModel;
+        let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));
+        var teamMemberModel;
+        teamMemberModel = {
+            isForTracker: true
+        };
+        teamMemberModel.isArchived = false;
+        this.commonService.getTeamLeadsList(teamMemberModel).subscribe((responseData) => {
+            let employeesDropDown = responseData.data;
+            if (employeesDropDown && employeesDropDown.length > 1) {
+                this.cookieService.set(LocalStorageProperties.EnableTeamDashboard, 'true', null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            }
+            else {
+                this.cookieService.set(LocalStorageProperties.EnableTeamDashboard, 'false', null, environment.cookiePath, this.window.location.hostname, false, "Strict");
+            }
+        });
+    }
+}
+HeaderSideComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: HeaderSideComponent, deps: [{ token: i1.PushNotificationsService }, { token: i2.ThemeService }, { token: i3.NgxUiLoaderService }, { token: i4.LayoutService }, { token: i5.TranslateService }, { token: i6.Router }, { token: i7.CookieService }, { token: i8.MatDialog }, { token: i9.CommonService }, { token: i10.Store }, { token: i11.PubNubAngular }, { token: i12.AuthenticationService }, { token: i13.Actions }, { token: i0.ChangeDetectorRef }, { token: i14.ToastrService }, { token: i15.StoreManagementService }, { token: i16.ShellModulesService }, { token: i17.ChatService }, { token: i18.SignalrService }, { token: WINDOW }], target: i0.ɵɵFactoryTarget.Component });
+HeaderSideComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.1", type: HeaderSideComponent, selector: "app-header-side", inputs: { notificPanel: "notificPanel" }, outputs: { opened: "opened" }, viewQueries: [{ propertyName: "feedTimeSheetPopover", first: true, predicate: ["feedTimeSheet"], descendants: true }, { propertyName: "feedBackPopOver", first: true, predicate: ["feedBackPopover"], descendants: true }, { propertyName: "documentPopover", first: true, predicate: ["documentPopover"], descendants: true }, { propertyName: "openAnnoucementDialogComponent", first: true, predicate: ["openAnnoucementDialogComponent"], descendants: true }, { propertyName: "fileUploadDropzonePopup", predicate: ["fileUploadDropzonePopup"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<mat-toolbar class=\"topbar remove-padding\">\r\n    <div fxFlex>\r\n        <app-menu [reload]=\"reload\" (isOpened)=\"isOpened($event)\" (openNewDashboard)=\"navigateToUrl($event)\"></app-menu>\r\n    </div>\r\n    <div fxFlex fxLayout=\"row\" fxHide.xs fxLayoutAlign=\"center\" style=\"vertical-align: center;\">\r\n    </div>\r\n    <div fxFlex fxLayout=\"row\" fxLayoutAlign=\"end center\">\r\n        <div *ngIf=\"companiesList != null && companiesList.length > 1\" class=\"filter-data custom-box language-section\"\r\n            style=\"width:150px;\" (click)=\"$event.stopPropagation()\">\r\n            <mat-select placeholder=\"\" name=\"selectedCompany\" [(ngModel)]=\"selectedCompany\"\r\n                (selectionChange)=\"selectCompany($event.value)\">\r\n                <mat-select-trigger>\r\n                    <div *ngIf=\"selectedCompany\" fxLayout=\"row\" fxLayoutGap=\"15px\">\r\n                        <div [ngStyle]=\"{ 'margin-bottom': selectedCompany.companyMiniLogo ? '10px' : '0px' }\">\r\n                            <app-avatar [name]=\"selectedCompany.companyName | removeSpecialCharacters\"\r\n                                fxLayoutAlign=\"start center\" matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ selectedCompany.companyName }}\"\r\n                                [src]=\"selectedCompany.companyMiniLogo | fetchSizedAndCachedImage: '20':''\"\r\n                                [isRound]=\"true\" size=\"20\">\r\n                            </app-avatar>\r\n                        </div>\r\n                        <span matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{selectedCompany.companyName}}\" matTooltipShowDelay=\"400\"\r\n                            fxFlex=\"calc(100% - 40px)\" class=\"language-display\" style=\"color: black !important;\">{{ selectedCompanyName }}</span>\r\n                    </div>\r\n                </mat-select-trigger>\r\n                <div fxFlex class=\"search_goalinput ml-1\" fxLayoutAlign=\"start center\"\r\n                    style=\"position: sticky; top: 0; z-index: 1; background-color: white;\">\r\n                    <div fxLayoutAlign=\"start center\">\r\n                        <mat-form-field class=\"full-width\">\r\n                            <input class=\"search_goal\" matInput placeholder=\"{{'HRMANAGAMENT.SEARCH' | translate}}\"\r\n                                [(ngModel)]=\"searchText\" autocomplete=\"off\">\r\n                            <!-- (input)=\"search($event)\"> -->\r\n                        </mat-form-field>\r\n                    </div>\r\n                    <span class=\"close_icon masterdata-search-close\" fxLayoutAlign=\"end center\">\r\n                        <span *ngIf=\"!searchText\"></span>\r\n                        <mat-icon *ngIf=\"searchText\" class=\"icon-button mr-05 mt-05\" aria-hidden=\"false\"\r\n                            (click)=\"closeSearch()\" style=\"cursor:pointer\">\r\n                            close</mat-icon>\r\n                    </span>\r\n                </div>\r\n                <mat-option *ngFor=\"let companyList of searchCompanies(companiesList, searchText)\" [value]=\"companyList\"\r\n                matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{companyList.companyName}}\" matTooltipShowDelay=\"400\">\r\n                    <div class=\"cursor-pointer\" fxLayout=\"row\">\r\n                        <app-avatar [name]=\"companyList.companyName | removeSpecialCharacters\"\r\n                            [ngStyle]=\"{ 'margin-bottom': companyList.companyMiniLogo ? '10px' : '0px' }\"\r\n                            fxLayoutAlign=\"start center\" matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ companyList.companyName }}\"\r\n                            [src]=\"companyList.companyMiniLogo | fetchSizedAndCachedImage: '20':''\" [isRound]=\"true\"\r\n                            size=\"20\">\r\n                        </app-avatar>\r\n                        <div class=\"ml-05\">\r\n                            {{ companyList.companyName }}\r\n                        </div>\r\n                    </div>\r\n                </mat-option>\r\n            </mat-select>\r\n        </div>\r\n        <!-- <div *ngIf=\"showTrailPeriod\">\r\n            <span>{{ 'SHELL.FREETRAILEXPIRE' | translate }}<span [(ngModel)]=\"noOfDays\">{{company.trailDays}}</span>\r\n                {{ 'SHELL.DAYS' | translate }}</span>\r\n        </div> -->\r\n        <!-- <div class=\"home\">\r\n            <button mat-icon-button [style.overflow]=\"'visible'\" matTooltip=\"{{ 'SHELL.HOME' | translate}}\"\r\n                class=\"topbar-button-right\" (click)=\"changeMenuType('WorkspaceMenuItems');navigateToDashboards()\"\r\n                [ngClass]=\"(menuType == 'WorkspaceMenuItems'|| this.router.url.includes('/dashboard-management')) ? 'icon_active_class' : ''\">\r\n                <mat-icon>home</mat-icon>\r\n            </button>\r\n        </div> -->\r\n        <!-- <div class=\"home\" *ngIf=\"canAccess_feature_ViewRoles\">\r\n            <button mat-icon-button [style.overflow]=\"'visible'\" matTooltip=\"{{ 'ROLESVIEW.ROLES' | translate}}\"\r\n                class=\"topbar-button-right\" (click)=\"changeMenuType('WorkspaceMenuItems');navigateToRoles()\"\r\n                [ngClass]=\"(menuType == 'WorkspaceMenuItems'|| this.router.url.includes('/rolemanagement/rolemanagement')) ? 'icon_active_class' : ''\">\r\n                <mat-icon>brightness_high</mat-icon>\r\n            </button>\r\n        </div> -->\r\n        <div *ngIf=\"(canAccess_feature_Settings) || (canAccess_feature_ViewRoles)\">\r\n            <button matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.SETTINGS' | translate }}\" class=\"topbar-button-right theme-navbar-icon-color\" mat-icon-button\r\n                (click)=\"navigateToSettings()\"\r\n                [ngClass]=\"(this.router.url.includes('/settings')) ? 'icon_active_class' : ''\">\r\n                <mat-icon>settings</mat-icon>\r\n            </button>\r\n        </div>\r\n    <!-- <div *ngIf=\"canAccess_feature_AbilityToChat\">\r\n            <button mat-icon-button [style.overflow]=\"'visible'\" matTooltip=\"{{ 'SHELL.CHAT' | translate }}\"\r\n                class=\"topbar-button-right\" (click)=\"navigateToMessenger()\"\r\n                [ngClass]=\"(this.router.url.includes('/chat')) ? 'icon_active_class' : ''\">\r\n                <mat-icon matBadge=\"{{messagesUnreadCount}}\" [matBadgeHidden]=\"messagesUnreadCount == 0\"\r\n                    matBadgeColor=\"warn\" class=\"m-0 icon\">forum</mat-icon>\r\n            </button>\r\n        </div>  -->\r\n\r\n        <div *ngIf=\"canAccess_feature_MyProjectWork\">\r\n            <button matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.MYWORK' | translate }}\" class=\"topbar-button-right theme-navbar-icon-color\" mat-icon-button\r\n                (click)=\"navigateToStatusReport()\">\r\n                <mat-icon>assignment</mat-icon>\r\n            </button>\r\n        </div>\r\n    </div>\r\n\r\n    <div\r\n        *ngIf=\"(canAccess_feature_PunchCard) && !( timesheetDisableorEnable && timesheetDisableorEnable.TimeSheetRestricted)\">\r\n        <button mat-icon-button id=\"feedTimeSheetComponent\" [style.overflow]=\"'visible'\"\r\n        matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.LOGTIME' | translate}}\" [satPopoverAnchorFor]=\"feedTimeSheet\"\r\n            (click)=\"openTimeSheet()\" class=\"topbar-button-right theme-navbar-icon-color\">\r\n            <mat-icon>access_time</mat-icon>\r\n        </button>\r\n    </div>\r\n    <!-- Notification toggle button -->\r\n    <button mat-icon-button matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.NOTIFICATIONS' | translate}}\" (click)=\"toggleNotific()\"\r\n        [style.overflow]=\"'visible'\" *ngIf=\"newNotificationsCount != 0\" class=\"topbar-button-right theme-navbar-icon-color\"\r\n        [matMenuTriggerFor]=\"notification\">\r\n        <mat-icon>notifications</mat-icon>\r\n        <span *ngIf=\"newNotificationsCount != 0\" class=\"notification-number mat-bg-warn\">{{\r\n            newNotificationsCount }}</span>\r\n    </button>\r\n    <mat-menu #notification=\"matMenu\">\r\n        <app-notifications></app-notifications>\r\n    </mat-menu>\r\n\r\n    <!-- Top left user menu -->\r\n    <button mat-icon-button [matMenuTriggerFor]=\"accountMenu\" (click)=\"toggleRecording()\"\r\n        [ngClass]=\"this.router.url.includes('/dashboard/profile/') ? 'icon_active_class' : ''\"\r\n        class=\"topbar-button-right img-button\" *ngIf=\"authenticatedUserRecord\">\r\n        <img class=\"icon-highlight-setter\" *ngIf=\"authenticatedUserRecord.profileImage\"\r\n            [src]=\"authenticatedUserRecord.profileImage | fetchSizedAndCachedImage: '60':''\" alt=\"profile image\" />\r\n        <div *ngIf=\"!authenticatedUserRecord.profileImage\" style=\"margin-left: 4px !important;\">\r\n            <app-avatar [name]=\"authenticatedUserRecord.fullName | removeSpecialCharacters\" [isRound]=\"true\" size=\"30\">\r\n            </app-avatar>\r\n        </div>\r\n    </button>\r\n\r\n    <sat-popover #feedTimeSheet [autoFocus]=\"false\" hasBackdrop [restoreFocus]=\"false\" [interactiveClose]=\"true\"\r\n        scrollStrategy=\"reposition\" verticalAlign=\"below\" horizontalAlign=\"before\">\r\n        <app-feed-time (closeFeedTimeSheetPopup)=\"closeFeedTimeSheet()\" [isFeedTimeSheet]=\"isFeedTimeSheet\">\r\n        </app-feed-time>\r\n    </sat-popover>\r\n\r\n    <mat-menu #accountMenu=\"matMenu\">\r\n        <button mat-menu-item (click)=\"navigateToProfile()\">\r\n            <mat-icon>account_box</mat-icon>\r\n            <span>{{ 'SHELL.PROFILE' | translate}}</span>\r\n            <mat-icon class=\"activity-recorder recording-style\" *ngIf=\"isRecording\">\r\n                <!-- fiber_manual_record -->\r\n            </mat-icon>\r\n        </button>\r\n\r\n        <!-- <button mat-menu-item (click)=\"goToUserStore()\" *ngIf=\"isStoreAccess\">\r\n            <mat-icon>cloud</mat-icon>\r\n            <span>Store</span>\r\n        </button> -->\r\n        <button mat-menu-item matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.CLEARDEMODATA' | translate}}\" *ngIf=\"showDeleteIcon && showDelete\"\r\n            (click)=\"clearDemoData()\" [style.overflow]=\"'visible'\">\r\n            <mat-icon>delete</mat-icon>\r\n            <span>{{ 'SHELL.CLEARDEMODATA' | translate}}</span>\r\n        </button>\r\n        <button mat-menu-item matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.EXPORTCONFIGURATION' | translate}}\"\r\n            *ngIf=\"canAccess_feature_ManageSystemExports\" (click)=\"exportConfigurationDialogData()\"\r\n            [style.overflow]=\"'visible'\">\r\n            <mat-icon>get_app</mat-icon>\r\n            <span>{{ 'SHELL.EXPORTCONFIGURATION' | translate}}</span>\r\n        </button>\r\n        <button mat-menu-item matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.IMPORTCONFIGURATION' | translate}}\"\r\n            [satPopoverAnchorFor]=\"fileUploadDropzonePopover\" #fileUploadDropzonePopup=\"satPopoverAnchor\"\r\n            *ngIf=\"canAccess_feature_ManageSystemImports\" (click)=\"addUploadFilePopupOpen(fileUploadDropzonePopup)\">\r\n            <mat-icon>publish</mat-icon>\r\n            <span>{{ 'SHELL.IMPORTCONFIGURATION' | translate}}</span>\r\n        </button>\r\n        <!--<div class=\"filter-data custom-box language-section\" (click)=\"$event.stopPropagation()\">\r\n            <mat-select placeholder=\"\" name=\"currentLang\" [(ngModel)]=\"currentLang\" (selectionChange)=\"setLang()\">\r\n                <mat-select-trigger>\r\n                    <div fxLayout=\"row\" fxLayoutGap=\"15px\">\r\n                        <mat-icon fxFlex=\"24px\" class=\"language-icon\">language</mat-icon>\r\n                        <span fxFlex=\"calc(100% - 40px)\" class=\"language-display\">{{ selectedLangName }}</span>\r\n                    </div>\r\n                </mat-select-trigger>\r\n                <mat-option value=\"option\" *ngFor=\"let lang of availableLangs\" [value]=\"lang.code\">\r\n                    {{ lang.name }}\r\n                </mat-option>\r\n            </mat-select>\r\n        </div>-->\r\n        <button mat-menu-item (click)=\"onNavigateToBillingScreen()\" *ngIf=\"canAccess_feature_ManageAccountsAndBilling\">\r\n            <mat-icon>account_balance</mat-icon>\r\n            <span>Account & Billing</span>\r\n        </button>\r\n        <button mat-menu-item (click)=\"onNavigateToPricingScreen()\" *ngIf=\"canAccess_feature_ManageAccountsAndBilling\">\r\n            <mat-icon>account_balance_wallet</mat-icon>\r\n            <span>Pricing & Features</span>\r\n        </button>\r\n\r\n        <button *ngIf=\"canAccess_feature_AlternateSignIn\" mat-menu-item (click)=\"alternateSignIn()\"\r\n            [style.overflow]=\"'visible'\" matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.SIGNINAS' | translate}}\">\r\n            <mat-icon>how_to_reg</mat-icon>\r\n            <span>{{ 'SHELL.SIGNINAS' | translate}}</span>\r\n        </button>\r\n        <button mat-menu-item (click)=\"onSignout()\">\r\n            <mat-icon>exit_to_app</mat-icon>\r\n            <span>{{ 'SHELL.SIGNOUT' | translate}}</span>\r\n        </button>\r\n        <mat-divider></mat-divider>\r\n        <button mat-menu-item (click)=\"feedBackPopover.toggle();openFeedBackDialog()\">\r\n            <mat-icon class=\"feedback-icon\" [satPopoverAnchorFor]=\"feedBackPopover\">\r\n                sentiment_satisfied_alt\r\n            </mat-icon>\r\n            <span>v-{{applicationVersion}}</span>\r\n        </button>\r\n    </mat-menu>\r\n</mat-toolbar>\r\n<!-- <ngx-ui-loader fgsSize=\"180\" [fgsType]=\"spinnerType\" color=\"primary\"></ngx-ui-loader> -->\r\n<div *ngIf=\"loading\" class=\"k-i-loading\"></div>\r\n<sat-popover #feedBackPopover verticalAlign=\"below\" hasBackdrop backdropClass=\"backdrop-color\"\r\n    [interactiveClose]=\"false\" horizontalAlign=\"end\">\r\n    <app-submit-feedback *ngIf=\"isFeedBackDialog\" (closeDialog)=\"closeFeedBacklogDialog()\">\r\n    </app-submit-feedback>\r\n</sat-popover>\r\n\r\n<mat-menu #menu2=\"matMenu\" class=\"dialog_window\" (click)=\"$event.stopPropagation()\">\r\n    <mat-card-content class=\"p-0 m-0 listof_assets store-list-dropdown\" id=\"style-1\">\r\n        <mat-list class=\"compact-list\">\r\n            <mat-card class=\"p-0 asset-card\" *ngIf=\"(canAccess_feature_AddOrUpdateForm || canAccess_feature_ViewForms)\"\r\n                [routerLink]=\"['/applications/view-forms']\">\r\n                <span class=\"hide-content-overflow userStory-name-control store-dropdown-padding\">Forms</span>\r\n            </mat-card>\r\n            <mat-card class=\"p-0 asset-card\" *ngIf=\"canAccess_feature_AddOrUpdateApplications\"\r\n                [routerLink]=\"['/applications/custom-applications']\">\r\n                <span class=\"hide-content-overflow userStory-name-control store-dropdown-padding\">Custom\r\n                    applications</span>\r\n            </mat-card>\r\n            <mat-card *ngIf=\"canAccess_feature_ViewRoles\" class=\"p-0 asset-card\"\r\n                [routerLink]=\"['/rolemanagement/rolemanagement']\">\r\n                <span class=\"hide-content-overflow userStory-name-control store-dropdown-padding\">Role\r\n                    configuration</span>\r\n            </mat-card>\r\n            <mat-card *ngIf=\"canAccess_feature_ManageProjectRolePermissions\" class=\"p-0 asset-card\"\r\n                [routerLink]=\"['/rolemanagement/entityrolemanagement']\">\r\n                <span class=\"hide-content-overflow userStory-name-control store-dropdown-padding\">{{projectRoleText |\r\n                    softLabelsPipe : softLabels}}</span>\r\n            </mat-card>\r\n        </mat-list>\r\n    </mat-card-content>\r\n</mat-menu>\r\n\r\n<div [@fade] *ngIf=\"displayWelcomeNote && userFullName\" class=\"welcome-note\">\r\n    <span *ngIf=\"loggedInCount == 1; else elseSpan\">Welcome &nbsp; </span> <span> {{ userFullName }} </span>\r\n    <ng-template #elseSpan> Welcome back &nbsp;</ng-template>\r\n</div>\r\n<sat-popover #fileUploadDropzonePopover hasBackdrop [interactiveClose]=\"false\" backdropClass=\"testrun-popover\"\r\n    scrollStrategy=\"reposition\">\r\n    <mat-card class=\"p-0 mr-0 custom-hrm-dropzone\">\r\n        <mat-card-title>\r\n            <div class=\"card-title-text mat-bg-primary p-05\" fxLayout=\"row\">\r\n                <div fxFlex class=\"text-center\">\r\n                    {{'TESTMANAGEMENT.UPLOADFILES' | translate}}\r\n                </div>\r\n                <div fxFlex=\"20px\" fxLayoutAlign=\"end center\">\r\n                    <button class=\"inline_edit_close_btn btn\" (click)=\"closeUploadFilePopup()\">\r\n                        <fa-icon icon=\"times\"></fa-icon>\r\n                    </button>\r\n                </div>\r\n            </div>\r\n        </mat-card-title>\r\n        <div class=\"m-1\">\r\n            <div class=\"custom-dropzone dropzone-height\" ngx-dropzone (change)=\"filesSelected($event)\" accept=\".json\">\r\n                <ngx-dropzone-label>\r\n                    <span>{{'DOCUMENTMANAGEMENT.DRAGANDDROPFILESHERE' | translate}}</span>\r\n                </ngx-dropzone-label>\r\n                <ngx-dropzone-preview class=\"custom-dropzone-preview\" *ngFor=\"let f of files\" [removable]=\"true\"\r\n                    (removed)=\"onRemove(f)\">\r\n                    <ngx-dropzone-label class=\"custom-dropzone-label\" [attr.data-tip]=\"f.name\">\r\n                        {{ setLabelNameForDropzone(f.name) }}\r\n                    </ngx-dropzone-label>\r\n                </ngx-dropzone-preview>\r\n            </div>\r\n            <div class=\"m-05 text-muted\" style=\"text-align: center;\">\r\n                <span>allowed file extensions : .json</span>\r\n            </div>\r\n            <mat-progress-bar color=\"primary\" mode=\"determinate\" [value]=\"progressValue\" *ngIf=\"progressValue > 0\">\r\n            </mat-progress-bar>\r\n            <div *ngIf=\"progressValue > 0\">\r\n                {{progressValue}}% completed (Uploading {{fileCounter}} of {{files.length}} files)\r\n            </div>\r\n            <div class=\"mt-05\" fxLayoutAlign=\"center end\" *ngIf=\"filesPresent\">\r\n                <button mat-button mat-raised-button color=\"primary\" (click)=\"saveFiles()\">\r\n                    <fa-icon class=\"mr-05\" icon=\"save\"></fa-icon>{{'UPLOAD' | translate}}\r\n                </button>\r\n                <button class=\"ml-1\" mat-button mat-raised-button (click)=\"removeAllFiles();\">\r\n                    <fa-icon class=\"mr-05\" icon=\"times\"></fa-icon>{{'DOCUMENTMANAGEMENT.CLEARFILES' | translate}}\r\n                </button>\r\n            </div>\r\n            <div class=\"mt-05\" fxLayoutAlign=\"center end\" *ngIf=\"importingInProgress\">\r\n                <button class=\"ml-1\" mat-button mat-raised-button [disabled]=\"true\">\r\n                    <fa-icon class=\"mr-05\" icon=\"upload\"></fa-icon>{{'SHELL.IMPORTINGTEXT' | translate }}\r\n                    <i class=\"fa fa-spin fa-spinner\" *ngIf=\"importingInProgress\"></i>\r\n                </button>\r\n            </div>\r\n        </div>\r\n    </mat-card>\r\n</sat-popover>\r\n\r\n<style>\r\n    .file-or-folder-icon {\r\n        width: 50px;\r\n        height: 50px;\r\n        font-size: 50px;\r\n    }\r\n\r\n    .file-or-folder-name-align {\r\n        overflow: hidden;\r\n        display: -webkit-box;\r\n        -webkit-line-clamp: 2;\r\n        -webkit-box-orient: vertical;\r\n        text-align: center;\r\n        word-break: break-word;\r\n    }\r\n\r\n    .dropzone-height {\r\n        height: 130px;\r\n    }\r\n\r\n    .custom-dropzone-preview {\r\n        height: 100px !important;\r\n        min-height: 100px !important;\r\n        padding: 0px !important;\r\n    }\r\n</style>\r\n<ng-template #openAnnoucementDialogComponent let-data>\r\n    <announcement-dialog [data]=[data]></announcement-dialog>\r\n</ng-template>", styles: ["\n    .file-or-folder-icon {\n        width: 50px;\n        height: 50px;\n        font-size: 50px;\n    }\n\n    .file-or-folder-name-align {\n        overflow: hidden;\n        display: -webkit-box;\n        -webkit-line-clamp: 2;\n        -webkit-box-orient: vertical;\n        text-align: center;\n        word-break: break-word;\n    }\n\n    .dropzone-height {\n        height: 130px;\n    }\n\n    .custom-dropzone-preview {\n        height: 100px !important;\n        min-height: 100px !important;\n        padding: 0px !important;\n    }\n"], components: [{ type: i19.MatToolbar, selector: "mat-toolbar", inputs: ["color"], exportAs: ["matToolbar"] }, { type: i20.MenuComponent, selector: "app-menu", inputs: ["reload"], outputs: ["isOpened", "openNewDashboard"] }, { type: i21.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { type: i22.SnovasysAvatarComponent, selector: "app-avatar", inputs: ["avatarClass", "name", "src", "isRound", "size"] }, { type: i23.MatFormField, selector: "mat-form-field", inputs: ["color", "floatLabel", "appearance", "hideRequiredMarker", "hintLabel"], exportAs: ["matFormField"] }, { type: i24.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i25.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: i26.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i27.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { type: i28.NotificationsComponent, selector: "app-notifications", inputs: ["notificPanel"] }, { type: i29.SatPopover, selector: "sat-popover", inputs: ["backdropClass", "horizontalAlign", "xAlign", "verticalAlign", "yAlign", "forceAlignment", "lockAlignment", "autoFocus", "restoreFocus", "scrollStrategy", "hasBackdrop", "interactiveClose", "openTransition", "closeTransition"], outputs: ["opened", "closed", "afterOpen", "afterClose", "backdropClicked", "overlayKeydown"] }, { type: i30.FeedTimeComponent, selector: "app-feed-time", inputs: ["isFeedTimeSheet"], outputs: ["closeFeedTimeSheetPopup"] }, { type: i27.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { type: i31.MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }, { type: i32.FeedBackSubmissionComponent, selector: "app-submit-feedback", outputs: ["closeDialog"] }, { type: i33.MatList, selector: "mat-list, mat-action-list", inputs: ["disableRipple", "disabled"], exportAs: ["matList"] }, { type: i34.MatCard, selector: "mat-card", exportAs: ["matCard"] }, { type: i35.FaIconComponent, selector: "fa-icon", inputs: ["classes", "icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "listItem", "rotate", "fixedWidth", "transform"] }, { type: i36.NgxDropzoneComponent, selector: "ngx-dropzone, [ngx-dropzone]", inputs: ["accept", "disabled", "multiple", "maxFileSize", "expandable"], outputs: ["change"] }, { type: i36.NgxDropzonePreviewComponent, selector: "ngx-dropzone-preview", inputs: ["removable", "file"], outputs: ["removed"] }, { type: i37.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "mode", "value", "bufferValue"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }, { type: i38.AnnoucementDialogComponent, selector: "announcement-dialog", inputs: ["data"], outputs: ["closeMatDialog"] }], directives: [{ type: i39.DefaultFlexDirective, selector: "  [fxFlex], [fxFlex.xs], [fxFlex.sm], [fxFlex.md],  [fxFlex.lg], [fxFlex.xl], [fxFlex.lt-sm], [fxFlex.lt-md],  [fxFlex.lt-lg], [fxFlex.lt-xl], [fxFlex.gt-xs], [fxFlex.gt-sm],  [fxFlex.gt-md], [fxFlex.gt-lg]", inputs: ["fxFlex", "fxFlex.xs", "fxFlex.sm", "fxFlex.md", "fxFlex.lg", "fxFlex.xl", "fxFlex.lt-sm", "fxFlex.lt-md", "fxFlex.lt-lg", "fxFlex.lt-xl", "fxFlex.gt-xs", "fxFlex.gt-sm", "fxFlex.gt-md", "fxFlex.gt-lg"] }, { type: i39.DefaultLayoutDirective, selector: "  [fxLayout], [fxLayout.xs], [fxLayout.sm], [fxLayout.md],  [fxLayout.lg], [fxLayout.xl], [fxLayout.lt-sm], [fxLayout.lt-md],  [fxLayout.lt-lg], [fxLayout.lt-xl], [fxLayout.gt-xs], [fxLayout.gt-sm],  [fxLayout.gt-md], [fxLayout.gt-lg]", inputs: ["fxLayout", "fxLayout.xs", "fxLayout.sm", "fxLayout.md", "fxLayout.lg", "fxLayout.xl", "fxLayout.lt-sm", "fxLayout.lt-md", "fxLayout.lt-lg", "fxLayout.lt-xl", "fxLayout.gt-xs", "fxLayout.gt-sm", "fxLayout.gt-md", "fxLayout.gt-lg"] }, { type: i40.DefaultShowHideDirective, selector: "  [fxShow], [fxShow.print],  [fxShow.xs], [fxShow.sm], [fxShow.md], [fxShow.lg], [fxShow.xl],  [fxShow.lt-sm], [fxShow.lt-md], [fxShow.lt-lg], [fxShow.lt-xl],  [fxShow.gt-xs], [fxShow.gt-sm], [fxShow.gt-md], [fxShow.gt-lg],  [fxHide], [fxHide.print],  [fxHide.xs], [fxHide.sm], [fxHide.md], [fxHide.lg], [fxHide.xl],  [fxHide.lt-sm], [fxHide.lt-md], [fxHide.lt-lg], [fxHide.lt-xl],  [fxHide.gt-xs], [fxHide.gt-sm], [fxHide.gt-md], [fxHide.gt-lg]", inputs: ["fxShow", "fxShow.print", "fxShow.xs", "fxShow.sm", "fxShow.md", "fxShow.lg", "fxShow.xl", "fxShow.lt-sm", "fxShow.lt-md", "fxShow.lt-lg", "fxShow.lt-xl", "fxShow.gt-xs", "fxShow.gt-sm", "fxShow.gt-md", "fxShow.gt-lg", "fxHide", "fxHide.print", "fxHide.xs", "fxHide.sm", "fxHide.md", "fxHide.lg", "fxHide.xl", "fxHide.lt-sm", "fxHide.lt-md", "fxHide.lt-lg", "fxHide.lt-xl", "fxHide.gt-xs", "fxHide.gt-sm", "fxHide.gt-md", "fxHide.gt-lg"] }, { type: i39.DefaultLayoutAlignDirective, selector: "  [fxLayoutAlign], [fxLayoutAlign.xs], [fxLayoutAlign.sm], [fxLayoutAlign.md],  [fxLayoutAlign.lg], [fxLayoutAlign.xl], [fxLayoutAlign.lt-sm], [fxLayoutAlign.lt-md],  [fxLayoutAlign.lt-lg], [fxLayoutAlign.lt-xl], [fxLayoutAlign.gt-xs], [fxLayoutAlign.gt-sm],  [fxLayoutAlign.gt-md], [fxLayoutAlign.gt-lg]", inputs: ["fxLayoutAlign", "fxLayoutAlign.xs", "fxLayoutAlign.sm", "fxLayoutAlign.md", "fxLayoutAlign.lg", "fxLayoutAlign.xl", "fxLayoutAlign.lt-sm", "fxLayoutAlign.lt-md", "fxLayoutAlign.lt-lg", "fxLayoutAlign.lt-xl", "fxLayoutAlign.gt-xs", "fxLayoutAlign.gt-sm", "fxLayoutAlign.gt-md", "fxLayoutAlign.gt-lg"] }, { type: i41.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i42.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i42.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i21.MatSelectTrigger, selector: "mat-select-trigger" }, { type: i39.DefaultLayoutGapDirective, selector: "  [fxLayoutGap], [fxLayoutGap.xs], [fxLayoutGap.sm], [fxLayoutGap.md],  [fxLayoutGap.lg], [fxLayoutGap.xl], [fxLayoutGap.lt-sm], [fxLayoutGap.lt-md],  [fxLayoutGap.lt-lg], [fxLayoutGap.lt-xl], [fxLayoutGap.gt-xs], [fxLayoutGap.gt-sm],  [fxLayoutGap.gt-md], [fxLayoutGap.gt-lg]", inputs: ["fxLayoutGap", "fxLayoutGap.xs", "fxLayoutGap.sm", "fxLayoutGap.md", "fxLayoutGap.lg", "fxLayoutGap.xl", "fxLayoutGap.lt-sm", "fxLayoutGap.lt-md", "fxLayoutGap.lt-lg", "fxLayoutGap.lt-xl", "fxLayoutGap.gt-xs", "fxLayoutGap.gt-sm", "fxLayoutGap.gt-md", "fxLayoutGap.gt-lg"] }, { type: i41.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i40.DefaultStyleDirective, selector: "  [ngStyle],  [ngStyle.xs], [ngStyle.sm], [ngStyle.md], [ngStyle.lg], [ngStyle.xl],  [ngStyle.lt-sm], [ngStyle.lt-md], [ngStyle.lt-lg], [ngStyle.lt-xl],  [ngStyle.gt-xs], [ngStyle.gt-sm], [ngStyle.gt-md], [ngStyle.gt-lg]", inputs: ["ngStyle", "ngStyle.xs", "ngStyle.sm", "ngStyle.md", "ngStyle.lg", "ngStyle.xl", "ngStyle.lt-sm", "ngStyle.lt-md", "ngStyle.lt-lg", "ngStyle.lt-xl", "ngStyle.gt-xs", "ngStyle.gt-sm", "ngStyle.gt-md", "ngStyle.gt-lg"] }, { type: i43.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { type: i44.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["id", "disabled", "required", "type", "value", "readonly", "placeholder", "errorStateMatcher", "aria-describedby"], exportAs: ["matInput"] }, { type: i42.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i41.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i41.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i40.DefaultClassDirective, selector: "  [ngClass], [ngClass.xs], [ngClass.sm], [ngClass.md], [ngClass.lg], [ngClass.xl],  [ngClass.lt-sm], [ngClass.lt-md], [ngClass.lt-lg], [ngClass.lt-xl],  [ngClass.gt-xs], [ngClass.gt-sm], [ngClass.gt-md], [ngClass.gt-lg]", inputs: ["ngClass", "ngClass.xs", "ngClass.sm", "ngClass.md", "ngClass.lg", "ngClass.xl", "ngClass.lt-sm", "ngClass.lt-md", "ngClass.lt-lg", "ngClass.lt-xl", "ngClass.gt-xs", "ngClass.gt-sm", "ngClass.gt-md", "ngClass.gt-lg"] }, { type: i29.SatPopoverAnchor, selector: "[satPopoverAnchorFor]", inputs: ["satPopoverAnchorFor"], outputs: ["popoverOpened", "popoverClosed"], exportAs: ["satPopoverAnchor"] }, { type: i27.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["matMenuTriggerRestoreFocus", "mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { type: i34.MatCardContent, selector: "mat-card-content, [mat-card-content], [matCardContent]" }, { type: i6.RouterLink, selector: ":not(a):not(area)[routerLink]", inputs: ["routerLink", "queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo"] }, { type: i34.MatCardTitle, selector: "mat-card-title, [mat-card-title], [matCardTitle]" }, { type: i36.ɵb, selector: "ngx-dropzone-label" }], pipes: { "removeSpecialCharacters": i45.RemoveSpecialCharactersPipe, "fetchSizedAndCachedImage": i46.FetchSizedAndCachedImagePipe, "translate": i5.TranslatePipe, "softLabelsPipe": i47.SoftLabelPipe }, animations: [
+        trigger('fade', [
+            transition('void => *', [
+                style({ opacity: 0 }),
+                animate(2000, style({ opacity: 1 })),
+                animate(6000, style({ opacity: 0 }))
+            ])
+        ])
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.1", ngImport: i0, type: HeaderSideComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "app-header-side",
+                    templateUrl: "./header-side.template.html",
+                    animations: [
+                        trigger('fade', [
+                            transition('void => *', [
+                                style({ opacity: 0 }),
+                                animate(2000, style({ opacity: 1 })),
+                                animate(6000, style({ opacity: 0 }))
+                            ])
+                        ])
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PushNotificationsService }, { type: i2.ThemeService }, { type: i3.NgxUiLoaderService }, { type: i4.LayoutService }, { type: i5.TranslateService }, { type: i6.Router }, { type: i7.CookieService }, { type: i8.MatDialog }, { type: i9.CommonService }, { type: i10.Store }, { type: i11.PubNubAngular }, { type: i12.AuthenticationService }, { type: i13.Actions }, { type: i0.ChangeDetectorRef }, { type: i14.ToastrService }, { type: i15.StoreManagementService }, { type: i16.ShellModulesService }, { type: i17.ChatService }, { type: i18.SignalrService }, { type: Window, decorators: [{
+                    type: Inject,
+                    args: [WINDOW]
+                }] }]; }, propDecorators: { feedTimeSheetPopover: [{
+                type: ViewChild,
+                args: ['feedTimeSheet']
+            }], feedBackPopOver: [{
+                type: ViewChild,
+                args: ['feedBackPopover']
+            }], fileUploadDropzonePopup: [{
+                type: ViewChildren,
+                args: ["fileUploadDropzonePopup"]
+            }], documentPopover: [{
+                type: ViewChild,
+                args: ['documentPopover']
+            }], notificPanel: [{
+                type: Input
+            }], opened: [{
+                type: Output
+            }], openAnnoucementDialogComponent: [{
+                type: ViewChild,
+                args: ["openAnnoucementDialogComponent"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"header-side.component.js","sourceRoot":"","sources":["../../../../../../../shell-module-components/shell-components/src/lib/shell-components/components/header-side/header-side.component.ts","../../../../../../../shell-module-components/shell-components/src/lib/shell-components/components/header-side/header-side.template.html"],"names":[],"mappings":"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","sourcesContent":["import { UserDetailsFetchedAfterLogin, UserDetailsFetchedAfterCompanyLogin, FetchTimeSheetButtonDetails, RolesFetchTriggered } from './../../store/actions/authentication.actions';\r\nimport {\r\n  Component,\r\n  Inject,\r\n  Input,\r\n  OnInit,\r\n  ViewChild,\r\n  Output,\r\n  EventEmitter,\r\n  NgModuleRef,\r\n  NgModuleFactoryLoader,\r\n  ViewContainerRef, ViewChildren, ChangeDetectorRef, TemplateRef\r\n} from \"@angular/core\";\r\nimport {\r\n  ReceiveMessageTriggered,\r\n  PresenceEventTriggered,\r\n  InitalStateOfUsersTriggered,\r\n  MessageActionTypes,\r\n  ReceiveChannelUpdateModelTriggered,\r\n  ReceiveSignalTriggered,\r\n} from \"../../store/actions/chat.actions\"\r\nimport { MatDialog } from \"@angular/material/dialog\";\r\nimport { Router } from \"@angular/router\";\r\nimport { SatPopover } from \"@ncstate/sat-popover\";\r\nimport { select, Store } from \"@ngrx/store\";\r\nimport { TranslateService } from \"@ngx-translate/core\";\r\nimport { CookieService } from \"ngx-cookie-service\";\r\n\r\nimport { Observable, Subject } from \"rxjs\";\r\nimport { takeUntil, tap } from \"rxjs/operators\";\r\nimport { GetUserStoreIdTriggered, AuthenticationActionTypes } from \"../../store/actions/authentication.actions\";\r\nimport { ClearAllUnreadNotificationsTriggered, ClearUnreadNotificationsTriggered, NewNotificationReceived, NotificationsActionTypes, UpsertUnreadNotificationsTriggered } from \"../../store/actions/notifications.actions\";\r\nimport { State } from \"../../store/reducers/index\";\r\nimport * as sharedModuleReducers from \"../../store/reducers/index\";\r\nimport '../../../globaldependencies/helpers/fontawesome-icons';\r\nimport { ConfirmationDialogComponent } from \"../confirmation-dialog/confirmation-dialog.component\";\r\nimport { CommonService } from \"../../services/common-used.service\";\r\nimport { Actions, ofType } from \"@ngrx/effects\";\r\nimport { LocalStorageProperties } from '../../../globaldependencies/constants/localstorage-properties';\r\nimport { ChannelNames } from '../../constants/channel-names';\r\nimport { WINDOW } from '../../../globaldependencies/helpers/window.helper';\r\nimport { AuthenticationService } from '../../services/authentication.service';\r\nimport { ThemeService } from '../../services/theme.service';\r\nimport { LayoutService } from '../../services/layout.service';\r\nimport { TimesheetDisableorEnable } from '../../models/timesheetenabledisable';\r\nimport { ThemeModel } from '../../models/themes.model';\r\nimport { NotificationModel, NotificationOutputModel } from '../../models/NotificationsOutPutModel';\r\nimport { CustomAppBaseComponent } from '../../../globaldependencies/components/componentbase';\r\nimport { SoftLabelConfigurationModel } from '../../models/softlabels-model';\r\nimport { UserModel } from '../../models/user';\r\nimport { CompaniesList } from '../../models/companieslist.model';\r\nimport { StoreModel } from '../../models/store-model';\r\nimport { AppNotification } from '../../models/AppNotification';\r\nimport { StoreSearchModel } from '../../models/store-search-model';\r\nimport { NgModuleFactory, Type } from '@angular/core';\r\nimport { WorkItemsDialogComponent } from '../all-work-items-dialog/all-work-items-dialog.component';\r\nimport { ShellModulesService } from '../../services/shell.modules.service';\r\nimport * as _ from \"underscore\";\r\nimport { FeedTimeDialogComponent } from '../feed-time/feed-time-dialog.component';\r\nimport { NotificationTypeIds } from '../../constants/notification-type-ids';\r\nimport { UserStoryAssignedNotification } from '../../models/UserStoryAssignedNotification';\r\nimport { ChannelRoutes } from '../../constants/notification-routes';\r\nimport { RoleUpdatedNotification } from '../../models/RoleUpdatedNotification';\r\nimport { ReportSubmittedNotification } from '../../models/ReportSubmittedNotification';\r\nimport { ReportConfigAssignedNotification } from '../../models/ReportConfigAssignedNotification';\r\nimport { MultipleChartsScheduling } from '../../models/multiChartsScheduling';\r\nimport { AssetAssignedNotification } from '../../models/AssetAssignedNotificationModel';\r\nimport { NewProjectCreatedNotificationModel } from '../../models/NewProjectCreatedNotificationModel';\r\nimport { GoalApprovedNotificationModel } from '../../models/goalApprovedNotificationModel';\r\nimport { UserStoryUpdateNotificationModel } from '../../models/userStoryUpdateNotificationModel';\r\nimport { UserStoryCommentNotificationModel } from '../../models/userStoryCommentNotificationModel';\r\nimport { SprintStartedNotificationModel } from '../../models/sprintStartedNotificationModel';\r\nimport { SprintReplanStartedNotificationModel } from '../../models/sprintReplanRequestedModel';\r\nimport { AnnoucementDialogComponent } from '../notifications/announcement-dialog.component';\r\nimport { WorkspaceList } from '../../models/workspaceList';\r\nimport { animate, style, transition, trigger } from '@angular/animations';\r\nimport { NgxUiLoaderService, SPINNER } from 'ngx-ui-loader';\r\nimport { NewProjectFeatureCreatedNotificationModel } from '../../models/NewProjectFeatureNotificationModel';\r\nimport { UserStoryArchiveNotificationModel } from '../../models/archiveUserStoryModel';\r\nimport { UserStoryParkNotificationModel } from '../../models/parkUserStoryInputModel';\r\nimport { ExportConfigurationDialogComponent } from '../export-import-configuration/export-configuration.component';\r\nimport { FileModel, FileResultModel, StoreManagementService, UpsertFileModel } from '@snovasys/snova-document-management';\r\nimport { ToastrService } from 'ngx-toastr';\r\ntype ModuleWithComponentService = Type<any> & { componentService: Type<any> };\r\n// import { ConstantVariables } from \"../constants/constant-variables\";\r\nimport Resumable from \"resumablejs\";\r\nimport { ApiUrls } from '../../constants/api-urls';\r\nimport { AvailableLangs } from '../../constants/available-languages';\r\nimport { ImportConfigurationModel } from '../../models/import-configuration-model';\r\nimport { ChatService } from '../../services/chat.service';\r\nimport { MessageDetails } from '../../models/MessageDetails';\r\nimport { ChannelUpdateModel } from '../../models/ChannelUpdateModel';\r\nimport { PushNotificationsService } from 'ng-push-ivy';\r\nimport { MessageTypingDetails } from '../../models/MessageTypingDetails';\r\nimport { PubNubAngular } from 'pubnub-angular2';\r\n\r\n\r\nimport { IntroModel } from \"../../models/IntroModel\";\r\nimport { LeaveApplicationNotification } from '../../models/leaveApplicationNotifiction';\r\nimport { SignalrService } from '../../services/signalr.service';\r\n\r\n/** @dynamic */\r\n\r\n@Component({\r\n  selector: \"app-header-side\",\r\n  templateUrl: \"./header-side.template.html\",\r\n  animations: [\r\n    trigger('fade', [\r\n      transition('void => *', [\r\n        style({ opacity: 0 }),\r\n        animate(2000, style({ opacity: 1 })),\r\n        animate(6000, style({ opacity: 0 }))\r\n      ])\r\n    ])\r\n  ]\r\n})\r\n\r\nexport class HeaderSideComponent extends CustomAppBaseComponent implements OnInit {\r\n  @ViewChild('feedTimeSheet') feedTimeSheetPopover: SatPopover;\r\n  @ViewChild('feedBackPopover') feedBackPopOver: SatPopover;\r\n  @ViewChildren(\"fileUploadDropzonePopup\") fileUploadDropzonePopup;\r\n  @ViewChild('documentPopover') documentPopover: SatPopover;\r\n  softLabels: SoftLabelConfigurationModel[];\r\n  @Input() notificPanel;\r\n  @Output() opened = new EventEmitter<any>();\r\n  @ViewChild(\"openAnnoucementDialogComponent\") private openAnnoucementDialogComponent: TemplateRef<any>;\r\n  spinnerType = SPINNER.circle;\r\n  public availableLangs = AvailableLangs.languages;\r\n  public availableLangsMobile = [\r\n    {\r\n      name: \"En\",\r\n      code: \"en\"\r\n    },\r\n    {\r\n      name: \"Te\",\r\n      code: \"te\"\r\n    },\r\n    {\r\n      name: \"Ko\",\r\n      code: \"ko\"\r\n    },\r\n    {\r\n      name: \"Ar\",\r\n      code: \"ar\"\r\n    }\r\n  ];\r\n  // themeModel$: Observable<ThemeModel>;\r\n  countOfNotifications$: Observable<number>;\r\n  notifications$: Observable<NotificationOutputModel[]>;\r\n  unreadCountOfNotifications$: Observable<number>;\r\n  assetId$: Observable<string>;\r\n  userStoreId$: Observable<string>;\r\n  themeModel: ThemeModel;\r\n  reload: boolean;\r\n  public ngDestroyed$ = new Subject();\r\n  dashboardFilters = {\r\n    projectId: null,\r\n    userId: null,\r\n    goalId: null,\r\n    isDailogue: true\r\n  };\r\n  public egretThemes;\r\n  public layoutConf: any;\r\n  public timesheetDisableorEnable: TimesheetDisableorEnable;\r\n  domains: any[];\r\n  loadingInProgress$: Observable<boolean>;\r\n  timePunchCardShow = false;\r\n  showTrailPeriod: boolean = false;\r\n  applicationVersion: any;\r\n  companiesList = [];\r\n  menuType: string\r\n  isFeedBackDialog: boolean;\r\n  selectedLangName: string;\r\n  currentLang: string;\r\n  selectedStoreId: string = \"\";\r\n  userStoreId: string;\r\n  storesList: StoreModel[];\r\n  validationMessage: string;\r\n  isRecording: boolean = false;\r\n  projectRoleText: string = 'Project role configuration';\r\n  loggedInUserId: string = \"\";\r\n  company: any;\r\n  loggedUserDetails: any;\r\n  noOfDays: any;\r\n  showDeleteIcon: boolean = false;\r\n  showDelete: boolean = false;\r\n  isStoreAccess: boolean = true;\r\n  companyId: string;\r\n  returnUrl: string;\r\n  selectedCompanyName: string;\r\n  selectedCompany: CompaniesList;\r\n  userName: string;\r\n  loading: boolean;\r\n  authenticatedUserRecord: UserModel;\r\n  employeeId: string;\r\n  isFeedTimeSheet: boolean;\r\n  defaultDashboardId: string;\r\n  timeSheetButtonDetails$: Observable<TimesheetDisableorEnable>\r\n  notifications: NotificationOutputModel[];\r\n  announcementId: string;\r\n  announceNotificationId: string;\r\n  displayWelcomeNote: boolean;\r\n  loggedInCount: any;\r\n  userFullName: any;\r\n  files: File[] = [];\r\n  filesPresent: boolean;\r\n  progressValue: number;\r\n  fileResultModel: FileResultModel[];\r\n  moduleTypeId = 9;\r\n  anyOperationInProgress: boolean;\r\n  fileIndex: number = 0;\r\n  fileCounter: number = 1;\r\n  uploadedFileNames = [];\r\n  isFileUploadCompleted: boolean = false;\r\n  isFolderUploadCompleted: boolean = false;\r\n  importingInProgress: boolean;\r\n  searchText: string = null;\r\n  // messagesUnreadCount: number = 0;\r\n  channelList: any;\r\n  userChannels: any;\r\n  colleaguesList: any;\r\n  loggedInUserfullName: any;\r\n  logInUserId = this.cookieService.get(\"CurrentUserId\");\r\n  loginUserchannelName: string;\r\n  previousMessage : any;\r\n  publishingMessageOfUser :any;\r\n  newNotificationsCount: any = 0;\r\n\r\n  constructor(\r\n    private pushNotifications: PushNotificationsService,\r\n    private themeService: ThemeService,\r\n    private ngxService: NgxUiLoaderService,\r\n    private layout: LayoutService,\r\n    public translate: TranslateService,\r\n    public router: Router,\r\n    private cookieService: CookieService,\r\n    public dialog: MatDialog,\r\n    private commonService: CommonService,\r\n    private store: Store<State>,\r\n    private pubnub: PubNubAngular,\r\n    private authService: AuthenticationService,\r\n    private actionUpdates$: Actions,\r\n    private cdRef: ChangeDetectorRef,\r\n    private toastr: ToastrService,\r\n    private storeManagementService: StoreManagementService,\r\n    private ShellModulesService: ShellModulesService,\r\n    private chatService: ChatService,\r\n    private signalr: SignalrService,\r\n    @Inject(WINDOW) private window: Window\r\n  ) {\r\n    super();\r\n    // this.signalr.initializeSignalRConnection();\r\n    this.signalr.notifications$.subscribe((data: any) => this.newNotificationsCount = data && data.length ? data.length : 0);\r\n\r\n    this.pushNotifications.requestPermission();\r\n    this.isRecording = false;\r\n    // this.getActTrackerRecorder();\r\n    if ((localStorage.getItem(LocalStorageProperties.UserModel) != null && localStorage.getItem(LocalStorageProperties.UserModel) != undefined)\r\n    ) {\r\n      this.loadNotifications();\r\n    }\r\n    let currentCulture = this.cookieService.get(LocalStorageProperties.CurrentCulture);\r\n    const companylan = JSON.parse(this.cookieService.get(LocalStorageProperties.CompanyDetails));\r\n    let currentCulturelan = companylan.lanCode;\r\n\r\n    if (currentCulture == '' || currentCulture == null || currentCulture == undefined || currentCulture === 'null' || currentCulture === 'undefined') {\r\n      if (currentCulturelan == '' || currentCulturelan == null || currentCulturelan == undefined || currentCulturelan === 'null' || currentCulturelan === 'undefined') {\r\n        currentCulture = 'en';\r\n      }\r\n      else {\r\n        currentCulture = currentCulturelan;\r\n      }\r\n    }\r\n    this.currentLang = currentCulture;\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    this.cookieService.set(LocalStorageProperties.CurrentCulture, this.currentLang, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.actionUpdates$\r\n      .pipe(\r\n        takeUntil(this.ngDestroyed$),\r\n        ofType(AuthenticationActionTypes.UserDetailsFetchedAfterCompanyLogin),\r\n        tap(() => {\r\n          this.reload = true;\r\n          // this.chatService.getRecentChannelMessages().subscribe((recentChannelMessages: any) => {\r\n          //   recentChannelMessages.data.forEach(element => {\r\n          //     this.messagesUnreadCount += element.unreadMessageCount;\r\n          //   });\r\n          // });\r\n          // this.chatService.getRecentIndividualMessages().subscribe((recentColleagueMessages: any) => {\r\n          //   var uniq = {};\r\n          //   recentColleagueMessages.data = recentColleagueMessages.data.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));\r\n          //   recentColleagueMessages.data.forEach(element => {\r\n          //     if(element.id != this.loggedInUserId){\r\n          //     this.messagesUnreadCount += element.unreadMessageCount;\r\n          //     }\r\n          //   });\r\n          // });\r\n    this.getIntroDetails();\r\n          this.ngOnInit();\r\n          this.getNotifications();\r\n          this.getTeamMembers();\r\n          var DefaultDashboardIdForLoggedInUser = this.cookieService.check(LocalStorageProperties.DefaultDashboard) ? JSON.parse(this.cookieService.get(LocalStorageProperties.DefaultDashboard)) : null;\r\n          const userReference = localStorage.getItem(LocalStorageProperties.UserReferenceId);\r\n          if (!DefaultDashboardIdForLoggedInUser) {\r\n            this.router.navigate([this.returnUrl]);\r\n          } else if (userReference != \"null\" && userReference != null) {\r\n            this.router.navigateByUrl(\"dashboard-management/dashboard/\" + DefaultDashboardIdForLoggedInUser + \"/form/\" + userReference);\r\n          } else {\r\n            this.router.navigateByUrl(\"dashboard-management/dashboard/\" + DefaultDashboardIdForLoggedInUser);\r\n          }\r\n\r\n        })\r\n      )\r\n      .subscribe();\r\n\r\n\r\n    this.actionUpdates$\r\n      .pipe(\r\n        takeUntil(this.ngDestroyed$),\r\n        ofType(AuthenticationActionTypes.UserDetailsFetchedAfterLogin),\r\n        tap(() => {\r\n          setTimeout(() => {\r\n            if (this.cookieService.check(LocalStorageProperties.CurrentUserId)) {\r\n              const CurrentUserId = this.cookieService.get(LocalStorageProperties.CurrentUserId);\r\n              // Subscribe to Task Assignment Notificaitons here.\r\n              const taskAssignmentChannelToSubscribeInto = ChannelNames.Channel_TaskAssignments + CurrentUserId;\r\n              const tastatusReportSubmissionChannelToSubscribeInto = ChannelNames.Channel_StatusReportSubmission + CurrentUserId;\r\n              const tastatusConfigAssignChannelToSubscribeInto = ChannelNames.Channel_StatusConfigAssign + CurrentUserId;\r\n              const multiChartsSchedulingChannelToSubscribeInto = ChannelNames.Channel_MultiChartsScheduling + CurrentUserId;\r\n              const assetsAssignedChannelToSubscribeInto = ChannelNames.Channel_AssetAssignment + CurrentUserId;\r\n              const projectCreatedChannelToSubscribeInto = ChannelNames.Channel_NewProject + CurrentUserId;\r\n              const projectAccessToMemberChannelToSubscribeInto = ChannelNames.Channel_ProjectMemberRole + CurrentUserId;\r\n              const goalApprovedChannelToSubscribeInto = ChannelNames.Channel_GoalApprovedFromReplan + CurrentUserId;\r\n              const userStoryUpdateChannelToSubscribeInto = ChannelNames.Channel_UserStoryUpdateNotification + CurrentUserId;\r\n              const AnnouncementChannelToSubscribeInto = ChannelNames.Channel_AnnouncementNotification + CurrentUserId;\r\n              const purchaseExecutionAssignedChannelToSubscribeInto = ChannelNames.Channel_PurchaseExecutionAssignToEmployeeNotification + CurrentUserId;\r\n              console.log(\"subscribing to \" + taskAssignmentChannelToSubscribeInto);\r\n              console.log(\"subscribing to \" + tastatusReportSubmissionChannelToSubscribeInto);\r\n              console.log(\"subscribing to \" + tastatusConfigAssignChannelToSubscribeInto);\r\n              console.log(\"subscribing to\" + assetsAssignedChannelToSubscribeInto);\r\n              console.log(\"subscribing to\" + projectCreatedChannelToSubscribeInto);\r\n              console.log(\"subscribing to\" + projectAccessToMemberChannelToSubscribeInto);\r\n              console.log(\"subscribing to\" + goalApprovedChannelToSubscribeInto);\r\n              console.log(\"subscribing to\" + userStoryUpdateChannelToSubscribeInto);\r\n              console.log(\"subscribing to\" + AnnouncementChannelToSubscribeInto);\r\n              console.log(\"subscribing to\" + purchaseExecutionAssignedChannelToSubscribeInto);\r\n              pubnub.subscribe({\r\n                channels: [taskAssignmentChannelToSubscribeInto, tastatusReportSubmissionChannelToSubscribeInto,\r\n                  tastatusConfigAssignChannelToSubscribeInto, multiChartsSchedulingChannelToSubscribeInto,\r\n                  assetsAssignedChannelToSubscribeInto, projectCreatedChannelToSubscribeInto, ,\r\n                  projectAccessToMemberChannelToSubscribeInto, goalApprovedChannelToSubscribeInto,\r\n                  userStoryUpdateChannelToSubscribeInto, AnnouncementChannelToSubscribeInto,purchaseExecutionAssignedChannelToSubscribeInto]\r\n              });\r\n\r\n              // Add other subscriptions here.\r\n            } else {\r\n              console.log(\"User not logged in yet to be able to subscribe.\");\r\n            }\r\n\r\n            var roleUpdatesChannelToSubscribeInto = ChannelNames.Channel_RoleUpdates + \"19B6F9FC-7370-4B9C-A05C-3B8D819EEEAF\";\r\n            console.log(\"subscribing to \" + roleUpdatesChannelToSubscribeInto);\r\n            pubnub.subscribe({\r\n              channels: [roleUpdatesChannelToSubscribeInto]\r\n            });\r\n          }, 3000);\r\n        })).subscribe();\r\n\r\n    this.actionUpdates$\r\n      .pipe(\r\n        takeUntil(this.ngDestroyed$),\r\n        ofType(NotificationsActionTypes.ClearAllUnreadNotificationsCompleted),\r\n        tap(() => {\r\n          this.notifications$ = this.store.pipe(select(sharedModuleReducers.getNotificationAll));\r\n          this.notifications$.subscribe(x => {\r\n            this.notifications = x;\r\n            const index = this.notifications.findIndex((p) => JSON.parse(p.notificationJson).NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.Announcement_Received.toString().toLowerCase());\r\n            if (index > -1) {\r\n              //this.announceNotificationId = JSON.parse(this.notifications[index].notificationJson).notificationId;\r\n              this.announceNotificationId = this.notifications[index].notificationId;\r\n              this.openAnnouncementDialog(JSON.parse(this.notifications[index].notificationJson));\r\n\r\n            }\r\n          });\r\n\r\n        })\r\n      )\r\n      .subscribe();\r\n\r\n    // this.actionUpdates$\r\n    //   .pipe(\r\n    //     takeUntil(this.ngDestroyed$),\r\n    //     ofType(MessageActionTypes.CountCompleted),\r\n    //     tap((result: any) => {\r\n    //       this.messagesUnreadCount = result.messageCount;\r\n    //       this.cdRef.detectChanges();\r\n    //     })\r\n    //   )\r\n    //   .subscribe();\r\n\r\n    this.actionUpdates$\r\n      .pipe(\r\n        takeUntil(this.ngDestroyed$),\r\n        ofType(MessageActionTypes.RequestingStateOfUsersCompleted),\r\n        tap((result: any) => {\r\n          this.subScribingToPresenceChannel();\r\n          \r\n        })\r\n      )\r\n      .subscribe();\r\n    this.actionUpdates$\r\n      .pipe(\r\n        takeUntil(this.ngDestroyed$),\r\n        ofType(MessageActionTypes.MessageCompleted),\r\n        tap((result: any) => {\r\n          var messageDetails = result['messageDetails'];\r\n          this.publishingMessageOfUser = messageDetails;\r\n          this.publishingMessage();\r\n        })\r\n      )\r\n      .subscribe();\r\n    this.actionUpdates$\r\n      .pipe(\r\n        takeUntil(this.ngDestroyed$),\r\n        ofType(MessageActionTypes.SendChannelUpdateModelCompleted),\r\n        tap((result: any) => {\r\n          var channelUpdateModel = result['channelUpdateModel'];\r\n          var loginCompanyId = this.cookieService.get(\"CompanyId\");\r\n          this.pubnub.publish({\r\n            channel: [(loginCompanyId + '-' + channelUpdateModel.channelId)],\r\n            message: JSON.stringify(channelUpdateModel)\r\n          }, function (status, resopnse) {\r\n            // console.log(status)\r\n            // console.log(resopnse)\r\n          })\r\n        })\r\n      )\r\n      .subscribe();\r\n     \r\n      \r\n    this.actionUpdates$\r\n      .pipe(\r\n        takeUntil(this.ngDestroyed$),\r\n        ofType(MessageActionTypes.SendingSignalCompleted),\r\n        tap((result: any) => {\r\n          var messageTypingDetails = result.messageTypingDetails;\r\n          var signalMessage= new MessageTypingDetails();\r\n          signalMessage.state = messageTypingDetails.state;\r\n          console.log(messageTypingDetails,signalMessage);\r\n          // this.pubnub.signal({\r\n          //   channel:[messageTypingDetails.pubnubChannelNameOfMessage],\r\n          //   message : JSON.stringify(signalMessage)\r\n          // })\r\n        })\r\n      )\r\n      .subscribe();  \r\n      const storeListner = (message) => {\r\n        console.log(\"---------Received pubnub message---------\");\r\n        //this.toastr.info(message.message.Summary);\r\n        try {\r\n          //Receiving the User Story Assigned Notification\r\n          if (typeof (message.message) == 'string') {\r\n            var indexOfCurrentTopic: number;\r\n            var messageDetailsObject = JSON.parse(message.message);\r\n            if (messageDetailsObject.textMessage || messageDetailsObject.filePath || messageDetailsObject.messageType) {\r\n              this.store.dispatch(new ReceiveMessageTriggered(messageDetailsObject));\r\n            }\r\n            else if (messageDetailsObject.isFromChannelArchive == true ||\r\n              messageDetailsObject.isFromRemoveMember == true ||\r\n              messageDetailsObject.refreshChannels == true || messageDetailsObject.isFromAddMember == true) {\r\n              this.chatService.getUserChannels().subscribe((channels: any) => {\r\n                this.channelList = channels.data;\r\n                var loginCompanyId = this.cookieService.get(\"CompanyId\");\r\n                var channelName = loginCompanyId + '-' + messageDetailsObject.channelId;\r\n                var index = this.channelList.findIndex(x => x.id == messageDetailsObject.channelId);\r\n                if (index != -1 && (messageDetailsObject.refreshChannels == true || messageDetailsObject.isFromAddMember == true)) {\r\n                  this.pubnub.subscribe({\r\n                    channels: [channelName]\r\n                  })\r\n                } else {\r\n                  if (index == -1) {\r\n                    this.pubnub.unsubscribe({\r\n                      channels: [channelName]\r\n                    })\r\n                  }\r\n                }\r\n                this.store.dispatch(new ReceiveChannelUpdateModelTriggered(messageDetailsObject));\r\n              });\r\n            }\r\n          \r\n            if (this.router.routerState.snapshot.url != \"/chat\" && messageDetailsObject.messageType != \"Reaction\" && messageDetailsObject.body != null && messageDetailsObject.title != null  && (messageDetailsObject.isPinned == null || messageDetailsObject.isPinned == undefined) &&  (messageDetailsObject.isStarred == null || messageDetailsObject.isStarred == undefined) && messageDetailsObject.senderUserId != this.logInUserId ) {\r\n              if (messageDetailsObject.channelId) {\r\n                this.chatService.getUserChannels().subscribe((channels: any) => {\r\n                  this.channelList = channels.data;\r\n                  indexOfCurrentTopic = this.channelList.findIndex(x => x.id == messageDetailsObject.channelId);\r\n                  if (indexOfCurrentTopic != -1) {\r\n                    // this.notificationOfChat(messageDetailsObject);\r\n                  }\r\n                });\r\n              } else {\r\n                // this.notificationOfChat(messageDetailsObject);\r\n              }\r\n            }\r\n          } else\r\n           if (message.message.NotificationTypeGuid == NotificationTypeIds.Notification_WorkItemAssignedToUser) {\r\n            var userStoryAssignedNotification = new UserStoryAssignedNotification();\r\n            userStoryAssignedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            userStoryAssignedNotification.route = ChannelRoutes.ViewWorkItem + userStoryAssignedNotification.notificationId;\r\n            this.store.dispatch(new NewNotificationReceived(userStoryAssignedNotification));\r\n          } else if (message.message.NotificationTypeGuid == NotificationTypeIds.GenericNotificationActivity) {\r\n            var userStoryAssignedNotification = new UserStoryAssignedNotification();\r\n            userStoryAssignedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            // userStoryAssignedNotification.route = ChannelRoutes.ViewWorkItem + userStoryAssignedNotification.notificationId;\r\n            this.store.dispatch(new NewNotificationReceived(userStoryAssignedNotification));\r\n          } else if (message.message.NotificationTypeGuid == NotificationTypeIds.Notification_RoleUpdated) {\r\n            var roleUpdatedNotification = new RoleUpdatedNotification();\r\n            roleUpdatedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            roleUpdatedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(roleUpdatedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid == NotificationTypeIds.Status_Report_Sumitted) {\r\n            var reportSubmittedNotification = new ReportSubmittedNotification();\r\n            reportSubmittedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            reportSubmittedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(reportSubmittedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid == NotificationTypeIds.Status_Report_Config_Created) {\r\n            var reportConfigAssignedNotification = new ReportConfigAssignedNotification();\r\n            reportConfigAssignedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            reportConfigAssignedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(reportConfigAssignedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid == NotificationTypeIds.Multiple_Charts_Scheduling_created) {\r\n            var multipleChartsScheduling = new MultipleChartsScheduling();\r\n            multipleChartsScheduling.loadFromCaseInsensitiveObject(message.message);\r\n            multipleChartsScheduling.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(multipleChartsScheduling));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid == NotificationTypeIds.Assets_Assignment) {\r\n            const assetAssignedNotification = new AssetAssignedNotification();\r\n            assetAssignedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            assetAssignedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(assetAssignedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.Reminder_Notification.toString().toLowerCase()) {\r\n            const assetAssignedNotification = new AssetAssignedNotification();\r\n            assetAssignedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            assetAssignedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(assetAssignedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.Announcement_Received.toString().toLowerCase()) {\r\n            const assetAssignedNotification = new AssetAssignedNotification();\r\n            assetAssignedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            assetAssignedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(assetAssignedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n            // if (message.message.Id != this.announceNotificationId) {\r\n            //   this.announceNotificationId = message.message.Id;\r\n            //   this.openAnnouncementDialog(message.message);\r\n            // }\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.Performance_Received.toString().toLowerCase() || message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ProjectMemberRoleAddedNotificationId.toString().toLowerCase()) {\r\n            const newProjectCreatedNotification = new NewProjectCreatedNotificationModel();\r\n            newProjectCreatedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            newProjectCreatedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(newProjectCreatedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.NewProjectCreatedNotificationId.toString().toLowerCase() || message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ProjectMemberRoleAddedNotificationId.toString().toLowerCase()) {\r\n            const newProjectCreatedNotification = new NewProjectCreatedNotificationModel();\r\n            newProjectCreatedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            newProjectCreatedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(newProjectCreatedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.GoalApprovedFromReplan.toString().toLowerCase()) {\r\n            const goalApprovedNotificationModel = new GoalApprovedNotificationModel();\r\n            goalApprovedNotificationModel.loadFromCaseInsensitiveObject(message.message);\r\n            goalApprovedNotificationModel.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(goalApprovedNotificationModel));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.USerStoryUpdateNotificationId.toString().toLowerCase()) {\r\n            const userStoryUpdateNotificationModel = new UserStoryUpdateNotificationModel();\r\n            userStoryUpdateNotificationModel.loadFromCaseInsensitiveObject(message.message);\r\n            userStoryUpdateNotificationModel.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(userStoryUpdateNotificationModel));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PushNotificationForUserStoryComment.toString().toLowerCase()) {\r\n            const userStoryCommentNotificationModel = new UserStoryCommentNotificationModel();\r\n            userStoryCommentNotificationModel.loadFromCaseInsensitiveObject(message.message);\r\n            userStoryCommentNotificationModel.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(userStoryCommentNotificationModel));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.SprintStarted.toString().toLowerCase()) {\r\n            const sprintStartedNotificationModel = new SprintStartedNotificationModel();\r\n            sprintStartedNotificationModel.loadFromCaseInsensitiveObject(message.message);\r\n            sprintStartedNotificationModel.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(sprintStartedNotificationModel));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.SprintRequestdForREplan.toString().toLowerCase()) {\r\n            const sprintReplanStartedNotificationModel = new SprintReplanStartedNotificationModel();\r\n            sprintReplanStartedNotificationModel.loadFromCaseInsensitiveObject(message.message);\r\n            sprintReplanStartedNotificationModel.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(sprintReplanStartedNotificationModel));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ProjectFeature.toString().toLowerCase()) {\r\n            const newProjectFeatureCreatedNotification = new NewProjectFeatureCreatedNotificationModel();\r\n            newProjectFeatureCreatedNotification.loadFromCaseInsensitiveObject(message.message);\r\n            newProjectFeatureCreatedNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(newProjectFeatureCreatedNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.UserStoryArchive.toString().toLowerCase()) {\r\n            const newUserStoryArchiveModel = new UserStoryArchiveNotificationModel();\r\n            newUserStoryArchiveModel.loadFromCaseInsensitiveObject(message.message);\r\n            newUserStoryArchiveModel.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(newUserStoryArchiveModel));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.UserStoryPark.toString().toLowerCase()) {\r\n            const newUserStoryParkModel = new UserStoryParkNotificationModel();\r\n            newUserStoryParkModel.loadFromCaseInsensitiveObject(message.message);\r\n            newUserStoryParkModel.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(newUserStoryParkModel));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.LeaveApplication.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ApproveLeaveApplication.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.RejectLeaveApplication.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ResignationNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ResignationApprovalNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ResignationRejectionNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.AutoTimeSheetSubmissionNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ProbationAssignNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ReviewAssignToEmployeeNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ReviewSubmittedByEmployeeNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.ReviewInvitationNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PerformanceReviewSubmittedByEmployeeNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PerformanceReviewInvitationNotificationModel.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          } \r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PerformanceReviewAssignToEmployeeNotification.toString().toLowerCase()) {\r\n            const leaveApplicationNotification = new LeaveApplicationNotification();\r\n            leaveApplicationNotification.loadFromCaseInsensitiveObject(message.message);\r\n            leaveApplicationNotification.route = ChannelRoutes.ViewAccount;\r\n            this.store.dispatch(new NewNotificationReceived(leaveApplicationNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          }\r\n          else if (message.message.NotificationTypeGuid.toString().toLowerCase() == NotificationTypeIds.PurchaseShipmentNotificationId.toString().toLowerCase()) {\r\n            const purchaseExecutionNotification = new LeaveApplicationNotification();\r\n            purchaseExecutionNotification.loadFromCaseInsensitiveObject(message.message);\r\n            purchaseExecutionNotification.route = ChannelRoutes.EditPurchaseExecution;\r\n            this.store.dispatch(new NewNotificationReceived(purchaseExecutionNotification));\r\n            this.store.dispatch(new RolesFetchTriggered());\r\n          }\r\n          else {\r\n            // TODO: Send these errors onto server for further processing\r\n            console.log(\"Found undetected notification type. \" + message.message.NotificationTypeGuid);\r\n          }\r\n          // Add other notifications here.\r\n  \r\n        } catch (exception) {\r\n          // TODO: Send these exceptions onto server for further processing\r\n          console.log(\"Exception Occured\" + exception.message);\r\n        }\r\n      };\r\n      const statusOfUser = (presenceEvent) => {\r\n        this.store.dispatch(new PresenceEventTriggered(presenceEvent));\r\n      }\r\n      const typingStatus = (signalEvent) => {\r\n        this.store.dispatch(new ReceiveSignalTriggered(signalEvent));\r\n      }  \r\n      this.chatService.getPubnubKeys().subscribe((keys:any) =>{\r\n       this.pubnub.init({\r\n         publishKey : keys.data.publishKey,\r\n         subscribeKey :keys.data.subscribeKey,\r\n         uuid : this.logInUserId\r\n        })\r\n       this.chatService.getAllUsersForSlackApp().subscribe((colleagues: any) => {\r\n        this.colleaguesList = colleagues.data;\r\n        this.chatService.getUserChannels().subscribe((channels: any) => {\r\n          this.channelList = channels.data;\r\n          this.signOutUserChannels();\r\n          var loginCompanyId = this.cookieService.get(\"CompanyId\");\r\n          if (this.channelList != undefined || this.channelList != null) {\r\n            for (var index1 = 0; index1 < this.channelList.length; index1++) {\r\n              this.pubnub.subscribe({\r\n                channels: [(loginCompanyId + '-' + this.channelList[index1].id)]\r\n              });\r\n            }\r\n          }\r\n          this.pubnub.subscribe({\r\n            channels: [('ChannelUpdates-' + loginCompanyId)]\r\n          });\r\n          this.pubnub.subscribe({\r\n            channels: [('UserUpdates-' + loginCompanyId)]\r\n          });\r\n          var index12 = this.colleaguesList.findIndex(x => x.userId == this.logInUserId);\r\n          if(index12 > -1){\r\n          var name = this.colleaguesList[index12].fullName;\r\n          name = name.trim();\r\n          name = this.replaceAll(name, \" \", \"\")\r\n          this.loginUserchannelName = (name + '-' + this.logInUserId);\r\n           this.pubnub.subscribe({\r\n            channels: [this.loginUserchannelName]\r\n          });\r\n        }\r\n        })\r\n      }) \r\n        this.pubnub.addListener({\r\n          status: st => {\r\n            if (st.category === \"PNUnknownCategory\") {\r\n              var newState = {\r\n                new: \"error\"\r\n              };\r\n              this.pubnub.setState(\r\n                {\r\n                  state: newState\r\n                }\r\n                // function (status) {\r\n                //   console.log(st.errorData.message);\r\n                // }\r\n              );\r\n            }\r\n          },\r\n          signal: signalEvent => {\r\n            typingStatus(signalEvent)\r\n          },\r\n          presence: presenceEvent => {\r\n            statusOfUser(presenceEvent)\r\n          },\r\n          message: message => {\r\n            console.log(\"subscribed to \" + message);\r\n            storeListner(message);\r\n          }\r\n        });\r\n      });\r\n  }\r\n  async signOutUserChannels(){\r\n    this.pubnub.unsubscribe({ channels: [this.loginUserchannelName] });\r\n  var loginCompanyId = this.cookieService.get(\"CompanyId\");\r\n  if (this.channelList != undefined || this.channelList != null) {\r\n    for (var index = 0; index < this.channelList.length; index++) {\r\n      this.pubnub.unsubscribe({\r\n        channels: [(loginCompanyId + '-' + this.channelList[index].id)]\r\n      });\r\n    }\r\n  }\r\n  this.pubnub.unsubscribe({\r\n    channels: [('ChannelUpdates-' + loginCompanyId)]\r\n  });\r\n  this.pubnub.unsubscribe({\r\n    channels: [('UserUpdates-' + loginCompanyId)]\r\n  });\r\n }\r\n\r\n  async subScribingToPresenceChannel(){\r\n    var loginCompanyId = this.cookieService.get(\"CompanyId\");\r\n          var presenceChannel = \"MessengerPresence-\" + loginCompanyId;\r\n           await this.pubnub.subscribe({\r\n            channels: [presenceChannel],\r\n            withPresence: true\r\n          });\r\n          this.pubnub.hereNow({\r\n              channels: [presenceChannel],\r\n              includeUUIDs: true,\r\n              includeState: true\r\n            },\r\n            (status, response) => {\r\n              this.store.dispatch(new InitalStateOfUsersTriggered(response))\r\n            }\r\n          );\r\n\r\n  }\r\n  publishingMessage() {\r\n    if (this.publishingMessageOfUser.pubnubChannelNameOfMessage.length > 0) {\r\n      this.publishingMessageOfUser.pubnubChannelNameOfMessage.forEach(channelName => {\r\n        this.pubnub.publish({\r\n          channel: [channelName],\r\n          message: JSON.stringify(this.publishingMessageOfUser)\r\n        }, function (status, resopnse) {\r\n          // console.log(status)\r\n          // console.log(resopnse)\r\n        })\r\n      });\r\n    }\r\n  }\r\n\r\n  openAnnouncementDialog(announced) {\r\n    this.dialog.closeAll();\r\n    let dialogId = \"annoucement-dialog\";\r\n    const dialogRef = this.dialog.open(this.openAnnoucementDialogComponent, {\r\n      minWidth: \"60vw\",\r\n      maxWidth: \"60vw\",\r\n      minHeight: \"50vh\",\r\n      maxHeight: \"80vh\",\r\n      disableClose: true,\r\n      id: dialogId,\r\n      data: {\r\n        dialogId: dialogId,\r\n        announcementId: announced.AnnouncementId,\r\n        announcement: announced.Announcement,\r\n        announcedBy: announced.AnnouncedBy,\r\n        announcedById: announced.AnnouncedById,\r\n        announcedByUserImage: announced.AnnouncedByUserImage,\r\n        announcedOn: announced.AnnouncedOn\r\n      }\r\n    });\r\n    dialogRef.afterClosed().subscribe((result) => {\r\n      const index = this.notifications.findIndex((p) => p.notificationId.toString().toLowerCase() == this.announceNotificationId.toString().toLowerCase());\r\n      if (index > -1) {\r\n        this.upsertReadNotification(this.notifications[index]);\r\n      }\r\n    });\r\n  }\r\n  // notificationOfChat(messageDetailsObject) {\r\n  //   if(this.previousMessage != messageDetailsObject){\r\n  //   this.messagesUnreadCount += 1;\r\n  //   var imageforNotification: any;\r\n  //   if (messageDetailsObject.senderProfileImage == null) {\r\n  //     imageforNotification = \"https://pngimage.net/wp-content/uploads/2018/05/avatar-png-images-1.png\";\r\n  //   }\r\n  //   else {\r\n  //     imageforNotification = messageDetailsObject.senderProfileImage;\r\n  //   }\r\n  //   let options = {\r\n  //     body: messageDetailsObject.body,\r\n  //     icon: imageforNotification,\r\n  //     data: {\r\n  //       senderUserId: messageDetailsObject.senderUserId,\r\n  //       channelId: messageDetailsObject.channelId\r\n  //     }\r\n  //   }\r\n  //   this.pushNotifications.create(messageDetailsObject.title, options).subscribe(\r\n  //     res => {\r\n  //       if (res.event.type === 'click') {\r\n  //         window.focus();\r\n  //         if (this.router.url != '/chat') {\r\n  //           if (res.notification.data.channelId != null && res.notification.data.channelId != undefined) {\r\n  //             localStorage.setItem(LocalStorageProperties.ChatId, res.notification.data.channelId);\r\n  //           } else {\r\n  //             localStorage.setItem(LocalStorageProperties.ChatId, res.notification.data.senderUserId);\r\n  //           }\r\n  //           this.router.navigate([\"/chat\"]);\r\n  //         }\r\n  //       }\r\n  //     },\r\n  //     err => console.log(err)\r\n  //   );\r\n  //   this.previousMessage = messageDetailsObject\r\n  //   }\r\n  // }\r\n  upsertReadNotification(selectedNotification) {\r\n    const notifications = [];\r\n    notifications.push(selectedNotification);\r\n    const notiifcationmodel = JSON.parse(selectedNotification.notificationJson);\r\n    if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.NewProjectCreatedNotificationId.toString().toLowerCase() ||\r\n      selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.ProjectMemberRoleAddedNotificationId.toString().toLowerCase()) {\r\n      this.router.navigate([\"projects/projectstatus/\" + notiifcationmodel.ProjectGuid + \"/active-goals\"]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.GoalApprovedFromReplan.toString().toLowerCase()) {\r\n      this.router.navigate([\"projects/goal/\" + notiifcationmodel.GoalGuid]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.Notification_WorkItemAssignedToUser.toString().toLowerCase()) {\r\n      this.router.navigate([\"projects/workitem/\" + notiifcationmodel.UserStoryGuid]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.USerStoryUpdateNotificationId.toString().toLowerCase()) {\r\n      this.router.navigate([\"projects/workitem/\" + notiifcationmodel.UserStoryId]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.SprintStarted.toString().toLowerCase()) {\r\n      this.router.navigate([\"projects/sprint/\" + notiifcationmodel.SprintGuid]);\r\n    }\r\n    else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.PushNotificationForUserStoryComment.toString().toLowerCase()) {\r\n      this.router.navigate([\"projects/workitem/\" + notiifcationmodel.UserStoryGuid]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.GoalRequestdForREplan.toString().toLowerCase()) {\r\n      this.router.navigate([\"projects/goal/\" + notiifcationmodel.GoalGuid]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.SprintRequestdForREplan.toString().toLowerCase()) {\r\n      this.router.navigate([\"projects/sprint/\" + notiifcationmodel.SprintGuid]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.Notification_AdhocWorkItemAssignedToUser.toString().toLowerCase()) {\r\n      this.router.navigate([\"dashboard/adhoc-workitem/\" + notiifcationmodel.UserStoryGuid]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n      NotificationTypeIds.AdhocUSerStoryUpdateNotificationId.toString().toLowerCase()) {\r\n      this.router.navigate([\"dashboard/adhoc-workitem/\" + notiifcationmodel.UserStoryId]);\r\n    } else if (selectedNotification.notificationTypeId.toString().toLowerCase() ==\r\n    NotificationTypeIds.PurchaseShipmentNotificationId.toString().toLowerCase()) {\r\n    this.router.navigate([\"client/purchase-execution/\" + notiifcationmodel.PurchaseGuid]);\r\n  }\r\n    this.store.dispatch(new UpsertUnreadNotificationsTriggered(notifications));\r\n\r\n\r\n  }\r\n  loadNotifications() {\r\n    const CurrentUserId = this.cookieService.get(LocalStorageProperties.CurrentUserId);\r\n    // Subscribe to Task Assignment Notificaitons here.\r\n    const taskAssignmentChannelToSubscribeInto = ChannelNames.Channel_TaskAssignments + CurrentUserId;\r\n    const tastatusReportSubmissionChannelToSubscribeInto = ChannelNames.Channel_StatusReportSubmission + CurrentUserId;\r\n    const tastatusConfigAssignChannelToSubscribeInto = ChannelNames.Channel_StatusConfigAssign + CurrentUserId;\r\n    const multiChartsSchedulingChannelToSubscribeInto = ChannelNames.Channel_MultiChartsScheduling + CurrentUserId;\r\n    const assetsAssignedChannelToSubscribeInto = ChannelNames.Channel_AssetAssignment + CurrentUserId;\r\n    const projectCreatedChannelToSubscribeInto = ChannelNames.Channel_NewProject + CurrentUserId;\r\n    const projectAccessToMemberChannelToSubscribeInto = ChannelNames.Channel_ProjectMemberRole + CurrentUserId;\r\n    const goalApprovedChannelToSubscribeInto = ChannelNames.Channel_GoalApprovedFromReplan + CurrentUserId;\r\n    const userStoryUpdateChannelToSubscribeInto = ChannelNames.Channel_UserStoryUpdateNotification + CurrentUserId;\r\n    const AnnouncementChannelToSubscribeInto = ChannelNames.Channel_AnnouncementNotification + CurrentUserId;\r\n    const ReminderChannelToSubscribeInto = ChannelNames.Channel_ReminderNotification + CurrentUserId;\r\n    const PerformanceChannelToSubscribeInto = ChannelNames.Channel_PeroformanceNotification + CurrentUserId;\r\n    const userStoryCommentChannelToSubscribeInto = ChannelNames.Channel_UserStoryComment + CurrentUserId;\r\n    const sprintStartedChannelToSubscribeInto = ChannelNames.Channel_SprintStarted + CurrentUserId;\r\n    const sprintReplanChannelToSubscribeInto = ChannelNames.Channel_SprintRequestedToReplan + CurrentUserId;\r\n    const projectFeatureChannelToSubscribeInto = ChannelNames.Channel_ProjectFeature + CurrentUserId;\r\n    const userStoryArchiveChannelToSubscribeInto = ChannelNames.Channel_UserStoryArchive + CurrentUserId;\r\n    const userStoryParkChannelToSubscribeInto = ChannelNames.Channel_UserStoryPark + CurrentUserId;\r\n    const genericActivityNotificationChannelToSubscribeInto = ChannelNames.Channel_GenericActivityNotification + CurrentUserId;\r\n    const purchaseExecutionAssignedChannelToSubscribeInto = ChannelNames.Channel_GenericActivityNotification + CurrentUserId;\r\n\r\n    console.log(\"subscribing to \" + taskAssignmentChannelToSubscribeInto);\r\n    console.log(\"subscribing to \" + tastatusReportSubmissionChannelToSubscribeInto);\r\n    console.log(\"subscribing to \" + tastatusConfigAssignChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + assetsAssignedChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + projectCreatedChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + projectAccessToMemberChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + goalApprovedChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + userStoryUpdateChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + AnnouncementChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + userStoryCommentChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + sprintStartedChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + sprintReplanChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + ReminderChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + PerformanceChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + projectFeatureChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + userStoryArchiveChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + userStoryParkChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + genericActivityNotificationChannelToSubscribeInto);\r\n    console.log(\"subscribing to\" + purchaseExecutionAssignedChannelToSubscribeInto);\r\n\r\n\r\n    this.pubnub.subscribe({\r\n      channels: [taskAssignmentChannelToSubscribeInto, tastatusReportSubmissionChannelToSubscribeInto,\r\n        tastatusConfigAssignChannelToSubscribeInto, multiChartsSchedulingChannelToSubscribeInto,\r\n        assetsAssignedChannelToSubscribeInto, projectCreatedChannelToSubscribeInto, ,\r\n        projectAccessToMemberChannelToSubscribeInto, goalApprovedChannelToSubscribeInto,\r\n        userStoryUpdateChannelToSubscribeInto, AnnouncementChannelToSubscribeInto, ReminderChannelToSubscribeInto,\r\n        userStoryCommentChannelToSubscribeInto, sprintStartedChannelToSubscribeInto,\r\n        sprintReplanChannelToSubscribeInto,\r\n        PerformanceChannelToSubscribeInto,\r\n        projectFeatureChannelToSubscribeInto,\r\n        userStoryArchiveChannelToSubscribeInto,\r\n        userStoryParkChannelToSubscribeInto, genericActivityNotificationChannelToSubscribeInto,purchaseExecutionAssignedChannelToSubscribeInto]\r\n    });\r\n    var roleUpdatesChannelToSubscribeInto = ChannelNames.Channel_RoleUpdates + \"19B6F9FC-7370-4B9C-A05C-3B8D819EEEAF\";\r\n    console.log(\"subscribing to \" + roleUpdatesChannelToSubscribeInto);\r\n    this.pubnub.subscribe({\r\n      channels: [roleUpdatesChannelToSubscribeInto]\r\n    });\r\n    \r\n  }\r\n\r\n  replaceAll(str, find, replace) {\r\n    var escapedFind = find.replace(/([.*+?^=!:${}()|\\[\\]\\/\\\\])/g, \"\\\\$1\");\r\n    return str.replace(new RegExp(escapedFind, 'g'), replace);\r\n  }\r\n  ngOnInit() {\r\n    this.signalr.getNotificationsFromApi().subscribe();\r\n    this.getSoftLabels();\r\n    if (this.cookieService.check(LocalStorageProperties.DisplayWelComeNote) && this.cookieService.get(LocalStorageProperties.DisplayWelComeNote) == 'true') {\r\n      if ((localStorage.getItem(LocalStorageProperties.UserModel) != null && localStorage.getItem(LocalStorageProperties.UserModel) != undefined)\r\n      ) {\r\n        this.userFullName = JSON.parse(localStorage.getItem(LocalStorageProperties.UserModel)).fullName;\r\n      }\r\n      var count = this.cookieService.check(LocalStorageProperties.UserLoggedInCount);\r\n      if (count && this.cookieService.get(LocalStorageProperties.UserLoggedInCount) != 'null'\r\n        && this.cookieService.get(LocalStorageProperties.UserLoggedInCount) != 'undefined') {\r\n        this.loggedInCount = this.cookieService.get(LocalStorageProperties.UserLoggedInCount);\r\n        if (this.loggedInCount == '1' || this.loggedInCount == '2') {\r\n          this.displayWelcomeNote = true;\r\n          setTimeout(() => {\r\n            this.displayWelcomeNote = false;\r\n            let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n            this.cookieService.set(LocalStorageProperties.DisplayWelComeNote, 'false', null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n          }, 8000);\r\n        }\r\n      }\r\n    }\r\n    let currentCulture = this.cookieService.get(LocalStorageProperties.CurrentCulture);\r\n    const companylan = JSON.parse(this.cookieService.get(LocalStorageProperties.CompanyDetails));\r\n    let currentCulturelan = companylan.lanCode;\r\n\r\n    if (currentCulture == '' || currentCulture == null || currentCulture == undefined || currentCulture === 'null' || currentCulture === 'undefined') {\r\n      if (currentCulturelan == '' || currentCulturelan == null || currentCulturelan == undefined || currentCulturelan === 'null' || currentCulturelan === 'undefined') {\r\n        currentCulture = 'en';\r\n      }\r\n      else {\r\n        currentCulture = currentCulturelan;\r\n      }\r\n    }\r\n    this.currentLang = currentCulture;\r\n    super.ngOnInit();\r\n    this.loadingInProgress$ = this.store.pipe(select(sharedModuleReducers.isTimeSheetFetching));\r\n    this.timeSheetButtonDetails$ = this.store.pipe(select(sharedModuleReducers.getTimeShettButtonDetails));\r\n    this.timeSheetButtonDetails$\r\n      .subscribe(data => {\r\n        this.timesheetDisableorEnable = data;\r\n      })\r\n    //this.getTimeSheetButtons();\r\n    //this.getUserStore();\r\n    this.showTrailPeriod = false;\r\n    this.egretThemes = this.themeService.egretThemes;\r\n    this.layoutConf = this.layout.layoutConf;\r\n\r\n    // this.themeModel$ = this.store.pipe(select(sharedModuleReducers.getThemeModel));\r\n    //this.store.dispatch(new InitializeAfterLoginData());\r\n    var user = JSON.parse(localStorage.getItem(LocalStorageProperties.UserModel));\r\n    if (user != null) {\r\n      this.monitorCompanyrelatedDetails(user);\r\n    }\r\n    this.loggedInUserId = this.cookieService.get(LocalStorageProperties.CurrentUserId);\r\n    this.getEmployeeIdByUserId();\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    this.applicationVersion = environment.version;\r\n    this.menuType = \"Main\";\r\n    this.selectedLangName = this.availableLangs.find(x => x.code == this.currentLang).name;\r\n    this.userStoreId$ = this.store.pipe(select(sharedModuleReducers.getUserStoreId));\r\n    this.userStoreId$.subscribe(result => {\r\n      this.userStoreId = result;\r\n    })\r\n  }\r\n\r\n  showHideDeleteButton(data) {\r\n    this.showDeleteIcon = data.isDemoDataCleared ? false : data.isToShowDeleteIcon;\r\n  }\r\n\r\n  monitorCompanyrelatedDetails(user) {\r\n    this.authenticatedUserRecord = user;\r\n    this.showHideDeleteButton(user);\r\n    this.companiesList = user.companiesList;\r\n    this.getCompanyDetails(user.companyId);\r\n    var company = this.companiesList.filter(x => x.companyId.toLowerCase() == this.cookieService.get(LocalStorageProperties.CompanyId).toLowerCase())\r\n    this.selectedCompany = company ? company[0] : null;\r\n    this.selectedCompanyName = company ? company[0] ? company[0].companyName : null : null;\r\n  }\r\n\r\n  navigateToDashboards() {\r\n    const userReference = localStorage.getItem(LocalStorageProperties.UserReferenceId);\r\n    this.defaultDashboardId = this.cookieService.check(LocalStorageProperties.DefaultDashboard) ? JSON.parse(this.cookieService.get(LocalStorageProperties.DefaultDashboard)) : null;\r\n    if (this.defaultDashboardId && userReference != \"null\" && userReference != null) {\r\n      this.router.navigateByUrl(\"dashboard-management/dashboard/\" + this.defaultDashboardId + \"/form/\" + userReference);\r\n    } else if (this.defaultDashboardId) {\r\n      this.router.navigateByUrl(\"dashboard-management/dashboard/\" + this.defaultDashboardId);\r\n    }\r\n  }\r\n\r\n  isOpened(event) {\r\n    this.opened.emit(event);\r\n  }\r\n\r\n  getSoftLabels() {\r\n    this.softLabels = JSON.parse(localStorage.getItem('SoftLabels'));\r\n  }\r\n\r\n   async onSignout() {\r\n    this.reload = false;\r\n    const CurrentUserId = this.cookieService.get(LocalStorageProperties.CurrentUserId);\r\n    const taskAssignmentChannelToSubscribeInto = ChannelNames.Channel_TaskAssignments\r\n      + this.cookieService.get(LocalStorageProperties.CurrentUserId);\r\n    const tastatusReportSubmissionChannelToSubscribeInto = ChannelNames.Channel_StatusReportSubmission\r\n      + this.cookieService.get(LocalStorageProperties.CurrentUserId);\r\n    const tastatusConfigAssignChannelToSubscribeInto = ChannelNames.Channel_StatusConfigAssign\r\n      + this.cookieService.get(LocalStorageProperties.CurrentUserId);\r\n    const multiChartsSchedulingChannelToSubscribeInto = ChannelNames.Channel_MultiChartsScheduling + CurrentUserId;\r\n    const assetsAssignedChannelToSubscribeInto = ChannelNames.Channel_AssetAssignment + CurrentUserId;\r\n    const projectCreatedChannelToSubscribeInto = ChannelNames.Channel_NewProject + CurrentUserId;\r\n    const projectAccessToMemberChannelToSubscribeInto = ChannelNames.Channel_ProjectMemberRole + CurrentUserId;\r\n    const goalApprovedChannelToSubscribeInto = ChannelNames.Channel_GoalApprovedFromReplan + CurrentUserId;\r\n    const userStoryUpdateChannelToSubscribeInto = ChannelNames.Channel_UserStoryUpdateNotification + CurrentUserId;\r\n    const AnnouncementChannelToSubscribeInto = ChannelNames.Channel_AnnouncementNotification + CurrentUserId;\r\n    const userStoryCommentChannelToSubscribeInto = ChannelNames.Channel_UserStoryComment + CurrentUserId;\r\n    const sprintStartedChannelToSubscribeInto = ChannelNames.Channel_SprintStarted + CurrentUserId;\r\n    const sprintReplanChannelToSubscribeInto = ChannelNames.Channel_SprintRequestedToReplan + CurrentUserId;\r\n    const PerformanceChannelToSubscribeInto = ChannelNames.Channel_PeroformanceNotification + CurrentUserId;\r\n    const ReminderChannelToSubscribeInto = ChannelNames.Channel_ReminderNotification + CurrentUserId;\r\n    const projectFeatureChannelToSubscribeInto = ChannelNames.Channel_ProjectFeature + CurrentUserId;\r\n    const userStoryArchiveChannelToSubscribeInto = ChannelNames.Channel_UserStoryArchive + CurrentUserId;\r\n    const userStoryParkChannelToSubscribeInto = ChannelNames.Channel_UserStoryPark + CurrentUserId;\r\n    const genericActivityNotificationChannelToSubscribeInto = ChannelNames.Channel_GenericActivityNotification + CurrentUserId;\r\n    const purchaseExecutionAssignedChannelToSubscribeInto = ChannelNames.Channel_PurchaseExecutionAssignToEmployeeNotification + CurrentUserId;\r\n\r\n    this.pubnub.unsubscribe({ channels: [taskAssignmentChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [tastatusReportSubmissionChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [tastatusConfigAssignChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [multiChartsSchedulingChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [assetsAssignedChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [projectCreatedChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [projectAccessToMemberChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [goalApprovedChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [userStoryUpdateChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [AnnouncementChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [userStoryCommentChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [sprintStartedChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [sprintReplanChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [PerformanceChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [ReminderChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [projectFeatureChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [userStoryArchiveChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [userStoryParkChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [purchaseExecutionAssignedChannelToSubscribeInto] });\r\n    this.pubnub.unsubscribe({ channels: [this.loginUserchannelName] });\r\n    // var loginCompanyId = this.cookieService.get(\"CompanyId\");\r\n    // var presenceChannel = \"MessengerPresence-\" + loginCompanyId;\r\n    // this.pubnub.unsubscribe({\r\n    //   channels: [presenceChannel],\r\n    // });\r\n    // if (this.channelList != undefined || this.channelList != null) {\r\n    //   for (var index = 0; index < this.channelList.length; index++) {\r\n    //     this.pubnub.unsubscribe({\r\n    //       channels: [(loginCompanyId + '-' + this.channelList[index].id)]\r\n    //     });\r\n    //   }\r\n    // }\r\n    // this.pubnub.unsubscribe({\r\n    //   channels: [('ChannelUpdates-' + loginCompanyId)]\r\n    // });\r\n    // this.pubnub.unsubscribe({\r\n    //   channels: [('UserUpdates-' + loginCompanyId)]\r\n    // });\r\n    this.pubnub.unsubscribe({ channels: [genericActivityNotificationChannelToSubscribeInto] });\r\n    // this.pubnub.unsubscribeAll();\r\n    // this.pubnub.removeAllListeners();\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    let companyName = this.cookieService.get(LocalStorageProperties.CompanyDetails);\r\n    let companyId = this.cookieService.get(LocalStorageProperties.CompanyId);\r\n\r\n    let companyDetails = this.cookieService.get(LocalStorageProperties.CompanyDetails);\r\n    let companyTheme = this.cookieService.get(LocalStorageProperties.CompanyTheme);\r\n    let UserLoggedInCount = this.cookieService.get(LocalStorageProperties.UserLoggedInCount);\r\n    let currentCulture = this.cookieService.get(LocalStorageProperties.CurrentCulture);\r\n    this.cookieService.deleteAll(environment.cookiePath);\r\n    this.cookieService.delete(\"selectedProjectsTab\");\r\n\r\n\r\n    this.cookieService.set(LocalStorageProperties.UserLoggedInCount, UserLoggedInCount, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.CurrentCulture, currentCulture, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.CurrentUser, null, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.CurrentUserId, null, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.CompanyName, companyName, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.CompanyId, companyId, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.DefaultDashboard, null, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.CompanyDetails, companyDetails, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.CompanyTheme, companyTheme, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.SearchClick, null, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.UserModel, null, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.cookieService.set(LocalStorageProperties.EnableTeamDashboard, null, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    localStorage.setItem(LocalStorageProperties.Dashboards, null);\r\n    localStorage.setItem(LocalStorageProperties.UserReferenceId, null);\r\n    localStorage.setItem(LocalStorageProperties.RoleFeatures, null);\r\n    localStorage.removeItem(LocalStorageProperties.UserRoleFeatures);\r\n    localStorage.removeItem(LocalStorageProperties.RedirectionUrl);\r\n    localStorage.removeItem(LocalStorageProperties.SideBarMenuItems);\r\n    localStorage.removeItem(LocalStorageProperties.IntroModules);\r\n    this.cookieService.set(LocalStorageProperties.AddOrEditCustomAppIsRequired, null, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n\r\n    this.router.navigate([\"/sessions/signin\"]);\r\n    return false;\r\n  }\r\n\r\n  setLang() {\r\n    this.translate.use(this.currentLang);\r\n    console.log(this.window.location.hostname);\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    this.cookieService.set(LocalStorageProperties.CurrentCulture, this.currentLang, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.selectedLangName = this.availableLangs.find(x => x.code == this.currentLang).name;\r\n  }\r\n\r\n  changeTheme(theme) {\r\n    this.themeService.changeTheme(theme);\r\n  }\r\n\r\n  toggleNotific() {\r\n    // this.getUnreadNotifications();\r\n  }\r\n\r\n  toggleRecording() {\r\n    this.getActTrackerRecorder();\r\n    var user = JSON.parse(localStorage.getItem(LocalStorageProperties.UserModel));\r\n    if (user != null) {\r\n      this.monitorCompanyrelatedDetails(user);\r\n    }\r\n  }\r\n\r\n  getNotifications() {\r\n    const notificationSearchModel = new AppNotification();\r\n    this.store.dispatch(new ClearAllUnreadNotificationsTriggered(notificationSearchModel));\r\n    this.unreadCountOfNotifications$ = this.store.pipe(select(sharedModuleReducers.getNotificationUnreadTotal));\r\n  }\r\n\r\n  getUnreadNotifications() {\r\n    const notificationSearchModel = new AppNotification();\r\n    this.store.dispatch(new ClearUnreadNotificationsTriggered(notificationSearchModel));\r\n    this.unreadCountOfNotifications$ = this.store.pipe(select(sharedModuleReducers.getNotificationUnreadTotal));\r\n  }\r\n\r\n  getActTrackerRecorder() {\r\n    this.commonService.getActTrackerRecorder().subscribe((response: any) => {\r\n      if (response.success) {\r\n        this.isRecording = response.data;\r\n      }\r\n    });\r\n  }\r\n\r\n  clearDemoData() {\r\n    const dialogRef = this.dialog.open(ConfirmationDialogComponent, {\r\n      height: \"30%\",\r\n      width: \"30%\",\r\n      hasBackdrop: true,\r\n      direction: \"ltr\",\r\n      data: {},\r\n      disableClose: true\r\n    });\r\n    dialogRef.afterClosed().subscribe(() => {\r\n      console.log(\"The dialog was closed\");\r\n    });\r\n  }\r\n\r\n\r\n  exportConfigurationDialogData() {\r\n    const dialogRef = this.dialog.open(ExportConfigurationDialogComponent, {\r\n      height: \"45%\",\r\n      width: \"40%\",\r\n      hasBackdrop: true,\r\n      direction: \"ltr\",\r\n      data: {},\r\n      disableClose: true\r\n    });\r\n    dialogRef.afterClosed().subscribe(() => {\r\n      console.log(\"The dialog was closed\");\r\n    });\r\n  }\r\n\r\n  toggleSidenav() {\r\n    if (this.layoutConf.sidebarStyle === \"closed\") {\r\n      return this.layout.publishLayoutChange({\r\n        sidebarStyle: \"full\"\r\n      });\r\n    }\r\n    this.layout.publishLayoutChange({\r\n      sidebarStyle: \"closed\"\r\n    });\r\n    setTimeout(() => { window.dispatchEvent(new Event(\"resize\")); }, 250);\r\n  }\r\n\r\n  toggleCollapse() {\r\n    // compact --> full\r\n    if (this.layoutConf.sidebarStyle === \"compact\") {\r\n      return this.layout.publishLayoutChange(\r\n        {\r\n          sidebarStyle: \"full\"\r\n        },\r\n        { transitionClass: true }\r\n      );\r\n    }\r\n\r\n    // * --> compact\r\n    this.layout.publishLayoutChange(\r\n      {\r\n        sidebarStyle: \"compact\"\r\n      },\r\n      { transitionClass: true }\r\n    );\r\n  }\r\n\r\n  public getTimeSheetButtons() {\r\n    //this.loadingInProgress = true;\r\n    // this.commonService.getTimeSheetEnabledInformation().pipe(takeUntil(this.ngDestroyed$))\r\n    //   .subscribe((data: any) => {\r\n    //     if (data === \"\" || data === undefined) {\r\n    //       return;\r\n    //     }\r\n    //     this.timesheetDisableorEnable = JSON.parse(data);\r\n    //     this.loadingInProgress = false;\r\n    //   });\r\n    this.store.dispatch(new FetchTimeSheetButtonDetails());\r\n  }\r\n\r\n  closeFeedTimeSheet() {\r\n    this.feedTimeSheetPopover.close();\r\n    this.isFeedTimeSheet = false;\r\n  }\r\n\r\n  openTimeSheet() {\r\n    const projectDialog = this.dialog.open(FeedTimeDialogComponent, {\r\n      minWidth: '30vw',\r\n      height: '35vh',\r\n      data: !this.isFeedTimeSheet\r\n      //disableClose: true\r\n    });\r\n    projectDialog.afterClosed().subscribe(() => {\r\n      this.closeFeedTimeSheet();\r\n    });\r\n    this.getTimeSheetButtons();\r\n    // this.isFeedTimeSheet = !this.isFeedTimeSheet;\r\n  }\r\n\r\n  // getAllMenuItems() {\r\n  //   this.store.dispatch(new GetAllMenuItemsTriggered(MenuCategories.Main));\r\n  // }\r\n\r\n  changeMenuType(type) {\r\n    this.menuType = type;\r\n  }\r\n\r\n  openFeedBackDialog() {\r\n    this.isFeedBackDialog = true;\r\n  }\r\n\r\n  closeFeedBacklogDialog() {\r\n    this.isFeedBackDialog = false;\r\n    this.feedBackPopOver.close();\r\n  }\r\n\r\n  getCompanyDetails(companyId: string) {\r\n    if (this.cookieService.check(LocalStorageProperties.CompanyDetails) && this.cookieService.check(LocalStorageProperties.CompanyId)) {\r\n      this.company = JSON.parse(this.cookieService.get(LocalStorageProperties.CompanyDetails));\r\n    }\r\n    if (!this.company) {\r\n      this.commonService.getCompanyById(companyId).subscribe((response: any) => {\r\n        this.company = response.data;\r\n\r\n        if (this.company.isRemoteAccess == 1 && this.company.trailDays > 0) {\r\n          this.showTrailPeriod = true;\r\n          // this.noOfDays=this.company.noOfDays;\r\n        }\r\n        if (this.company.isDemoData == true) {\r\n          this.showDelete = true;\r\n        } else {\r\n          this.showDelete = false;\r\n        }\r\n        if (this.company.isDemoData == false || this.company.isDemoData == null) {\r\n          this.showDelete = false;\r\n        }\r\n        if (this.company != null && this.company != undefined && this.company.industryId.toUpperCase() == '7499F5E3-0EF2-4044-B840-2411B68302F9')\r\n          this.isStoreAccess = false;\r\n        else\r\n          this.isStoreAccess = true;\r\n      });\r\n    }\r\n    else {\r\n      if (this.company.isRemoteAccess == 1 && this.company.trailDays > 0) {\r\n        this.showTrailPeriod = true;\r\n        // this.noOfDays=this.company.noOfDays;\r\n      }\r\n      if (this.company.isDemoData == true) {\r\n        this.showDelete = true;\r\n      }\r\n      if (this.company.isDemoData == false || this.company.isDemoData == null) {\r\n        this.showDelete = false;\r\n      }\r\n      if (this.company != null && this.company != undefined && this.company.industryId.toUpperCase() == '7499F5E3-0EF2-4044-B840-2411B68302F9')\r\n        this.isStoreAccess = false;\r\n      else\r\n        this.isStoreAccess = true;\r\n    }\r\n  }\r\n\r\n  getUserStore() {\r\n    let storeSearchModel = new StoreSearchModel();\r\n    storeSearchModel.isArchived = false;\r\n    storeSearchModel.isDefault = true;\r\n    storeSearchModel.isCompany = false;\r\n    this.store.dispatch(new GetUserStoreIdTriggered(storeSearchModel));\r\n  }\r\n\r\n  goToUserStore() {\r\n    if (this.cookieService.get(LocalStorageProperties.CurrentUserId))\r\n      this.router.navigate([\"document/store\", this.userStoreId, this.cookieService.get(LocalStorageProperties.CurrentUserId).toLowerCase()]);\r\n  }\r\n\r\n  selectAfterlogin(e) {\r\n    this.companyId = e.companyId\r\n    this.selectedCompanyName = e.companyName;\r\n    this.selectedCompany = e;\r\n  }\r\n\r\n async selectCompany(e) {\r\n    if (this.cookieService.get(LocalStorageProperties.CompanyId).toLowerCase() != e.companyId.toString().toLowerCase()) {\r\n      this.reload = false;\r\n      console.log(e);\r\n      this.companyId = e.companyId;\r\n      this.selectedCompanyName = e.companyName;\r\n      this.selectedCompany = e;\r\n      this.loading = true;\r\n      this.searchText = null;\r\n      this.ngxService.start();\r\n      this.authService.companyLogin(this.selectedCompany).subscribe(async (userToken: any) => {\r\n        if (userToken.success) {\r\n          await this.onSignout();\r\n          let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n          this.cookieService.set(LocalStorageProperties.CurrentUser, e.authToken, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n          this.cookieService.set(LocalStorageProperties.CurrentUserId, e.userId, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n          this.cookieService.set(LocalStorageProperties.CurrentUser, userToken.data.authToken, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n          this.cookieService.set(\"DefaultDashboard\", userToken.data.defaultDashboardId ? JSON.stringify(userToken.data.defaultDashboardId.workspaceId) : null, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n          this.cookieService.set('CompanyDetails', JSON.stringify(userToken.data.companyDetails));\r\n          this.cookieService.set('CompaniesList', JSON.stringify(userToken.data.usersModel.companiesList)),\r\n          localStorage.setItem('RoleFeatures', JSON.stringify(userToken.data.roleFeatures));\r\n          localStorage.setItem(\"UserModel\", JSON.stringify(userToken.data.usersModel));\r\n          localStorage.setItem('SoftLabels', JSON.stringify(userToken.data.softLabels));\r\n          localStorage.setItem(\"CompanySettings\", JSON.stringify(userToken.data.companySettings));\r\n          localStorage.setItem(\"FromLogIn\", JSON.stringify(true));\r\n          this.cookieService.set(LocalStorageProperties.CompanyName, userToken.data.usersModel.companyName, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n          this.cookieService.set(LocalStorageProperties.CompanyId, userToken.data.usersModel.companyId, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n          //this.store.dispatch(new UserDetailsFetchedAfterCompanyLogin(userToken.data.usersModel));\r\n          this.setDafaultLanguage();\r\n        }\r\n        this.loading = false;\r\n        this.ngxService.stop();\r\n      });\r\n    }\r\n  }\r\n\r\n  setDafaultLanguage() {\r\n    const company = JSON.parse(this.cookieService.get(LocalStorageProperties.CompanyDetails));\r\n    let currentCulture = company.lanCode;\r\n    if (currentCulture == null || currentCulture == undefined || currentCulture === 'null' || currentCulture === 'undefined') {\r\n      currentCulture = 'en';\r\n    }\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    this.cookieService.set(LocalStorageProperties.CurrentCulture, currentCulture, null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n    this.currentLang = currentCulture;\r\n    this.translate.use(this.currentLang);\r\n  }\r\n\r\n\r\n  getEmployeeIdByUserId() {\r\n\r\n  }\r\n\r\n  navigateToProfile() {\r\n    this.commonService.getUserById(this.cookieService.get(LocalStorageProperties.CurrentUserId).toLowerCase()).subscribe((response: any) => {\r\n      if (response.success == true) {\r\n        this.employeeId = response.data.employeeId;\r\n        if (this.employeeId) {\r\n          this.router.navigate([\"dashboard/profile\", this.cookieService.get(LocalStorageProperties.CurrentUserId).toLowerCase(), \"overview\"]);\r\n        }\r\n        else {\r\n          this.router.navigate([\"dashboard/myProfile\", this.cookieService.get(LocalStorageProperties.CurrentUserId).toLowerCase()]);\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n\r\n\r\n  navigateToMessenger() {\r\n    this.router.navigate([\"/chat\"]);\r\n  }\r\n\r\n\r\n  navigateToStatusReport() {\r\n    const projectDialog = this.dialog.open(WorkItemsDialogComponent, {\r\n      minWidth: '82vw',\r\n      height: '82vh',\r\n      data: { dashboardFilters: this.dashboardFilters },\r\n      disableClose: true\r\n    });\r\n    projectDialog.afterClosed().subscribe(() => { });\r\n  }\r\n  navigateToSettings() {\r\n    this.router.navigate([\"/settings\"]);\r\n  }\r\n\r\n  alternateSignIn() {\r\n    this.router.navigate([\"/sessions/generic-signin\"]);\r\n  }\r\n\r\n  navigateToRoles() {\r\n    this.router.navigate([\"/rolemanagement/rolemanagement\"]);\r\n  }\r\n\r\n  navigateToUrl(workspaceId) {\r\n    const userReference = localStorage.getItem(LocalStorageProperties.UserReferenceId);\r\n    if (userReference != \"null\" && userReference != null) {\r\n      this.router.navigateByUrl(\"dashboard-management/dashboard/\" + workspaceId + \"/form/\" + userReference);\r\n    } else {\r\n      this.router.navigateByUrl(\"dashboard-management/dashboard/\" + workspaceId);\r\n    }\r\n  }\r\n\r\n  addUploadFilePopupOpen(fileUploadDropzonePopup) {\r\n    fileUploadDropzonePopup.openPopover();\r\n  }\r\n  setLabelNameForDropzone(fileName) {\r\n    return fileName.substring(0, 20) + \"...\";\r\n  }\r\n  onRemove(event) {\r\n    this.files.splice(this.files.indexOf(event), 1);\r\n    if (this.files.length > 0) {\r\n      this.filesPresent = true;\r\n    } else {\r\n      this.filesPresent = false;\r\n    }\r\n  }\r\n  removeAllFiles() {\r\n    this.filesPresent = false;\r\n    this.files = [];\r\n  }\r\n  filesSelected(event) {\r\n    this.files.push(...event.addedFiles);\r\n    if (this.files.length > 0) {\r\n      this.filesPresent = true;\r\n    }\r\n  }\r\n\r\n  closeUploadFilePopup() {\r\n    this.fileUploadDropzonePopup.forEach((p) => p.closePopover());\r\n    this.files = [];\r\n    this.fileResultModel = [];\r\n  }\r\n  saveFiles() {\r\n    this.anyOperationInProgress = true;\r\n    const formData = new FormData();\r\n    this.files.forEach((file: File) => {\r\n      this.fileIndex = this.fileIndex + 1;\r\n      const fileKeyName = \"file\" + this.fileIndex.toString();\r\n      formData.append(fileKeyName, file);\r\n    });\r\n\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    this.UploaderOnInit(environment.apiURL + ApiUrls.UploadFileChunks);\r\n  }\r\n  private UploaderOnInit(url: string): void {\r\n    let progress = 0;\r\n    const r = new Resumable({\r\n      target: url,\r\n      chunkSize: 1 * 1024 * 1024, //3 MB\r\n      query: { moduleTypeId: this.moduleTypeId },\r\n      headers: {\r\n        \"Authorization\": `Bearer ${this.cookieService.get(LocalStorageProperties.CurrentUser)}`\r\n      },\r\n    });\r\n    r.addFiles(this.files);\r\n    r.on('fileAdded', (file, event) => {\r\n      if (!this.fileResultModel || this.fileResultModel.length > 0) {\r\n        this.fileResultModel = [];\r\n        this.cdRef.detectChanges();\r\n      }\r\n      r.upload()\r\n    });\r\n    r.on('complete', (event) => {\r\n      r.files.pop();\r\n      this.progressValue = 0;\r\n      this.filesPresent = false;\r\n      this.uploadedFileNames = [];\r\n      this.fileCounter = 1;\r\n      this.fileIndex = 0;\r\n      this.anyOperationInProgress = false;\r\n    });\r\n    r.on('progress', () => {\r\n      progress = Math.round(r.progress() * 100);\r\n      this.progressValue = progress;\r\n      this.cdRef.detectChanges();\r\n    });\r\n    r.on('fileSuccess', (file, response) => {\r\n      if (file && file.fileName) {\r\n        if (!this.uploadedFileNames.find(x => x == file.fileName)) {\r\n          this.uploadedFileNames.push(file.fileName)\r\n          this.fileCounter = this.uploadedFileNames.length;\r\n\r\n          let result = JSON.parse(response);\r\n          if (result && result.length > 0) {\r\n            if (!this.fileResultModel) {\r\n              this.fileResultModel = [];\r\n            }\r\n            let fileResult = new FileResultModel();\r\n            fileResult.fileExtension = result[0].FileExtension;\r\n            fileResult.fileName = result[0].FileName;\r\n            fileResult.filePath = result[0].FilePath;\r\n            fileResult.fileSize = result[0].FileSize;\r\n            this.fileResultModel.push(fileResult);\r\n            if (result[0].FilePath != null && result[0].FilePath != \"\")\r\n              this.importDynamicJson(result[0].FilePath);\r\n            else\r\n              this.closeUploadFilePopup();\r\n          }\r\n          this.cdRef.detectChanges();\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  importDynamicJson(configuredJsonURL) {\r\n    var importConfigurationModel = new ImportConfigurationModel();\r\n    importConfigurationModel.configurationUrl = configuredJsonURL;\r\n    this.importingInProgress = true;\r\n    this.commonService.SystemImportConfiguration(importConfigurationModel).subscribe((response: any) => {\r\n      if (response.success === true) {\r\n        this.closeUploadFilePopup();\r\n        this.toastr.success(\"Data imported successfully\");\r\n      }\r\n      else {\r\n        this.toastr.error(response.apiResponseMessages[0].message);\r\n      }\r\n      this.importingInProgress = false;\r\n    });\r\n  }\r\n\r\n  closeSearch() {\r\n    this.searchText = null;\r\n  }\r\n\r\n  searchCompanies(companies, search) {\r\n    if (search == null || search == '') {\r\n      return companies;\r\n    } else if (search != null) {\r\n      search = search.toLowerCase();\r\n      search = search.trim();\r\n      const temp = companies.filter(data =>\r\n        data.companyName.toString().toLowerCase().indexOf(search) > -1\r\n      )\r\n      return temp;\r\n    }\r\n  }\r\n\r\n\r\n  ngOnDestroy() {\r\n    // this.pubnub.unsubscribe({ channels: [this.loginUserchannelName] });\r\n    // var loginCompanyId = this.cookieService.get(\"CompanyId\");\r\n    // if (this.channelList != undefined || this.channelList != null) {\r\n    //   for (var index = 0; index < this.channelList.length; index++) {\r\n    //     this.pubnub.unsubscribe({\r\n    //       channels: [(loginCompanyId + '-' + this.channelList[index].id)]\r\n    //     });\r\n    //   }\r\n    // }\r\n    //  this.pubnub.unsubscribe({\r\n    //   channels: [('ChannelUpdates-' + loginCompanyId)]\r\n    // });\r\n    // this.pubnub.unsubscribe({\r\n    //   channels: [('UserUpdates-' + loginCompanyId)]\r\n    // });\r\n    this.ngDestroyed$.next();\r\n    this.ngDestroyed$.complete();\r\n  }\r\n  onNavigateToBillingScreen() {\r\n    this.router.navigate([\"/shell/Accounts\"]);\r\n  }\r\n\r\n  onNavigateToPricingScreen() {\r\n    this.router.navigate([\"/shell/payments-plans\"]);\r\n  }\r\n  getIntroDetails() {\r\n    var intro = new IntroModel();\r\n    intro.userId = this.cookieService.get(LocalStorageProperties.CurrentUserId);\r\n    this.commonService.getIntroDetails(intro).subscribe((responseData: any) => {\r\n      if (responseData.success == false) {\r\n        this.validationMessage = responseData.apiResponseMessages[0].message;\r\n        this.anyOperationInProgress = false;\r\n        this.toastr.error(this.validationMessage);\r\n      }\r\n      else if (responseData.success == true) {\r\n        let intro = JSON.parse(localStorage.getItem(LocalStorageProperties.IntroModules));\r\n        if(!intro)\r\n        localStorage.setItem(LocalStorageProperties.IntroModules, JSON.stringify(responseData.data));\r\n      }\r\n    });\r\n  }\r\n\r\n  getTeamMembers() {\r\n    var teamMemberModel;\r\n    let environment = JSON.parse(localStorage.getItem(LocalStorageProperties.Environment));\r\n    var teamMemberModel;\r\n    teamMemberModel = {\r\n      isForTracker: true\r\n    }\r\n    teamMemberModel.isArchived = false;\r\n    this.commonService.getTeamLeadsList(teamMemberModel).subscribe((responseData: any) => {\r\n      let employeesDropDown = responseData.data;\r\n      if (employeesDropDown && employeesDropDown.length > 1) {\r\n        this.cookieService.set(LocalStorageProperties.EnableTeamDashboard, 'true', null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n      }\r\n      else {\r\n        this.cookieService.set(LocalStorageProperties.EnableTeamDashboard, 'false', null, environment.cookiePath, this.window.location.hostname, false, \"Strict\");\r\n      }\r\n    })\r\n  }\r\n}\r\n","<mat-toolbar class=\"topbar remove-padding\">\r\n    <div fxFlex>\r\n        <app-menu [reload]=\"reload\" (isOpened)=\"isOpened($event)\" (openNewDashboard)=\"navigateToUrl($event)\"></app-menu>\r\n    </div>\r\n    <div fxFlex fxLayout=\"row\" fxHide.xs fxLayoutAlign=\"center\" style=\"vertical-align: center;\">\r\n    </div>\r\n    <div fxFlex fxLayout=\"row\" fxLayoutAlign=\"end center\">\r\n        <div *ngIf=\"companiesList != null && companiesList.length > 1\" class=\"filter-data custom-box language-section\"\r\n            style=\"width:150px;\" (click)=\"$event.stopPropagation()\">\r\n            <mat-select placeholder=\"\" name=\"selectedCompany\" [(ngModel)]=\"selectedCompany\"\r\n                (selectionChange)=\"selectCompany($event.value)\">\r\n                <mat-select-trigger>\r\n                    <div *ngIf=\"selectedCompany\" fxLayout=\"row\" fxLayoutGap=\"15px\">\r\n                        <div [ngStyle]=\"{ 'margin-bottom': selectedCompany.companyMiniLogo ? '10px' : '0px' }\">\r\n                            <app-avatar [name]=\"selectedCompany.companyName | removeSpecialCharacters\"\r\n                                fxLayoutAlign=\"start center\" matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ selectedCompany.companyName }}\"\r\n                                [src]=\"selectedCompany.companyMiniLogo | fetchSizedAndCachedImage: '20':''\"\r\n                                [isRound]=\"true\" size=\"20\">\r\n                            </app-avatar>\r\n                        </div>\r\n                        <span matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{selectedCompany.companyName}}\" matTooltipShowDelay=\"400\"\r\n                            fxFlex=\"calc(100% - 40px)\" class=\"language-display\" style=\"color: black !important;\">{{ selectedCompanyName }}</span>\r\n                    </div>\r\n                </mat-select-trigger>\r\n                <div fxFlex class=\"search_goalinput ml-1\" fxLayoutAlign=\"start center\"\r\n                    style=\"position: sticky; top: 0; z-index: 1; background-color: white;\">\r\n                    <div fxLayoutAlign=\"start center\">\r\n                        <mat-form-field class=\"full-width\">\r\n                            <input class=\"search_goal\" matInput placeholder=\"{{'HRMANAGAMENT.SEARCH' | translate}}\"\r\n                                [(ngModel)]=\"searchText\" autocomplete=\"off\">\r\n                            <!-- (input)=\"search($event)\"> -->\r\n                        </mat-form-field>\r\n                    </div>\r\n                    <span class=\"close_icon masterdata-search-close\" fxLayoutAlign=\"end center\">\r\n                        <span *ngIf=\"!searchText\"></span>\r\n                        <mat-icon *ngIf=\"searchText\" class=\"icon-button mr-05 mt-05\" aria-hidden=\"false\"\r\n                            (click)=\"closeSearch()\" style=\"cursor:pointer\">\r\n                            close</mat-icon>\r\n                    </span>\r\n                </div>\r\n                <mat-option *ngFor=\"let companyList of searchCompanies(companiesList, searchText)\" [value]=\"companyList\"\r\n                matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{companyList.companyName}}\" matTooltipShowDelay=\"400\">\r\n                    <div class=\"cursor-pointer\" fxLayout=\"row\">\r\n                        <app-avatar [name]=\"companyList.companyName | removeSpecialCharacters\"\r\n                            [ngStyle]=\"{ 'margin-bottom': companyList.companyMiniLogo ? '10px' : '0px' }\"\r\n                            fxLayoutAlign=\"start center\" matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ companyList.companyName }}\"\r\n                            [src]=\"companyList.companyMiniLogo | fetchSizedAndCachedImage: '20':''\" [isRound]=\"true\"\r\n                            size=\"20\">\r\n                        </app-avatar>\r\n                        <div class=\"ml-05\">\r\n                            {{ companyList.companyName }}\r\n                        </div>\r\n                    </div>\r\n                </mat-option>\r\n            </mat-select>\r\n        </div>\r\n        <!-- <div *ngIf=\"showTrailPeriod\">\r\n            <span>{{ 'SHELL.FREETRAILEXPIRE' | translate }}<span [(ngModel)]=\"noOfDays\">{{company.trailDays}}</span>\r\n                {{ 'SHELL.DAYS' | translate }}</span>\r\n        </div> -->\r\n        <!-- <div class=\"home\">\r\n            <button mat-icon-button [style.overflow]=\"'visible'\" matTooltip=\"{{ 'SHELL.HOME' | translate}}\"\r\n                class=\"topbar-button-right\" (click)=\"changeMenuType('WorkspaceMenuItems');navigateToDashboards()\"\r\n                [ngClass]=\"(menuType == 'WorkspaceMenuItems'|| this.router.url.includes('/dashboard-management')) ? 'icon_active_class' : ''\">\r\n                <mat-icon>home</mat-icon>\r\n            </button>\r\n        </div> -->\r\n        <!-- <div class=\"home\" *ngIf=\"canAccess_feature_ViewRoles\">\r\n            <button mat-icon-button [style.overflow]=\"'visible'\" matTooltip=\"{{ 'ROLESVIEW.ROLES' | translate}}\"\r\n                class=\"topbar-button-right\" (click)=\"changeMenuType('WorkspaceMenuItems');navigateToRoles()\"\r\n                [ngClass]=\"(menuType == 'WorkspaceMenuItems'|| this.router.url.includes('/rolemanagement/rolemanagement')) ? 'icon_active_class' : ''\">\r\n                <mat-icon>brightness_high</mat-icon>\r\n            </button>\r\n        </div> -->\r\n        <div *ngIf=\"(canAccess_feature_Settings) || (canAccess_feature_ViewRoles)\">\r\n            <button matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.SETTINGS' | translate }}\" class=\"topbar-button-right theme-navbar-icon-color\" mat-icon-button\r\n                (click)=\"navigateToSettings()\"\r\n                [ngClass]=\"(this.router.url.includes('/settings')) ? 'icon_active_class' : ''\">\r\n                <mat-icon>settings</mat-icon>\r\n            </button>\r\n        </div>\r\n    <!-- <div *ngIf=\"canAccess_feature_AbilityToChat\">\r\n            <button mat-icon-button [style.overflow]=\"'visible'\" matTooltip=\"{{ 'SHELL.CHAT' | translate }}\"\r\n                class=\"topbar-button-right\" (click)=\"navigateToMessenger()\"\r\n                [ngClass]=\"(this.router.url.includes('/chat')) ? 'icon_active_class' : ''\">\r\n                <mat-icon matBadge=\"{{messagesUnreadCount}}\" [matBadgeHidden]=\"messagesUnreadCount == 0\"\r\n                    matBadgeColor=\"warn\" class=\"m-0 icon\">forum</mat-icon>\r\n            </button>\r\n        </div>  -->\r\n\r\n        <div *ngIf=\"canAccess_feature_MyProjectWork\">\r\n            <button matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.MYWORK' | translate }}\" class=\"topbar-button-right theme-navbar-icon-color\" mat-icon-button\r\n                (click)=\"navigateToStatusReport()\">\r\n                <mat-icon>assignment</mat-icon>\r\n            </button>\r\n        </div>\r\n    </div>\r\n\r\n    <div\r\n        *ngIf=\"(canAccess_feature_PunchCard) && !( timesheetDisableorEnable && timesheetDisableorEnable.TimeSheetRestricted)\">\r\n        <button mat-icon-button id=\"feedTimeSheetComponent\" [style.overflow]=\"'visible'\"\r\n        matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.LOGTIME' | translate}}\" [satPopoverAnchorFor]=\"feedTimeSheet\"\r\n            (click)=\"openTimeSheet()\" class=\"topbar-button-right theme-navbar-icon-color\">\r\n            <mat-icon>access_time</mat-icon>\r\n        </button>\r\n    </div>\r\n    <!-- Notification toggle button -->\r\n    <button mat-icon-button matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.NOTIFICATIONS' | translate}}\" (click)=\"toggleNotific()\"\r\n        [style.overflow]=\"'visible'\" *ngIf=\"newNotificationsCount != 0\" class=\"topbar-button-right theme-navbar-icon-color\"\r\n        [matMenuTriggerFor]=\"notification\">\r\n        <mat-icon>notifications</mat-icon>\r\n        <span *ngIf=\"newNotificationsCount != 0\" class=\"notification-number mat-bg-warn\">{{\r\n            newNotificationsCount }}</span>\r\n    </button>\r\n    <mat-menu #notification=\"matMenu\">\r\n        <app-notifications></app-notifications>\r\n    </mat-menu>\r\n\r\n    <!-- Top left user menu -->\r\n    <button mat-icon-button [matMenuTriggerFor]=\"accountMenu\" (click)=\"toggleRecording()\"\r\n        [ngClass]=\"this.router.url.includes('/dashboard/profile/') ? 'icon_active_class' : ''\"\r\n        class=\"topbar-button-right img-button\" *ngIf=\"authenticatedUserRecord\">\r\n        <img class=\"icon-highlight-setter\" *ngIf=\"authenticatedUserRecord.profileImage\"\r\n            [src]=\"authenticatedUserRecord.profileImage | fetchSizedAndCachedImage: '60':''\" alt=\"profile image\" />\r\n        <div *ngIf=\"!authenticatedUserRecord.profileImage\" style=\"margin-left: 4px !important;\">\r\n            <app-avatar [name]=\"authenticatedUserRecord.fullName | removeSpecialCharacters\" [isRound]=\"true\" size=\"30\">\r\n            </app-avatar>\r\n        </div>\r\n    </button>\r\n\r\n    <sat-popover #feedTimeSheet [autoFocus]=\"false\" hasBackdrop [restoreFocus]=\"false\" [interactiveClose]=\"true\"\r\n        scrollStrategy=\"reposition\" verticalAlign=\"below\" horizontalAlign=\"before\">\r\n        <app-feed-time (closeFeedTimeSheetPopup)=\"closeFeedTimeSheet()\" [isFeedTimeSheet]=\"isFeedTimeSheet\">\r\n        </app-feed-time>\r\n    </sat-popover>\r\n\r\n    <mat-menu #accountMenu=\"matMenu\">\r\n        <button mat-menu-item (click)=\"navigateToProfile()\">\r\n            <mat-icon>account_box</mat-icon>\r\n            <span>{{ 'SHELL.PROFILE' | translate}}</span>\r\n            <mat-icon class=\"activity-recorder recording-style\" *ngIf=\"isRecording\">\r\n                <!-- fiber_manual_record -->\r\n            </mat-icon>\r\n        </button>\r\n\r\n        <!-- <button mat-menu-item (click)=\"goToUserStore()\" *ngIf=\"isStoreAccess\">\r\n            <mat-icon>cloud</mat-icon>\r\n            <span>Store</span>\r\n        </button> -->\r\n        <button mat-menu-item matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.CLEARDEMODATA' | translate}}\" *ngIf=\"showDeleteIcon && showDelete\"\r\n            (click)=\"clearDemoData()\" [style.overflow]=\"'visible'\">\r\n            <mat-icon>delete</mat-icon>\r\n            <span>{{ 'SHELL.CLEARDEMODATA' | translate}}</span>\r\n        </button>\r\n        <button mat-menu-item matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.EXPORTCONFIGURATION' | translate}}\"\r\n            *ngIf=\"canAccess_feature_ManageSystemExports\" (click)=\"exportConfigurationDialogData()\"\r\n            [style.overflow]=\"'visible'\">\r\n            <mat-icon>get_app</mat-icon>\r\n            <span>{{ 'SHELL.EXPORTCONFIGURATION' | translate}}</span>\r\n        </button>\r\n        <button mat-menu-item matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.IMPORTCONFIGURATION' | translate}}\"\r\n            [satPopoverAnchorFor]=\"fileUploadDropzonePopover\" #fileUploadDropzonePopup=\"satPopoverAnchor\"\r\n            *ngIf=\"canAccess_feature_ManageSystemImports\" (click)=\"addUploadFilePopupOpen(fileUploadDropzonePopup)\">\r\n            <mat-icon>publish</mat-icon>\r\n            <span>{{ 'SHELL.IMPORTCONFIGURATION' | translate}}</span>\r\n        </button>\r\n        <!--<div class=\"filter-data custom-box language-section\" (click)=\"$event.stopPropagation()\">\r\n            <mat-select placeholder=\"\" name=\"currentLang\" [(ngModel)]=\"currentLang\" (selectionChange)=\"setLang()\">\r\n                <mat-select-trigger>\r\n                    <div fxLayout=\"row\" fxLayoutGap=\"15px\">\r\n                        <mat-icon fxFlex=\"24px\" class=\"language-icon\">language</mat-icon>\r\n                        <span fxFlex=\"calc(100% - 40px)\" class=\"language-display\">{{ selectedLangName }}</span>\r\n                    </div>\r\n                </mat-select-trigger>\r\n                <mat-option value=\"option\" *ngFor=\"let lang of availableLangs\" [value]=\"lang.code\">\r\n                    {{ lang.name }}\r\n                </mat-option>\r\n            </mat-select>\r\n        </div>-->\r\n        <button mat-menu-item (click)=\"onNavigateToBillingScreen()\" *ngIf=\"canAccess_feature_ManageAccountsAndBilling\">\r\n            <mat-icon>account_balance</mat-icon>\r\n            <span>Account & Billing</span>\r\n        </button>\r\n        <button mat-menu-item (click)=\"onNavigateToPricingScreen()\" *ngIf=\"canAccess_feature_ManageAccountsAndBilling\">\r\n            <mat-icon>account_balance_wallet</mat-icon>\r\n            <span>Pricing & Features</span>\r\n        </button>\r\n\r\n        <button *ngIf=\"canAccess_feature_AlternateSignIn\" mat-menu-item (click)=\"alternateSignIn()\"\r\n            [style.overflow]=\"'visible'\" matTooltipClass=\"tooltipClass-mat\" matTooltip=\"{{ 'SHELL.SIGNINAS' | translate}}\">\r\n            <mat-icon>how_to_reg</mat-icon>\r\n            <span>{{ 'SHELL.SIGNINAS' | translate}}</span>\r\n        </button>\r\n        <button mat-menu-item (click)=\"onSignout()\">\r\n            <mat-icon>exit_to_app</mat-icon>\r\n            <span>{{ 'SHELL.SIGNOUT' | translate}}</span>\r\n        </button>\r\n        <mat-divider></mat-divider>\r\n        <button mat-menu-item (click)=\"feedBackPopover.toggle();openFeedBackDialog()\">\r\n            <mat-icon class=\"feedback-icon\" [satPopoverAnchorFor]=\"feedBackPopover\">\r\n                sentiment_satisfied_alt\r\n            </mat-icon>\r\n            <span>v-{{applicationVersion}}</span>\r\n        </button>\r\n    </mat-menu>\r\n</mat-toolbar>\r\n<!-- <ngx-ui-loader fgsSize=\"180\" [fgsType]=\"spinnerType\" color=\"primary\"></ngx-ui-loader> -->\r\n<div *ngIf=\"loading\" class=\"k-i-loading\"></div>\r\n<sat-popover #feedBackPopover verticalAlign=\"below\" hasBackdrop backdropClass=\"backdrop-color\"\r\n    [interactiveClose]=\"false\" horizontalAlign=\"end\">\r\n    <app-submit-feedback *ngIf=\"isFeedBackDialog\" (closeDialog)=\"closeFeedBacklogDialog()\">\r\n    </app-submit-feedback>\r\n</sat-popover>\r\n\r\n<mat-menu #menu2=\"matMenu\" class=\"dialog_window\" (click)=\"$event.stopPropagation()\">\r\n    <mat-card-content class=\"p-0 m-0 listof_assets store-list-dropdown\" id=\"style-1\">\r\n        <mat-list class=\"compact-list\">\r\n            <mat-card class=\"p-0 asset-card\" *ngIf=\"(canAccess_feature_AddOrUpdateForm || canAccess_feature_ViewForms)\"\r\n                [routerLink]=\"['/applications/view-forms']\">\r\n                <span class=\"hide-content-overflow userStory-name-control store-dropdown-padding\">Forms</span>\r\n            </mat-card>\r\n            <mat-card class=\"p-0 asset-card\" *ngIf=\"canAccess_feature_AddOrUpdateApplications\"\r\n                [routerLink]=\"['/applications/custom-applications']\">\r\n                <span class=\"hide-content-overflow userStory-name-control store-dropdown-padding\">Custom\r\n                    applications</span>\r\n            </mat-card>\r\n            <mat-card *ngIf=\"canAccess_feature_ViewRoles\" class=\"p-0 asset-card\"\r\n                [routerLink]=\"['/rolemanagement/rolemanagement']\">\r\n                <span class=\"hide-content-overflow userStory-name-control store-dropdown-padding\">Role\r\n                    configuration</span>\r\n            </mat-card>\r\n            <mat-card *ngIf=\"canAccess_feature_ManageProjectRolePermissions\" class=\"p-0 asset-card\"\r\n                [routerLink]=\"['/rolemanagement/entityrolemanagement']\">\r\n                <span class=\"hide-content-overflow userStory-name-control store-dropdown-padding\">{{projectRoleText |\r\n                    softLabelsPipe : softLabels}}</span>\r\n            </mat-card>\r\n        </mat-list>\r\n    </mat-card-content>\r\n</mat-menu>\r\n\r\n<div [@fade] *ngIf=\"displayWelcomeNote && userFullName\" class=\"welcome-note\">\r\n    <span *ngIf=\"loggedInCount == 1; else elseSpan\">Welcome &nbsp; </span> <span> {{ userFullName }} </span>\r\n    <ng-template #elseSpan> Welcome back &nbsp;</ng-template>\r\n</div>\r\n<sat-popover #fileUploadDropzonePopover hasBackdrop [interactiveClose]=\"false\" backdropClass=\"testrun-popover\"\r\n    scrollStrategy=\"reposition\">\r\n    <mat-card class=\"p-0 mr-0 custom-hrm-dropzone\">\r\n        <mat-card-title>\r\n            <div class=\"card-title-text mat-bg-primary p-05\" fxLayout=\"row\">\r\n                <div fxFlex class=\"text-center\">\r\n                    {{'TESTMANAGEMENT.UPLOADFILES' | translate}}\r\n                </div>\r\n                <div fxFlex=\"20px\" fxLayoutAlign=\"end center\">\r\n                    <button class=\"inline_edit_close_btn btn\" (click)=\"closeUploadFilePopup()\">\r\n                        <fa-icon icon=\"times\"></fa-icon>\r\n                    </button>\r\n                </div>\r\n            </div>\r\n        </mat-card-title>\r\n        <div class=\"m-1\">\r\n            <div class=\"custom-dropzone dropzone-height\" ngx-dropzone (change)=\"filesSelected($event)\" accept=\".json\">\r\n                <ngx-dropzone-label>\r\n                    <span>{{'DOCUMENTMANAGEMENT.DRAGANDDROPFILESHERE' | translate}}</span>\r\n                </ngx-dropzone-label>\r\n                <ngx-dropzone-preview class=\"custom-dropzone-preview\" *ngFor=\"let f of files\" [removable]=\"true\"\r\n                    (removed)=\"onRemove(f)\">\r\n                    <ngx-dropzone-label class=\"custom-dropzone-label\" [attr.data-tip]=\"f.name\">\r\n                        {{ setLabelNameForDropzone(f.name) }}\r\n                    </ngx-dropzone-label>\r\n                </ngx-dropzone-preview>\r\n            </div>\r\n            <div class=\"m-05 text-muted\" style=\"text-align: center;\">\r\n                <span>allowed file extensions : .json</span>\r\n            </div>\r\n            <mat-progress-bar color=\"primary\" mode=\"determinate\" [value]=\"progressValue\" *ngIf=\"progressValue > 0\">\r\n            </mat-progress-bar>\r\n            <div *ngIf=\"progressValue > 0\">\r\n                {{progressValue}}% completed (Uploading {{fileCounter}} of {{files.length}} files)\r\n            </div>\r\n            <div class=\"mt-05\" fxLayoutAlign=\"center end\" *ngIf=\"filesPresent\">\r\n                <button mat-button mat-raised-button color=\"primary\" (click)=\"saveFiles()\">\r\n                    <fa-icon class=\"mr-05\" icon=\"save\"></fa-icon>{{'UPLOAD' | translate}}\r\n                </button>\r\n                <button class=\"ml-1\" mat-button mat-raised-button (click)=\"removeAllFiles();\">\r\n                    <fa-icon class=\"mr-05\" icon=\"times\"></fa-icon>{{'DOCUMENTMANAGEMENT.CLEARFILES' | translate}}\r\n                </button>\r\n            </div>\r\n            <div class=\"mt-05\" fxLayoutAlign=\"center end\" *ngIf=\"importingInProgress\">\r\n                <button class=\"ml-1\" mat-button mat-raised-button [disabled]=\"true\">\r\n                    <fa-icon class=\"mr-05\" icon=\"upload\"></fa-icon>{{'SHELL.IMPORTINGTEXT' | translate }}\r\n                    <i class=\"fa fa-spin fa-spinner\" *ngIf=\"importingInProgress\"></i>\r\n                </button>\r\n            </div>\r\n        </div>\r\n    </mat-card>\r\n</sat-popover>\r\n\r\n<style>\r\n    .file-or-folder-icon {\r\n        width: 50px;\r\n        height: 50px;\r\n        font-size: 50px;\r\n    }\r\n\r\n    .file-or-folder-name-align {\r\n        overflow: hidden;\r\n        display: -webkit-box;\r\n        -webkit-line-clamp: 2;\r\n        -webkit-box-orient: vertical;\r\n        text-align: center;\r\n        word-break: break-word;\r\n    }\r\n\r\n    .dropzone-height {\r\n        height: 130px;\r\n    }\r\n\r\n    .custom-dropzone-preview {\r\n        height: 100px !important;\r\n        min-height: 100px !important;\r\n        padding: 0px !important;\r\n    }\r\n</style>\r\n<ng-template #openAnnoucementDialogComponent let-data>\r\n    <announcement-dialog [data]=[data]></announcement-dialog>\r\n</ng-template>"]}