(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 () {
	'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'];

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

		vm.annualCycleModuleEnable = HandbookConfiguration.EnabledAnnualCycle.toUpperCase() == "TRUE" ? true : false;
		vm.readingListEnabled = HandbookConfiguration.ReadingListEnabled.toUpperCase() == "TRUE" ? true : false;
		vm.hearingEnabled = HandbookConfiguration.HearingEnabled.toUpperCase() == "TRUE" ? true : 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.hearingGridSetting = [];
		vm.HearingsSetting = [];
		vm.readingList = [];

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

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

		vm.changeSelectedOption = changeSelectedOption;

		vm.columnNotRemove = 'name';
		function buildHearingsGridSetting() {
			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: 10, 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: $scope.translation.CommonGridColumns.Chapter, width: 20, 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 });
		}

		initialize();

		function initialize() {
			var storageWhatsNewPeriodAll = localStorageService.getItem("WhatsNewPeriodAll");
			vm.selectedOption = storageWhatsNewPeriodAll != null ? 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) {
				handleNavigate();
			});

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

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

					let 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);
						});
					}
				}
			});
		}

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

			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 > 0)
						|| (url.indexOf('missingreadingreceipts') > -1 && vm.missingReadingDocuments.length > 0))) {
					triggerTabClicked('#reading-list-tab', true);
				} else {
					triggerTabClicked('#master-tab', true);
				}
				if (vm.readingListEnabled && url.indexOf('readinglist') > -1
					&& vm.allReadingDocuments.length > 0) {
					triggerTabClicked('#reading-lists-tab', false);
				}

				if (vm.readingListEnabled && url.indexOf('missingreadingreceipts') > -1
					&& vm.missingReadingDocuments.length > 0) {
					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 > 0 && url.indexOf('awaitinghearing') > -1)
					|| (vm.publicHearings.length > 0 && url.indexOf('publichearings') > -1)) {
					triggerTabClicked('#hearings-tab', true);
				} else {
					triggerTabClicked('#master-tab', true);
				}
				if (vm.aWaitingHearings.length > 0 && url.indexOf('awaitinghearing') > -1) {
					triggerTabClicked('#aWaitingHearingstab', false);
				}
				if (vm.publicHearings.length > 0 && url.indexOf('publichearings') > -1) {
					triggerTabClicked('#publicHearingstab', false);
				}
			}

		}

		function triggerTabClicked(tabId, clickItSelf) {
			setTimeout(function () {
				let 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() {
			return $http.get(handbookRequests.GetRecentlyApprovedDocumentsRequest, { params: { periodOption: vm.selectedOption } })
				.success(function (data, status, headers, config) {
					vm.whatNewData = data;
					updateAttachmentsForDocuments(data);
					updateTotalWhatNew();
					updateNewestDocuments(vm.whatNewData, 1);
				});
		}

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

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

		function loadReadingDocumentsLists() {
			if (!vm.readingListEnabled) {
				return;
			}

			return $http
				.get('/api/UserDocuments/GetReadingDocumentsList')
				.success(function (data) {
					if (data && data.length > 0) {
						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);
								}
							}
						});
					}
					vm.allReadingDocuments = data;

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

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

					var distincDocuments = getDistinctDocuments(angular.copy(data));
					vm.documentsGroups = getDocumentGroupsByReadingListName(angular.copy(distincDocuments));
					vm.missingReadingDocuments = getMissingReadingDocuments(angular.copy(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;
						});
					}
				});
		}

		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: 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 });
			tooltipData.push({ label: globalResources.CommonGridColumns.Approver, data: row.approvedBy });
			tooltipData.push({ label: globalResources.CommonGridColumns.Responsible, data: row.responsible });
			return tooltipData;
		}

		function hearingRowClick(id) {
			//redirect to hearing feedback page
			window.open(String.format(urlOpenHearingFeedback, String(id)));
		}

		function getMissingReadingDocuments(documents) {
			var missingDocuments = [];
			updateAttachmentsForDocuments(documents);

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

		function getGroupByTemplateName(templateName, documentsGroups) {
			for (var i = 0; i < documentsGroups.length; i++) {
				var group = documentsGroups[i];
				if (group.templateName == templateName) {
					return group;
				}
			}
			return null;
		}

		function getDocumentGroupsByReadingListName(documents) {
			if (!documents || documents.length <= 0) {
				return [];
			}
			var documentsGroups = [];
			for (var i = 0; i < documents.length; i++) {
				var document = documents[i];
				if (!document.readingListName) {
					continue;
				}
				var readingList = document.readingListName.split(',');
				for (var j = 0; j < readingList.length; j++) {
					var templateName = readingList[j].trim();
					var group = getGroupByTemplateName(templateName, documentsGroups);
					document.sort = getSortDocument(templateName, document.documentId);
					if (!group) {
						documentsGroups.push({
							documents: [document],
							templateName: templateName,
							totalDocuments: 1
						});
						continue;
					}

					group.documents.push(document);
					group.totalDocuments += 1;
				}
			}
			for (var i = 0; i < documentsGroups.length; i++) {
				documentsGroups[i].documents = $filter('orderBy')(documentsGroups[i].documents, ['sort', 'name']);
			}
			return documentsGroups;
		}

		function getSortDocument(readingListName, documentId) {
			for (var i = 0; i < vm.allReadingDocuments.length; i++) {
				var document = vm.allReadingDocuments[i];
				if (document.documentId == documentId && document.readingListName == readingListName) {
					return document.sort;
				}
			}
			return 0;
		}

		function getDistinctDocuments(documents) {
			var distincDocuments = [];
			documents.forEach(function (item) {
				var existing = distincDocuments.filter(function (v, i) {
					return v.documentId == item.documentId;
				});
				if (existing.length) {
					var existingIndex = distincDocuments.indexOf(existing[0]);
					distincDocuments[existingIndex].readingListName = (distincDocuments[existingIndex].readingListName + ", ").concat(item.readingListName);
				} else {
					distincDocuments.push(item);
				}
			});
			return distincDocuments;
		}

		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) {
					documentIds.push(documents[i].id);
				}
			}
			if (documentIds.length > 0) {
				$http
					.get('/api/Documents/GetAttachmentsForDocuments', { params: { documentIds: documentIds } })
					.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]);
									}
								}
							}
						}
					});
			}
		}

		$(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 () {
    '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 },
                { 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'];
    function controller($rootScope, $scope, $http, $stateParams) {
        $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.changeView = changeView;
        vm.resolveColor = resolveColor;
        vm.resolveSchoolYearColor = resolveSchoolYearColor;
        vm.scrollToThisMonth = scrollToThisMonth;
        vm.print = print;
        vm.close = close;

        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;
            }
        }

        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();
                }

                vm.activities = data.activities;

                if (vm.activities.length) {
                    vm.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);
						}
                    });
                }

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

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

                initListView();
                initCycleMonths();
            });
        }

		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() {
            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 });

            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 });
        }

        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;
        }

        //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 () {
	'use strict';

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

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

	function mainPageController($scope, $http, $window, $modal, $location, hotkeys, resizeService, broadcastService, tabStateService, shortcutKeysService, localStorageService, npDialog, helpPagesService) {
		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');
		}

		vm.rememberedChangedWidth = 0;
		vm.userId = user.userId;
		vm.annualCycleHomeUrl = HandbookConfiguration.AnnualCycleHomeUrl;
		vm.isTest = HandbookConfiguration.IsTest == 'True' ? true : false;
		vm.enabledAnnualCycle = HandbookConfiguration.EnabledAnnualCycle == 'True' ? true : false;
		vm.publishedVersion = HandbookConfiguration.PublishedVersion.toUpperCase() == 'TRUE' ? true : false;
		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 = HandbookConfiguration.ShowStartpageImage == "True" || HandbookConfiguration.ShowStartpageImage == "true";
		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 = HandbookConfiguration.HelpEnabled.toUpperCase() == 'TRUE' ? true : false;
		vm.goToHelpPages = goToHelpPages;

		initialize();

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

			vm.changeFontsizeGuide = 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 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 = $modal.open({
				templateUrl: 'app/components/home/templates/myReadingReceipts.html',
				controller: controllers.myReadingReceiptsController + ' as vm',
				size: 'lg',
				resolve: {
					items: function () {
					}
				}
			});
		};

		function changePassword() {
			var modalInstance = $modal.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() {
			$modal.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 (HandbookConfiguration.MetadataEnabled.toUpperCase() == "TRUE") {
							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 (HandbookConfiguration.MetadataEnabled.toUpperCase() == "TRUE") {
							shortcutKeysService.toggleDocumentSearchInContentTab.method();
						}
					} else if (HandbookConfiguration.ReadingListEnabled.toUpperCase() == "TRUE") {
						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'];

    function startpageController($state, $http, $scope, $sce, $timeout, $window, newsService, tabStateService, localStorageService, documentService) {
        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
        };

        vm.loadAllNews = loadAllNews;
        vm.gotoUrl = gotoUrl;
        vm.collapseHandle = collapseHandle;
        vm.goToNewsDetails = loadNews;
        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();
        };

        function getNews() {
            newsService
                .getNews({ showInModule: E.NewsCategoryShownIn.shownInHandbookFrontend })
                .then(function (result) {
                    handleDevicesSize(result.data.length);
                    vm.news = result.data;
                    addTrustAsHtml();
                    $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;
                    addTrustAsHtml();
                    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 (HandbookConfiguration.CollapseMenuGroups.toLowerCase() == 'true') {
                        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-12';
                    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 addTrustAsHtml() {
            if (vm.news != null) {
                vm.news.forEach(function (item) {
                    if (item.ingress) {
                        item.ingress = $sce.trustAsHtml(item.ingress);
                    }
                });
            }
        };

        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 <= 414 && availHeight <= 736) || (availHeight <= 414 && availWidth <= 736)) {
                //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 () {
    'use strict';

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

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

    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;

        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;
                    vm.news.ingress = $sce.trustAsHtml(vm.news.ingress);
                    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', '$modalInstance', '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) {
				$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, $modalInstance) {
        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)) {
                tabStateService.removeState(tabStateType);
            } 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('documentModule', [])
		.controller('DocumentController', documentController);

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

	function documentController($scope, $rootScope, $http, $stateParams, $state, $sce, $location, $anchorScroll, $timeout, $filter,
		broadcastService, documentService, favoriteService, tabStateService, anchorService, documentContentsSearchService, resizeService, localStorageService, folderService, treeNavigationService, $q) {
		var ignoreRichText = (HandbookConfiguration.LazyLoadRichText == 'True') ? true : false;

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

		vm.isEmbedUrl = false;

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

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

		vm.highlights = {
			highlightText: '',
			currentIndex: 0,
			totalFound: 0
		};
		vm.isShowMetadata = HandbookConfiguration.MetadataEnabled == 'True' ? true : false;
		vm.isShowMetatagTab = HandbookConfiguration.ShowMetatagTab.toUpperCase() == 'TRUE' ? true : false;
		vm.simpleSubscription = HandbookConfiguration.SimpleSubscription.toUpperCase() == 'TRUE' ? true : false;
		vm.publishedVersion = HandbookConfiguration.PublishedVersion.toUpperCase() == 'TRUE' ? true : false;
		vm.backendIsDb4 = HandbookConfiguration.BackendIsDb4.toUpperCase() == 'TRUE' ? true : false;
		vm.showDocumentLinkToBackend = HandbookConfiguration.ShowDocumentLinkToBackend == 'True' ? true : false;
		vm.enableDocumentExtention = HandbookConfiguration.EnableDocumentExtention == 'True' ? true : false;

		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.hideCompareButton = false;
		vm.showContent = showContent;
		vm.shareFieldLink = shareFieldLink;
		vm.showSidebarFields = showSidebarFields;
		vm.isToggleSidebarFields = true;
		var isIE = detectIE();
		var cursorY;
		document.onmousemove = function (e) {
			cursorY = e.pageY;
		}
		vm.hideSidebarFields = hideSidebarFields;
		initialize();

		function initialize() {

			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();
		}


		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 (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 = $sce.trustAsHtml(response.data.content + ' ');
											fieldContent.isVisible = true;
										}
									});

									richTextRequests.push(richtextRequest);

								} else {
									if (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");

							}

							if (vm.currentData.relatedAttachments.length > 0) {
								vm.menuFields.push("Idattachment");
							}
							if (vm.currentData.relatedDocuments.length > 0) {
								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 = (HandbookConfiguration.EnableCompare.toUpperCase() == 'TRUE' && vm.currentData.version > 0) ? true : false;
						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 > 0 && 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 (HandbookConfiguration.ViewDocumentFieldDirectly == 'True' && preview == -1) {
				openDocumentFields();
			}
		}


		function updateFields() {
			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.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 > 0) {
						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;
					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();
			}, 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 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;

			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 if (String(id).indexOf('Idattachment') > -1)
					vm.activeAttachments = true;
				else if (String(id).indexOf('IdLink') > -1)
					vm.activeLink = true;
				else
					vm.activeFile = true;
			}
			setTimeout(function () {
				isFieldActive = false;
			}, 2000);
		};

		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) {
				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 () {
    'use strict';

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

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

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

        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 = HandbookConfiguration.PublishedVersion.toUpperCase() == 'TRUE' ? true : false;

        vm.hearingCommentAfterResponse = HandbookConfiguration.HearingCommentAfterResponse.toUpperCase() == "TRUE";

        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 = $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() {
            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.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($modal, employees, vm.translation.AddToHearingsPerson, null, true, vm.currentData.folderId);
            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 = $modal.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'];

	function documentFieldsController($http, $sce, $timeout, $location, $scope, $rootScope, $anchorScroll,
        documentService, anchorService, documentContentsSearchService, resizeService, $stateParams, pubSub, folderService, treeNavigationService, $q) {
        var ignoreRichText = (HandbookConfiguration.LazyLoadRichText == 'True') ? true : false;

        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 = HandbookConfiguration.ShowDocumentLinkToBackend == 'True' ? true : false;
        vm.simpleSubscription = HandbookConfiguration.SimpleSubscription.toUpperCase() == 'TRUE' ? true : false;

        vm.isShowMetadata = HandbookConfiguration.MetadataEnabled == 'True' ? true : false;
        vm.isShowMetatagTab = HandbookConfiguration.ShowMetatagTab.toUpperCase() == 'TRUE' ? true : false;
        vm.publishedVersion = HandbookConfiguration.PublishedVersion.toUpperCase() == 'TRUE' ? true : false;
        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 = $sce.trustAsHtml(response.data.content);
                                            fieldContent.isVisible = true;
                                        }
                                    });

                                    richTextRequests.push(getRichText);
                                } else {
                                    if (fieldContent.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 = (HandbookConfiguration.EnableCompare.toUpperCase() == 'TRUE' && vm.oldData.version > 0) ? true : false;
                        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(modules.chapterModule, [])
        .controller(controllers.chapterController, chapterController);

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

    function chapterController($scope, $http, $state, $stateParams, $timeout, $sce, $rootScope, $filter,
        broadcastService, favoriteService, tabStateService, resizeService, localStorageService, treeNavigationService, documentService, $location) {
        var attachmentStores = {};
        var vm = this;
        vm.handbookRequests = handbookRequests;
        vm.isPinMeta = localStorageService.getItem(localStorageKeys.stateOfSticky);
        vm.isPinMeta = vm.isPinMeta == 'true' ? true : false;
        vm.pinMetaChange = pinMetaChange;
        $scope.translation = globalResources;
        $scope.internetPublishOption = HandbookConfiguration.InternetPublishOption == 'True' ? true : false;
        vm.publishedVersion = HandbookConfiguration.PublishedVersion == 'True' ? true : false;
        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 = HandbookConfiguration.BackendIsDb4.toUpperCase() == 'TRUE' ? true : false;
        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.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 = [];

        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);
            });
        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);
        };

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

        //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('#' + folderContent.content + '').height()
                    - 10
                    - angular.element('.' + folderContent.groupMetatagList + '').height()
                    - angular.element('#chapterItemTabs').height();
                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);
                });
        };

        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
                    .get('/api/Documents/GetAttachmentsForDocuments', { params: { documentIds: documentIds } })
                    .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 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;
                    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) {
                $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;
                    });

                    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.showFolderLinkToBackend = (HandbookConfiguration.ShowDocumentLinkToBackend == 'True') && 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)
                });
				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) {
                    getMetadataGroupsForContentTab(vm.folderInformation.viewType);
                }

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

                buildViewMode();
                updateExportGroupByParam();

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

        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();
                vm.newTotalDocuments = 0;
                vm.scrolling = false;
                $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 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 < length; i++) {
                vm.infiniteGroups[i].isShow = 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 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);
            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 = 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);
                        vm.searchDocuments = response.data.documents;
                        vm.totalHits = vm.searchDocuments.length;
                        vm.totalFound = response.data.totalCount;
                        adjustContentPosition();
                    } else {
                        vm.totalHits = 0;
                        vm.totalFound = 0;
                    }
                });
        };

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

        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 () {
    'use strict';

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

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

    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 == 'true' ? true : false;

                    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(modules.chapterModule)
		.controller(controllers.searchController, searchController);

	searchController.$inject = ['$scope', '$http', '$state', '$stateParams', '$timeout', '$document',
		'favoriteService', 'folderService', 'tabStateService', 'resizeService', 'stringValidationService', 'metaDataService', 'documentService', '$q'];

	function searchController($scope, $http, $state, $stateParams, $timeout, $document,
		favoriteService, folderService, tabStateService, resizeService, stringValidationService, metaDataService, documentService, $q) {
		var vm = this;
		vm.handbookRequests = handbookRequests;
		$scope.translation = globalResources;
		vm.commonGridSettingKey = gridSettingKeys.commonVisibilitySettings;
		vm.enabledMetadataSearch = true;
		vm.enabledAdvanceSearch = true;
		vm.isMetadataSearch = (HandbookConfiguration.MetadataEnabled.toLowerCase() == 'true' ? true : false) && vm.enabledMetadataSearch;
		vm.doSearchDataMining = (HandbookConfiguration.DoSearchDataMining.toLowerCase() == 'true' ? true : false);
		vm.enabledCompendiaSearch = (HandbookConfiguration.CompendiaSearch == 'True' ? true : false);
		vm.searchInFolders = HandbookConfiguration.SearchInFolders.toUpperCase() == 'TRUE' ? true : false;

		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.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.search = search;
		vm.openCompendiaDocument = openCompendiaDocument;
		vm.defaultExportFileName = globalResources.SearchResult;
		vm.openDocument = openDocument;
		vm.folderClick = folderClick;

		vm.isClickDocument = false;

		initialize();

		$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 initialize() {
			//check and resize the view
			if (vm.isMetadataSearch) {
				getRegisterItems();
			}
			if (vm.searchInFolders) {
				buildFoldersGridSetting();
			}

			loadFolderTree();
			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 () {
						calculateHeightForDocumentGrids();
					}, 500);
				});
			} else {
				getSearchResult(E.searchType.Maximum, true);
			}

			activeButtonGroup(parseInt(vm.type), true);
			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,
				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);
		};

		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 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) {
				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 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.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) {
				calculateHeightForDocumentGrids();
			}
		}

		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];
			} else if (type == 4 && vm.enabledMetadataSearch) {
				$scope.isAdvanceSearch = false;
				$scope.isMetadataSearch = true;
				$scope.searchPlaceHolder = $scope.translation.MetadataSearch;
				$scope.selectedSearchType = $scope.searchTypes[3];
			}

			$timeout(function () {
				activeButtonGroup(type);
			}, 500);
		}

		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 > 0
				|| 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() {
			if (!$scope.keyword) {
				return;
			}
			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() {
			if (!$scope.keyword) {
				return;
			}
			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) {
			var searchCondition = ((vm.keyword != null && vm.keyword != "")
				|| vm.folderId > 0
				|| 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.toUTCString().replace('UTC', 'GMT');
				}
				if (vm.toDate != null && typeof vm.toDate != 'string') {
					vm.toDate = vm.toDate.toUTCString().replace('UTC', 'GMT');
				}
				if (vm.registerItemId) {
					vm.searchInContents = true;
				}
				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);
							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.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);
						if (reCalculateHeigth) {
							$timeout(function () {
								calculateHeightForDocumentGrids();
							}, 500);
						}
					});
			} else {
				vm.searchConditionTrue = false;
			}
		}

		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) {
				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;
				}
			}
		};

		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() {
			$http.get(handbookRequests.GetFoldersRequest, { params: { 'id': null, 'showDocumentInTree': false } })
				.success(function (data, status, headers, config) {
					$scope.folderTree = data;
					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;
				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;
					}
				}
				$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;
				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;
					}
				}
				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
					.get('/api/Documents/GetAttachmentsForDocuments', { params: { documentIds: documentIds } })
					.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 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;
		}

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

		function calculateHeightForDocumentGrids() {
			var heightOfShowAllLink = 25;
			var documentHeight = 33;
			var folderHeight = 33;
			var remainingHeight = calculateRemainingHeightForDocumentGrids() - 30 - (showFolderSearch ? 30 : 0) - (showCompendiaSearch ? 30 : 0);// If 3 headers grid existed = 90

			var realHeightOfCompendia = 0; // real height of Compendia Document Grid
			var realHeightOfDocument; // Real height of Handbook Document Grid
			var heightOfCompendia = vm.compendiaDocuments.length ? vm.compendiaDocuments.length * documentHeight : 0; // Height of Compendia Document Grid
			var heightOfDocument = 0; // Height of Handbook Document Grid
			var realHeightOfFolder = 0;
			var heightOfFolder = vm.folders.length ? (vm.folders.length) * folderHeight : 0;
			var calRemainingHeight = 0;

			var percentHandbook = (showFolderSearch && showCompendiaSearch) ? 0.4 : 0.6;
			var percentCompendia = !showCompendiaSearch ? 0 : (!showFolderSearch ? 1 - percentHandbook : 0.3);
			var percentFolder = 1 - percentHandbook - percentCompendia;

			if (!showFolderSearch && !showCompendiaSearch) {
				heightOfDocument = remainingHeight ;
			} else {
				realHeightOfCompendia = showCompendiaSearch ? (vm.compendiaDocuments.length * documentHeight) : 0;
				realHeightOfDocument = vm.documents.length ? (vm.documents.length) * documentHeight : documentHeight; 
				realHeightOfFolder = showFolderSearch ? (vm.folders.length) * folderHeight : 0;
				if ((realHeightOfCompendia + realHeightOfDocument + realHeightOfFolder) > remainingHeight) {
					var calHeigthCompendia = showCompendiaSearch ? (percentCompendia * remainingHeight - documentHeight) : 0;
					heightOfCompendia = (calHeigthCompendia > realHeightOfCompendia) ? realHeightOfCompendia : calHeigthCompendia;
					var calHeigthFolder = showFolderSearch ? (percentFolder * remainingHeight - folderHeight) : 0;
					heightOfFolder = (calHeigthFolder > realHeightOfFolder) ? realHeightOfFolder : calHeigthFolder;

					calRemainingHeight = remainingHeight - heightOfCompendia - heightOfFolder;
					if (calRemainingHeight > realHeightOfDocument) {
						heightOfDocument = realHeightOfDocument;
						calRemainingHeight = remainingHeight - heightOfDocument - heightOfFolder - heightOfCompendia;
						if (heightOfFolder < realHeightOfFolder && showFolderSearch) {
							heightOfFolder = heightOfFolder + calRemainingHeight;
						} else if (heightOfCompendia < realHeightOfCompendia && showCompendiaSearch) {
							heightOfCompendia = heightOfCompendia + calRemainingHeight;
						}
					} else {
						heightOfDocument = calRemainingHeight;
					}
				} else {
					heightOfCompendia = realHeightOfCompendia;
					heightOfDocument = realHeightOfDocument;
					heightOfFolder = realHeightOfFolder;
				}
			}
			if ((heightOfDocument < realHeightOfDocument)) {
				heightOfDocument = heightOfDocument - heightOfShowAllLink;
			}
			$('.handbook-folders #gridController tbody').css('max-height', heightOfFolder);
			$('.compendia-documents .content-wrapper').css('max-height', heightOfCompendia);
			$('.handbook-documents #gridController tbody').css('max-height', heightOfDocument);
		}
				
		$(window).on('resize', function () {
			calculateHeightForDocumentGrids()
		});

		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', '$modal', '$modalInstance', 'broadcastService', 'items',
        function ($scope, $http, $state, $modal, $modalInstance, broadcastService, items) {
            $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.simpleSubscription = HandbookConfiguration.SimpleSubscription.toUpperCase() == 'TRUE' ? true : false;

            initDataSource();

            $scope.loadEmailSubscribedFolder = function () {
                $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.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 = '';
                if (checkFolder(folder.type)) {
                    if (folder.isRecursiveFolder) {
                        requestUrl = handbookRequests.RemoveEmailSubscription + '/' + folder.id;
                    } else {
                        requestUrl = handbookRequests.RemoveOnlyFolderFromEmailSubscription + '/' + folder.id;
                    }
                } else {
                    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) {
                if (!$scope.runOnce) { // to prevent this evt run twice
                    $scope.isChanged = true;
                    var dataSource = getSourceByItemType(obj.type);
                    removeBorderAndUpdateOrder(index, evt.element, obj, dataSource, false, false);
                }
            }

            $scope.onDropCompleteForLastItem = function (index, obj, evt) {
                $scope.isChanged = true;
                var dataSource = getSourceByItemType(obj.type);
                removeBorderAndUpdateOrder(index, evt.element, obj, dataSource, false, true);
            }

            $scope.onDropCompleteForTopItem = function (index, obj, evt) {
                $scope.isChanged = true;
                var dataSource = getSourceByItemType(obj.type);
                removeBorderAndUpdateOrder(index, evt.element, obj, dataSource, true, false);
            }

            $scope.setCurrentTab = function (tab) {
                $scope.currentTab = tab;
            };

            $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 () {
                $scope.folders = angular.copy($scope.originalFoldersData);
                $scope.documents = angular.copy($scope.originalDocumentsData);
                closeAndUpdateFavoriteTree();
            };

            $scope.saveAndClose = function () {
                if ($scope.isChanged) {
                    var documents = reArrangeAndGetChangedSortOrderItems($scope.documents, $scope.originalDocumentsData);
                    var folders = reArrangeAndGetChangedSortOrderItems($scope.folders, $scope.originalFoldersData);
                    var updatedItems = documents.concat(folders);

                    $http.post(handbookRequests.UpdateFavoritesSortOrder, updatedItems)
                         .then(function () {
                             $scope.isChanged = false;
                             updateOriginalData();
                             closeAndUpdateFavoriteTree();
                         });
                }
                else {
                    $modalInstance.close();
                }
            };

            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;
                    }
                }
            };

            function isFolder(type) {
                return type > E.nodeTypes.ShortcutDocument;
            };

            function confirmAndDeleteItem(object, requestUrl, dataSource, originalDataSource, isUpdateFavoriteTree) {
                var modalInstance = $modal.open({
                    templateUrl: paths.ConfirmationView,
                    controller: controllers.confirmController,
                    resolve: {
                        item: function () {
                            return object.name;
                        }
                    }
                });

                modalInstance.result.then(function (isConfirm) {
                    if (isConfirm) {
                        $http.post(requestUrl)
                             .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);
                                 }
                             });
                    }
                });
            };

            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 getSourceByCurrentTab(isOriginalSource) {
                if ($scope.currentTab == manageFavoriteTabs.folder) {
                    if (isOriginalSource) {
                        return $scope.originalFoldersData;
                    }
                    else {
                        return $scope.folders;
                    }
                }
                else if ($scope.currentTab == manageFavoriteTabs.document) {
                    if (isOriginalSource) {
                        return $scope.originalDocumentsData;
                    }
                    else {
                        return $scope.documents;
                    }
                }
            };

            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', '$modalInstance', 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', '$modal', '$location', '$timeout', 'favoriteService', 'treeNavigationService', 'localStorageService', 'documentService'];

	function treeViewController($scope, $http, $state, $modal, $location, $timeout, favoriteService, treeNavigationService, localStorageService, documentService) {
		$scope.showTreeFavorites = false;
		$scope.showTreeDocument = false;
		$scope.showTreeMyMostRead = false;
		$scope.showTreeMyLastVisited = false;
		$scope.showToggleSearchPanel = false;

		$scope.documentList = {};
		$scope.favoritesList = {};
		$scope.myMostReadList = {};
		$scope.myLastVisitedList = {};

		var currentRecursiveIndex = 0;
		var parents = [];
		var previousRequest = { itemId: 0, itemType: '' };
		var initOpeningDocumentGroupAsDefault = false;
		$scope.init = function () {
			if (HandbookConfiguration.OpenDocumentGroupAsDefault == "True") {
				initOpeningDocumentGroupAsDefault = true;
				$scope.loadWhenSelectMenu("Document");
			}
		};

		$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 } })
							.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 } })
							.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).
							success(function (data, status, headers, config) {
								$scope.documentList = data;
								treeNavigationService.navigateToItemLocation(true);
								if (isNaN(HandbookConfiguration.OpenDocumentGroupTopFolderAsDefault) == false && initOpeningDocumentGroupAsDefault) {
									initOpeningDocumentGroupAsDefault = false;
									if ($scope.documentList && $scope.documentList.length > 0) {
										var node = null;
										for (var i = 0; i < $scope.documentList.length; i++) {
											if ($scope.documentList[i].id == parseInt(HandbookConfiguration.OpenDocumentGroupTopFolderAsDefault)) {
												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;
			}
		};

		$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.$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 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).
						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 = $modal.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).
				success(function (data, status, headers, config) {
					$scope.documentList = data;
					treeNavigationService.navigateToItemLocation(true);
				});
		};
	};

})();

;

(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 () {
    'use strict';

    angular.module('handbookApp', [
        'ui.bootstrap', 'angularTreeview', 'ui.router', 'ngGrid', 'ui.tree',
        'placeholderShim', 'cfp.hotkeys', 'ngClipboard', 'dibari.angular-ellipsis', 'modelOptions', 'ngSanitize',
        'accountModule', 'documentModule', 'customeDirectivesModule', 'PubSubModule', 'homeModule', 'chapterModule', 'configModule',
        'documentFieldsModule', 'tabModule', 'managementModule', 'newsListModule', 'feedbackModule',
		'advanceSearchModule', 'metadataSearchModule', 'smart-table', 'infinite-scroll', 'hearingFeedbackModule', 'NewsCategoryModule', 'documentHearingFieldsModule', 'compareWithEarlierVersionModule', 'fieldsContentWholeDocumentModule', 'rwdImageMaps', 'vs-repeat', 'documentCompareWithEarlierVersionModule'
    ]).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;
        }];
    });

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

    model.controller(controllers.feedbackController, ['$scope', '$http', '$modal', 'feedBackService', '$modalInstance', 'entityId','$sce',
    function ($scope, $http, $modal, feedBackService, $modalInstance, entityId, $sce) {

        $scope.globalResources =angular.copy(globalResources);
        $scope.globalResources.Feedback_Message = $sce.trustAsHtml(globalResources.Feedback_Message);
        $scope.globalResources.Feedback_Message1 = $sce.trustAsHtml(globalResources.Feedback_Message1);

        if (HandbookConfiguration.RecipientsForFeedbackMail == E.RecipientsForFeedbackMail.OwnerOnly) {
            $scope.isOwnerOnly = true;
        }

        $scope.currentData = {
            feedbackText: ''
        };

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

        $scope.close = function () {
            $modalInstance.close(true);
        };
    }]);

})();;
(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.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', '$modalInstance', 'quickSearchKeyword', 'metaDataService', 'broadcastService',
    function ($scope, $state, $http, $document, folderService, $modalInstance, quickSearchKeyword, metaDataService, broadcastService) {
        $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;

        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)
                         .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('servicesModule')
           .controller('AddMembersController', controller);

    controller.$inject = ['$modalInstance', '$http', '$scope', 'existedEmployees', 'titlePage', 'roleId', 'excludedQuitDepartmentId', 'folderId'];

    function controller($modalInstance, $http, $scope, existedEmployees, titlePage, roleId, excludedQuitDepartmentId, folderId) {
        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;

        initialize();

        function initialize() {
            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) {
            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.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.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 () {
    'use strict';

    angular.module(modules.chapterModule)
           .controller('SendDocumentToHearingEmailController', controller);

    controller.$inject = ['$modalInstance', '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 = HandbookConfiguration.MetadataEnabled == 'True' ? true : false;
        vm.isShowMetatagTab = HandbookConfiguration.ShowMetatagTab.toUpperCase() == 'TRUE' ? true : false;
        vm.publishedVersion = HandbookConfiguration.PublishedVersion.toUpperCase() == 'TRUE' ? true : false;
        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() {
            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 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'];

    function controller($http, $state, $sce) {
        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 = HandbookConfiguration.EnableDocumentExtention == 'True' ? true : false;

        initialize();
        vm.printDocumentComparison = printDocumentComparison;
        vm.changeFromVersion = changeFromVersion;
        vm.changeToVersion = changeToVersion;
        vm.viewCompareParentDocument = viewCompareParentDocument;
        vm.viewCompareChildDocument = viewCompareChildDocument;

        function initialize() {
            generateComparisonResult(null, 0);

            if (vm.enableDocumentExtention)
                getParentIdExtendDocument();
        }

        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 getParentIdExtendDocument() {
            vm.parentDocumentId = 0;
            $http
                .get('/api/Documents/GetParentIdExtendDocument', { params: { childId: vm.currentDocumentId, isBackend: false } })
                .success(function (data) {
                    if (data && data > 0) {
                        vm.parentDocumentId = data;
                    }
                });
        }

        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'];

	function controller($http, $state, $sce, $scope) {
        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 = HandbookConfiguration.AdvancedCompare == 'True' ? true : false;
        vm.enableDocumentExtention = HandbookConfiguration.EnableDocumentExtention == 'True' ? true : 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*/);

            $scope.$on('$destroy', function () {
                window.removeEventListener('resize', initCompareScrollEvent);
            });

            generateComparisonResult(null, 0);

            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)
                getParentIdExtendDocument();
		}

		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 getParentIdExtendDocument() {
            vm.parentDocumentId = 0;
            $http
                .get('/api/Documents/GetParentIdExtendDocument', { params: { childId: vm.currentDocumentId, isBackend: false } })
                .success(function (data) {
                    if (data && data > 0) {
                        vm.parentDocumentId = data;
                    }
                });
        }

        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('fieldsContentWholeDocumentModule', [])
        .controller("FieldsContentWholeDocumentController", FieldsContentWholeDocumentController);

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

    function FieldsContentWholeDocumentController($http, $state, $sce, $timeout, $location, $scope, $rootScope, $anchorScroll,
		documentService, anchorService, documentContentsSearchService, resizeService, $stateParams, pubSub, folderService, treeNavigationService, $q, tabStateService) {

        var ignoreRichText = (HandbookConfiguration.LazyLoadRichText == 'True') ? true : false;

        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 = HandbookConfiguration.ShowDocumentLinkToBackend == 'True' ? true : false;
        vm.simpleSubscription = HandbookConfiguration.SimpleSubscription.toUpperCase() == 'TRUE' ? true : false;

        vm.isShowMetadata = HandbookConfiguration.MetadataEnabled == 'True' ? true : false;
        vm.isShowMetatagTab = HandbookConfiguration.ShowMetatagTab.toUpperCase() == 'TRUE' ? true : false;
        vm.publishedVersion = HandbookConfiguration.PublishedVersion.toUpperCase() == 'TRUE' ? true : false;
        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 = $sce.trustAsHtml(response.data.content);
                                            fieldContent.isVisible = true;
                                        }
                                    });

                                    richTextRequests.push(getRichText);
                                } else {
                                    if (fieldContent.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 = (HandbookConfiguration.EnableCompare.toUpperCase() == 'TRUE' && vm.currentData.version > 0) ? true : false;
                        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');
		}

    };

})();;