(function () {
    angular.module(modules.homeModule, ['ui.bootstrap', 'ui.router']);
})();;

(function () {
    'use strict';

    angular.module('handbookApp', ['angularTreeview', 'processModule', 'dashboardModule',
        'ui.bootstrap', 'ui.router', 'ngGrid', 'ui.tree',
        'placeholderShim', 'cfp.hotkeys', 'ngClipboard', 'dibari.angular-ellipsis', 'modelOptions', 'ngSanitize',
        'accountModule', 'customeDirectivesModule', 'PubSubModule', 'homeModule', 'configModule',
        'documentFieldsModule', 'tabModule', 'managementModule', 'newsListModule', 'feedbackModule',
        'advanceSearchModule', 'metadataSearchModule', 'smart-table', 'infinite-scroll', 'hearingFeedbackModule',
        'NewsCategoryModule', 'documentHearingFieldsModule', 'compareWithEarlierVersionModule', 'rwdImageMaps',
        'vs-repeat', 'documentCompareWithEarlierVersionModule', 'ui.grid', 'ui.grid.expandable', 'ui.grid.autoResize',
        'ui.grid.cellNav', 'highcharts-ng', 'ui.bootstrap.typeahead', 'checklistModule', 'annualCycleModule'
    ]).provider('workersPool', function workersPoolProvider() {
        var self = this;
        window.workersPool = {};
        window.workersPool['document-worker.js'] = new Worker('/workers/document-worker.js');
        window.workersPool['meta-data-document-worker.js'] = new Worker('/workers/meta-data-document-worker.js');
        this.$get = [function workersPoolFactory() {
            return window.workersPool;
        }];
    }).run(['$rootScope', '$location', '$state', '$http', function ($rootScope, $location, $state, $http) {

        if (window.customResources) {
            //console.log(JSON.stringify(window.resources).length);
            $.extend(true, window.resources, window.customResources);
            //console.log(JSON.stringify(window.resources).length);
        }

        $rootScope.resources = window.resources;
    }]);

    angular.module('printingApp', ['printingModule']);
})();;
(function () {
    var directivesModule = angular.module('customeDirectivesModule');

    directivesModule.directive('npDepartment', ['$document', function ($document) {
        return {
            restrict: 'E',
            controller: ['$scope', '$http', '$timeout', controller],
            controllerAs: 'vm',
            scope: {
                getDepartment: '=',
                dselected: '=',
                dselectedList: '=?',
                cssclass: '@',
                treeClass: '@',
                moduleClass: '@',
                indexControl: '=?'
            },
            templateUrl: '/app/shared/directives/department.tpl.html',
            link: function (scope, element, attr) {
                scope.isDropdownShown = false;
                scope.isSearchResultShown = false;
                $document.bind('click', function (event) {
                    var isClickedElementChildOfPopup = element
                      .find(event.target)
                      .length > 0;

                    if (isClickedElementChildOfPopup)
                        return;
                    scope.isDropdownShown = false;
                    scope.isSearchResultShown = false;
                    scope.$apply();
                });
            }
        };
    }]);

    function controller($scope, $http, $timeout) {
        var vm = this;

        vm.currentDepartmentIndex = -1;

        vm.selectDepartmentFromDropdown = selectDepartmentFromDropdown;
        vm.selectDepartmentFromSearchResult = selectDepartmentFromSearchResult;
        vm.handleExpand = handleExpand;
        vm.toggle = toggle;
        vm.clearDepartment = clearDepartment;
        vm.onDepartmentKeyup = onDepartmentKeyup;
        vm.onSearchDepartmentSelect = onSearchDepartmentSelect;
        vm.isDisabledDepartment = isDisabledDepartment;
        vm.showSearchResult = showSearchResult;
        vm.showDropdown = showDropdown;

        vm.initialize = function () {
            if ($scope.indexControl == undefined) {
                $scope.indexControl = '1';
            }
            vm.searchDepartments = [];
            $http.get('/api/Users/GetDepartments', { params: { departmentId: null } })
               .success(function (data, status, headers, config) {
                   vm.departments = data;
                   angular.forEach(vm.departments, function (department) {
                       angular.extend(department, {
                           cssClass: 'fa fa-share-alt'
                       });
                   });

                   vm.selectedParentDepartment = $scope.dselected;
                   vm.selectedDepartment = angular.copy($scope.dselected);
                   if (vm.selectedParentDepartment != null && vm.selectedParentDepartment.name.length > 0) {
                       updateDepartmentGUI();
                   }
               })
               .error(function (data, status, headers, config) {
                   vm.departments = null;
               });
        }

        function selectDepartmentFromDropdown(node) {
            if ((vm.selectedDepartment != null && node.$modelValue.id == vm.selectedDepartment.id)
                || isDisabledDepartment($scope.dselected, $scope.dselectedList, node.$modelValue)) {
                return;
            }
            $scope.getDepartment(node.$modelValue);
            $scope.isDropdownShown = false;
            vm.selectedParentDepartment = node.$modelValue;
            updateDepartmentGUI();
        }

        function selectDepartmentFromSearchResult(department) {
            if (isDisabledDepartment($scope.dselected, $scope.dselectedList, department)) {
                return;
            }
            $scope.getDepartment(department);
            $scope.isSearchResultShown = false;
            vm.selectedParentDepartment = department;
            updateDepartmentGUI();
        }

        function handleExpand(expanded, itemId, selectedNode) {
            if (expanded == true) {

                //sibling is the data which bind with the scope. So if we modify sibling, it will reflect to $scope.list
                var siblings = selectedNode.$parentNodeScope == null ? selectedNode.vm.departments : selectedNode.$parentNodeScope.$modelValue.items;
                var modelValue = selectedNode.$modelValue;
                if (modelValue.isLoaded) {
                    return;
                } else {
                    modelValue.isLoaded = true;
                }

                $http.get('/api/Users/GetDepartments', { params: { departmentId: itemId } })
                     .success(function (data, status, headers, config) {
                         if (data != null && data.length > 0) {
                             var length = siblings.length;
                             for (var i = 0; i < length; i++) {
                                 if (siblings[i].id == itemId && siblings[i].id != 0) {
                                     angular.forEach(data, function (department) {
                                         angular.extend(department, {
                                             cssClass: 'fa fa-share-alt'
                                         });
                                     });

                                     if (siblings[i].items == null) {
                                         siblings[i].items = [];
                                     }
                                     siblings[i].items = siblings[i].items.concat(data);;
                                     break;
                                 }
                             }
                         }
                     })
                    .error(function (data, status, headers, config) {
                        // TODO: log error
                    });
            }
        }

        function toggle(scope) {
            scope.toggle();
        };

        function clearDepartment() {
            $(ELEMENT_SELECTORS.DepartmentSelectionInputSelector + $scope.indexControl).val('').focus();
            $(ELEMENT_SELECTORS.DepartmentSelectionContainerSelector + $scope.indexControl).removeClass(ELEMENT_SELECTORS.DepartmentContainerClassSelector);
            $(ELEMENT_SELECTORS.DepartmentSelectionClearSelector + $scope.indexControl).hide();
            vm.selectedParentDepartment = null;
            $scope.getDepartment({
                address1: '',
                address2: '',
                address3: '',
                country: '',
                countryId: null,
                cssClass: '',
                description: '',
                email: '',
                fax: '',
                id: null,
                isCompany: false,
                name: '',
                organizationNo: '',
                parentId: null,
                path: '',
                phone: '',
                url: '',
                visitAddress1: '',
                visitAddress2: '',
                visitAddress3: ''
            });
        };

        function onDepartmentKeyup(e) {
            if ((e.which === 8 || e.which == 46)) {
                if ($(e.target).val() == '') {
                    $(ELEMENT_SELECTORS.DepartmentSelectionContainerSelector + $scope.indexControl).removeClass(ELEMENT_SELECTORS.DepartmentContainerClassSelector);
                }
            } else {
                if ($(e.target).val() != '') {
                    updateDepartmentGUI();
                }
            }

            if (vm.selectedParentDepartment) {
                getDepartmentsOnTyping(vm.selectedParentDepartment.path);
            }

            onDataNavigating(e);
        };

        function updateDepartmentGUI() {
            $timeout(function () {
                $(ELEMENT_SELECTORS.DepartmentSelectionInputSelector + $scope.indexControl).next().toggle(Boolean($(ELEMENT_SELECTORS.DepartmentSelectionInputSelector + $scope.indexControl).val()));
                $(ELEMENT_SELECTORS.DepartmentSelectionContainerSelector + $scope.indexControl).addClass(ELEMENT_SELECTORS.DepartmentContainerClassSelector);
                $(ELEMENT_SELECTORS.DepartmentSelectionInputSelector + $scope.indexControl).focus();
            }, 0, false);
        };

        function onSearchDepartmentSelect($item, $model, $label) {
            if (!isDisabledDepartment($scope.dselected, $scope.dselectedList, $item)) {
                $scope.getDepartment($item);
                vm.selectedParentDepartment = $item;
                updateDepartmentGUI();
            } else {
                clearDepartment();
            }
        };

        function isDisabledDepartment(dselected, dselectedList, department) {
            if (dselected) {
                if (department.id == dselected.id) {
                    return true;
                }
            }

            if (dselectedList) {
                for (var i = 0; i < dselectedList.length; i++) {
                    if (department.id == dselectedList[i].id) {
                        return true;
                    }
                }
            }

            return false;
        }

        function getDepartmentsOnTyping(keyword) {
            if (keyword.length >= 2) {
                $http.get(handbookRequests.SearchDepartmentsRequest, {
                    params: { 'keyword': keyword }
                })
                .then(function (response, status, headers, config) {
                    vm.searchDepartments = response.data;
                    angular.forEach(vm.searchDepartments, function (department) {
                        angular.extend(department, {
                            cssClass: 'fa fa-share-alt'
                        });
                    });
                });
            } else {
                vm.searchDepartments = [];
            }
        };

        $scope.$watch('dselected', function (newValue, oldValue) {
            if (newValue != null && newValue != oldValue) {
                vm.selectedParentDepartment = newValue;
                vm.selectedDepartment = newValue;
                updateDepartmentGUI();
            }
        });

        function showSearchResult() {
            $scope.isDropdownShown = false;
            $scope.isSearchResultShown = true;
            vm.selectedDepartment = null;
        }

        function showDropdown() {
            $scope.isSearchResultShown = false;
            $scope.isDropdownShown = true;
        }

        function onDataNavigating($event) {
            if (($event.which == 38 || $event.which == 40) && $scope.isSearchResultShown) {
                setCurrentItemInSearchResult($event.which);
            } else if ($event.which == 13 && vm.currentSearchDepartment) {
                selectDepartmentFromSearchResult(vm.currentSearchDepartment)
            }
        }

        function setCurrentItemInSearchResult(keyCode) {
            if (keyCode == 38 && vm.currentDepartmentIndex > 0) {
                vm.currentDepartmentIndex -= 1;
            }

            if (keyCode == 40 && vm.currentDepartmentIndex < vm.searchDepartments.length - 1) {
                vm.currentDepartmentIndex += 1;
            }

            if ((keyCode == 38 || keyCode == 40) && (vm.currentDepartmentIndex < vm.searchDepartments.length)) {
                vm.currentSearchDepartment = vm.searchDepartments[vm.currentDepartmentIndex];
            }
        }
    }

})();;
(function () {
    var directivesModule = angular.module('customeDirectivesModule');

    directivesModule.directive('npTreeNav', ['$document', function ($document) {
        return {
            restrict: 'E',
            controller: ['$scope', '$http', '$state', 'pubSub', '$timeout', controller],
            controllerAs: 'vm',
            scope: {
                getSelectedNode: '=',
                template: '=',
                isActiveContainerClass: '=',
                currentNode: '=',
                customCss: '@',
                treeCss: '@',
                isDisabled: '=',
                levelType: '=',
                isShowAll: '='
            },
            templateUrl: '/app/shared/treeNav/tree.tpl.html',
            link: function (scope, element, attr) {
                scope.showFolderTree = false;
                $document.bind('click', function (event) {
                    var isClickedElementChildOfPopup = element
                        .find(event.target)
                        .length > 0;

                    if (isClickedElementChildOfPopup)
                        return;
                    scope.showFolderTree = false;
                    scope.$apply();
                });
            }
        };
    }]);

    function controller($scope, $http, $state, pubSub, $timeout) {
        var vm = this;
        vm.translation = resources;
        vm.clearSelectedFolder = clearSelectedFolder;
        vm.onSearchFolderSelect = onSearchFolderSelect;
        vm.onSearchKeyup = onSearchKeyup;
        var killFolderInformation = null;
        $scope.initialize = function () {
            killFolderInformation = pubSub.subscribe('changeFolderInformation', changeFolderInformation);
            if ($scope.currentNode) {
                onSelectFolder($scope.currentNode);
            }

            $http.get('/api/Folders/GetChildren', { params: { 'Id': null, showDocumentInTree: false } })
                .success(function (data, status, headers, config) {
                    if (!Array.isArray(data))
                        return;

                    if ($scope.isShowAll) {
                        var item = { id: null, name: resources.L.Common.all, type: 0 };
                        data.splice(0, 0, item);

                        vm.selectedFolder = item;
                        onSelectFolder(vm.selectedFolder);
                    }

                    if ($scope.levelType && $scope.levelType >= 0) {
                        $scope.list = getNodesByLevelType(data, $scope.levelType);
                    } else {
                        $scope.list = data;
                    }

                    buildIcons($scope.list);

                })
                .error(function (data, status, headers, config) {
                    $scope.list = null;
                });
        }
        $scope.$on('$destroy', function () {
            killFolderInformation();
        });

        $scope.options = {
            dropped: function (event) {
                console.log('dropped');
            },
            beforeDrop: function (event) {
                console.log('beforeDrop');
            }
        };

        $scope.handleExpand = function (expanded, itemId, selectedNode) {
            if (expanded == true) {

                //sibling is the data which bind with the scope. So if we modify sibling, it will reflect to $scope.list
                var siblings = selectedNode.$parentNodeScope == null ? selectedNode.list : selectedNode.$parentNodeScope.$modelValue.items;
                var modelValue = selectedNode.$modelValue;
                modelValue.expanded = expanded;
                modelValue.class = getIconsWithReadPermission(modelValue);
                //check if type of selected node is in [1, 2, 3, 4] = [Document, LinkDocument, FileDocument, ShortcutDocument] refer to enum NodeType, we dont call request
                if (modelValue.isLoaded || modelValue.type <= 4) {
                    return;
                } else {
                    modelValue.isLoaded = true;
                }

                $http.get('/api/Folders/GetChildren', { params: { 'Id': itemId, showDocumentInTree: false } })
                    .success(function (data, status, headers, config) {
                        if (data != null && data.length > 0 && Array.isArray(data)) {
                            var length = siblings.length;
                            for (var i = 0; i < length; i++) {
                                if (siblings[i].id == itemId) {
                                    if (siblings[i].items == null) {
                                        siblings[i].items = [];
                                    }
                                    buildIcons(data);
                                    if ($scope.levelType && $scope.levelType >= 0) {
                                        data = getNodesByLevelType(data, $scope.levelType);
                                    }
                                    siblings[i].items = siblings[i].items.concat(data);;
                                    break;
                                }
                            }
                        }
                    })
                    .error(function (data, status, headers, config) {
                        // TODO: log error
                    });
            } else {
                var modelValue = selectedNode.$modelValue;
                modelValue.expanded = expanded;
                modelValue.class = getIconsWithReadPermission(modelValue);
            }
        };
        function changeFolderInformation() {
            if ($scope.currentNode) {
                onSelectFolder($scope.currentNode);
            }

            $http.get('/api/Folders/GetChildren', { params: { 'Id': null, showDocumentInTree: false } })
                .then(function (result) {
                    if (!Array.isArray(result.data))
                        return;
                    if ($scope.levelType && $scope.levelType >= 0) {
                        $scope.list = getNodesByLevelType(result.data, $scope.levelType);
                    } else {
                        $scope.list = result.data;
                    }
                    buildIcons($scope.list);
                }, function (reason) {
                    $scope.list = null;
                });
        };
        function getNodesByLevelType(nodes, levelType) {
            var list = [];
            angular.forEach(nodes, function (node) {
                if (node.levelType == levelType) {
                    list.push(node);
                }
            });

            return list;
        };
        $scope.selectNode = function (node, $event) {
            setHighlight($event);
            $scope.showFolderTree = false;
            vm.selectedFolder = node.$modelValue;
            $scope.getSelectedNode(vm.selectedFolder);
            onSelectFolder(vm.selectedFolder);
        }

        $scope.toggle = function (scope) {
            scope.toggle();
        };

        $scope.isFolderNode = function (type) {
            return type == E.nodeTypes.Folder || type == E.nodeTypes.TopFolder || type == E.nodeTypes.DepartmentFolder || type == E.nodeTypes.RegionalFolder;
        };

        function setHighlight(event) {
            $('.angular-ui-tree-handle').removeClass('selected-node');
            $('.selected-node').parent().removeClass('selected-node');
            $(event.target).parent().addClass('selected-node');
        };

        function buildIcons(list) {
            if (!Array.isArray(list)) {
                return;
            }
            var length = list.length;
            for (var i = 0; i < length; i++) {
                list[i].class = getIconsWithReadPermission(list[i]);
            }
        };

        function clearSelectedFolder() {
            $(ELEMENT_SELECTORS.FolderSelectionContainerSelector).removeClass(ELEMENT_SELECTORS.FolderContainerClassSelector);
            vm.selectedFolder = null;
            $scope.getSelectedNode(vm.selectedFolder);
        };

        function onSelectFolder(node) {
            $timeout(function () {
                $(ELEMENT_SELECTORS.FolderSelectionInputSelector).next().toggle(Boolean($(ELEMENT_SELECTORS.FolderSelectionInputSelector).val()));
                $(ELEMENT_SELECTORS.FolderSelectionContainerSelector).addClass(ELEMENT_SELECTORS.FolderContainerClassSelector);
            }, 0, false);
            setFolderSelection(node);
        };

        function setFolderSelection(node) {
            switch (node.type.toString()) {
                case E.nodeTypes.RegionalFolder:
                    angular.element(ELEMENT_SELECTORS.FolderSelectionContainerSelector).removeClass('f-enterprise')
                        .removeClass('f-normal')
                        .removeClass('f-department')
                        .addClass('f-regional visible');
                    break;
                case E.nodeTypes.Folder:
                    angular.element(ELEMENT_SELECTORS.FolderSelectionContainerSelector).removeClass('f-enterprise')
                        .removeClass('f-department')
                        .removeClass('f-regional')
                        .addClass('f-normal visible');
                    break;
                case E.nodeTypes.TopFolder:
                    angular.element(ELEMENT_SELECTORS.FolderSelectionContainerSelector).removeClass('f-normal')
                        .removeClass('f-department')
                        .removeClass('f-regional')
                        .addClass('f-enterprise visible');
                    break;
                case E.nodeTypes.DepartmentFolder:
                    angular.element(ELEMENT_SELECTORS.FolderSelectionContainerSelector).removeClass('f-enterprise')
                        .removeClass('f-normal')
                        .removeClass('f-regional')
                        .addClass('f-department visible');
                    break;
                default:
                    angular.element(ELEMENT_SELECTORS.FolderSelectionContainerSelector).addClass('f-normal visible');
            }
        };

        function onSearchFolderSelect($item, $model, $label) {
            vm.selectedFolder = $item;
            $scope.getSelectedNode(vm.selectedFolder);
            onSelectFolder($item);
        };

        function onSearchKeyup(e) {
            if ((e.which === 8 || e.which == 46)) {
                if ($(e.target).val() == '') {
                    $(ELEMENT_SELECTORS.FolderSelectionContainerSelector).removeClass(ELEMENT_SELECTORS.FolderContainerClassSelector);
                    vm.selectedFolder = null;
                }
            } else {
                if ($(e.target).val() != '') {
                    $timeout(function () {
                        $(ELEMENT_SELECTORS.FolderSelectionInputSelector).next().toggle(Boolean($(ELEMENT_SELECTORS.FolderSelectionInputSelector).val()));
                        $(ELEMENT_SELECTORS.FolderSelectionContainerSelector).addClass(ELEMENT_SELECTORS.FolderContainerClassSelector);
                    }, 0, false);
                }
            }
        };

        $scope.$watch('vm.selectedFolder.name', function (newValue, oldValue) {
            if (newValue != null && newValue.length >= 2 && newValue != oldValue) {
                $http.get('/api/Search/SearchFolders', { params: { 'keyword': newValue } })
                    .then(function (response, status, headers, config) {
                        vm.folders = response.data;
                        buildIcons(vm.folders);
                    });
            }
            if (newValue == null) {
                vm.folders = [];
            }
        });

        $scope.$watch('currentNode', function (newValue, oldValue) {
            if (newValue != null && newValue != oldValue) {
                vm.selectedFolder = newValue;
                onSelectFolder(vm.selectedFolder);
            }
        }, true);

    }

})();;

(function () {
	'use strict';

	angular.module(modules.homeModule)
		.controller(controllers.homeController, homeController);

	homeController.$inject = ['$scope', '$http', '$state', '$timeout', '$sce', '$location', '$q',
		'favoriteService', 'tabStateService', 'localStorageService', 'resizeService', 'broadcastService', 'documentService',
		'$filter', 'browserService', 'configService'];

	function homeController($scope, $http, $state, $timeout, $sce, $location, $q,
		favoriteService, tabStateService, localStorageService, resizeService, broadcastService, documentService,
		$filter, browserService, configService) {
		var vm = this;

		$scope.translation = globalResources;
		vm.enabledProcessModule = configService.getBool(HandbookConfiguration.EnableProcess);
		vm.annualCycleModuleEnable = configService.getBool(HandbookConfiguration.EnabledAnnualCycle);
		vm.readingListEnabled = configService.getBool(HandbookConfiguration.ReadingListEnabled);
		vm.hearingEnabled = configService.getBool(HandbookConfiguration.HearingEnabled);
		vm.checkHearingTab = false;

		vm.commonGridSettingKey = gridSettingKeys.commonVisibilitySettings;
		vm.readingListGridSettingKey = gridSettingKeys.readingListVisibilitySettings;
		vm.groupDocumentAnchorPrefix = prefix.groupDocumentAnchorPrefix;

		vm.loadWhatNew = loadWhatNew;
		vm.loadFavorite = loadFavorite;
		vm.loadReadingDocumentsLists = loadReadingDocumentsLists;
		vm.loadHearingDocuments = loadHearingDocuments;
		vm.hearingRowClick = hearingRowClick;
		vm.onRowClick = onRowClick;
		vm.adjustMenuPosition = adjustMenuPosition;
		vm.ajustmentNews = ajustmentNews;
		vm.goToRegisterDeviation = goToRegisterDeviation;
		vm.goToChecklist = goToChecklist;
		vm.goToAnnualCycle = goToAnnualCycle;
		vm.goToRiskModule = goToRiskModule;
		vm.viewReport = viewReport;
		vm.clickNavTab = clickNavTab;

		vm.hearingGridSetting = [];
		vm.HearingsSetting = [];
		vm.readingList = [];
		vm.allReadingDocuments = [];
		vm.processAwaitingHearings = [];
		vm.processPublicHearings = [];
		vm.aWaitingHearings = [];
		vm.publicHearings = [];
		vm.selectedTab = "";

		vm.messageWhatNew = String.format(globalResources.RecentlyApprovedDocumentsInTheHandbook, globalResources.AllFolders);

		vm.normalStartpage = HandbookConfiguration.StartpageThemeKey == E.StartpageTheme.Normal;

		vm.changeSelectedOption = changeSelectedOption;
		vm.publishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);

		var backendUrl = HandbookConfiguration.BackendURL;
		var lastChar = backendUrl.charAt(backendUrl.length - 1);
		var commonAdd = lastChar == '/' ? '' : '/';
		vm.columnNotRemove = 'name';
		vm.BROWSER_TYPE = BrowserType;
		vm.browserType = browserService.detectBrowserWindow();
		vm.periodWhatNewOptions = [
			{ id: 0, name: globalResources.Today },
			{ id: 1, name: globalResources.LastWeek },
			{ id: 2, name: globalResources.LastMonth },
			{ id: 3, name: globalResources.Last3Months }
		];

		function buildHearingsGridSetting() {
			var nameFolder = vm.enabledProcessModule ? $scope.translation.CommonGridColumns.Chapter + '/' + $scope.translation.CommonGridColumns.ProcessArea
				: $scope.translation.CommonGridColumns.Chapter;
			vm.hearingGridSetting.push({ id: 'information', name: '', width: '20px', coldefault: true });
			vm.hearingGridSetting.push({ id: 'name', name: $scope.translation.CommonGridColumns.Title, width: 50, coldefault: true });
			vm.hearingGridSetting.push({ id: 'dueDate', name: $scope.translation.HearingDueDate, width: 22, coldefault: true, customCss: 'min-width-90', type: COLUMN_DATA_TYPES.STRING_DATE });
			vm.hearingGridSetting.push({ id: 'isPublic', name: $scope.translation.Public, width: 5, coldefault: true, customCss: 'min-width-45' });
			vm.hearingGridSetting.push({ id: 'folderName', name: nameFolder, width: 26, coldefault: true });
			vm.hearingGridSetting.push({ id: 'version', name: $scope.translation.CommonGridColumns.Version, width: '90px', coldefault: true, customCss: 'align-right' });
			vm.hearingGridSetting.push({ id: 'documentId', name: $scope.translation.CommonGridColumns.DocumentId, width: '60px', coldefault: true, customCss: 'align-right' });
			vm.hearingGridSetting.push({ id: 'responsible', name: $scope.translation.CommonGridColumns.Responsible, width: 20, coldefault: true });
		}

		var url = angular.copy($location.$$url);
		url = url.toLowerCase();
		if (url.indexOf('checklist-fe') > -1) {
			triggerTabClicked('#checklist-tab', true);
			goTochecklistFromUrl(url);
		}

		
		initialize();

        if (url.indexOf('/ac/') > -1) {
            goToAnnualCycleFromUrl(url);
        }

		function initialize() {

			var storageWhatsNewPeriodAll = localStorageService.getItem("WhatsNewPeriodAll");
			vm.selectedOption = storageWhatsNewPeriodAll != null ? parseInt(storageWhatsNewPeriodAll) : parseInt(HandbookConfiguration.WhatsNewPeriodAll);

			if (vm.hearingEnabled) {
				buildHearingsGridSetting();
				vm.HearingsSetting = angular.copy(vm.hearingGridSetting);
				vm.HearingsSetting[0].name = $scope.translation.CommonGridColumns.DocumentInfo;
			}
			resizeService.resizeView();
			gridConfiguration();
			detectBrowser();
			angular.element(prefix.hashbangPrefix + 'homeTabs li').removeClass(cssClass.active);

			var mandatatoryRequests = [
				loadWhatNew(),
				loadFavorite(),
				loadReadingDocumentsLists(),
				loadHearingDocuments()
			];

			$q.all(mandatatoryRequests).then(function (response) {
				if (!vm.readingListEnabled || (!vm.allReadingDocuments.length && !vm.missingReadingDocuments.length))
					vm.selectedTab = "annual-cycle-tab";
				handleNavigate();			
				setTimeout(function () {
					setTabPanelActive();
				});
			});

			if (HandbookConfiguration.StartpageThemeKey == E.StartpageTheme.Normal) {
				tabStateService.adjustContentHeightHomeStartPageTab();
			}

			$scope.$on('annualCyclesLength', function (e, arg) {
				if (vm.annualCycleModuleEnable) {
					vm.annualCycleModuleEnable = (arg != 0);

					var url = $location.$$url;
					if (!url)
						return;
					url = url.toLowerCase();

					if (url.indexOf('tab?') == -1) {
						return;
					}

					if (url.indexOf('mypage') > -1 && url.indexOf('annualcycle') > -1 && vm.annualCycleModuleEnable) {
						setTimeout(function () {
							triggerTabClicked('#reading-list-tab', true);
							triggerTabClicked('#annual-cycle-tab', false);
						});
					}
				}
			});
		}

		$(window).on('resize', function () {
			vm.browserType = browserService.detectBrowserWindow();
		});

		function viewReport() {
			$state.go(handbookActions.MyReadingListsReport, {});
		};

		function clickNavTab(tab) {
			vm.selectedTab = tab;
		};

		function handleNavigate() {
			var url = angular.copy($location.$$url);
			if (!url)
				return;
			url = url.toLowerCase();

			if (url.indexOf('checklist-fe') > -1) {
				return;
			}

			if (url.indexOf('tab?') == -1) {
				return;
			}

			if (url.indexOf('whatsnew') > -1) {
				triggerTabClicked('#what-new-tab', true);
			} else if (url.indexOf('updatedfavorites') > -1) {
				triggerTabClicked('#favorite-tab', true);
			} else if (url.indexOf('mypage') > -1) {
				if (vm.readingListEnabled &&
					((url.indexOf('readinglist') > -1 && vm.allReadingDocuments.length)
						|| (url.indexOf('missingreadingreceipts') > -1 && vm.missingReadingDocuments.length))) {
					triggerTabClicked('#reading-list-tab', true);
				} else {
					triggerTabClicked('#master-tab', true);
				}
				if (vm.readingListEnabled && url.indexOf('readinglist') > -1
					&& vm.allReadingDocuments.length) {
					triggerTabClicked('#reading-lists-tab', false);
				}

				if (vm.readingListEnabled && url.indexOf('missingreadingreceipts') > -1
					&& vm.missingReadingDocuments.length) {
					triggerTabClicked('#missing-reading-tab', false);
				}
			} else if (url.indexOf('home') > -1) {
				triggerTabClicked('#master-tab', true);
			} else if (url.indexOf('tohearing') > -1) {
				if ((vm.aWaitingHearings.length && url.indexOf('awaitinghearing') > -1)
					|| (vm.publicHearings.length && url.indexOf('publichearings') > -1)) {
					triggerTabClicked('#hearings-tab', true);
				} else {
					triggerTabClicked('#master-tab', true);
				}
				if (vm.aWaitingHearings.length && url.indexOf('awaitinghearing') > -1) {
					triggerTabClicked('#aWaitingHearingstab', false);
				}
				if (vm.publicHearings.length && url.indexOf('publichearings') > -1) {
					triggerTabClicked('#publicHearingstab', false);
				}
			}

		}

		function triggerTabClicked(tabId, clickItSelf) {
			setTimeout(function () {
				var childTab = $(tabId + ' a');
				if (childTab) {
					$(childTab).click();
					if (clickItSelf && $(tabId)) {
						$(tabId).click();
					}
				}
			});
		}


		function changeSelectedOption() {
			localStorageService.setItem("WhatsNewPeriodAll", vm.selectedOption);
			loadWhatNew();
		}

		function ajustmentNews() {
			broadcastService('adjustmentNews', {});
		}

		function updateNewestDocuments(documents, type) {
			var storageObject = localStorageService.getItem(localStorageKeys.readDocuments);
			var readDocuments = [];
			if (storageObject != null) {
				readDocuments = JSON.parse(storageObject);
			}
			var count = 0
			if (documents != null) {
				for (var i = 0; i < documents.length; i++) {
					for (var j = 0; j < readDocuments.length; j++) {
						if (documents[i].id == readDocuments[j].id
							&& documents[i].longApprovedDate == readDocuments[j].approvedDate
							&& documents[i].isNew) {
							count += 1;
							documents[i].isNew = false;
						}
					}
				}
			}

			if (count > 0) {
				switch (type) {
					case 1: // what's new
						vm.totalWhatNew -= count;
						break;
					case 2: // updated favorite
						vm.totalNewestFavorites -= count;
						break;
				}
			}
		}

		function detectBrowser() {
			var ieVersion = msieversion();
			if (ieVersion > 0 && ieVersion < 9) {
				vm.unsupportBrowserMessage = $sce.trustAsHtml(String.format(globalResources.UnsupportedBrowser + '<a href="' + HandbookConfiguration.OldHandbookUrl + '"' + '>' + HandbookConfiguration.OldHandbookUrl + '</a>'));
				angular.element('#sidebar-wrapper').addClass('toggle-sidebar');
				angular.element('#resizeBar').addClass('toggle-sidebar');
				angular.element('#wrapper').addClass('toggle-wrapper');
				angular.element('.tabbable').addClass('toggle-mainview');
				$state.go(handbookActions.UnsupportBrowser, {});
			}
		}

		function gridConfiguration() {
			getGridSetting(vm.commonGridSettingKey);
			getColumnsDefinition(vm.commonGridSettingKey);
			vm.commonColumnsDefinition = angular.copy(optionalColumnsDenifinition);

			getGridSetting(vm.readingListGridSettingKey);
			getColumnsDefinition(vm.readingListGridSettingKey);
			vm.readingListColumnsDefinition = angular.copy(optionalColumnsDenifinition);
		}

		function loadWhatNew() {
			if (vm.enabledProcessModule) {
				return $http
					.get(handbookRequests.GetRecentlyApprovedDocumentsProcessesRequest, { params: { periodOption: vm.selectedOption } })
					.success(function (data) {
						if (data) {
							vm.whatNewData = data;
							documentService.getAgreeFilesForDocuments(vm.whatNewData);
							updateTotalWhatNew();
							updateNewestDocuments(vm.whatNewData, 1);
							updateAttachmentsForDocuments(data);
							updateAttachmentsForProcesses(data);
						}
					});
            }
			return $http.get(handbookRequests.GetRecentlyApprovedDocumentsRequest, { params: { periodOption: vm.selectedOption } })
				.success(function (data, status, headers, config) {
					vm.whatNewData = data;
                    updateAttachmentsForDocuments(data);
                    documentService.getAgreeFilesForDocuments(vm.whatNewData);
					updateTotalWhatNew();
					updateNewestDocuments(vm.whatNewData, 1);
				});
		}

		function updateTotalWhatNew() {
			vm.totalWhatNew = getNewCount(vm.whatNewData);
		}

		function loadFavorite() {
			if (vm.enabledProcessModule) {
				return $http
					.get(handbookRequests.GetProcessAndDocumentLatestFavoriteRequest)
					.success(function (data) {
						if (data) {
							vm.favoriteData = data;
							documentService.getAgreeFilesForDocuments(vm.favoriteData);
							updateTotalNewestFavorites();
							updateNewestDocuments(vm.favoriteData, 2);
							updateAttachmentsForDocuments(data);
							updateAttachmentsForProcesses(data);
						}
					});
            }
			return $http.get(handbookRequests.GetLatestFavoriteRequest).
				success(function (data, status, headers, config) {
                    vm.favoriteData = data;
                    updateAttachmentsForDocuments(data);
                    documentService.getAgreeFilesForDocuments(vm.favoriteData);
					updateTotalNewestFavorites();
                    updateNewestDocuments(vm.favoriteData, 2);
				});
		}

		function loadReadingDocumentsLists() {
			if (!vm.readingListEnabled) {
				return;
			}
			if (vm.enabledProcessModule) {
				return $http
					.get('/api/CombineDocumentAndProcess/GetReadingDocumentsAndProcessesList')
					.success(function (data) {
						if (data && data.length) {
							data.forEach(function (item) {
								if (item.confirmDate) {
									if (item.readingReceiptsExpire) {
										item.tooltipExpired = String.format(globalResources.TooltipReadingReceiptsExpired, item.confirmDate, item.readingReceiptValidity);
									} else {
										item.tooltipExpired = String.format(globalResources.TooltipReadingReceiptsNoExpired, item.confirmDate);
									}
								}
							});
							updateAttachmentsForDocuments(data);
							updateAttachmentsForProcesses(data);
						}


						(data || []).forEach(function (item) {
							//todo: compare with id instead
							var existing = vm.readingList.filter(function (d) {
								return d.readingListId == item.readingListId;
							});

							if (!existing || existing.length <= 0) {
								vm.readingList.push({
									readingListId: item.readingListId,
									readingListName: item.readingListName,
									readingReceiptValidity: item.readingReceiptValidity,
									readingReceiptsExpire: item.readingReceiptsExpire,
									readingListCreatedDate: item.readingListCreatedDate,
									readingListUpdatedDate: item.readingListUpdatedDate,
									readingListCreatedBy: item.readingListCreatedBy,
									readingListUpdatedBy: item.readingListUpdatedBy,
									readingListDescription: item.readingListDescription
								});
							}
						});
						
						vm.allReadingDocuments = decorateDocumentReadingListName(data);

						updateAttachmentsForDocuments(vm.allReadingDocuments)
						updateAttachmentsForProcesses(vm.allReadingDocuments)
						var distincDocuments = getDistinctDocuments(vm.allReadingDocuments);
						vm.documentsGroups = getDocumentGroupsByReadingListId(vm.allReadingDocuments);
						vm.missingReadingDocuments = getMissingReadingDocuments(distincDocuments);
						vm.documentsGroups.forEach(function (item) {
							item.tooltips = generateReadingListTooltip(item);
						});
					});
			}
			else {
				return $http
					.get('/api/UserDocuments/GetReadingDocumentsList')
					.success(function (data) {
						if (data && data.length) {
							data.forEach(function (item) {
								if (item.confirmDate) {
									if (item.readingReceiptsExpire) {
										item.tooltipExpired = String.format(globalResources.TooltipReadingReceiptsExpired, item.confirmDate, item.readingReceiptValidity);
									} else {
										item.tooltipExpired = String.format(globalResources.TooltipReadingReceiptsNoExpired, item.confirmDate);
									}
								}
							});
						}
					

						(data || []).forEach(function (document) {
							//todo: compare with id instead
							var existing = vm.readingList.filter(function (d) {
								return d.readingListId == document.readingListId;
							});

							if (!existing || !existing.length) {
								vm.readingList.push({
									readingListId: document.readingListId,
									readingListName: document.readingListName,
									readingReceiptValidity: document.readingReceiptValidity,
									readingReceiptsExpire: document.readingReceiptsExpire,
									readingListCreatedDate: document.readingListCreatedDate,
									readingListUpdatedDate: document.readingListUpdatedDate,
									readingListCreatedBy: document.readingListCreatedBy,
									readingListUpdatedBy: document.readingListUpdatedBy,
									readingListDescription: document.readingListDescription
								});
							}
						});
						vm.allReadingDocuments = decorateDocumentReadingListName(angular.copy(data));
						updateAttachmentsForDocuments(vm.allReadingDocuments)
						var distincDocuments = getDistinctDocuments(vm.allReadingDocuments);
						vm.documentsGroups = getDocumentGroupsByReadingListId(vm.allReadingDocuments);
						vm.missingReadingDocuments = getMissingReadingDocuments(distincDocuments);
						vm.documentsGroups.forEach(function (item) {
							item.tooltips = generateReadingListTooltip(item);
						});
					});
			}
		}

		function generateReadingListTooltip(row) {

			var groups = vm.readingList.filter(function (d) {
				return d.readingListName == row.templateName;
			});

			var group = groups[0];
			var result = "<div class='table-css'>";

			result += getElementForTooltips(globalResources.Name, group.readingListName);
			var createdDate = (group.readingListCreatedDate != null && group.readingListCreatedDate != 'null') ? group.readingListCreatedDate : '';
			var updatedDate = (group.readingListUpdatedDate != null && group.readingListUpdatedDate != 'null') ? group.readingListUpdatedDate : '';
			result += getElementForTooltips(globalResources.CreatedDate, createdDate);
			result += getElementForTooltips(globalResources.CreatedBy, group.readingListCreatedBy);
			result += getElementForTooltips(globalResources.UpdatedDate, updatedDate);
			result += getElementForTooltips(globalResources.UpdatedBy, group.readingListUpdatedBy);
			if (group.readingReceiptsExpire) {

				result += getElementForTooltips(globalResources.Validity, group.readingReceiptValidity + " " + globalResources.Months);
			}
			result += getElementForTooltips(globalResources.Description, group.readingListDescription);
			result += "    </div>";
			return result;
		}

		function loadHearingDocuments() {
			if (!vm.hearingEnabled)
				return;
			return $http.get(handbookRequests.GetHearingDocumentsRequest).
				success(function (data, status, headers, config) {
					if (data) {
						vm.aWaitingHearings = data.awaitingHearings;
						vm.publicHearings = data.publicHearings;

						vm.aWaitingHearings.forEach(function (item) {
							item.information = _buildDocumentTooltip(item);
							item.isPublic = item.isPublic ? globalResources.Yes : globalResources.No;
							item.folderName = '<img src="' + item.folderIcon + '">' + item.folderName;
						});

						vm.publicHearings.forEach(function (item) {
							item.information = _buildDocumentTooltip(item);
							item.isPublic = item.isPublic ? globalResources.Yes : globalResources.No;
							item.folderName = '<img src="' + item.folderIcon + '">' + item.folderName;
						});

						loadHearingProcesses();
					}
				});
		}

		function loadHearingProcesses() {
			getProcessAwaitingHearings();
			getProcessPublicHearings();
		}

		function getProcessAwaitingHearings() {
			$http.get(handbookRequests.GetProcessAwaitingHearing).
				success(function (data, status, headers, config) {
					if (data) {
						vm.processAwaitingHearings = data;
						combineProcessHearings(vm.aWaitingHearings, vm.processAwaitingHearings);
						setTimeout(function () {
							vm.checkHearingTab = vm.aWaitingHearings.length || vm.publicHearings.length;
                        })
					}
				});
		}

		function getProcessPublicHearings() {
			$http.get(handbookRequests.GetProcessPublicHearing).
				success(function (data, status, headers, config) {
					if (data) {
						vm.processPublicHearings = data;
						combineProcessHearings(vm.publicHearings, vm.processPublicHearings);
						setTimeout(function () {
							vm.checkHearingTab = vm.aWaitingHearings.length || vm.publicHearings.length;
						})
					}
				});
		}

		function combineProcessHearings(documents, processes) {
			if (processes) {
				processes.forEach(function (p) {
					var d = {
						agreeFiles: [],
						approvalStatus: "Hearing",
						approvedBy: p.approvedBy,
						approvedDate: p.approvedDate,
						approverResponsible: null,
						attachments: null,
						chapterLevel: 0,
						createdDate: p.createdDate,
						deleted: p.deleted,
						documentIcon: "typcn typcn-document-text",
						documentId: p.id,
						documentStatus: 3,
						draft: p.IsDraft,
						dueDate: p.dueDate,
						dueDateDisplay: null,
						entityId: p.entityId,
						expirationDate: null,
						expired: false,
						expiredDate: p.expiredDate,
						feedBackCount: 0,
						feedBackDislike: 0,
						feedBackLike: 0,
						feedBackNull: 0,
						folderIcon: "f-normal typcn typcn-folder",
						areaId: p.areaId,
						folderName: '<span class="fs18 areas-color ng-scope fa fa-folder"></span> ' + p.folderName,
						handbookId: 0,
						hasAgreeFiles: false,
						hasAttachment: false,
						id: p.id,
						internetDocument: p.internetDocument,
						isAddNewVirtual: false,
						isHearing: false,
						isPublic: p.isPublic ? 'Yes' : 'No',
						knowledgeTypeId: 0,
						lastContentEdit: "",
						location: p.location,
						metatagValue: null,
						name: p.name,
						order: p.order,
						orgiginApprovedDate: null,
						orgiginPublishedDate: p.publishedDate,
						permissions: null,
						publishedDate: p.publishedDate,
						readCount: 0,
						registerItemItemId: 0,
						responsible: p.responsible,
						responsibleId: p.responsibleId,
						template: null,
						templateId: null,
						type: 0,
						updatedDate: p.updatedDate,
						version: p.version,
						virtual: false,
						isProcess: p.isProcess
					};
					documents.push(d);
				});

				documents.sort(function (x, y) {
					var d1 = x.dueDate.toString().substr(6, 4) + x.dueDate.toString().substr(3, 2) + x.dueDate.toString().substr(0, 2);
					var d2 = y.dueDate.toString().substr(6, 4) + y.dueDate.toString().substr(3, 2) + y.dueDate.toString().substr(0, 2);
					return d1 > d2 ? -1 : (d1 == d2 ? 0 : 1);
				});	

			}
		}


		function _buildDocumentTooltip(row) {
			var tooltipData = [];
			tooltipData.push({ label: globalResources.LinkedVirtually, data: row.virtual ? globalResources.Yes : globalResources.No });
			tooltipData.push({ label: globalResources.CommonGridColumns.Title, data: row.name });
			tooltipData.push({ label: globalResources.CommonGridColumns.Type, data: row.template });
			tooltipData.push({ label: row.isProcess ? globalResources.ProcessArea: globalResources.CommonGridColumns.Chapter, data: row.folderName });
			tooltipData.push({ label: globalResources.CommonGridColumns.Location, data: row.location });
			tooltipData.push({ label: globalResources.CommonGridColumns.Version, data: row.version });
			tooltipData.push({ label: globalResources.CommonGridColumns.DocumentId, data: row.documentId });
			tooltipData.push({ label: globalResources.CommonGridColumns.ApprovedDate, data: row.approvedDate });
			if (!vm.publishedVersion) {
				tooltipData.push({ label: globalResources.CommonGridColumns.Approver, data: row.approvedBy });
				tooltipData.push({ label: globalResources.CommonGridColumns.Responsible, data: row.responsible });
            }
			return tooltipData;
		}

		function hearingRowClick(id, isProcess = false, version) {
			var linkDirect = isProcess ? urlOpenProcessHearing : urlOpenHearingFeedback;
			//redirect to hearing feedback page
			if(isProcess){
				window.open(String.format(linkDirect, String(id), String(version)));
			} else {
				window.open(String.format(linkDirect, String(id)));
			}		
		}

		function getMissingReadingDocuments(documents) {
			var missingDocuments = [];
            documentService.getAgreeFilesForDocuments(documents);

			var length = documents.length;
			for (var i = 0; i < length; i++) {
				if (!documents[i].isConfirmed) {
					missingDocuments.push(documents[i]);
				}
			}
			return missingDocuments;
		}

		function getDocumentGroupsByReadingListId(documents) {
			
			if (!vm.readingList || !vm.readingList.length) {
				return [];
			}

			if (!documents || !documents.length) {
				return [];
			}
			var documentsGroups = [];
			for (var i = 0; i < vm.readingList.length; i++) {
				var readingList = vm.readingList[i];
				var documentsOfEachReadingList = [];
				documents.forEach(function (item) {
					if (item.readingListId == readingList.readingListId) {
						documentsOfEachReadingList.push(item);
                    }
				});
				if (documentsOfEachReadingList.length) {
					documentsGroups.push({
						documents: documentsOfEachReadingList,
						templateName: readingList.readingListName,
						totalDocuments: documentsOfEachReadingList.length
					});
                }
			}
			for (var i = 0; i < documentsGroups.length; i++) {
				documentsGroups[i].documents = $filter('orderBy')(documentsGroups[i].documents, ['sort', 'name']);
			}
			return documentsGroups;
		}

		function decorateDocumentReadingListName(documents) {
			var results = [];
			for (var i = 0; i < documents.length; i++) {
				var document = documents[i];
				var existing = results.filter(function (item) {
					return item.documentId == document.documentId;
				});
				if (existing.length) {
					var existingIndex = results.indexOf(existing[0]);
					results[existingIndex].readingListName = (results[existingIndex].readingListName + ", ").concat(document.readingListName);
					document.readingListName = results[existingIndex].readingListName;
				}
				results.push(document);
            }
			return results;
        }

		function getDistinctDocuments(documents) {
			var distincDocuments = [];
			documents.forEach(function (item) {
				var existing = distincDocuments.filter(function (v, i) {
					return v.documentId == item.documentId;
				});
				if (!existing.length) {
					distincDocuments.push(item);
				}
			});
			return distincDocuments;
		}

		function getDistinctItems(items) {
			var distincItems = [];
			items.forEach(function (item) {
				var existing = distincItems.filter(function (v, i) {
					return v === item;
				});
				if (!existing.length) {
					distincItems.push(item);
				}
			});
			return distincItems;
        }

		function updateTotalNewestFavorites() {
			vm.totalNewestFavorites = getNewCount(vm.favoriteData);
		}

		function getNewCount(data) {
			var countItemNew = 0;
			(data || []).forEach(function (item) {
				if (item.isNew) {
					countItemNew += 1;
				}
			});
			return countItemNew;
		}

		function adjustContentPosition() {
			var tabState = tabStateService.getState(tabStateType.homeTabState);
			$timeout(function () {
				tabStateService.adjustContentPosition(tabState, tabStateType.homeTabState);
			}, 0, false);
		}

		function onRowClick($event) {
			favoriteService.setFavoriteNodeState({ isFavorited: false });
			documentService.goToDocument($event);
		}

		function adjustMenuPosition(toggleSidebar, tabId) {
			// Extra processing for 'Updated Favorite' and What's new tab. It depends on the sidebar toggle.
			if (tabId == homeTabs.updatedFavorite) {
				var updateFavoritePrintbox = angular.element('#' + homeContent.updatedFavoritePage + ' #print-box2');
				if (toggleSidebar == true) {
					updateFavoritePrintbox.removeClass(avoidCustomPageClass);
				} else {
					updateFavoritePrintbox.addClass(avoidCustomPageClass);
				}
			} else if (tabId == homeTabs.whatNew) {
				var whatNewPrintbox = angular.element('#' + homeContent.whatNewPage + ' #print-box2');
				if (toggleSidebar == true) {
					whatNewPrintbox.removeClass(avoidCustomPageClass);
				} else {
					whatNewPrintbox.addClass(avoidCustomPageClass);
				}
			}
		}

		function updateAttachmentsForDocuments(documents) {
			var documentIds = [];
			for (var i = 0; i < documents.length; i++) {
				if (documents[i].hasAttachment && !documents[i].isProcess) {
					documentIds.push(documents[i].id);
				}
			}
			documentIds = getDistinctItems(documentIds);
			if (documentIds.length) {
				$http
					.post('/api/Documents/GetAttachmentsForDocuments', { documentIds: documentIds })
					.success(function (data) {
						if (data && data.length) {
							data.forEach(function(x) {
								x.itemId = x.extraId ? x.extraId : x.itemId;
							});
						}
						for (var i = 0; i < documents.length; i++) {
							if (documents[i].hasAttachment && !documents[i].isProcess) {
								documents[i].attachments = [];
								for (var j = 0; j < data.length; j++) {
									if (data[j].documentId == documents[i].id) {
										documents[i].attachments.push(data[j]);
									}
								}
							}
						}
					});
			}
		}

		function updateAttachmentsForProcesses(processes) {
			if (!processes || !processes.length) {
				return null;
			}

			var processEntityIds = [];
			for (var i = 0; i < processes.length; i++) {
				if (processes[i].hasAttachment && processes[i].isProcess) {
					processEntityIds.push(processes[i].entityId);
				}
			}

			processEntityIds = getDistinctItems(processEntityIds);
			if (processEntityIds.length) {
				$http.get('/api/Processes/GetAttachmentsForProcesses', {
					params: { processEntityIds },
				})
					.success(function (data) {
						if (data && data.length) {
							data.forEach(x => {
								x.itemId = x.extraId ? x.extraId : x.itemId;
							});
						}
						for (var i = 0; i < processes.length; i++) {
							if (processes[i].hasAttachment && processes[i].isProcess) {
								processes[i].attachments = [];
								processes[i].attachmentHtml = '';
								for (var j = 0; j < data.length; j++) {
									if (data[j].processEntityId === processes[i].entityId) {
										processes[i].attachments.push(data[j]);
									}
								}
							}
						}
					});
			}

		}

		function goToRegisterDeviation() {
			window.open(HandbookConfiguration.DeviationUrl);
        }

		function goToRiskModule() {
			window.open(backendUrl + commonAdd + 'rm');
		}

		function goToChecklist() {
			var url = angular.copy($location.$$url);
			url = url.toLowerCase();
			if (url.indexOf('checklist') > -1) {
				return;
			}
			vm.linkToChecklist = $sce.trustAsResourceUrl(commonAdd + 'checklist/category/main?isHideTopbar');
		}

		function goTochecklistFromUrl(url) {
			let linkChecklist = '';
			if (url.indexOf('home') > -1 || url == 'checklist') {
				linkChecklist = 'checklist';
			} else {
				linkChecklist = url.substring(1, url.length).replace('checklist-fe', 'checklist');
			}
			//if (url.indexOf('categories') > -1) {
			//	linkChecklist = 'checklist/categories';
			//}
			//if (url.indexOf('completedchecklists') > -1) {
			//	linkChecklist = 'checklist/completedchecklists';
			//}
			//if (url.indexOf('category/main') > -1) {
			//	linkChecklist = 'checklist/category/main';
			//}

			//if (url.indexOf('adminsubcategory') > -1
			//	|| tem / add /) {
			//	linkChecklist = url.substring(1, url.length);
			//} 

			//vm.linkToChecklist = $sce.trustAsResourceUrl(backendUrl + commonAdd + linkChecklist + '?isHideTopbar');
			vm.linkToChecklist = $sce.trustAsResourceUrl('/' + linkChecklist + '?isHideTopbar');
		}

		function setTabPanelActive() {
			var tabPanel = $(".tab-pane.active");
			if (tabPanel) {
				var id = getTabId(tabPanel);
				switch (id) {
					case 'tab1':
						triggerTabClicked('#master-tab', true);
						break;
					case 'tab2':
						triggerTabClicked('#what-new-tab', true);
						break;
					case 'tab3':
						triggerTabClicked('#favorite-tab', true);
						break;
					case 'tab4':
						triggerTabClicked('#reading-list-tab', true);
						break;
					case 'tab5':
						triggerTabClicked('#hearings-tab', true);
						break;
					case 'tab6':
						triggerTabClicked('#checklist-tab', true);
						break;
					default:
				}
			}
		}

		function getTabId(arrTabPanelActive) {
			for (var i = 0; i < arrTabPanelActive.length; i++) {
				if (arrTabPanelActive[i].id.indexOf('tab') > -1)
					return arrTabPanelActive[i].id;
			}
		}

		$(window).on('resize', function () {
			// This function use to adjust the height of document content/folder content when user try to resize browser viewport.
			// TODO: If we regardless the height of document/folder when user resize browser viewport, we can remove this code.
			var currentTabState = tabStateService.getCurrentTabState();
			if (tabStateService.getCurrentStateType() == tabStateType.homeTabState) {
				if (currentTabState == null) {
					var tabState = localStorageService.getItem(tabStateType.homeTabState);
					currentTabState = tabState;
				}
				tabStateService.adjustContentPosition(currentTabState, tabStateType.homeTabState);
			}
			//Fix for safari When local storage is not enable
			if (HandbookConfiguration.StartpageThemeKey == E.StartpageTheme.Normal) {
				tabStateService.adjustContentHeightHomeStartPageTab();
			}
		});

		function goToAnnualCycle() {
            history.pushState({}, "", "/ac/home");
            activeAnnualCycleTab();
			var linkAnnualCycle = backendUrl + commonAdd + 'ac/home';
			vm.linkAnnualCycle = $sce.trustAsResourceUrl(linkAnnualCycle + '?isHideTopbar');
        }

		function goToAnnualCycleFromUrl() {
			activeAnnualCycleTab();
            var url = angular.copy($location.$$url);
			var linkAnnualCycle = backendUrl + commonAdd + url.substring(1, url.length);
			vm.linkAnnualCycle = $sce.trustAsResourceUrl(linkAnnualCycle + '?isHideTopbar');
		}

		function activeAnnualCycleTab() {
			tabStateService.setState(tabStateType.homeTabState, "annual-cycle-new-tab");
            angular.element(prefix.hashbangPrefix + "homeTabs li").removeClass(cssClass.active);
            angular.element(prefix.hashbangPrefix + "new-annual-cycle-tab").addClass(cssClass.active);
            angular.element(".tab-pane.active").removeClass(cssClass.active);
            angular.element(prefix.hashbangPrefix + "tab9").addClass(cssClass.active);
        }
    };
})();

;

(function () {
    'use strict';

    angular.module(modules.homeModule)
           .controller('annualCycleController', controller);

    controller.$inject = ['$scope', '$http'];

    function controller($scope, $http) {

        var partitionings = [
                {
                    id: 1,
                    name: globalResources.Month
                },
                {
                    id: 2,
                    name: globalResources.Quarter
                },
                {
                    id: 3,
                    name: globalResources.Tertiary
                },
                {
                    id: 4,
                    name: globalResources.SchoolYear
                }
        ];
        var vm = this;
        vm.gridSettings = [
                { id: 'name', name: globalResources.Name, width: 15, coldefault: true },
            { id: 'description', name: globalResources.Description, width: 15, coldefault: true, customCss: 'ellipsis-span' },
                { id: 'year', name: globalResources.Period, width: 10, coldefault: true },
                { id: 'partitioning', name: globalResources.Partitioning, width: 10, coldefault: true }
        ];

        vm.identifier = 'gridSettings';
        vm.colCannotRemove = 'name';
        vm.alerts = [];
        vm.annualCycles = [];

        vm.clickRow = clickRow;

        vm.searchAnnualCycle = searchAnnualCycle;

        searchAnnualCycle();

        function searchAnnualCycle(keyword) {
            return $http.get('/api/annualCycle/getPaged', {
                params: {
                    keyword: keyword,
                    pageIndex: 0,
                    pageSize: 99999
                }
            }).then(function (response) {
                vm.annualCycles = [];
                if (response.data && response.data.data) {
                    response.data.data.forEach(function (ele) {
                        ele.id = ele.annualCycleId;
                        ele.partitioning = (partitionings.find(function (x) {
                            return x.id == ele.partitioning;
                        })).name;
                        ele.year = ele.year ? ele.year : globalResources.Recurring;
                        vm.annualCycles.push(ele);
                    });
                }

                $scope.$emit('annualCyclesLength', vm.annualCycles.length);
            });
        }

        function clickRow(id) {
            window.open('/annualCycle/' + id, "_blank");
        }

    }
})();

;

(function () {
    'use strict';

    angular.module(modules.homeModule)
        .controller('annualCycleDetailController', controller)
        .filter('activitiesByMonthFilter', activitiesByMonthFilter)
        .filter('activitiesBySchoolYearMonthFilter', activitiesBySchoolYearMonthFilter);

    controller.$inject = ['$rootScope', '$scope', '$http', '$stateParams', 'uiGridConstants', '$state'];
    function controller($rootScope, $scope, $http, $stateParams, uiGridConstants, $state) {
        $scope.translation = globalResources;
        var yearRange = 11;

        var vm = this;
        vm.activities = [];
        vm.periods = getPeriods(yearRange);
        vm.periodsForSchoolYear = getPeriodsForSchoolYear(yearRange);

        vm.model = {
            name: '',
            description: '',
            viewType: -1,
            partitioning: 1
        };

        vm.monthViews = [];
        vm.schoolYearMonthViews = [];
        vm.cycleMonths = [];
        vm.cycleSchoolMonths = [];
        vm.activityTasks = [];
        vm.listActivitiesInView = [];
        vm.isExpandAll = false;

        vm.changeView = changeView;
        vm.resolveColor = resolveColor;
        vm.resolveSchoolYearColor = resolveSchoolYearColor;
        vm.scrollToThisMonth = scrollToThisMonth;
        vm.print = print;
        vm.close = close;
        vm.expandActivityRow = expandActivityRow;
        vm.expandAllTasksInActivity = expandAllTasksInActivity;
        vm.expandAllItems = expandAllItems;
        vm.initListActivitiesGrid = initListActivitiesGrid;
        vm.getActivityDetailUrl = getActivityDetailUrl;
        vm.getTaskDetailUrl = getTaskDetailUrl;
        vm.alerts = [];
        vm.canExpandAll = true;
        
        init();

        function close() {
            window.close();
        }

        function print() {
            window.open(String.format('/Printing/PrintAnnualCycleDetail?annualCycleId={0}&viewType={1}&period={2}', vm.model.annualCycleId, vm.model.viewType, vm.model.period));
        }

        function scrollToThisMonth(month) {

        }

        function resolveColor(month, partitioning) {
            if (partitioning == 1)
                return 'color-blue';
            else if (partitioning == 2) {
                if (month >= 1 && month < 4)
                    return 'color-blue';
                else if (month >= 4 && month < 7)
                    return 'color-green';
                else if (month >= 7 && month < 10)
                    return 'color-orange';
                else
                    return 'color-purple';
            }
            else if (partitioning == 3) {
                if (month >= 1 && month < 5)
                    return 'color-blue';
                else if (month >= 5 && month < 9)
                    return 'color-green';
                else
                    return 'color-orange';
            }
        }

        function resolveSchoolYearColor(month, partitioning) {
            if (partitioning == 1)
                return 'color-blue';
            else if (partitioning == 2) {
                if (month == 9 || month == 10 || month == 11)
                    return 'color-blue';
                else if (month == 12 || month == 1 || month == 2)
                    return 'color-green';
                else if (month == 3 || month == 4 || month == 5)
                    return 'color-orange';
                else
                    return 'color-purple';
            }
            else if (partitioning == 3) {
                if (month == 9 || month == 10 || month == 11 || month == 12)
                    return 'color-blue';
                else if (month == 1 || month == 2 || month == 3 || month == 4)
                    return 'color-green';
                else
                    return 'color-orange';
            }
            else if (partitioning == 4) {
                if (month == 8 || month == 9 || month == 10 || month == 11 || month == 12)
                    return 'color-blue';
                else if (month == 1 || month == 2 || month == 3 || month == 4 || month == 5)
                    return 'color-green';
                else
                    return 'color-orange';
            }
        }

        function changeView() {
            if (vm.model.viewType == 0) {
                vm.model.viewType = 1;
            }
            else if (vm.model.viewType == 1) {
                vm.model.viewType = 0;
            }
		}

		var getDaysInMonth = function (month, year) {
			return new Date(year, month, 0).getDate();
		};


        function init() {
            $http.get('/api/annualCycle/getAnnualCycle/' + $stateParams.id).then(function (response) {
                if (!response.data) {
                    return;
                }

                var data = response.data;
                vm.model.annualCycleId = data.annualCycleId;
                vm.model.name = data.name;
                vm.model.description = data.description;
                vm.model.partitioning = data.partitioning;
                vm.model.viewType = data.viewType;
                vm.model.isSchoolYear = data.isSchoolYear;
                vm.model.period = data.year;

                if (vm.model.period) {
                    vm.isDisablePeriod = true;
                    vm.model.period = parseInt(vm.model.period);
                } else {
                    vm.model.period = (new Date()).getFullYear();
                }

				var activities = [];
				if (data.activities.length) {
					data.activities.forEach(function (activity) {
                        var sDate = new Date(activity.startDate);
                        var eDate = new Date(activity.endDate);
                        var sDate_Date = sDate.getDate();
                        var sDate_Month = sDate.getMonth();
                        var sDate_Year = sDate.getFullYear();
                        var eDate_Date = eDate.getDate();
                        var eDate_Month = eDate.getMonth();
                        var eDate_Year = eDate.getFullYear();
                        activity.startYear = sDate_Year;
                        activity.tooltip = '';

                        if (activity.description) {
                            activity.tooltip = '<div><label class"tool-tip-label">' + globalResources.Description + ':</label><div>' + activity.description + '</div></div>';
                        }

                        if (activity.responsibleNames) {
                            activity.tooltip = activity.tooltip + (activity.description ? '<br />' : '') + '<div><label class"tool-tip-label">' + globalResources.Responsible + ':</label><div>' + activity.responsibleNames + '</div></div>';
                        }

                        activity.isStartAndEndInTheSameMonth = (sDate_Month == eDate_Month) && (sDate_Year == eDate_Year);
						activity.isStartAndEndInTheSameDay = (sDate_Date == eDate_Date) && (sDate_Month == eDate_Month) && (sDate_Year == eDate_Year);
						if (activity.activityDocuments && activity.activityDocuments.length > 0) {
							activity.tooltipDocuments = getTooltipDocuments(activity.activityDocuments);
                        }

                        activity.percentageTasksCompleted = Math.round(activity.numberTasksDone / activity.numberTotalTasks * 100);

						if ((sDate_Month != eDate_Month) || (sDate_Year != eDate_Year)) {
							var numberLoop = (eDate_Year != sDate_Year) ? Math.abs((12 - sDate_Month + eDate_Month + 1) + 12 * (eDate_Year - sDate_Year - 1))
								: eDate_Month - sDate_Month + 1;
							var year = sDate_Year;
							var month = sDate_Month;//Month start from index 0
							for (var i = 0; i < numberLoop; i++) {
								var activityTemp = angular.copy(activity);
								if (month > 11) {
									month = month - 12;
									year = year + 1;
								}
								if (month == sDate_Month && year == sDate_Year) {
									var day = getDaysInMonth(month + 1, year);
									activityTemp.endDate = new Date(year, month, day);
									activityTemp.isStartAndEndInTheSameDay = (sDate_Date == day);
								} else if (month == eDate_Month && year == eDate_Year) {
									activityTemp.startDate = new Date(year, month, 1);
									activityTemp.isStartAndEndInTheSameDay = (eDate_Date == 1);
								} else {
									var day = getDaysInMonth(month + 1, year);
									activityTemp.startDate = new Date(year, month, 1);
									activityTemp.endDate = new Date(year, month, day);
								}
								activityTemp.isStartAndEndInTheSameMonth = true;
								activities.push(activityTemp);

								month = month + 1;
							}
						} else {
							activities.push(activity);
						}

                    });
                }

				vm.activities = activities;

                vm.readingListReaders = data.readers;
                vm.readingListExclusions = data.exclusions;
                //updateReadingListReaderTypes(vm.readingListReaders);

                $rootScope.title += ' : ' + vm.model.name;
                $rootScope.description = vm.model.description;

                getAccessibleActivitiTasks();

                initCycleMonths();
            })
            .catch(err => {
                vm.alerts.unshift({ type: 'danger', message: globalResources.NotExistOrNoPermission });
            });
        }

        function getAccessibleActivitiTasks() {
            $http.get('/api/Activity/GetAccessibleActivityTasksInAnnualCycle?annualCycleId=' + $stateParams.id)
                .success(function (data) {
                    if (data) {
                        vm.activityTasks = (data || []).map(x => {
                            if (!x.responsibleId) {
                                x.responsibleName = globalResources.AllActivityResponsibles;
                            }
                            if (x.responsibleId == -1) {
                                x.responsibleName = globalResources.ActivityResponsible;
                            }
                            x.descriptionDisplay = x.description ? x.description.replace(/\n/g, "<br />") : '';
                            x.statusDisplay = generateStatusText(x.status);
                            x.tooltipAttachmnents = getTooltipTaskAttachments(x.activityAttachments, x.activityTaskDocuments);
                            return x;
                        });
                        initListView();

                    }
                });
        }

        function getTooltipTaskAttachments(activityAttachments, activityTaskDocuments) {
            var tooltip = '';
            if (activityAttachments.length > 0) {
                tooltip += '<div class="white task-attachment-tooltip-title">';
                tooltip += globalResources.Attachments;
                tooltip += '</div>';
                tooltip += '<div class="pt15 margin-bottom-20">';
                for (var i = 0; i < activityAttachments.length; i++) {
                    tooltip += '<div class="mt5">';
                    tooltip += '<a href="api/File/GetActivityTaskAttachment?id=' + activityAttachments[i].activityAttachmentId + '" target="_blank" style="color: #fff !important;">' + activityAttachments[i].title + '</a>';
                    tooltip += '</div>';
                }
                tooltip += '</div>';
            }

            if (activityTaskDocuments.length > 0) {
                tooltip += '<div class="white task-attachment-tooltip-title">';
                tooltip += globalResources.Documents;
                tooltip += '</div>';
                tooltip += '<div class="pt15">';
                for (var i = 0; i < activityTaskDocuments.length; i++) {
                    tooltip += '<div class="mt5">';
                    tooltip += '<a href="document/' + activityTaskDocuments[i].documentId + '" target="_blank" style="color: #fff !important;">' + activityTaskDocuments[i].documentName + '</a>';
                    tooltip += '</div>';
                }
                tooltip += '</div>';
            }

            return tooltip;
        }

		function getTooltipDocuments(activityDocuments) {
			var result = "<div class='attachment-tooltip'>";

			for (var i = 0; i < activityDocuments.length; i++) {
				result += "    <div class='item'>";
				result += "        <a href='/document/" + activityDocuments[i].documentId + "' target='_blank' style='color:white !important;'>" + activityDocuments[i].documentName + "</a>";
				result += "    </div>";
			}
			result += "</div>"
			return result;
		}

        function initListView() {
            if (!vm.model.isSchoolYear) {
                vm.monthViews.push({ id: 1, name: globalResources.January });
                vm.monthViews.push({ id: 2, name: globalResources.February });
                vm.monthViews.push({ id: 3, name: globalResources.March });
                vm.monthViews.push({ id: 4, name: globalResources.April });
                vm.monthViews.push({ id: 5, name: globalResources.May });
                vm.monthViews.push({ id: 6, name: globalResources.June });
                vm.monthViews.push({ id: 7, name: globalResources.July });
                vm.monthViews.push({ id: 8, name: globalResources.August });
                vm.monthViews.push({ id: 9, name: globalResources.September });
                vm.monthViews.push({ id: 10, name: globalResources.October });
                vm.monthViews.push({ id: 11, name: globalResources.November });
                vm.monthViews.push({ id: 12, name: globalResources.December });
                initListActivitiesGrid(vm.monthViews);
            }
            else {
                vm.schoolYearMonthViews.push({ id: 8, name: globalResources.August });
                vm.schoolYearMonthViews.push({ id: 9, name: globalResources.September });
                vm.schoolYearMonthViews.push({ id: 10, name: globalResources.October });
                vm.schoolYearMonthViews.push({ id: 11, name: globalResources.November });
                vm.schoolYearMonthViews.push({ id: 12, name: globalResources.December });
                vm.schoolYearMonthViews.push({ id: 1, name: globalResources.January });
                vm.schoolYearMonthViews.push({ id: 2, name: globalResources.February });
                vm.schoolYearMonthViews.push({ id: 3, name: globalResources.March });
                vm.schoolYearMonthViews.push({ id: 4, name: globalResources.April });
                vm.schoolYearMonthViews.push({ id: 5, name: globalResources.May });
                vm.schoolYearMonthViews.push({ id: 6, name: globalResources.June });
                vm.schoolYearMonthViews.push({ id: 7, name: globalResources.July });
                initListActivitiesGrid(vm.schoolYearMonthViews, true);
            }
        }

        function initListActivitiesGrid(monthViews, isSchoolYear = false) {
            vm.listActivitiesInView = [];
            monthViews.forEach(item => {
                item.isExpandAllTasks = false;
                item.activitiesGrid = {
                    expandableRowTemplate: '/app/components/annualCycle/templates/annualCycleDetail.activityTasksRowTemplate.html',
                    showExpandAllButton: false,
                    enableExpandableRowHeader: false,
                    enableOnDblClickExpand: false,
                    expandableRowHeight: 'auto',
                    columnDefs: [
                        {
                            field: 'startDate', displayName: item.name,
                            enableSorting: false,
                            width: '10%',
                            cellTemplate: `
									<div style="padding-left: 15px;">
										{{row.entity.startDate | date : 'dd'}}
										<span ng-if="row.entity.isStartAndEndInTheSameMonth && !row.entity.isStartAndEndInTheSameDay">-{{row.entity.endDate | date : 'dd'}}</span>
									</div>
									`
                        },
                        {
                            field: 'name', displayName: globalResources.Activity,
                            width: '17%',
                            cellTemplate: `
									<div class="ui-grid-cell-contents font-bold">
                                        <a class="hover-as-link text-black" ng-href="{{grid.appScope.vm.getActivityDetailUrl(row.entity.activityId)}}" target="_self">{{row.entity.name}}</a>
									</div>
									`
                        },
                        { field: 'description', displayName: globalResources.Description },
                        {
                            field: 'responsibleName', displayName: globalResources.Responsible,
                            width: '10%',
                            cellTemplate: `
								<div class="ui-grid-cell-contents">
									<div>
										{{row.entity.responsibleName}}
									</div>
									<div class="fs11 dialog-inform-cl margin-bottom-10">
										{{grid.appScope.translation.ActivityResponsible}}
									</div>
								</div>
							`
                        },
                        {
                            field: 'responsibleNames', displayName: '',
                            width: '10%',
                            cellTemplate: `
							<div class="ui-grid-cell-contents">
								<div>
									{{row.entity.responsibleNames}}
								</div>
								<div ng-if="row.entity.responsibleNames" class="fs11 dialog-inform-cl margin-bottom-10">
									{{grid.appScope.translation.MainResponsible}}
								</div>
							</div>
							`
                        },
                        {
                            field: 'status', displayName: 'Status',
                            width: '10%',
                            enableSorting: false,
                            cellTemplate: `
								<div class="ui-grid-cell-contents">
									<div class="progress">
										<div class="progress-bar bg-img-none" role="progressbar" aria-valuenow="60" aria-valuemin="0"
											 ng-class="{'progress-bar-bg-danger': row.entity.percentageTasksCompleted == 0,
														'progress-bar-bg-success': row.entity.percentageTasksCompleted == 100,
														'progress-bar-bg-warning': row.entity.percentageTasksCompleted > 0 && row.entity.percentageTasksCompleted < 100 }"
											 aria-valuemax="100" style="width: {{row.entity.percentageTasksCompleted != 0 ? row.entity.percentageTasksCompleted : 100}}%; background-image: none;">
										</div>
									</div>
									<div>
										{{row.entity.numberTasksDone}}/{{row.entity.numberTotalTasks}}
									</div>
								</div>
									`
                        },
                        {
                            field: 'document', displayName: '',
                            width: '45',
                            enableSorting: false,
                            cellTemplate: `<div class="text-align-center">
										<a ng-if="row.entity.tooltipDocuments" href=""
                                           class="far fa-copy fs22"
                                           style="color: #666666; font-size: 22px;"
                                           uib-popover-html="row.entity.tooltipDocuments"
                                           popover-title="{{grid.appScope.translation.Documents}}"
                                           popover-trigger="'outsideClick'"
                                           popover-append-to-body="true"
                                           popover-placement="left"></a>
										</div>`
                        },
                        {
                            field: 'expand', displayName: '', width: '45', enableSorting: false,
                            headerCellTemplate:
                                `<div class="expand-measure pt10">
									<span ng-if="grid.appScope.$parent.month.hasTasks"
                                        ng-click="grid.appScope.vm.expandAllTasksInActivity(grid.appScope.$parent.month, grid);" class="pointer">
										<i class="tc-white" ng-class="{'fa fa-angle-down': !grid.appScope.$parent.month.isExpandAllTasks, 'fa fa-angle-up': grid.appScope.$parent.month.isExpandAllTasks }"></i>
									</span>
								</div>`,
                            cellTemplate: `<div class="expand-measure" ng-if="row.entity.numberTotalTasks > 0">
							<span class="pointer"
								  ng-click="grid.appScope.vm.expandActivityRow(row.entity, grid, grid.appScope.$parent.month)">
								<i class="fa fa-angle-down" ng-if="!row.isExpanded"></i>
								<i class="fa fa-angle-up" ng-if="row.isExpanded"></i>
							</span>
                        </div>`
                        }
                    ],
                    enableColumnMenus: false,
                    onRegisterApi: function (gridApi) {
                        vm.gridApi = gridApi;
                    }
                };
                item.activitiesGrid.onRegisterApi = function (gridApi) {
                    item.gridApi = gridApi;
                };
                item.activitiesGrid.data = isSchoolYear ? filterActivitiesBySchoolYearMonth(vm.activities, item.id, vm.model.period) : filterActivitiesByMonth(vm.activities, item.id, vm.model.period);
                item.activitiesGrid.enableHorizontalScrollbar = uiGridConstants.scrollbars.NEVER;
                item.activitiesGrid.enableVerticalScrollbar = uiGridConstants.scrollbars.NEVER;
                if (item.activitiesGrid.data.length > 0) {
                    if (item.activitiesGrid.data.some(activity => activity.numberTotalTasks > 0)) {
                        item.hasTasks = true;
                    }
                    vm.listActivitiesInView = angular.copy(vm.listActivitiesInView).concat(item.activitiesGrid.data);
                }
                item.activitiesGrid.data.forEach(activity => {
                    initActivityTasksGrid(activity);
                });
            });
            if (!vm.listActivitiesInView.some(item => item.numberTotalTasks > 0)) {
                vm.canExpandAll = false;
                if (vm.listActivitiesInView.length > 0) {
                    monthViews.forEach(item => {
                        var statusCol = item.activitiesGrid.columnDefs.find(col => col.field === 'status');
                        if (statusCol) {
                            statusCol.visible = false;
                        }
                    });
                }
            }
            else {
                vm.canExpandAll = true;
            }
        }

        function expandActivityRow(entity, grid, monthViewItem) {
            grid.api.expandable.toggleRowExpansion(entity);
            monthViewItem.isExpandAllTasks = monthViewItem.gridApi.grid.rows.every(item => item.isExpanded == true);
        }

        function expandAllTasksInActivity(monthViewItem, grid) {
            monthViewItem.isExpandAllTasks = !monthViewItem.isExpandAllTasks;

            monthViewItem.gridApi.grid.rows.forEach(row => {
                if (row.isExpanded != monthViewItem.isExpandAllTasks) {
                    grid.api.expandable.toggleRowExpansion(row.entity);
                }
            });
        }
            
        function expandAllItems(listMonthViews) {
            vm.isExpandAll = !vm.isExpandAll;
            listMonthViews.forEach(monthViewItem => {
                if (monthViewItem.activitiesGrid.data.length > 0 && monthViewItem.isExpandAllTasks != vm.isExpandAll) {
                    monthViewItem.isExpandAllTasks = !monthViewItem.isExpandAllTasks;
                    if (vm.isExpandAll) {
                        monthViewItem.gridApi.expandable.expandAllRows();
                    }
                    else {
                       monthViewItem.gridApi.expandable.collapseAllRows();
                    }
                }
            });
        }

        function initActivityTasksGrid(activity) {
            activity.subGridOptions = {
                showHeader: false,
                columnDefs: [
                    {
                        field: 'startDate',
                        enableSorting: false,
                        width: '10%',
                        cellTemplate: `
									<div style="padding-left: 15px;">
										{{row.entity.endDateDisplay}}
									</div>
									`

                    },
                    {
                        field: 'name',
                        width: '17%',
                        cellTemplate: `
									<div class="ui-grid-cell-contents font-bold">
										<a class="hover-as-link text-black" ng-href="{{grid.options.expandableRowScope.getTaskDetailUrl(row.entity.activityTaskId)}}" target="_self">{{row.entity.name}}</a>
									</div>
									`
                    },
                    {
                        field: 'description'
                    },
                    {
                        field: 'responsibleName',
                        width: '10%',
                        cellTemplate: `
						<div class="ui-grid-cell-contents">
							<div>
								{{row.entity.responsibleName}}
							</div>
							<div class="fs11 dialog-inform-cl margin-bottom-10">
								{{grid.appScope.translation.TaskResponsible}}
							</div>
						</div>
							`
                    },
                    {
                        field: 'responsibleNames',
                        width: '10%'
                    },
                    {
                        field: 'statusDisplay', displayName: 'Status',
                        width: '10%',
                        cellTemplate: `<div class="ui-grid-cell-contents pb10">
											<span class="fs12 font-bold" style="padding: 7px 10px;" 
												ng-class="{'task-status-grey': row.entity.status == 1,
								                'task-status-warning': row.entity.status == 2, 'task-status-success': row.entity.status == 3, 'task-status-danger': row.entity.status == 4}">{{row.entity.statusDisplay}}
											</span>
									   </div>`
                    },
                    {
                        field: 'document', displayName: '',
                        width: '45',
                        cellTemplate: `<div ng-if="row.entity.activityAttachments.length > 0 || row.entity.activityTaskDocuments.length > 0"
											class="attachment-tooltip">
										<a href=""
                                           class="far fa-copy fs22"
                                           style="color: #666666; font-size: 22px;"
                                           uib-popover-html="row.entity.tooltipAttachmnents"
                                           popover-trigger="'outsideClick'"
                                           popover-placement="left"
                                           popover-append-to-body="true"></a>
									    </div>`
                    },
                    {
                        field: 'expand',
                        displayName: '',
                        width: '45'
                    }
                ]
            };
            activity.subGridOptions.data = angular.copy(vm.activityTasks).filter(item => item.activityId == activity.activityId);
            activity.subGridOptions.enableHorizontalScrollbar = uiGridConstants.scrollbars.NEVER;
            activity.subGridOptions.enableVerticalScrollbar = uiGridConstants.scrollbars.NEVER;
            activity.subGridOptions.expandableRowScope = { getTaskDetailUrl: vm.getTaskDetailUrl };
        }

        function generateStatusText(status) {
            switch (status) {
                case 1:
                    return globalResources.NotStarted.toUpperCase();
                case 2:
                    return globalResources.InProgress.toUpperCase();
                case 3:
                    return globalResources.Completed.toUpperCase();
                case 4:
                    return globalResources.Consult.toUpperCase();
                default:
                    return globalResources.NotStarted.toUpperCase();
            }
        }

        function initCycleMonths() {
            vm.cycleMonths.push(
                {
                    months: [
                        { id: 11, name: globalResources.November, 'class': 'bottom-right' },
                        { id: 12, name: globalResources.December, 'class': 'bottom-right' },
                        { id: 1, name: globalResources.January, 'class': 'bottom-left' },
                        { id: 2, name: globalResources.February, 'class': 'bottom-left' },
                    ]
                },
                {
                    months: [
                        { id: 10, name: globalResources.October, 'class': 'bottom-right' },
                        {},
                        {},
                        { id: 3, name: globalResources.March, 'class': 'bottom-left' },
                    ]
                },
                {
                    months: [
                        { id: 9, name: globalResources.September, 'class': 'top-right' },
                        {},
                        {},
                        { id: 4, name: globalResources.April, 'class': 'top-left' },
                    ]
                },
                {
                    months: [
                        { id: 8, name: globalResources.August, 'class': 'top-right' },
                        { id: 7, name: globalResources.July, 'class': 'top-right' },
                        { id: 6, name: globalResources.June, 'class': 'top-left' },
                        { id: 5, name: globalResources.May, 'class': 'top-left' },
                    ]
                });


            vm.cycleSchoolMonths.push(
                {
                    months: [
                        { id: 6, name: globalResources.July, 'class': 'bottom-right' },
                        { id: 7, name: globalResources.June, 'class': 'bottom-right' },
                        { id: 8, name: globalResources.August, 'class': 'bottom-left' },
                        { id: 9, name: globalResources.September, 'class': 'bottom-left' },
                    ]
                },
                {
                    months: [
                        { id: 5, name: globalResources.May, 'class': 'bottom-right' },
                        {},
                        {},
                        { id: 10, name: globalResources.October, 'class': 'bottom-left' },
                    ]
                },
                {
                    months: [
                        { id: 4, name: globalResources.April, 'class': 'top-right' },
                        {},
                        {},
                        { id: 11, name: globalResources.November, 'class': 'top-left' },
                    ]
                },
                {
                    months: [
                        { id: 3, name: globalResources.March, 'class': 'top-right' },
                        { id: 2, name: globalResources.February, 'class': 'top-right' },
                        { id: 1, name: globalResources.January, 'class': 'top-left' },
                        { id: 12, name: globalResources.December, 'class': 'top-left' },
                    ]
                });
        }

        function getPeriods(yearRange) {
            var result = [];
            var currentYear = new Date().getFullYear();
            for (var i = -5; i < yearRange - 5; i++) {
                result.push(currentYear + i);
            }

            return result;
        }

        function getPeriodsForSchoolYear(yearRange) {
            var result = [];
            var currentYear = new Date().getFullYear();
            for (var i = -1; i < yearRange - 1; i++) {
                var year = currentYear + i;
                var nextYear = year + 1;
                result.push({
                    key: year,
                    value: year + ' / ' + nextYear
                });
            }

            return result;
        }

        function getActivityDetailUrl(activityId) {
            return String.format('/ac/activity/activityDetail/{0}', activityId);
            // $state.go('activityDetail', { activityId });
        }

        function getTaskDetailUrl(taskId) {
            return String.format('/ac/task/taskDetail/{0}', taskId);
        }
        //TODO : uncomment when have requirements
        //function updateReadingListReaderTypes(readers) {
        //    for (var i = 0; i < readers.length; i++) {
        //        var reader = readers[i];
        //        switch (reader.readerType) {
        //            case E.readerTypes.Person:
        //                reader.readerTypeName = resources.L.Common.person;
        //                break;
        //            case E.readerTypes.Department:
        //                reader.readerTypeName = resources.L.Common.department;
        //                break;
        //            case E.readerTypes.Role:
        //                reader.readerTypeName = resources.L.Common.role;
        //                break;
        //        }
        //    }
        //}
    }

    function activitiesByMonthFilter() {
        return function (source, month, year) {
            if (!year || !month || !source) {
                return [];
            }
            var result = source.filter(function (activity) {
                var date = new Date(activity.startDate);
                return date.getMonth() == (month - 1) && date.getFullYear() == year;
            })
            return result;
        };
    }

    function activitiesBySchoolYearMonthFilter() {
        return function (source, month, year) {
            if (!year || !month || !source) {
                return [];
            }
            var result = source.filter(function (activity) {
                var date = new Date(activity.startDate);
                var activityYear = date.getFullYear();
                var activityMonth = date.getMonth();
                if (activityYear == year && activityMonth >= 7 && activityMonth == (month - 1)) {
                    return true;
                }
                else if (activityYear == year + 1 && activityMonth <= 6 && activityMonth == (month - 1)) {
                    return true;
                }

                return false;
            })
            return result;
        };
    }

    function filterActivitiesByMonth(source, month, year) {
        if (!year || !month || !source) {
            return [];
        }
        var result = source.filter(function (activity) {
            var date = new Date(activity.startDate);
            return date.getMonth() == (month - 1) && date.getFullYear() == year;
        })
        return result;
    }

    function filterActivitiesBySchoolYearMonth(source, month, year) {
        if (!year || !month || !source) {
            return [];
        }
        var result = source.filter(function (activity) {
            var date = new Date(activity.startDate);
            var activityYear = date.getFullYear();
            var activityMonth = date.getMonth();
            if (activityYear == year && activityMonth >= 7 && activityMonth == (month - 1)) {
                return true;
            }
            else if (activityYear == year + 1 && activityMonth <= 6 && activityMonth == (month - 1)) {
                return true;
            }

            return false;
        })
        return result;
    }
})();

;

(function () {
    'use strict';

    angular.module(modules.homeModule)
        .controller('MainPageController', mainPageController);

    mainPageController.$inject = ['$scope', '$http', '$window', '$uibModal', '$location', 'hotkeys', 'resizeService',
        'broadcastService', 'tabStateService', 'shortcutKeysService', 'localStorageService', 'npDialog',
        'helpPagesService', '$sce', 'configService'];

    function mainPageController($scope, $http, $window, $uibModal, $location, hotkeys, resizeService,
        broadcastService, tabStateService, shortcutKeysService, localStorageService, npDialog,
        helpPagesService, $sce, configService) {
        var vm = this;
        vm.translation = {
            aboutNetpowerHandbook: globalResources.About + ' ' + globalResources.NetpowerHandbook,
            changePassword: globalResources.ChangePassword,
            userManual: globalResources.UserManual
        };

        var urlParams = $location.url().split('/');
        vm.isEmbedUrl = false;
        vm.isHearingUrl = false;
        vm.isFolderUrl = false;
        vm.isDocumentUrl = false;
        vm.isMainUrl = false;
        if (urlParams != null && urlParams.length > 0) {
            vm.isMainUrl = urlParams[1] == '';
            vm.isEmbedUrl = (urlParams[1] == 'embed' || urlParams[1] == 'annualCycle');
            vm.isFolderUrl = urlParams[1] == 'folder';
            vm.isDocumentUrl = urlParams[1] == 'document';
            vm.isHearingUrl = ((urlParams[3] == 'hearing') || (urlParams[3] == 'hearingfields') || urlParams[3] == 'compareWithEarlierVersion') || (urlParams[3] == 'viewsendtohearing');
        }

        vm.rememberedChangedWidth = 0;
        vm.userId = user.userId;
        vm.annualCycleHomeUrl = HandbookConfiguration.AnnualCycleHomeUrl;
        vm.isTest = configService.getBool(HandbookConfiguration.IsTest);
        vm.enabledAnnualCycle = configService.getBool(HandbookConfiguration.EnabledAnnualCycle);
        vm.publishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);
        vm.publicAlert = HandbookConfiguration.PublicAlert;
        vm.activityPopupSize = parseInt(HandbookConfiguration.ActivityPopupSize);
        vm.showActiveActivities = true;
        vm.sidebarAdjustmentWidth = sidebarAdjustmentWidth;
        vm.autoHideSidebar = autoHideSidebar;
        vm.openMyReadingReceipt = openMyReadingReceipt;
        vm.changePassword = changePassword;
        vm.showStartpageImage = configService.getBool(HandbookConfiguration.ShowStartpageImage);
        vm.setMasterTab = setMasterTab;
        vm.changeFontsizeGuide = globalResources.ChangeFontsizeMessage;
        vm.toggleActivities = toggleActivities;
        vm.showActiveActivitiesTab = showActiveActivitiesTab;
        vm.showUpcomingActivitiesTab = showUpcomingActivitiesTab;
        vm.editActivity = editActivity;
        vm.stopPropagation = stopPropagation;
        vm.openAboutDialog = openAboutDialog;
        vm.changeColor = changeColor;
        vm.changeLanguage = changeLanguage;
        vm.keydown = keydown;
        vm.helpEnabled = configService.getBool(HandbookConfiguration.HelpEnabled);
        vm.goToHelpPages = goToHelpPages;
        vm.showSearchBoxHeader = false;
        vm.toggleSearchBox = toggleSearchBox;
        initialize();

        function initialize() {
            vm.norwegianLanguage = true;
            var language = getLanguageCulture();
            if (language != null && language != '') {
                vm.norwegianLanguage = (language == LANGUAGES.NORWEGIAN);
            }

            vm.changeFontsizeGuide = $sce.trustAsHtml(String.format('<div class="changeFontsizeDlg"><div>{0}</div></div>', vm.changeFontsizeGuide));
            if (vm.enabledAnnualCycle) {
                getActiveActivities();
            }

            if (vm.isTest) {
                updatePositionForTestModeHeader();
            }

            var hasShownPublicAlert = localStorageService.getItem(hasShownPublicAlertKeyStorage);
            if (vm.publishedVersion && vm.publicAlert && !hasShownPublicAlert) {
                npDialog.showDialog(
                    {
                        type: dialogTypes.OK,
                        message: vm.publicAlert,
                        title: globalResources.Information
                    }, function () { });
                localStorageService.setItem(hasShownPublicAlertKeyStorage, true);
            }
        };

        $(document).bind('click', function (event) {
            var isClickedElementChildOfPopup = $('#dropdownusername')
                .find(event.target)
                .length > 0;

            if (isClickedElementChildOfPopup)
                return;
            vm.showDropdownTopbar = false;
            angular.element('#dropdownusername').removeClass('open');
            $scope.$apply();
        });

        function toggleSearchBox() {
            vm.showSearchBoxHeader = !vm.showSearchBoxHeader;
            setTimeout(function () {
                tabStateService.adjustContentHeightPosition(tabStateType.documentTabState);
            }, 0)
        }

        function changeColor() {
            if (vm.showDropdownTopbar) {
                angular.element('#dropdownusername').addClass('open');
            } else {
                angular.element('#dropdownusername').removeClass('open');
            }
        };

        function changeLanguage(language) {
            $http.post(handbookRequests.ChangeLanguage,
                {
                    language: language
                }).then(function (data, status, headers, config) {
                    vm.norwegianLanguage = !vm.norwegianLanguage;
                    user.language = vm.norwegianLanguage ? 'no' : 'en';
                    var hasShownPublicAlert = localStorageService.getItem(hasShownPublicAlertKeyStorage);
                    localStorageService.clearAll();
                    if (hasShownPublicAlert) {
                        localStorageService.setItem(hasShownPublicAlertKeyStorage, hasShownPublicAlert);
                    }
                    location.reload();
                });
        };

        function setMasterTab() {
            tabStateService.setState(tabStateType.homeTabState, homeTabs.startPage);
        }

        function sidebarAdjustmentWidth() {
            if ($window.innerWidth > 980) {
                _setWidthWhenLargerThan980px();
            }
            else {
                _setWidthWhenSmallerThan980px();
            }

            broadcastService(broadcastType.toggleSidebar, $scope.toggleSidebar);
        };

        function autoHideSidebar() {
            if ($window.innerWidth < 960 && angular.element('#sidebar-wrapper').hasClass('toggle-sidebar')) {
                angular.element('#sidebar-wrapper').removeClass('toggle-sidebar');
                angular.element('#resizeBar').removeClass('toggle-sidebar');
                angular.element('#wrapper').removeClass('toggle-wrapper');
                angular.element('.tabbable').removeClass('toggle-mainview');
                $scope.toggleSidebar = false;
            }
        };

        function _setWidthWhenLargerThan980px() {
            if (angular.element('#sidebar-wrapper').hasClass('toggle-sidebar')) {
                _resizeSidebarWithRememberedChangedWidth();
            }
            else {
                _rememberWidthChangedAndResizeToOrginalSize();
            }
        };

        function _setWidthWhenSmallerThan980px() {
            if (angular.element('#sidebar-wrapper').hasClass('toggle-sidebar')) {
                _rememberWidthChangedAndResizeToOrginalSize();
            }
            else {
                _resizeSidebarWithRememberedChangedWidth();
            }
        };

        function _rememberWidthChangedAndResizeToOrginalSize() {
            vm.rememberedChangedWidth = angular.element(elementId.sidebarWrapper).width();
            resizeService.resizeToOrginalSize();
        };

        function _resizeSidebarWithRememberedChangedWidth() {
            if (vm.rememberedChangedWidth != 0 && vm.rememberedChangedWidth != 320) {
                resizeService.resizeToChangedSize(vm.rememberedChangedWidth);
            }
        };

        function openMyReadingReceipt() {
            var modalInstance = $uibModal.open({
                templateUrl: '/app/components/home/templates/myReadingReceipts.html',
                controller: controllers.myReadingReceiptsController + ' as vm',
                size: 'lg',
                resolve: {
                    items: function () {
                    }
                }
            });
        };

        function changePassword() {
            var modalInstance = $uibModal.open({
                templateUrl: '/app/components/account/templates/changePassword.html',
                controller: 'ChangePasswordController as vm',
                size: 'md'
            });
        }

        function getActiveActivities() {
            $http
                .get('/api/Activity/GetActiveActivitiesForNotification')
                .success(function (data) {
                    vm.activeActivities = data;
                    if (data.length > 0) {
                        vm.showActiveActivities = true;
                    }

                    getUpcomingActivities();
                });
        }

        function getUpcomingActivities() {
            $http
                .get('/api/Activity/GetUpcomingActivities')
                .success(function (data) {
                    vm.upcomingActivities = data;

                    if (vm.activeActivities.length == 0 && data.length > 0) {
                        vm.showUpcomingActivities = true;
                    }
                });
        }

        function toggleActivities(event) {
            if (angular.element('.activity-notifications > div').css('display') == 'none') {
                angular.element('.activity-notifications > div').css('display', 'block');
            } else {
                angular.element('.activity-notifications > div').css('display', 'none');
            }

            stopPropagation(event);
        }

        function showActiveActivitiesTab() {
            vm.showActiveActivities = true;
            vm.showUpcomingActivities = false;
        }

        function showUpcomingActivitiesTab() {
            vm.showActiveActivities = false;
            vm.showUpcomingActivities = true;
        }

        function editActivity(activity) {
            angular.element('.activity-notifications > div').css('display', 'none');
            window.open(String.format(HandbookConfiguration.EditActivityUrl, activity.activityId));
        }

        function stopPropagation(event) {
            if (event) {
                event.stopPropagation();
            }
        }

        function openAboutDialog() {
            $uibModal.open({
                templateUrl: '/app/components/home/templates/about.html',
                controller: 'AboutController as vm',
                size: 'md'
            });
        }

        hotkeys.bindTo($scope)
            .add({
                combo: shortcutKeysService.gotoStartpage.shortcut,
                description: 'Open start page', // The description just explain in code, not use in GUI
                callback: shortcutKeysService.gotoStartpage.method
            })
            .add({
                combo: shortcutKeysService.openFavouritesMenu.shortcut, // because shilf+alt+f is hotkey of browser, so we use ctrl instead.
                description: 'Open faviroute sidebar',
                callback: shortcutKeysService.openFavouritesMenu.method
            })
            .add({
                combo: shortcutKeysService.openDocumentsMenu.shortcut,
                description: 'Open document sidebar',
                callback: shortcutKeysService.openDocumentsMenu.method
            })
            .add({
                combo: shortcutKeysService.openSimpleSearch.shortcut,
                description: 'Open simple search. Set focus on search field in top bar so user can start typing',
                callback: shortcutKeysService.openSimpleSearch.method
            })
            .add({
                combo: shortcutKeysService.navigateItemInSidebar.shortcut,
                description: 'Navigate folder in folder view.',
                callback: shortcutKeysService.navigateItemInSidebar.method
            })
            .add({
                combo: shortcutKeysService.printFolderPDFIndex.shortcut,
                description: 'Print folder/document index PDF',
                callback: function () {
                    var url = $location.url();
                    if (url.indexOf('folder') > 0) {
                        shortcutKeysService.printFolderPDFIndex.method();
                    } else if (url.indexOf('document') > 0) {
                        shortcutKeysService.printDocumentPDFA4.method();
                    }
                }
            })
            .add({
                combo: shortcutKeysService.toggleFavorite.shortcut,
                description: 'Toggle folder favorite',
                callback: shortcutKeysService.toggleFavorite.method
            })
            .add({
                combo: shortcutKeysService.toggleEmailNotification.shortcut,
                description: 'Toggle email subscription',
                callback: shortcutKeysService.toggleEmailNotification.method
            })
            .add({
                combo: shortcutKeysService.toggleOnlyFolderEmailNotification.shortcut,
                description: 'Toggle only folder email subscription',
                callback: shortcutKeysService.toggleOnlyFolderEmailNotification.method
            })
            .add({
                combo: shortcutKeysService.openGridSetting.shortcut,
                description: 'Open grid settings. First column should have focus so user can use space to toggle and tab to go to next one',
                callback: shortcutKeysService.openGridSetting.method
            })
            .add({
                combo: shortcutKeysService.toggleFolderContentTab.shortcut,
                description: 'Toggle folder/document content tab',
                callback: function () {
                    var url = $location.url();
                    if (url.indexOf('folder') > 0) {
                        shortcutKeysService.toggleFolderContentTab.method();
                    } else if (url.indexOf('document') > 0) {
                        shortcutKeysService.toggleDocumentContentTab.method();
                    } else {
                        shortcutKeysService.toggleMasterHomeTab.method();
                    }
                }
            })
            .add({
                combo: shortcutKeysService.toggleFolderAboutTab.shortcut,
                description: 'Toggle folder/document about tab',
                callback: function () {
                    var url = $location.url();
                    if (url.indexOf('folder') > 0) {
                        shortcutKeysService.toggleFolderAboutTab.method();
                    } else if (url.indexOf('document') > 0) {
                        shortcutKeysService.toggleDocumentAboutTab.method();
                    } else {
                        shortcutKeysService.toggleWhatsNewsTab.method();
                    }
                }
            })
            .add({
                combo: shortcutKeysService.toggleDocumentMetadataTab.shortcut,
                description: 'Toggle metadata if enabled',
                callback: function () {
                    var url = $location.url();
                    if (url.indexOf('document') > 0) {
                        if (configService.getBool(HandbookConfiguration.MetadataEnabled)) {
                            shortcutKeysService.toggleDocumentMetadataTab.method();
                        } else {
                            shortcutKeysService.toggleDocumentSearchInContentTab.method();
                        }
                    } else {
                        shortcutKeysService.toggleUpdatedFavoriteTab.method();
                    }
                }
            })
            .add({
                combo: shortcutKeysService.toggleDocumentSearchInContentTab.shortcut,
                description: 'Toggle metadata if enabled',
                callback: function () {
                    var url = $location.url();
                    if (url.indexOf('document') > 0) {
                        if (configService.getBool(HandbookConfiguration.MetadataEnabled)) {
                            shortcutKeysService.toggleDocumentSearchInContentTab.method();
                        }
                    } else if (configService.getBool(HandbookConfiguration.ReadingListEnabled)) {
                        shortcutKeysService.toggleMyReadingListTab.method();
                    }
                }
            })
            .add({
                combo: shortcutKeysService.openDocumentReadingReceipt.shortcut,
                description: 'Open reading receipt',
                callback: shortcutKeysService.openDocumentReadingReceipt.method
            })
            .add({
                combo: shortcutKeysService.openDocumentFeedback.shortcut,
                description: 'Open feedback',
                callback: shortcutKeysService.openDocumentFeedback.method
            })
            .add({
                combo: shortcutKeysService.toggleDocumentFullScreenViewing.shortcut,
                description: 'Toggle fullscreen viewing',
                callback: shortcutKeysService.toggleDocumentFullScreenViewing.method
            })
            .add({
                combo: shortcutKeysService.linkToDocumentManagement.shortcut,
                description: 'Link to document management',
                callback: function () {
                    var url = $location.url();
                    if (url.indexOf('folder') > 0) {
                        shortcutKeysService.linkToFolderManagement.method();
                    } else if (url.indexOf('document') > 0) {
                        shortcutKeysService.linkToDocumentManagement.method();
                    }
                }
            });

        $(window).keyup(function (event) { // handle number 0 on number pad
            if (event.ctrlKey && event.altKey && event.keyCode == 96) {
                shortcutKeysService.gotoStartpage.method();
            }
        });

        $(window).on('resize', function () {
            resizeService.resizeToOrginalSize();
            if (vm.isTest) {
                updatePositionForTestModeHeader();
            }
        });

        $(window).on('click', function () {
            angular.element('.activity-notifications > div').css('display', 'none');
        })

        function updatePositionForTestModeHeader() {
            var widthOfDocument = $(document).width();
            var widthOfToggleSidebarButton = 42;
            var widthOfSearchDocumentsControl = 280;
            var widthOfLeftControls = widthOfToggleSidebarButton + widthOfSearchDocumentsControl;
            var widthOfTestModeHeader = 50;
            var widthOfRightMenu = $('#navbar-header .navbar-right').width();
            var remainingWidth = widthOfDocument - widthOfLeftControls - widthOfTestModeHeader - widthOfRightMenu;

            $('#navbar-header .test-mode-header').css('left', (remainingWidth) / 2 + widthOfLeftControls);

        }

        function keydown(e) {
            if (e.which === 112) {
                if (vm.helpEnabled) {
                    document.onhelp = function () {
                        return (false);
                    };
                    window.onhelp = function () {
                        return (false);
                    };
                    e.returnValue = false;
                    e.keyCode = 0;
                    e.preventDefault();
                    e.stopPropagation();
                    goToHelpPages();
                    return false;
                }
            }
        }

        function goToHelpPages() {
            if (vm.helpEnabled) {
                var urlParams = $location.url().split('/');
                var viewId = 1;
                if (urlParams != null && urlParams.length > 0) {
                    switch (urlParams[1]) {
                        case 'folder':
                            viewId = 2;
                            break;
                        case 'document':
                            viewId = 3;
                            break;
                        case '':
                            if (angular.element('#hearings-tab').hasClass('active')) {
                                viewId = 4;
                            }
                            break;
                        default:
                            viewId = 1;
                    }
                }
                var newWindow = window.open("", "_blank");
                helpPagesService.getHelpPages(viewId).then(function (data, status, headers, config) {
                    newWindow.location.href = data.helpURL;
                });
            }
        }
    };
})();;

(function () {
	'use strict';

	angular.module(modules.homeModule)
		.controller('StartpageController', startpageController);

	startpageController.$inject = ['$state', '$http', '$scope', '$sce', '$timeout', '$window', 'newsService',
		'tabStateService', 'localStorageService', 'documentService', 'browserService', 'configService'];

	function startpageController($state, $http, $scope, $sce, $timeout, $window, newsService,
		tabStateService, localStorageService, documentService, browserService, configService) {
		var vm = this;
		
		vm.toggleLoadAllNews = localStorageService.getItem('toggleLoadAllNews') || false;
		vm.news = [];
		vm.leftMenuGroups = [];
		vm.rightMenuGroups = [];
		vm.currentPage = -1;
		vm.totalResults = 0;
		vm.maxDisplayPage = NewsGridConfig.maxDisplayPage;
		vm.itemPerPage = NewsGridConfig.pageSize;
		vm.translation = {
			more: globalResources.More,
			showmore: globalResources.Showmore,
			first: globalResources.First,
			last: globalResources.Last,
			newsHeader: globalResources.NewsHeader,
			news: globalResources.News,
			run: globalResources.Run,
			yourReports: globalResources.YourReports,
			searchDocumentTitleOrId: globalResources.SearchDocumentTitleOrId,
			selectTheTypeOfSearch: globalResources.SelectTheTypeOfSearch,
			myReports: globalResources.MyReports,
			processes: globalResources.Processes,
			myPage: globalResources.MyPage
		};

		vm.reportTypes = DEVIATION_REPORTS_TYPES;

		vm.loadAllNews = loadAllNews;
		vm.gotoUrl = gotoUrl;
		vm.collapseHandle = collapseHandle;
		vm.goToNewsDetails = loadNews;
		vm.runReport = runReport;
		vm.enableHomepageSearch = HandbookConfiguration.EnableHomepageSearch;
		vm.dashboardIframeUrl = $sce.trustAsResourceUrl(HandbookConfiguration.BackendURL + 'dashboard?hideTopBar=true');
		vm.BROWSER_TYPE = BrowserType;
		vm.browserType = browserService.detectBrowserWindow();

		initialize();

		function initialize() {
			vm.isDataAvailable = (HandbookConfiguration.StartpageThemeKey != E.StartpageTheme.StartpageWithNewsAndImage);
			if (vm.toggleLoadAllNews) {
				loadAllNews(localStorageService.getItem('pageIndex'));
			}
			else {
				getNews();
				//add for device
				$timeout(function () {
					newsService.adjustNewsHeight();
					$scope.$apply();
				}, 3000, false);
			}
			getMenuGroups();
			getUserFilterSearches();

			if (HandbookConfiguration.StartpageThemeKey == E.StartpageTheme.StartpageWithProcessAndWidgets) {
				setTimeout(function () {
					$('#processTabTrigger').trigger('click');
				});
            }
		};

		function getUserFilterSearches() {
			return $http.get('/api/Users/GetUserSavedSearches', { params: { searchFilterType: searchFilterTypes.handbookReports } })
				.then(function (response, status, headers, config) {
					if (response.data) {
						response.data.forEach(function (item) {
							var type = getReportType(item.searchFilters);
							item.reportType = getReportTypeText(type);
							item.module = searchFilterTypes.handbookReports;
						});
						vm.saveSearches = response.data;
						getUserFilterSearchesForDeviation();
					}
				});

		}

		function getUserFilterSearchesForDeviation() {
			return $http.get('/api/Users/GetUserSavedSearches', { params: { searchFilterType: searchFilterTypes.deviationReports } })
				.then(function (response, status, headers, config) {
					if (response.data) {
						if (!vm.saveSearches)
							vm.saveSearches = [];

						response.data.forEach(function (item) {
							var type = getReportType(item.searchFilters);
							item.module = searchFilterTypes.deviationReports;
							item.reportType = getReportTypeTextForDeviation(type);
							vm.saveSearches.push(item);
						});
					}
				});

		}

		function getReportType(searchFilters) {
			if (!searchFilters)
				return '';

			var arrSearchFilter = decodeURIComponent(searchFilters).split('&');
			if (arrSearchFilter == null || arrSearchFilter.length <= 0)
				return '';

			for (var i = 0; i < arrSearchFilter.length; i++) {
				var values = arrSearchFilter[i].split('=');
				if (values != null && values.length > 0 && values[0] == 'reportType') {
					return values[1];
				}
			}
			return '';
		}

		function getReportTypeText(type) {
			if (type != '')
				type = parseInt(type);
			switch (type) {
				case 1:
					return globalResources.ReadingReceiptsPerson;
				case 2:
					return globalResources.ReadingReceiptsDocument;
				case 3:
					return globalResources.ReadingReceiptsFolder;
				case 4:
					return globalResources.NumberOfDocumentsPerFolder;
				case 5:
					return globalResources.FolderStatistics;
				case 6:
					return globalResources.NewRevisedDocuments;
				case 7:
					return globalResources.WritePermissionsPerson;
				case 8:
					return globalResources.ApprovePermissionsPerson;
				case 9:
					return globalResources.WritePermissions;
				case 10:
					return globalResources.ApprovePermissions;
				case 11:
					return globalResources.ReadingListsPerson;
				case 12:
					return globalResources.ReadingListDepartment;
				case 13:
					return globalResources.ReadingListClosestLeader;
				case 14:
					return globalResources.ReadingListRole;
				case 15:
					return globalResources.MostReadDocumentsTotal;
				case 16:
					return globalResources.MostReadDocumentsVersion;
				case 17:
					return globalResources.StatusDocumentsPerFolder;
				case 18:
					return globalResources.LeastReadDocumentsTotal;
				case 19:
					return globalResources.LeastReadDocumentsVersion;
				default:
			}

			return '';
		}

		function getReportTypeTextForDeviation(type) {
			if (type != '')
				type = parseInt(type);
			switch (type) {
				case vm.reportTypes.CATEGORY_NUMBER:
					return globalResources.categoryNumberPerStatus;
				case vm.reportTypes.CATEGORY_NUMBER_PER_METATAG:
					return globalResources.metatagCategoryReport;
				case vm.reportTypes.CATEGORY_NUMBER_PER_SUB_CATEGORY:
					return globalResources.subCategoryCategoryReport;
				case vm.reportTypes.CATEGORY_NUMBER_PER_HANDLING_UNIT:
					return globalResources.categoryNumberPerHandlingUnit;
				case vm.reportTypes.CATEGORY_YEAR_AND_MONTH_NUMBER:
					return globalResources.categoryYearAndMonthNumber;
				case vm.reportTypes.CATEGORY_NUMBER_PER_MONTH_PER_YEAR:
					return globalResources.categoryNumberPerMonthPerYear;
				case vm.reportTypes.CATEGORY_SEVERITY_NUMBER:
					return globalResources.categorySeverityNumbers;
				case vm.reportTypes.CATEGORY_KPI:
					return globalResources.category + ' - ' + globalResources.kpi;
				case vm.reportTypes.ACTIONS_NUMBER_AND_TYPE:
					return globalResources.actionsNumberAndType;
				case vm.reportTypes.ACTIONS_NUMBER_PER_MONTH_PER_YEAR:
					return globalResources.actionsNumberPerMonthPerYear;
				case vm.reportTypes.STATISTICS:
					return globalResources.statistics;
				case vm.reportTypes.CATEGORY_COST_PER_YEAR:
					return globalResources.costCategory;
				case vm.reportTypes.CATEGORY_COST_PER_MONTH_PER_YEAR:
					return globalResources.costTypeSumPerMonthPerYear;
				case vm.reportTypes.CATEGORY_CUSTOM_FIELD:
					return globalResources.categoryCustomFieldReport;
				case vm.reportTypes.CATEGORY_EQUIPMENT:
					return globalResources.categoryEquipmentReport;
				default:
			}

			return '';
		}

		function getNews() {
			newsService
				.getNews({ showInModule: E.NewsCategoryShownIn.shownInHandbookFrontend })
				.then(function (result) {
					handleDevicesSize(result.data.length);
					vm.news = result.data;
					if (vm.news.length > 0) {
						vm.news.filter(function (x) {
							if (x.image !== null) {
								newsService
									.getNewsImageById(x.id)
									.then(function (result) {
										if (result.data !== null && result.data.value !== null) {
											if (result.data.id === -1) {
												x.image.value = result.data.value;
											}
											else {
												x.image.value = 'data:image/png;base64,' + result.data.value;
											}
										}
									})
									.catch(function (result) {

									});
							}
						});
					}
					$timeout(function () {
						newsService.adjustNewsHeight();
						$scope.$apply();
					}, 500, false);
				});
		};

		function loadNews(id) {
			user.currentNewsPage = 1;
			newsService
				.updateNewsReadCount(id);
		};

		function loadAllNews(pageIndex, pageSize) {
			if (!vm.toggleLoadAllNews) {
				pageIndex = 1;
			}

			newsService
				.getNewsWithPaging(pageIndex - 1, pageSize || NewsGridConfig.pageSize)
				.then(function (result) {
					vm.news = result.data.news;
					vm.toggleLoadAllNews = true;
					vm.totalResults = result.data.totalResults;
					vm.currentPage = pageIndex;
					localStorageService.setItem('toggleLoadAllNews', true);
					localStorageService.setItem('pageIndex', pageIndex);
				});

			adjustContentPosition();
		};

		function getMenuGroups() {
			$http
				.get(handbookRequests.GetMenuGroups)
				.then(function (result) {
					var menus = result.data;
					var rootMenuId = HandbookConfiguration.MenuId;

					var columns = [];
					for (var i = 0; i < menus.length; i++) {
						if (menus[i].parentItemId == rootMenuId) {
							columns.push(menus[i]);
						}
					}

					var groups = getGroupsPerCoumn(menus, columns);
					groups = getGroupItems(menus, groups);

					vm.menus = groups;
					buildGroupsStyle(vm.menus);

					if (configService.getBool(HandbookConfiguration.CollapseMenuGroups)) {
						collapseMenuGroups();
					}
					vm.isDataAvailable = true;
				})
		};

		function collapseMenuGroups() {
			$timeout(function () {
				for (var i = 0; i < vm.menus.length; i++) {
					for (var j = 0; j < vm.menus[i].groups.length; j++) {
						if (!vm.menus[i].groups[j].expanded) {
							angular.element('#spgroup_' + vm.menus[i].groups[j].itemId).toggleClass('collapsed');
							angular.element('#spgroup_' + vm.menus[i].groups[j].itemId + '_icon').removeClass('collapse-arrow').addClass('collapsed-arrow');
						}
					}
				}
			}, 500, false);
		}

		function getGroupsPerCoumn(menus, columns) {
			var groups = [];
			var index = 0, hasGroupItems = false;
			for (var i = 0; i < columns.length; i++) {
				for (var j = 0; j < menus.length; j++) {
					if (menus[j].parentItemId == columns[i].itemId) {
						hasGroupItems = true;
						if (groups[index] == null) {
							var children = []; children.push(menus[j]);
							groups.push({ groups: children });
						} else {
							groups[index].groups.push(menus[j]);
						}
					}
				}
				if (hasGroupItems) {
					for (var k = 0; k < groups[index].groups.length; k++) {
						menus.splice($.inArray(groups[index].groups[k], menus), 1);
					}
					index += 1;
				}
				hasGroupItems = false;
			}
			return groups;
		}

		function buildGroupsStyle(menus) {
			var length = menus.length;
			var padding = 2, css = '';
			var width = 100 / length - padding;

			switch (length) {
				case 1:
					if (HandbookConfiguration.StartpageThemeKey == E.StartpageTheme.StartpageWithNewsAndImage) {
						css = 'col-md-6 col6res';
					} else {
						css = 'col-md-12';
					}
					break;
				case 2:
					if (HandbookConfiguration.StartpageThemeKey == E.StartpageTheme.StartpageWithNewsAndImage) {
						css = 'col-md-4 col4res';
					} else {
						css = 'col-md-6';
					}
					break;
				case 3:
					css = 'col-md-4';
					break;
				case 4:
					css = 'col-md-3';
					break;
				default:
					css = 'col-md-2';
					break;
			}

			vm.imageCss = css;

			for (var i = 0; i < length; i++) {
				menus[i].style = 'width: ' + width + '%; float: left;';
				menus[i].css = css;
				if (i < length - 1) {
					menus[i].style += 'margin-right: ' + padding + '%;'
				}
			}
		}

		function getGroupItems(menus, groups) {
			for (var i = 0; i < menus.length; i++) {
				for (var j = 0; j < groups.length; j++) {
					for (var k = 0; k < groups[j].groups.length; k++) {
						if (menus[i].parentItemId == groups[j].groups[k].itemId) {
							if (groups[j].groups[k].items == null) {
								var items = []; items.push(menus[i]);
								groups[j].groups[k].items = items;
							} else {
								groups[j].groups[k].items.push(menus[i]);
							}
						}
					}
				}
			}

			return groups;
		}

		function adjustContentPosition() {
			var tabState = tabStateService.getState(tabStateType.homeTabState);
			$timeout(function () {
				tabStateService.adjustContentPosition(tabState, tabStateType.homeTabState);
			}, 0, false);
		};

		function gotoUrl(item, e) {
			var requestUrl = '/api/Menu/SaveClickedCount';
			var request = { itemId: item.itemId };
			if (item.url) {
				$http.post(requestUrl, request);
			}
			if (item.url.indexOf('http') >= 0) {
				if (item.url.indexOf($window.location.hostname) < 0) {
					return;
				}
			}
			if (item.url.indexOf('document/') >= 0) {
				if (item.newWindow != '1') {
					documentService.goToDocument(item.url.substr(item.url.lastIndexOf('/') + 1));
					e.preventDefault();
				}
			} else if (item.url.indexOf('folder/') >= 0) {
				if (item.newWindow != '1') {
					$state.go(handbookActions.FolderAction, { folderId: item.url.substr(item.url.lastIndexOf('/') + 1) });
					e.preventDefault();
				}
			}
		};

		$scope.$watch('vm.currentPage', function (newPage) {
			if (vm.currentPage != -1) {
				loadAllNews(newPage);
			}
		});

		$(window).on('resize', function () {
			handleDevicesSize(vm.news.length);
			$timeout(function () {
				newsService.adjustNewsHeight();
				$scope.$apply();
			}, 500, false);
		});

		function collapseHandle(collapsedFlag) {
			vm.collapsed = collapsedFlag;
		};

		$scope.$on('adjustmentNews', function (e, target) {

			$timeout(function () {
				newsService.adjustNewsHeight()
			}, 500, false);
		});

		function handleDevicesSize(newsLength) {
			var availWidth = screen.availWidth;
			var availHeight = screen.availHeight;

			if (availWidth <= 768) {
				//mobile
				vm.newsItemClass = 'col-xs-12';
			} else {
				switch (newsLength) {
					case 1:
						vm.newsItemClass = 'col-xs-12';
						break;
					case 2:
						vm.newsItemClass = 'col-xs-6';
						break;
					default:
						vm.newsItemClass = 'col-xs-4';
						break;
				}
			}
		}

		function runReport(saveReport) {
			var backendUrl = HandbookConfiguration.BackendURL;
			var lastChar = backendUrl.charAt(backendUrl.length - 1);
			var commonAdd = lastChar == '/' ? '' : '/';
			if (saveReport.module == searchFilterTypes.handbookReports) {
				window.open(backendUrl + commonAdd + 'handbook/reportsView/param?' + saveReport.searchFilters, '_blank');
			} else {
				window.open(backendUrl + commonAdd + 'deviation/reports/param?' + saveReport.searchFilters, '_blank');
			}
		}

	};
})();

;
(function () {
    'use strict';

    angular.module(modules.homeModule)
           .controller('AboutController', controller);

    controller.$inject = ['$uibModalInstance'];

    function controller($modalInstance) {
        var vm = this;
        vm.translation = {
            about: globalResources.About,
            netpowerHandbook: globalResources.NetpowerHandbook,
            version: globalResources.CommonGridColumns.Version,
            close: globalResources.Close
        };

        vm.applicationVersion = HandbookConfiguration.ApplicationVersion;

        vm.close = close;

        function close() {
            $modalInstance.dismiss('cancel');
        }
    }
})();;

(function () {
    'use strict';

    angular.module(modules.homeModule)
        .controller('NewsDetailsController', newsDetailsController);

    newsDetailsController.$inject = ['$stateParams', '$sce', '$timeout',
        'newsService', 'anchorService', 'resizeService'];

    function newsDetailsController($stateParams, $sce, $timeout,
        newsService, anchorService, resizeService) {
        var vm = this;

        vm.news = null;
        vm.id = $stateParams.newsId;
        vm.translation = {
            attachments: globalResources.CommonGridColumns.HasAttachment,
            editNews: globalResources.EditNews
        };
        vm.GetFileRequest = handbookRequests.GetFileRequest;
        vm.linkToEditNewsView = linkToEditNewsView;

        vm.copyUserFriendlyUrlTooltip = globalResources.CopyUserFriendlyUrl;


        initialize();

        vm.urlNews = window.location.origin + '/news/' + vm.id;

        function initialize() {
            resizeService.resizeView();
            getNewsById(vm.id);
        };

        function getNewsById(id) {
            newsService
                .getActiveNewsById(id)
                .then(function (result) {
                    vm.news = result.data;
                    if (vm.news !== null && vm.news.image !== null) {
                        newsService
                            .getNewsImageById(vm.news.id)
                            .then(function (result) {
                                if (result.data !== null && result.data.value !== null) {
                                    if (result.data.id === -1) {
                                        vm.news.image.value = result.data.value;
                                    }
                                    else {
                                        vm.news.image.value = 'data:image/png;base64,' + result.data.value;
                                    }
                                }
                            });
                    }
                    vm.news.body = $sce.trustAsHtml(vm.news.body);
                    runServicesAfterInit();
                })
        };

        function runServicesAfterInit() {
            $timeout(function () {
                updateLocalAnchors();
            }, 500);
        }

        function updateLocalAnchors() {
            var domContent = angular.element('div.news-detail-body');
            anchorService.updateLocalAnchors(domContent);
        }

        function linkToEditNewsView() {
            var backendUrl = HandbookConfiguration.BackendURL;
            var lastChar = backendUrl.charAt(backendUrl.length - 1);
            var commonAdd = lastChar == '/' ? '' : '/';

            var url = backendUrl + commonAdd + 'admin/newsCategories/' + vm.news.categoryId + '/' + vm.id + '/edit';
            window.open(url, '_blank');

        }
    };
})();

;

(function () {
    'use strict';

    angular.module(modules.homeModule)
        .controller(controllers.myReadingReceiptsController, myReadingReceiptsController);

    myReadingReceiptsController.$inject = ['$scope', '$http', '$state', '$uibModalInstance', 'localStorageService'];

    function myReadingReceiptsController($scope, $http, $state, $modalInstance, localStorageService) {
        var vm = this;
        vm.initialize = initialize;
        vm.translation = globalResources;
        vm.openTree = openTree;
        vm.clearSelectedFolder = clearSelectedFolder;
        vm.viewReport = viewReport;
        vm.cancel = cancel;
        vm.chooseAmongFavorites = chooseAmongFavorites;

        vm.originalFolderTree = null;
        vm.originalFavorites = null;

        var itemAll = { id: -1, name: vm.translation.All };

        function initialize() {
            vm.includeSubfolders = false;
            vm.showFolderTree = false;
            vm.selectedFolder = null;
            vm.style = {
                folderClass: '',
                inputClass: ''
            };
            var chooseAmongFavorites = localStorageService.getItem('ChooseAmongFavorites');
            if (chooseAmongFavorites == null || chooseAmongFavorites == 'false') {
                getFolderTree();
            } else {
                vm.chooseFavorite = true;
                getFolderFavorites();
            }
            vm.title = String.format(globalResources.MyReadingReceipt, user.fullName);
        };

        function openTree() {
            vm.showFolderTree = !vm.showFolderTree;
        };

        function clearSelectedFolder($event) {
            vm.selectedFolder = null;
            vm.style.folderClass = '';
            vm.style.inputClass = '';
        };

        $scope.$watch('vm.selectedFolder', function (selected) {
            if (selected) {
                if (selected.id == -1) {
                    vm.includeSubfolders = true;
                }
            }
        });

        function viewReport() {
            var id = 0, includeSubfolders = true;
            if (vm.selectedFolder.id > 0) {
                id = vm.selectedFolder.id;
                includeSubfolders = vm.includeSubfolders;
            }
            $state.go(handbookActions.MyReadingReceiptsReport, {
                folderId: id,
                recursive: includeSubfolders
            });

            $modalInstance.close();
        };

        function cancel() {
            $modalInstance.close();
        };

        $scope.selectNodeLabel = function (node) {
            vm.selectedFolder = node;
            vm.showFolderTree = false;
            vm.style.folderClass = 'mrc-folder-' + node.type;
            if (node.id > 0) {
                vm.style.inputClass = 'padding-left-65';
            } else {
                vm.style.inputClass = '';
            }
        };

        $scope.selectNodeHead = function (node) {
            //check if type of selected node is in [1, 2, 3, 4] = [Document, LinkDocument, FileDocument, ShortcutDocument] refer to enum NodeType, we dont call request
            if (!node.isLoaded && node.type > 4) {
                // Does not follow config ShowDocumentsInTree
				$http.get(handbookRequests.GetFoldersRequest, { params: { 'Id': node.id, 'showDocumentInTree': false } })
                    .success(function (data, status, headers, config) {
                        node.children = data;
                        node.isLoaded = true;
                    })
                    .error(function (data, status, headers, config) {
                        node.isLoaded = true;
                    });
            }
        };

        function getFolderFavorites() {
            if (vm.originalFavorites == null) {
                $http.get(handbookRequests.GetFavoritesRequest).
                    success(function (data, status, headers, config) {
                        var tempData = [];
                        tempData.push(itemAll);
                        if (data && data.length > 0) {
                            data.forEach(function (item) {
                                if (isFolderNode(item)) {
                                    tempData.push(item);
                                }
                            })
                        }
                        vm.documents = tempData;
                        vm.originalFavorites = tempData;
                        vm.selectedFolder = itemAll;
                    });
            } else {
                vm.documents = vm.originalFavorites;
            }
        };

        function getFolderTree() {
            if (vm.originalFolderTree == null) {
				$http.get(handbookRequests.GetFoldersRequest, { params: { 'id': null, 'showDocumentInTree': false } })
                    .success(function (data, status, headers, config) {
                        data.splice(0, 0, itemAll);
                        vm.documents = data;
                        vm.originalFolderTree = data;
                        vm.selectedFolder = itemAll;
                    });
            } else {
                vm.documents = vm.originalFolderTree;
            }
        };

        function chooseAmongFavorites() {
            if (vm.chooseFavorite) {
                getFolderFavorites();
                localStorageService.setItem('ChooseAmongFavorites', true);
            } else {
                getFolderTree();
                localStorageService.setItem('ChooseAmongFavorites', false);
            }
        };

        function isFolderNode(node) {
            return node.type == E.nodeTypes.Folder || node.type == E.nodeTypes.TopFolder || node.type == E.nodeTypes.DepartmentFolder || node.type == E.nodeTypes.RegionalFolder;
        };
    };
})();

;

(function () {
    'use strict';

    angular.module(modules.homeModule)
           .controller(controllers.personChapterConfirmsSumsListController, personChapterConfirmsSumsListController);

    personChapterConfirmsSumsListController.$inject = ['$scope', '$http'];

    function personChapterConfirmsSumsListController($scope, $http) {
        var vm = this;
        vm.initialize = initialize;

        function initialize() {
        };
    };
})();

;

(function () {
    'use strict';

    angular.module('tabModule', [])
           .controller('TabController', tabController);

	tabController.$inject = ['$scope', 'tabStateService', 'readingConfirmationService', 'feedBackService', 'documentService','$location'];

	function tabController($scope, tabStateService, readingConfirmationService, feedBackService, documentService, $location) {
        var vm = this;

        vm.feedbackText = '';
        vm.setState = setState;
        vm.initializeTabs = initializeTabs;
        vm.sendFeedback = sendFeedback;
        vm.sendReadingConfirmation = sendReadingConfirmation;
        vm.getConfirmInformation = getConfirmInformationBaseOnView;

        function setState(tabId, tabType) {
            var tabStateType = getTabStateType(tabType);

            setFocusTextSearchForTabActive(tabId);

            if (tabStateService.isTabActive(tabId)) {
                if (tabId == "more-tab") {
                    const activeItem = {
                        tabId: '#more-tab',
                        tabContentId: '.tab-content.home-content #tab8'
                    }
                    angular.element(activeItem.tabId).toggleClass('active');
                    angular.element(activeItem.tabContentId).toggleClass('active');
                }
            } else {
                tabStateService.setState(tabStateType, tabId);
                tabStateService.setCurrentTabState(tabId);
			}
			var element = $location.url().split('/');
			if (tabId.includes('document') && element[3] != 'fields' && element[3] != 'hearingfields') {
                setTimeout(function () { documentService.stickyTitle(); }, 0);
            }
        };

        function initializeTabs(tabType, isInitReadingConfirmationTab) {
            var _tabStateType = getTabStateType(tabType);
            tabStateService.setCurrentStateType(_tabStateType);

            var tabState = tabStateService.getState(_tabStateType);
            if ((tabState == null || tabState == "") && _tabStateType == tabStateType.homeTabState) {
                tabStateService.setState(tabStateType.homeTabState, homeTabs.startPage);
            }
            setFocusTextSearchForTabActive(tabState);

            tabStateService.initTabState(_tabStateType);
            if (isInitReadingConfirmationTab) {// not loading data again if fieldview
                initializeReadingReceiptTab();
            }
        };

        function setFocusTextSearchForTabActive(tabState) {
            if (tabState != null) {
                if (tabState == 'document-searchincontent') {
                    setTimeout(function () {
                        angular.element('#input-search-in-document').focus();
                    }, 0);
                }
            } 
        };

        function sendFeedback() {
            if (vm.feedbackText == '' || vm.feedbackText == null) {
                alert(globalResources.PleaseEnterFeedback);
                return false;
            }
            return feedBackService
                .sendFeedback($scope.$parent.vm.currentData.entityId, vm.feedbackText)
                .then(function (data) {
                    if (data == true) {
                        vm.feedbackText = '';
                        alert(globalResources.ThanksForYourFeedback);
                    }
                });
        };

        function sendReadingConfirmation() {
            var currentData = $scope.$parent.vm.currentData;
            if (currentData.confirmInformation) {
                readingConfirmationService
                    .sendReadingConfirmation(currentData.entityId, currentData.folderId)
                    .then(function (data) {
                        if (data == true) {
                            var currentDate = new Date();
                            currentData.confirmInformation.readConfirmationDate = currentDate.toLocaleDateString();
                        }
                    });
            }
        }

        function getConfirmInformationBaseOnView() {
            if ($scope.$parent.vm.currentDataPromise) { //documentView
                $scope.$parent.vm.currentDataPromise.then(function (data) {
                    if (data.entityId && !data.confirmInformation) {
                        getConfirmInformation(data);
                    }
                });
            }
            else { //filedView
                if ($scope.$parent.vm.currentData.entityId && !$scope.$parent.vm.currentData.confirmInformation) {
                    getConfirmInformation($scope.$parent.vm.currentData);
                }
            }
        };

        function getTabStateType(tabType) {
            var type = '';
            switch (tabType) {
                case tabStateType.documentTabState:
                    type = tabStateType.documentTabState;
                    break;
                case tabStateType.chapterTabState:
                    type = tabStateType.chapterTabState;
                    break;
                case tabStateType.homeTabState:
                    type = tabStateType.homeTabState;
                    break;
                default:
                    type = tabStateType.documentTabState;
                    break;
            }

            return type;
        };

        function initializeReadingReceiptTab() {
            if (tabStateService.isTabActive(documentTab.readingReceipt)) {
                getConfirmInformationBaseOnView();
            };
        };

        function getConfirmInformation(data) {
            readingConfirmationService.GetConfirmInformation(data.entityId)
                .then(function (response) {
                    data.confirmInformation = response.data;
                });
        };
    };

})();;
(function () {
    'use strict';

    angular.module('handbookApp')
        .controller('DocumentController', documentController);

    documentController.$inject = ['$scope', '$rootScope', '$http', '$stateParams', '$state', '$sce', '$location', '$anchorScroll', '$timeout', '$filter', '$uibModal',
        'broadcastService', 'documentService', 'favoriteService', 'tabStateService', 'anchorService', 'documentContentsSearchService',
        'resizeService', 'localStorageService', 'folderService', 'treeNavigationService', '$q', 'configService', 'browserService'];

    function documentController($scope, $rootScope, $http, $stateParams, $state, $sce, $location, $anchorScroll, $timeout, $filter, $uibModal,
        broadcastService, documentService, favoriteService, tabStateService, anchorService, documentContentsSearchService,
        resizeService, localStorageService, folderService, treeNavigationService, $q, configService, browserService) {

        var ignoreRichText = configService.getBool(HandbookConfiguration.LazyLoadRichText);

        var vm = this;
        var isFieldActive;
        var lastId;
        var urlParams = $location.url().split('/');

        vm.isEmbedUrl = false;

        if (urlParams != null && urlParams.length) {
            vm.isEmbedUrl = urlParams[1] == 'embed';
        }

        vm.currentData = {};
        vm.originalData = {};

        vm.enableExtendedFeedback = configService.getBool(HandbookConfiguration.EnableExtendedFeedback);

        vm.highlights = {
            highlightText: '',
            currentIndex: 0,
            totalFound: 0
        };
        vm.isShowMetadata = configService.getBool(HandbookConfiguration.MetadataEnabled);
        vm.isShowMetatagTab = configService.getBool(HandbookConfiguration.ShowMetatagTab);
        vm.simpleSubscription = configService.getBool(HandbookConfiguration.SimpleSubscription);
        vm.publishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);
        vm.backendIsDb4 = configService.getBool(HandbookConfiguration.BackendIsDb4);
        vm.showDocumentLinkToBackend = configService.getBool(HandbookConfiguration.ShowDocumentLinkToBackend);
        vm.enableDocumentExtention = configService.getBool(HandbookConfiguration.EnableDocumentExtention);
        vm.enableAgree = configService.getBool(HandbookConfiguration.EnabledAgree);
        vm.enableElementsIntegration = ElementsIntegrationConfiguration.ArchiveIntegrationMode != E.ArchiveIntegrationModeTypes.None;

        vm.viewModeList =
            [
                { id: parseInt(E.documentTemplateViewMode.ProcessDependencies), name: globalResources.documentTemplateViewModeName.ProcessDependencies },
                { id: parseInt(E.documentTemplateViewMode.Normal), name: globalResources.documentTemplateViewModeName.Normal },
                { id: parseInt(E.documentTemplateViewMode.Process), name: globalResources.documentTemplateViewModeName.Process },
                { id: parseInt(E.documentTemplateViewMode.RelatedDocuments), name: globalResources.documentTemplateViewModeName.RelatedDocuments },
                { id: parseInt(E.documentTemplateViewMode.InvolvedChapters), name: globalResources.documentTemplateViewModeName.InvolvedChapters },
            ];

        vm.metadataList = [];
        vm.documentId = $stateParams.documentId;
        vm.addFavoriteRequest = handbookRequests.AddFavoriteDocument;
        vm.removeFavoriteRequest = handbookRequests.RemoveFavoriteDocument;
        vm.contentAnchorPrefix = prefix.contentAnchorPrefix;
        vm.processRelationTypes = E.ProcessRelationType;
        vm.showError = false;
        vm.isFullScreen = true;
        vm.heightdocumentcontentidentifier = 0;
        vm.FolderLinks = [];
        vm.menuFields = [];
        vm.urlDocument = window.location.origin + '/document/' + vm.documentId;
        vm.updateFields = updateFields;
        vm.goToDocumentFields = goToDocumentFields;
        vm.removeFromFavorite = removeFromFavorite;
        vm.searchAndHighlightText = searchAndHighlightText;
        vm.navForward = navForward;
        vm.navBackward = navBackward;
        vm.fullScreen = fullScreen;
        vm.selectViewModeChange = selectViewModeChange;
        vm.linkToDocumentManagement = linkToDocumentManagement;
        vm.isFloatTitle = $(window).height() > HandbookConfiguration.DocumentTitleScreenHeight ? true : false;
        vm.getNextSearchResultByEnter = getNextSearchResultByEnter;
        vm.compareDocument = compareDocument;
        vm.registDeviationWithDocument = registDeviationWithDocument;
        vm.hideCompareButton = false;
        vm.showContent = showContent;
        vm.shareFieldLink = shareFieldLink;
        vm.showSidebarFields = showSidebarFields;
        vm.printAgreeFile = printAgreeFile;
        vm.feedbackDocument = feedbackDocument;
        vm.goToDocumentInPublicHandbook = goToDocumentInPublicHandbook;
        vm.openAboutDocument = openAboutDocument;
        vm.addDocumetEmailSubscription = addDocumetEmailSubscription;
        vm.browserType = browserService.detectBrowserWindow();
        vm.BROWSER_TYPE = BrowserType;

        vm.isToggleSidebarFields = true;
        var isIE = detectIE();
        var cursorY;
        document.onmousemove = function (e) {
            cursorY = e.pageY;
        }
        vm.hideSidebarFields = hideSidebarFields;
        vm.agreeFiles = [];
        vm.extendDocumentsGridSetting = [];
        vm.documentNameHadExtended = '';
        vm.showExtendDocument = false;
        vm.totalExtendDocument = 0;
        vm.deviationUrl = HandbookConfiguration.DeviationUrl;
        vm.documentDeviationCategoryLink = HandbookConfiguration.DocumentDeviationCategoryLink;
        vm.enabledDeviation = configService.getBool(HandbookConfiguration.EnabledDeviation);
        vm.publicUrl = HandbookConfiguration.PublicURL;
        vm.isPublishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);
        vm.documentPublishTooltip = HandbookConfiguration.PublicURL && !vm.isPublishedVersion ? globalResources.GoToDocumentInPublicHandbook : globalResources.PublishedToTheInternet;
        vm.copyUserFriendlyPublishedUrlTooltip = globalResources.CopyUserFriendlyPublishedUrl;
        vm.copyUserFriendlyUrlTooltip = globalResources.CopyUserFriendlyUrl;
        vm.documentPublishUrl = HandbookConfiguration.PublicURL + `document/${vm.documentId}`;
        vm.addClass = 'copy-publish-url';
        vm.publishUrlImg = './Content/Images/shared-publish-internet.png'
        vm.documentViewOption = parseInt(HandbookConfiguration.DocumentViewOption);
        vm.searchDocumentInMobile = false;
        vm.toggleSearchInMobile = toggleSearchInMobile;
        vm.scrollDocumentContentToTop = scrollDocumentContentToTop;
        vm.setViewMode = setViewMode;
        vm.showContentanchor = showContentanchor;
        vm.clearAnchorActive = clearAnchorActive;
        initialize();

        function initialize() {
            if (vm.enableDocumentExtention) {
                builExtentDocumentsGridSetting();
            }

            if (angular.element('#handbook-nav:visible').length == 0) {
                documentService.showFullscreen();
                vm.isFullScreen = false;
            }
            fullScreenInit();

            processEmbedUrl();
            //check and resize the view
            resizeService.resizeView();
            //get document info from service
            if (!vm.isEmbedUrl) {
                var currentDocument = documentService.getDocuments();
                if (currentDocument && currentDocument.documentInformation) {
                    vm.isFavoriteNodeSelected = true;
                    buildDocumentObjectFromCurrentDocument(currentDocument);
                    $rootScope.title = globalResources.Handbook + " - " + currentDocument.documentInformation.documentName;

                    runServicesAfterInit();
                }
                else {
                    getDocument();

                }
                folderService.getFolderByVirtualDocumentId($stateParams.documentId).then(function (response) {
                    vm.FolderLinks = response.data;
                });
            } else {
                getDocument();
            }

            treeNavigationService.navigateToItemLocation(true);
            addScroll();
            if (vm.browserType == vm.BROWSER_TYPE.MOBILE) {
                handleScrollInMobile();
            }
        }

        $(window).on('resize', function () {
            vm.browserType = browserService.detectBrowserWindow();
        });

        function toggleSearchInMobile(){
            vm.searchDocumentInMobile = !vm.searchDocumentInMobile; 
        }

        function builExtentDocumentsGridSetting() {
            vm.extendDocumentsGridSetting.push({ id: 'documentIdDisplay', name: globalResources.CommonGridColumns.DocumentId, width: 5, coldefault: true });
            vm.extendDocumentsGridSetting.push({ id: 'documentNameDisplay', name: globalResources.Name, width: 30, coldefault: true });
            vm.extendDocumentsGridSetting.push({ id: 'pathDisplay', name: globalResources.Path, width: 35, coldefault: true });
            vm.extendDocumentsGridSetting.push({ id: 'strCreatedDateFirstVersion', name: globalResources.CreatedDate, width: 10, coldefault: true, type: COLUMN_DATA_TYPES.STRING_DATE});
            vm.extendDocumentsGridSetting.push({ id: 'responsible', name: globalResources.Responsible, width: 20, coldefault: true });
        }

        function loadExtendDocumentsTab() {
            $http.get('/api/Documents/GetExtendDocumentsByDocumentId', { params: { 'documentId': vm.documentId } })
                .success(function (data, status, headers, config) {
                    data = data || [];
                    vm.showExtendDocument = data.length > 0;
                    vm.totalExtendDocument = data.length;
                    vm.extendDocuments = data;
                    vm.extendDocumentNotification = '';

                    let linkTemp = "<a class='link-document-extend' href='{0}' target='_blank'>{1}</a>";
                    let linkDocTemp = "<a href='{0}' target='_blank'>{1}</a>";
                    let urlTemp = '/document/{0}';
                    let urlFolTemp = '/folder/{0}';
                    let count = 0;
                    for (var i = 0; i < vm.extendDocuments.length; i++) {
                        let document = vm.extendDocuments[i];
                        document.documentIdDisplay = String.format(linkDocTemp, String.format(urlTemp, document.documentId), document.documentId);
                        document.documentNameDisplay = String.format(linkDocTemp, String.format(urlTemp, document.documentId), document.documentName);
                        document.pathDisplay = String.format(linkDocTemp, String.format(urlFolTemp, document.folderId), document.path);
                        if (document.isDepartment) {
                            let link = document.documentNameDisplay;
                            vm.extendDocumentNotification += vm.extendDocumentNotification == '' ? link : ', ' + link;
                            document.documentNameDisplay = document.documentNameDisplay + `<span class="fa fa-info-circle extend-document-info-icon ml10" title="${globalResources.ExtensionLocatedInDepartmentFolder}"></span>`;
                            count = count + 1;
                        }
                    }

                    if (vm.extendDocumentNotification != '') {
                        let message = count > 1 ? globalResources.ExtendDocumentNotification : globalResources.ExtendDocumentNotificationForOnePerson;
                        vm.extendDocumentNotification = String.format(message, vm.extendDocumentNotification);
                        $timeout(function () {
                            tabStateService.adjustContentHeightPosition(tabStateType.documentTabState);
                        });
                        
                    }
                });
        }

        function getReadDocuments() {
            var storageObject = localStorageService.getItem(localStorageKeys.readDocuments);
            var readDocuments = [];
            if (storageObject != null) {
                readDocuments = JSON.parse(storageObject);
            }

            var existed = false, offset;
            for (var i = 0; i < readDocuments.length; i++) {
                if (readDocuments[i].id == vm.documentId) {
                    existed = true;
                    offset = i;
                    break;
                }
            }

            if (!existed) {
                readDocuments.push({ id: vm.documentId, approvedDate: vm.currentData.approvedDate });
            } else {
                readDocuments[offset].approvedDate = vm.currentData.approvedDate;
            }
            localStorageService.setItem(localStorageKeys.readDocuments, JSON.stringify(readDocuments));
        }



        function getDocument() {
            if (vm.isShowMetadata && vm.isShowMetatagTab) {
                getMetadataTab();
            }

            var params = {
                params: {
                    'documentId': $stateParams.documentId,
                    'ignoreRichText': ignoreRichText,
                    'hasExtention': vm.enableDocumentExtention,
                    showLoading: true
                }
            };

            vm.currentDataPromise = $http.get(handbookRequests.GetDocumentInformationRequest, params)
                .then(function (result, status, headers, config) {
                    if (result != null) {
                        vm.currentData = result.data;
                        var viewMode = vm.currentData.viewMode;
                        var hash = window.location.hash;

                        if (vm.enableDocumentExtention && DOCUMENT_EXTENDABLE_TYPES.PARENT == vm.currentData.extendable) {
                            loadExtendDocumentsTab();
                        }

                        if (vm.enableDocumentExtention && DOCUMENT_EXTENDABLE_TYPES.CHILD == vm.currentData.extendable) {
                            let href = '/document/' + vm.currentData.documentIdHadExtended;
                            let extendDocumentUrl = String.format("<a class='link-document-extenable' href='{0}' target='_blank'>{1}</a>", href, vm.currentData.documentNameHadExtended);
                            vm.documentNameHadExtended = globalResources.DocumentIsAnExtensionOf + extendDocumentUrl;
                        }

                        if (hash) {
                            vm.currentData.viewMode = 1;

                        }
                        vm.currentData.fieldContents = vm.currentData.fieldContents.filter(function (x) {
                            return x.isVisible;
                        });

                        vm.isFavoriteNodeSelected = true;
                        createTooltipsRelatedDocument(result.data);
                        if (vm.currentData.description) {
                            vm.currentData.description = $sce.trustAsHtml(vm.currentData.description.replace(new RegExp(String.fromCharCode(13) + String.fromCharCode(10), 'g'), '<br/>'));
                        }
                        vm.currentData.nodeType = convertToNodeType(vm.currentData.type);
                        if (vm.currentData.fieldContents != null) {
                            var indexTemp = 0;

                            var richTextRequests = [];

                            vm.currentData.fieldContents.forEach(function (fieldContent) {
                                if (fieldContent.description) {
                                    fieldContent.description = $sce.trustAsHtml(fieldContent.description);
                                }
                                vm.menuFields.push("Id" + fieldContent.fieldId);
                                if (ignoreRichText && fieldContent.fieldType == 6 && fieldContent.fieldContentId) {
                                    var params = {
                                        params: {
                                            id: fieldContent.fieldContentId,
                                            hasExtention: vm.enableDocumentExtention
                                        }
                                    }

                                    var richtextRequest = $http.get('/api/documents/getRichText', params).then(function (response) {
                                        if (response.data && response.data.content) {
                                            fieldContent.content = documentService.changeUrlBackendToFrontend(window.location.origin, response.data.content);
                                            fieldContent.content = $sce.trustAsHtml(`${fieldContent.content} `);
                                            fieldContent.isVisible = true;
                                            fieldContent.fieldsAnchor = [];
                                            var aElement = document.createElement('div');
                                            aElement.innerHTML = response.data.content;
                                            var aTags = aElement.getElementsByTagName('a');
                                            if (aTags) {
                                                for (var i = 0; i < aTags.length; i++) {
                                                    if (aTags[i].text.trim().length) {
                                                        var itemAnchor = {
                                                            value: aTags[i].text,
                                                            id: aTags[i].name,
                                                            name: aTags[i].id
                                                        };
                                                        fieldContent.fieldsAnchor.push(itemAnchor);
                                                    }
                                                }
                                            };
                                        }
                                    });

                                    richTextRequests.push(richtextRequest);

                                } else {
                                    if (fieldContent.content) {
                                        fieldContent.content = documentService.changeUrlBackendToFrontend(window.location.origin, fieldContent.content);
                                        fieldContent.content = $sce.trustAsHtml(`${fieldContent.content} `);
                                    }
                                }

                                fieldContent.indexShow = indexTemp;
                                indexTemp = indexTemp + 1;
                            });

                            if (ignoreRichText) {
                                $q.all(richTextRequests).then(function () {
                                    angular.copy(vm.currentData, vm.originalData);
                                    $timeout(function () {
                                        runServicesAfterInit();
                                        if (hash) {
                                            moveToDefaultField(hash);
                                        } else if (viewMode == 1) openDocumentFields(result.data)
                                    });


                                });
                            }
                            if (vm.currentData.type == 2) {
                                vm.menuFields.unshift("IdLink");
                            }
                            if (vm.currentData.type == 1) {
                                vm.menuFields.unshift("IdFile");

                            }

                            var agree = vm.currentData.agree;
                            if (agree && agree.id && agree.id != 0) {
                                if (agree.searchHistoryId) {
                                    vm.agreeFiles.push({
                                        id: agree.searchHistoryId,
                                        extensionName: agree.searchHistoryFileName.split('.').pop().toUpperCase(),
                                        name: agree.searchHistoryFileName,
                                        fileTypeName: globalResources.SearchHistory,
                                        fileType: 1
                                    });
                                }
                                if (agree.abstractListId) {
                                    vm.agreeFiles.push({
                                        id: agree.abstractListId,
                                        extensionName: agree.abstractListFileName.split('.').pop().toUpperCase(),
                                        name: agree.abstractListFileName,
                                        fileTypeName: globalResources.AbstractList,
                                        fileType: 1
                                    });
                                }
                                if (agree.implementationPlanId) {
                                    vm.agreeFiles.push({
                                        id: agree.implementationPlanId,
                                        extensionName: agree.implementationPlanFileName.split('.').pop().toUpperCase(),
                                        name: agree.implementationPlanFileName,
                                        fileTypeName: globalResources.ImplementationPlan,
                                        fileType: 1
                                    });
                                }
                                if (vm.currentData.knowledgeTypeId == KnowledgeType.allAgreeRequirements) {
                                    vm.agreeFiles.push({
                                        id: vm.currentData.entityId,
                                        extensionName: 'pdf',
                                        name: globalResources.PicoForm,
                                        fileTypeName: globalResources.PicoForm,
                                        fileType: 2
                                    });
                                }
                                if (vm.currentData.knowledgeTypeId == KnowledgeType.allAgreeRequirements
                                    || vm.currentData.knowledgeTypeId == KnowledgeType.shortVersionOfAgreeRequirements) {
                                    vm.agreeFiles.push({
                                        id: vm.currentData.entityId,
                                        extensionName: 'pdf',
                                        name: globalResources.AgreeMethodReport,
                                        fileTypeName: globalResources.AgreeMethodReport,
                                        fileType: 3
                                    });
                                }
                            }

                            if (vm.agreeFiles.length) {
                                vm.menuFields.push("IdAgreeFiles");
                            }

                            if (vm.currentData.relatedAttachments.length) {
                                vm.menuFields.push("Idattachment");
                            }

                            if (vm.currentData.relatedDocuments.length) {
                                vm.menuFields.push("IdrelatedDocument");
                            }
                            vm.updateFields();
                        }

                        if (vm.isShowMetadata && vm.isShowMetatagTab) {
                            vm.currentData.metadatas = angular.copy(vm.metadataList);
                            formatMetadata();
                        }
                        vm.showDocumentLinkToBackend = vm.showDocumentLinkToBackend &&
                            (vm.currentData.hasEditPermission || vm.currentData.hasApprovalPermission);

                        if (!ignoreRichText || !vm.currentData.fieldContents) {
                            runServicesAfterInit();
                        }

                        angular.copy(vm.currentData, vm.originalData);

                        setTimeout(function () { documentService.stickyTitle(); }, 0);
                        setIconForDocument(vm.currentData);
                        getReadDocuments();
                        sendDocumentOpenedEvent();
                        executeDocumentTypeIfNeeded();
                        vm.currentData.urlLink = vm.currentData.url;
                        if (vm.currentData.url != null && vm.currentData.url.length > 3) {
                            if (vm.currentData.url.substring(0, 3) == 'www') {
                                vm.currentData.urlLink = 'http://' + vm.currentData.url;
                            }
                        }

                        documentService.setDocuments(null); // clear service                     
                        $rootScope.title = globalResources.Handbook + " - " + result.data.documentName;

                        vm.isCompare = configService.getBool(HandbookConfiguration.EnableCompare) && vm.currentData.version > 0;
                        if (!vm.isCompare && vm.currentData.extendable == DOCUMENT_EXTENDABLE_TYPES.CHILD) {
                            documentService.checkParentExtensionHasToCompare(vm.currentData.documentId)
                                .then(function (data) {
                                    if (data) {
                                        vm.isCompare = data;
                                    }
                                });
                        }

                        if (vm.currentData.type == E.documentTypes.LinkDocument || vm.currentData.type == E.documentTypes.FileDocument) {
                            vm.hideCompareButton = true;
                        }
                        return vm.currentData;
                    } else {
                        showMessageError(globalResources.NoAccessDocument, status);
                    }
                }).catch(function (result, status, headers, config) {
                    showMessageError(result.data, result.status);
                });
        }


        function setIconForDocument(data) {
            data = data == null ? vm.currentData : data;
            var icon = '';
            switch (data.levelType.toString()) {
                case E.HandbookLevelTypes.Enterprise:
                    icon = paths.DocumentLevelTypeEnterprise;
                    break;
                case E.HandbookLevelTypes.Regional:
                    icon = paths.DocumentLevelTypeRegional;
                    break;
                case E.HandbookLevelTypes.Local:
                    icon = paths.DocumentLevelTypeLocal;
                    break;
                default:
                    icon = paths.DocumentLevelTypeEnterprise;
                    break;
            }
            data.docIcon = icon;
        }

        function showMessageError(message, status) {
            if (!status || status.toString() == '600') {
                vm.errorMessage = globalResources.RequiredPermissionsToReadDocument;
            } else if (status.toString() == '632') {
                vm.errorMessage = globalResources.DocumentDoNotExistOrIsArchived;
            } else if (status.toString() == '633') {
                vm.errorMessage = globalResources.DocumentDoNotExistOrIsArchivedOrNotPublished;
                vm.showDocumentLinkToBackendWhenError = true;
            } else {
                vm.errorMessage = message;
            }
            vm.showError = true;
            vm.isFavoriteNodeSelected = favoriteService.getFavoriteNodeState().isFavorited;
            vm.currentData.documentId = vm.documentId;
            vm.currentData.isFavorite = vm.isFavoriteNodeSelected;

            runErrorServicesAfterInit();
        }

        function getMetadataTab() {
            $http.get(handbookRequests.GetDocumentMetadataRequest, { params: { 'documentId': $stateParams.documentId } })
                .then(function (result) {
                    vm.metadataList = result.data;
                });
        }

        function formatMetadata() {
            if (vm.isShowMetadata && vm.currentData.metadatas && vm.currentData.metadatas.length && vm.isShowMetatagTab) {
                vm.currentData.metadatas.forEach(function (item) {
                    item.nameDisplay = $sce.trustAsHtml(item.registerName + ' - ' + item.registerItemName + ' - ' + item.registerValue);
                });
            }
        }

        function rebindCurrentDocument(currentDocument) {
            vm.isFavoriteNodeSelected = true;
            vm.currentData = angular.copy(currentDocument.documentInformation);
            setIconForDocument(vm.currentData);
            $rootScope.title = globalResources.Handbook + " - " + vm.currentData.documentName;

            if (vm.currentData.description) {
                vm.currentData.description = $sce.trustAsHtml(vm.currentData.description.toString());
            }
            vm.currentData.fieldContents.forEach(function (fieldContent) {
                if (fieldContent.content) {
                    fieldContent.content = $sce.trustAsHtml(fieldContent.content + ' ');
                }
                if (fieldContent.description) {
                    fieldContent.description = $sce.trustAsHtml(fieldContent.description.toString());
                }
            });

            if (vm.isShowMetadata && vm.isShowMetatagTab) {
                formatMetadata();
            }
            angular.copy(vm.currentData, vm.originalData);
            vm.documentId = vm.currentData.documentId;

            runServicesAfterInit();
            setTimeout(function () { documentService.stickyTitle(); }, 0);
            var preview = $location.url().indexOf('preview');
            if (configService.getBool(HandbookConfiguration.ViewDocumentFieldDirectly) && preview == -1) {
                openDocumentFields();
            }
        }

        function updateFields() {
            if (vm.currentData.relatedAttachments && vm.currentData.relatedAttachments.length) {
                vm.currentData.relatedAttachments.forEach(function (x) {
                    x.itemId = x.extraId ? x.extraId : x.itemId;
                });
            }
            var relatedDocumentAll = angular.copy(vm.currentData.relatedDocuments);
            var relatedAttachmentAll = angular.copy(vm.currentData.relatedAttachments);
            var fieldContentsProcess = [];
            var fieldContentsNonProcess = [];

            vm.currentData.isShowTopBoxContent = false;

            for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
                var fieldContent = vm.currentData.fieldContents[i];

                if (checkShowFieldName(fieldContent)) {
                    vm.currentData.isShowTopBoxContent = true;
                    if (fieldContent.relatedAttachments && fieldContent.relatedAttachments.length) {
                        fieldContent.relatedAttachments.forEach(function (x) {
                            x.itemId = x.extraId ? x.extraId : x.itemId;
                        });
                    }

                    if (fieldContent.isProcess) {
                        fieldContentsProcess.push(fieldContent);
                    }
                    else {
                        fieldContentsNonProcess.push(fieldContent);
                    }
                }

                var relatedDocuments = fieldContent.relatedDocuments;
                relatedDocumentAll = relatedDocumentAll.concat(relatedDocuments);

                var relatedAttachments = fieldContent.relatedAttachments;
                relatedAttachmentAll = relatedAttachmentAll.concat(relatedAttachments);

                var relatedImageGroups = groupBy(fieldContent.images, function (item) {
                    return [item.verticalAlign];
                });
                var relatedBottomImages = [];
                var relatedTopImages = [];
                relatedImageGroups.forEach(function (item) {
                    if (item.key == parseInt(E.VerticalAlign.Top)) {
                        relatedTopImages = relatedTopImages.concat(item.value.data);
                    } else {
                        if (item.key == parseInt(E.VerticalAlign.Bottom)) {
                            relatedBottomImages = relatedBottomImages.concat(item.value.data);
                        }
                    }
                });
                fieldContent.relatedTopImages = relatedTopImages;
                fieldContent.relatedBottomImages = relatedBottomImages;
            }

            if (vm.currentData.isProcess) {
                vm.currentData.relatedDocumentAll = relatedDocumentAll;
                vm.currentData.relatedAttachmentAll = relatedAttachmentAll;

                vm.currentData.fieldContentsProcess = fieldContentsProcess;
                vm.currentData.fieldContentsNonProcess = fieldContentsNonProcess;

                var relatedDocumentGroups = groupBy(relatedDocumentAll, function (item) {
                    return [item.folderId];
                });

                vm.currentData.relatedDocumentGroups = [];
                relatedDocumentGroups.forEach(function (item) {
                    var relatedDocumentGroup = {};
                    relatedDocumentGroup.id = item.key;
                    relatedDocumentGroup.name = item.value.data[0].folderName;
                    relatedDocumentGroup.relatedDocuments = item.value.data;
                    vm.currentData.relatedDocumentGroups.push(relatedDocumentGroup);
                });

                relatedDocumentForDependencies(relatedDocumentAll);
                relatedAttachmentForDependencies(relatedAttachmentAll);
                attachRelatedItemsFieldsForDependencies();
            }
        }

        $scope.$on(broadcastType.favoriteUpdate, function (e, target) {
            if (vm.originalData) {
                vm.originalData.isFavorite = target;
            }
            if (vm.currentData) {
                vm.currentData.isFavorite = target;
            }
        });

        function goToDocumentFields(fieldId, hash) {
            isFieldActive = false;
            clearActive();
            vm.currentData.viewMode = 1;
            setTimeout(function () {
                var field = vm.currentData.fieldContents.find(function (x) {
                    return x.fieldId == fieldId;
                });
                if (field) showContent(fieldId, field);
                runServicesAfterInit();
            }, 1000)
            addScroll();

        }

        function copyFormatted(html) {
            // Create an iframe (isolated container) for the HTML
            var container = document.createElement('div');
            container.innerHTML = html;

            // Hide element
            container.style.position = 'fixed';
            container.style.pointerEvents = 'none';
            container.style.opacity = 0;

            // Mount the iframe to the DOM to make `contentWindow` available
            document.body.appendChild(container);

            // Copy to clipboard
            window.getSelection().removeAllRanges();

            var range = document.createRange();
            range.selectNode(container);
            window.getSelection().addRange(range);

            //copy selected dom
            document.execCommand('copy');

            // Remove the iframe
            document.body.removeChild(container);
        }

        function shareFieldLink(fieldId, fieldName) {
            if (vm.fieldShare != fieldId) {
                vm.fieldShare = fieldId;
                angular.element('#fieldShare' + fieldId).addClass('opacity-0-5');
                var link = window.location.href.split('#')[0] + '#p' + fieldId;
                var shareLink = '<a href="' + link + '" target="_blank" style="font-size: 16px; text-decoration: underline; color: blue">' + vm.currentData.documentName + ' - ' + fieldName + '</a>';
                $('#html-container').text(shareLink);
                var htmlEditor = CodeMirror.fromTextArea(document.getElementById('html-container'), {
                    mode: 'text/html'
                });
                var cm = $('.CodeMirror')[0].CodeMirror;
                $(cm.getWrapperElement()).hide();
                copyFormatted(htmlEditor.getValue());
                $timeout(function () {
                    vm.fieldShare = 0;
                    angular.element('#fieldShare' + fieldId).removeClass('opacity-0-5');
                }, 5000, false);
            }
        }

        function openDocumentFields(data) {
            for (var i = 0; i < data.fieldContents.length; i++) {
                var fieldContent = data.fieldContents[i];
                if (fieldContent.showOnPDA) {
                    showContent(fieldContent.fieldId, fieldContent);
                    return;
                }
            };
            //in case there is no PDA of documentType
            if (data.defaultField != null) {
                //get all visible field (field has contents)
                var allVisibleField = $filter('filter')(data.fieldContents, { isVisible: true }, true);
                if (allVisibleField.length != 0) {
                    //get default field
                    var field = $filter('filter')(allVisibleField, { fieldId: data.defaultField }, true);
                    var fieldId = allVisibleField[0].fieldId;
                    if (field.length) {
                        fieldId = data.defaultField;
                        showContent(data.defaultField, field[0]);
                    } else if (data.fieldContents[0]) showContent(data.fieldContents[0].fieldId, data.fieldContents[0]);
                }
            } else if (data.fieldContents[0]) showContent(data.fieldContents[0].fieldId, data.fieldContents[0]);

        }

        function scrollAffectFieldSelected() {
            var
                topMenuDocument = $("#document-top-menu-identifier"),
                topMenuDocumentHeight = topMenuDocument.outerHeight(),
                idCurrent = '';

            var mousePosition = getMousePosition();

            if (typeof mousePosition == 'undefined') {
                return;
            }
            var d;
            for (var i = 0; i < vm.menuFields.length; i++) {
                d = i;
                var menu = "#" + vm.menuFields[i];
                var top = $(menu).offset().top;
                if (mousePosition < top) {
                    idCurrent = i == 0 ? vm.menuFields[0] : vm.menuFields[i - 1];
                    break;
                }
            }
            if (idCurrent == '') {
                idCurrent = vm.menuFields[d];
            }


            if ((lastId !== idCurrent) && (idCurrent != '')) {
                lastId = idCurrent;
                angular.forEach(vm.currentData.fieldContents, function (fieldContent) {
                    fieldContent.activeField = '';
                });
                clearActive();
                switch (lastId) {
                    case 'IdLink':
                        $scope.$apply(function () { vm.activeLink = true; });
                    case 'IdFile':
                        $scope.$apply(function () { vm.activeFile = true; });
                    case 'Idattachment':
                        $scope.$apply(function () { vm.activeAttachments = true; });
                        break;
                    case 'IdrelatedDocument':
                        $scope.$apply(function () { vm.activeRelatedDocuments = true; });
                        break;
                    case 'IdAgreeFiles':
                        $scope.$apply(function () { vm.activeAgreeFiles = true; });
                        break;
                    default:
                        var fieldId = lastId.substring(2);
                        for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
                            if (vm.currentData.fieldContents[i].fieldId == parseInt(fieldId)) {
                                $scope.$apply(function () {
                                    vm.currentData.fieldContents[i].activeField = 'active';
                                });
                                break;
                            }
                        }
                }
            }
        }

        function addScroll() {
            setTimeout(function () {
                var content = $(".document-detail");
                if (content) {
                    content.scroll(function () {
                        if (!isFieldActive) {
                            scrollAffectFieldSelected();
                        }
                    });
                }
            })
        }

        function setStickyTitle() {
            setTimeout(function () { stickyTitle(); }, 0);
        }

        function stickyTitle(height) {
            var title = document.querySelector('#documentTitle');
            var titlePosition = title.getBoundingClientRect();
            var content = document.querySelector('#document-content-identifier');
            if (!content) {
                return;
            }

            var contentPosition = content.getBoundingClientRect();
            var placeholder = $("#placeholderTitleId")
            if (placeholder.length > 0) {
                placeholder.remove();
            }
            placeholder = document.createElement('div');
            placeholder.id = "placeholderTitleId";
            placeholder.style.height = titlePosition.height + 'px';
            var isAdded = false;
            var heightToFloat = 0, currentPosition = 0;
            heightToFloat = contentPosition.top + 50;
            var heightScroll = height ? height : $('#document-content-identifier').height();

            if ($(window).height() > HandbookConfiguration.DocumentTitleScreenHeight) {
                removeStickyTitle();
                $('#document-content-identifier').scroll(function () {
                    var scrollTop = $('#document-content-identifier').scrollTop();
                    var isfullScreen = $('#document-content-identifier').hasClass('fullScreen-height');
                    currentPosition = isfullScreen ? scrollTop : contentPosition.top + scrollTop;
                    if (currentPosition >= heightToFloat && !isAdded) {
                        title.classList.add('sticky');
                        document.querySelector('#document-content-identifier').classList.add('scrolling');

                        title.parentNode.insertBefore(placeholder, title);
                        isAdded = true;
                        var contentWidth = $('#document-content-identifier').width() + 10;
                        if (!isfullScreen) {
                            $('#documentTitle').css('top', contentPosition.top);
                            $('#documentTitle').css('width', contentWidth);
                            $('#documentTitle').css('background-color', 'white');
                        } else {
                            $('#documentTitle').css('width', contentWidth);
                            $('#documentTitle').css('background-color', 'white');
                        }
                        heightScroll = !isfullScreen ? heightScroll : screen.availHeight - 100;
                        $('#document-content-identifier').css('margin-top', '85px');
                        $('#document-content-identifier').css('height', heightScroll - 85);
                    } else if (currentPosition < heightToFloat && isAdded) {
                        title.classList.remove('sticky');
                        document.querySelector('#document-content-identifier').classList.remove('scrolling');

                        $('#documentTitle').css('top', '');
                        $('#documentTitle').css('width', '');
                        $('#documentTitle').css('background-color', '');
                        $('#documentTitle').css('margin-left', '');
                        title.parentNode.removeChild(placeholder);
                        isAdded = false;
                        $('#document-content-identifier').css('margin-top', '0px');
                        $('#document-content-identifier').css('height', heightScroll);
                    } else {
                        //$('#document-content-identifier').css('height', heightScroll);
                    }
                    if (!isFieldActive) {
                        scrollAffectFieldSelected();
                    }

                });
            }
            else {
                $('#document-content-identifier').scroll(function () {
                    var isfullScreen = $('#document-content-identifier').hasClass('fullScreen-height');
                    currentPosition = isfullScreen ? $('#document-content-identifier').scrollTop() : contentPosition.top + $('#document-content-identifier').scrollTop();
                    if (!isFieldActive) {
                        scrollAffectFieldSelected();
                    }
                });
            }
        }

        function runInitforIE(height) {
            if ($(window).height() > HandbookConfiguration.DocumentTitleScreenHeight) {
                var title = document.querySelector('#documentTitle');
                var titlePosition = title.getBoundingClientRect();
                var content = document.querySelector('#document-content-identifier');
                var contentPosition = content.getBoundingClientRect();
                var placeholder = $("#placeholderTitleId")
                if (placeholder.length > 0) {
                    placeholder.remove();
                }
                placeholder = document.createElement('div');
                placeholder.id = "placeholderTitleId";
                var heightToFloat = 0, currentPosition = 0;
                heightToFloat = contentPosition.top + 50;
                var heightScroll = height ? height : $('#document-content-identifier').height();
                var scrollTop = $('#document-content-identifier').scrollTop();
                var isfullScreen = $('#document-content-identifier').hasClass('fullScreen-height');
                currentPosition = isfullScreen ? scrollTop : contentPosition.top + scrollTop;
                if (currentPosition >= heightToFloat) {
                    title.classList.add('sticky');
                    document.querySelector('#document-content-identifier').classList.add('scrolling');

                    title.parentNode.insertBefore(placeholder, title);
                    var contentWidth = $('#document-content-identifier').width() + 10;
                    if (!isfullScreen) {
                        $('#documentTitle').css('top', contentPosition.top);
                        $('#documentTitle').css('width', contentWidth);
                        $('#documentTitle').css('background-color', 'white');
                    } else {
                        $('#documentTitle').css('width', contentWidth);
                        $('#documentTitle').css('background-color', 'white');
                    }
                    heightScroll = !isfullScreen ? heightScroll : screen.availHeight - 100;
                    $('#document-content-identifier').css('margin-top', '90px');
                    $('#document-content-identifier').css('height', heightScroll - 90);
                }
            }
        }

        function redirectGoToDocumentFields(fieldId) {
            if (user.fromState && user.fromState.name == 'documentfields'
                && user.fromParams && user.fromParams.documentId == vm.documentId) {
                window.history.go(-1);
            } else {
                var hash = window.location.hash;
                goToDocumentFields(fieldId, hash);
            }
        }

        $rootScope.$on('$stateChangeStart', function (e, toState, toParams, fromState, fromParams) {
            user.fromState = fromState;
            user.fromParams = fromParams;
        });

        function removeFromFavorite() {
            var requestUrl = vm.removeFavoriteRequest + '/' + vm.documentId;
            $http.post(requestUrl)
                .then(function () {
                    var target = {
                        data: {
                            id: vm.documentId,
                            isDocument: true
                        },
                        requestType: requestType.removeRequest
                    };
                    broadcastService(broadcastType.favoriteTarget, target);
                });
        }

        function searchAndHighlightText() {
            highlightTextInContent();
            documentContentsSearchService.searchAndHighlightText(vm.highlights);
        }

        function navForward() {
            documentContentsSearchService.navForward(vm.highlights);
        }

        function navBackward() {
            documentContentsSearchService.navBackward(vm.highlights);
        }

        function checkShowFieldName(fieldContent) {
            if (fieldContent.fieldName != '' && fieldContent.fieldName != undefined && fieldContent.isVisible && !fieldContent.isHideByBooklet) {
                return true;
            }
            return false;
        }

        function convertToNodeType(documentType) {
            switch (documentType.toString()) {
                case E.documentTypes.Document:
                    return E.nodeTypes.Document;
                case E.documentTypes.LinkDocument:
                    return E.nodeTypes.LinkDocument;
                case E.documentTypes.FileDocument:
                    return E.nodeTypes.FileDocument;
                case E.documentTypes.ShortcutDocument:
                    return E.nodeTypes.ShortcutDocument;
            }
        }

        function selectViewModeChange() {        
            history.replaceState("", document.title, window.location.pathname
                + window.location.search);
            setTimeout(function () {
                if (vm.currentData.fieldContents[0]);
                showContent(vm.currentData.fieldContents[0].fieldId, vm.currentData.fieldContents[0]);
                runServicesAfterInit();

                // change height content of document
                var mainBody = angular.element(".main-container_body").height();
                var docContent = angular.element("#content-tab").height();

                angular.element('#document-content-identifier').css({
                    height: (mainBody - docContent - 122)
                });

            }, 500)
            addScroll();
        }

        function runErrorServicesAfterInit() {
            tabStateService.closeOpenedTabIfNoPrivilege(tabStateType.documentTabState);
        }

        function scrollToAnchorIfExists() {
            var hash = $location.hash();
            if (hash != '') {
                $anchorScroll();
            }
        }

        function updateLocalAnchors() {
            var domContent = angular.element('div#document-content-identifier');
            anchorService.updateLocalAnchors(domContent);
        }

        function highlightTextInContent() {
            if (vm.currentData.fieldContents != undefined) {
                var viewMode = angular.copy(vm.currentData.viewMode);
                angular.copy(vm.originalData, vm.currentData);
                vm.currentData.viewMode = viewMode;
                vm.currentData.fieldContents.forEach(function (fieldContent) {
                    fieldContent.content = documentContentsSearchService.searchAndHighlight(fieldContent.content, vm.highlights.highlightText);
                    fieldContent.description = $sce.trustAsHtml(fieldContent.description.toString());
                });
            }
        }

        function relatedDocumentForDependencies(relatedDocumentAll) {
            var relatedDocumentGroups = groupBy(relatedDocumentAll, function (item) {
                return [item.processRelationType];
            });
            var relatedDocumentManagements = [];
            var relatedDocumentResources = [];
            relatedDocumentGroups.forEach(function (item) {
                if (item.key == parseInt(vm.processRelationTypes.Management)) {
                    relatedDocumentManagements = relatedDocumentManagements.concat(item.value.data);
                } else {
                    if (item.key == parseInt(vm.processRelationTypes.Resources)) {
                        relatedDocumentResources = relatedDocumentResources.concat(item.value.data);
                    }
                }
            });

            vm.currentData.relatedDocumentManagement = relatedDocumentManagements;
            vm.currentData.relatedDocumentResources = relatedDocumentResources;
        }

        function relatedAttachmentForDependencies(relatedAttachmentAll) {
            var relatedAttachmentGroups = groupBy(relatedAttachmentAll, function (item) {
                return [item.processRelationType];
            });

            var relatedAttachmentManagements = [];
            var relatedAttachmentResources = [];
            relatedAttachmentGroups.forEach(function (item) {
                if (item.key == parseInt(vm.processRelationTypes.Management)) {
                    relatedAttachmentManagements = relatedAttachmentManagements.concat(item.value.data);
                } else {
                    if (item.key == parseInt(vm.processRelationTypes.Resources)) {
                        relatedAttachmentResources = relatedAttachmentResources.concat(item.value.data);
                    }
                }
            });
            vm.currentData.relatedAttachmentManagement = relatedAttachmentManagements;
            vm.currentData.relatedAttachmentResources = relatedAttachmentResources;
        }

        function attachRelatedItemsFieldsForDependencies() {
            vm.currentData.fieldContentsProcess.forEach(function (field) {
                var relatedDocumetFieldGroups = groupBy(field.relatedDocuments, function (item) {
                    return [item.processRelationType];
                });
                var relatedDocumentInputValues = [];
                var relatedDocumentOutputValue = [];
                relatedDocumetFieldGroups.forEach(function (item) {
                    if (item.key == parseInt(vm.processRelationTypes.InputOrInputValues)) {
                        relatedDocumentInputValues = relatedDocumentInputValues.concat(item.value.data);
                    } else {
                        if (item.key == parseInt(vm.processRelationTypes.OutputOrOutputValues)) {
                            relatedDocumentOutputValue = relatedDocumentOutputValue.concat(item.value.data);
                        }
                    }
                });
                field.relatedDocumentInputValues = relatedDocumentInputValues;
                field.relatedDocumentOutputValue = relatedDocumentOutputValue;

                var relatedAttachmentFieldGroups = groupBy(field.relatedAttachments, function (item) {
                    return [item.processRelationType];
                });
                var relatedAttachmentInputValues = [];
                var relatedAttachmentOutputValue = [];
                relatedAttachmentFieldGroups.forEach(function (item) {
                    if (item.key == parseInt(vm.processRelationTypes.InputOrInputValues)) {
                        relatedAttachmentInputValues = relatedAttachmentInputValues.concat(item.value.data);
                    } else {
                        if (item.key == parseInt(vm.processRelationTypes.OutputOrOutputValues)) {
                            relatedAttachmentOutputValue = relatedAttachmentOutputValue.concat(item.value.data);
                        }
                    }
                });
                field.relatedAttachmentInputValues = relatedAttachmentInputValues;
                field.relatedAttachmentOutputValue = relatedAttachmentOutputValue;
            });
        }

        function sendDocumentOpenedEvent() {
            var target = {
                id: vm.currentData.documentId,
                name: vm.currentData.documentName,
                type: vm.currentData.nodeType,
                levelType: vm.currentData.levelType,
                defaultFieldView: vm.currentData.defaultFieldView
            };
            broadcastService(broadcastType.documentOpenedTarget, target);
        }

        function showSidebarFields() {
            vm.isToggleSidebarFields = true;
        }

        function hideSidebarFields() {
            vm.isToggleSidebarFields = false;
        }

        function executeDocumentTypeIfNeeded() {
            if (vm.currentData.type == E.documentTypes.LinkDocument) {
                openUrlDocument();
            }

            if (vm.currentData.type == E.documentTypes.FileDocument) {
                openFileDocument();
            }
        }

        function openUrlDocument() {
            var urlLink = vm.currentData.url;
            if (vm.currentData.url != null && vm.currentData.url.length > 3) {
                if (vm.currentData.url.substring(0, 3) == 'www') {
                    urlLink = 'http://' + vm.currentData.url;
                }
            }
            window.open(urlLink, '_blank');
        }

        function runServicesAfterInit() {
            updateLocalAnchors();
        }

        function openFileDocument() {
            window.open(handbookRequests.GetFileDocumentRequest + vm.currentData.entityId, '_blank');
        }

        function compareDocument() {
            window.open(String.format('/document/{0}/compareWithEarlierVersion', vm.currentData.documentId), '_blank');
        }

        function registDeviationWithDocument() {
            window.open(vm.deviationUrl + vm.documentDeviationCategoryLink + '?documentRelatedId=' + vm.currentData.documentId, '_blank');
        }

        function fullScreen() {
            if (vm.isFullScreen) {
                documentService.showFullscreen();
            } else {
                documentService.showNormal();
                tabStateService.adjustContentHeightPosition(tabStateType.documentTabState);
                $('#document-content-identifier').css('margin-top', '0px');
            }
            vm.isFullScreen = !vm.isFullScreen;
            setTimeout(function () {
                var height = $('#document-content-identifier').height();
                stickyTitle(height);
                if (isIE) {
                    runInitforIE(height);
                }
            }, 500);
        }

        function linkToDocumentManagement() {
            var backendUrl = HandbookConfiguration.BackendURL;
            var lastChar = backendUrl.charAt(backendUrl.length - 1);
            var commonAdd = lastChar == '/' ? '' : '/';
            if (vm.backendIsDb4) {
                var url = backendUrl + '&documentId=' + vm.documentId;
                url = url.replace('gk=2', 'gk=1');
                window.open(url, '_blank');
            } else {
                window.open(backendUrl + commonAdd + 'document/' + vm.documentId, '_blank');
            }
        }

        function getNextSearchResultByEnter(keyEvent) {
            if (keyEvent.which == 13) {
                navForward();
            }
        }

        $scope.$on(broadcastType.linkToDocumentManagement, function (e, target) {
            linkToDocumentManagement();
        });

        $scope.$on(broadcastType.toggleDocumentFullscreen, function (e, target) {
            fullScreen();
        });

        function fullScreenInit() {
            if (angular.element('#handbook-nav:visible').length == 0) {
                documentService.showFullscreen();
                vm.isFullScreen = false;
            } else {
                documentService.showNormal();
                vm.isFullScreen = true;
            }
        }

        function processEmbedUrl() {
            if (vm.isEmbedUrl) {
                if (vm.typeHideHeader) {
                    angular.element('#documentHeader1Container').hide();
                    angular.element('#fieldTitle').hide();
                }
            }
        }

        function moveToDefaultField(hash) {
            var hashTemp = hash.split('#p');
            if (hashTemp.length < 1) {
                var elmnt = document.getElementById(hash.split('#')[1]);
                if (elmnt) elmnt.scrollIntoView();
                return;
            }

            var field = vm.currentData.fieldContents.find(function (x) {
                return x.fieldId == hashTemp[1];
            });
            if (field) {

                showContent(hashTemp[1], field)

            } else {
                var elmnt = document.getElementById(hash.split('#')[1]);
                if (elmnt) elmnt.scrollIntoView();
            }

        }

        function clearActive() {
            vm.activeRelatedDocuments = false;
            vm.activeAttachments = false;
            vm.activeLink = false;
            vm.activeFile = false;
            vm.activeAgreeFiles = false;

            for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
                vm.currentData.fieldContents[i].activeField = '';
            }
        };

        function showContent(id, fieldContent) {
            isFieldActive = true;
            animationChangeBackgroundColor(id);
            clearActive();
            clearAnchorActive();
            if (fieldContent) {
                fieldContent.activeField = 'active';
            } else {
                if (String(id).indexOf('IdrelatedDocument') > -1)
                    vm.activeRelatedDocuments = true;
                else if (String(id).indexOf('Idattachment') > -1)
                    vm.activeAttachments = true;
                else if (String(id).indexOf('IdLink') > -1)
                    vm.activeLink = true;
                else if (String(id).indexOf('IdAgreeFildes') > -1) {
                    vm.activeAgreeFiles = true;
                }
                else
                    vm.activeFile = true;
            }

            setTimeout(function () {
                isFieldActive = false;
            }, 2000);
        };


        function showContentanchor(id, fieldContent, itemAnchor) {
            isFieldActive = true;
            clearActive();
            clearAnchorActive();
            if (fieldContent) {
                fieldContent.activeField = 'active';
                itemAnchor.activeField = 'active';
                let e = document.getElementById(itemAnchor.id);
                e.className += " activeAnchor";
                e.scrollIntoView({
                    block: 'start',
                    behavior: 'smooth',
                    inline: 'start'
                });
            } else {
                if (String(id).indexOf('IdrelatedDocument') > -1)
                    vm.activeRelatedDocuments = true;
                else if (String(id).indexOf('Idattachment') > -1)
                    vm.activeAttachments = true;
                else if (String(id).indexOf('IdLink') > -1)
                    vm.activeLink = true;
                else if (String(id).indexOf('IdAgreeFildes') > -1) {
                    vm.activeAgreeFiles = true;
                }
                else
                    vm.activeFile = true;
            }
            
            setTimeout(function () {
                isFieldActive = false;
            }, 2000);
        };

        function clearAnchorActive() {
            vm.currentData.fieldContents.forEach((content) => {
                let anchors = content.fieldsAnchor;
                if (anchors) {
                    anchors = anchors.filter((x) => x.id != "");
                    if (anchors) {
                        anchors.forEach((anchor) => {
                            anchor.activeField = '';
                            let e = document.getElementById(anchor.id);
                            e.className -= " activeAnchor";
                        });
                    }
                }
            });
        };

        function getMousePosition() {
            return cursorY
        }

        function removeStickyTitle() {
            var title = document.querySelector('#documentTitle');
            title.classList.remove('sticky');
            $('#documentTitle').css('top', '');
            $('#documentTitle').css('width', '');
            $('#documentTitle').css('background-color', '');
            $('#documentTitle').css('margin-left', '');
            var placeholder = document.querySelector('#placeholderTitleId');
            if (placeholder != null) {
                title.parentNode.removeChild(placeholder);
            }
            document.querySelector('#document-content-identifier').classList.remove('scrolling');
            $('#document-content-identifier').unbind('scroll');
        }

        function animationChangeBackgroundColor(id) {
            id = String(id);
            var indexHash = id.indexOf('#');
            if (indexHash > 0) {
                id = id.substr(0, indexHash);
            }
            var hash = '#Id' + id;
            var elementId = '#Id' + id;
            if (id.indexOf('IdrelatedDocument') > -1 || id.indexOf('IdLink') > -1 || id.indexOf('IdFile') > -1 || id.indexOf('Idattachment') > -1
                || id.indexOf('IdAgreeFiles') > -1) {
                hash = '#' + id;
                elementId = '#' + id;
            }
            var $parentDiv = $('.document-detail');
            if ($(hash).position()) {
                $parentDiv.animate({ scrollTop: $(hash).position().top }, 'slow');
            }
            var $element = $(elementId);
            if ($element) {

                $element.animate({ backgroundColor: '#D7D7D7' }, 1500);
                $timeout(function () {
                    $element.css("background-color", "");
                }, 2000);
            }
        }

        function printAgreeFile(type) {
            if (type == 2) {
                window.open(String.format(handbookRequests.PrintPicoFormPdfRequest, vm.currentData.documentId, false), '_blank');
                return;
            }
            if (vm.currentData.knowledgeTypeId == KnowledgeType.shortVersionOfAgreeRequirements) {
                window.open(String.format(handbookRequests.PrintAgreeMethodReportShortVersionRequest, vm.currentData.documentId, false), '_blank');
                return;
            }
            window.open(String.format(handbookRequests.PrintAgreeMethodReportFullVersionRequest, vm.currentData.documentId, false), '_blank');
        }

        function feedbackDocument(positive) {
            var modalInstance = $uibModal.open({
                templateUrl: paths.FeedbackModalView,
                controller: controllers.feedbackController,
                size: 'lg',
                backdrop: 'static',
                resolve: {
                    model: function () {
                        return {
                            entityId: vm.currentData.entityId,
                            positive: positive
                        };
                    }
                }
            });
        }

        function goToDocumentInPublicHandbook(documentId) {
            if (HandbookConfiguration.PublicURL && !vm.isPublishedVersion) {
                window.open(vm.documentPublishUrl, '_blank');
            }
        }

        function openAboutDocument() {
            var modalInstance = $uibModal.open({
                templateUrl: '/app/components/document/aboutDocumentModal.html',
                controller: 'AboutDocumentModalController as vm',
                size: 'lg',
                backdrop: 'static',
                resolve: {
                    model: function () {
                        return {
                            documentData: vm.currentData,
                            publishedVersion: vm.publishedVersion,
                            folderLinks: vm.FolderLinks,
                            enableElementsIntegration: vm.enableElementsIntegration,
                        };
                    }
                }
            });
        }

        function handleScrollInMobile() {
            setTimeout(function () {
                angular.element(document.querySelector('#documentDetailContainer')).bind('scroll', function () {
                    const contentWithLayoutTop = $('#topmenuMobile').position().top;
                    const topmenuMobileBottom = $('#documentHeader1Container').position().top + $('#documentHeader1Container').height();
                    if (contentWithLayoutTop < topmenuMobileBottom) {
                        angular.element('#documentHeader1Container').addClass('shadow-effect');
                        angular.element('#goHeadButton').removeClass('hide');
                    }
                    else {
                        angular.element('#documentHeader1Container').removeClass('shadow-effect');
                        angular.element('#goHeadButton').addClass('hide');
                    }
                })
            }, 0)
        }

        function scrollDocumentContentToTop() {
            var hash = '#topmenuMobile';
            var $parentDiv = $('.document-detail');
            if ($(hash).position()) {
                $parentDiv.animate({ scrollTop: $(hash).position().top }, 'slow');
                angular.element('#goHeadButton').addClass('hide');
            }
            
        }

        function addDocumetEmailSubscription() {
            var requestUrl = handbookRequests.AddEmailSubscriptionDocument + '/' + vm.currentData.documentId;
            $http.post(requestUrl)
                .then(function () {
                    vm.currentData.isEmailSubscribe = !vm.currentData.isEmailSubscribe;
                });
        };

        function setViewMode(viewMode) {
            vm.currentData.viewMode = viewMode;
            selectViewModeChange();
        }
    }

})();;

(function () {
	'use strict';

	angular.module('hearingFeedbackModule', [])
		.controller('HearingFeedbackController', HearingFeedbackController);

	HearingFeedbackController.$inject = ['$scope', '$http', '$stateParams', '$state', '$sce', '$location', '$anchorScroll', '$timeout', '$uibModal', '$filter',
		'broadcastService', 'documentService', 'tabStateService', 'anchorService', 'documentContentsSearchService', 'resizeService', 'npDialog', 'folderService', 'configService'];

	function HearingFeedbackController($scope, $http, $stateParams, $state, $sce, $location, $anchorScroll, $timeout, $uibModal, $filter,
		broadcastService, documentService, tabStateService, anchorService, documentContentsSearchService, resizeService, npDialog, folderService, configService) {

		var vm = this;
		vm.translation = globalResources;


		vm.currentData = {};
		vm.originalData = {};
		vm.isMyAssessment = false;
		vm.hearing = {};
		vm.commentDocuments = [];
		vm.preCommentDocuments = [];
		vm.preHearingMembers = [];

		vm.loginUserName = user.fullName;
		vm.loginUserId = user.userId;
		vm.responseFlag = 0;
		vm.documentTypes = E.documentTypes;

		vm.publishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);

		vm.hearingCommentAfterResponse = configService.getBool(HandbookConfiguration.HearingCommentAfterResponse);

		vm.highlights = {
			highlightText: '',
			currentIndex: 0,
			totalFound: 0
		};

		vm.userLoginPublishComment = [];
		vm.userLoginDraftComment = [];

		vm.viewModeList =
			[
				{ id: parseInt(E.documentTemplateViewMode.ProcessDependencies), name: globalResources.documentTemplateViewModeName.ProcessDependencies },
				{ id: parseInt(E.documentTemplateViewMode.Normal), name: globalResources.documentTemplateViewModeName.Normal },
				{ id: parseInt(E.documentTemplateViewMode.Process), name: globalResources.documentTemplateViewModeName.Process },
				{ id: parseInt(E.documentTemplateViewMode.RelatedDocuments), name: globalResources.documentTemplateViewModeName.RelatedDocuments },
				{ id: parseInt(E.documentTemplateViewMode.InvolvedChapters), name: globalResources.documentTemplateViewModeName.InvolvedChapters },
			];

		vm.hearings = [];
		vm.closeHearingGridSetting = [];
		vm.hearingMemberGridSetting = [];
		vm.preHearingMembersGridSetting = [];
		vm.preHearingMembersActiveGridSetting = [];
		vm.getNextSearchResultByEnter = getNextSearchResultByEnter;

		vm.columnNotRemove = 'fullName';
		function builHearingGridSetting() {
			vm.closeHearingGridSetting.push({ id: 'fullName', name: globalResources.Name, width: 35, coldefault: true });
			vm.closeHearingGridSetting.push({ id: 'countComment', name: globalResources.NumberOfComments, width: 15, coldefault: true });
			vm.closeHearingGridSetting.push({ id: 'response', name: globalResources.Assessment, width: 15, coldefault: true });
			vm.closeHearingGridSetting.push({ id: 'reason', name: globalResources.Appreciation, width: 35, coldefault: true });
		}
		function builHearingMemberGridSetting() {
			vm.hearingMemberGridSetting.push({ id: 'fullName', name: globalResources.Name, width: 70, coldefault: true });
			vm.hearingMemberGridSetting.push({ id: 'response', name: globalResources.Assessment, width: 30, coldefault: true });
		}

		function builPreHearingMembersGridSetting() {
			vm.preHearingMembersGridSetting.push({ id: 'fullName', name: globalResources.Name, width: 35, coldefault: true });
			vm.preHearingMembersGridSetting.push({ id: 'countComment', name: globalResources.NumberOfComments, width: 15, coldefault: true });
			vm.preHearingMembersGridSetting.push({ id: 'response', name: globalResources.Assessment, width: 15, coldefault: true });
			vm.preHearingMembersGridSetting.push({ id: 'reason', name: globalResources.Appreciation, width: 35, coldefault: true });
		}
		function builPreHearingMembersActiveGridSetting() {
			vm.preHearingMembersActiveGridSetting.push({ id: 'fullName', name: globalResources.Name, width: 70, coldefault: true });
			vm.preHearingMembersActiveGridSetting.push({ id: 'response', name: globalResources.Assessment, width: 30, coldefault: true });
		}

		vm.documentId = $stateParams.documentId;
		vm.contentAnchorPrefix = prefix.contentAnchorPrefix;
		vm.processRelationTypes = E.ProcessRelationType;
		vm.showError = false;
		vm.isFullScreen = true;
		vm.FolderLinks = [];

		vm.urlDocument = window.location.origin + '/document/' + vm.documentId;
		vm.updateFields = updateFields;
		vm.searchAndHighlightText = searchAndHighlightText;
		vm.navForward = navForward;
		vm.navBackward = navBackward;
		vm.fullScreen = fullScreen;
		vm.saveCommentDocument = saveCommentDocument;
		vm.saveCommentField = saveCommentField;
		vm.editCommentDocument = editCommentDocument;
		vm.editCommentField = editCommentField;
		vm.deleteCommentDocument = deleteCommentDocument;
		vm.deleteCommentField = deleteCommentField;
		vm.focusItem = focusItem;
		vm.postHearingResponse = postHearingResponse;
		vm.closeHearingFeedback = closeHearingFeedback;
		vm.activeTab = activeTab;
		vm.printPDF = printPDF;
		vm.openFileDocument = openFileDocument;
		vm.editCommentDraf = editCommentDraf;
		vm.addPerson = addPerson;
		vm.publishDocumentComment = publishDocumentComment;
		vm.publishFieldComment = publishFieldComment;
		vm.goToDocumentFields = goToDocumentFields;
		vm.openCompareDocument = openCompareDocument;
		vm.onTabSelectedDocument = onTabSelectedDocument;

		initialize();

		function initialize() {
			builHearingGridSetting();
			builHearingMemberGridSetting();
			builPreHearingMembersGridSetting();
			builPreHearingMembersActiveGridSetting();

			if (angular.element('#handbook-nav:visible').length == 0) {
				documentService.showFullscreen();
				vm.isFullScreen = false;
			}
			//Check and resize the view
			resizeService.resizeView();
			//Get current document and request for document if current is null
			getDocument();

			folderService.getFolderByVirtualDocumentId(vm.documentId).then(function (response) {
				vm.FolderLinks = response.data;
			});
		};

		function calculatorHeightContent(timeOut) {
			$timeout(function () {
				tabStateService.adjustContentHeightPosition(tabStateType.documentTabState);
			}, timeOut ? timeOut : 2000);
		}

		function onTabSelectedDocument() {
			calculatorHeightContent(500);
		}

		function getDocument() {
			vm.currentDataPromise =
				$http.get(handbookRequests.GetDocumentInformationForHearingRequest, { params: { 'documentId': $stateParams.documentId, showLoading: true } })
					.then(function (result) {
						createTooltipsRelatedDocument(result.data);
						vm.currentData = result.data;
						if (vm.currentData.description) {
							vm.currentData.description = $sce.trustAsHtml(vm.currentData.description.replace(new RegExp(String.fromCharCode(13) + String.fromCharCode(10), 'g'), '<br/>'));
						}
						vm.currentData.nodeType = convertToNodeType(vm.currentData.type);
						if (vm.currentData.fieldContents != null) {
							var indexTemp = 0;
							vm.currentData.fieldContents.forEach(function (fieldContent) {
								if (fieldContent.content) {
									fieldContent.content = documentService.changeUrlBackendToFrontend(window.location.origin, fieldContent.content, true);
									fieldContent.content = $sce.trustAsHtml(fieldContent.content);
								}
								if (fieldContent.description) {
									fieldContent.description = $sce.trustAsHtml(fieldContent.description);
								}
								fieldContent.indexShow = indexTemp;
								indexTemp = indexTemp + 1;
							});
							vm.updateFields();
						}

						runServicesAfterInit();

						documentService.setDocuments(null); // clear service

						getHearingData();

						calculatorHeightContent();
						updateAfterCurrentDataChanged();
						return vm.currentData;
					})
					.catch(function (result) {
						vm.errorMessage = result.data;
						vm.showError = true;
						// Update currentData so favorite button work
						vm.currentData.documentId = vm.documentId;
						runErrorServicesAfterInit();
					});
		};

		function updateAfterCurrentDataChanged() {
			setIconForDocument(vm.currentData);
		}

		function setIconForDocument(data) {
			data = data == null ? vm.currentData : data;
			var icon = '';
			switch (data.levelType.toString()) {
				case E.HandbookLevelTypes.Enterprise:
					icon = paths.DocumentLevelTypeEnterprise;
					break;
				case E.HandbookLevelTypes.Regional:
					icon = paths.DocumentLevelTypeRegional;
					break;
				case E.HandbookLevelTypes.Local:
					icon = paths.DocumentLevelTypeLocal;
					break;
				default:
					icon = paths.DocumentLevelTypeEnterprise;
					break;
			}
			data.docIcon = icon;
		}

		function getHearingData() {
			$http.get(handbookRequests.GetHearingForFeedbackRequest, {
				params: {
					'entityId': vm.currentData.entityId
				}
			})
				.then(function (response, status, headers, config) {
					if (response.data && response.data.id != null && response.data.id > 0) {
						vm.hearing = response.data;

						if (vm.hearing.description && vm.hearing.description != '') {
							vm.hearing.description = $sce.trustAsHtml(vm.hearing.description.replace(/[\r\n\t]/g, "<br/>"));
						}

						checkMemberHearing();
						if (vm.currentData.approvalStatus == 3) {
							vm.showComment = (!vm.hearing.public && vm.isMemberHearing) || vm.hearing.public;
						} else {
							vm.showComment = false;
							vm.hearingClose = true;
						}
						if (vm.hearingClose) {
							vm.hearings = vm.hearing.hearingMembers;
							broadcastService(broadcastType.gridDataChanges, { id: 'closeHearing', data: vm.hearings, isForced: true });
						} else {
							vm.hearings = vm.hearing.hearingMembers;
						}

						var preHearingMembers = vm.hearing.preHearingMembers;
						groupPreHearingMembers(preHearingMembers);

						if (!vm.hearingCommentAfterResponse && !vm.isMyAssessment) {
							vm.showComment = false;
						}
						adjustmentHearingComments(vm.hearing.hearingComments, vm.hearing.preHearingComments);
					}
					angular.copy(vm.currentData, vm.originalData);
					updateAfterCurrentDataChanged();
				});
		};

		function groupPreHearingMembers(preHearingMembers) {
			if (preHearingMembers == null || preHearingMembers.length <= 0)
				return;

			var result = groupBy(preHearingMembers, function (item) {
				return [item.hearingsId];
			});
			result = $filter('orderBy')(result, ['key']);

			for (var i = 0; i < result.length - 1; i++) {
				var order = 1;
				for (var j = i + 1; j < result.length; j++) {
					if (result[i].value.data[0].dueDate == result[j].value.data[0].dueDate) {
						result[i].order = !result[i].order ? order : result[i].order;
						result[j].order = order + 1;
						order = order + 1;
						if (j == result.length - 1)
							i = j;
					} else {
						i = j - 1;
						break;
					}
				}
			}
			vm.preHearingMembers = [];

			for (var i = 0; i < result.length; i++) {
				var membersGroup = result[i].value.data;
				membersGroup = $filter('orderBy')(membersGroup, ['fullName']);

				vm.preHearingMembers.push({
					members: membersGroup,
					name: membersGroup[0].dueDate + (result[i].order ? ' - ' + result[i].order : ''),
					href: 'preMemberTab' + result[i].key,
					icon: 'typcn typcn-message fa-lg',
					tabIndex: i,
					active: (i == 0)
				});
			}
		}

		function adjustmentHearingComments(dataComments, preDataComments) {
			var commentDocuments = [];
			var commentFields = [];
			if (dataComments.length > 0) {
				dataComments.forEach(function (item) {
					if (item.fieldId == null) {
						commentDocuments.push(angular.copy(item));
					} else {
						commentFields.push(angular.copy(item));
					}
				});
			}
			vm.commentDocuments = commentDocuments;

			var preCommentDocuments = [];
			var preCommentFields = [];
			if (preDataComments.length > 0) {
				preDataComments.forEach(function (item) {
					if (item.fieldId == null) {
						preCommentDocuments.push(angular.copy(item));
					} else {
						preCommentFields.push(angular.copy(item));
					}
				})
			}
			vm.preCommentDocuments = preCommentDocuments;

			if ((commentFields != null && commentFields.length > 0) || (preCommentFields != null && preCommentFields.length > 0)) {
				for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
					var fieldContent = vm.currentData.fieldContents[i];
					fieldContent.commentDocumentText = '';
					if (commentFields != null && commentFields.length > 0) {
						var comments = [];
						commentFields.forEach(function (item) {
							if (fieldContent.fieldId == item.fieldId) {
								comments.push(angular.copy(item));
							}
						});
						fieldContent.comments = comments;
					}
					if (preCommentFields != null && preCommentFields.length > 0) {
						var preComments = [];
						preCommentFields.forEach(function (item) {
							if (fieldContent.fieldId == item.fieldId) {
								preComments.push(angular.copy(item));
							}
						});
						fieldContent.preComments = preComments;
					}
				}
			}
		};

		function editCommentDraf(comment) {
			comment.showCommentDocument = true;
			vm.focusItem('editCommentText' + comment.id);
			comment.commentDocumentText = comment.comment.replace(new RegExp('<br/>', 'g'), '\n');
		}

		function saveCommentDocument(isDraft) {
			var request = {
				entityId: vm.currentData.entityId,
				hearingsId: vm.hearing.id,
				comment: vm.commentDocumentText,
				isDraft: isDraft
			};
			$http.post(handbookRequests.CreateHearingCommentRequest, request)
				.success(function (data, status, headers, config) {
					vm.commentDocuments = data;
					vm.commentDocumentText = '';
				})
				.error(function (data, status, headers, config) {
					vm.hearingClose = true;
				});
		};

		function saveCommentField(fieldContent, isDraft) {
			var request = {
				entityId: vm.currentData.entityId,
				hearingsId: vm.hearing.id,
				comment: fieldContent.commentDocumentText,
				isDraft: isDraft,
				fieldId: fieldContent.fieldId
			};
			$http.post(handbookRequests.CreateHearingCommentRequest, request)
				.success(function (data, status, headers, config) {
					fieldContent.comments = data;
					fieldContent.commentDocumentText = '';
				})
				.error(function (data, status, headers, config) {
					vm.hearingClose = true;
				});
		};

		function publishDocumentComment(comment) {
			var request = {
				entityId: vm.currentData.entityId,
				hearingsId: vm.hearing.id,
				id: comment.id,
				comment: comment.comment
			};
			$http.post(handbookRequests.PublishHearingComment, request)
				.success(function (data, status, headers, config) {
					vm.commentDocuments = data;
					getHearingData();
				})
				.error(function (data, status, headers, config) {
					vm.hearingClose = true;
				});
		}

		function publishFieldComment(comment, fieldContent) {
			var request = {
				entityId: vm.currentData.entityId,
				id: comment.id,
				hearingsId: vm.hearing.id,
				fieldId: fieldContent.fieldId,
				comment: comment.comment
			};
			$http.post(handbookRequests.PublishHearingComment, request)
				.success(function (data, status, headers, config) {
					fieldContent.comments = data;
					getHearingData();
				})
				.error(function (data, status, headers, config) {
					vm.hearingClose = true;
				});
		}

		function editCommentDocument(comment, isDraft) {
			var request = {
				entityId: vm.currentData.entityId,
				hearingsId: vm.hearing.id,
				id: comment.id,
				comment: comment.commentDocumentText,
				isDraft: isDraft,
			};

			$http.post(handbookRequests.UpdateHearingCommentRequest, request)
				.success(function (data, status, headers, config) {
					vm.commentDocuments = data;
				})
				.error(function (data, status, headers, config) {
					vm.hearingClose = true;
				});
		};

		function editCommentField(comment, fieldContent, isDraft) {
			var request = {
				entityId: vm.currentData.entityId,
				id: comment.id,
				hearingsId: vm.hearing.id,
				comment: comment.commentDocumentText,
				isDraft: isDraft,
				fieldId: fieldContent.fieldId
			};
			$http.post(handbookRequests.UpdateHearingCommentRequest, request)
				.success(function (data, status, headers, config) {
					fieldContent.comments = data;
				})
				.error(function (data, status, headers, config) {
					vm.hearingClose = true;
				});
		};

		function deleteCommentDocument(comment) {
			var isConfirm = confirm(globalResources.DeleteHearingCommentConfirmMessage);
			if (isConfirm) {
				var request = {
					entityId: vm.currentData.entityId,
					id: comment.id
				};
				$http.post(handbookRequests.DeleteHearingCommentRequest, request)
					.success(function (data, status, headers, config) {
						vm.commentDocuments.splice($.inArray(comment, vm.commentDocuments), 1);
					})
					.error(function (data, status, headers, config) {
						vm.hearingClose = true;
					});
			}
		}

		function deleteCommentField(comment, comments) {
			var isConfirm = confirm(globalResources.DeleteHearingCommentConfirmMessage);
			if (isConfirm) {
				var request = {
					entityId: vm.currentData.entityId,
					id: comment.id
				};
				$http.post(handbookRequests.DeleteHearingCommentRequest, request)
					.success(function (data, status, headers, config) {
						comments.splice($.inArray(comment, comments), 1);
					})
					.error(function (data, status, headers, config) {
						vm.hearingClose = true;
					});
			}
		};

		function checkMemberHearing() {
			if (vm.hearing.hearingMembers.length > 0) {
				vm.hearing.hearingMembers.forEach(function (item) {
					if (item.employeeId == vm.loginUserId) {
						vm.isMyAssessment = !item.hearingResponse && vm.currentData.approvalStatus == 3;
						vm.isMemberHearing = true;
					}
				})
			}
		};

		function getPublishAndDraftCommentOfLoginUser() {
			vm.userLoginDraftComment = [];
			vm.userLoginPublishComment = [];

			vm.commentDocuments.forEach(function (item) {
				if (item.createdBy == vm.loginUserId) {
					if (item.isDraft) {
						vm.userLoginDraftComment.push(angular.copy(item));
					} else {
						vm.userLoginPublishComment.push(angular.copy(item));
					}
				}
			});

			for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
				var fieldContent = vm.currentData.fieldContents[i];
				if (fieldContent.comments && fieldContent.comments.length > 0) {
					fieldContent.comments.forEach(function (item) {
						if (item.createdBy == vm.loginUserId) {
							if (item.isDraft) {
								vm.userLoginDraftComment.push(angular.copy(item));
							} else {
								vm.userLoginPublishComment.push(angular.copy(item));
							}
						}
					});
				}
			}
		};

		function postHearingResponse(message) {
			getPublishAndDraftCommentOfLoginUser();
			vm.responseFlag = message;
			if (vm.userLoginDraftComment.length > 0) {
				npDialog.showDialog(
					{
						type: dialogTypes.YES_NO,
						message: globalResources.ResponseConfirmDraftMessage,
						title: globalResources.HearingDocument,
						hearingEmailNotification: true
					}, processResponseWithDraftComment);
			} else {
				postResponse(false);
			}
		}

		function processResponseWithDraftComment(result) {
			var hasDraftComment = false;
			if (result == dialogResults.CONFIRM) {
				$http.post(handbookRequests.UpdatePublishAllCommentRequest, {
					entityId: vm.currentData.entityId,
					hearingsId: vm.hearing.id
				})
					.success(function (data, status, headers, config) {
						getHearingData();
						postResponse(false);
					})
					.error(function (data, status, headers, config) {
						vm.hearingClose = true;
					});
			} else {
				postResponse(true);
			}
		};

		function postResponse(hasDraftComment) {
			var countPushlishMessage = (vm.userLoginPublishComment.length != null ? vm.userLoginPublishComment.length : 0) + (hasDraftComment == false ? (vm.userLoginDraftComment.length != null ? vm.userLoginDraftComment.length : 0) : 0);
			var publishMessage = String.format(globalResources.PublishCommentToDocument, countPushlishMessage);
			var messageConfirm = '';
			switch (vm.responseFlag) {
				case RESPONSE_MESSAGE.recommended:
					messageConfirm = String.format(globalResources.ResponseRecommendedMessage, countPushlishMessage > 0 ? publishMessage : '');
					break;
				case RESPONSE_MESSAGE.notRecommended:
					messageConfirm = String.format(globalResources.ResponseNotRecommendedMessage, countPushlishMessage > 0 ? publishMessage : '');
					break;
				case RESPONSE_MESSAGE.neutral:
					messageConfirm = String.format(globalResources.ResponseNeutralMessage, countPushlishMessage > 0 ? publishMessage : '');
					break;
			}

			npDialog.showDialog(
				{
					type: dialogTypes.OK_CANCEL,
					message: messageConfirm,
					title: globalResources.HearingDocument,
					toggleReason: true,
					enableButton: vm.responseFlag == RESPONSE_MESSAGE.notRecommended,
					hearingEmailNotification: true
				}, processSendHearingResponse);
		}

		function processSendHearingResponse(result) {
			if (result.result == dialogResults.CONFIRM) {
				$http.post(handbookRequests.UpdateHearingResponseForMemberRequest, {
					entityId: vm.currentData.entityId,
					hearingsId: vm.hearing.id,
					hearingResponse: vm.responseFlag,
					reason: result.reason,
					emailNotification: result.emailNotification
				})
					.success(function (data, status, headers, config) {
						closeHearingFeedback();
					})
					.error(function (data, status, headers, config) {
						vm.hearingClose = true;
					});
			}
		}

		function focusItem(itemId) {
			setTimeout(function () {
				angular.element('#' + itemId).show();
				angular.element('#' + itemId).focus();
			}, 0);
		};

		function updateFields() {
			if (vm.currentData.relatedAttachments && vm.currentData.relatedAttachments.length > 0) {
				vm.currentData.relatedAttachments.forEach(function (x) {
					x.itemId = x.extraId ? x.extraId : x.itemId;
					x.isLastVersion = true;
				});
			}
			var relatedDocumentAll = angular.copy(vm.currentData.relatedDocuments);
			var relatedAttachmentAll = angular.copy(vm.currentData.relatedAttachments);
			var fieldContentsProcess = [];
			var fieldContentsNonProcess = [];

			vm.currentData.isShowTopBoxContent = false;

			for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
				var fieldContent = vm.currentData.fieldContents[i];
				if (fieldContent.relatedAttachments && fieldContent.relatedAttachments.length > 0) {
					fieldContent.relatedAttachments.forEach(function (x) {
						x.itemId = x.extraId ? x.extraId : x.itemId;
					});
				}
				if (checkShowFieldName(fieldContent)) {
					vm.currentData.isShowTopBoxContent = true;
					if (fieldContent.isProcess) {
						fieldContentsProcess.push(fieldContent);
					}
					else {
						fieldContentsNonProcess.push(fieldContent);
					}
				}

				var relatedDocuments = fieldContent.relatedDocuments;
				relatedDocumentAll = relatedDocumentAll.concat(relatedDocuments);

				var relatedAttachments = fieldContent.relatedAttachments;
				relatedAttachmentAll = relatedAttachmentAll.concat(relatedAttachments);

				var relatedImageGroups = groupBy(fieldContent.images, function (item) {
					return [item.verticalAlign];
				});
				var relatedBottomImages = [];
				var relatedTopImages = [];
				relatedImageGroups.forEach(function (item) {
					if (item.key == parseInt(E.VerticalAlign.Top)) {
						relatedTopImages = relatedTopImages.concat(item.value.data);
					} else {
						if (item.key == parseInt(E.VerticalAlign.Bottom)) {
							relatedBottomImages = relatedBottomImages.concat(item.value.data);
						}
					}
				});
				fieldContent.relatedTopImages = relatedTopImages;
				fieldContent.relatedBottomImages = relatedBottomImages;
			}
			if (vm.currentData.isProcess) {
				vm.currentData.relatedDocumentAll = relatedDocumentAll;
				vm.currentData.relatedAttachmentAll = relatedAttachmentAll;

				vm.currentData.fieldContentsProcess = fieldContentsProcess;
				vm.currentData.fieldContentsNonProcess = fieldContentsNonProcess;

				var relatedDocumentGroups = groupBy(relatedDocumentAll, function (item) {
					return [item.folderId];
				});

				vm.currentData.relatedDocumentGroups = [];
				relatedDocumentGroups.forEach(function (item) {
					var relatedDocumentGroup = {};
					relatedDocumentGroup.id = item.key;
					relatedDocumentGroup.name = item.value.data[0].folderName;
					relatedDocumentGroup.relatedDocuments = item.value.data;
					vm.currentData.relatedDocumentGroups.push(relatedDocumentGroup);
				});

				relatedDocumentForDependencies(relatedDocumentAll);
				relatedAttachmentForDependencies(relatedAttachmentAll);
				attachRelatedItemsFieldsForDependencies();
			}
		};

		function attachRelatedItemsFieldsForDependencies() {
			vm.currentData.fieldContentsProcess.forEach(function (field) {
				var relatedDocumetFieldGroups = groupBy(field.relatedDocuments, function (item) {
					return [item.processRelationType];
				});
				var relatedDocumentInputValues = [];
				var relatedDocumentOutputValue = [];
				relatedDocumetFieldGroups.forEach(function (item) {
					if (item.key == parseInt(vm.processRelationTypes.InputOrInputValues)) {
						relatedDocumentInputValues = relatedDocumentInputValues.concat(item.value.data);
					} else {
						if (item.key == parseInt(vm.processRelationTypes.OutputOrOutputValues)) {
							relatedDocumentOutputValue = relatedDocumentOutputValue.concat(item.value.data);
						}
					}
				});
				field.relatedDocumentInputValues = relatedDocumentInputValues;
				field.relatedDocumentOutputValue = relatedDocumentOutputValue;

				var relatedAttachmentFieldGroups = groupBy(field.relatedAttachments, function (item) {
					return [item.processRelationType];
				});
				var relatedAttachmentInputValues = [];
				var relatedAttachmentOutputValue = [];
				relatedAttachmentFieldGroups.forEach(function (item) {
					if (item.key == parseInt(vm.processRelationTypes.InputOrInputValues)) {
						relatedAttachmentInputValues = relatedAttachmentInputValues.concat(item.value.data);
					} else {
						if (item.key == parseInt(vm.processRelationTypes.OutputOrOutputValues)) {
							relatedAttachmentOutputValue = relatedAttachmentOutputValue.concat(item.value.data);
						}
					}
				});
				field.relatedAttachmentInputValues = relatedAttachmentInputValues;
				field.relatedAttachmentOutputValue = relatedAttachmentOutputValue;
			});
		};

		function relatedDocumentForDependencies(relatedDocumentAll) {
			var relatedDocumentGroups = groupBy(relatedDocumentAll, function (item) {
				return [item.processRelationType];
			});
			var relatedDocumentManagements = [];
			var relatedDocumentResources = [];
			relatedDocumentGroups.forEach(function (item) {
				if (item.key == parseInt(vm.processRelationTypes.Management)) {
					relatedDocumentManagements = relatedDocumentManagements.concat(item.value.data);
				} else {
					if (item.key == parseInt(vm.processRelationTypes.Resources)) {
						relatedDocumentResources = relatedDocumentResources.concat(item.value.data);
					}
				}
			});

			vm.currentData.relatedDocumentManagement = relatedDocumentManagements;
			vm.currentData.relatedDocumentResources = relatedDocumentResources;
		};

		function relatedAttachmentForDependencies(relatedAttachmentAll) {
			var relatedAttachmentGroups = groupBy(relatedAttachmentAll, function (item) {
				return [item.processRelationType];
			});

			var relatedAttachmentManagements = [];
			var relatedAttachmentResources = [];
			relatedAttachmentGroups.forEach(function (item) {
				if (item.key == parseInt(vm.processRelationTypes.Management)) {
					relatedAttachmentManagements = relatedAttachmentManagements.concat(item.value.data);
				} else {
					if (item.key == parseInt(vm.processRelationTypes.Resources)) {
						relatedAttachmentResources = relatedAttachmentResources.concat(item.value.data);
					}
				}
			});
			vm.currentData.relatedAttachmentManagement = relatedAttachmentManagements;
			vm.currentData.relatedAttachmentResources = relatedAttachmentResources;
		};

		function searchAndHighlightText() {
			highlightTextInContent();
			documentContentsSearchService.searchAndHighlightText(vm.highlights);
		};

		function navForward() {
			documentContentsSearchService.navForward(vm.highlights);
		};

		function navBackward() {
			documentContentsSearchService.navBackward(vm.highlights);
		};

		function checkShowFieldName(fieldContent) {
			if (fieldContent.fieldName != '' && fieldContent.fieldName != undefined && fieldContent.isVisible && !fieldContent.isHideByBooklet) {
				return true;
			}
			return false;
		}

		function convertToNodeType(documentType) {
			switch (documentType.toString()) {
				case E.documentTypes.Document:
					return E.nodeTypes.Document;
				case E.documentTypes.LinkDocument:
					return E.nodeTypes.LinkDocument;
				case E.documentTypes.FileDocument:
					return E.nodeTypes.FileDocument;
				case E.documentTypes.ShortcutDocument:
					return E.nodeTypes.ShortcutDocument;
			}
		}

		function runServicesAfterInit() {
			$timeout(function () {
				updateLocalAnchors();
				scrollToAnchorIfExists();
			});
		}

		function runErrorServicesAfterInit() {
			tabStateService.closeOpenedTabIfNoPrivilege(tabStateType.documentTabState);
		}

		function scrollToAnchorIfExists() {
			var hash = $location.hash();
			if (hash != '') {
				$anchorScroll();
			}
		}

		function updateLocalAnchors() {
			var domContent = angular.element('div#document-content');
			anchorService.updateLocalAnchors(domContent);
		}

		function highlightTextInContent() {
			if (vm.currentData.fieldContents != undefined) {
				var viewMode = angular.copy(vm.currentData.viewMode);
				angular.copy(vm.originalData, vm.currentData);
				vm.currentData.viewMode = viewMode;
				vm.currentData.fieldContents.forEach(function (fieldContent) {
					fieldContent.content = documentContentsSearchService.searchAndHighlight(fieldContent.content, vm.highlights.highlightText);
					fieldContent.description = $sce.trustAsHtml(fieldContent.description.toString());
				});
			}
		};

		function fullScreen() {
			if (vm.isFullScreen) {
				documentService.showFullscreen();
			} else {
				documentService.showNormal();
			}
			vm.isFullScreen = !vm.isFullScreen;
		}

		$scope.$on(broadcastType.toggleDocumentFullscreen, function (e, target) {
			fullScreen();
		});

		function closeHearingFeedback() {
			window.close();
		};

		function activeTab() {
			$timeout(function () {
				tabStateService.adjustContentHeightPosition(tabStateType.documentTabState);
			}, 500);
		};

		function printPDF() {
			window.open(String.format("/Printing/PrintHearingFeedback?documentId={0}", vm.documentId));
		};

		function openFileDocument() {
			window.open(handbookRequests.GetFileDocumentRequest + vm.currentData.entityId, '_blank');
		}

		function addPerson() {
			var employees = [];
			vm.hearings.forEach(function (item) {
				employees.push({ id: item.employeeId });
			});
			var modalInstance = openAddMembersDialog($uibModal, employees, vm.translation.AddToHearingsPerson, null, true, vm.currentData.folderId, true);
			modalInstance.result.then(function (data) {
				onAddedMembers(data);
			});
		}

		function onAddedMembers(data) {
			if (!data) {
				return;
			}
			vm.members = [];
			data.forEach(function (item) {
				vm.members.push({
					fullName: item.fullName,
					email: item.email,
					departmentName: item.departmentName,
					id: item.id
				});
			});

			if (vm.members.length != 0) {
				var url = String.format('{0}/document/{1}/hearing', window.location.origin, vm.documentId);
				var objectEmailContent = {
					documentName: vm.currentData.documentName,
					documentResponsible: vm.currentData.responsible,
					url: url,
					dueDate: $filter('date')(vm.hearing.dueDate, "dd.MM.yyyy"),
					allowForwarding: vm.hearing.allowForwarding
				};
				var modalInstance = $uibModal.open({
					templateUrl: '/app/components/document/sendDocumentToHearingEmail.html',
					controller: 'SendDocumentToHearingEmailController as vm',
					size: 'md',
					resolve: {
						objectEmailContent: function () {
							return objectEmailContent;
						}
					}
				});

				modalInstance.result.then(function (data) {
					onSendEmail(data);
				});
			}
		}

		function onSendEmail(data) {
			if (!data) {
				return;
			}
			var request = {
				subject: data.subject,
				body: data.body,
				employees: vm.members,
				entityId: vm.currentData.entityId,
				documentId: vm.documentId,
				hearingId: vm.hearing.id
			};

			$http.post('/api/Documents/AddMembersToHearingDocument', request)
				.success(function (data, status, headers, config) {
					vm.hearings = data;
					broadcastService(broadcastType.gridDataChanges, { id: 'activeHearing', data: vm.hearings, isForced: true });
				})
				.error(function (data, status, headers, config) {
					if (status == httpStatusCodes.METHOD_NOT_ALLOWED) {
						vm.alerts.unshift({ type: 'danger', message: resources.M.Common.dontHaveActionPermission });
					}
					else {
						vm.alerts.unshift({ type: 'danger', message: getErrorMessage(status) });
					}
				});
		}

		function goToDocumentFields(fieldId) {
			$state.go('hearingFieldsContent', { documentId: vm.documentId, fieldId: fieldId });
		};

		function openCompareDocument() {
			window.open(String.format('/documenthearing/{0}/compareWithEarlierVersion', vm.currentData.documentId), '_blank');
		}

		function getNextSearchResultByEnter(keyEvent) {
			if (keyEvent.which == 13) {
				navForward();
			}
		}

	};

})();;

(function () {
    'use strict';

    angular.module('documentFieldsModule', [])
        .controller("DocumentFieldsController", documentFieldsController);

	documentFieldsController.$inject = ['$http', '$sce', '$timeout', '$location', '$scope', '$rootScope', '$anchorScroll',
        'documentService', 'anchorService', 'documentContentsSearchService', 'resizeService', '$stateParams', 'pubSub',
        'folderService', 'treeNavigationService', '$q', 'configService'];

	function documentFieldsController($http, $sce, $timeout, $location, $scope, $rootScope, $anchorScroll,
        documentService, anchorService, documentContentsSearchService, resizeService, $stateParams, pubSub,
        folderService, treeNavigationService, $q, configService) {
        var ignoreRichText = configService.getBool(HandbookConfiguration.LazyLoadRichText);

        var vm = this;

        vm.documentInformation = {};
        vm.originalData = {};
        vm.fieldId = -1;
        vm.currentData = {};
        vm.oldData = {};
        vm.highlights = {
            highlightText: '',
            currentIndex: 0,
            totalFound: 0
        };
        vm.FolderLinks = [];


        var urlParams = $location.url().split('/');
        vm.isEmbedUrl = false;
        vm.typeHideHeader = false;
        vm.documentId = $stateParams.documentId;

        vm.addFavoriteRequest = handbookRequests.AddFavoriteDocument;
        vm.removeFavoriteRequest = handbookRequests.RemoveFavoriteDocument;

        if (urlParams != null && urlParams.length > 0) {
            vm.isEmbedUrl = urlParams[1] == 'embed';
            if (vm.isEmbedUrl) {
                vm.fieldId = urlParams[5];
                vm.typeHideHeader = urlParams.length == 7 ? (urlParams[6] == '1') : false;
                vm.documentId = urlParams[3];
            }
        }
        vm.urlDocument = window.location.origin + '/document/' + vm.documentId + '?preview=true';
        vm.showDocumentLinkToBackend = configService.getBool(HandbookConfiguration.ShowDocumentLinkToBackend);
        vm.simpleSubscription = configService.getBool(HandbookConfiguration.SimpleSubscription);

        vm.isShowMetadata = configService.getBool(HandbookConfiguration.MetadataEnabled);
        vm.isShowMetatagTab = configService.getBool(HandbookConfiguration.ShowMetatagTab);
        vm.publishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);
        vm.showContent = showContent;
        vm.clearActive = clearActive;
        vm.searchAndHighlightText = searchAndHighlightText;
        vm.navForward = navForward;
        vm.navBackward = navBackward;
        vm.printDocumentField = printDocumentField;
        vm.fullScreen = fullScreen;
        vm.isFloatTitle = $(window).height() > HandbookConfiguration.DocumentTitleScreenHeight ? true : false;
        vm.linkToDocumentManagement = linkToDocumentManagement;
        vm.getNextSearchResultByEnter = getNextSearchResultByEnter;
        vm.documentViewOption = parseInt(HandbookConfiguration.DocumentViewOption);
        vm.isToggleSidebarFields = true;
        vm.showSidebarFields = showSidebarFields;
        vm.hideSidebarFields = hideSidebarFields;
        vm.compareDocument = compareDocument;
        vm.hideCompareButton = false;

        initialize();

        function initialize() {

            fullScreenInit();

            processEmbedUrl();
            //check and resize the view
            resizeService.resizeView();
            //get document info from service
            if (!vm.isEmbedUrl) {
                var currentDocument = documentService.getDocuments();

                if (currentDocument && currentDocument.documentInformation) {
                    vm.isFavoriteNodeSelected = true;
                    buildDocumentObjectFromCurrentDocument(currentDocument);
                    $rootScope.title = globalResources.Handbook + " - " + currentDocument.documentInformation.documentName;
                    angular.copy(vm.documentInformation, vm.originalData);
                    runServicesAfterInit();
                }
                else {
                    getDocument();
                }
                folderService.getFolderByVirtualDocumentId($stateParams.documentId).then(function (response) {
                    vm.FolderLinks = response.data;
                });
            } else {
                getDocument();
            }
            treeNavigationService.navigateToItemLocation(true);
        };

        function processEmbedUrl() {
            if (vm.isEmbedUrl) {
                if (vm.typeHideHeader) {
                    angular.element('#documentHeader1Container').hide();
                    angular.element('#fieldTitle').hide();
                }
            }
        }

        function linkToDocumentManagement() {
            var backendUrl = HandbookConfiguration.BackendURL;
            var lastChar = backendUrl.charAt(backendUrl.length - 1);
            var commonAdd = lastChar == '/' ? '' : '/';
            if (vm.backendIsDb4) {
                var url = backendUrl + '&documentId=' + vm.documentId;
                url = url.replace('gk=2', 'gk=1');
                window.open(url, '_blank');
            } else {
                window.open(backendUrl + commonAdd + 'document/' + vm.documentId, '_blank');
            }
        };

        function getDocument() {
            if (vm.isShowMetadata && vm.isShowMetatagTab) {
                getMetadataTab();
            }

            var params = {
                params: {
                    'documentId': vm.documentId,
                    'ignoreRichText': ignoreRichText,
                    showLoading: true
                }
            };

            vm.currentDataPromise =
                $http.get(handbookRequests.GetDocumentInformationRequest, params)
                    .then(function (result) {
                        vm.isFavoriteNodeSelected = true;
                        createTooltipsRelatedDocument(result.data);
                        vm.oldData = result.data;
                        if (vm.oldData.description) {
                            vm.oldData.description = $sce.trustAsHtml(vm.oldData.description.replace(new RegExp(String.fromCharCode(13) + String.fromCharCode(10), 'g'), '<br/>'));
                        }
                        vm.oldData.nodeType = convertToNodeType(vm.oldData.type);
                        if (vm.oldData.fieldContents != null) {

                            var richTextRequests = [];

                            vm.oldData.fieldContents.forEach(function (fieldContent) {
                                if (!vm.oldData.fieldId) {
                                    vm.oldData.fieldId = fieldContent.fieldId;
                                }

                                if (fieldContent.description) {
                                    fieldContent.description = $sce.trustAsHtml(fieldContent.description);
                                }

                                if (ignoreRichText && fieldContent.fieldType == 6 && fieldContent.fieldContentId) {
                                    var params = {
                                        params: {
                                            id: fieldContent.fieldContentId
                                        }
                                    }

                                    var getRichText = $http.get('/api/documents/getRichText', params).then(function (response) {
                                        if (response.data && response.data.content) {
                                            fieldContent.content = documentService.changeUrlBackendToFrontend(window.location.origin, response.data.content);
                                            fieldContent.content = $sce.trustAsHtml(`${fieldContent.content} `);
                                            fieldContent.isVisible = true;
                                        }
                                    });

                                    richTextRequests.push(getRichText);
                                } else {
                                    if (fieldContent.content) {
                                        fieldContent.content = documentService.changeUrlBackendToFrontend(window.location.origin, response.data.content);
                                        fieldContent.content = $sce.trustAsHtml(`${fieldContent.content} `);
                                    }
                                }
                            });


                            if (ignoreRichText) {
                                $q.all(richTextRequests).then(function () {
                                    angular.copy(vm.oldData, vm.originalData);
                                    vm.oldData.documentInformation = angular.copy(vm.oldData);
                                    vm.oldData.confirmInformation = vm.currentData.confirmInformation;

                                    if (vm.isEmbedUrl) {
                                        vm.oldData.fieldId = vm.fieldId;
                                    } else {
                                        vm.oldData.fieldId = $stateParams.fieldId;
                                    }
                                    buildDocumentObjectFromCurrentDocument(vm.oldData);
                                    runServicesAfterInit();
                                });
                            }

                            updateFields();
                        }
                        if (vm.isShowMetadata && vm.isShowMetatagTab) {
                            vm.oldData.metadatas = angular.copy(vm.metadataList);
                            formatMetadata();
                        }

                        if (!ignoreRichText || !vm.oldData.fieldContents){
                            angular.copy(vm.oldData, vm.originalData);
                            vm.oldData.documentInformation = angular.copy(vm.oldData);
                            vm.oldData.confirmInformation = vm.currentData.confirmInformation;

                            if (vm.isEmbedUrl) {
                                vm.oldData.fieldId = vm.fieldId;
                            } else {
                                vm.oldData.fieldId = $stateParams.fieldId;
                            }
                            buildDocumentObjectFromCurrentDocument(vm.oldData);
                            runServicesAfterInit();
                        }

                        documentService.setDocuments(null); // clear service
                        vm.showDocumentLinkToBackend = vm.showDocumentLinkToBackend &&
							(vm.oldData.hasEditPermission || vm.oldData.hasApprovalPermission);

                        vm.isCompare = configService.getBool(HandbookConfiguration.EnableCompare) && vm.oldData.version > 0;
                        if (vm.currentData.type == E.documentTypes.LinkDocument || vm.currentData.type == E.documentTypes.FileDocument) {
                            vm.hideCompareButton = true;
                        }
                        $rootScope.title = globalResources.Handbook + " - " + result.data.documentName;
                        return vm.currentData;
                    })
                    .catch(function (result) {
                        vm.errorMessage = result.data;
                        vm.showError = true;
                        // Update currentData so favorite button work
                        vm.currentData.documentId = vm.documentId;
                        runErrorServicesAfterInit();
                    });
        };

        function getMetadataTab() {
            $http.get(handbookRequests.GetDocumentMetadataRequest, { params: { 'documentId': $stateParams.documentId } })
                .then(function (result) {
                    vm.metadataList = result.data;
                });
        };

        function formatMetadata() {
            if (vm.isShowMetadata && vm.oldData.metadatas && vm.oldData.metadatas.length > 0 && vm.isShowMetatagTab) {
                vm.oldData.metadatas.forEach(function (item) {
                    item.nameDisplay = $sce.trustAsHtml(item.registerName + ' - ' + item.registerItemName + ' - ' + item.registerValue);
                });
            }
        }

        function updateFields() {
            var relatedDocumentAll = angular.copy(vm.oldData.relatedDocuments);
            var relatedAttachmentAll = angular.copy(vm.oldData.relatedAttachments);

            vm.oldData.isShowTopBoxContent = false;

            for (var i = 0; i < vm.oldData.fieldContents.length; i++) {
                var fieldContent = vm.oldData.fieldContents[i];
                if (checkShowFieldName(fieldContent)) {
                    vm.oldData.isShowTopBoxContent = true;
                }

                var relatedDocuments = fieldContent.relatedDocuments;
                relatedDocumentAll = relatedDocumentAll.concat(relatedDocuments);

                var relatedAttachments = fieldContent.relatedAttachments;
                relatedAttachmentAll = relatedAttachmentAll.concat(relatedAttachments);

                var relatedImageGroups = groupBy(fieldContent.images, function (item) {
                    return [item.verticalAlign];
                });
                var relatedBottomImages = [];
                var relatedTopImages = [];
                relatedImageGroups.forEach(function (item) {
                    if (item.key == parseInt(E.VerticalAlign.Top)) {
                        relatedTopImages = relatedTopImages.concat(item.value.data);
                    } else {
                        if (item.key == parseInt(E.VerticalAlign.Bottom)) {
                            relatedBottomImages = relatedBottomImages.concat(item.value.data);
                        }
                    }
                });
                fieldContent.relatedTopImages = relatedTopImages;
                fieldContent.relatedBottomImages = relatedBottomImages;
            }
        };

        function checkShowFieldName(fieldContent) {
			if (fieldContent.fieldName != '' && fieldContent.fieldName != undefined && fieldContent.isVisible && !fieldContent.isHideByBooklet) {
                return true;
            }
            return false;
        }

        function convertToNodeType(documentType) {
            switch (documentType.toString()) {
                case E.documentTypes.Document:
                    return E.nodeTypes.Document;
                case E.documentTypes.LinkDocument:
                    return E.nodeTypes.LinkDocument;
                case E.documentTypes.FileDocument:
                    return E.nodeTypes.FileDocument;
                case E.documentTypes.ShortcutDocument:
                    return E.nodeTypes.ShortcutDocument;
            }
        }

        function setIconForDocument(data) {
            data = data == null ? vm.currentData : data;
            var icon = '';
            switch (data.levelType.toString()) {
                case E.HandbookLevelTypes.Enterprise:
                    icon = paths.DocumentLevelTypeEnterprise;
                    break;
                case E.HandbookLevelTypes.Regional:
                    icon = paths.DocumentLevelTypeRegional;
                    break;
                case E.HandbookLevelTypes.Local:
                    icon = paths.DocumentLevelTypeLocal;
                    break;
                default:
                    icon = paths.DocumentLevelTypeEnterprise;
                    break;
            }
            data.docIcon = icon;
        }

        function buildDocumentObjectFromCurrentDocument(currentDocument) {
            if (currentDocument) {
                vm.documentInformation = angular.copy(currentDocument.documentInformation);
                vm.currentData = angular.copy(currentDocument.documentInformation);
                setIconForDocument(vm.documentInformation);
                if (vm.currentData.description) {
                    vm.currentData.description = $sce.trustAsHtml(vm.currentData.description.toString());
                }
                if (vm.isShowMetadata && vm.currentData.metadatas && vm.currentData.metadatas.length > 0 && vm.isShowMetatagTab) {
                    vm.currentData.metadatas.forEach(function (item) {
                        item.nameDisplay = $sce.trustAsHtml(item.nameDisplay.toString());
                    });
                }
                if (vm.documentInformation) {
                    for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
                        if (vm.documentInformation.fieldContents[i].fieldId == currentDocument.fieldId) {
                            vm.fieldId = currentDocument.fieldId;
                            vm.currentData.confirmInformation = currentDocument.confirmInformation;
                            vm.documentInformation.fieldContents[i].activeField = 'active';
                            if (vm.documentInformation.fieldContents[i].fieldName) {
                                vm.documentInformation.fieldName = $sce.trustAsHtml(vm.documentInformation.fieldContents[i].fieldName.toString());
                            }
                            if (vm.documentInformation.fieldContents[i].content) {
                                vm.documentInformation.content = $sce.trustAsHtml(vm.documentInformation.fieldContents[i].content.toString());
                            }
                            vm.documentInformation.relatedDocuments = vm.documentInformation.fieldContents[i].relatedDocuments;
                            vm.documentInformation.relatedAttachments = vm.documentInformation.fieldContents[i].relatedAttachments;

                            vm.documentInformation.relatedTopImages = vm.documentInformation.fieldContents[i].relatedTopImages;
                            vm.documentInformation.relatedBottomImages = vm.documentInformation.fieldContents[i].relatedBottomImages;
                        }
                        else {
                            vm.documentInformation.fieldContents[i].activeField = '';
                        }
                    }
                }
            }
        };

        function showContent(fieldItem, type) {
            vm.clearActive();
            if (fieldItem) {
                fieldItem.activeField = 'active';
                if (fieldItem.fieldName) {
                    vm.documentInformation.fieldName = $sce.trustAsHtml(fieldItem.fieldName);
                }
                if (fieldItem.content) {
                    vm.documentInformation.content = $sce.trustAsHtml(fieldItem.content.toString());
                } else {
                    vm.documentInformation.content = '';
                }
                vm.documentInformation.relatedDocuments = fieldItem.relatedDocuments;
                vm.documentInformation.relatedAttachments = fieldItem.relatedAttachments;
                vm.documentInformation.relatedTopImages = fieldItem.relatedTopImages;
                vm.documentInformation.relatedBottomImages = fieldItem.relatedBottomImages;
                vm.fieldId = fieldItem.fieldId;
                angular.copy(vm.documentInformation, vm.originalData);
                updateLocalAnchors();
            } else {
                clearDocumentInformation();
                if (type == 0) {
                    vm.activeRelatedDocuments = true;
                    vm.documentInformation.relatedDocuments = vm.currentData.relatedDocuments;
                } else {
                    vm.activeAttachments = true;
                    vm.documentInformation.relatedAttachments = vm.currentData.relatedAttachments;
                }
            }
        };

        $scope.$watch('vm.documentInformation.fieldName', function (newValue, oldValue) {
            pubSub.publish(broadcastType.loadContentFieldDone, { fieldName: newValue });
        });

        function clearDocumentInformation() {
            vm.documentInformation.fieldName = '';
            vm.documentInformation.content = '';
            vm.documentInformation.relatedDocuments = null;
            vm.documentInformation.relatedAttachments = null;
            vm.documentInformation.relatedTopImages = null;
            vm.documentInformation.relatedBottomImages = null;
        }

        function clearActive() {

            vm.activeRelatedDocuments = false;
            vm.activeAttachments = false;

            for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
                vm.documentInformation.fieldContents[i].activeField = '';
            }
        };

        function searchAndHighlightText() {
            highlightTextInContent();
            documentContentsSearchService.searchAndHighlightText(vm.highlights);
        };

        function navForward() {
            documentContentsSearchService.navForward(vm.highlights);
        };

        function navBackward() {
            documentContentsSearchService.navBackward(vm.highlights);
        };

        function printDocumentField() {
            window.open(String.format(handbookRequests.PrintHtmlFieldRequest, vm.documentInformation.documentId, vm.fieldId));
        };

        function highlightTextInContent() {
            if (vm.documentInformation.content != undefined) {
                angular.copy(vm.originalData, vm.documentInformation);
                vm.documentInformation.content = documentContentsSearchService.searchAndHighlight(vm.documentInformation.content, vm.highlights.highlightText);
            }
        };

        function updateLocalAnchors() {
            $timeout(function () {
                var domContent = angular.element('div.contentWithLayout');
				anchorService.updateLocalAnchors(domContent, true);
				scrollToAnchorIfExists();
            });
        }

		function scrollToAnchorIfExists() {
			var hash = $location.hash();
			if (hash != '') {
				$anchorScroll();
			}
		}

        function runServicesAfterInit() {
            updateLocalAnchors();
        }

        function fullScreen() {
            if (vm.isFullScreen) {
                documentService.showFullscreen();
            } else {
                documentService.showNormal();
            }
            vm.isFullScreen = !vm.isFullScreen;
        }

        function fullScreenInit() {
            if (angular.element('#handbook-nav:visible').length == 0) {
                documentService.showFullscreen();
                vm.isFullScreen = false;
            } else {
                documentService.showNormal();
                vm.isFullScreen = true;
            }
        }

        $scope.$on(broadcastType.toggleDocumentFullscreen, function (e, target) {
            fullScreen();
        });

        function anchorClick(hash) {
            if (vm.documentInformation.fieldContents.length == 1)
                return;
            var existedAnchor = false;
            var domContent = angular.element('div.contentWithLayout');
            angular.forEach(domContent.find('a[name]'), function (tag) {
                if (hash.hash.indexOf(tag.attributes.name.value) != -1) {
                    existedAnchor = true;
                }
            });
            if (existedAnchor)
                return;

            if (hash.hash.indexOf('AndreEH%C3%A5ndboksdokumenter') != -1) {
                if (vm.currentData.relatedDocuments.length > 0) {
                    showContent(null, 0);
                }
                return;
            }
            if (hash.hash.indexOf('vedlegg') != -1) {
                if (vm.currentData.relatedAttachments.length > 0) {
                    showContent(null, 1);
                }
                return;
            }
            var field = null;
            for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
                var fieldContent = vm.documentInformation.fieldContents[i];
                if (fieldContent.fieldId == vm.fieldId || !fieldContent.content) {
                    continue;
                }

                var div = document.createElement('div');
                div.innerHTML = fieldContent.content;
                domContent = angular.element(div);
                angular.forEach(domContent.find('a[name]'), function (tag) {
                    if (hash.hash.indexOf(tag.attributes.name.value) != -1) {
                        existedAnchor = true;
                    }
                });
                if (existedAnchor) {
                    field = fieldContent;
                    break;
                }
            }
            if (field != null) {
                showContent(field);
            }
        }

        function getNextSearchResultByEnter(keyEvent) {
            if (keyEvent.which == 13) {
                navForward();
            }
        }

        $scope.$on('anchorclick', function (e, target) {
            anchorClick(target);
        });

        function showSidebarFields() {
            vm.isToggleSidebarFields = true;
        }

        function hideSidebarFields() {
            vm.isToggleSidebarFields = false;
		}

		function compareDocument() {
			window.open(String.format('/document/{0}/compareWithEarlierVersion', vm.documentId), '_blank');
		}
    };

})();;

(function () {
    'use strict';

    angular.module("handbookApp")
        .controller(controllers.chapterController, chapterController);

    chapterController.$inject = ['$scope', '$http', '$state', '$stateParams', '$timeout', '$sce', '$rootScope', '$filter',
        'broadcastService', 'favoriteService', 'tabStateService', 'resizeService', 'localStorageService', 'treeNavigationService',
        'documentService', '$location', 'browserService', '$uibModal', '$anchorScroll', 'configService'];

    function chapterController($scope, $http, $state, $stateParams, $timeout, $sce, $rootScope, $filter,
        broadcastService, favoriteService, tabStateService, resizeService, localStorageService, treeNavigationService,
        documentService, $location, browserService, $uibModal, $anchorScroll, configService) {
        var attachmentStores = {};
        var vm = this;
        vm.handbookRequests = handbookRequests;
        vm.isPinMeta = localStorageService.getItem(localStorageKeys.stateOfSticky);
        vm.isPinMeta = configService.getBool(vm.isPinMeta);
        vm.pinMetaChange = pinMetaChange;
        $scope.translation = globalResources;
        $scope.internetPublishOption = configService.getBool(HandbookConfiguration.InternetPublishOption);
        vm.publishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);
        vm.commonGridSettingKey = gridSettingKeys.commonVisibilitySettings;
        vm.folderId = $stateParams.folderId;       

        vm.groupDocuments = [];
        vm.folderList = {};
        vm.folderInformation = {};
        vm.keyword = $location.$$search.keyword || '';
        vm.groupDocumentAnchorPrefix = prefix.groupDocumentAnchorPrefix;
        vm.addFavoriteRequest = handbookRequests.AddFavoriteFolder;
        vm.removeFavoriteRequest = handbookRequests.RemoveFavoriteFolder;
        vm.addEmailSubscriptionRequest = handbookRequests.AddEmailSubscription;
        vm.removeEmailSubscriptionRequest = handbookRequests.RemoveEmailSubscription;

        vm.urlchapter = window.location.origin + '/folder/' + vm.folderId;

        vm.backendIsDb4 = configService.getBool(HandbookConfiguration.BackendIsDb4);
        vm.showFolderLinkToBackend = false;

        vm.objectShowDocumentsInSubChapters = {
            showDocumentsInSubChapters: $location.$$search.showDocumentsInSubChapters? true : false
        };

        vm.DocumentViewTypes = [
            { Id: documentViewTypes.DocumentViewTypes_Standard, Name: globalResources.Folders.DocumentViewStandard },
            { Id: documentViewTypes.DocumentViewTypes_Template, Name: globalResources.DocumentType }
        ];
        vm.metaDataTags = [];

        vm.onRowClick = onRowClick;
        vm.changeDocumentView = changeDocumentView;
        vm.gotoParentFolder = gotoParentFolder;
        vm.showDocumentsRecursive = showDocumentsRecursive;
        vm.removeFromFavorite = removeFromFavorite;
        vm.getConsecutiveIndex = getConsecutiveIndex;
        //vm.adjustContentPosition = adjustContentPosition;
        vm.showAllDocuments = showAllDocuments;
        vm.showDocumentsIncludeLevel1 = showDocumentsIncludeLevel1;
        vm.searchInFolder = searchInFolder;
        vm.toTopGroup = toTopGroup;
        vm.backToFolderView = backToFolderView;
        vm.showWhatsNewDocumentsRecursive = showWhatsNewDocumentsRecursive;
        vm.linkToFolderManagement = linkToFolderManagement;
		vm.showAllGroups = showAllGroups;
        vm.changeSelectedOption = changeSelectedOption;
        vm.nameFolderWithMetaTag = nameFolderWithMetaTag;
        vm.urlFolderWithMetaTag = urlFolderWithMetaTag;
        vm.getFolderClassMobile = getFolderClassMobile;
        vm.backToFolderMobileView = backToFolderMobileView;

        vm.currentRowIndex = 0;
        vm.totalDocuments = 0;
        vm.nextPage = nextPage;
        vm.infiniteGroups = [];
        vm.busy = false;
        vm.newTotalDocuments = 0;
        vm.scrolling = false;
        vm.subFoldersGridSetting = [];
        vm.showDocumentIncludeLevel1 = false;
        vm.showWhatsNewDocumentsInSubChapters = false;
        vm.searchDocuments = [];
        vm.WhatsNewDocuments = [];

        vm.copyUserFriendlyUrlTooltip = globalResources.CopyUserFriendlyUrl;
        vm.BROWSER_TYPE = BrowserType;
        vm.browserType = browserService.detectBrowserWindow();
        vm.showDropdownFolderOptions = false;
        vm.showSortOption = false;
        vm.isStandardView = true;
        vm.openAboutFolder = openAboutFolder;
        vm.addOnlyFolderEmailSubscription = addOnlyFolderEmailSubscription;
        vm.removeOnlyFolderEmailSubscription = removeOnlyFolderEmailSubscription;
        vm.addRecursiveFolderEmailSubscription = addRecursiveFolderEmailSubscription;
        vm.removeRecursiveFolderEmailSubscription = removeRecursiveFolderEmailSubscription;
        vm.simpleSubscription = configService.getBool(HandbookConfiguration.SimpleSubscription);
        vm.openWhatsNewFolder = openWhatsNewFolder;
        vm.changeSelectedOptionInMobileView = changeSelectedOptionInMobileView;
        vm.collapsed = collapsed;


        var infiniteScrollLoadsize = (HandbookConfiguration.InfiniteScrollLoadGroupSize == "0" || HandbookConfiguration.InfiniteScrollLoadGroupSize == 0) ?
            0 :
            parseInt(HandbookConfiguration.InfiniteScrollLoadGroupSize);

        var infiniteScrollLoadDocumentssize = (HandbookConfiguration.InfiniteScrollLoadSize == "0" || HandbookConfiguration.InfiniteScrollLoadSize == 0) ?
            0 :
            parseInt(HandbookConfiguration.InfiniteScrollLoadSize);
        $scope.$on('ngRepeatFinished', function (ngRepeatFinishedEvent) {
            adjustContentPosition();
        });

        $scope.$on(broadcastType.scrollTarget, function (e, target) {
            vm.scrolling = true;
        });

        $scope.$on('ActiveFolderWhatsnew', function (e, target) {
            vm.isWhatsNew = true;
        });

        $scope.$on("$destroy", function () {
            documentService.clearDocumentsInWorker();
            documentService.clearMetaDocumentsInWorker();
        });

        $scope.$on(broadcastType.gridSettingTarget, function (e, target, gridSettingKey) {
            if (gridSettingKey == gridSettingKeys.commonVisibilitySettings) {
                vm.exportParams.columns = getDocumentColumnsForExporting(gridSettingKeys.commonVisibilitySettings);
            }
        });

        $scope.selectNodeHead = selectNodeHead;
        $scope.selectNodeLabel = selectNodeLabel;

        $(document)
            .on(collapseExpandEvent.shown, function (event) {
                var $target = $(event.target.parentNode);
                $target.find("." + collapseExpandClass.collapse)
                    .removeClass(collapseExpandClass.collapse)
                    .addClass(collapseExpandClass.expand);
            })
            .on(collapseExpandEvent.hidden, function (event) {
                var $target = $(event.target.parentNode);
                $target.find("." + collapseExpandClass.expand)
                    .removeClass(collapseExpandClass.expand)
                    .addClass(collapseExpandClass.collapse);
            })
            .bind('click', function (event) {
                let isClickedElementChildOfPopup = angular.element("#moreIcon").find(event.target).length > 0 ||
                    angular.element("#moreIconChild").find(event.target).length > 0;
                if (isClickedElementChildOfPopup) {
                    vm.showSortOption = false;
                    return;
                }
                vm.showDropdownFolderOptions = false;

                isClickedElementChildOfPopup = angular.element("#sortIcon").find(event.target).length > 0 ||
                    angular.element("#sortIconChild").find(event.target).length > 0;
                    
                if (isClickedElementChildOfPopup) {
                    return;
                }
                vm.showSortOption = false;
            });
        vm.exportParams = {
            folderId: vm.folderId,
            isRecursive: false,
            groupBy: E.exportDocumentGroupsByColumn.none
        };

        initialize();

        function initialize() {
			var storageWhatsNewPeriodFolder = localStorageService.getItem("WhatsNewPeriodFolder");
			vm.selectedOption = storageWhatsNewPeriodFolder != null ? storageWhatsNewPeriodFolder : parseInt(HandbookConfiguration.WhatsNewPeriodFolder);

            resizeService.resizeView();

            getGridSetting(gridSettingKeys.commonVisibilitySettings);
            getColumnsDefinition(gridSettingKeys.commonVisibilitySettings);
            buildSubFoldersGridSetting();
            vm.exportParams.columns = getDocumentColumnsForExporting(gridSettingKeys.commonVisibilitySettings);
            vm.commonGridColumnDefinition = commonColumnsDefinition;
            vm.optionalColumns = optionalColumnsDenifinition;
            vm.commonColumnsDefinition = angular.copy(optionalColumnsDenifinition);
            vm.hasViewAccess = true;
            vm.hasViewContentAccess = true;
            getFolderInfoStorage();

            if (vm.keyword) {
                searchInFolder();
            } else {
                showDocumentsRecursive();
            }

            updateFolderInfoStorage();
            vm.listOutSubChapters = HandbookConfiguration.ListOutSubChapters;

            getWhatsNewForFolder();

            if (!vm.publishedVersion && $scope.internetPublishOption) {
                vm.DocumentViewTypes.push({ Id: documentViewTypes.DocumentViewTypes_Internet, Name: globalResources.publishedOrUnpublished });
            }
            treeNavigationService.navigateToItemLocation(true);
        };

        $(window).on('resize', function () {
            vm.browserType = browserService.detectBrowserWindow();
        });

        function changeSelectedOption() {
			localStorageService.setItem("WhatsNewPeriodFolder", vm.selectedOption);
			getWhatsNewForFolder();
        }

        function changeSelectedOptionInMobileView(period) {
            vm.selectedOption = period.value;
            localStorageService.setItem("WhatsNewPeriodFolder", vm.selectedOption);
        }

        //watch the height of the content change
        $scope.$watch(
            function () {
                return angular.element('#' + folderContent.content + '').height();
            },
            function (newValue, oldValue) {
                if (newValue != oldValue) {
                    updateScroll();
                }
            }
        );

        function updateScroll() {
            if (vm.isPinMeta) {            
                var currentHeight = angular.element('#content-body-chapter').height()
                    - angular.element('#chapterItemTabs').height()
                    - angular.element('#topmenuleftid').height()
                    - angular.element('#list-document-type').height()
                    - angular.element('.' + folderContent.groupMetatagList + '').height() - 37;
                          
                angular.element('#' + folderContent.groupMetatagView + '').css({ height: currentHeight, 'overflow-y': 'auto' });                     
            }
            else {
                angular.element('#' + folderContent.groupMetatagView + '').css({ height: '', 'overflow-y': '' });
            }
            localStorageService.setItem(localStorageKeys.stateOfSticky, vm.isPinMeta);
        }
        function pinMetaChange() {
            vm.isPinMeta = !vm.isPinMeta;
            if (vm.infiniteGroups.length != vm.groupDocuments.length) {
                vm.infiniteGroups = vm.groupDocuments;
                vm.newTotalDocuments = vm.infiniteGroups.length;
            }
            updateScroll();
        }

        function linkToFolderManagement() {
            var backendUrl = HandbookConfiguration.BackendURL;
            var lastChar = backendUrl.charAt(backendUrl.length - 1);
            var commonAdd = lastChar == '/' ? '' : '/';
            if (vm.backendIsDb4) {
                var url = backendUrl + '&folder=' + vm.folderId;
                url = url.replace('gk=2', 'gk=1');
                window.open(url, '_blank');
            } else {
                window.open(backendUrl + commonAdd + 'folder/' + vm.folderId, '_blank');
            }
        }

        $scope.$on('linkToFolderManagement', function (e, target) {
            linkToFolderManagement();
        });

        function onRowClick(id) {
            favoriteService.setFavoriteNodeState({ isFavorited: false });
            $state.go(handbookActions.FolderAction, { folderId: id });
        };

        function changeDocumentView() {
            vm.showGroupDocumentTitle = vm.folderInformation.viewType != documentViewTypes.DocumentViewTypes_Standard;
            listedOutDocuments(vm.folderInformation.viewType);
            updateFolderInfoStorage();
            updateExportGroupByParam();
        };

        function selectNodeHead(node) {
            if (node.children == undefined || !node.children.length) {
                $http.get(handbookRequests.GetSubfoldersRequest, { params: { 'folderId': node.id } })
                    .success(function (data, status, headers, config) {
                        node.children = data;
                    });
            }
        };

        function selectNodeLabel(node) {
            $state.go(handbookActions.FolderAction, {
                folderId: node.id
            });
        };

        function gotoParentFolder() {
            $state.go(handbookActions.FolderAction, { folderId: vm.folderInformation.parentFolderId });
        };

        function getWhatsNewForFolder() {
			$http.get(handbookRequests.GetRecentlyApprovedDocumentsForFolder, { params: { 'folderId': vm.folderId, 'includeSubFolder': vm.showWhatsNewDocumentsInSubChapters, 'periodOption': vm.selectedOption } })
                .success(function (data, status, headers, config) {
                    vm.WhatsNewDocuments = data;
                    updateAttachmentsForWhatsNewDocuments(data);
                    documentService.getAgreeFilesForDocuments(vm.WhatsNewDocuments);
                });
        };

        function updateAttachmentsForWhatsNewDocuments(documents) {
            var documentIds = [];
            for (var i = 0; i < documents.length; i++) {
                if (documents[i].hasAttachment) {
                    documentIds.push(documents[i].id);
                }
            }
            if (documentIds.length > 0) {
                $http
                    .post('/api/Documents/GetAttachmentsForDocuments', { documentIds: documentIds })
					.success(function (data) {
						if (data && data.length > 0) {
							data.forEach(function (x) {
								x.itemId = x.extraId ? x.extraId : x.itemId;
							});
						}
                        for (var i = 0; i < documents.length; i++) {
                            if (documents[i].hasAttachment) {
                                documents[i].attachments = [];
                                for (var j = 0; j < data.length; j++) {
                                    if (data[j].documentId == documents[i].id) {
                                        documents[i].attachments.push(data[j]);
                                    }
                                }
                            }
                        }

                    });
            }
        }

        function showWhatsNewDocumentsRecursive() {
            getWhatsNewForFolder();
        }

        function showDocumentsRecursive() {
            listedOutDocuments(vm.folderInformation.viewType);
            updateFolderInfoStorage();
            buildExportFileName();
            vm.exportParams.isRecursive = vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters;
        };

        function showDocumentsIncludeLevel1() {
            listedOutDocuments(vm.folderInformation.viewType);
            updateFolderInfoStorage();
            updateExportGroupByParam();
        }

        function removeFromFavorite() {
            var requestUrl = vm.removeFavoriteRequest + '/' + vm.folderId;
            $http.post(requestUrl)
                .then(function () {
                    var target = {
                        data: {
                            id: vm.folderId,
                            isDocument: false
                        },
                        requestType: requestType.removeRequest
                    };
                    broadcastService(broadcastType.favoriteTarget, target);
                });
        };

        function getConsecutiveIndex(parentIndex, $index, documents) {
            var total = 0;
            for (var i = 0; i < parentIndex; i += 1) {
                total += documents[i].length;
            }
            return (total + $index);
        }

        function listedOutDocuments(viewType) {
            vm.groupDocuments = [];
            vm.isIncludeLevel1 = false;
            if (viewType != null) {
                if (viewType != documentViewTypes.DocumentViewTypes_Standard && viewType != documentViewTypes.DocumentViewTypes_Template
                    && viewType != documentViewTypes.DocumentViewTypes_Internet) {
                    getDocuments($stateParams.folderId);
                    vm.isIncludeLevel1 = true;
                } else {
                    listedOutDocumentsRecursive();
                }
            } else {
                getDocuments($stateParams.folderId);
            }
        };

        function getMetaGroupName(viewType) {
            var result = '';
            if (vm.DocumentViewTypes && vm.DocumentViewTypes.length > 0) {
                for (var i = 0; i < vm.DocumentViewTypes.length; i++) {
                    if (viewType == vm.DocumentViewTypes[i].Id) {
                        result = vm.DocumentViewTypes[i].Name;
                        break;
                    }
                }
            }
            return result;
        }

        function getMetadataGroupsForContentTab(viewType) {
            vm.isIncludeLevel1 = true;
            vm.metaGroupName = getMetaGroupName(viewType);
            vm.folderData.documents = vm.folderData.documents != null ? vm.folderData.documents : [];
            
            return documentService.getMetaDocumentsViaWorker(
                $stateParams.folderId,
                viewType,
                vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters,
                vm.showDocumentIncludeLevel1,
                vm.folderData.documents
            )
                .then(function (metadata) {
                    if (!metadata) {
                        return;
                    }

                    vm.metaDataTags = metadata.metaTags;
                    documentService.getAgreeFilesForDocuments(metadata.folderDocuments);
                    if (vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters) {
                        $http.get(handbookRequests.GetDocumentsRecursive, {
                            params: {
                                'folderId': $stateParams.folderId
                            }
                        }).success(function (data, status, headers, config) {
                            updateAttachmentsForDocuments(data, true);
                            vm.folderData = {
                                documents: data,
                                folders: vm.folderData.folders
                            };
                            mappingDocumentTemplates(metadata.documents);
                            getDocumentsGroupByTypes(vm.folderData.documents, true);
                            buildViewMode();
                        });
                    } else {
                        vm.folderData.documents = metadata.folderDocuments;
                        vm.groupDocuments = metadata.groupDocuments;
                        updateInfiniteScrollingData();
                    }
                });
        }

        function listedOutDocumentsRecursive() {
            if (vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters) {
                if (!vm.folderInformation || !vm.folderInformation.id) {
                    $http.get("/api/Documents/GetFolderInformation", { params: { 'folderId': $stateParams.folderId } })
                        .success(function (data, status, headers, config) {
                            vm.isFavoriteNodeSelected = true;

                            angular.extend(vm.folderInformation, {
                                level: data.level,
                                levelTypeText: data.levelTypeText,
                                parentFolderId: data.parentFolderId,
                                viewType: vm.folderInformation.viewType || data.viewType,
                                name: data.name,
                                isFavorite: data.isFavorite,
                                hasEmailSubscription: data.hasEmailSubscription,
                                hasOnlyFolderEmailSubscription: data.hasOnlyFolderEmailSubscription,
                                isFavoriteReadonly: data.isFavoriteReadonly,
                                documentTemplates: data.documentTemplates,
                                type: data.type,
                                nodeType: convertToNodeType(data.type),
                                id: data.id,
                                description: data.description == null ? '' : $sce.trustAsHtml(data.description),
                                icon: getFolderClassMobile(data.type)
                            });
                            buildExportFileName();
                            vm.showGroupDocumentTitle = vm.folderInformation.viewType != documentViewTypes.DocumentViewTypes_Standard;
                            vm.showFolderLinkToBackend = configService.getBool(HandbookConfiguration.ShowDocumentLinkToBackend) && data.hasWritePermission;
                            vm.folderIcon = getFolderIcon(vm.folderInformation.type);
                        });
                }
                $http.get(handbookRequests.GetDocumentsRecursive, {
                    params: {
                        'folderId': $stateParams.folderId,
                        showLoading: true
                    }
                }).success(function (data, status, headers, config) {
                    updateAttachmentsForDocuments(data, true);
                    
                    vm.folderData = {
                        documents: data,
                        folders: vm.folderData != null ? vm.folderData.folders : null
                    };
                    angular.extend(vm.folderInformation, {
                        documentTemplates: getDocumentTemplates(data)
                    });
                    buildExportFileName();
                    angular.forEach(vm.folderData.documents, function (document) {
                        document.internetDocumentString = document.internetDocument ? globalResources.publishedInternet : globalResources.unpublishedInternet;
                    });

                    documentService.getAgreeFilesForDocuments(vm.folderData.documents);
                    getDocumentsGroupByTypes(vm.folderData.documents);

                    buildViewMode();
                });

                if (HandbookConfiguration.MetadataEnabled == "True") {
                    $http.get(handbookRequests.GetMetadataGroupsRecursive, {
                        params: {
                            'folderId': $stateParams.folderId
                        }
                    }).success(function (data, status, headers, config) {
                        getMetadataGroupTypes(data);
                    });
                }
            } else {
                getDocuments($stateParams.folderId);
            }
        }

        function mappingDocumentTemplates(documentMetatags) {
            if (vm.folderData != null) {
                vm.folderData.documents = vm.folderData.documents != null ? vm.folderData.documents : [];
                vm.folderData.documents.forEach(function (item) {
                    item.templateGroup = globalResources.UndefinedMetatag;
                });
            }
            if (documentMetatags != null && documentMetatags.length > 0 && vm.folderData != null) {
                var length = documentMetatags.length;
                for (var i = 0; i < length; i++) {
                    updateDocumentTemplate(documentMetatags[i], documentMetatags[i].id)
                }
            }
        };

        function updateDocumentTemplate(documentMetatag, id) {
            documentMetatag.templateGroup = documentMetatag.metatagValue;
            var existedDocument = false;
            var length = vm.folderData.documents.length;
            for (var i = 0; i < length; i++) {
                if (vm.folderData.documents[i].id == id
                    && (vm.folderData.documents[i].templateGroup == globalResources.UndefinedMetatag || vm.folderData.documents[i].templateGroup == null)) {
                    vm.folderData.documents[i].templateGroup = documentMetatag.metatagValue || '';
                    existedDocument = true;
                    break;
                }
            }
            if (!existedDocument) {
                vm.folderData.documents.push(angular.copy(documentMetatag));
            }
        };

        function getSortGroupMetadata(metatagValue) {
            var sort = (vm.metaDataTags != null && vm.metaDataTags.length > 0) ? vm.metaDataTags.length + 1 : 0;
            if (vm.metaDataTags != null && vm.metaDataTags.length > 0) {
                for (var i = 0; i < vm.metaDataTags.length; i++) {
                    if (vm.metaDataTags[i].registerValue == metatagValue) {
                        sort = vm.metaDataTags[i].sort;
                        break;
                    }
                }
            }
            return sort;
        }

        function getDocuments(folderId) {
            var previousViewType = (vm.folderInformation != undefined && vm.folderInformation.viewType != undefined) ? vm.folderInformation.viewType : null;

            return documentService.getDocumentsViaWorker(folderId, previousViewType).then(function (data) {

                vm.hasViewContentAccess = data.hasViewContentAccess;
                vm.hasViewAccess = data.hasViewAccess;
                vm.errorMessage = data.errorMessage;

                if (data.errorMessage && !data.documentsError) {
                    var favoriteState = favoriteService.getFavoriteNodeState();
                    vm.isFavoriteNodeSelected = favoriteState.isFavorited;
                    // Update folder information for favorite button can work
                    vm.folderInformation.isFavorite = vm.isFavoriteNodeSelected;
                    vm.folderInformation.id = vm.folderId;
                    runErrorServicesAfterInit();
                    return;
                }

                vm.isFavoriteNodeSelected = true;

                if (data.documentsError) {
                    runErrorServicesAfterInit();
                    return;
                }

                vm.folderData = {
                    documents: data.documents,
                    folders: data.folders
                };
                vm.documentsMobile = angular.copy(vm.folderData.documents);
                vm.subFoldersMobile = angular.copy(vm.folderData.folders);
                sortItemsAscByName(vm.documentsMobile);
                sortItemsAscByName(vm.subFoldersMobile);
                
                documentService.getAgreeFilesForDocuments(vm.folderData.documents);

                vm.showFolderLinkToBackend = configService.getBool(HandbookConfiguration.ShowDocumentLinkToBackend) && data.hasWritePermission;

                angular.forEach(vm.folderData.folders, function (node) {
                    node.icon = getFolderClass(convertToFolderType(node.type))
                });

                angular.extend(vm.folderInformation, {
                    level: data.level,
                    levelTypeText: data.levelTypeText,
                    parentFolderId: data.parentFolderId,
                    viewType: data.viewType,
                    name: data.name,
                    isFavorite: data.isFavorite,
                    hasEmailSubscription: data.hasEmailSubscription,
                    hasOnlyFolderEmailSubscription: data.hasOnlyFolderEmailSubscription,
                    isFavoriteReadonly: data.isFavoriteReadonly,
                    documentTemplates: data.documentTemplates,
                    type: data.type,
                    nodeType: convertToNodeType(data.type),
                    id: data.id,
                    description: data.description == null ? '' : $sce.trustAsHtml(data.description),
                    icon: getFolderClassMobile(data.type)
                });
				vm.messageWhatNew = String.format(globalResources.RecentlyApprovedDocumentsInTheHandbook, vm.folderInformation.name);
                buildExportFileName();
                $rootScope.title = globalResources.Handbook + " - " + data.name;

                angular.forEach(data.metadataGroupTypes, function (type) {
                    var exist = vm.DocumentViewTypes.some(function (dt) {
                        return dt.Id == type.Id;
                    })

                    if (!exist) {
                        vm.DocumentViewTypes.push(type);
                    }
                });

                vm.showGroupDocumentTitle = vm.folderInformation.viewType != documentViewTypes.DocumentViewTypes_Standard;
                vm.folderIcon = getFolderIcon(vm.folderInformation.type);

                var isGetMetadataGroupsForContentTab = hasGetMetadataGroupsForContentTab();
                if (isGetMetadataGroupsForContentTab && vm.browserType != vm.BROWSER_TYPE.MOBILE) {
                    getMetadataGroupsForContentTab(vm.folderInformation.viewType);
                }

                if (hasGetDocumentsGroupByTypes()) {
                    vm.groupDocuments = data.groupDocuments;
                    updateInfiniteScrollingData();
                }

                buildViewMode();
                updateExportGroupByParam();

                $timeout(function () {
                    updateScroll();
                }, 500);
            });
        }

        function sortItemsAscByName(items) {
            items.sort(function (a, b) {
                if (a.name.toLowerCase() < b.name.toLowerCase())
                    return -1;
                if (a.name.toLowerCase() > b.name.toLowerCase()) {
                    return 1;
                }
                return 0;
            });
        }

        function hasGetMetadataGroupsForContentTab() {
            return vm.folderInformation.viewType != documentViewTypes.DocumentViewTypes_Standard
                && vm.folderInformation.viewType != documentViewTypes.DocumentViewTypes_Template
                && vm.folderInformation.viewType != documentViewTypes.DocumentViewTypes_Internet;
        }

        function hasGetDocumentsGroupByTypes() {
            return vm.folderInformation.viewType == documentViewTypes.DocumentViewTypes_Standard
                || vm.folderInformation.viewType == documentViewTypes.DocumentViewTypes_Template
                || vm.folderInformation.viewType == documentViewTypes.DocumentViewTypes_Internet;
        }

        function buildViewMode() {
            if ((vm.folderData.documents && vm.folderData.documents.length > 0)
                && (vm.folderData.folders && vm.folderData.folders.length > 0)) {
                vm.viewMode = 2;
            } else if (vm.folderData.folders && vm.folderData.folders.length > 0) {
                vm.viewMode = 1;
            } else {
                vm.viewMode = 0;
            }
        }

        function buildSubFoldersGridSetting() {
            vm.subFoldersGridSetting.push({ id: 'name', name: globalResources.SubFolders.toUpperCase(), width: 100, coldefault: true, icon: 'icon' });
            vm.columnNotRemove = 'name';
        }

        function adjustContentPosition() {
            var tabState = tabStateService.getState(tabStateType.chapterTabState);
            $timeout(function () {
                tabStateService.adjustContentPosition(tabState, tabStateType.chapterTabState);
            }, 0, false);
        };

        function getMetadataGroupTypes(metadataGroups) {
            if (metadataGroups != null && metadataGroups.length > 0) {
                var length = metadataGroups.length;
                for (var i = 0; i < length; i++) {
                    var key = metadataGroups[i].id.toString();
                    if (!existsTemplate(key, vm.DocumentViewTypes)) { // We do not stored duplicated groups
                        vm.DocumentViewTypes.push({ Id: key, Name: metadataGroups[i].name });
                    }
                }
            }
        };

        function updateAttachmentsForDocuments(documents, recursive) {

            if (documents) {
                $http
                    .get('/api/Folders/GetAttachmentsInFolder', {
                        params: {
                            folderId: vm.folderId,
                            recursive: recursive ? 1 : 0
                        }
                    })
                    .success(function (data) {
                        for (var i = 0; i < documents.length; i++) {
                            if (documents[i].hasAttachment) {
                                documents[i].attachments = [];
                                for (var j = 0; j < data.length; j++) {
                                    if (data[j].documentId == documents[i].id) {
                                        documents[i].attachments.push(data[j]);
                                    }
                                }
                            }
                        }
                    });
            }
        }

        function existsTemplate(obj, list) {
            for (var i = 0; i < list.length; i++) {
                if (list[i].Id == obj) {
                    return true;
                }
            }

            return false;
        };

        function getDocumentsGroupByTypes(documents, isMetadataGroup) {
            if (documents == null) {
                return;
            }

            var result = groupBy(documents, function (item) {
                if (isMetadataGroup) {
                    return [item.templateGroup];
                } else if (vm.folderInformation.viewType == documentViewTypes.DocumentViewTypes_Internet) {
                    return [item.internetDocumentString];
                } else {
                    return [item.template];
                }
            });

            vm.groupDocuments = [];
            var lastOne = {
                documents: [],
                templateName: '',
                totalDocuments: 0,
                sortGroup: 0
            };
            var hasUndefinedGroup = false;
            for (var i = 0; i < result.length; i++) {
                var sortGroup = 0;
                var documentsGroup = result[i].value.data;

                if (isMetadataGroup && vm.metaDataTags != null && vm.metaDataTags.length > 0) {
                    sortGroup = getSortGroupMetadata(result[i].key);
                    if (vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters || vm.showDocumentIncludeLevel1) {
                        documentsGroup = $filter('orderBy')(documentsGroup, ['name']);
                    } else {
                        documentsGroup = $filter('orderBy')(documentsGroup, ['order', 'name']);
                    }
                }
                if (result[i].key == globalResources.UndefinedMetatag) {
                    lastOne.documents = documentsGroup;
                    lastOne.templateName = result[i].key;
                    lastOne.totalDocuments = result[i].value.data.length;
                    lastOne.sortGroup = sortGroup;
                    hasUndefinedGroup = true;
                } else {
                    vm.groupDocuments.push({
                        documents: documentsGroup,
                        templateName: result[i].key,
                        totalDocuments: result[i].value.data.length,
                        sortGroup: sortGroup
                    });
                }
            }
            if (isMetadataGroup && vm.metaDataTags != null && vm.metaDataTags.length > 0) {
                if (!checkSortOrderMetaTags(vm.groupDocuments)) {
                    vm.groupDocuments.sort(function (a, b) {
                        return a.sortGroup - b.sortGroup;
                    });
                } else {
                    vm.groupDocuments.sort(function (a, b) {
                        return a.templateName.toLowerCase().localeCompare(b.templateName.toLowerCase());
                    });
                }
            } else {
                vm.groupDocuments.sort(function (a, b) {
                    return a.templateName.toLowerCase().localeCompare(b.templateName.toLowerCase());
                });
            }

            if (hasUndefinedGroup) {
                vm.groupDocuments.push(lastOne);
            }

            updateInfiniteScrollingData();
        }

        function checkSortOrderMetaTags(data) {
            if (data == null || data.length == 0) {
                return true;
            }
            return data[data.length - 1].sortGroup == data[0].sortGroup && data[data.length - 1].sortGroup == 0;
        }

        function updateInfiniteScrollingData() {
            if (!vm.groupDocuments) {
                return;
            }
            var newTotal = vm.groupDocuments != null ? vm.groupDocuments.length : 0;
            if (infiniteScrollLoadsize == 0) {
                vm.infiniteGroups = vm.groupDocuments;
            } else {
                vm.totalDocuments = newTotal;
                vm.currentRowIndex = 0;
                vm.infiniteGroups = getAPage();
                scrollToGroupDocument();
                vm.newTotalDocuments = 0;
                vm.scrolling = false;
                if (vm.browserType != BrowserType.MOBILE) {
                    $timeout(function () { //scroll a bit up
                        var folderContentObject = angular.element('#' + folderContent.content + '')[0];
                        var scrollTop = folderContentObject.scrollTop;
                        folderContentObject.scrollTop -= scrollTop / 2;
                    }, 10, false);
                }
            }
            checkShowAllGroupLink(vm.infiniteGroups);
            initShowGroups();
        }

        function scrollToGroupDocument() {   
            $timeout(function () {
                var anchorGroup = $location.hash();
                var indexToScroll = Number(anchorGroup.split('-').pop() || 0);

                if (vm.infiniteGroups[indexToScroll]) {
                    vm.infiniteGroups[indexToScroll].isShow = true;
                    vm.infiniteGroups[indexToScroll].isToggled = false;
                }

                if (anchorGroup) {
                    $location.hash(anchorGroup);
                    $anchorScroll();
                }
            }, 100);
        }

        function checkShowAllGroupLink(infiniteGroups) {
            if (!vm.groupDocuments || !infiniteGroups) {
                return;
            }

            var result = false;
            if (infiniteGroups.length <= vm.groupDocuments.length) {
                result = checkDocumentsInOneGroup();
            } else {
                result = true;
            }
            vm.showAllGroup = result;
        }

        function initShowGroups() {
            var length = vm.infiniteGroups.length > 5 ? 5 : vm.infiniteGroups.length;
            for (var i = 0; i < vm.infiniteGroups.length; i++) {
                if (i < length) {
                    vm.infiniteGroups[i].isShow = true;
                    vm.infiniteGroups[i].isToggled = false;
                } else {
                    vm.infiniteGroups[i].isShow = false;
                    vm.infiniteGroups[i].isToggled = true;
                }
            }
        }

        function checkDocumentsInOneGroup() {
            for (var i = 0; i < vm.groupDocuments.length; i++) {
                var item = vm.groupDocuments[i];
                if (item.totalDocuments > infiniteScrollLoadDocumentssize) {
                    return true;
                }
            }
            return false;
        }

        function getDocumentTemplates(documents) {
            if (documents != null) {
                var result = [];
                var lastOne = '';
                var hasUndefinedGroup = false;
                for (var i = 0; i < documents.length; i++) {
                    if (result.indexOf(documents[i].template) < 0) {
                        if (documents[i].template == globalResources.UndefinedMetatag) {
                            lastOne = documents[i].template;
                            hasUndefinedGroup = true;
                        } else {
                            result.push(documents[i].template);
                        }
                    }
                }

                result.sort(function (a, b) {
                    return a.toLowerCase().localeCompare(b.toLowerCase());
                });

                if (hasUndefinedGroup) {
                    result.push(lastOne);
                }

                var groupTemplates = [], columns = 6;
                for (var j = 0; j < result.length; j += columns) {
                    groupTemplates.push(result.slice(j, j + columns));
                }

                return groupTemplates;
            }

            return [];
        };

        function getFolderClass(folderType) {
            switch (folderType.toString()) {
                case E.folderTypes.Folder:
                    return 'folder-5-icon';
                case E.folderTypes.TopFolder:
                    return 'folder-6-icon';
                case E.folderTypes.DepartmentFolder:
                    return 'folder-7-icon';
                case E.folderTypes.RegionalFolder:
                    return 'folder-8-icon';
                default:
                    return 'folder-5-icon';
            }
        }

        function getFolderClassMobile(folderType) {
            switch (folderType.toString()) {
                case E.folderTypes.Folder:
                    return 'folder-blue-icon';
                case E.folderTypes.TopFolder:
                    return 'folder-orange-icon';
                case E.folderTypes.DepartmentFolder:
                    return 'folder-green-icon';
                case E.folderTypes.RegionalFolder:
                    return 'folder-regional-icon';
                default:
                    return 'folder-blue-icon';
            }
        }

        function getFolderIcon(folderType) {
            switch (folderType.toString()) {
                case E.folderTypes.Folder:
                    return paths.FolderIcon;
                case E.folderTypes.RegionalFolder:
                    return paths.RegionalFolderIcon;
                case E.folderTypes.TopFolder:
                    return paths.TopFolderIcon;
                case E.folderTypes.DepartmentFolder:
                    return paths.DepartmentFolderIcon;
                default:
                    return paths.FolderIcon;
            }
        };

        function convertToNodeType(folderType) {
            switch (folderType.toString()) {
                case E.folderTypes.Folder:
                    return E.nodeTypes.Folder;
                case E.folderTypes.TopFolder:
                    return E.nodeTypes.TopFolder;
                case E.folderTypes.DepartmentFolder:
                    return E.nodeTypes.DepartmentFolder;
                case E.folderTypes.RegionalFolder:
                    return E.nodeTypes.RegionalFolder;
            }
        };

        function convertToFolderType(nodeType) {
            switch (nodeType.toString()) {
                case E.nodeTypes.Folder:
                    return E.folderTypes.Folder;
                case E.nodeTypes.TopFolder:
                    return E.folderTypes.TopFolder;
                case E.nodeTypes.DepartmentFolder:
                    return E.folderTypes.DepartmentFolder;
                case E.nodeTypes.RegionalFolder:
                    return E.folderTypes.RegionalFolder;
            }
        };

        function runErrorServicesAfterInit() {
            tabStateService.closeOpenedTabIfNoPrivilege(tabStateType.chapterTabState);
        };

        function updateFolderInfoStorage() {
            var showDocumentsInSubChapters = vm.objectShowDocumentsInSubChapters ? !!vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters : false;
            var arrFolderInfo = [];
            var folderExist = false;
            var folderInfo = localStorageService.getItem(folderInformationKeyStorage);
            if (folderInfo != null) {
                var folders = JSON.parse(folderInfo);
                if (folders.constructor === Array) {
                    for (var i = 0; i < folders.length; i++) {
                        var folder = folders[i];
                        if (folder.folderId != vm.folderId) {
                            continue;
                        }
                        folder.folderId = vm.folderId;
                        folder.recursive = showDocumentsInSubChapters;
                        folder.template = vm.folderInformation.viewType;
                        folder.includeLevel1 = vm.showDocumentIncludeLevel1;
                        folderExist = true;
                        break;
                    }
                    arrFolderInfo = folders;
                }
            }
            if (!folderExist) {
                arrFolderInfo.push({
                    folderId: vm.folderId,
                    recursive: showDocumentsInSubChapters,
                    template: vm.folderInformation.viewType,
                    includeLevel1: vm.showDocumentIncludeLevel1
                });
            }

            localStorageService.setItem(folderInformationKeyStorage, JSON.stringify(arrFolderInfo));
        }

        function getFolderInfoStorage() {
            var folderInfo = localStorageService.getItem(folderInformationKeyStorage);
            var viewFolder = $location.search().viewFolder;

            if (folderInfo != null) {
                var folderInfoObject = JSON.parse(folderInfo);

                if (folderInfoObject.constructor === Array) {
                    for (var i = 0; i < folderInfoObject.length; i++) {
                        var folder = folderInfoObject[i];
                        if (folder.folderId != vm.folderId) {
                            continue;
                        }
                        vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters = folder.recursive;
                        vm.folderInformation.viewType = viewFolder ? viewFolder : folder.template;
                        vm.showGroupDocumentTitle = vm.folderInformation.viewType != documentViewTypes.DocumentViewTypes_Standard;
                        vm.showDocumentIncludeLevel1 = (folder.includeLevel1 != null && folder.includeLevel1 != undefined) ? folder.includeLevel1 : false;
                        updateExportGroupByParam();
                        break;
                    }
                }
            }     

        }

        function getAPage() {
            var data = [];
            var startIndex = vm.currentRowIndex;
            var endIndex = startIndex + infiniteScrollLoadsize;
            for (var i = startIndex; i < endIndex; i++) {
                if (vm.currentRowIndex < vm.totalDocuments) {
                    data.push(vm.groupDocuments[i]);
                    vm.currentRowIndex += 1;
                } else {
                    break;
                }
            }
            return data;
        };

        function nextPage() {
            if (vm.busy) return;

            if (vm.groupDocuments == null || vm.groupDocuments.length == 0) {
                if (vm.folderData != null && vm.folderData.documents != null && hasGetDocumentsGroupByTypes()) {
                    getDocumentsGroupByTypes(vm.folderData.documents);
                }
            }

            vm.busy = true;
            if (infiniteScrollLoadsize == 0) {
                vm.infiniteGroups = vm.groupDocuments;
            } else {
                if (vm.infiniteGroups.length < vm.newTotalDocuments || (vm.scrolling && vm.infiniteGroups.length < vm.groupDocuments.length)) {
                    vm.infiniteGroups = vm.infiniteGroups.concat(getAPage());
                }
            }

            vm.newTotalDocuments = vm.infiniteGroups.length;
            vm.busy = false;
        };

        function showAllGroups(group) {
            if (vm.infiniteGroups.length != vm.groupDocuments.length) {
                vm.infiniteGroups = vm.groupDocuments;
                vm.newTotalDocuments = vm.infiniteGroups.length;
            }
            group.isShow = true;
        }

        function showAllDocuments() {
            vm.infiniteGroups = vm.groupDocuments;
            vm.currentRowIndex = vm.totalDocuments;
            broadcastService('showAllDocumentInGroup', {});
        };

        function searchInFolder() {
            vm.isSearchInFolder = true;
            var searchRequestParams = {
                keyword: vm.keyword,
                searchInContents: true,
                searchType: 3,
                folderId: vm.folderId,
                fromDate: null,
                toDate: null,
                hasExpired: false,
                registerId: null,
                registerItemId: null,
				registerItemValueId: null,
				includeVirtualDocuments: true
            };

            if (!vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters) {
                searchRequestParams.notRecursiveFolderId = true;
            }


            $location.search('keyword', vm.keyword || undefined);
            $location.search('showDocumentsInSubChapters', vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters || undefined);

            $http.get(handbookRequests.SearchRequest, { params: searchRequestParams })
                .then(function (response, status, headers, config) {
                    if (response.data.documents != null) {
                        updateAttachmentsForDocuments(response.data.documents);
                        documentService.getAgreeFilesForDocuments(response.data.documents);
                        vm.searchDocuments = response.data.documents;
                        vm.totalHits = vm.searchDocuments.length;
                        vm.totalFound = response.data.totalCount;
                        adjustContentPosition();
                    } else {
                        vm.totalHits = 0;
                        vm.totalFound = 0;
                    }
                });
            if (vm.browserType == BrowserType.MOBILE) {
                getDocuments($stateParams.folderId);
            }
        };

        function backToFolderView() {
            vm.isSearchInFolder = false;
            adjustContentPosition();
        }

        function backToFolderMobileView() {
            vm.isSearchInFolder = false;
            vm.keyword = '';
        }

        function toTopGroup() {
            angular.element('#folder-content-identifier').scrollTop(0);
        };

        function buildExportFileName() {
            if (!vm.folderInformation.name) {
                return;
            }
            if (vm.objectShowDocumentsInSubChapters.showDocumentsInSubChapters) {
                vm.exportFileName = String.format(globalResources.Exporter.ChapterWithSubChaptersDocumentList, vm.folderInformation.name);
            } else {
                vm.exportFileName = String.format(globalResources.Exporter.ChapterDocumentList, vm.folderInformation.name);
            }
        }

        function updateExportGroupByParam() {
            if (vm.folderInformation.viewType == documentViewTypes.DocumentViewTypes_Standard) {
                vm.exportParams.groupBy = E.exportDocumentGroupsByColumn.none;
            } else if (vm.folderInformation.viewType == documentViewTypes.DocumentViewTypes_Template) {
                vm.exportParams.groupBy = E.exportDocumentGroupsByColumn.documentType;
            } else {
                vm.exportParams.groupBy = E.exportDocumentGroupsByColumn.metatag;
                vm.exportParams.metadataGroupId = vm.folderInformation.viewType;
                vm.exportParams.includeLevel1 = vm.showDocumentIncludeLevel1;
            }
        }

        function nameFolderWithMetaTag(item) {
            if (item.documents.length) {
                return item.documents[0].folderName + ' - ' + item.templateName;
            }
        }

        function urlFolderWithMetaTag(item, index) {
            if (item.documents.length) {
                var urlName = item.documents[0].handbookId + '?viewFolder=' + vm.folderInformation.viewType + '#groupDocumentHeader-' + index;
                return window.location.origin + '/folder/' + urlName;
            }             

        }

        function openAboutFolder() {
            vm.showDropdownFolderOptions = !vm.showDropdownFolderOptions;
            var modalInstance = $uibModal.open({
                templateUrl: '/app/components/chapter/templates/aboutFolderModal.html',
                controller: 'AboutFolderModalController as vm',
                size: 'lg',
                backdrop: 'static',
                resolve: {
                    model: function () {
                        return {
                            folderData: vm.folderInformation
                        };
                    }
                }
            });
        }

        function addOnlyFolderEmailSubscription() {
            if (!vm.folderInformation.hasEmailSubscription) {
                var requestUrl = handbookRequests.AddOnlyFolderToEmailSubscription + '/' + vm.folderId;
                $http.post(requestUrl)
                    .then(function () {
                        vm.folderInformation.hasOnlyFolderEmailSubscription = !vm.folderInformation.hasOnlyFolderEmailSubscription;
                    });
            }
            vm.showDropdownFolderOptions = !vm.showDropdownFolderOptions;
        }

        function removeOnlyFolderEmailSubscription() {
            var requestUrl = handbookRequests.RemoveOnlyFolderFromEmailSubscription + '/' + vm.folderId;
            $http.post(requestUrl)
                .then(function () {
                    vm.folderInformation.hasOnlyFolderEmailSubscription = !vm.folderInformation.hasOnlyFolderEmailSubscription;
                });
            vm.showDropdownFolderOptions = !vm.showDropdownFolderOptions;
        }

        function addRecursiveFolderEmailSubscription() {
            var requestUrl = handbookRequests.AddEmailSubscription + '/' + vm.folderId;

            $http.post(requestUrl)
                .then(function () {
                    vm.folderInformation.hasEmailSubscription = !vm.folderInformation.hasEmailSubscription;
                    vm.folderInformation.hasOnlyFolderEmailSubscription = false;
                    vm.folderInformation.hasEmailSubscription = true;
                });
            vm.showDropdownFolderOptions = !vm.showDropdownFolderOptions;
        };

        function removeRecursiveFolderEmailSubscription() {
            var requestUrl = handbookRequests.RemoveEmailSubscription + '/' + vm.folderId;

            $http.post(requestUrl)
                .then(function () {
                    vm.folderInformation.hasEmailSubscription = !vm.folderInformation.hasEmailSubscription;
                    vm.folderInformation.hasEmailSubscription = false;
                });
            vm.showDropdownFolderOptions = !vm.showDropdownFolderOptions;
        }

        function openWhatsNewFolder() {
            vm.showDropdownFolderOptions = !vm.showDropdownFolderOptions;
            var modalInstance = $uibModal.open({
                templateUrl: '/app/components/chapter/templates/whatsNewFolderModal.html',
                controller: 'WhatsNewFolderModalController as vm',
                size: 'lg',
                backdrop: 'static',
                resolve: {
                    model: function () {
                        return {
                            hasViewAccess: vm.hasViewAccess,
                            showWhatsNewDocumentsInSubChapters: vm.showWhatsNewDocumentsInSubChapters,
                            selectedOption: vm.selectedOption,
                            hasViewContentAccess: vm.hasViewContentAccess,
                            WhatsNewDocuments: vm.WhatsNewDocuments,
                            changeSelectedOptionInMobileView: vm.changeSelectedOptionInMobileView,
                            folderData: vm.folderInformation,
                        };
                    }
                }
            });
        }


        function collapsed(index) {
            vm.infiniteGroups[index].isToggled = !vm.infiniteGroups[index].isToggled;
            vm.infiniteGroups[index].isShow = !vm.infiniteGroups[index].isToggled
            angular.element('#groupDocument-' + index).toggleClass('collapsed');
            angular.element('#groupDocument-' + index + '_icon').toggleClass('collapsed-arrow').toggleClass('collapse-arrow');
        }

    };
})();;
(function () {
    'use strict';

    angular.module('accountModule', [])
           .controller('ChangePasswordController', controller);

    controller.$inject = ['$http', '$timeout', '$uibModalInstance'];

    function controller($http, $timeout, $modalInstance) {
        var vm = this;
        vm.translation = globalResources;

        vm.initialize = initialize;
        vm.passwordPattern = /((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*]).{8,16})/;
        vm.changeOldPassword = changeOldPassword;
        vm.changeNewPassword = changeNewPassword;
        vm.changePassword = changePassword;
        vm.cancel = cancel;

        function initialize() {
            setFocusForElement('oldPassword');
        }

        function setFocusForElement(id) {
            $timeout(function () {
                var element = document.getElementById(id);
                angular.element(element).focus();
            }, 500);
        }

        function changeOldPassword() {
            $http.post('/api/Users/CheckPassword', { password: vm.oldPassword })
                .success(function (isCorrect) {
                    vm.isOldPasswordCorrect = isCorrect;

                    if (vm.isOldPasswordCorrect) {
                        setFocusForElement('newPassword');
                    }
                });
        }

        function changeNewPassword() {
            vm.isNewPasswordValid = vm.passwordPattern.test(vm.newPassword);

            if (vm.isNewPasswordValid) {
                vm.newPasswordTooltip = '';
            } else {
                buildNewPasswordTooltip();
            }
        }

        function buildNewPasswordTooltip() {
            var pattern = null;
            vm.newPasswordTooltip = '<div>' + globalResources.M.PasswordRequirements + '</div>';

            // Check length of password
            if (vm.newPassword.length >= 8 && vm.newPassword.length <= 16) {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-ok text-success" />';
            } else {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-remove text-danger" />';
            }
            vm.newPasswordTooltip += globalResources.M.BeBetween8And16Characters + '</div>';

            // Check lowercase character
            pattern = /(?=.*[a-z])/;
            if (pattern.test(vm.newPassword)) {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-ok text-success" />';
            } else {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-remove text-danger" />';
            }
            vm.newPasswordTooltip += globalResources.M.AtLeastOneLowercaseLetter + '</div>';

            // Check uppercase character
            pattern = /(?=.*[A-Z])/;
            if (pattern.test(vm.newPassword)) {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-ok text-success" />';
            } else {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-remove text-danger" />';
            }
            vm.newPasswordTooltip += globalResources.M.AtLeastOneUppercaseLetter + '</div>';

            // Check number character
            pattern = /(?=.*\d)/;
            if (pattern.test(vm.newPassword)) {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-ok text-success" />';
            } else {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-remove text-danger" />';
            }
            vm.newPasswordTooltip += globalResources.M.AtLeastOneNumber + '</div>';

            // Check special character
            pattern = /(?=.*[!@#$%^&*])/;
            if (pattern.test(vm.newPassword)) {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-ok text-success" />';
            } else {
                vm.newPasswordTooltip += '<div><span class="glyphicon glyphicon-remove text-danger" />';
            }
            vm.newPasswordTooltip += globalResources.M.AtLeastOneSpecialCharacter + '</div>';
        }

        function changePassword() {
            $http.post('/api/Users/ChangePassword', { password: vm.newPassword })
                .success(function () {
                    $modalInstance.dismiss('cancel');
                });
        }

        function cancel() {
            $modalInstance.dismiss('cancel');
        }
    }
})();;
(function () {
    'use strict';

    angular.module("handbookApp")
        .controller(controllers.searchController, searchController);

    searchController.$inject = ['$scope', '$http', '$state', '$stateParams', '$timeout', '$document',
        'favoriteService', 'folderService', 'tabStateService', 'resizeService', 'stringValidationService',
        'metaDataService', 'documentService', '$location', '$q', 'configService'];

    function searchController($scope, $http, $state, $stateParams, $timeout, $document,
        favoriteService, folderService, tabStateService, resizeService, stringValidationService,
        metaDataService, documentService, $location, $q, configService) {
        var vm = this;
        vm.handbookRequests = handbookRequests;
        $scope.translation = globalResources;
        vm.commonGridSettingKey = gridSettingKeys.commonVisibilitySettings;
        vm.enabledMetadataSearch = true;
        vm.enabledAdvanceSearch = true;
        vm.isMetadataSearch = configService.getBool(HandbookConfiguration.MetadataEnabled) && vm.enabledMetadataSearch;
        vm.doSearchDataMining = configService.getBool(HandbookConfiguration.DoSearchDataMining);
        vm.enabledCompendiaSearch = configService.getBool(HandbookConfiguration.CompendiaSearch);
        vm.searchInFolders = configService.getBool(HandbookConfiguration.SearchInFolders);
        var showCompendiaSearch = vm.enabledCompendiaSearch;
        var showFolderSearch = vm.searchInFolders;

        vm.searchLogLevel = parseInt(HandbookConfiguration.SearchLogLevel);
        $scope.searchTypes = [
            { id: 1, name: $scope.translation.TitleSearch },
            { id: 2, name: $scope.translation.ContentSearch }
        ];
        if (vm.enabledAdvanceSearch) {
            $scope.searchTypes.push({ id: 3, name: $scope.translation.AdvanceSearch });
        }
        if (vm.isMetadataSearch) {
            $scope.searchTypes.push({ id: 4, name: $scope.translation.MetadataSearch });
        }

        $scope.keywords = {};
        vm.today = new Date();

        vm.keyword = $stateParams.keyword;
        vm.searchInContents = $stateParams.searchInContents == true || $stateParams.searchInContents == 'true';
        //vm.documentTemplate = $stateParams.template;
        vm.folderId = $stateParams.folderId;
        vm.fromDate = $stateParams.fromDate != null ? new Date(parseInt($stateParams.fromDate)) : null;
        vm.toDate = $stateParams.toDate != null ? new Date(parseInt($stateParams.toDate)) : null;
        vm.fromDateDisplayed = $stateParams.fromDate != null ? new Date(parseInt($stateParams.fromDate)) : null;
        vm.toDateDisplayed = $stateParams.toDate != null ? new Date(parseInt($stateParams.toDate)) : null;
        vm.registerItemId = $stateParams.registerItemId;
        vm.registerItemValueId = $stateParams.registerItemValueId;
        vm.type = $stateParams.type;
        vm.hasExpired = $stateParams.hasExpired == 1;
        vm.version = $stateParams.version != null ? parseInt($stateParams.version) : null;
        vm.documentType = $stateParams.documentType != null ? parseInt($stateParams.documentType) : null;
        vm.advancedSearchLocationType = vm.folderId == null ? 1 : (isNaN(vm.folderId) ? 2 : 1);

        vm.documents = {};
        vm.folders = {};
        vm.compendiaDocuments = [];
        vm.totalHits = 0;
        vm.totalFound = 0;
        vm.showLoadMore = false;
        vm.loadMoreClickedCounter = 0;
        vm.searchFilter = '';
        vm.folderName = '';
        vm.searchType = E.searchType.Maximum;
        vm.searchFilters = '';
        vm.showMoreLink = globalResources.Showmore;

        vm.selectedItem = {
            selectedMetadata: null,
            selectedTag: null
        };

        vm.foldersGridSetting = [];

        vm.initMetadata = {
            metadatas: [],
            tags: []
        };

        vm.startMetadata = 0;
        vm.startTag = 0;

        vm.onRowClick = onRowClick;
        vm.loadByMaxSearchSize = loadByMaxSearchSize;
        vm.showLoadMoreLink = showLoadMoreLink;
        $scope.selectNodeHead = selectNodeHead;
        $scope.selectNodeLabel = selectNodeLabel;
        $scope.clearSelectedNode = clearSelectedNode;
        $scope.clearFromDate = clearFromDate;
        $scope.clearToDate = clearToDate;
        $scope.changeSearchType = changeSearchType;
        $scope.setSearchLocationType = setSearchLocationType;
        $scope.search = search;
        $scope.isProcessNode = isProcessNode;
        vm.openCompendiaDocument = openCompendiaDocument;
        vm.defaultExportFileName = globalResources.SearchResult;
        vm.openDocument = openDocument;
        vm.folderClick = folderClick;

        vm.isClickDocument = false;

        vm.areaGridSetting = [];
        vm.processes = {};
        vm.processAreas = {};
        vm.areasRecords = 0;
        vm.processRecords = 0;
        vm.goToProcess = goToProcess;
        vm.goToProcessArea = goToProcessArea;
        vm.enableProcess = HandbookConfiguration.EnableProcess.toUpperCase() == "TRUE" ? true : false;
        vm.maxHeight = 635;

        initialize();

        function initialize() {
            //check and resize the view
            if (vm.isMetadataSearch) {
                getRegisterItems();
            }
            if (vm.searchInFolders) {
                buildFoldersGridSetting();
            }
            buildAreaGridSetting();
            loadFolderTree();

            if (vm.enableProcess) {
                loadAreaTree();
            }

            resizeService.resizeView();

            getGridSetting(gridSettingKeys.commonVisibilitySettings);
            getColumnsDefinition(gridSettingKeys.commonVisibilitySettings);
            vm.getFolderInformation = getFolderInformation();

            vm.commonColumnsDefinition = angular.copy(optionalColumnsDenifinition);
            //TODO Why do we use these 2 lines?
            /*$scope.commonGridColumnDefinition = commonColumnsDefinition;
            $scope.optionalColumns = optionalColumnsDenifinition;*/


            if (vm.enabledCompendiaSearch) {
                var mandatatoryRequests = [
                    searchCompendiaDocuments(vm.keyword),
                    getSearchResult(E.searchType.Maximum)
                ];

                $q.all(mandatatoryRequests).then(function (response) {
                    $timeout(function () {
                        handleNavigate();                
                    }, 500);
                });
            } else {
                getSearchResult(E.searchType.Maximum, true);
            }

            activeButtonGroup(parseInt(vm.type), true);
            activeLocationTypeButtonGroup(vm.advancedSearchLocationType);
            vm.filter = {
                keyword: vm.keyword,
                searchInContents: vm.searchInContents,
                searchType: E.searchType.Maximum,
                folderId: vm.folderId,
                fromDate: vm.fromDate,
                toDate: vm.toDate,
                hasExpired: vm.hasExpired,
                registerItemId: vm.registerItemValueId != null ? null : vm.registerItemId,
                registerItemValueId: vm.registerItemValueId,
                advancedSearchLocationType: vm.advancedSearchLocationType,
                version: vm.version,
                documentType: vm.documentType
            };
            vm.exportParams = {
                folderId: vm.folderId,
                isRecursive: false,
                groupBy: E.exportDocumentGroupsByColumn.none,
                filter: vm.filter
            };
            vm.exportParams.columns = getDocumentColumnsForExporting(gridSettingKeys.commonVisibilitySettings);
        };

        $scope.$on('$stateChangeStart',
            function (event, toState, toParams, fromState, fromParams, options) {
                if (vm.isClickDocument
                    || vm.searchLogLevel != SEARCH_LOG_LEVEL.LOG_DOCUMENT_SELECTED_AND_0_HIT_AND_NO_SELECTION
                    || fromState.name != "searchDocuments" || vm.documents.length == 0 || vm.documents.length == undefined
                    || vm.documents == null) {
                    vm.isClickDocument = false;
                    return;
                }
                else {
                    insertLogWords(-2, user.userId, vm.keyword, $scope.selectedSearchType.id);
                }
                vm.isClickDocument = false;

            });

        function folderClick(id) {
            favoriteService.setFavoriteNodeState({ isFavorited: false });
            $state.go(handbookActions.FolderAction, { folderId: id });
        };

        function goToProcess(processNumber) {
            $state.go('process-detail', { processNumber: processNumber });
        }

        function goToProcessArea(areaId) {
            $state.go('process-area-detail', { areaId: areaId });
        }

        function handleNavigate() {
            var url = angular.copy($location.$$url);
            if (!url)
                return;
            url = url.toLowerCase();

            if (url.indexOf('tab?') == -1) {
                return;
            }

            if (vm.processes.length > 0 && url.indexOf('searchProcesses') > -1) {
                triggerTabClicked('#seachProcesses', false);
            }

            if (vm.documents.length > 0 && url.indexOf('searchDocuments') > -1) {
                triggerTabClicked('#searchDocuments', false);
            }

            if (vm.processAreas.length > 0 && url.indexOf('searchProcessAreas') > -1) {
                triggerTabClicked('#searchProcessAreas', false);
            }

            if (vm.folders.length > 0 && url.indexOf('searchFolders') > -1) {
                triggerTabClicked('#searchFolders', false);
            }
        }

        function triggerTabClicked(tabId, clickItSelf) {
            setTimeout(function () {
                var childTab = $(tabId + ' a');
                if (childTab) {
                    $(childTab).click();
                    if (clickItSelf && $(tabId)) {
                        $(tabId).click();
                    }
                }
            });
        }

        function buildFoldersGridSetting() {
            vm.foldersGridSetting.push({ id: 'name', name: globalResources.Folder, width: 50, coldefault: true, icon: 'icon' });
            vm.foldersGridSetting.push({ id: 'location', name: globalResources.CommonGridColumns.Location, width: 50, coldefault: true });
            vm.columnNotRemove = 'name';
        }

        function buildAreaGridSetting() {
            vm.areaGridSetting.push({ id: 'name', name: globalResources.ProcessArea, width: 50, coldefault: true, icon: 'icon' });
            vm.areaGridSetting.push({ id: 'location', name: globalResources.CommonGridColumns.Location, width: 50, coldefault: true });
            vm.columnNotRemove = 'name';
        }

        function openDocument(id) {
            vm.isClickDocument = true;
            insertLogWords(id, user.userId, vm.keyword, $scope.selectedSearchType.id);
        }

        $scope.$on(broadcastType.gridSettingTarget, function (e, target, gridSettingKey) {
            if (gridSettingKey == gridSettingKeys.commonVisibilitySettings) {
                vm.exportParams.columns = getDocumentColumnsForExporting(gridSettingKeys.commonVisibilitySettings);
            }
        });

        $document.bind('click', function (event) {
            var isClickedElementChildOfPopup = $('.folder-search')
                .find(event.target)
                .length > 0;

            if (isClickedElementChildOfPopup)
                return;
            $scope.showFolderTree = false;
        });

        $scope.$on('ngRepeatFinished', function (ngRepeatFinishedEvent) {
            adjustContentPosition();
        });

        function adjustContentPosition() {
            var tabState = tabStateService.getState(tabStateType.searchTabState);
            $timeout(function () {
                tabStateService.adjustContentPosition(tabState, tabStateType.searchTabState);
            }, 0, false);
        }

        function getRegisterItems() {
            if (vm.isMetadataSearch) {
                if (vm.advancedSearchLocationType == 2) {
                    $http.get('/api/MetaData/GetRegisterAndRegisterItemsForModule', { params: { application: 200 } })
                        .then(function (response) {
                            if (response && response.data) {
                                vm.initMetadata.metadatas = response.data;
                            }
                        })
                }
                else {
                    metaDataService.getRegisterAndRegisterItems().then(function (data) {
                        if (data) {
                            vm.initMetadata.metadatas = data;
                        }
                    });
                }

            }
        };

        $scope.$watch('vm.selectedItem.selectedMetadata', function (selectedMetadata) {
            if (vm.isMetadataSearch) {
                if (vm.startTag != 1) {
                    vm.selectedItem.selectedTag = null;
                    if (selectedMetadata != null && selectedMetadata != undefined) {
                        getMetadataTags(selectedMetadata.registerItemId);
                    }
                } else {
                    vm.startTag = 0;
                }
            }
        });

        function getMetadataTags(registerItemId) {
            if (vm.isMetadataSearch) {
                metaDataService.getMetadataTags(registerItemId).then(function (data) {
                    if (data) {
                        vm.initMetadata.tags = data;
                    }
                });
            }
        };

        function isProcessNode(node) {
            return isNaN(node.id);
        }

        function selectNodeHead(node) {
            if (!node.isLoaded && vm.advancedSearchLocationType == 1) {
                $http.get(handbookRequests.GetSubfoldersRequest, { params: { 'folderId': node.id } })
                    .success(function (data, status, headers, config) {
                        node.children = data;
                        node.isLoaded = true;
                    })
                    .error(function (data, status, headers, config) {
                        node.isLoaded = true;
                    });
            }
            else if (!node.isLoaded && vm.advancedSearchLocationType == 2) {
                $http.get('/api/ProcessAreas/GetContent', { params: { AreaId: node.id, ShowProcessesInTree: false, IsOnlyApproved: false } })
                    .success(function (data, status, headers, config) {
                        node.children = data.areas;
                        node.isLoaded = true;
                    })
                    .error(function (data, status, headers, config) {
                        node.isLoaded = true;
                    });
            }
        };

        function selectNodeLabel(node) {
            $scope.selectedNode = node;
            $scope.showFolderTree = false;
        };

        function clearSelectedNode() {
            $scope.selectedNode = null;
        }

        function clearFromDate() {
            $scope.fromDate = null;
        }

        function clearToDate() {
            $scope.toDate = null;
        }

        function activeButtonGroup(type, notCalculateHeigthGrid) {
            angular.element('#search-title-id').addClass('btn-disabled');
            angular.element('#search-content-id').addClass('btn-disabled');
            angular.element('#search-advance-id').addClass('btn-disabled');
            angular.element('#search-metadata-id').addClass('btn-disabled');
            if (type == 1) {
                angular.element('#search-title-id').removeClass('btn-disabled');
                $scope.selectedSearchType = $scope.searchTypes[0];
            } else if (type == 2) {
                angular.element('#search-content-id').removeClass('btn-disabled');
                $scope.selectedSearchType = $scope.searchTypes[1];
            } else if (type == 3) {
                angular.element('#search-advance-id').removeClass('btn-disabled');
                $scope.selectedSearchType = $scope.searchTypes[2];
            } else if (type == 4) {
                angular.element('#search-metadata-id').removeClass('btn-disabled');
                $scope.selectedSearchType = $scope.searchTypes[3];
            }

            var showMoreItem = (type == 3 || type == 4);
            if (!notCalculateHeigthGrid) {
                setHeightForGrid();
            }
        }

        function changeSearchType(type) {
            if (type == 1) {
                $scope.isAdvanceSearch = false;
                $scope.isMetadataSearch = false;
                $scope.searchPlaceHolder = $scope.translation.TitleSearch;
                $scope.selectedSearchType = $scope.searchTypes[0];
            } else if (type == 2) {
                $scope.isAdvanceSearch = false;
                $scope.isMetadataSearch = false;
                $scope.searchPlaceHolder = $scope.translation.ContentSearch;
                $scope.selectedSearchType = $scope.searchTypes[1];
            }
            else if (type == 3 && vm.enabledAdvanceSearch) {
                $scope.isAdvanceSearch = true;
                $scope.isMetadataSearch = false;
                $scope.searchPlaceHolder = $scope.translation.AdvanceSearch;
                $scope.selectedSearchType = $scope.searchTypes[2];
                activeLocationTypeButtonGroup(vm.advancedSearchLocationType);
            } else if (type == 4 && vm.enabledMetadataSearch) {
                $scope.isAdvanceSearch = false;
                $scope.isMetadataSearch = true;
                $scope.searchPlaceHolder = $scope.translation.MetadataSearch;
                $scope.selectedSearchType = $scope.searchTypes[3];
                activeLocationTypeButtonGroup(vm.advancedSearchLocationType);
            }
            setHeightForGrid();
            
            $timeout(function () {
                activeButtonGroup(type);
            }, 500);
        }

        function activeLocationTypeButtonGroup(type) {
            angular.element('#search-folder-id').addClass('label-btn-disabled');
            angular.element('#search-process-area-id').addClass('label-btn-disabled');
            if (type == 1) {
                angular.element('#search-folder-id').removeClass('label-btn-disabled');
            } else if (type == 2) {
                angular.element('#search-process-area-id').removeClass('label-btn-disabled');
            }
        }

        function setSearchLocationType(type) {
            vm.advancedSearchLocationType = type;
            clearSelectedNode();
            if (vm.isMetadataSearch) {
                getRegisterItems();
            }
            activeLocationTypeButtonGroup(type);
        }

        function search() {
            if ($scope.selectedSearchType.id == 1) {
                searchTitle();
            } else if ($scope.selectedSearchType.id == 2) {
                searchContent();
            } else if ($scope.selectedSearchType.id == 3) {
                searchAdvance();
            } else if ($scope.selectedSearchType.id == 4) {
                searchMetadata();
            }

            var searchCondition = ((vm.keyword != null && vm.keyword != "")
                || vm.folderId != ''
                || vm.fromDate != null
                || vm.toDate != null
                || (vm.registerItemId != null && vm.registerItemId != undefined && vm.registerItemId != 0))
                && stringValidationService.notContainSpecialCharacter(vm.keyword);
            if (!searchCondition) {
                return;
            }
            $state.go(handbookActions.SearchResultAction, {
                keyword: vm.keyword,
                searchInContents: vm.searchInContents ? 1 : 0,
                folderId: vm.folderId,
                fromDate: vm.fromDate,
                toDate: vm.toDate,
                hasExpired: vm.hasExpired ? 1 : 0,
                registerItemId: vm.registerItemId,
                registerItemValueId: vm.registerItemValueId,
                type: $scope.selectedSearchType.id
            });
        }

        function openCompendiaDocument(link) {
            window.open(link);
        }

        function searchTitle() {
            vm.keyword = $scope.keyword;
            vm.searchInContents = false;
            vm.folderId = null;
            vm.fromDate = null;
            vm.toDate = null;
            vm.hasExpired = false;
            vm.registerItemId = null;
            vm.registerItemValueId = null;
        }

        function searchContent() {
            vm.keyword = $scope.keyword;
            vm.searchInContents = true;
            vm.folderId = null;
            vm.fromDate = null;
            vm.toDate = null;
            vm.hasExpired = false;
            vm.registerItemId = null;
            vm.registerItemValueId = null;
        }

        function searchAdvance() {
            vm.keyword = $scope.keyword;
            vm.searchInContents = true;
            vm.folderId = $scope.selectedNode != null ? $scope.selectedNode.id : null;
            vm.folderName = $scope.selectedNode != null ? $scope.selectedNode.name : null;

            vm.fromDate = ($scope.fromDate != null && ($scope.toDate == null || $scope.fromDate <= $scope.toDate)) ? $scope.fromDate.getTime() : null;
            vm.toDate = ($scope.toDate != null && $scope.toDate <= vm.today) ? $scope.toDate.getTime() : null;
            vm.hasExpired = $scope.hasExpired;
            vm.registerItemId = null;
            vm.registerItemValueId = null;
        }

        function searchMetadata() {
            vm.keyword = $scope.keyword;
            vm.searchInContents = true;
            vm.folderId = $scope.selectedNode != null ? $scope.selectedNode.id : null;
            vm.folderName = $scope.selectedNode != null ? $scope.selectedNode.name : null;
            vm.fromDate = null;
            vm.toDate = null;
            vm.hasExpired = false;
            vm.registerItemId = vm.selectedItem.selectedMetadata != null ? vm.selectedItem.selectedMetadata.registerItemId : null;
            vm.registerItemValueId = vm.selectedItem.selectedTag != null ? vm.selectedItem.selectedTag.registerItemValueId : null;
        }

        function getSearchResult(searchType, reCalculateHeigth) {
            const quickSearchKeyword = vm.keyword ? vm.keyword.trim() : '';
            if (!quickSearchKeyword) {
                return;
            }
            var searchCondition = ((vm.keyword != null && vm.keyword != "")
                || vm.folderId != ''
                || vm.fromDate != null
                || vm.toDate != null
                || (vm.registerItemId != null && vm.registerItemId != undefined && vm.registerItemId != 0))
                && stringValidationService.notContainSpecialCharacter(vm.keyword);
            if (searchCondition) {
                vm.searchConditionTrue = true;

                vm.totalHits = specialCharacter.questionMark;
                vm.totalFound = specialCharacter.questionMark;
                if (vm.fromDate != null && typeof vm.fromDate != 'string') {
                    vm.fromDate = vm.fromDate.toLocaleDateString() + ' GMT';
                }
                if (vm.toDate != null && typeof vm.toDate != 'string') {
                    vm.toDate = vm.toDate.toLocaleDateString() + ' GMT';
                }
                if (vm.registerItemId) {
                    vm.searchInContents = true;
                }
                if (vm.enableProcess) {
                    if (vm.type != 3 && vm.type != 4) {
                        var processRequestParams = {
                            keyword: vm.keyword ? vm.keyword: '',
                            searchType: searchType,
                            isFrontend: true,
                            isContentSearch: vm.searchInContents
                        };
                        $http.get(handbookRequests.SearchProcessAreas, { params: processRequestParams })
                            .then(function (response) {
                                if (response != null && response.data != null && response.data.length) {
                                    vm.processAreas = response.data;
                                    angular.forEach(vm.processAreas, function (node) {
                                        node.icon = 'fa fa-folder areas-color';
                                    });
                                    vm.areasRecords = vm.processAreas.length;
                                }
                            });
                        getProcessSearchResult(vm.keyword ? vm.keyword : '', searchType);
                    }
                    else {
                        if (vm.folderId == null) {
                            advancedSearchProcess(vm.keyword, searchType)
                        }
                        else if (isNaN(vm.folderId)) {
                            return advancedSearchProcess(vm.keyword, searchType)
                        }
                    }
                }

                var searchRequestParams = {
                    keyword: vm.keyword,
                    searchInContents: vm.searchInContents,
                    searchType: searchType,
                    folderId: vm.folderId,
                    fromDate: vm.fromDate,
                    toDate: vm.toDate,
                    hasExpired: vm.hasExpired,
                    registerItemId: vm.registerItemValueId != null ? null : vm.registerItemId,
                    registerItemValueId: vm.registerItemValueId,
                    version: vm.version,
                    documentType: vm.documentType,
                    searchFilters: vm.searchParams,
                    showLoading: true,
                };

                vm.searchType = searchType;

                tabStateService.setCurrentStateType(tabStateType.searchTabState);

                return $http.get(handbookRequests.SearchRequest, { params: searchRequestParams })
                    .then(function (response, status, headers, config) {
                        if (response.data.documents != null && (response.data.documents.length > 0)) {
                            updateAttachmentsForDocuments(response.data.documents);
                            documentService.getAgreeFilesForDocuments(response.data.documents);
                            vm.documents = response.data.documents;
                            vm.totalHits = vm.documents.length;
                            vm.totalFound = response.data.totalCount;
                            var showMoreItem = (vm.type == 3 || vm.type == 4);
                        } else {
                            vm.totalHits = 0;
                            vm.totalFound = 0;
                            if (vm.searchLogLevel == SEARCH_LOG_LEVEL.LOG_DOCUMENT_SELECTED_AND_0_HIT
                                || vm.searchLogLevel == SEARCH_LOG_LEVEL.LOG_DOCUMENT_SELECTED_AND_0_HIT_AND_NO_SELECTION) {
                                insertLogWords(-1, user.userId, vm.keyword, $scope.selectedSearchType.id);
                            }
                        }
                        if (response.data.folders != null && response.data.folders.length > 0 && (vm.type != 3 && vm.type != 4)) {
                            vm.folders = response.data.folders;
                            angular.forEach(vm.folders, function (node) {
                                node.icon = getFolderClass(node.type)
                            });
                            vm.totalFolderHits = vm.folders.length;
                        }
                        showFolderSearch = (showFolderSearch && vm.folders.length > 0 || vm.processAreas.length > 0);
                        if (reCalculateHeigth) {
                            $timeout(function () {
                                setHeightForGrid();
                            }, 200);
                        }
                    });
            } else {
                vm.searchConditionTrue = false;
            }  
        }

        function advancedSearchProcess(keyword, searchType) {
            let searchParams = {
                keyword: keyword,
                isContentSearch: vm.searchInContents ? true : false,
                areaId: vm.folderId,
                metadataMustContainAll: vm.type == 4,
                myProcessOnly: false,
                processStatus: 2,
                fromDate: vm.fromDate,
                toDate: vm.toDate,
                searchType: searchType,
                registerItemId: vm.registerItemId,
                registerItemValueId: vm.registerItemValueId,
                dateFilter: 4,
                hasQuit: false,
                hasQuitApprove: false,
                includeSubAreas: vm.type == 3 || vm.type == 4,
                includeVirtualProcesses: true,
                isFrontend: true,
            }
            $http.get('/api/SearchProcess/SearchProcessesAdvance', { params: searchParams })
                .success(function (response) {
                    if (response != null && response.length) {
                        updateAttachmentsForProcesses(response);
                        vm.processes = response;
                        angular.forEach(vm.folders, function (node) {
                            node.icon = getFolderClass(node.type)
                        });
                        vm.processRecords = vm.processes.length;
                    }
                })
                .error(function (data, status, headers, config) {
                });
        }

        function getProcessSearchResult(keyword, searchType) {
            var processRequestParams = {
                keyword: keyword,
                searchType: searchType,
                isFrontend: true,
                isContentSearch: vm.searchInContents
            };

            $http.get(handbookRequests.SearchProcesses, { params: processRequestParams })
                .then(function (response) {
                    if (response != null && response.data != null && response.data.length) {
                        updateAttachmentsForProcesses(response.data);
                        vm.processes = response.data;
                        angular.forEach(vm.folders, function (node) {
                            node.icon = getFolderClass(node.type)
                        });
                        vm.processRecords = vm.processes.length;
                    }
                });

            $http.get(handbookRequests.SearchProcessAreas, { params: processRequestParams })
                .then(function (response) {
                    if (response != null && response.data != null && response.data.length) {
                        vm.processAreas = response.data;
                        angular.forEach(vm.processAreas, function (node) {
                            node.icon = 'fa fa-folder areas-color';
                        });
                        vm.areasRecords = vm.processAreas.length;
                    }
                });
        }

        function getFolderClass(nodeType) {
            switch (nodeType.toString()) {
                case E.nodeTypes.Folder:
                    return 'folder-5-icon';
                case E.nodeTypes.TopFolder:
                    return 'folder-6-icon';
                case E.nodeTypes.DepartmentFolder:
                    return 'folder-7-icon';
                case E.nodeTypes.RegionalFolder:
                    return 'folder-8-icon';
                default:
                    return 'folder-5-icon';
            }
        };

        function searchCompendiaDocuments(keyword) {
            var searchUrl = null;
            if (vm.type == 1) {
                searchUrl = handbookRequests.CompendiaDocument_TitleSearch;
            } else if (vm.type == 2) {
                searchUrl = handbookRequests.CompendiaDocument_ContentSearch;
            }

            if (searchUrl == null) {
                vm.compendiaDocuments = [];
                return;
            }

            return $http.get(searchUrl, { params: { keyword: keyword, showLoading: true } })
                .success(function (data) {
                    vm.compendiaDocuments = data;
                    showCompendiaSearch = (showCompendiaSearch && vm.compendiaDocuments.length > 0);
                });
        }

        function getFolderInformation() {
            if (vm.folderId != undefined && vm.folderId != 0) {
                if (!isNaN(vm.folderId)) {
                    var folder = folderService.getFolder();
                    if (folder == undefined) {
                        folderService.getFolderById(vm.folderId).then(function (response) {
                            vm.folderName = response.data.name;
                            $scope.selectedNode = response.data;
                        });
                    }
                    else {
                        vm.folderName = folder.name;
                        $scope.selectedNode = folder;
                    }
                }
                else {
                    $http.get('/api/ProcessAreas/GetContent', { params: { AreaId: vm.folderId, ShowProcessesInTree: false, IsOnlyApproved: false } })
                        .success(function (data, status, headers, config) {
                            vm.folderName = data.areaInformation.name;
                            $scope.selectedNode = data.areaInformation;
                        });
                }

            }
        };

        function getSearchFilter() {
            var filter = '';
            if (vm.keyword != null && vm.keyword != '') {
                filter = vm.keyword;
            }
            var folderIdNotNull = vm.folderId != 0 && vm.folderId != null,
                fromDateNotNull = vm.fromDateDisplayed != null,
                toDateNotNull = vm.toDateDisplayed != null,
                registerItemIdNotNull = vm.selectedItem.selectedMetadata != null,
                registerItemValueIdNotNull = vm.selectedItem.selectedTag != null,
                startOption = specialCharacter.space + specialCharacter.openParenthesis,
                endOption = specialCharacter.closeParenthesis,
                seperator = specialCharacter.comma + specialCharacter.space,
                colon = specialCharacter.space + specialCharacter.colon + specialCharacter.space;
            if ($scope.selectedSearchType.id == 3) {
                if (folderIdNotNull || fromDateNotNull || toDateNotNull || registerItemIdNotNull) {
                    if (folderIdNotNull) {
                        filter += startOption + globalResources.Chapter + colon + vm.folderName;
                    }
                    else {
                        filter += startOption;
                    }

                    if (fromDateNotNull && folderIdNotNull) {
                        filter += seperator + globalResources.From + colon + getDateStringFromInput(vm.fromDateDisplayed);
                    }
                    else if (fromDateNotNull) {
                        filter += globalResources.From + colon + getDateStringFromInput(vm.fromDateDisplayed);
                    }

                    if ((toDateNotNull && folderIdNotNull) || (toDateNotNull && fromDateNotNull)) {
                        filter += seperator + globalResources.To + colon + getDateStringFromInput(vm.toDateDisplayed) + endOption;
                    }
                    else if (toDateNotNull) {
                        filter += globalResources.To + colon + getDateStringFromInput(vm.toDateDisplayed) + endOption;
                    }
                    else {
                        filter += endOption;
                    }
                }
            } else if ($scope.selectedSearchType.id == 4) {
                if (folderIdNotNull || registerItemIdNotNull) {
                    if (folderIdNotNull) {
                        filter += startOption + globalResources.Chapter + colon + vm.folderName;
                    }
                    else {
                        filter += startOption;
                    }

                    if (registerItemIdNotNull) {
                        filter += seperator + globalResources.Metadata + colon + vm.selectedItem.selectedMetadata.name;
                    }

                    if (registerItemValueIdNotNull) {
                        filter += seperator + globalResources.Tag + colon + vm.selectedItem.selectedTag.registerValue + endOption;
                    }
                    else {
                        filter += endOption;
                    }
                }
            }

            return filter;
        };

        function loadFolderTree() {
            // Does not follow config showDocumentInTree
            $http.get(handbookRequests.GetFoldersRequest, { params: { 'id': null, 'showDocumentInTree': false } })
                .success(function (data, status, headers, config) {
                    $scope.folderTree = data;
                    if (vm.advancedSearchLocationType == 1)
                        loadSearchType();
                });
        }

        function loadAreaTree() {
            $http.get('/api/ProcessAreas/GetContent', { params: { AreaId: null, ShowProcessesInTree: false, IsOnlyApproved: false } })
                .success(function (data, status, headers, config) {
                    $scope.areaTree = data.areas;
                    if (vm.advancedSearchLocationType == 2)
                        loadSearchType();
                });
        }

        function loadSearchType() {
            if (vm.type == 3) {
                $scope.searchPlaceHolder = $scope.translation.AdvanceSearch;
                $scope.selectedSearchType = $scope.searchTypes[2];
                $scope.keyword = vm.keyword;
                $scope.fromDate = vm.fromDateDisplayed;
                $scope.toDate = vm.toDateDisplayed;
                $scope.hasExpired = vm.hasExpired;
                if (vm.advancedSearchLocationType == 1) {
                    for (var i = 0; i < $scope.folderTree.length; i++) {
                        if (vm.folderId == $scope.folderTree[i].id) {
                            $scope.selectedNode = $scope.folderTree[i];
                            vm.folderName = $scope.selectedNode != null ? $scope.selectedNode.name : null;
                            break;
                        }
                    }
                }
                else if (vm.advancedSearchLocationType == 2) {
                    for (var i = 0; i < $scope.areaTree.length; i++) {
                        if (vm.folderId == $scope.areaTree[i].id) {
                            $scope.selectedNode = $scope.areaTree[i];
                            vm.folderName = $scope.selectedNode != null ? $scope.selectedNode.name : null;
                            break;
                        }
                    }
                }

                $scope.isAdvanceSearch = true;
                $scope.isMetadataSearch = false;
            } else if (vm.type == 2) {
                $scope.searchPlaceHolder = $scope.translation.ContentSearch;
                $scope.selectedSearchType = $scope.searchTypes[1];
                $scope.keyword = vm.keyword;
                $scope.isAdvanceSearch = false;
                $scope.isMetadataSearch = false;
            } else if (vm.type == 1) {
                $scope.searchPlaceHolder = $scope.translation.TitleSearch;
                $scope.selectedSearchType = $scope.searchTypes[0];
                $scope.keyword = vm.keyword;
                $scope.isAdvanceSearch = false;
                $scope.isMetadataSearch = false;
            } else if (vm.type == 4) {
                $scope.searchPlaceHolder = $scope.translation.MetadataSearch;
                $scope.keyword = vm.keyword;
                $scope.selectedSearchType = $scope.searchTypes[3];
                $scope.isAdvanceSearch = false;
                $scope.isMetadataSearch = true;
                if (vm.advancedSearchLocationType == 1) {
                    for (var i = 0; i < $scope.folderTree.length; i++) {
                        if (vm.folderId == $scope.folderTree[i].id) {
                            $scope.selectedNode = $scope.folderTree[i];
                            vm.folderName = $scope.selectedNode != null ? $scope.selectedNode.name : null;
                            break;
                        }
                    }
                }
                else if (vm.advancedSearchLocationType == 2) {
                    for (var i = 0; i < $scope.areaTree.length; i++) {
                        if (vm.folderId == $scope.areaTree[i].id) {
                            $scope.selectedNode = $scope.areaTree[i];
                            vm.folderName = $scope.selectedNode != null ? $scope.selectedNode.name : null;
                            break;
                        }
                    }
                }
                initMetadataSearch();
            }
            $timeout(function () {
                vm.searchFilter = getSearchFilter();
            }, 700);
        }

        function initMetadataSearch() {
            if (vm.registerItemId && vm.registerItemId != 0) {
                getRegisterItems();
                getMetadataTags(vm.registerItemId);


                $timeout(function () {
                    if (vm.registerItemId && vm.registerItemId != 0) {
                        for (var i = 0; i < vm.initMetadata.metadatas.length; i++) {
                            var metadata = vm.initMetadata.metadatas[i];
                            if (vm.registerItemId == metadata.registerItemId) {
                                vm.selectedItem.selectedMetadata = metadata;
                                break;
                            }
                        }
                        if (vm.registerItemValueId && vm.registerItemValueId != 0) {
                            for (var i = 0; i < vm.initMetadata.tags.length; i++) {
                                var tag = vm.initMetadata.tags[i];
                                if (vm.registerItemValueId == tag.registerItemValueId) {
                                    vm.selectedItem.selectedTag = tag;
                                    break;
                                }
                            }
                        }
                        vm.startMetadata = 1;
                        vm.startTag = 1;
                    }
                }, 500);
            }
        };

        function onRowClick($event) {
            favoriteService.setFavoriteNodeState({
                isFavorited: false
            });
            documentService.goToDocument($event);
        };

        function loadByMaxSearchSize() {
            vm.loadMoreClickedCounter = 1;
            getSearchResult(E.searchType.Maximum);
        };

        function showLoadMoreLink(row) {
            var _isShow = vm.documents.length < vm.totalFound && vm.loadMoreClickedCounter == 0;
            var _isLastIndex = row.rowIndex == vm.documents.length - 1;

            if (_isShow && _isLastIndex) {
                return true;
            }
            return false;
        };

        function getDateStringFromInput(date) {
            return date.getDate() + '.' + (date.getMonth() + 1) + '.' + date.getFullYear();
        }

        function updateAttachmentsForDocuments(documents) {
            var documentIds = [];
            for (var i = 0; i < documents.length; i++) {
                if (documents[i].hasAttachment) {
                    documentIds.push(documents[i].id);
                }
            }
            if (documentIds.length > 0) {
                $http
                    .post('/api/Documents/GetAttachmentsForDocuments', { documentIds: documentIds })
                    .success(function (data) {
                        if (data && data.length > 0) {
                            data.forEach(function (x) {
                                x.itemId = x.extraId ? x.extraId : x.itemId;
                            });
                        }
                        for (var i = 0; i < documents.length; i++) {
                            if (documents[i].hasAttachment) {
                                documents[i].attachments = [];
                                for (var j = 0; j < data.length; j++) {
                                    if (data[j].documentId == documents[i].id) {
                                        documents[i].attachments.push(data[j]);
                                    }
                                }
                            }
                        }
                    });
            }
        }

        function updateAttachmentsForProcesses(processes) {
            if (processes == null || processes.length == 0) {
                return processes;
            }

            var processEntityIds = [];
            for (var i = 0; i < processes.length; i++) {
                if (processes[i].hasAttachment && processes[i].isProcess) {
                    processEntityIds.push(processes[i].entityId);
                }
            }
            if (processEntityIds.length > 0) {
                $http.get('/api/Processes/GetAttachmentsForProcesses', {
                    params: { processEntityIds },
                })
                    .success(function (data) {
                        if (data && data.length > 0) {
                            data.forEach(x => {
                                x.itemId = x.extraId ? x.extraId : x.itemId;
                            });
                        }
                        for (var i = 0; i < processes.length; i++) {
                            if (processes[i].hasAttachment) {
                                processes[i].attachments = [];
                                processes[i].attachmentHtml = '';
                                for (var j = 0; j < data.length; j++) {
                                    if (data[j].processEntityId === processes[i].entityId) {
                                        processes[i].attachments.push(data[j]);
                                    }
                                }
                            }
                        }
                    });
            }

        }

        function calculateRemainingHeightForDocumentGrids() {
            var heightOfTopBar = $('#handbook-nav').outerHeight(true);
            var heightOfBreadcrumbs = $('.search-result-page > .clearfix').outerHeight(true);
            var heightOfSearchButtons = $('.search-result-page > .button-group').outerHeight(true);
            var heightOfSearchForm = $('.search-result-page > .form-button').outerHeight(true);
            var heightOfAdvancedSearchForm = $scope.isAdvanceSearch ? $('.search-result-page .search-result-search-more').outerHeight(true) : 0;
            var heightOfHandbookDocumentsTitle = $('.search-result-page .search-document-title-hit').outerHeight(true);
            var heightOfCompendiaDocumentsTitle = !showCompendiaSearch
                ? 0 : $('.search-result-page .compendia-title-hit').outerHeight(true);
            var heightOfFolderSearchTitle = !showFolderSearch
                ? 0 : $('.search-result-page .search-folder-title-hit').outerHeight(true);

            return $(window).height() - heightOfTopBar - heightOfBreadcrumbs
                - heightOfSearchButtons - heightOfSearchForm - heightOfAdvancedSearchForm
                - heightOfHandbookDocumentsTitle
                - heightOfCompendiaDocumentsTitle
                - heightOfFolderSearchTitle;
        }
     

        function setHeightForGrid() {
            $timeout(function () {        
                var filter = $('.advanced-search-more').height();
                if (Number(filter) > 0) {
                    vm.maxHeight = 570;
                } else {
                    vm.maxHeight = 635;
                }
               calculateHeightForDocumentGrids();
            }, 100);
        }

        function calculateHeightForDocumentGrids() {
            $('.handbook-folders #gridController tbody').css('max-height', vm.maxHeight);
            $('.compendia-documents .content-wrapper').css('max-height', vm.maxHeight);
            $('.handbook-documents #gridController tbody').css('max-height', vm.maxHeight);
        }     

        function insertLogWords(documentId, employeeId, searchKey, searchType) {
            if (!vm.doSearchDataMining) {
                return;
            }

            vm.searchFilters = window.location.search;
            if (vm.searchFilters && vm.searchFilters != '') {
                if (documentId == -2) {
                    searchKey = decodeURI(vm.searchFilters.match("keyword=(.*)&search")[1]);
                    searchType = vm.searchFilters.substring(vm.searchFilters.length - 1);
                }

                return $http.post('/api/Search/LogSearchWords',
                    {
                        documentId: documentId,
                        employeeId: employeeId,
                        searchKey: searchKey,
                        searchType: searchType,
                        searchFilters: vm.searchFilters
                    }).then(function (data, status, headers, config) {
                        return true;
                    });
            }
        }
    };
})();;
(function () {
    var model = angular.module('managementModule', ['ngDraggable']);

    model.controller(controllers.manageFavoritesController, ['$scope', '$http', '$state', '$uibModal', '$uibModalInstance', 'broadcastService', 'items', 'pubSub', '$q', 'configService',
        function ($scope, $http, $state, $uibModal, $modalInstance, broadcastService, items, pubSub, $q, configService) {
            $scope.translation = globalResources;
            $scope.folders = [];
            $scope.forcedAndDepartmentFolders = [];
            $scope.originalFoldersData = [];
            $scope.documents = [];
            $scope.originalDocumentsData = [];
            $scope.emailSubsribed = [];
            $scope.manageFavoriteTabs = manageFavoriteTabs;
            $scope.currentTab = manageFavoriteTabs.folder;
            $scope.isChanged = false;
            $scope.isSortByAlphabet = true;
            $scope.runOnce = false;
            $scope.areas = [];
            $scope.processes = [];
            $scope.showSort = $scope.currentTab !== manageFavoriteTabs.emailSubscribed;

            $scope.simpleSubscription = configService.getBool(HandbookConfiguration.SimpleSubscription);
            $scope.enableProcessModule = configService.getBool(HandbookConfiguration.EnableProcess);

            initDataSource();

            $scope.loadEmailSubscribedFolder = function () {
                if ($scope.enableProcessModule) {
                     $http.get('/api/CombineDocumentAndProcess/GetUserEmailSubscriptionsForDocumentAndProcess')
                        .then(function (res) {
                            if (res) {
                                var items = []
                                items = res.data;
                                items.forEach(function (item) {
                                    if (checkFolder(item.type) || item.isProcessArea) {
                                        if (item.isRecursiveFolder) {
                                            item.subscriptionName = $scope.translation.FolderAndSubFolders;
                                        } else {
                                            item.subscriptionName = $scope.translation.FolderOnly;
                                        }
                                    }
                                });
                                $scope.emailSubsribed = items;
                            }
                        });
                    return;
                }
               
                $http.get(handbookRequests.GetUserEmailSubscriptionsForFoldersAndDocuments)
                     .then(function (result) {
                         result.data.forEach(function (item) {
                             if (checkFolder(item.type)) {
                                 if (item.isRecursiveFolder) {
                                     item.subscriptionName = $scope.translation.FolderAndSubFolders;
                                 } else {
                                     item.subscriptionName = $scope.translation.FolderOnly;
                                 }
                             }
                         });
                         $scope.emailSubsribed = result.data;
                     })
            };

            function checkFolder(type){
                if(type == E.nodeTypes.Folder || type == E.nodeTypes.TopFolder || type == E.nodeTypes.DepartmentFolder || type == E.nodeTypes.RegionalFolder){
                    return true;
                }
                return false;
            }

            $scope.removeAreaFromFavorites = function (area) {
                var params = {
                    areaId: area.id
                }
                var requestUrl = handbookRequests.RemoveAreaFromFavoritesRequest;
                confirmAndDeleteItem(area, requestUrl, $scope.areas, null, true, params);
            };

            $scope.removeProcessFromFavorites = function (process) {
                var params = {
                    processId: process.processId
                };
                var requestUrl = "/api/ProcessAreas/RemoveProcessFromFavorites/" + params;
                confirmAndDeleteItem(process, requestUrl, $scope.processes, null, true, params);
            };

            $scope.removeFolderFromFavorite = function (folder) {
                var requestUrl = handbookRequests.RemoveFavoriteFolder + '/' + folder.id;
                confirmAndDeleteItem(folder, requestUrl, $scope.folders, $scope.originalFoldersData, true);
            };

            $scope.removeDocumentFromFavorite = function (document) {
                var requestUrl = handbookRequests.RemoveFavoriteDocument + '/' + document.id;
                confirmAndDeleteItem(document, requestUrl, $scope.documents, $scope.originalDocumentsData, true);
            };

            $scope.removeEmailSubscribed = function (folder) {
                var requestUrl = '';
                var params;
                if (folder.isProcess) {
                    requestUrl = handbookRequests.RemoveProcessEmailSubscription;
                    params = { ProcessId: folder.id };
                    confirmAndDeleteItem(folder, requestUrl, $scope.emailSubsribed, null, false, { ProcessId: folder.id });
                    return;
                }
                else if (folder.isProcessArea) {
                    params = { AreaId: folder.id };
                    if (folder.isRecursiveFolder) {
                        requestUrl = handbookRequests.RemoveAreaAndItsChildrenFromEmailSubscription;
                    }
                    else {
                        requestUrl = handbookRequests.RemoveOnlyAreaFromEmailSubscription;
                    }
                    confirmAndDeleteItem(folder, requestUrl, $scope.emailSubsribed, null, false, { AreaId: folder.id });
                    return;
                }
                else if (checkFolder(folder.type)) {
                    params = false;
                    if (folder.isRecursiveFolder) {
                        requestUrl = handbookRequests.RemoveEmailSubscription + '/' + folder.id;
                    } else {
                        requestUrl = handbookRequests.RemoveOnlyFolderFromEmailSubscription + '/' + folder.id;
                    }
                } else {
                    params = false;
                    requestUrl = handbookRequests.RemoveEmailSubscriptionDocument + '/' + folder.id;
                }
                confirmAndDeleteItem(folder, requestUrl, $scope.emailSubsribed, null, false);
            };

            $scope.onDragSuccess = function (data, evt) {
                $scope.runOnce = false;
            };

            $scope.onDropComplete = function (index, obj, evt, isProcessAreaItem) {
                if (!$scope.runOnce) { // to prevent this evt run twice
                    $scope.isChanged = true;
                    var dataSource = isProcessAreaItem ? getSourceProcessAreasByItemType(obj.type) : getSourceByItemType(obj.type);
                    removeBorderAndUpdateOrder(index, evt.element, obj, dataSource, false, false);
                }
            }

            $scope.onDropCompleteForLastItem = function (index, obj, evt, isProcessAreaItem) {
                $scope.isChanged = true;
                var dataSource = isProcessAreaItem ? getSourceProcessAreasByItemType(obj.type) : getSourceByItemType(obj.type);
                removeBorderAndUpdateOrder(index, evt.element, obj, dataSource, false, true);
            }

            $scope.onDropCompleteForTopItem = function (index, obj, evt, isProcessAreaItem) {
                $scope.isChanged = true;
                var dataSource = isProcessAreaItem ? getSourceProcessAreasByItemType(obj.type) : getSourceByItemType(obj.type);
                removeBorderAndUpdateOrder(index, evt.element, obj, dataSource, true, false);
            }

            $scope.setCurrentTab = function (tab) {
                $scope.currentTab = tab;
                $scope.showSort = $scope.currentTab !== manageFavoriteTabs.emailSubscribed;
            };

            $scope.addCurrentActiveClass = function (id) {
                removeOldActiveDragItem();
                angular.element(prefix.hashbangPrefix + id).addClass(cssClass.currentDrag);
            };

            $scope.sortAlphabet = function () {
                if (!$scope.isSortByAlphabet) {
                    $scope.isChanged = true;
                    var source = getSourceByCurrentTab(false);
                    setOrderByAlphabet(source);
                }
            };

            $scope.cancel = function () {
                $modalInstance.close();
            };

            $scope.saveAndClose = function () {
                if ($scope.isChanged) {
                    $q.all([updateSortOrderProcessItems(), updateSortOrderHandbookItems()]).then(function () {
                        closeAndUpdateFavoriteTree();
                    });
                }
                else {
                    $modalInstance.close();
                }
            };

            function updateSortOrderHandbookItems() {
                var documents = reArrangeAndGetChangedSortOrderItems($scope.documents, $scope.originalDocumentsData);
                var folders = reArrangeAndGetChangedSortOrderItems($scope.folders, $scope.originalFoldersData);
                var updatedItems = documents.concat(folders);
                return $http.post(handbookRequests.UpdateFavoritesSortOrder, updatedItems)
                    .then(function () {
                        $scope.isChanged = false;
                        updateOriginalData();
                    });
            }

            function updateSortOrderProcessItems() {
                if ($scope.enableProcessModule) {
                    var originalAreas = angular.copy($scope.areas);
                    var originalProcesses = angular.copy($scope.processes);
                    var areas = reArrangeAndGetChangedSortOrderItems($scope.areas, originalAreas);
                    var processes = reArrangeAndGetChangedSortOrderItems($scope.processes, originalProcesses);
                    var params = {
                        areas: areas,
                        processes: processes
                    };
                    return $http.post("/api/ProcessAreas/UpdateFavoritesSortOrder", params)
                        .success(function (data, status, headers, config) {
                            if (data) {
                                pubSub.publish(broadcastType.updateFavoritesProcesses, true);
                            }
                        });
                }
            }

            function initDataSource() {
                for (var index = 0; index < items.length; index++) {
                    if (isFolder(items[index].type)) {
                        if (!items[index].isForced && items[index].type != E.nodeTypes.DepartmentFolder) {
                            $scope.folders.splice(index, 0, items[index]);
                            $scope.originalFoldersData.splice(index, 0, angular.copy(items[index]));
                        }
                        else {
                            $scope.forcedAndDepartmentFolders.splice(index, 0, items[index]);
                        }
                    }
                    else {
                        $scope.documents.splice(index, 0, items[index]);
                        $scope.originalDocumentsData.splice(index, 0, angular.copy(items[index]));
                    }

                    if (items[index].sort > 0) {
                        $scope.isSortByAlphabet = false;
                    }
                }
                loadProcessAndAreas();
            }

            function loadProcessAndAreas() {
                $http.get(handbookRequests.GetFavoritesItemsExcludeForcedFavoriteRequest)
                    .success(function (data, status, headers, config) {
                        if (data) {
                            decorateNodes(data.areas, data.processes);
                            $scope.areas = data.areas;
                            $scope.processes = data.processes;
                            var existedSort = $scope.areas.some(function (item) { return item.sort > 0; }) || $scope.processes.some(function (item) { return item.sort > 0; });
                            if (existedSort) {
                                $scope.isSortByAlphabet = false;
                            }
                        }
                    });
            }

            function decorateNodes(areas, processes) {
                if (areas && areas.length > 0) {
                    for (var i = 0; i < areas.length; i++) {
                        areas[i].type = 0;
                    }
                }
                if (processes && processes.length > 0) {
                    for (var i = 0; i < processes.length; i++) {
                        processes[i].type = 1;
                        processes[i].id = processes[i].processNumber;
                    }
                }
            }

            function isFolder(type) {
                return type > E.nodeTypes.ShortcutDocument;
            }

            function confirmAndDeleteItem(object, requestUrl, dataSource, originalDataSource, isUpdateFavoriteTree, params) {
                var modalInstance = $uibModal.open({
                    templateUrl: paths.ConfirmationView,
                    controller: controllers.confirmController,
                    resolve: {
                        item: function () {
                            return object.name;
                        }
                    }
                });

                modalInstance.result.then(function (isConfirm) {
                    if (isConfirm) {
                        $http.post(requestUrl, params)
                             .then(function () {
                                 //remove item in manage window
                                 dataSource.splice($.inArray(object, dataSource), 1);

                                 //remove item in original data
                                 if (originalDataSource != null) {
                                     removeItemFromList(object.id, originalDataSource);
                                 }
                                 //remove item in favorite tree
                                 if (isUpdateFavoriteTree) {
                                     broadcastToUpdateFavoriteTree(object);
                                     if ($scope.enableProcessModule) {
                                         pubSub.publish(broadcastType.updateFavoritesProcesses, true);
                                     }
                                 }
                             });
                    }
                });
            }

            function removeItemFromList(id, dataSource) {
                for (var index = 0; index < dataSource.length; index++) {
                    if (dataSource[index].id == id) {
                        dataSource.splice(index, 1);
                        break;
                    }
                }
            }

            function removeOldActiveDragItem() {
                var oldActive = angular.element.find(elementClass.currentDrag);
                if (oldActive.length > 0) {
                    oldActive.forEach(function (element) {
                        var css = element.className.replace(' ' + cssClass.currentDrag, '');
                        element.className = css;
                    });
                }
            }

            function broadcastToUpdateFavoriteTree(item) {
                var target = {
                    data: {
                        id: item.id,
                        name: item.name,
                        type: item.type,
                        isDocument: !isFolder(item.type)
                    },
                    requestType: requestType.removeRequest
                };
                broadcastService(broadcastType.favoriteTarget, target);
            }

            function removeBorderAndUpdateOrder(index, element, object, dataSource, isTop, isBottom) {
                element.removeClass(cssClass.dragEnter);
                if (isTop || isBottom) {
                    removeItemFromList(object.id, dataSource);
                    if (isTop) {
                        dataSource.splice(0, 0, object);
                    }
                    else {
                        dataSource.splice(dataSource.length, 0, object);
                    }
                }
                else {
                    var moveObjectIndex = dataSource.indexOf(object);
                    if (index != moveObjectIndex) {
                        removeItemFromList(object.id, dataSource);
                    }
                    if (index > moveObjectIndex) {
                        dataSource.splice(index, 0, object); //move down
                    }
                    if (index < moveObjectIndex) {
                        dataSource.splice(index + 1, 0, object); //move up
                    }
                }
                $scope.runOnce = true;
                removeOldActiveDragItem();
            }

            function getSourceByItemType(type) {
                if (isFolder(type)) {
                    return $scope.folders;
                } else {
                    return $scope.documents;
                }
            }

            function getSourceProcessAreasByItemType(type) {
                return type == 0 ? $scope.areas : $scope.processes;
            }

            function getSourceByCurrentTab(isOriginalSource) {
                switch ($scope.currentTab) {
                    case manageFavoriteTabs.folder:
                        if (isOriginalSource) {
                            return $scope.originalFoldersData;
                        }
                        else {
                            return $scope.folders;
                        }
                    case manageFavoriteTabs.document:
                        if (isOriginalSource) {
                            return $scope.originalDocumentsData;
                        }
                        else {
                            return $scope.documents;
                        }
                    case manageFavoriteTabs.processArea:
                        return $scope.areas;

                    case manageFavoriteTabs.process:
                        return $scope.processes;

                    default:
                        return $scope.folders;
                }
            }

            function reArrangeAndGetChangedSortOrderItems(dataSource, originalDataSource) {
                var changedItems = [];
                for (var index = 0; index < dataSource.length; index++) {
                    dataSource[index].sort = index;
                    if (dataSource[index].sort != originalDataSource[index].sort || dataSource[index].id != originalDataSource[index].id) {
                        changedItems.splice(changedItems.length, 0, dataSource[index]);
                    }
                }
                return changedItems;
            }

            function setOrderByAlphabet(dataSource) {
                dataSource.sort(function (item1, item2) {
                    if (item1.name.toLowerCase() > item2.name.toLowerCase())
                        return 1;
                    else
                        return -1;
                    return 0;
                });
                for (var index = 0; index < dataSource.length; index++) {
                    dataSource[index].sort = 0;
                }
            }

            function closeAndUpdateFavoriteTree() {
                var source = $scope.documents.concat($scope.folders).concat($scope.forcedAndDepartmentFolders);
                $modalInstance.close(source);
            }

            function updateOriginalData() {
                $scope.originalFoldersData = angular.copy($scope.folders);
                $scope.originalDocumentsData = angular.copy($scope.documents);
            }

        }]);

    model.controller(controllers.confirmController, ['$scope', 'item', '$uibModalInstance', function ($scope, item, $modalInstance) {
        $scope.translation = globalResources;
        $scope.confirmMessage = String.format(globalResources.DeleteConfirmMessage, '"' + item + '"');

        $scope.confirm = function () {
            $modalInstance.close(true);
        };

        $scope.cancel = function () {
            $modalInstance.close(false);
        };

    }]);

})();;
(function () {
	'use strict';

	angular.module('angularTreeview')
		.controller('frontpageTreeview', treeViewController);

	treeViewController.$inject = ['$scope', '$http', '$state', '$uibModal', '$location', '$timeout', 'favoriteService', 'treeNavigationService', 'documentService', 'pubSub', 'configService'];

	function treeViewController($scope, $http, $state, $uibModal, $location, $timeout, favoriteService, treeNavigationService, documentService, pubSub, configService) {
		$scope.showTreeFavorites = false;
		$scope.showTreeDocument = false;
		$scope.showTreeMyMostRead = false;
		$scope.showTreeMyLastVisited = false;
		$scope.showToggleSearchPanel = false;
		$scope.showTreeProcesses = false;
		$scope.enableProcessModule = configService.getBool(HandbookConfiguration.EnableProcess);
		$scope.documentList = {};
		$scope.favoritesList = {};
		$scope.myMostReadList = {};
		$scope.myLastVisitedList = {};
		$scope.showDocumentInTree = configService.getBool(HandbookConfiguration.ShowDocumentsInTree);

		var currentRecursiveIndex = 0;
		var parents = [];
		var previousRequest = { itemId: 0, itemType: '' };
		var initOpeningDocumentGroupAsDefault = false;
		var killProcessAreaRouteChanged = null;

		$scope.init = function () {
			openDefaultGroup();

			navigateToTreeMenuItem();
		};

		$scope.$on('$destroy', function () {
			killProcessAreaRouteChanged();
		});

		function openDefaultGroup() {
			const groupToOpenAsDefault = parseInt(HandbookConfiguration.GroupToOpenAsDefault);
			if (groupToOpenAsDefault != GROUP_TO_OPEN_AS_DEFAULTS.NONE) {
				switch (groupToOpenAsDefault) {
					case GROUP_TO_OPEN_AS_DEFAULTS.DOCUMENT:
						initOpeningDocumentGroupAsDefault = true;
						$scope.loadWhenSelectMenu("Document");
						break;
					case GROUP_TO_OPEN_AS_DEFAULTS.PROCESS:
						$scope.loadWhenSelectMenu("Processes");
						break;
				}
				killProcessAreaRouteChanged = pubSub.subscribe(broadcastType.processAreaRouteChanged, processAreaRouteChanged);
			}
		}

		function navigateToTreeMenuItem() {
			var urlParams = new URLSearchParams(window.location.search);
			var menuType = urlParams.get('treeMenu');
			switch (menuType) {
				case 'Favorites':
					$scope.loadWhenSelectMenu('Favorites');
					break;
				case 'MyLastVisited':
					$scope.loadWhenSelectMenu('MyLastVisited');
					break;
				default:
					break;
            }
			
		}

		$scope.clearSelect = function () {
			if (HandbookConfiguration.IsAuthenticated == "True" && HandbookConfiguration.IsAnonymous != "True") {
				if ($scope["favoritesTree"].currentNode) {
					var currentItem = getItemById($scope["favoritesTree"].currentNode.id, $scope.favoritesList);
					if (currentItem) {
						currentItem.selected = undefined;
					}
				}

				if ($scope["myMostReadTree"].currentNode && $scope["myMostReadTree"].currentNode.selected) {
					$scope["myMostReadTree"].currentNode.selected = undefined;
				}
				if ($scope["myLastVisitedTree"].currentNode && $scope["myLastVisitedTree"].currentNode.selected) {
					$scope["myLastVisitedTree"].currentNode.selected = undefined;
				}
			}

			if ($scope["documentTree"].currentNode && $scope["documentTree"].currentNode.selected) {
				$scope["documentTree"].currentNode.selected = undefined;
			}
		};

		$scope.selectNodeHead = function (node) {
			//check if type of selected node is in [1, 2, 3, 4] = [Document, LinkDocument, FileDocument, ShortcutDocument] refer to enum NodeType, we dont call request
			if (!node.isLoaded && node.type > 4) {
				switch (node.TreeFlag) {
					case "Document":
						$http.get(handbookRequests.GetFoldersRequest, { params: { 'Id': node.id, 'showDocumentInTree': $scope.showDocumentInTree } })
							.success(function (data, status, headers, config) {
								node.children = data;
								node.isLoaded = true;
								var isScroll = !$scope.showTreeFavorites && !$scope.showTreeMyMostRead && !$scope.showTreeMyLastVisited;
								treeNavigationService.onChildrenLoaded(node, isScroll);
							})
							.error(function (data, status, headers, config) {
								node.isLoaded = true;
							});
						break;
					case "Favorites":
						$http.get(handbookRequests.GetFoldersRequest, { params: { 'Id': node.id, 'showDocumentInTree': $scope.showDocumentInTree} })
							.success(function (data, status, headers, config) {
								node.children = data;
								node.isLoaded = true;
							})
							.error(function (data, status, headers, config) {
								node.isLoaded = true;
							});
						break;
				}
			}
		};

		$scope.IsFolderNode = function (node) {
			return node.type == E.nodeTypes.Folder || node.type == E.nodeTypes.TopFolder || node.type == E.nodeTypes.DepartmentFolder || node.type == E.nodeTypes.RegionalFolder;
		}

        $scope.selectNodeLabel = function (node) {
			angular.element('.selected:not(#' + node.id + '-label)').removeClass('selected');
			$scope.clearSelect();
			if (node.isFavorited != undefined && node.isFavorited == true) {
				favoriteService.setFavoriteNodeState({ isFavorited: true, id: node.id, type: node.type });
			} else {
				favoriteService.setFavoriteNodeState({ isFavorited: false, id: node.id, type: node.type });
			}

			if (node.treeId == 'documentTree') {
				//If we click on document tree we don't call Autohighlight function
				treeNavigationService.setIsDocumentTree(true);
				//Need to set timeout for set item selected
				$timeout(function () {
					if ($scope.IsFolderNode(node)) {
						angular.element('#' + node.id + '-label-f').addClass('selected');
					} else {
						angular.element('#' + node.id + '-' + node.virtualHandbookId + '-label').addClass('selected');
					}
				});
			}
			if ($scope.IsFolderNode(node)) {
				$state.go(handbookActions.FolderAction, { folderId: node.id });
            } else {
				documentService.goToDocument(node.id, node.defaultFieldView);
			}
		};

		$scope.loadWhenSelectMenu = function (menuType) {
            $scope.showHideMenuLeft(menuType);
			switch (menuType) {
				case "Document":
					$scope.showTreeDocument = !$scope.showTreeDocument;
					if ($scope.showTreeDocument) {
						var node = angular.element('#treeDocuments .selected');
						if (node && node.length > 0) {
							$timeout(function () {
								treeNavigationService.scrollToVisibleView(node);
							});
						}
					}
					if ($scope.showTreeDocument && $scope.documentList.length == undefined) {
						$http.get(handbookRequests.GetFoldersRequest, { params: { 'Id': null, 'showDocumentInTree': $scope.showDocumentInTree } })
							.success(function (data, status, headers, config) {
								$scope.documentList = data;
								treeNavigationService.navigateToItemLocation(true);
								if (parseInt(HandbookConfiguration.DocumentRootItemToExpand) !== NONE_DOCUMENT_ROOT_ITEM_TO_EXPAND
									&& initOpeningDocumentGroupAsDefault) {
									initOpeningDocumentGroupAsDefault = false;
									if ($scope.documentList && $scope.documentList.length > 0) {
										var node = null;
										const documentRootItemToExpandId = parseInt(HandbookConfiguration.DocumentRootItemToExpand);
										for (var i = 0; i < $scope.documentList.length; i++) {
											if ($scope.documentList[i].id == documentRootItemToExpandId) {
												node = $scope.documentList[i];
												break;
											}
										}
										if (node != null) {
											node.TreeFlag = "Document";
											node.collapsed = true;
											$scope.selectNodeHead(node);
										}
									}
								}
							});
					}
					break;
				case "Favorites":
					$scope.showTreeFavorites = !$scope.showTreeFavorites;
					if ($scope.showTreeFavorites && $scope.favoritesList.length == undefined) {
						$http.get(handbookRequests.GetFavoritesRequest).
							success(function (data, status, headers, config) {
								getFavoritesData(data);
							});
					}
					break;
				case "MyMostRead":
					$scope.showTreeMyMostRead = !$scope.showTreeMyMostRead;
					if ($scope.showTreeMyMostRead && $scope.myMostReadList.length == undefined) {
						$http.get(handbookRequests.GetMostViewedDocumentsRequest).
							success(function (data, status, headers, config) {
								$scope.myMostReadList = data;
							});
					}
					break;
				case "MyLastVisited":
					$scope.showTreeMyLastVisited = !$scope.showTreeMyLastVisited;
					if ($scope.showTreeMyLastVisited && $scope.myLastVisitedList.length == undefined) {
						$http.get(handbookRequests.GetRecentDocumentsRequest).
							success(function (data, status, headers, config) {
								$scope.myLastVisitedList = data;
							});
					}
					break;
				case "ToggleSearchPanel":
					$scope.showToggleSearchPanel = true;
					break;
				case "Processes":
					$scope.showTreeProcesses = !$scope.showTreeProcesses;
					$state.go('areas-root-view');
					break;
			}
		};

		$scope.showHideMenuLeft = function (menuType) {
			$scope.showTreeFavorites = (menuType != "Favorites") ? false : $scope.showTreeFavorites;
			$scope.showTreeMyMostRead = (menuType != "MyMostRead") ? false : $scope.showTreeMyMostRead;
			$scope.showTreeMyLastVisited = (menuType != "MyLastVisited") ? false : $scope.showTreeMyLastVisited;
			$scope.showTreeDocument = (menuType != "Document") ? false : $scope.showTreeDocument;
			$scope.showToggleSearchPanel = (menuType != "ToggleSearchPanel") ? false : $scope.showToggleSearchPanel;
			$scope.showTreeProcesses = (menuType != "Processes") ? false : $scope.showTreeProcesses;
		};

        $scope.$on(broadcastType.onTreeNavigation, function (e, target) {
			treeNavigationService.changeRoute();
			var element = $location.path().split('/');
			var requestParams = {
				itemId: element[2],
				itemType: element[1]
			};
			if (previousRequest.itemId == requestParams.itemId && requestParams.itemType == requestParams.itemType) {
				return;
			}
			previousRequest = angular.copy(requestParams);
			if (target.parents != null && target.parents.length > 0) {
				navigateToCurrentItem(target.parents);
			}
		});

        $scope.$on(broadcastType.collapseExpandSidebar, function (e, target) {
			//Get flag to check user click on tree
			//If click on document tree we will not call Autohighlight 
			var isDocumentTree = treeNavigationService.getIsDocumentTree();
			if (target.navigateSideBar && !isDocumentTree) {
				treeNavigationService.changeRoute();
				navigateToCurrentItem(null);
			} else {
				treeNavigationService.setIsDocumentTree(false);
			}
		});

		$scope.$on(broadcastType.onOpeningSidebarMenu, function (e, target) {
			$scope.loadWhenSelectMenu(target.menu);
		});

		function processAreaRouteChanged(target) {
			if (!$scope.showTreeProcesses)
				$scope.showTreeProcesses = !$scope.showTreeProcesses;
		}

		function navigateToCurrentItem(parents) {
			if ($scope.showTreeDocument == false) {
				if (!$scope.showTreeFavorites && !$scope.showTreeMyMostRead && !$scope.showTreeMyLastVisited) {
					$scope.showTreeDocument = true;
					$scope.showHideMenuLeft('Document');
				}
				if ($scope.documentList.length == undefined) {
					$http.get(handbookRequests.GetFoldersRequest, { params: { 'Id': null, 'showDocumentInTree': $scope.showDocumentInTree } })
						.success(function (data, status, headers, config) {
							$scope.documentList = data;
							makeRecursiveParentRequest(parents);
						});
				} else {
					makeRecursiveParentRequest(parents);
				}
			} else {
				makeRecursiveParentRequest(parents);
			}
		};

        function makeRecursiveParentRequest(parents) {
			treeNavigationService.setDocumentsTree($scope["documentTree"]);
			var isScroll = !$scope.showTreeFavorites && !$scope.showTreeMyMostRead && !$scope.showTreeMyLastVisited;
			if (parents == null || parents.length == 0) {
				var element = $location.path().split('/');
				treeNavigationService.setNodeType($location.path().indexOf('document/') >= 0 ? treeNodeTypes.document : treeNodeTypes.folder);
				var requestParams = {
					itemId: element[2],
					itemType: element[1]
				};
				if (requestParams.itemId) {
					$http.get(handbookRequests.GetParentFoldersRequest, { params: requestParams })
						.then(function (response, status, headers, config) {
							var _parents = buildBreadcrumbs(response.data);
							treeNavigationService.navigateToCurrentItem($scope.documentList, _parents, isScroll);
						});
				}
			} else {
				treeNavigationService.navigateToCurrentItem($scope.documentList, parents, isScroll);
			}
        }

		function buildBreadcrumbs(data) {
			var result = [];
			var totalItem = data.length;

			//move root to result array
			for (var i = 0; i < data.length; i++) {
				if (data[i].parentFolderId == null) {
					result.push(data[i]);
					data.splice(i, 1);
					break;
				}
			}

			//fill in the rest
			var currentItem = 0;
			while (result.length != totalItem && currentItem <= result.length) {
				for (var i = 0; i < data.length; i++) {
					if (result[currentItem].id == data[i].parentFolderId) {
						result.push(data[i]);
						data.splice(i, 1);
						break;
					}
				}
				currentItem++;
			}

			return result;
		};

		$scope.popupModal = function () {
			var modalInstance = $uibModal.open({
				templateUrl: paths.ManageFavoritesView,
				controller: controllers.manageFavoritesController,
				size: 'lg',
				backdrop: 'static',
				resolve: {
					items: function () {
						var data = angular.copy($scope.favoritesList);
						return data;
					}
				}
			});

			modalInstance.result.then(function (items) {
				if (items != undefined) {
					$scope.favoritesList = items;
				}
			});
		};

		$scope.$on(broadcastType.documentOpenedTarget, function (e, target) {
			if ($scope.myLastVisitedList.length != undefined) {
				updateLastVisitedList(target);
			}
		});

		$scope.$on(broadcastType.favoriteTarget, function (e, target) {
			$scope.refreshFavorites();
		});

		function addOrRemoveFavoriteItem(target) {
			if (target.requestType == requestType.addRequest) {
				target.data.isFavorited = true;
				if (target.data.type > E.nodeTypes.ShortcutDocument) {
					var lastDocumentIndex = getLastFavoriteDocumentIndex();
					$scope.favoritesList.splice(lastDocumentIndex, 0, target.data);
				}
				else {
					$scope.favoritesList.splice(0, 0, target.data);
				}
			}
			else {
				if (target.data.isDocument) {
					removeDocumentInfavoritesList(target);
				} else {
					removeFolderInfavoritesList(target)
				}
				// Remove favorite state
				favoriteService.setFavoriteNodeState({
					isFavorited: false, id: target.data.id, type: 0
				});
			}
		}

		function removeFolderInfavoritesList(target) {
			for (var index = 0; index < $scope.favoritesList.length; index++) {
				if ($scope.favoritesList[index].id == target.data.id && $scope.IsFolderNode($scope.favoritesList[index])) {
					$scope.favoritesList.splice(index, 1);
					break;
				}
			}
		}

		function removeDocumentInfavoritesList(target) {
			for (var index = 0; index < $scope.favoritesList.length; index++) {
				if ($scope.favoritesList[index].id == target.data.id && isDocumentNode($scope.favoritesList[index].type)) {
					$scope.favoritesList.splice(index, 1);
					break;
				}
			}
		}

		function isDocumentNode(type) {
			return type == E.nodeTypes.Document || type == E.nodeTypes.LinkDocument || type == E.nodeTypes.FileDocument || type == E.nodeTypes.ShortcutDocument;
		}

		function getFavoritesData(data) {
			for (var i = 0; i < data.length; i++) {
				data[i].isFavorited = true;
			}

			$scope.favoritesList = data;
		};

		function getLastFavoriteDocumentIndex() {
			var lastDocumentIndex = 0;
			for (var index = 0; index < $scope.favoritesList.length; index++) {
				if ($scope.favoritesList[index].type > E.nodeTypes.ShortcutDocument) {
					lastDocumentIndex = index;
					break;
				}
			}
			return lastDocumentIndex;
		}

		function updateLastVisitedList(target) {
			// Flag:  Check my last visited tree is selected
			var isSelectedTree = ($scope["myLastVisitedTree"].currentNode && $scope["myLastVisitedTree"].currentNode.selected);
			//Update  currentNode.selected = undefined if my last visited tree is selected
			if (isSelectedTree) {
				$scope["myLastVisitedTree"].currentNode.selected = undefined;
			}

			for (var index = 0; index < $scope.myLastVisitedList.length; index++) {
				if ($scope.myLastVisitedList[index].id == target.id) {
					$scope.myLastVisitedList.splice(index, 1);
					break;
				}
			}
			if ($scope.myLastVisitedList.length == HandbookConfiguration.RecentItemsCount) {
				$scope.myLastVisitedList.splice($scope.myLastVisitedList.length - 1, 1);
			}
			$scope.myLastVisitedList.splice(0, 0, target);
			//if my last visited tree is selected
			if (isSelectedTree) {
				$scope["myLastVisitedTree"].currentNode = $scope.myLastVisitedList[0];
				$scope["myLastVisitedTree"].currentNode.selected = cssClass.selected;
			}
		}

		function getItemById(id, source) {
			for (var index = 0; index < source.length; index++) {
				if (source[index].id == id) {
					return source[index];
					break;
				}
			}
			return null;
		}

		$scope.refreshFavorites = function () {
			$http.get(handbookRequests.GetFavoritesRequest).
				success(function (data, status, headers, config) {
					getFavoritesData(data);
				});
		}

		$scope.refreshDocument = function () {
			$http.get(handbookRequests.GetFoldersRequest, { params: { 'Id': null, 'showDocumentInTree': $scope.showDocumentInTree } })
				.success(function (data, status, headers, config) {
					$scope.documentList = data;
					treeNavigationService.navigateToItemLocation(true);
				});
		}

		$scope.goToProcessAreasRootView = function () {
			$state.go('areas-root-view');
		}
	};

})();

;

(function () {
    'use strict';

    angular.module(modules.printingModule, [])
           .controller(controllers.printingController, printController);

    printController.$inject = ['$scope'];

    function printController($scope) {
        $scope.init = function () {
            getGridSetting();
            $scope.columnsSetting = commonGridSetting;
            window.print();
        };
    };

})();;
(function () {
    var model = angular.module('feedbackModule', []);

    model.controller(controllers.feedbackController, ['$scope', '$http', '$uibModal', 'feedBackService', '$uibModalInstance', 'model', '$sce', 'configService',
        function ($scope, $http, $uibModal, feedBackService, $modalInstance, model, $sce, configService) {

            var vm = this;

            $scope.globalResources = angular.copy(globalResources);
            $scope.globalResources.Feedback_Message = $sce.trustAsHtml(globalResources.Feedback_Message);
            $scope.globalResources.Feedback_Message1 = $sce.trustAsHtml(globalResources.Feedback_Message1);
            $scope.globalResources.FeedBackCheckLabel = $sce.trustAsHtml(globalResources.FeedBackCheckLabel);
            $scope.globalResources.FeedBackCheckLabelA = $sce.trustAsHtml(globalResources.FeedBackCheckLabelA);
            $scope.globalResources.FeedBackCheckLabelB = $sce.trustAsHtml(globalResources.FeedBackCheckLabelB);
            $scope.globalResources.FeedBackCheckLabelC = $sce.trustAsHtml(globalResources.FeedBackCheckLabelC);
            $scope.globalResources.FeedBackCheckLabelD = $sce.trustAsHtml(globalResources.FeedBackCheckLabelD);
            $scope.globalResources.FeedBackCheckLabelE = $sce.trustAsHtml(globalResources.FeedBackCheckLabelE);
            $scope.globalResources.FeedBackCheckLabelF = $sce.trustAsHtml(globalResources.FeedBackCheckLabelF);
            $scope.globalResources.FeedBackCheckLabelG = $sce.trustAsHtml(globalResources.FeedBackCheckLabelG);
            $scope.globalResources.FeedBackCheckLabelH = $sce.trustAsHtml(globalResources.FeedBackCheckLabelH);

            $scope.feedBackLabels = [
                { value: 1, text: $scope.globalResources.FeedBackCheckLabelA, positive: true, result: 0 },
                { value: 2, text: $scope.globalResources.FeedBackCheckLabelB, positive: true, result: 0 },
                { value: 1, text: $scope.globalResources.FeedBackCheckLabelD, positive: false, result: 0 },
                { value: 2, text: $scope.globalResources.FeedBackCheckLabelE, positive: false, result: 0 },
                { value: 4, text: $scope.globalResources.FeedBackCheckLabelF, positive: false, result: 0 },
                { value: 8, text: $scope.globalResources.FeedBackCheckLabelG, positive: false, result: 0 },
                { value: 16, text: $scope.globalResources.FeedBackCheckLabelH, positive: false, result: 0 }
            ];

            if (HandbookConfiguration.RecipientsForFeedbackMail == E.RecipientsForFeedbackMail.OwnerOnly) {
                $scope.isOwnerOnly = true;
            }

            vm.enableExtendedFeedback = configService.getBool(HandbookConfiguration.EnableExtendedFeedback);
            $scope.enableExtendedFeedback = vm.enableExtendedFeedback;

            $scope.currentData = {
				positive: model.positive,
                feedbackMessage: '',
                feedBack: 0,
                sendAlsoToApprover: false
            };

            $scope.sendFeedback = function () {
                if (vm.enableExtendedFeedback) {
                    const selectedOption = getSelectedFeedBack();
                    if (selectedOption) {
                        $scope.currentData.feedbackMessage = selectedOption + $scope.currentData.feedbackMessage;
					}
					if (!validFeedBack()) {
						alert(globalResources.PleaseEnterFeedback);
						return false;
					}
                }
                return feedBackService
					.sendFeedback(model.entityId, $scope.currentData)
                    .then(function (response) {
                        if (response) {
                            $modalInstance.close(true);
                            resetCurrentData();
                            alert(globalResources.ThanksForYourFeedback);
                        }
                    });
            };

            $scope.close = function () {
                $modalInstance.close(true);
            };

            $scope.calculateFeedBack = function () {
                var count = 0;

                var feedBackLabels = $scope.feedBackLabels || [];
                for (var i = 0; i < feedBackLabels.length; i++) {
                    var x = feedBackLabels[i];
                    if (parseInt(x.result) > 0) {
                        count = count + parseInt(x.result);
                    }
                }

                $scope.currentData.feedBack = count;
            }

            function validFeedBack() {
                if ($scope.currentData.positive != null && ($scope.currentData.feedbackMessage || $scope.currentData.feedBack)) {
                    return true;
                }
                return false;
            }

            function resetCurrentData() {
                $scope.currentData.positive = null;
                $scope.currentData.feedbackMessage = '';
                $scope.currentData.feedBack = 0;
                $scope.currentData.sendAlsoToApprover = false;
            }

            function getSelectedFeedBack() {
                var value = '';

                var feedBackLabels = $scope.feedBackLabels || [];
                for (var i = 0; i < feedBackLabels.length; i++) {
                    var x = feedBackLabels[i];
                    if (parseInt(x.result) > 0) {
                        value = value + x.text + '\n';
                    }
                }

                return value;
            }

        }]);

})();;
(function () {
    'use strict';

    angular.module('handbookApp')
        .config(['$stateProvider', '$urlRouterProvider', '$locationProvider', routesConfig]);

    function routesConfig($stateProvider, $urlRouterProvider, $locationProvider) {
        $locationProvider.hashPrefix('!');
        $locationProvider.html5Mode(true);
        var internalPaths = window.paths;

		var templateUrlFieldView = internalPaths.DocumentFields;
		var controllerFieldView = 'DocumentFieldsController';

		if (parseInt(HandbookConfiguration.DocumentViewOption) == 2) {
			templateUrlFieldView = '/Document/fieldsContentWholeDocument';
			controllerFieldView = 'FieldsContentWholeDocumentController';
		}

        // Now set up the states
        $stateProvider
            .state('tab', {
                url: '/tab',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Home,
                    description: globalResources.HomeMetaDescription
                }
            })
            .state(handbookActions.DocumentAction, {
                url: handbookActionParameters.DocumentActionParameters,
                templateUrl: internalPaths.DocumentHome,
                controller: 'DocumentController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Document,
                    description: globalResources.DocumentMetaDescription
                }
            })
            .state(handbookActions.DocumentFromFieldViewAction, {
                url: handbookActionParameters.DocumentFromFieldViewActionParameters,
                templateUrl: internalPaths.DocumentHome,
                controller: 'DocumentController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Document,
                    description: globalResources.DocumentMetaDescription
                }
            })
            .state(handbookActions.HearingAction, {
                url: '/document/:documentId/hearing',
                templateUrl: '/Document/HearingFeedback',
                controller: 'HearingFeedbackController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Document,
                    description: globalResources.DocumentMetaDescription
                }
            })
            .state('hearingFieldsContent', {
                url: '/document/:documentId/hearingfields/:fieldId',
                templateUrl: '/Document/HearingFieldsContent',
                controller: 'DocumentHearingFieldsController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Document,
                    description: globalResources.DocumentMetaDescription
                }
            })
            .state('hearingCompareWithEarlierVersion', {
                url: '/documenthearing/:documentId/compareWithEarlierVersion',
                templateUrl: '/Document/CompareWithEarlierVersion',
                controller: 'CompareWithEarlierVersionController',
				controllerAs: 'vm',
                data: {
                    title: globalResources.Document,
                    description: globalResources.DocumentMetaDescription
                }
			})
			.state('compareWithEarlierVersion', {
				url: '/document/:documentId/compareWithEarlierVersion',
				templateUrl: '/Document/DocumentCompareWithEarlierVersion',
				controller: 'DocumentCompareWithEarlierVersionController',
				controllerAs: 'vm',
				data: {
					title: globalResources.Document,
					description: globalResources.DocumentMetaDescription
				}
			})
            .state(handbookActions.FolderAction, {
                url: handbookActionParameters.FolderActionParameters,
                templateUrl: internalPaths.ChapterHome,
                controller: 'chapterController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Folder,
                    description: globalResources.FolderMetaDescription
                }
            })
            .state(handbookActions.HomeAction, {
                url: handbookActionParameters.HomeActionParameters,
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Home,
                    description: globalResources.HomeMetaDescription
                }
            })
            .state(handbookActions.SearchResultAction, {
                url: handbookActionParameters.SearchResultActionParameters,
                templateUrl: internalPaths.ChapterSearch,
                controller: 'searchController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Search,
                    description: globalResources.SearchMetaDescription
                }
            })
            .state(handbookActions.DocumentFieldsAction, {
                url: '/document/:documentId/fields/:fieldId',
				templateUrl: templateUrlFieldView,
				controller: controllerFieldView,
                controllerAs: 'vm',
                data: {
                    title: globalResources.Document,
                    description: globalResources.DocumentMetaDescription
                }
            })
            .state(handbookActions.StartpageNews, {
                url: handbookActionParameters.StartpageNewsParameters,
                templateUrl: internalPaths.NewsDetais,
                controller: 'NewsDetailsController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Home,
                    description: globalResources.HomeMetaDescription
                }
            }).state(handbookActions.UnsupportBrowser, {
                url: '/unsupportedBrowser',
                templateUrl: '/app/components/home/templates/unsupportedBrowser.html',
                controller: 'homeController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Home,
                    description: globalResources.HomeMetaDescription
                }
            }).state(handbookActions.MyReadingReceiptsReport, {
                url: "/myReadingReceipts/params?folderId&recursive",
                templateUrl: '/app/components/home/templates/reportsView.html',
                controller: 'reportsViewController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Home,
                    description: globalResources.HomeMetaDescription
                }
            }).state(handbookActions.MyReadingListsReport, {
                url: "/myReadingLists",
                templateUrl: '/app/components/home/templates/reportsMyReadingListView.html',
                controller: 'reportsMyReadingListViewController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Home,
                    description: globalResources.HomeMetaDescription
                }
            }).state(handbookActions.NewsListAction, {
                url: '/newsList/:pageIndex',
                params: {
                    pageIndex: 1
                },
                templateUrl: '/app/components/home/view/newsList.html',
                controller: 'NewsListController',
                controllerAs: 'vm',
                data: {
                    title: globalResources.Home,
                    description: globalResources.HomeMetaDescription
                }
            }).state(handbookActions.NewsCategoryAction, {
                url: '/newscategory/:categoryId',
                templateUrl: '/app/components/home/view/newsCategory.html',
                controller: 'NewsCategoryController',
                controllerAs: 'vm',
                params: {
                    categoryId: '',
                    pageIndex: '1'
                },
                data: {
                    title: globalResources.Home,
                    description: globalResources.HomeMetaDescription
                }
            }).state('embedDocument', {
                url: '/embed/document/:documentId',
                templateUrl: internalPaths.DocumentHome,
                controller: 'DocumentController',
                controllerAs: 'vm',
                data: {
                    title: '',
                    description: ''
                }
            }).state('embedDocumentField', {
                url: '/embed/document/:documentId/field/:fieldId/:type',
                templateUrl: internalPaths.DocumentFields,
                controller: 'DocumentFieldsController',
                controllerAs: 'vm',
                params: {
                    type: 0
                },
                data: {
                    title: '',
                    description: ''
                }
            }).state('embedDocumentField1', {
                url: '/embed/document/:documentId/field/:fieldId',
                templateUrl: internalPaths.DocumentFields,
                controller: 'DocumentFieldsController',
                controllerAs: 'vm',
                params: {
                    type: 0
                },
                data: {
                    title: '',
                    description: ''
                }
            }).state('annualCycleDetail', {
                url: '/annualCycle/:id',
                templateUrl: '/app/components/annualCycle/annualCycleDetail.html',
                controller: 'annualCycleDetailController',
                controllerAs: 'vm',
                params: {
                    id: ''
                },
                data: {
                    title: globalResources.AnnualCycle,
                    description: ''
                }
            })

        $urlRouterProvider.otherwise(handbookActionParameters.HomeActionParameters);
    };

    angular.module('handbookApp').run(['$rootScope', '$location', '$timeout', 'anchorService', 'documentService', 'broadcastService',
        function ($rootScope, $location, $timeout, anchorService, documentService, broadcastService) {
            $rootScope.$on('$locationChangeSuccess', function () {
                $rootScope.actualLocation = $location.absUrl();
			});
			$rootScope.$on('$locationChangeStart', function (event, next, current) {
				if (next && next.indexOf('fields') > 0) {
					$location.$$absUrl = decodeURIComponent($location.$$absUrl);
					var indexHash = $location.$$absUrl.indexOf('#');
					if (indexHash > 0 && !$location.$$hash) {
						var length = $location.$$absUrl.length - (indexHash + 1);
						$location.$$hash = $location.$$absUrl.substr(indexHash + 1, length);
					}
					$location.$$url = decodeURIComponent($location.$$url);
				}
			});
            $rootScope.$watch(function () { return $location.absUrl() }, function (newLocation, oldLocation) {
                var isBackButton = false;
                if ($rootScope.actualLocation === newLocation) {
                    isBackButton = true;
                }
                if ($location.hash() == null || $location.hash() == '') {
                    $timeout(function () {
                        var documentContent = angular.element('#document-content-identifier'),
                            folderContent = angular.element('#folder-content-identifier'),
                            newsContent = angular.element('#wrapper');
                        var anchorOject = anchorService.getAnchorObject();
                        var position = (anchorOject != null && isBackButton) ? anchorOject.position : 0;
                        if (documentContent && documentContent.length > 0) {
                            documentContent[0].scrollTop = position;
                        } else if (folderContent && folderContent.length > 0) {
                            folderContent[0].scrollTop = position;
                        } else if (newsContent && newsContent.length > 0) {
                            newsContent[0].scrollTop = position;
                        }
                        anchorService.setAnchorObject(0);
                    }, 100);
                }
                if (isBackButton) {
                    if (angular.element('#handbook-nav:visible').length == 0) {
                        documentService.showNormal();
                        broadcastService(broadcastType.toggleDocumentFullscreen, {});
                    }
                }
                if (!newLocation.includes(oldLocation) && !oldLocation.includes(newLocation)) {
                    angular.element('#treeDocuments span').removeClass('selected');
                }
            });

            $rootScope.$on('$stateChangeSuccess', function (event, toState) {

                // Sets the layout name, which can be used to display different layouts (header, footer etc.)
                // based on which page the user is located
                $rootScope.layout = toState.layout;
                $rootScope.title = globalResources.Handbook + " - " + toState.data.title;
                $rootScope.metaDescription = toState.data.description;
            });
        }]);
})();;
(function () {
    var model = angular.module('metadataSearchModule', []);

    model.controller(controllers.metadataController, ['$scope', '$state', '$http', '$document', 'folderService', '$uibModalInstance', 'quickSearchKeyword', 'metaDataService', 'broadcastService', 'configService',
        function ($scope, $state, $http, $document, folderService, $modalInstance, quickSearchKeyword, metaDataService, broadcastService, configService) {
        $scope.translation = globalResources;
        $scope.currentData = {
            advanceSearchKeyword: quickSearchKeyword,
            folderName: '',
            selectedFolderId: 0,
        };
        $scope.selectedItem = {
            selectedMetadata: null,
            selectedTag: null
        };
        
        $scope.initMetadata = {
            metadatas: [],
            tags: []
        };
        

        $scope.folderTree = [];
        $scope.filterOptionNeededMessage = globalResources.FilterOptionNeededMessage;
        $scope.showTreeDocument = false;
        $scope.key_showRemoveIcon = false;
        $scope.folder_showRemoveIcon = false;

        $scope.initMetadataSearchData = initMetadataSearchData;
        $scope.onMetadataSearch = onMetadataSearch;
        $scope.close = close;
        $scope.loadFolderTree = loadFolderTree;
        $scope.hidePopupOnLostFocus = hidePopupOnLostFocus;
        $scope.selectNodeHead = selectNodeHead;
        $scope.selectNodeLabel = selectNodeLabel;
        $scope.hideTooltip = hideTooltip;
        $scope.clear_advKeyword = clear_advKeyword;
        $scope.clear_advFolder = clear_advFolder;
        $scope.showDocumentInTree = configService.getBool(HandbookConfiguration.ShowDocumentsInTree);

        function initMetadataSearchData() {
            setTimeout(function () {
                $('#adv_keyword').focus();
            }, 1000);

            //Init chapter base on url
            var id = $state.params.folderId;
            if (id != undefined && id > 0 && $state.current.name == 'folder') {
                folderService.getFolderById(id).then(function (response) {
                    $scope.currentData.folderName = response.data.name;
                    $scope.currentData.selectedFolderId = response.data.id;
                });;
            }
            $scope.key_showRemoveIcon = ($scope.currentData.advanceSearchKeyword != undefined && $scope.currentData.advanceSearchKeyword.length > 0);

            getRegisterItems();
        };

        function getRegisterItems() {
            metaDataService.getRegisterAndRegisterItems().then(function (data) {
                if (data) {
                    $scope.initMetadata.metadatas = data;
                }
            });
        };

        $scope.$watch('selectedItem.selectedMetadata', function (selectedMetadata) {
            $scope.selectedItem.selectedTag = null;
            if (selectedMetadata != null && selectedMetadata != undefined) {
                getMetadataTags(selectedMetadata.registerItemId);
            } 
        });

        function getMetadataTags(registerItemId) {
            metaDataService.getMetadataTags(registerItemId).then(function (data) {
                if (data) {
                    $scope.initMetadata.tags = data;
                }
            });
        };

        function onMetadataSearch() {
            if ($scope.currentData.selectedFolderId != 0 || $scope.selectedItem.selectedRegister != null || $scope.currentData.advanceSearchKeyword != '') {
                $scope.filterOptionNeededMessage = '';
                $state.go(handbookActions.SearchResultAction, {
                    keyword: $scope.currentData.advanceSearchKeyword,
                    searchInContents: 1,
                    folderId: $scope.currentData.selectedFolderId,
                    registerItemId: $scope.selectedItem.selectedMetadata != null ? $scope.selectedItem.selectedMetadata.registerItemId : null,
                    registerItemValueId: $scope.selectedItem.selectedTag != null ? $scope.selectedItem.selectedTag.registerItemValueId : null,
                    type: 4
                });
                $modalInstance.close(true);
                broadcastService(broadcastType.resetQuickSearchKeyword, null);
            }
            else {
                $scope.filterOptionNeededMessage = globalResources.FilterOptionNeededMessage;
            }
        };

        $document.bind('click', function (event) {
            var isClickedElementChildOfPopup = $('.folder-search')
              .find(event.target)
              .length > 0;

            if (isClickedElementChildOfPopup)
                return;
            $scope.showTreeDocument = false;
        });

        function close() {
            $modalInstance.close(true);
        }

        function loadFolderTree() {
            $scope.showTreeDocument = !$scope.showTreeDocument;
            if ($scope.showTreeDocument) {
                if ($scope.folderTree.length == undefined || $scope.folderTree.length == 0) {
                    $http.get(handbookRequests.GetFoldersRequest, { params: { 'Id': null, 'showDocumentInTree': $scope.showDocumentInTree } })
                         .success(function (data, status, headers, config) {
                             $scope.folderTree = data;
                         });
                }
            }
        };

        function hidePopupOnLostFocus() {
            $scope.showTreeDocument = false;
        };

        function selectNodeHead(node) {
            if (!node.isLoaded) {
                $http.get(handbookRequests.GetSubfoldersRequest, { params: { 'folderId': node.id } })
                    .success(function (data, status, headers, config) {
                        node.children = data;
                        node.isLoaded = true;
                    })
                    .error(function (data, status, headers, config) {
                        node.isLoaded = true;
                    });
            }
        };

        function selectNodeLabel(node) {
            $scope.currentData.folderName = node.name;
            $scope.currentData.selectedFolderId = node.id;
            $scope.folder_showRemoveIcon = ($scope.currentData.selectedFolderId != undefined && $scope.currentData.selectedFolderId > 0);
            folderService.setFolder(node);
            hidePopupOnLostFocus();
            hideTooltip();
        };

        function hideTooltip() {
            if (angular.element('#btnAdvanceSearch').scope().tt_isOpen) {
                angular.element('#btnAdvanceSearch').scope().tt_isOpen = false;
            }
            $scope.key_showRemoveIcon = ($scope.currentData.advanceSearchKeyword != undefined && $scope.currentData.advanceSearchKeyword.length > 0);
        };

        function clear_advKeyword() {
            $scope.currentData.advanceSearchKeyword = '';
            $scope.key_showRemoveIcon = false;
        };

        function clear_advFolder() {
            $scope.currentData.folderName = '';
            $scope.currentData.selectedFolderId = 0;
            $scope.folder_showRemoveIcon = false;
        };
        
    }]);

})();;

(function () {
    'use strict';

    angular.module(modules.homeModule)
           .controller('reportsViewController', reportsViewController);

    reportsViewController.$inject = ['$state', '$stateParams', '$http'];

    function reportsViewController($state, $stateParams, $http) {
        var vm = this;
        vm.filter = {
            folderId: $stateParams.folderId != null ? $stateParams.folderId : null,
            includeSubfolders: $stateParams.recursive
        };

        initialize();

        function initialize() {
            var screenHeight = window.innerHeight;
            angular.element('#frameReport').height(screenHeight - 50);

            vm.reportPage = '/Reports/Viewer.aspx?folderId=' + vm.filter.folderId + '&recursive=' + vm.filter.includeSubfolders;

        };

        $(window).on('resize', function () {
            var screenHeight = window.innerHeight;
            angular.element('#frameReport').height(screenHeight - 50);
        });
    };

})();;

(function () {
    'use strict';

    angular.module(modules.homeModule)
        .controller('reportsMyReadingListViewController', reportsMyReadingListViewController);

    reportsMyReadingListViewController.$inject = ['$state', '$stateParams', '$http'];

    function reportsMyReadingListViewController($state, $stateParams, $http) {
        var vm = this; 

        initialize();

        function initialize() {
            
            var screenHeight = window.innerHeight;
            angular.element('#frameReport').height(screenHeight - 50);

            vm.reportPage = `/Reports/Viewer.aspx?reportType=11&userId=${user.userId}`;
        };

        $(window).on('resize', function () {
            var screenHeight = window.innerHeight;
            angular.element('#frameReport').height(screenHeight - 50);
        });
    };

})();;
(function () {
    angular
        .module('processModule', ['ui.bootstrap', 'ui.router'])
        .run(['$location', '$state', 'pubSub', 'documentService', 'tabStateService', '$rootScope', function ($location, $state, pubSub, documentService, tabStateService, $rootScope) {
            window.addEventListener("message", (event) => {
                if (!event.data || event.data.moduleName != 'process' || !event.data.eventName)
                    return;
                
                let backendRoute = '';
                switch (event.data.eventName) {
                    case 'process-route-change':
                        let frontendRoute = event.data.value.toLowerCase();
                        let areaIdTarget = null;
                        let processNumberTarget = null;

                        if (frontendRoute.indexOf('/home/details') > -1) {
                            backendRoute = '/process-fe/home/root-details';
                            $state.go('areas-root-view')
                        }
                        else if (frontendRoute.indexOf('/area/detail') > -1) {
                            backendRoute = '/process-fe' + frontendRoute;
                            let areaId = backendRoute.substring(backendRoute.lastIndexOf('/') + 1);
                            if (areaId.indexOf('?isfrontend') > -1) {
                                areaId = areaId.substring(0, areaId.indexOf('?isfrontend'));
                            }
                            if (areaId && areaId != '') {
                                areaIdTarget = areaId;
                            }
                        }
                        else if (frontendRoute.indexOf('/process-detail/management') > -1) {
                            let processNumber = frontendRoute.substring(frontendRoute.lastIndexOf('/') + 1);
                            if (processNumber.indexOf('?isfrontend') > -1) {
                                processNumber = processNumber.substring(0, processNumber.indexOf('?isfrontend'));
                            }
                            if (processNumber && processNumber != '') {
                                processNumberTarget = processNumber;
                                backendRoute = '/process-fe/process-detail/' + processNumber;
                            }
                        }
                        else if (frontendRoute.indexOf('/process-detail/viewsendtohearing') > -1) {
                            backendRoute = '/process-fe' + frontendRoute;                    
                            let processNumber = backendRoute.substring(backendRoute.lastIndexOf('/') + 1);
                            if (processNumber) {
                                processNumberTarget = processNumber;
                            }
                        }
                        pubSub.publish(broadcastType.processAreaRouteChanged, {
                            areaId: areaIdTarget,
                            processNumber: processNumberTarget
                        });
                        break;
                    case 'go-to-handbook-home':
                        backendRoute = '/';
                        $state.go('home');
                        break;
                    case 'open-full-screen-diagram':
                        documentService.showFullscreen();
                        break;
                    case 'close-full-screen-diagram':
                        documentService.showNormal();
                        tabStateService.adjustContentHeightPosition(tabStateType.documentTabState);
                        $('#document-content-identifier').css('margin-top', '0px');
                        break;
                    case 'hide-navigation-bar':
                        angular.element('#dropdownusername').removeClass('open');
                        if (angular.element('.activity-notifications > div').css('display') === 'block') {
                            angular.element('.activity-notifications > div').css('display', 'none');
                        }
                        break;
                    case 'update-favorites-processes':
                        pubSub.publish(broadcastType.updateFavoritesProcesses, true);
                        break;
                    case 'rebuild-tree-view':
                        // pubSub.publish(broadcastType.rebuildTreeView);
                        break;
                    case 'start-loading-spinner':
                        var loadingSpinner = document.getElementById('ng-loading-spinner');
                        if (loadingSpinner)
                            loadingSpinner.style.display = 'block';
                        break;
                    case 'stop-loading-spinner':
                        var loadingSpinner = document.getElementById('ng-loading-spinner');
                        if (loadingSpinner)
                            loadingSpinner.style.display = 'none';
                        break;
                    case 'update-document-title':
                        $rootScope.$apply(function () {
                            $rootScope.title = globalResources.Handbook + " - " + event.data.value;
                            $rootScope.metaDescription = event.data.value;
                        });
                        break;
                    default:
                        backendRoute = '/';
                }

                if (!backendRoute) return;

                let url = $location.url();

                if (backendRoute.indexOf('?isfrontend') > -1) {
                    backendRoute = backendRoute.substring(0, backendRoute.indexOf('?isfrontend'));
                }
                if (url === backendRoute) return;
                if (!history.state || !history.state.id || (history.state.id !== backendRoute)) {
                    history.pushState({ id: backendRoute }, backendRoute, backendRoute);
                }
            });
        }]);
})();;
(function () {
    'use strict';

    angular.module('processModule')
        .config(['$stateProvider', '$urlRouterProvider', routesConfig]);

    function routesConfig($stateProvider, $urlRouterProvider) {
        $stateProvider
            .state('areas-root-view', {
                url: '/process-fe/home/root-details',
                params: {},
                templateUrl: 'app/process/areas-root-view/areas-root-view.html',
                controller: 'areas-root-view.controller',
                controllerAs: 'vm',
                data: {
                    title: 'Process Home',
                    description: 'Process Home'
                }
            })
            .state('process-area-detail', {
                url: '/process-fe/area/detail/:areaId',
                params: { areaId: '0' },
                templateUrl: 'app/process/area-detail/area-detail.html',
                controller: 'area-detail.controller',
                controllerAs: 'vm',
                data: {
                    title: 'Area detail',
                    description: 'Area detail'
                }
            })
            .state('process-detail', {
                url: '/process-fe/process-detail/:processNumber',
                params: { processNumber: 0 },
                templateUrl: 'app/process/process-detail-view/process-detail-view.html',
                controller: 'process-detail-view.controller',
                controllerAs: 'vm',
                data: {
                    title: 'Process detail',
                    description: 'Process detail'
                }
            })
            .state('process-hearing-view', {
                url: '/process-fe/process-detail/viewsendtohearing/:processNumber/:version',
                params: { processNumber: '0', version: '' },
                templateUrl: 'app/process/process-hearing-view/process-hearing-view.html',
                controller: 'process-hearing-view.controller',
                controllerAs: 'vm',
                data: {
                    title: 'Process hearing',
                    description: 'Process hearing'
                }
            });
        $urlRouterProvider.otherwise('/');
    };
})();;
(function () {
    angular
        .module('checklistModule', [])
        .run(['$location', '$state', 'pubSub', 'documentService', 'tabStateService', '$rootScope', function ($location, $state, pubSub, documentService, tabStateService, $rootScope) {
            window.addEventListener("message", (event) => {
                if (!event.data || event.data.moduleName != 'checklist' || !event.data.eventName)
                    return;

                let backendRoute = '';
                switch (event.data.eventName) {
                    case 'checklist-route-change':

                        let frontendRoute = event.data.value.toLowerCase();
                        if (frontendRoute.indexOf('checklist/home') > -1) {
                            backendRoute = '/checklist-fe/home';
                        } else {
                            backendRoute = '/checklist-fe/' + frontendRoute;
                        }
                       
                        break;
                    
                    default:
                        backendRoute = '/';
                }

                if (!backendRoute) return;

                let url = $location.url();
                if (url === backendRoute) return;
                if (backendRoute.indexOf('?isHideTopbar') > -1) {
                    backendRoute = backendRoute.substring(0, backendRoute.indexOf('?isHideTopbar'));
                }
                if (!history.state || !history.state.id || (history.state.id !== backendRoute)) {
                    history.pushState({}, backendRoute, backendRoute);
                    //window.dispatchEvent(new PopStateEvent('popstate', {
                    //    state: history.state
                    //}));
                }
            });
        }]);
})();;
(function () {
    'use strict';

    angular.module('checklistModule')
        .config(['$stateProvider', '$urlRouterProvider', routesConfig]);

    function routesConfig($stateProvider, $urlRouterProvider) {
        var internalPaths = window.paths;
        $stateProvider
            .state('checklistHome', {
                url: '/checklist-fe/home',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Checklist Home',
                    description: 'Checklist Home'
                }
            })
            .state('checklistCategories', {
                url: '/checklist-fe/categories?isHideTopbar',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Checklist categories',
                    description: 'Checklist categories'
                }
            })
            .state('completedchecklists', {
                url: '/checklist-fe/completedchecklists',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Completed checklist categories',
                    description: 'Completed checklist categories'
                }
            })
            .state('fillchecklistfromcategorymain', {
                url: '/checklist-fe/category/main',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Fill checklist categories',
                    description: 'Fill checklist categories'
                }
            })
            .state('adminsubcategory', {
                url: '/checklist-fe/adminsubcategory/:categoryId',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Admin sub categories',
                    description: 'Admin sub categories'
                }
            })
            .state('adminsubcategoryadd', {
                url: '/checklist-fe/adminsubcategory/add/:categoryId',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Add admin sub category',
                    description: 'Add admin sub category'
                }
            })
            .state('adminsubcategoryedit', {
                url: '/checklist-fe/adminsubcategory/edit/:categoryId',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Edit admin sub category',
                    description: 'Edit admin sub category'
                }
            })
            .state('admincategoryadd', {
                url: '/checklist-fe/category/add',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Add admin category',
                    description: 'Add admin category'
                }
            })
            .state('admincategoryedit', {
                url: '/checklist-fe/category/edit/:id',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Edit admin category',
                    description: 'Edit admin category'
                }
            })
            .state('checklistofsubcategory', {
                url: '/checklist-fe/list/:categoryId',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'List Checklist',
                    description: 'List Checklist'
                }
            })
            .state('editchecklistdetail', {
                url: '/checklist-fe/tem/edit/:categoryId/:checklistId/:type',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Edit Checklist detail',
                    description: 'Edit Checklist detail'
                }
            })
            .state('editchecklistfield', {
                url: '/checklist-fe/tem/addeditfield/:categoryId/:checkListId/:type',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Edit Checklist field',
                    description: 'Edit Checklist field'
                }
            })
            .state('adminmaincategoryaccess', {
                url: '/checklist-fe/adminmaincategoryaccess',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Main categories Access',
                    description: 'Main categories Access'
                }
            })
            .state('editaccesscategory', {
                url: '/checklist-fe/editaccesscategory/:fromEntityId/:id/:fromType',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Edit categories Access',
                    description: 'Edit categories Access'
                }
            })
            .state('editaccesschecklist', {
                url: '/checklist-fe/editaccesschecklist/:fromEntityId/:id/:fromType',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Edit checklist Access',
                    description: 'Edit checklist Access'
                }
            })
            .state('editaccessmaincategory', {
                url: '/checklist-fe/editaccessmaincategory/:id',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Edit Access main category',
                    description: 'Edit Access main category'
                }
            })
            .state('editaccesscategorychecklist', {
                url: '/checklist-fe/editaccesscategorychecklist/:fromEntityId/:id/:type',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Edit Access category',
                    description: 'Edit Access category'
                }
            })
            .state('adminsubcategoryaccess', {
                url: '/checklist-fe/adminsubcategoryaccess/:id',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Admin sub category access',
                    description: 'Admin sub category access'
                }
            })
            .state('categorysubcategory', {
                url: '/checklist-fe/category/subcategory/:cateId',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Sub category',
                    description: 'Sub category'
                }
            })
            .state('checklistWidget', {
                url: '/checklist-fe/tem/viewlist/:cateId',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Checklist',
                    description: 'Checklist'
                }
            })
            .state('completedchecklistsdetail', {
                url: '/checklist-fe/completedchecklists/detail/:id',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Completed Checklist',
                    description: 'Completed Checklist'
                }
            })
            .state('implementChecklist', {
                url: '/checklist-fe/implement/add/:categoryId/:checklistId',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Implement Checklist',
                    description: 'Implement Checklist'
                }
            })
            .state('implementChecklistNoPermission', {
                url: '/checklist-fe/implement/fromemail/add/:categoryId/:checklistId',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                reloadOnSearch: false,
                data: {
                    title: 'Implement Checklist',
                    description: 'Implement Checklist'
                }
            })
           ;
        $urlRouterProvider.otherwise('/');
    };
})();;
(function () {
    'use strict';

    angular.module('processModule')
        .controller('areasTreeview', areasTreeviewController);

    areasTreeviewController.$inject = ['$scope', '$timeout', '$http', '$state', 'pubSub', 'configService'];

    function areasTreeviewController($scope, $timeout, $http, $state, pubSub, configService) {
        var vm = this;
        var currentRecursiveIndex = 0;
        var indexOfChildren = 0;
        var killProcessAreaRouteChanged = null;
        vm.isExpanded = false;

        vm.initialize = initialize;
        vm.items = [];
        vm.parentList = [];
        vm.allAreas = [];
        vm.selectNodeInAreaTree = selectNodeInAreaTree;
        vm.handleExpandArea = handleExpandArea;
        vm.wrapText = configService.getBool(HandbookConfiguration.WrapTextInNavigationTree);

        function initialize() {
            getAllAccessibleAreas();
            buildTree();
            killProcessAreaRouteChanged = pubSub.subscribe(broadcastType.processAreaRouteChanged, processAreaRouteChanged);
        }

        $scope.$on('$destroy', function () {
            killProcessAreaRouteChanged();
        });

        function buildTree() {
            $http.get(handbookRequests.GetProcessAreasRequest, {
                params: {
                    areaId: null,
                    showProcessesInTree: true,
                    isOnlyApproved: true
                }
            }).success(function (data) {
                if (data) {
                    $scope.processAreasList = data.areas;
                    decorateNodes($scope.processAreasList, null);
                    if (window.location.href.indexOf('/area/detail') > -1) {
                        let areaId = window.location.href.substring(window.location.href.lastIndexOf('/') + 1);
                        if (areaId && areaId != '') {
                            getParentAreasRecursive(areaId, true);
                        }
                    }
                    else if (window.location.href.indexOf('/process-detail') > -1) {
                        let processNumber = window.location.href.substring(window.location.href.lastIndexOf('/') + 1);
                        if (processNumber && processNumber != '') {
                            getParentAreasRecursive(processNumber, false);
                        }
                    }
                }
            });
        }

        $scope.options = {
            dropped: function (event) { },
            beforeDrop: function (event) { }
        };

        function getAllAccessibleAreas() {
            return $http.get(handbookRequests.GetAllAccessibleAreasRequest, {
                params: {
                    changeLocationMode: 0 //changeLocationMode.ReadArea
                }
            }).success(function (data) {
                if (data) {
                    vm.allAreas = data;
                }

            },
                function () {
                    vm.allAreas = [];
                });
        }

        function processAreaRouteChanged(target) {
            if (target.areaId == null && target.processNumber == null) {
                $('.selected').removeClass('selected');
            }
            if (target.processNumber) {
                getParentAreasRecursive(target.processNumber, false);
            } else {
                let isExistAreaId = vm.allAreas.some(function (item) { return item.id == target.areaId; });
                if (isExistAreaId) {
                    getParentAreasRecursive(target.areaId, true);
                }
            }
        }

        function handleExpandArea(expanded, itemId, selectedNode) {
            if (expanded == true && selectedNode.$modelValue.type == 0 && (selectedNode.$modelValue.childCount > 0)) {
                var siblings = selectedNode.$parentNodeScope == null ? selectedNode.processAreasList : selectedNode.$parentNodeScope.$modelValue.items;
                var modelValue = selectedNode.$modelValue;
                if (modelValue.isLoaded) {
                    afterExpanded(itemId, 0);
                    return;
                } else {
                    modelValue.isLoaded = true;
                }

                $http.get(handbookRequests.GetProcessAreasRequest, {
                    params: {
                        areaId: itemId,
                        showProcessesInTree: true,
                        isOnlyApproved: true
                    }
                })
                    .success(function (data, status, headers, config) {
                        if (data) {
                            decorateNodes(data.areas, data.processes);
                            var length = siblings.length;
                            for (var i = 0; i < length; i++) {
                                if (siblings[i].id == itemId) {
                                    vm.selectedNode = siblings[i];
                                    if (siblings[i].items == null) {
                                        siblings[i].items = [];
                                    }
                                    siblings[i].items = siblings[i].items.concat(data.areas);
                                    siblings[i].items = siblings[i].items.concat(data.processes);
                                    afterExpanded(itemId, 0);
                                    break;
                                }
                            }
                        }
                    },
                        function (data, status, headers, config) {
                            //modelValue.items = [];
                        });
            }
        }

        function selectNodeInAreaTree(node, item, collapsed, $event) {
            if (item.type == 0 || !item.type) {
                $state.go('process-area-detail', { areaId: item.id });
            }
            else if (item.type == 1) {
                $state.go('process-detail', { processNumber: item.processNumber });
            }
            let isSelectedFolder = $(event.target).hasClass('selected');
            if ((isSelectedFolder || collapsed) && HandbookConfiguration.ToggleFolderUponClick.toUpperCase() == "TRUE") {
                vm.isExpanded = true;
                item.expanded = !item.expanded;
                handleExpandArea(collapsed, item.id, node);
                $scope.toggle(node);
            }
            setHighlight($event);
        }

        $scope.toggle = function (scope) {
            scope.toggle();
        };

        $scope.$on(broadcastType.collapseExpandSidebar, function (e, target) {
            if (target.navigateSideBar) {
                currentRecursiveIndex = 0;
                //navigateToCurrentItem(null);
            }
        });

        function decorateNodes(areas, processes) {
            if (areas && areas.length > 0) {
                for (var i = 0; i < areas.length; i++) {
                    areas[i].type = 0;
                }
            }
            if (processes && processes.length > 0) {
                for (var i = 0; i < processes.length; i++) {
                    processes[i].type = 1;
                    processes[i].id = processes[i].processNumber;
                }
            }
        }

        function getParentAreasRecursive(itemId, isArea) {
            return $http.get(handbookRequests.GetParentAreas, {
                params: {
                    processNumber: isArea ? null : itemId,
                    areaId: isArea ? itemId : null,
                    isArea: isArea
                }
            })
                .success(function (data, status, headers, config) {
                    if (data && data.length > 0) {
                        var _parents = data;
                        decorateNodes(_parents, null);
                        if (!isArea) {
                            var process = {
                                id: itemId,
                                type: 1,
                                parentAreaId: _parents[0].id
                            }
                            _parents = _parents.concat([process]);
                        }
                        navigateToCurrentItem($scope.processAreasList, _parents);
                    }
                    vm.isExpanded = false;
                },
                    function (data, status, headers, config) {
                        modelValue.items = [];
                    });
        }

        function navigateToCurrentItem(tempItems, recursives) {
            $timeout(function () {
                onChildrenLoaded(tempItems, recursives);
            }, 0);
        }

        function onChildrenLoaded(tempItems, recursives) {
            vm.parentList = recursives;
            vm.items = tempItems;
            if (currentRecursiveIndex < vm.parentList.length) {
                if (vm.items != null && vm.items.length > 0) {
                    for (var i = 0; i < vm.items.length; i++) {
                        if (vm.items[i].id == vm.parentList[currentRecursiveIndex].id && vm.items[i].type == vm.parentList[currentRecursiveIndex].type) {
                            currentRecursiveIndex += 1;
                            indexOfChildren = i;
                            var node = angular.element('#treeProcesses #' + vm.items[indexOfChildren].id + '_' + vm.items[indexOfChildren].type);
                            if (!vm.items[indexOfChildren].expanded && vm.items[indexOfChildren].childCount > 0) {
                                node.trigger('click');
                            } else {
                                afterExpanded(vm.items[indexOfChildren].id, vm.items[indexOfChildren].type);
                            }
                            break;
                        }
                    }
                }
            }
        }

        function afterExpanded(nodeId, nodeType) {
            if (currentRecursiveIndex == vm.parentList.length) { // it's current area/process
                $timeout(function () {
                    var idSelected = angular.element("#treeProcesses #" + nodeId + '_' + (nodeType == 1 ? 'process' : 'area'));
                    $('.selected').removeClass('selected');
                    if (idSelected.length != 0) {
                        $(idSelected).addClass('selected');
                        $('.selected').focus();
                    }
                }, 0);
                currentRecursiveIndex = 0;
            } else if (currentRecursiveIndex != 0) {
                $timeout(function () {
                    vm.items = vm.items[indexOfChildren].items.map(function (element) {
                        if (element.entityId) {
                            return {
                                id: element.processNumber,
                                type: 1,
                                parentAreaId: element.processAreaId,
                                name: element.name,
                                expanded: true
                            }
                        }
                        else
                            return element;
                    });
                    onChildrenLoaded(vm.items, vm.parentList);
                }, 0);
            }
        }

        function setHighlight(event) {
            $('.selected').removeClass('selected');
            $(event.target).addClass('selected');
        }

    };

})();

;
(function () {
    angular
        .module('dashboardModule', ['ui.bootstrap', 'ui.router'])
        .run(['$location', '$state', function ($location, $state) {
            window.addEventListener("message", (event) => {
                if (!event.data || event.data.moduleName != 'dashboard' || !event.data.eventName)
                    return;
                
                let backendRoute = '';
                switch (event.data.eventName) {
                    case 'dashboard-route-change':
                        let frontendRoute = event.data.value.toLowerCase();
                        if (frontendRoute.indexOf('/reading-list/') > -1) {
                            let readingListId = frontendRoute.substring(frontendRoute.lastIndexOf('/') + 1);
                            if (readingListId.indexOf('?hidetopbar') > -1) {
                                readingListId = readingListId.substring(0, readingListId.indexOf('?hidetopbar'));
                            }
                            if (readingListId && readingListId != '') {
                                backendRoute = '/reading-list/' + readingListId;
                                $state.go('reading-list-detail', { readingListId: readingListId });
                            }
                        } else if (frontendRoute.indexOf('/reading-list') > -1) {
                            backendRoute = '/reading-list';
                            $state.go('reading-list');
                        }
                        break;
                    case 'handbook-home':
                        backendRoute = '/';
                        $state.go('home');
                        break;
                    default:
                        backendRoute = '/';
                }

                if (!backendRoute) return;

                let url = $location.url();

                if (backendRoute.indexOf('?hidetopbar') > -1) {
                    backendRoute = backendRoute.substring(0, backendRoute.indexOf('?hidetopbar'));
                }
                //if (url === backendRoute) return;
                if (!history.state || !history.state.id || (history.state.id !== backendRoute)) {
                    history.pushState({ id: backendRoute }, backendRoute, backendRoute);
                }
            });
        }]);
})();;
(function () {
    'use strict';

    angular.module('dashboardModule')
        .config(['$stateProvider', '$urlRouterProvider', routesConfig]);

    function routesConfig($stateProvider, $urlRouterProvider) {
        $stateProvider
            .state('reading-list', {
                url: '/reading-list',
                templateUrl: 'app/dashboard/reading-list/reading-list-view.html',
                controller: 'reading-list-view.controller',
                controllerAs: 'vm',
                data: {
                    title: 'Reading list',
                    description: 'Reading list'
                }
            })
            .state('reading-list-detail', {
                url: '/reading-list/:readingListId',
                params: { readingListId: null },
                templateUrl: 'app/dashboard/reading-list/reading-list-view.html',
                controller: 'reading-list-view.controller',
                controllerAs: 'vm',
                data: {
                    title: 'Reading list',
                    description: 'Reading list'
                }
            });
        $urlRouterProvider.otherwise('/');
    };
})();;

(function () {
    'use strict';

    angular.module('servicesModule')
           .controller('AddMembersController', controller);

    controller.$inject = ['$uibModalInstance', '$http', '$scope', 'existedEmployees', 'titlePage', 'roleId', 'excludedQuitDepartmentId', 'folderId', 'isHearing'];

    function controller($modalInstance, $http, $scope, existedEmployees, titlePage, roleId, excludedQuitDepartmentId, folderId, isHearing) {
        var vm = this;

        vm.translation = globalResources;

        var infiniteScrollLoadsize = (HandbookConfiguration.InfiniteScrollLoadSize == "0" || HandbookConfiguration.InfiniteScrollLoadSize == 0) ?
           0 :
           parseInt(HandbookConfiguration.InfiniteScrollLoadSize);

        

        vm.titlePage = titlePage;

        vm.search = {
            recursive: false,
            pageSize: infiniteScrollLoadsize,
            pageIndex: 0,
            firstName: '',
            lastName: '',
            roleId: null,
            excludedQuitDepartmentId: excludedQuitDepartmentId,
            folderId: folderId
        };


        vm.selectedRole = {};

        vm.getDepartment = getDepartment;
        vm.saveChanges = saveChanges;
        vm.cancel = cancel;
        vm.existedEmployees = existedEmployees;
        vm.excludedEmployees = [];

        vm.nextPage = nextPage;
        vm.searchEmployee = searchEmployee;
        vm.onSelectRow = onSelectRow;
        vm.checkAll = checkAll;
        vm.onKeyUp = onKeyUp;

        vm.isHearing = isHearing;
        vm.changeSaveSearch = changeSaveSearch;
        vm.searchPatterns = [];
        vm.searchByHearing = false;
        initialize();
        

        function initialize() {
            if (vm.isHearing) {
                getUserFilterSearches();
            }

            if (vm.existedEmployees) {
                vm.existedEmployees.forEach(function (item) {
                    vm.excludedEmployees.push(item.id);
                });
            }
            vm.total = 0;
            vm.times = 0;
            vm.currentRowIndex = 0;
            vm.selectedEmployees = [];
            vm.selectedEmployeesCount = 0;

            $http.get('/api/Users/GetSecurityGroups', {})
                .success(function (data, status, headers, config) {
                    vm.roles = data;
                })

            var promise = $http.post('/api/Users/GetEmployees',
               {
                   recursive: vm.search.recursive,
                   pageSize: vm.search.pageSize,
                   pageIndex: vm.search.pageIndex,
                   departmentId: vm.search.departmentId,
                   firstName: vm.search.firstName,
                   lastName: vm.search.lastName,
                   roleId: vm.search.roleId,
                   excludedEmployeeId: vm.excludedEmployees,
                   excludedQuitDepartmentId: vm.search.excludedQuitDepartmentId,
                   folderId: vm.search.folderId
               });

            promise.success(function (data, status, headers, config) {
                vm.employees = data;
            });
        };

        $scope.$watch('vm.employees', function (data, oldData) { // This handler for initialize data.
            var response = gridUtilities.lookupData(data, vm.rowCollection, vm.originalCollection, infiniteScrollLoadsize, vm.total, vm.currentRowIndex);
            vm.total = response.total;
            vm.currentRowIndex = response.currentIndex;
            vm.rowCollection = response.data;
        }, true);

        function nextPage(tableState) {
            vm.searchByHearing = false;
            resetselectedSearchPattern();
            if (infiniteScrollLoadsize == 0) {
                vm.rowCollection = vm.employees;
                vm.originalCollection = angular.copy(vm.rowCollection);
            } else {
                //if we reset (like after a search or an order)
                if (tableState.pagination.start === 0) {
                    if (vm.rowCollection == null || vm.rowCollection.length == 0) {
                        getAPage(true);
                        $scope.$apply();
                    }
                } else {
                    //we load more
                    getAPage(false);
                    $scope.$apply();
                }
            }
        };

        function getAPage(first) {
            vm.search.pageIndex += 1;
            vm.searchByHearing = false;
            resetselectedSearchPattern();
            vm.search.roleId = vm.selectedRole != null ? vm.selectedRole.id : null;
            var promise = $http.post('/api/Users/GetEmployees',
                {
                    recursive: vm.search.recursive,
                    pageSize: vm.search.pageSize,
                    pageIndex: vm.search.pageIndex,
                    departmentId: vm.search.departmentId,
                    firstName: vm.search.firstName,
                    lastName: vm.search.lastName,
                    roleId: vm.search.roleId,
                    excludedEmployeeId: vm.excludedEmployees,
                    folderId: vm.search.folderId
                });

            promise.success(function (data, status, headers, config) {
                if (first) {
                    vm.rowCollection = data;
                } else {
                    vm.rowCollection = vm.rowCollection.concat(data);
                }

                vm.originalCollection = angular.copy(vm.rowCollection);
            });
        }

        function searchEmployee() {
            vm.searchByHearing = false;
            resetselectedSearchPattern();
            vm.search.pageIndex = 1;
            vm.search.roleId = vm.selectedRole != null ? vm.selectedRole.id : null;
            var promise = $http.post('/api/Users/GetEmployees',
                {
                    recursive: vm.search.recursive,
                    pageSize: vm.search.pageSize,
                    pageIndex: vm.search.pageIndex,
                    departmentId: vm.search.departmentId,
                    firstName: vm.search.firstName,
                    lastName: vm.search.lastName,
                    roleId: vm.search.roleId,
                    excludedEmployeeId: vm.excludedEmployees,
                    excludedQuitDepartmentId: vm.search.excludedQuitDepartmentId,
                    folderId: vm.search.folderId
                });

            promise.success(function (data, status, headers, config) {
                vm.selectedEmployees = [];
                vm.selectedEmployeesCount = 0;

                vm.rowCollection = data;
                vm.originalCollection = angular.copy(vm.rowCollection);
            });
        };

        function onSelectRow(row) {
            if (row.selected == true) {
                vm.selectedEmployees.push(row);
                if (row != null) {
                    vm.selectedEmployeesCount += 1;
                }
            } else {
                if (row != null) {
                    if (vm.selectedEmployeesCount > 0) {
                        vm.selectedEmployeesCount -= 1;
                    }
                }

                vm.selectedEmployees.splice($.inArray(row, vm.selectedEmployees), 1);
            }
        };

        function checkAll() {
            vm.selectedEmployees = [];
            vm.selectedEmployeesCount = 0;
            if (vm.isAllSelected) {
                vm.rowCollection.forEach(function (item) {
                    item.selected = true;
                    vm.selectedEmployees.push(item);
                    vm.selectedEmployeesCount += 1;
                });
            } else {
                vm.rowCollection.forEach(function (item) {
                    item.selected = false;
                });
            }
        };

        function onKeyUp(e) {
            if (e.which == 13) {
                searchEmployee();
            }
        }
        function getDepartment(department) {
            if (department) {
                vm.search.departmentId = department.id;
            } else {
                vm.search.departmentId = null;
            }
        }

        function saveChanges() {
            if (vm.selectedEmployees && vm.selectedEmployees.length != 0) {
                $modalInstance.close(vm.selectedEmployees);
            }
        }

        function cancel() {
            $modalInstance.dismiss('cancel');
        }

        function getUserFilterSearches() {
            vm.searchPatterns = [];
            $http.get('/api/Users/GetUserSavedSearches', { params: { searchFilterType: searchFilterTypes.hearingMembers } })
                .then(function (res) {
                    if (res.data && res.data.length > 0) {
                        vm.searchPatterns = res.data;
                        vm.searchPatterns.unshift({
                            id: 0,
                            name: vm.translation.ChooseSavedHearingMembersList,
                            searchFilterType: searchFilterTypes.hearingMembers
                        });

                        vm.selectedSearchPattern = vm.searchPatterns[0];
                    }
                    vm.isHearing = (res.data && res.data.length > 0);
            });
        }

        function changeSaveSearch() {
            vm.selectedEmployees = [];
            vm.selectedEmployeesCount = 0;
            vm.search.pageIndex = 1;
            vm.searchByHearing = true;
            var selectedRequest = vm.selectedSearchPattern;
            if (!selectedRequest || !selectedRequest.searchFilters) {
                return;
            }

            var request = {
                pageIndex: 1,
                pageSize: 0,
                searchIds: selectedRequest.searchFilters,
                folderId: vm.search.folderId
            };

            $http.post('/api/users/GetEmployees', request).then(function (response) {
                if (response.data) {
                    if (!vm.excludedEmployees)
                        vm.excludedEmployees = [];
                    vm.rowCollection = response.data.filter(x => !vm.excludedEmployees.find(y => y == x.id));
                    vm.originalCollection = angular.copy(vm.rowCollection);
                }
            });
        }

        function resetselectedSearchPattern() {
            if (vm.isHearing && vm.searchPatterns.length > 0) {
                vm.selectedSearchPattern = vm.searchPatterns[0];
            }
        }
    };
})();;

(function () {
    'use strict';

    angular.module("handbookApp")
           .controller('SendDocumentToHearingEmailController', controller);

    controller.$inject = ['$uibModalInstance', 'objectEmailContent'];

    function controller($modalInstance, objectEmailContent) {
        var vm = this;

        vm.translation = globalResources;
        vm.email = {
            subject: '',
            body: ''
        };

        vm.saveChanges = saveChanges;
        vm.cancel = cancel;

        initialize();

        function initialize() {
            vm.email.subject = vm.translation.SubjectSendToHearingCreate;
            var extraInfo = objectEmailContent.allowForwarding ? vm.translation.ExtraInfoSendToHearingCreate : '';
            vm.email.body = String.format(vm.translation.BodySendToHearingCreate, objectEmailContent.documentName, objectEmailContent.dueDate, objectEmailContent.url, objectEmailContent.documentResponsible, extraInfo);
        };

        function saveChanges() {
            if (vm.email.subject && vm.email.body) {
                $modalInstance.close(vm.email);
            }
        }

        function cancel() {
            $modalInstance.dismiss('cancel');
        }
    };
})();;

(function () {
	'use strict';

	angular.module('documentHearingFieldsModule', [])
		.controller("DocumentHearingFieldsController", documentHearingFieldsController);

	documentHearingFieldsController.$inject = ['$http', '$sce', '$timeout', '$location', '$scope', '$rootScope', '$state', '$anchorScroll',
		'documentService', 'anchorService', 'documentContentsSearchService', 'resizeService', '$stateParams', 'folderService'];

	function documentHearingFieldsController($http, $sce, $timeout, $location, $scope, $rootScope, $state, $anchorScroll,
		documentService, anchorService, documentContentsSearchService, resizeService, $stateParams, folderService) {

		var vm = this;

		vm.documentInformation = {};
		vm.originalData = {};
		vm.fieldId = -1;
		vm.currentData = {};
		vm.oldData = {};
		vm.highlights = {
			highlightText: '',
			currentIndex: 0,
			totalFound: 0
		};

		vm.loginUserId = user.userId;
		var urlParams = $location.url().split('/');
		vm.isEmbedUrl = false;
		vm.typeHideHeader = false;
		vm.documentId = $stateParams.documentId;
		if (urlParams != null && urlParams.length > 0) {
			vm.isEmbedUrl = urlParams[1] == 'embed';
			if (vm.isEmbedUrl) {
				vm.fieldId = urlParams[5];
				vm.typeHideHeader = urlParams.length == 7 ? (urlParams[6] == '1') : false;
				vm.documentId = urlParams[3];
			}
		}

		vm.isShowMetadata = configService.getBool(HandbookConfiguration.MetadataEnabled);
		vm.isShowMetatagTab = configService.getBool(HandbookConfiguration.ShowMetatagTab);
		vm.publishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);
		vm.showContent = showContent;
		vm.clearActive = clearActive;
		vm.searchAndHighlightText = searchAndHighlightText;
		vm.navForward = navForward;
		vm.navBackward = navBackward;

		vm.focusItem = focusItem;
		vm.goBackDocumentHearing = goBackDocumentHearing;
		vm.editCommentField = editCommentField;
		vm.saveCommentField = saveCommentField;
		vm.editCommentDraf = editCommentDraf;
		vm.deleteCommentField = deleteCommentField;
		vm.goBackDocumentHearing = goBackDocumentHearing;
		vm.printPDF = printPDF;
		vm.getNextSearchResultByEnter = getNextSearchResultByEnter;

		vm.isFloatTitle = $(window).height() > HandbookConfiguration.DocumentTitleScreenHeight ? true : false;

		initialize();

		function initialize() {

			processEmbedUrl();
			//check and resize the view
			resizeService.resizeView();

			getDocument();
		};

		function processEmbedUrl() {
			if (vm.isEmbedUrl) {
				if (vm.typeHideHeader) {
					angular.element('#documentHeader1Container').hide();
					angular.element('#fieldTitle').hide();
				}
			}
		}

		function getDocument() {
			if (vm.isShowMetadata && vm.isShowMetatagTab) {
				getMetadataTab();
			}
			vm.currentDataPromise =
				$http.get(handbookRequests.GetDocumentInformationForHearingRequest, { params: { 'documentId': vm.documentId } })
					.then(function (result) {
						createTooltipsRelatedDocument(result.data);
						vm.oldData = result.data;
						if (vm.oldData.description) {
							vm.oldData.description = $sce.trustAsHtml(vm.oldData.description.replace(new RegExp(String.fromCharCode(13) + String.fromCharCode(10), 'g'), '<br/>'));
						}
						vm.oldData.nodeType = convertToNodeType(vm.oldData.type);
						if (vm.oldData.fieldContents != null) {
							vm.oldData.fieldContents.forEach(function (fieldContent) {
								if (!vm.oldData.fieldId) {
									vm.oldData.fieldId = fieldContent.fieldId;
								}
								if (fieldContent.content) {
									fieldContent.content = $sce.trustAsHtml(fieldContent.content);
								}
								if (fieldContent.description) {
									fieldContent.description = $sce.trustAsHtml(fieldContent.description);
								}
							});
							updateFields();
						}
						if (vm.isShowMetadata && vm.isShowMetatagTab) {
							vm.oldData.metadatas = angular.copy(vm.metadataList);
							formatMetadata();
						}
						angular.copy(vm.oldData, vm.originalData);
						runServicesAfterInit();

						vm.oldData.documentInformation = angular.copy(vm.oldData);
						vm.oldData.confirmInformation = vm.currentData.confirmInformation;

						vm.oldData.fieldId = $stateParams.fieldId;

						buildDocumentObjectFromCurrentDocument(vm.oldData);

						getHearingData();

						$rootScope.title = globalResources.Handbook + " - " + result.data.documentName;
						return vm.currentData;
					})
					.catch(function (result) {
						vm.errorMessage = result.data;
						vm.showError = true;
						// Update currentData so favorite button work
						vm.currentData.documentId = vm.documentId;
						runErrorServicesAfterInit();
					});
		};

		function runErrorServicesAfterInit() {
			tabStateService.closeOpenedTabIfNoPrivilege(tabStateType.documentTabState);
		}

		function getMetadataTab() {
			$http.get(handbookRequests.GetDocumentMetadataRequest, { params: { 'documentId': $stateParams.documentId } })
				.then(function (result) {
					vm.metadataList = result.data;
				});
		};

		function formatMetadata() {
			if (vm.isShowMetadata && vm.oldData.metadatas && vm.oldData.metadatas.length > 0 && vm.isShowMetatagTab) {
				vm.oldData.metadatas.forEach(function (item) {
					item.nameDisplay = $sce.trustAsHtml(item.registerName + ' - ' + item.registerItemName + ' - ' + item.registerValue);
				});
			}
		}

		function updateFields() {
			if (vm.oldData.relatedAttachments && vm.oldData.relatedAttachments.length > 0) {
				vm.oldData.relatedAttachments.forEach(function (x) {
					x.itemId = x.extraId ? x.extraId : x.itemId;
				});
			}
			var relatedDocumentAll = angular.copy(vm.oldData.relatedDocuments);
			var relatedAttachmentAll = angular.copy(vm.oldData.relatedAttachments);

			vm.oldData.isShowTopBoxContent = false;

			for (var i = 0; i < vm.oldData.fieldContents.length; i++) {
				var fieldContent = vm.oldData.fieldContents[i];
				if (fieldContent.relatedAttachments && fieldContent.relatedAttachments.length > 0) {
					fieldContent.relatedAttachments.forEach(function (x) {
						x.itemId = x.extraId ? x.extraId : x.itemId;
					});
				}
				if (checkShowFieldName(fieldContent)) {
					vm.oldData.isShowTopBoxContent = true;
				}

				var relatedDocuments = fieldContent.relatedDocuments;
				relatedDocumentAll = relatedDocumentAll.concat(relatedDocuments);

				var relatedAttachments = fieldContent.relatedAttachments;
				relatedAttachmentAll = relatedAttachmentAll.concat(relatedAttachments);

				var relatedImageGroups = groupBy(fieldContent.images, function (item) {
					return [item.verticalAlign];
				});
				var relatedBottomImages = [];
				var relatedTopImages = [];
				relatedImageGroups.forEach(function (item) {
					if (item.key == parseInt(E.VerticalAlign.Top)) {
						relatedTopImages = relatedTopImages.concat(item.value.data);
					} else {
						if (item.key == parseInt(E.VerticalAlign.Bottom)) {
							relatedBottomImages = relatedBottomImages.concat(item.value.data);
						}
					}
				});
				fieldContent.relatedTopImages = relatedTopImages;
				fieldContent.relatedBottomImages = relatedBottomImages;
			}
		};

		function getHearingData() {
			$http.get(handbookRequests.GetHearingForFeedbackRequest, {
				params: {
					'entityId': vm.oldData.entityId
				}
			})
				.then(function (response, status, headers, config) {
					if (response.data && response.data.id != null && response.data.id > 0) {
						vm.hearing = response.data;
						if (vm.hearing.description && vm.hearing.description != '') {
							vm.hearing.description = $sce.trustAsHtml(vm.hearing.description.replace(/[\r\n\t]/g, "<br/>"));
						}
						checkMemberHearing();
						if (vm.oldData.approvalStatus == 3) {
							vm.showComment = (!vm.hearing.public && vm.isMemberHearing) || vm.hearing.public;
						} else {
							vm.showComment = false;
							vm.hearingClose = true;
						}
						if (vm.hearingClose) {
							vm.closeHearings = vm.hearing.hearingMembers;
							pubSub.publish(broadcastType.gridDataChanges, { id: 'closeHearing', data: vm.closeHearings }, { isForced: true });
						} else {
							vm.hearings = vm.hearing.hearingMembers;
						}
						vm.preHearingMembers = vm.hearing.preHearingMembers;

						if (!vm.hearingCommentAfterResponse && !vm.isMyAssessment) {
							vm.showComment = false;
						}

						adjustmentHearingComments(vm.hearing.hearingComments, vm.hearing.preHearingComments);
					}
				});
		};

		function checkShowFieldName(fieldContent) {
			if (fieldContent.fieldName != '' && fieldContent.fieldName != undefined && fieldContent.isVisible && !fieldContent.isHideByBooklet) {
				return true;
			}
			return false;
		}

		function adjustmentHearingComments(dataComments, preDataComments) {
			var commentDocuments = [];
			var commentFields = [];
			if (dataComments.length > 0) {
				dataComments.forEach(function (item) {
					if (item.fieldId == null) {
						commentDocuments.push(angular.copy(item));
					} else {
						commentFields.push(angular.copy(item));
					}
				});
			}
			vm.commentDocuments = commentDocuments;

			var preCommentDocuments = [];
			var preCommentFields = [];
			if (preDataComments.length > 0) {
				preDataComments.forEach(function (item) {
					if (item.fieldId == null) {
						preCommentDocuments.push(angular.copy(item));
					} else {
						preCommentFields.push(angular.copy(item));
					}
				})
			}
			vm.preCommentDocuments = preCommentDocuments;

			if ((commentFields != null && commentFields.length > 0) || (preCommentFields != null && preCommentFields.length > 0)) {
				for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
					var fieldContent = vm.documentInformation.fieldContents[i];
					fieldContent.commentDocumentText = '';
					if (commentFields != null && commentFields.length > 0) {
						var comments = [];
						commentFields.forEach(function (item) {
							if (fieldContent.fieldId == item.fieldId) {
								comments.push(angular.copy(item));
							}
						});
						fieldContent.comments = comments;
					}
					if (preCommentFields != null && preCommentFields.length > 0) {
						var preComments = [];
						preCommentFields.forEach(function (item) {
							if (fieldContent.fieldId == item.fieldId) {
								preComments.push(angular.copy(item));
							}
						});
						fieldContent.preComments = preComments;
					}

					if (fieldContent.fieldId == $stateParams.fieldId) {
						vm.documentInformation.fieldContent = angular.copy(fieldContent);
					}

				}
			} else {
				for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
					var fieldContent = vm.documentInformation.fieldContents[i];
					if (fieldContent.fieldId == $stateParams.fieldId) {
						vm.documentInformation.fieldContent = angular.copy(fieldContent);
					}
				}
			}
		};

		function convertToNodeType(documentType) {
			switch (documentType.toString()) {
				case E.documentTypes.Document:
					return E.nodeTypes.Document;
				case E.documentTypes.LinkDocument:
					return E.nodeTypes.LinkDocument;
				case E.documentTypes.FileDocument:
					return E.nodeTypes.FileDocument;
				case E.documentTypes.ShortcutDocument:
					return E.nodeTypes.ShortcutDocument;
			}
		}

		function setIconForDocument(data) {
			data = data == null ? vm.currentData : data;
			var icon = '';
			switch (data.levelType.toString()) {
				case E.HandbookLevelTypes.Enterprise:
					icon = paths.DocumentLevelTypeEnterprise;
					break;
				case E.HandbookLevelTypes.Regional:
					icon = paths.DocumentLevelTypeRegional;
					break;
				case E.HandbookLevelTypes.Local:
					icon = paths.DocumentLevelTypeLocal;
					break;
				default:
					icon = paths.DocumentLevelTypeEnterprise;
					break;
			}
			data.docIcon = icon;
		}

		function buildDocumentObjectFromCurrentDocument(currentDocument) {
			if (currentDocument) {
				vm.documentInformation = angular.copy(currentDocument.documentInformation);
				vm.currentData = angular.copy(currentDocument.documentInformation);
				setIconForDocument(vm.documentInformation);
				if (vm.currentData.description) {
					vm.currentData.description = $sce.trustAsHtml(vm.currentData.description.toString());
				}
				if (vm.isShowMetadata && vm.currentData.metadatas && vm.currentData.metadatas.length > 0 && vm.isShowMetatagTab) {
					vm.currentData.metadatas.forEach(function (item) {
						item.nameDisplay = $sce.trustAsHtml(item.nameDisplay.toString());
					});
				}
				if (vm.documentInformation) {
					for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
						if (vm.documentInformation.fieldContents[i].fieldId == currentDocument.fieldId) {
							vm.fieldId = currentDocument.fieldId;
							vm.currentData.confirmInformation = currentDocument.confirmInformation;
							vm.documentInformation.fieldContents[i].activeField = 'active';
							if (vm.documentInformation.fieldContents[i].fieldName) {
								vm.documentInformation.fieldName = $sce.trustAsHtml(vm.documentInformation.fieldContents[i].fieldName.toString());
							}
							if (vm.documentInformation.fieldContents[i].content) {
								vm.documentInformation.content = $sce.trustAsHtml(vm.documentInformation.fieldContents[i].content.toString());
							}
							vm.documentInformation.relatedDocuments = vm.documentInformation.fieldContents[i].relatedDocuments;
							vm.documentInformation.relatedAttachments = vm.documentInformation.fieldContents[i].relatedAttachments;

							vm.documentInformation.relatedTopImages = vm.documentInformation.fieldContents[i].relatedTopImages;
							vm.documentInformation.relatedBottomImages = vm.documentInformation.fieldContents[i].relatedBottomImages;

							vm.documentInformation.fieldContent = vm.documentInformation.fieldContents[i];
						}
						else {
							vm.documentInformation.fieldContents[i].activeField = '';
						}
					}
				}
			}
		};

		function showContent(fieldItem) {
			vm.clearActive();
			fieldItem.activeField = 'active';
			if (fieldItem.fieldName) {
				vm.documentInformation.fieldName = $sce.trustAsHtml(fieldItem.fieldName);
			}
			if (fieldItem.content) {
				vm.documentInformation.content = $sce.trustAsHtml(fieldItem.content.toString());
			} else {
				vm.documentInformation.content = '';
			}
			vm.documentInformation.fieldContent = angular.copy(fieldItem);

			vm.documentInformation.relatedDocuments = fieldItem.relatedDocuments;
			vm.documentInformation.relatedAttachments = fieldItem.relatedAttachments;
			vm.documentInformation.relatedTopImages = fieldItem.relatedTopImages;
			vm.documentInformation.relatedBottomImages = fieldItem.relatedBottomImages;
			vm.fieldId = fieldItem.fieldId;
			angular.copy(vm.documentInformation, vm.originalData);
			updateLocalAnchors();
		};

		function clearActive() {
			for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
				vm.documentInformation.fieldContents[i].activeField = '';
			}
		};

		function searchAndHighlightText() {
			highlightTextInContent();
			documentContentsSearchService.searchAndHighlightText(vm.highlights);
		};

		function navForward() {
			documentContentsSearchService.navForward(vm.highlights);
		};

		function navBackward() {
			documentContentsSearchService.navBackward(vm.highlights);
		};

		function highlightTextInContent() {
			if (vm.documentInformation.content != undefined) {
				angular.copy(vm.originalData, vm.documentInformation);
				vm.documentInformation.content = documentContentsSearchService.searchAndHighlight(vm.documentInformation.content, vm.highlights.highlightText);
			}
		};

		function updateLocalAnchors() {
			$timeout(function () {
				var domContent = angular.element('div.contentWithLayout');
				anchorService.updateLocalAnchors(domContent, true);
				scrollToAnchorIfExists();
			});
		}

		function scrollToAnchorIfExists() {
			var hash = $location.hash();
			if (hash != '') {
				$anchorScroll();
			}
		}

		function runServicesAfterInit() {
			updateLocalAnchors();
		}

		function checkMemberHearing() {
			if (vm.hearing.hearingMembers.length > 0) {
				vm.hearing.hearingMembers.forEach(function (item) {
					if (item.employeeId == vm.loginUserId) {
						vm.isMyAssessment = !item.hearingResponse && vm.currentData.approvalStatus == 3;
						vm.isMemberHearing = true;
					}
				})
			}
		};

		function focusItem(itemId) {
			setTimeout(function () {
				angular.element('#' + itemId).show();
				angular.element('#' + itemId).focus();
			}, 0);
		};

		function goBackDocumentHearing() {
			$state.go(handbookActions.HearingAction, { documentId: vm.documentId });
		}

		function saveCommentField(fieldContent, isDraft) {
			var request = {
				entityId: vm.oldData.entityId,
				hearingsId: vm.hearing.id,
				comment: fieldContent.commentDocumentText,
				isDraft: isDraft,
				fieldId: fieldContent.fieldId
			};
			$http.post(handbookRequests.CreateHearingCommentRequest, request)
				.success(function (data, status, headers, config) {
					updateCommentsInformation(fieldContent, data);
					fieldContent.comments = data;
					fieldContent.commentDocumentText = '';
				})
				.error(function (data, status, headers, config) {
					vm.hearingClose = true;
				});
		};

		function editCommentField(comment, fieldContent, isDraft) {
			var request = {
				entityId: vm.oldData.entityId,
				id: comment.id,
				hearingsId: vm.hearing.id,
				comment: comment.commentDocumentText,
				isDraft: isDraft,
				fieldId: fieldContent.fieldId
			};
			$http.post(handbookRequests.UpdateHearingCommentRequest, request)
				.success(function (data, status, headers, config) {
					updateCommentsInformation(fieldContent, data);
					fieldContent.comments = data;
				})
				.error(function (data, status, headers, config) {
					vm.hearingClose = true;
				});
		};

		function updateCommentsInformation(fieldContent, data) {
			for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
				if (vm.documentInformation.fieldContents[i].fieldId == fieldContent.fieldId) {
					vm.documentInformation.fieldContents[i].comments = data;
					break;
				}
			}
		}

		function deleteCommentField(comment, comments) {
			var isConfirm = confirm(globalResources.DeleteHearingCommentConfirmMessage);
			if (isConfirm) {
				var request = {
					entityId: vm.currentData.entityId,
					id: comment.id
				};
				$http.post(handbookRequests.DeleteHearingCommentRequest, request)
					.success(function (data, status, headers, config) {
						comments.splice($.inArray(comment, comments), 1);
						for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
							if (vm.documentInformation.fieldContents[i].fieldId == vm.documentInformation.fieldContent.fieldId) {
								vm.documentInformation.fieldContents[i].comments.splice($.inArray(comment, vm.documentInformation.fieldContents.comments), 1);
								break;
							}
						}
					})
					.error(function (data, status, headers, config) {
						vm.hearingClose = true;
					});
			}
		};

		function editCommentDraf(comment) {
			comment.showCommentDocument = true;
			vm.focusItem('txtUpdateComment');
			comment.commentDocumentText = comment.comment.replace(new RegExp('<br/>', 'g'), '\n');
		}

		function printPDF() {
			window.open(String.format("/Printing/PrintHearingFeedback?documentId={0}", vm.documentId));
		};

		function anchorClick(hash) {
			if (vm.documentInformation.fieldContents.length == 1)
				return;
			var existedAnchor = false;
			var domContent = angular.element('div.contentWithLayout');
			angular.forEach(domContent.find('a[name]'), function (tag) {
				if (hash.hash.indexOf(tag.attributes.name.value) != -1) {
					existedAnchor = true;
				}
			});
			if (existedAnchor)
				return;

			var field = null;
			for (var i = 0; i < vm.documentInformation.fieldContents.length; i++) {
				var fieldContent = vm.documentInformation.fieldContents[i];
				if (fieldContent.fieldId == vm.fieldId || !fieldContent.content) {
					continue;
				}

				var div = document.createElement('div');
				div.innerHTML = fieldContent.content;
				domContent = angular.element(div);
				angular.forEach(domContent.find('a[name]'), function (tag) {
					if (hash.hash.indexOf(tag.attributes.name.value) != -1) {
						existedAnchor = true;
					}
				});
				if (existedAnchor) {
					field = fieldContent;
					break;
				}
			}
			if (field != null) {
				showContent(field);
			}
		}

		function getNextSearchResultByEnter(keyEvent) {
			if (keyEvent.which == 13) {
				navForward();
			}
		}

		$scope.$on('anchorclick', function (e, target) {
			anchorClick(target);
		});

	};

})();;
(function () {
    'use strict';

    angular.module('compareWithEarlierVersionModule', [])
        .controller('CompareWithEarlierVersionController', controller);

    controller.$inject = ['$http', '$state', '$sce', '$q', 'documentService', 'configService'];

    function controller($http, $state, $sce, $q, documentService, configService) {
        var vm = this;
        
        vm.DocumentTitleResult = '';
        vm.translation = globalResources
        vm.DocumentTitleResult = '';
        vm.currentDocumentId = $state.params.documentId;
        vm.childDocumentId = $state.params.documentId;
        vm.parentDocumentId = 0;
        vm.originalData = {};
        vm.fromVersions = [];
        vm.toVersions = [];
        vm.input = {
            fromVersion: null,
            toVersion: null
        };
        vm.enableDocumentExtention = configService.getBool(HandbookConfiguration.EnableDocumentExtention);
        vm.showCompareParentExtension = false;
        vm.showCompareChildrenExtension = false;

        initialize();
        vm.printDocumentComparison = printDocumentComparison;
        vm.changeFromVersion = changeFromVersion;
        vm.changeToVersion = changeToVersion;
        vm.viewCompareParentDocument = viewCompareParentDocument;
        vm.viewCompareChildDocument = viewCompareChildDocument;

        function initialize() {
            angular.element('.main-container_header').hide();
            if (vm.enableDocumentExtention) {
                vm.parentDocumentId = 0;

                var promises = [];
                var hearingMode = true;
                promises.push(documentService.getParentIdExtendDocument(vm.currentDocumentId, hearingMode));
                promises.push(documentService.checkDocumentHaveToCompareById(vm.currentDocumentId, hearingMode));

                $q.all(promises).then(function (result) {
                    var resultGetParentId = parseInt(result[0]);
                    if (resultGetParentId && resultGetParentId > 0) {
                        vm.parentDocumentId = resultGetParentId;
                    }

                    var resultCheckDocumentHaveToCompareById = result[1];
                    if (!resultCheckDocumentHaveToCompareById) {
                        vm.currentDocumentId = vm.parentDocumentId;
                    }

                    vm.showCompareParentExtension = vm.parentDocumentId > 0;
                    vm.showCompareChildrenExtension = resultCheckDocumentHaveToCompareById;

                    generateComparisonResult(null, 0);
                });
            }
            else {
                generateComparisonResult(null, 0);
            }
        }

        function generateComparisonResult(selectedVersion, isType) {

            var params = {
                params: {
                    documentId: vm.currentDocumentId,
                    fromVersion: vm.input.fromVersion,
                    toVersion: vm.input.toVersion,
                    showLoading: true
                }
            };

            $http
                .get('/api/Documents/GenerateComparisonResult', params)
                .success(function (data) {
                    vm.data = data;
                    if (isType == 0) { // initialize
                        vm.originalData = angular.copy(vm.data);
                        getDataForComboVersions(selectedVersion, isType);
                        vm.input.fromVersion = parseInt(data.earlierVersionNumber);
                        vm.input.toVersion = parseInt(data.latestVersionNumber);
                    } else {
                        getDataForComboVersions(selectedVersion, isType);
                    }
					vm.DocumentTitleResult = $sce.trustAsHtml(String.format('{0} - {1} - {2}: {3} - {4} {5} {6} {7}', globalResources.ComparisonResult,
                        data.comparisonNameResult, globalResources.DocId, vm.currentDocumentId,
						globalResources.CommonGridColumns.Version, data.earlierVersionNumber, globalResources.And, data.latestVersionNumber));

                    vm.data.earlierVersionHtml = $sce.trustAsHtml(data.earlierVersionHtml);
                    vm.data.latestVersionHtml = $sce.trustAsHtml(data.latestVersionHtml);
                    vm.data.comparisonResult = $sce.trustAsHtml(data.comparisonResult);
                })
                .error(function (data, status, headers, config) {
                    vm.errorMessage = getErrorMessage(status);
                });
        }

        function getDataForComboVersions(selectedVersion, isType) {

            if (selectedVersion == null && isType > 0)
                return;
            var latestVersion = parseInt(vm.originalData.latestVersionNumber);
            var fromVersions = [];
            var toVersions = [];
            switch (isType) {
                case 0:// initialize
                    selectedVersion = latestVersion - 1;
                    for (var i = 0; i <= selectedVersion; i++) {
                        fromVersions.push({ id: i, name: i });
                    }
                    for (var j = selectedVersion + 1; j <= latestVersion; j++) {
                        toVersions.push({ id: j, name: j });
                    }
                    vm.fromVersions = angular.copy(fromVersions);
                    vm.toVersions = angular.copy(toVersions);
                    break;
                case 1: // From version
                    for (var j = selectedVersion + 1; j <= latestVersion; j++) {
                        toVersions.push({ id: j, name: j });
                    }
                    vm.toVersions = angular.copy(toVersions);
                    break;
                case 2: // to version
                    selectedVersion = selectedVersion - 1;
                    for (var i = 0; i <= selectedVersion; i++) {
                        fromVersions.push({ id: i, name: i });
                    }
                    vm.fromVersions = angular.copy(fromVersions);
                    break;
                default:
            }
        }

        function changeFromVersion() {
            generateComparisonResult(vm.input.fromVersion, 1);
        }

        function changeToVersion() {
            generateComparisonResult(vm.input.toVersion, 2);
        }

        $(window).on('resize', function () {
            angular.element('.comparison-result').removeAttr('style');
            angular.element('#resizeBar').removeAttr('style');
            angular.element('.comparison-versions').removeAttr('style');
        });

        function printDocumentComparison() {
            window.open(String.format('/Printing/PrintCompareWithEarlierVersion?documentId={0}&fromVersion={1}&toVersion={2}', vm.currentDocumentId, vm.input.fromVersion, vm.input.toVersion));
        }

        function viewCompareParentDocument() {
            if (vm.currentDocumentId != vm.parentDocumentId) {
                vm.currentDocumentId = vm.parentDocumentId;
                generateComparisonResult(null, 0);
            }
        }

        function viewCompareChildDocument() {
            if (vm.currentDocumentId != vm.childDocumentId) {
                vm.currentDocumentId = vm.childDocumentId;
                generateComparisonResult(null, 0);
            }
        }
    }
})();;
(function () {
	'use strict';

	angular.module('documentCompareWithEarlierVersionModule', [])
		.controller('DocumentCompareWithEarlierVersionController', controller);

	controller.$inject = ['$http', '$state', '$sce', '$scope', '$q', 'documentService', 'configService'];

	function controller($http, $state, $sce, $scope, $q, documentService, configService) {
        var vm = this;
        
        vm.translation = globalResources
		vm.DocumentTitleResult = '';
        vm.currentDocumentId = $state.params.documentId;
        vm.childDocumentId = $state.params.documentId;
        vm.parentDocumentId = 0;
		vm.originalData = {};
		vm.fromVersions = [];
		vm.toVersions = [];
		vm.input = {
			fromVersion: null,
			toVersion: null
		};

		vm.advancedCompare = configService.getBool(HandbookConfiguration.AdvancedCompare);
		vm.enableDocumentExtention = configService.getBool(HandbookConfiguration.EnableDocumentExtention);
        vm.showCompareParentExtension = false;
        vm.showCompareChildrenExtension = false;

		initialize();
		vm.printDocumentComparison = printDocumentComparison;
		vm.changeFromVersion = changeFromVersion;
        vm.changeToVersion = changeToVersion;
        vm.viewCompareParentDocument = viewCompareParentDocument;
        vm.viewCompareChildDocument = viewCompareChildDocument;


        function initialize() {

			window.addEventListener('resize', initCompareScrollEvent, true /*Capture event*/);
			angular.element('.main-container_header').hide();

            $scope.$on('$destroy', function () {
                window.removeEventListener('resize', initCompareScrollEvent);
            });

            function initCompareScrollEvent() {
                if (vm.advancedCompare) {
                    angular.element('.comparison-result').removeAttr('style');
                    angular.element('#resizeBar').removeAttr('style');
                    angular.element('.comparison-versions').removeAttr('style');
                }
            }
            
            if (vm.enableDocumentExtention) {
                vm.parentDocumentId = 0;

                var promises = [];

                promises.push(documentService.getParentIdExtendDocument(vm.currentDocumentId));
                promises.push(documentService.checkDocumentHaveToCompareById(vm.currentDocumentId));

                $q.all(promises).then(function (result) {
                    var resultGetParentId = parseInt(result[0]);
                    if (resultGetParentId && resultGetParentId > 0) {
                        vm.parentDocumentId = resultGetParentId;
					}

					var resultCheckDocumentHaveToCompareById = result[1];
                    if (!resultCheckDocumentHaveToCompareById) {
                        vm.currentDocumentId = vm.parentDocumentId;
                    }

                    vm.showCompareParentExtension = vm.parentDocumentId > 0;
                    vm.showCompareChildrenExtension = resultCheckDocumentHaveToCompareById;

                    generateComparisonResult(null, 0);
                });
            }
            else {
                generateComparisonResult(null, 0);
            }
		}

		function generateComparisonResult(selectedVersion, isType) {

			var params = {
				params: {
                    documentId: vm.currentDocumentId,
					fromVersion: vm.input.fromVersion,
					toVersion: vm.input.toVersion
				}
			};

			$http
				.get('/api/Documents/GenerateDocumentComparisonResult', params)
				.success(function (data) {
					vm.data = data;
					if (vm.advancedCompare) {
						if (isType == 0) { // initialize
							vm.originalData = angular.copy(vm.data);
							getDataForComboVersions(selectedVersion, isType);
							vm.input.fromVersion = parseInt(data.earlierVersionNumber);
							vm.input.toVersion = parseInt(data.latestVersionNumber);
						} else {
							getDataForComboVersions(selectedVersion, isType);
						}
					}
					vm.DocumentTitleResult = $sce.trustAsHtml(String.format('{0} - {1} - {2}: {3} - {4} {5} {6} {7}', globalResources.ComparisonResult,
                        data.comparisonNameResult, globalResources.DocId, vm.currentDocumentId,
						globalResources.CommonGridColumns.Version, data.earlierVersionNumber, globalResources.And, data.latestVersionNumber));
					vm.data.earlierVersionHtml = $sce.trustAsHtml(data.earlierVersionHtml);
					vm.data.latestVersionHtml = $sce.trustAsHtml(data.latestVersionHtml);
					vm.data.comparisonResult = $sce.trustAsHtml(data.comparisonResult);
				})
				.error(function (data, status, headers, config) {
					vm.errorMessage = getErrorMessage(status);
				});
		}

		function getDataForComboVersions(selectedVersion, isType) {

			if (selectedVersion == null && isType > 0)
				return;
			var latestVersion = parseInt(vm.originalData.latestVersionNumber);
			var fromVersions = [];
			var toVersions = [];
			switch (isType) {
				case 0:// initialize
					selectedVersion = latestVersion - 1;
					for (var i = 0; i <= selectedVersion; i++) {
						fromVersions.push({ id: i, name: i });
					}
					for (var j = selectedVersion + 1; j <= latestVersion; j++) {
						toVersions.push({ id: j, name: j });
					}
					vm.fromVersions = angular.copy(fromVersions);
					vm.toVersions = angular.copy(toVersions);
					break;
				case 1: // From version
					for (var j = selectedVersion + 1; j <= latestVersion; j++) {
						toVersions.push({ id: j, name: j });
					}
					vm.toVersions = angular.copy(toVersions);
					break;
				case 2: // to version
					selectedVersion = selectedVersion - 1;
					for (var i = 0; i <= selectedVersion; i++) {
						fromVersions.push({ id: i, name: i });
					}
					vm.fromVersions = angular.copy(fromVersions);
					break;
				default:
			}
		}

		function changeFromVersion() {
			generateComparisonResult(vm.input.fromVersion, 1);
		}

		function changeToVersion() {
			generateComparisonResult(vm.input.toVersion, 2);
		}

		function printDocumentComparison() {
			if (vm.advancedCompare) {
				window.open(String.format('/Printing/PrintDocumentComparisonResultForLatestApproved?documentId={0}&fromVersion={1}&toVersion={2}', $state.params.documentId, vm.input.fromVersion, vm.input.toVersion));
			} else {
                window.open(String.format('/Printing/PrintDocumentComparisonResultForLatestApproved?documentId={0}', vm.currentDocumentId));
			}
        }

        function viewCompareParentDocument() {
            if (vm.currentDocumentId != vm.parentDocumentId) {
                vm.currentDocumentId = vm.parentDocumentId;
                vm.input.fromVersion = null;
                vm.input.toVersion = null;
                generateComparisonResult(null, 0);
            }
        }

        function viewCompareChildDocument() {
            if (vm.currentDocumentId != vm.childDocumentId) {
                vm.currentDocumentId = vm.childDocumentId;
                vm.input.fromVersion = null;
                vm.input.toVersion = null;
                generateComparisonResult(null, 0);
            }
        }
	}
})();;

(function () {
    'use strict';

    angular.module('handbookApp')
        .controller("FieldsContentWholeDocumentController", FieldsContentWholeDocumentController);

    FieldsContentWholeDocumentController.$inject = ['$http','$state', '$sce', '$timeout', '$location', '$scope', '$rootScope', '$anchorScroll',
        'documentService', 'anchorService', 'documentContentsSearchService', 'resizeService', '$stateParams', 'pubSub', 'folderService',
        'treeNavigationService', '$q', 'tabStateService', 'configService'];

    function FieldsContentWholeDocumentController($http, $state, $sce, $timeout, $location, $scope, $rootScope, $anchorScroll,
        documentService, anchorService, documentContentsSearchService, resizeService, $stateParams, pubSub, folderService,
        treeNavigationService, $q, tabStateService, configService) {

        var ignoreRichText = configService.getBool(HandbookConfiguration.LazyLoadRichText);

        var vm = this;

        //vm.documentInformation = {};
        vm.originalData = {};
        vm.fieldId = -1;
        vm.currentData = {};
        vm.highlights = {
            highlightText: '',
            currentIndex: 0,
            totalFound: 0
        };
        vm.FolderLinks = [];
        vm.menuFields = [];
		var isIE = detectIE();

        var urlParams = $location.url().split('/');
        var isFieldActive;
        vm.isEmbedUrl = false;
        vm.typeHideHeader = false;
        vm.documentId = $stateParams.documentId;
        vm.hideGoToDocumentFields = true;

        vm.addFavoriteRequest = handbookRequests.AddFavoriteDocument;
        vm.removeFavoriteRequest = handbookRequests.RemoveFavoriteDocument;

        if (urlParams != null && urlParams.length > 0) {
            vm.isEmbedUrl = urlParams[1] == 'embed';
            if (vm.isEmbedUrl) {
                vm.fieldId = urlParams[5];
                vm.typeHideHeader = urlParams.length == 7 ? (urlParams[6] == '1') : false;
                vm.documentId = urlParams[3];
            }
        }
        vm.urlDocument = window.location.origin + '/document/' + vm.documentId + '?preview=true';
        vm.showDocumentLinkToBackend = configService.getBool(HandbookConfiguration.ShowDocumentLinkToBackend);
        vm.simpleSubscription = configService.getBool(HandbookConfiguration.SimpleSubscription);

        vm.isShowMetadata = configService.getBool(HandbookConfiguration.MetadataEnabled);
        vm.isShowMetatagTab = configService.getBool(HandbookConfiguration.ShowMetatagTab);
        vm.publishedVersion = configService.getBool(HandbookConfiguration.PublishedVersion);
        vm.showContent = showContent;
        vm.searchAndHighlightText = searchAndHighlightText;
        vm.navForward = navForward;
        vm.navBackward = navBackward;
        vm.printDocumentField = printDocumentField;
        vm.fullScreen = fullScreen;
        vm.isFloatTitle = $(window).height() > HandbookConfiguration.DocumentTitleScreenHeight ? true : false;
        vm.linkToDocumentManagement = linkToDocumentManagement;
        vm.getNextSearchResultByEnter = getNextSearchResultByEnter;
        vm.documentViewOption = parseInt(HandbookConfiguration.DocumentViewOption);
        vm.isToggleSidebarFields = true;
        vm.showSidebarFields = showSidebarFields;
        vm.hideSidebarFields = hideSidebarFields;
		vm.setStickyTitle = setStickyTitle;
        vm.compareDocument = compareDocument;
        vm.hideCompareButton = false;

        initialize();

        function initialize() {
            window.location.replace('/document/' + $stateParams.documentId + '#' + $stateParams.fieldId)
        };

        function processEmbedUrl() {
            if (vm.isEmbedUrl) {
                if (vm.typeHideHeader) {
                    angular.element('#documentHeader1Container').hide();
                    angular.element('#fieldTitle').hide();
                }
            }
        }

        function linkToDocumentManagement() {
            var backendUrl = HandbookConfiguration.BackendURL;
            var lastChar = backendUrl.charAt(backendUrl.length - 1);
            var commonAdd = lastChar == '/' ? '' : '/';
            if (vm.backendIsDb4) {
                var url = backendUrl + '&documentId=' + vm.documentId;
                url = url.replace('gk=2', 'gk=1');
                window.open(url, '_blank');
            } else {
                window.open(backendUrl + commonAdd + 'document/' + vm.documentId, '_blank');
            }
        };

        function getDocument() {
            if (vm.isShowMetadata && vm.isShowMetatagTab) {
                getMetadataTab();
            }

            var params = {
                params: {
                    'documentId': vm.documentId,
                    'ignoreRichText': ignoreRichText,
                    showLoading: true
                }
            };

            vm.currentDataPromise =
                $http.get(handbookRequests.GetDocumentInformationRequest, params)
                    .then(function (result) {
                        var fieldIdTemp = vm.isEmbedUrl ? vm.fieldId : $stateParams.fieldId;
                        vm.isFavoriteNodeSelected = true;
                        createTooltipsRelatedDocument(result.data);
                        vm.currentData = result.data;
                        if (vm.currentData.description) {
                            vm.currentData.description = $sce.trustAsHtml(vm.currentData.description.replace(new RegExp(String.fromCharCode(13) + String.fromCharCode(10), 'g'), '<br/>'));
                        }
                        vm.currentData.nodeType = convertToNodeType(vm.currentData.type);
                        var fieldContentTemp = null;
                        if (vm.currentData.fieldContents != null) {

                            var richTextRequests = [];

                            vm.currentData.fieldContents.forEach(function (fieldContent) {
                                if (fieldContent.fieldId == fieldIdTemp) {
                                    fieldContentTemp = fieldContent;
                                }
                                if (fieldContent.description) {
                                    fieldContent.description = $sce.trustAsHtml(fieldContent.description);
                                }
                                vm.menuFields.push("Id" + fieldContent.fieldId);

                                if (ignoreRichText && fieldContent.fieldType == 6 && fieldContent.fieldContentId) {
                                    var params = {
                                        params: {
                                            id: fieldContent.fieldContentId
                                        }
                                    }

                                    var getRichText = $http.get('/api/documents/getRichText', params).then(function (response) {
                                        if (response.data && response.data.content) {
                                            fieldContent.content = documentService.changeUrlBackendToFrontend(window.location.origin, response.data.content);
                                            fieldContent.content = $sce.trustAsHtml(`${fieldContent.content} `);
                                            fieldContent.isVisible = true;
                                        }
                                    });

                                    richTextRequests.push(getRichText);
                                } else {
                                    if (fieldContent.content) {
                                        fieldContent.content = documentService.changeUrlBackendToFrontend(window.location.origin, response.data.content);
                                        fieldContent.content = $sce.trustAsHtml(`${fieldContent.content} `);
                                    }
                                }
                            });

                            if (ignoreRichText) {
                                $q.all(richTextRequests).then(function () {
                                    angular.copy(vm.currentData, vm.originalData);
                                    $timeout(function () {
                                        showContent(fieldIdTemp, fieldContentTemp);
                                    });
                                    $timeout(function () {
                                        runServicesAfterInit();
                                    }, 2000);
                                });
                            }

                            updateFields();

                            if (vm.currentData.relatedDocuments.length > 0) {
                                vm.menuFields.push("IdrelatedDocument");
                            }
                            if (vm.currentData.relatedAttachments.length > 0) {
                                vm.menuFields.push("Idattachment");
                            }
                        }
                        if (vm.isShowMetadata && vm.isShowMetatagTab) {
                            vm.currentData.metadatas = angular.copy(vm.metadataList);
                            formatMetadata();
                        }

                        documentService.setDocuments(null); // clear service
                        vm.showDocumentLinkToBackend = vm.showDocumentLinkToBackend &&
							(vm.currentData.hasEditPermission || vm.currentData.hasApprovalPermission);

                        $rootScope.title = globalResources.Handbook + " - " + result.data.documentName;

                        angular.copy(vm.currentData, vm.originalData);
                        vm.currentData.fieldId = fieldIdTemp;

                        if(!ignoreRichText || !vm.currentData.fieldContents){
                            $timeout(function () {
                                showContent(fieldIdTemp, fieldContentTemp);
                            });
                            $timeout(function () {
                                runServicesAfterInit();
                            }, 2000);
                        }

                        setTimeout(function () { stickyTitle(); }, 0);
                        updateAfterCurrentDataChanged();
                        vm.isCompare = configService.getBool(HandbookConfiguration.EnableCompare) && vm.currentData.version > 0;
                        if (vm.currentData.type == E.documentTypes.LinkDocument || vm.currentData.type == E.documentTypes.FileDocument) {
                            vm.hideCompareButton = true;
                        }
                        return vm.currentData;
                    })
                    .catch(function (result) {
                        vm.errorMessage = result.data;
                        vm.showError = true;
                        // Update currentData so favorite button work
                        vm.currentData.documentId = vm.documentId;
                    });
        };

        function scrollAffectFieldSelected() {
            var lastId,
                topMenuDocument = $("#document-top-menu-identifier"),
                topMenuDocumentHeight = topMenuDocument.outerHeight(),
                idCurrent = '';
            for (var i = 0; i < vm.menuFields.length; i++) {
                var item = "#" + vm.menuFields[i];
                if ($(item).length) {
                    var top = $(item).offset().top;
                    if ((top < topMenuDocumentHeight + 250) && (top > 0)) {
                        idCurrent = vm.menuFields[i];
                        break;
                    }
                }
            }
            if ((lastId !== idCurrent) && (idCurrent != '')) {
                lastId = idCurrent;
                angular.forEach(vm.currentData.fieldContents, function (fieldContent) {
                    fieldContent.activeField = '';
                });
                switch (lastId) {
                    case 'Idattachment':
                        vm.activeAttachments = true;
                        break;
                    case 'IdrelatedDocument':
                        vm.activeRelatedDocuemnts = true;
                        break;
                    default:
                        var fieldId = lastId.substring(2);
                        for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
                            if (vm.currentData.fieldContents[i].fieldId == parseInt(fieldId)) {
                                $scope.$apply(function () {
                                    vm.currentData.fieldContents[i].activeField = 'active';
                                });
                                break;
                            }
                        }
                }
            }
		}

		function setStickyTitle() {
			setTimeout(function () { stickyTitle(); }, 0);
		}

		function stickyTitle(height) {
            var title = document.querySelector('#documentTitle');
            var titlePosition = title.getBoundingClientRect();
            var content = document.querySelector('#document-content-identifier');
            if (!content) {
                return;
            }

            var contentPosition = content.getBoundingClientRect();
			var placeholder = $("#placeholderTitleId")
			if (placeholder.length > 0) {
				placeholder.remove();
			}
			placeholder = document.createElement('div');
			placeholder.id = "placeholderTitleId";
            placeholder.style.height = titlePosition.height + 'px';
            var isAdded = false;
            var heightToFloat = 0, currentPosition = 0;
            heightToFloat = contentPosition.top + 50;
			var heightScroll = height ? height : $('#document-content-identifier').height();

			if ($(window).height() > HandbookConfiguration.DocumentTitleScreenHeight) {
				removeStickyTitle();
				$('#document-content-identifier').scroll(function () {
					var scrollTop = $('#document-content-identifier').scrollTop();
                    var isfullScreen = $('#document-content-identifier').hasClass('fullScreen-height');
					currentPosition = isfullScreen ? scrollTop : contentPosition.top + scrollTop;
					if (currentPosition >= heightToFloat && !isAdded) {
                        title.classList.add('sticky');
                        document.querySelector('#document-content-identifier').classList.add('scrolling');

						title.parentNode.insertBefore(placeholder, title);
						isAdded = true;
						var contentWidth = $('#document-content-identifier').width() + 10;
						if (!isfullScreen) {
							$('#documentTitle').css('top', contentPosition.top);
							$('#documentTitle').css('width', contentWidth);
							$('#documentTitle').css('background-color', 'white');
						} else {
							$('#documentTitle').css('width', contentWidth);
							$('#documentTitle').css('background-color', 'white');
						}
						heightScroll = !isfullScreen ? heightScroll : screen.availHeight - 100;
						$('#document-content-identifier').css('margin-top', '85px');
						$('#document-content-identifier').css('height', heightScroll -85);
					} else if (currentPosition < heightToFloat && isAdded) {
                        title.classList.remove('sticky');
                        document.querySelector('#document-content-identifier').classList.remove('scrolling');

						$('#documentTitle').css('top', '');
						$('#documentTitle').css('width', '');
						$('#documentTitle').css('background-color', '');
						$('#documentTitle').css('margin-left', '');
						title.parentNode.removeChild(placeholder);
						isAdded = false;
						$('#document-content-identifier').css('margin-top', '0px');
						$('#document-content-identifier').css('height', heightScroll);
					} else {
						//$('#document-content-identifier').css('height', heightScroll);
					}
                    if (!isFieldActive) {
                        scrollAffectFieldSelected();
                    }

                });
            }
            else {
                $('#document-content-identifier').scroll(function () {
                    var isfullScreen = $('#document-content-identifier').hasClass('fullScreen-height');
                    currentPosition = isfullScreen ? $('#document-content-identifier').scrollTop() : contentPosition.top + $('#document-content-identifier').scrollTop();
                    if (!isFieldActive) {
                        scrollAffectFieldSelected();
                    }
                });
            }
        }

		function runInitforIE(height) {
			if ($(window).height() > HandbookConfiguration.DocumentTitleScreenHeight) {
				var title = document.querySelector('#documentTitle');
				var titlePosition = title.getBoundingClientRect();
				var content = document.querySelector('#document-content-identifier');
				var contentPosition = content.getBoundingClientRect();
				var placeholder = $("#placeholderTitleId")
				if (placeholder.length > 0) {
					placeholder.remove();
				}
				placeholder = document.createElement('div');
				placeholder.id = "placeholderTitleId";
				var heightToFloat = 0, currentPosition = 0;
				heightToFloat = contentPosition.top + 50;
				var heightScroll = height ? height: $('#document-content-identifier').height();
				var scrollTop = $('#document-content-identifier').scrollTop();
				var isfullScreen = $('#document-content-identifier').hasClass('fullScreen-height');
				currentPosition = isfullScreen ? scrollTop : contentPosition.top + scrollTop;
				if (currentPosition >= heightToFloat) {
                    title.classList.add('sticky');
                    document.querySelector('#document-content-identifier').classList.add('scrolling');

					title.parentNode.insertBefore(placeholder, title);
					var contentWidth = $('#document-content-identifier').width() + 10;
					if (!isfullScreen) {
						$('#documentTitle').css('top', contentPosition.top);
						$('#documentTitle').css('width', contentWidth);
						$('#documentTitle').css('background-color', 'white');
					} else {
						$('#documentTitle').css('width', contentWidth);
						$('#documentTitle').css('background-color', 'white');
					}
					heightScroll = !isfullScreen ? heightScroll : screen.availHeight - 100;
					$('#document-content-identifier').css('margin-top', '90px');
					$('#document-content-identifier').css('height', heightScroll - 90);
				}
			}
		}

        function removeStickyTitle() {
            var title = document.querySelector('#documentTitle');
            title.classList.remove('sticky');
            $('#documentTitle').css('top', '');
            $('#documentTitle').css('width', '');
            $('#documentTitle').css('background-color', '');
			$('#documentTitle').css('margin-left', '');
            var placeholder = document.querySelector('#placeholderTitleId');
            if (placeholder != null) {
                title.parentNode.removeChild(placeholder);
            }
            document.querySelector('#document-content-identifier').classList.remove('scrolling');
            $('#document-content-identifier').unbind('scroll');
        }


        function getMetadataTab() {
            $http.get(handbookRequests.GetDocumentMetadataRequest, { params: { 'documentId': $stateParams.documentId } })
                .then(function (result) {
                    vm.metadataList = result.data;
                });
        };

        function formatMetadata() {
            if (vm.isShowMetadata && vm.currentData.metadatas && vm.currentData.metadatas.length > 0 && vm.isShowMetatagTab) {
                vm.currentData.metadatas.forEach(function (item) {
                    item.nameDisplay = $sce.trustAsHtml(item.registerName + ' - ' + item.registerItemName + ' - ' + item.registerValue);
                });
            }
        }

        function updateFields() {
            var relatedDocumentAll = angular.copy(vm.currentData.relatedDocuments);
            var relatedAttachmentAll = angular.copy(vm.currentData.relatedAttachments);

            vm.currentData.isShowTopBoxContent = false;

            for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
                var fieldContent = vm.currentData.fieldContents[i];
                if (checkShowFieldName(fieldContent)) {
                    vm.currentData.isShowTopBoxContent = true;
                }

                var relatedDocuments = fieldContent.relatedDocuments;
                relatedDocumentAll = relatedDocumentAll.concat(relatedDocuments);

                var relatedAttachments = fieldContent.relatedAttachments;
                relatedAttachmentAll = relatedAttachmentAll.concat(relatedAttachments);

                var relatedImageGroups = groupBy(fieldContent.images, function (item) {
                    return [item.verticalAlign];
                });
                var relatedBottomImages = [];
                var relatedTopImages = [];
                relatedImageGroups.forEach(function (item) {
                    if (item.key == parseInt(E.VerticalAlign.Top)) {
                        relatedTopImages = relatedTopImages.concat(item.value.data);
                    } else {
                        if (item.key == parseInt(E.VerticalAlign.Bottom)) {
                            relatedBottomImages = relatedBottomImages.concat(item.value.data);
                        }
                    }
                });
                fieldContent.relatedTopImages = relatedTopImages;
                fieldContent.relatedBottomImages = relatedBottomImages;
            }
        };

        function checkShowFieldName(fieldContent) {
            if (fieldContent.fieldName != '' && fieldContent.fieldName != undefined && fieldContent.isVisible && !fieldContent.isHideByBooklet) {
                return true;
            }
            return false;
        }

        function convertToNodeType(documentType) {
            switch (documentType.toString()) {
                case E.documentTypes.Document:
                    return E.nodeTypes.Document;
                case E.documentTypes.LinkDocument:
                    return E.nodeTypes.LinkDocument;
                case E.documentTypes.FileDocument:
                    return E.nodeTypes.FileDocument;
                case E.documentTypes.ShortcutDocument:
                    return E.nodeTypes.ShortcutDocument;
            }
        }

        function setIconForDocument(data) {
            data = data == null ? vm.currentData : data;
            var icon = '';
            switch (data.levelType.toString()) {
                case E.HandbookLevelTypes.Enterprise:
                    icon = paths.DocumentLevelTypeEnterprise;
                    break;
                case E.HandbookLevelTypes.Regional:
                    icon = paths.DocumentLevelTypeRegional;
                    break;
                case E.HandbookLevelTypes.Local:
                    icon = paths.DocumentLevelTypeLocal;
                    break;
                default:
                    icon = paths.DocumentLevelTypeEnterprise;
                    break;
            }
            data.docIcon = icon;
        }

        function updateAfterCurrentDataChanged() {
            setIconForDocument(vm.currentData);
        }

        function buildDocumentObjectFromCurrentDocument(currentDocument) {
            if (currentDocument) {
                vm.currentData = angular.copy(currentDocument.documentInformation);
                angular.copy(currentDocument.documentInformation, vm.originalData);
                updateAfterCurrentDataChanged();
                if (vm.currentData.description) {
                    vm.currentData.description = $sce.trustAsHtml(vm.currentData.description.toString());
                }
                var fieldContent = '';
                for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
                    if (vm.currentData.fieldContents[i].fieldId == currentDocument.fieldId) {
                        vm.fieldId = currentDocument.fieldId;
                        fieldContent = vm.currentData.fieldContents[i];
                        $timeout(function () {
                            showContent(vm.fieldId, fieldContent);
                        });
                    }
                }
                setTimeout(function () { stickyTitle(); }, 0);
            }
        };

        function clearActive() {
            vm.activeRelatedDocuments = false;
            vm.activeAttachments = false;

            for (var i = 0; i < vm.currentData.fieldContents.length; i++) {
                vm.currentData.fieldContents[i].activeField = '';
            }
        };

        function showContent(id, fieldContent) {
            isFieldActive = true;
            animationChangeBackgroundColor(id);
            clearActive();
            if (fieldContent) {
                fieldContent.activeField = 'active';
            } else {
                if (String(id).indexOf('IdrelatedDocument') > -1)
                    vm.activeRelatedDocuments = true;
                else
                    vm.activeAttachments = true;
            }
            setTimeout(function () {
                isFieldActive = false;
            }, 2000);
        };

        function animationChangeBackgroundColor(id) {
			id = String(id);
			var indexHash = id.indexOf('#');
			if (indexHash > 0) {
				id = id.substr(0, indexHash);
			}
            var hash = '#p' + id;
            var elementId = '#Id' + id;
            if (id.indexOf('IdrelatedDocument') > -1 || id.indexOf('Idattachment') > -1) {
                hash = '#' + id;
                elementId = '#' + id;
            }
            var $parentDiv = $('.document-detail');
            $parentDiv.animate({ scrollTop: $(hash).position().top }, 'slow');

            var $element = $(elementId);
            $element.animate({ backgroundColor: '#D7D7D7' }, 1500);
            $timeout(function () {
                $element.css("background-color", "");
            }, 2000);
        }

        function searchAndHighlightText() {
            highlightTextInContent();
            documentContentsSearchService.searchAndHighlightText(vm.highlights);
        };

        function navForward() {
            documentContentsSearchService.navForward(vm.highlights);
        };

        function navBackward() {
            documentContentsSearchService.navBackward(vm.highlights);
        };

        function printDocumentField() {
            window.open(String.format(handbookRequests.PrintHtmlFieldRequest, vm.documentInformation.documentId, vm.fieldId));
        };

        function highlightTextInContent() {
            if (vm.currentData.fieldContents != undefined) {
                var viewMode = angular.copy(vm.currentData.viewMode);
                angular.copy(vm.originalData, vm.currentData);
                vm.currentData.viewMode = viewMode;
                vm.currentData.fieldContents.forEach(function (fieldContent) {
                    fieldContent.content = documentContentsSearchService.searchAndHighlight(fieldContent.content, vm.highlights.highlightText);
                    fieldContent.description = $sce.trustAsHtml(fieldContent.description.toString());
                });
            }
        };

        function updateLocalAnchors() {
            $timeout(function () {
                var domContent = angular.element('div.contentWithLayout');
                anchorService.updateLocalAnchors(domContent, true);
                scrollToAnchorIfExists();
            });
        }

        function scrollToAnchorIfExists() {
            var hash = $location.hash();
            if (hash != '') {
                $anchorScroll();
            }
        }

        function runServicesAfterInit() {
            updateLocalAnchors();
        }

		function fullScreen() {
            if (vm.isFullScreen) {
                documentService.showFullscreen();
			} else {
				documentService.showNormal();
				tabStateService.adjustContentHeightPosition(tabStateType.documentTabState);
				$('#document-content-identifier').css('margin-top', '0px');
            }
			vm.isFullScreen = !vm.isFullScreen;
			setTimeout(function () {
				var height = $('#document-content-identifier').height();
				stickyTitle(height);
				if (isIE) {
					runInitforIE(height);
				}
            }, 500);
        }

        function fullScreenInit() {
            if (angular.element('#handbook-nav:visible').length == 0) {
                documentService.showFullscreen();
                vm.isFullScreen = false;
            } else {
                documentService.showNormal();
                vm.isFullScreen = true;
            }
        }

        function getNextSearchResultByEnter(keyEvent) {
            if (keyEvent.which == 13) {
                navForward();
            }
        }

        $scope.$on(broadcastType.toggleDocumentFullscreen, function (e, target) {
            fullScreen();
        });

        function showSidebarFields() {
            vm.isToggleSidebarFields = true;
        }

        function hideSidebarFields() {
            vm.isToggleSidebarFields = false;
		}

		function compareDocument() {
			window.open(String.format('/document/{0}/compareWithEarlierVersion', vm.documentId), '_blank');
		}

    };

})();;
(function () {
	'use strict';
	angular.module(modules.homeModule)
		.controller('statisticsController', controller);

	controller.$inject = ['$http', '$state', '$filter', 'pubSub', 'npDialog', '$location'];

	function controller($http, $state, $filter, pubSub, npDialog, $location) {
		var vm = this;
		vm.translation = resources;

		// Variables
		vm.alerts = [];
		var urlParams = $location.url().split('/');

		vm.tabsSetting = [];

		// Main features
		init();

		function init() {
			buildTabsSetting();
		}

		function buildTabsSetting() {
			vm.tabsSetting.push({
				name: resources.L.Statistics.useAndKeyValues,
				description: resources.L.Statistics.useAndKeyValues,
				href: 'dailyStatistics',
				icon: '',
				tabIndex: 1,
				active: true,
				count: 0,
				activatedClass: 'home-tab-active',
				hide: false,
				url: '/app/components/statistics/daily-statistics/daily-statistics.html',
				elementContentId: 'dailyStatistics'
			});
			vm.tabsSetting.push({
				name: resources.L.Statistics.folderStatistics,
				description: resources.L.Statistics.folderStatistics,
				href: 'folderStatistics',
				icon: '',
				tabIndex: 2,
				active: false,
				count: 0,
				activatedClass: 'home-tab-active',
				hide: false,
				url: '/app/components/statistics/folder-statistics/folder-statistics.html',
				elementContentId: 'folderStatistics'
			});
		}

	}

})();;
(function () {
    'use strict';
	angular.module(modules.homeModule).component('handbookDailyStatistics', {
        templateUrl: 'app/components/statistics/daily-statistics/daily-statistics.html',
        controller: controller,
        controllerAs: 'vm',
        bindings: {
        }
    });

	controller.$inject = ['$http', '$scope', 'pubSub', '$rootScope', 'configService'];
	function controller($http, $scope, pubSub, $rootScope, configService) {
        var vm = this;
		vm.docUsageTodaysSetting = [];
		init();

		function init() {
			buildGridSetting();
			getDailyStatistics();
		}

		function getDailyStatistics() {
			var promise = $http.get('/api/Documents/GetDailyStatisticsOverView', {});
			promise.success(function (data, status, headers, config) {
				var result = data;
				vm.objHandbookStatistics = result.objHandbookStatistics;
				vm.arrDailyStatistics = result.arrDailyStatistics;
				vm.docUsageTodays = result.docUsageTodays;

				getHighCharts(vm.arrDailyStatistics);
			});
		}

		function buildGridSetting() {
			vm.docUsageTodaysSetting = [
				{ id: 'name', name: resources.L.Statistics.mostReadToday, width: 50, coldefault: true , isObject: false },
				{ id: 'id', name: resources.L.Statistics.documentId, width: 25, coldefault: true, isObject: false },
				{ id: 'countValue', name: resources.L.Statistics.quantity, width: 25, coldefault: true, isObject: false, customCss: 'text-right' }
			];
		}

		function getHighCharts(data) {
			if (!data || data.length == 0)
				return;
			var categories = data.map(x => x.accessDateDisplay);
			var documents = data.map(x => x.docAccessCount);
			var users = data.map(x => x.userAccessCount);

			var aa = document.getElementById('daily-charts-id');

			var chart = Highcharts.chart('daily-charts-id', {
				chart: {
					zoomType: 'xy',			
				},
				title: {
					text: resources.L.Statistics.dailyUseDoc
				},
				subtitle: {
					text: ''
				}, 
				xAxis: [{
					categories: categories,
					crosshair: true
				}],
				yAxis: [{ // Primary yAxis
					allowDecimals: false,
					labels: {
						format: '{value}',
						style: {
							color: Highcharts.getOptions().colors[1]
						}
					},
					title: {
						text: resources.L.Statistics.users,
						style: {
							color: Highcharts.getOptions().colors[1]
						}
					}
				}, { // Secondary yAxis
					title: {
						text: resources.L.Common.documents,
						style: {
							color: Highcharts.getOptions().colors[0]
						}
					},
					labels: {
						format: '{value}',
						style: {
							color: Highcharts.getOptions().colors[0]
						}
					},
					opposite: true
				}],
				tooltip: {
					shared: true
				},
				legend: {
					layout: 'vertical',
					align: 'left',
					x: 50,
					verticalAlign: 'top',
					y: -10,
					floating: true,
					backgroundColor:
						Highcharts.defaultOptions.legend.backgroundColor || // theme
						'rgba(255,255,255,0.25)'
				},
				series: [{
					name: resources.L.Common.documents,
					type: 'column',
					yAxis: 1,
					data: documents,
					tooltip: {
						valueSuffix: ''
					}

				}, {
					name: resources.L.Statistics.users,
					type: 'spline',
					data: users,
					tooltip: {
						valueSuffix: ''
					}
				}]
			});		
		
			//var drawChart = setInterval(function () {
			//	if (chart.chartWidth == 310) {
			//		chart.reflow();
			//	} else {
			//		clearInterval(drawChart);
			//	}
			//	console.log(chart.chartWidth, 'drawChart');
			//}, 500);
	
		}
    }
})();;
(function () {
    'use strict';
	angular.module(modules.homeModule).component('handbookFoderStatistics', {
        templateUrl: 'app/components/statistics/folder-statistics/folder-statistics.html',
        controller: controller,
        controllerAs: 'vm',
        bindings: {
        }
    });

	controller.$inject = ['$http', 'configService'];
	function controller($http, configService) {
		var vm = this;

		vm.tabsChartsSetting = [];
		vm.periods = [];
		vm.subFolderStatisticsSetting = [];
		vm.defaultSelectedFolder = { id: null, name: resources.L.Common.all, type: 0 };
		vm.folderName = resources.L.Common.all;
		vm.statisticsPercentageForAwaitingApproval = configService.getBool(HandbookConfiguration.StatisticsPercentageForAwaitingApproval);

		vm.folderId = null;

		vm.getSelectedNode = getSelectedNode;
		vm.changePeriod = changePeriod;

        init();
		
		function init() {
			getPeriods();
			vm.selectOptionPeriod = 2;
			
			buildTabsSetting();
			getFolderStatistics(null, vm.selectOptionPeriod);
		}

		function buildGridSetting(nameFolder) {
			vm.subFolderStatisticsSetting = [
				{ id: 'folderName', name: nameFolder, width: 30, coldefault: true, isObject: false},
				{ id: 'approved', name: resources.L.Statistics.docsInUse, width: 10, coldefault: true, isObject: false, customCss: 'font-weight-normal'  },
				{ id: 'internet', name: resources.L.Document.internet, width: 10, coldefault: true, isObject: false, customCss: 'font-weight-normal'  },
				{ id: 'newCount', name: resources.L.Statistics.newThisMonth, width: 10, coldefault: true, isObject: false, customCss: 'font-weight-normal'  },
				{ id: 'revised', name: resources.L.Statistics.revisedThisMonth, width: 10, coldefault: true, isObject: false, customCss: 'font-weight-normal'  },
				{ id: 'archived', name: resources.L.Statistics.archivedThisMonth, width: 10, coldefault: true, isObject: false, customCss: 'font-weight-normal'  },
				{ id: 'awaitingApproval', name: resources.L.Enum.DocumentStatuses.awaitingApproval, width: 10, coldefault: true, isObject: false, customCss: 'font-weight-normal'  },
				{ id: 'expired', name: resources.L.Statistics.expired, width: 10, coldefault: true, isObject: false, customCss: 'font-weight-normal'  }
			];
		}

		function getPeriods() {
			vm.periods = [
				{ id: 0, name: resources.L.Common.all },
				{ id: 1, name: resources.L.Statistics.fiveYear },
				{ id: 2, name: resources.L.Statistics.last13Months },
			];
		}

		function buildTabsSetting() {
			vm.tabsChartsSetting.push({
				name: resources.L.Statistics.approvedVsInternet,
				description: resources.L.Statistics.approvedVsInternet,
				href: 'approveInternet',
				icon: 'fa fa-line-chart',
				tabIndex: 1,
				active: true,
				count: 0,
				activatedClass: 'home-tab-active',
				hide: false,
				url: '',
				elementContentId: 'approveInternet'
			});
			vm.tabsChartsSetting.push({
				name: resources.L.Statistics.newVsRevisedVsArchived,
				description: resources.L.Statistics.newVsRevisedVsArchived,
				href: 'newRevisedArchived',
				icon: 'fa fa-line-chart',
				tabIndex: 2,
				active: false,
				count: 0,
				activatedClass: 'home-tab-active',
				hide: false,
				url: '',
				elementContentId: 'newRevisedArchived'
			});
			vm.tabsChartsSetting.push({
				name: resources.L.Statistics.awaitingApprovalVsExpired,
				description: resources.L.Statistics.awaitingApprovalVsExpired,
				href: 'awaitingApprovedExpired',
				icon: 'fa fa-line-chart',
				tabIndex: 2,
				active: false,
				count: 0,
				activatedClass: 'home-tab-active',
				hide: false,
				url: '',
				elementContentId: 'awaitingApprovedExpired'
			});
		}

		function getFolderStatistics(folderId, type) {
			buildGridSetting(vm.folderName);

			var request = {
				handbookId: folderId,
				type: type
			};
			var promise = $http.get('/api/Documents/GetFolderStatisticsOverView', { params: request});
			promise.success(function (data, status, headers, config) {
				var result = data;
				vm.folderStatistics = result.folderStatistics;
				vm.subFolderStatistics = result.subFolderStatistics;
				buildChartApprovedInternet(result.folderStatisticsForCharts);
				buildChartNewRevisedArchived(result.folderStatisticsForCharts);
				buildChartAwaitingApprovalExpired(result.folderStatisticsForCharts);
			});
		}

		function buildChartApprovedInternet(data) {
			var approveTitle = resources.L.Document.approved;
			var internetTitle = resources.L.Document.internet;
			var categories = data.map(x => x.monthYear);
			var approvedDocs = data.map(x => x.approved);
			var internetDocs = data.map(x => x.internet);
			Highcharts.chart('approve-internet-charts-id', {
				title: {
					text: resources.L.Statistics.approvedVsInternet
				},
				subtitle: {
					text: ''
				},
				yAxis: {
					title: {
						text: resources.L.Common.number
					}
				},
				xAxis: {
					categories: categories
				},
				legend: {
					layout: 'vertical',
					align: 'right',
					verticalAlign: 'middle'
				},
				plotOptions: {
					series: {
						label: {
							connectorAllowed: false
						},
						pointStart: null
					}
				},
				series: [{
					name: approveTitle,
					data: approvedDocs
				}, {
					name: internetTitle,
					data: internetDocs
				}],
				responsive: {
					rules: [{
						condition: {
							maxWidth: 500
						},
						chartOptions: {
							legend: {
								layout: 'horizontal',
								align: 'center',
								verticalAlign: 'bottom'
							}
						}
					}]
				}

			});
		}

		function buildChartNewRevisedArchived(data) {
			var categories = data.map(x => x.monthYear);
			var newCountDocs = data.map(x => x.newCount);
			var revisedDocs = data.map(x => x.revised);
			var archivedDocs = data.map(x => x.archived);

			Highcharts.chart('new-revised-archived-charts-id', {
				title: {
					text: resources.L.Statistics.newVsRevisedVsArchived
				},
				subtitle: {
					text: ''
				},
				yAxis: {
					title: {
						text: resources.L.Common.number
					}
				},
				xAxis: {
					categories: categories
				},
				legend: {
					layout: 'vertical',
					align: 'right',
					verticalAlign: 'middle'
				},
				plotOptions: {
					series: {
						label: {
							connectorAllowed: false
						},
						pointStart: null
					}
				},
				series: [{
					name: resources.L.Action.new,
					data: newCountDocs
				}, {
					name: resources.L.Statistics.revised,
					data: revisedDocs
				}, {
					name: resources.L.Common.archived,
					data: archivedDocs
				}],
				responsive: {
					rules: [{
						condition: {
							maxWidth: 500
						},
						chartOptions: {
							legend: {
								layout: 'horizontal',
								align: 'center',
								verticalAlign: 'bottom'
							}
						}
					}]
				}

			});
		}

		function buildChartAwaitingApprovalExpired(data) {
			var categories = data.map(x => x.monthYear);
			var awaitingApprovalDocs = data.map(x => x.awaitingApproval);
			var expiredDocs = data.map(x => x.expired);

			Highcharts.chart('awaiting-approved-expired-charts-id', {
				title: {
					text: resources.L.Statistics.awaitingApprovalVsExpired
				},
				subtitle: {
					text: ''
				},
				yAxis: {
					title: {
						text: resources.L.Common.number
					}
				},
				xAxis: {
					categories: categories
				},
				legend: {
					layout: 'vertical',
					align: 'right',
					verticalAlign: 'middle'
				},
				plotOptions: {
					series: {
						label: {
							connectorAllowed: false
						},
						pointStart: null
					}
				},
				series: [{
					name: resources.L.Enum.DocumentStatuses.awaitingApproval,
					data: awaitingApprovalDocs
				}, {
					name: resources.L.Statistics.expired,
					data: expiredDocs
				}],
				responsive: {
					rules: [{
						condition: {
							maxWidth: 500
						},
						chartOptions: {
							legend: {
								layout: 'horizontal',
								align: 'center',
								verticalAlign: 'bottom'
							}
						}
					}]
				}

			});


		}

		function getSelectedNode(node) {
			if (node != null) {
				vm.folderId = node.id;
				vm.folderName = node.name;
				getFolderStatistics(vm.folderId, vm.selectOptionPeriod);
			}
		}

		function changePeriod() {
			var request = {
				handbookId: vm.folderId,
				type: vm.selectOptionPeriod
			};
			var promise = $http.get('/api/Documents/GetFolderStatisticsForChart', { params: request });
			promise.success(function (data, status, headers, config) {
				var result = data;
				buildChartApprovedInternet(result);
				buildChartNewRevisedArchived(result);
				buildChartAwaitingApprovalExpired(result);
			});
		}

    }
})();;
(function () {
    'use strict';
    angular.module('servicesModule')
        .controller('AboutFolderModalController', controller);
    controller.$inject = ['$scope', '$http', '$uibModal', '$uibModalInstance', 'model', '$sce'];
    function controller($scope, $http, $uibModal, $modalInstance, model, $sce) {
        var vm = this;
        vm.globalResources = angular.copy(globalResources);
        vm.data = model;
        vm.close = close;
        initialize();

        function initialize() {
        }


        function close() {
            $modalInstance.close(true);
        };

    };
})();;
(function () {
    'use strict';
    angular.module('servicesModule').controller('WhatsNewFolderModalController', controller);
    controller.$inject = ['$scope', '$http', '$uibModal', '$uibModalInstance', 'model', '$sce'];

    function controller($scope, $http, $uibModal, $modalInstance, model, $sce) {
        var vm = this;
        vm.globalResources = angular.copy(globalResources);
        vm.data = model;
        vm.close = close;
        vm.showDropdown = false;
        vm.listPeriod = [
            { name: vm.globalResources.Today, value: 0 },
            { name: vm.globalResources.LastWeek, value: 1 },
            { name: vm.globalResources.LastMonth, value: 2 },
            { name: vm.globalResources.Last3Months, value: 3 },
        ];
        vm.selectedPeriod = vm.listPeriod[parseInt(HandbookConfiguration.WhatsNewPeriodFolder)];
        vm.selectPeriod = selectPeriod;
        vm.whatsNewDocuments = vm.data.WhatsNewDocuments;
        vm.showWhatsNewDocumentsInSubChapters = vm.data.showWhatsNewDocumentsInSubChapters;
        vm.showWhatsNewDocumentsRecursive = showWhatsNewDocumentsRecursive;
        initialize();
        function initialize() {
            setPeriod(parseInt(vm.data.selectedOption))
        }

        function setPeriod(optionNumber) {
            const period = vm.listPeriod.filter(function (period) {
                return period.value == optionNumber;
            })
            if (period && period.length) {
                vm.selectedPeriod = period[0];
            }
        }

        function selectPeriod(period) {
            vm.data.changeSelectedOptionInMobileView(period);
            setPeriod(period.value); 
            getWhatsNewForFolder();
        }

        function showWhatsNewDocumentsRecursive() {
            getWhatsNewForFolder();
        }

        function getWhatsNewForFolder() {
            $http.get(handbookRequests.GetRecentlyApprovedDocumentsForFolder, { params: { 'folderId': vm.data.folderData.id, 'includeSubFolder': vm.showWhatsNewDocumentsInSubChapters, 'periodOption': vm.selectedPeriod.value } })
                .success(function (data, status, headers, config) {
                    vm.whatsNewDocuments  = data;
                });
        };

        function close() {
            $modalInstance.close(true);
        };
    };
})();;
(function () {
    'use strict';
    angular.module('servicesModule')
        .controller('AboutDocumentModalController', controller);

    controller.$inject = ['$scope', '$http', '$uibModal', '$uibModalInstance', 'model', '$sce'];

    function controller($scope, $http, $uibModal, $modalInstance, model, $sce) {
        var vm = this;
        vm.globalResources = angular.copy(globalResources);
        vm.data = model;
        vm.close = close;
        vm.goToFolder = goToFolder;

        initialize();

        function initialize() {
            handleScroll();
        }

        function handleScroll() {
            setTimeout(function () {
                angular.element(document.querySelector('.about-detail-container')).bind('scroll', function () {
                    const aboutDetailContainerTop = $('#documentViewId').position().top;
                    const documentTitleContainerBottom = $('#documentTitleContainer').position().top + $('#documentTitleContainer').height();
                    if (aboutDetailContainerTop < documentTitleContainerBottom) {
                        angular.element('#documentTitleContainer').addClass('shadow-effect');
                    }
                    else {
                        angular.element('#documentTitleContainer').removeClass('shadow-effect');
                    }
                })
            }, 0)
        }
     
        function close() {
            $modalInstance.close(true);
        };

        function goToFolder(folderId) {
            vm.close();
            window.open(`/folder/${folderId}`, '_self')
        }
    };
})();;
(function () {
    angular.module('annualCycleModule', ['ui.bootstrap', 'ui.router']).run(['$location', '$state', function ($location, $state) {
        window.addEventListener("message", (event) => {
            if (!event.data || event.data.moduleName != 'annualCycle' || !event.data.eventName)
                return;
            let backendRoute = '';
            switch (event.data.eventName) {
                case 'annual-cycle-route-change':
                    let frontendRoute = event.data.value.toLowerCase();
                    if (frontendRoute.indexOf('/activitydetail/') > -1) {
                        let activityId = frontendRoute.substring(frontendRoute.lastIndexOf('/') + 1);
                        if (activityId && activityId != '') {
                            backendRoute = 'ac/activity/activityDetail/' + activityId;
                        }
                    } else if (frontendRoute.indexOf('/taskdetail/') > -1) {
                        let taskId = frontendRoute.substring(frontendRoute.lastIndexOf('/') + 1);
                        if (taskId && taskId != '') {
                            backendRoute = 'ac/task/taskDetail/' + taskId;
                        }
                    }
                    else if (frontendRoute == '/home') {
                        backendRoute = 'ac/home';
                    }
                    break;
                default:
                    backendRoute = '/';
                    break;
            }

            if (!backendRoute) return;

            if (!history.state || !history.state.id || (history.state.id !== backendRoute)) {
                history.pushState({ id: backendRoute }, backendRoute, backendRoute);
            }
        });
    }]);
})();;
(function () {
    'use strict';

    angular.module('annualCycleModule')
        .config(['$stateProvider', '$urlRouterProvider', routesConfig]);

    function routesConfig($stateProvider, $urlRouterProvider) {
        var internalPaths = window.paths;
        $stateProvider
            .state('activityDetail', {
                url: '/ac/activity/activityDetail/:activityId',
                params: { activityId: '' },
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                data: {
                    title: 'Activity Detail',
                    description: 'Activity Detail'
                }
            })
            .state('taskDetail', {
                url: '/ac/task/taskDetail/:taskId',
                params: { taskId: '' },
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                data: {
                    title: 'Task Detail',
                    description: 'Task Detail'
                }
            })
            .state('activityList', {
                url: '/ac/home',
                templateUrl: internalPaths.FrontpageHome,
                controller: 'homeController',
                controllerAs: 'vm',
                data: {
                    title: 'Activity List',
                    description: 'Activity List'
                }
            })
        $urlRouterProvider.otherwise('/');
    };
})();;
(function () {
    'use strict';

    angular.module('processModule')
        .controller('area-detail.controller', areaDetailController);

    areaDetailController.$inject = ['$stateParams', 'routeService', '$sce'];
    function areaDetailController($stateParams, routeService, $sce) {
        var vm = this;
        vm.initialize = initialize;
        vm.areaId = $stateParams.areaId;
        vm.areaDetailIframe = '';

        initialize();

        function initialize() {
            vm.areaDetailIframe = $sce.trustAsResourceUrl(routeService.getProcessBaseRoute() + 'area/detail/' + vm.areaId + '?isFrontend=true');
        }
    };

})();;
(function () {
    'use strict';

    angular.module('processModule')
        .controller('areas-root-view.controller', areasRootViewController);

    areasRootViewController.$inject = ['$scope', 'routeService', '$sce'];
    function areasRootViewController($stateParams, routeService, $sce) {
        var vm = this;
        vm.initialize = initialize;
        vm.areaId = $stateParams.areaId;
        vm.areasRootViewIframe = '';


        initialize();

        function initialize() {
            vm.areasRootViewIframe = $sce.trustAsResourceUrl(routeService.getProcessBaseRoute() + 'home/details?isOnlyApproved=true&isFrontend=true');
        }
    }
})();

;
(function () {
    'use strict';

    angular.module('processModule')
        .controller('favoritesTreeView', favoritesTreeViewController);

    favoritesTreeViewController.$inject = ['$scope', '$timeout', '$http', '$state', 'pubSub', 'configService'];

    function favoritesTreeViewController($scope, $timeout, $http, $state, pubSub, configService) {
        var vm = this;
        var killUpdateFavoritesProcesses = null;

        vm.isExpanded = false;
        vm.initialize = initialize;
        vm.items = [];
        vm.selectNodeInAreaTree = selectNodeInAreaTree;
        vm.handleExpandArea = handleExpandArea;
        $scope.favoritesList = [];
        vm.wrapText = configService.getBool(HandbookConfiguration.WrapTextInNavigationTree);

        function initialize() {
            getFavoritesList();
            killUpdateFavoritesProcesses = pubSub.subscribe(broadcastType.updateFavoritesProcesses, updateFavoritesProcesses);
        }

        $scope.$on('$destroy', function () {
            killUpdateFavoritesProcesses();
        });

        function getFavoritesList() {
            $http.get(handbookRequests.GetFavoritesProcessesAreasRequest)
                .success(function (data, status, headers, config) {
                    if (data) {
                        decorateNodes(data.areas, data.processes);
                        $scope.favoritesList = data.processes;
                        $scope.favoritesList = $scope.favoritesList.concat(data.areas);
                    }
                });
        }

        $scope.options = {
            dropped: function (event) { },
            beforeDrop: function (event) { }
        };

        function updateFavoritesProcesses(target) {
            if (target) {
                getFavoritesList();
            }
        }

        function handleExpandArea(expanded, itemId, selectedNode) {
            if (expanded == true && selectedNode.$modelValue.type == 0 && (selectedNode.$modelValue.childCount > 0)) {
                var siblings = selectedNode.$parentNodeScope == null ? selectedNode.favoritesList : selectedNode.$parentNodeScope.$modelValue.items;
                var modelValue = selectedNode.$modelValue;
                if (modelValue.isLoaded) {
                    return;
                } else {
                    modelValue.isLoaded = true;
                }

                $http.get(handbookRequests.GetProcessAreasRequest, {
                    params: {
                        areaId: itemId,
                        showProcessesInTree: true,
                        isOnlyApproved: true
                    }
                })
                    .success(function (data, status, headers, config) {
                        if (data) {
                            decorateNodes(data.areas, data.processes);
                            var length = siblings.length;
                            for (var i = 0; i < length; i++) {
                                if (siblings[i].id == itemId) {
                                    vm.selectedNode = siblings[i];
                                    if (siblings[i].items == null) {
                                        siblings[i].items = [];
                                    }
                                    siblings[i].items = siblings[i].items.concat(data.areas);
                                    siblings[i].items = siblings[i].items.concat(data.processes);
                                    break;
                                }
                            }
                        }
                    },
                        function (data, status, headers, config) {
                            //modelValue.items = [];
                        });
            }
        }

        function selectNodeInAreaTree(node, item, collapsed, $event) {
            if (item.type == 0 || !item.type) {
                $state.go('process-area-detail', { areaId: item.id });
            }
            else if (item.type == 1) {
                $state.go('process-detail', { processNumber: item.processNumber });
            }
            let isSelectedFolder = $(event.target).hasClass('selected');
            if ((isSelectedFolder || collapsed) && HandbookConfiguration.ToggleFolderUponClick.toUpperCase() == "TRUE") {
                vm.isExpanded = true;
                item.expanded = !item.expanded;
                handleExpandArea(collapsed, item.id, node);
                $scope.toggle(node);
            }
            setHighlight($event);
        }

        $scope.toggle = function (scope) {
            scope.toggle();
        };

        function decorateNodes(areas, processes) {
            if (areas && areas.length > 0) {
                for (var i = 0; i < areas.length; i++) {
                    areas[i].type = 0;
                }
            }
            if (processes && processes.length > 0) {
                for (var i = 0; i < processes.length; i++) {
                    processes[i].type = 1;
                    processes[i].id = processes[i].processNumber;
                }
            }
        }

        function setHighlight(event) {
            $('.selected').removeClass('selected');
            $(event.target).addClass('selected');
        }

    };

})();

;
(function () {
    'use strict';

    angular.module('processModule')
        .controller('process-detail-view.controller', processDetailViewController);

    processDetailViewController.$inject = ['$stateParams', 'routeService', '$sce'];
    function processDetailViewController($stateParams, routeService, $sce) {
        var vm = this;
        vm.initialize = initialize;
        vm.processNumber = $stateParams.processNumber;
        vm.processDetailViewIframe = '';


        initialize();

        function initialize() {
            vm.processDetailViewIframe = $sce.trustAsResourceUrl(routeService.getProcessBaseRoute() + 'process-detail/management/' + vm.processNumber + '?isFrontend=true');
        }
    }
})();

;
(function () {
    'use strict';

    angular.module('processModule')
        .controller('process-hearing-view.controller', processHearingViewController);

    processHearingViewController.$inject = ['$stateParams', 'routeService', '$sce'];
    function processHearingViewController($stateParams, routeService, $sce) {
        var vm = this;
        vm.initialize = initialize;
        vm.processNumber = $stateParams.processNumber
        vm.version = $stateParams.version;
        vm.processHearingViewFrame = '';

        initialize();

        function initialize() {
            vm.processHearingViewFrame = $sce.trustAsResourceUrl(routeService.getProcessBaseRoute() + `process-detail/viewsendtohearing/${vm.processNumber}/${vm.version}?isFrontend=true`);
        }
    };

})();

;
(function () {
    'use strict';

    angular.module('dashboardModule')
        .controller('reading-list-view.controller', readingListViewController);

    readingListViewController.$inject = ['$stateParams', 'routeService', '$sce'];
    function readingListViewController($stateParams, routeService, $sce) {
        var vm = this;
        vm.initialize = initialize;
        vm.readingListId = $stateParams.readingListId;
        vm.readingListIframe = '';

        initialize();

        function initialize() {
            vm.readingListIframe = vm.readingListId ? $sce.trustAsResourceUrl(HandbookConfiguration.BackendURL + `dashboard/reading-list/${vm.readingListId}?hideTopBar=true`)
                                            : $sce.trustAsResourceUrl(HandbookConfiguration.BackendURL + 'dashboard/reading-list?hideTopBar=true');
        }
    };

})();;