(function () {
	angular.module('Plania').controller('addPropertyMappingController', ['$scope', '$modalInstance', 'params', 'svvTunnelRepository', controller]);

	function controller($scope, $modalInstance, params, svvTunnelRepository) {
		$scope.category = params.Category;
		$scope.objectType = params.ObjectType;

		$scope.$watch('objectType.NvdbTypeId', function (newValue, oldValue) {
			if (newValue) {
				var url = 'propertymappingtypes/availablePlaniaProperties/' +
					$scope.category.prefix +
					'/' +
					$scope.objectType.PlaniaGuid +
					'/' +
					$scope.objectType.NvdbTypeId;
				svvTunnelRepository.get(url, {}).then(
					function (response) {
						$scope.planiaProperties = response.data;
					},
					function (error) {
						svvTunnelRepository.growl(error, 'danger');
					}
				);
			}
		});

		$scope.onPlaniaPropertyChanged = function () {
			var url = 'propertymappingtypes/nvdbEgenskaper/' +
				$scope.objectType.NvdbTypeId +
				'/' +
				$scope.selectedPlaniaProperty.PlaniaProperty;

			svvTunnelRepository.get(url, {}).then(
				function (response) {
					$scope.nvdbProperties = response.data;
				}, function (error) {
					svvTunnelRepository.growl(error, 'danger');
				});
		};

		$scope.canSave = function () {
			if ($scope.selectedNvdbProperty && $scope.selectedPlaniaProperty) {
				return true;
			}
			return false;
		};

		$scope.save = function () {
			var model = {
				CategoryPrefix: $scope.category.prefix,
				CategoryGuid: $scope.objectType.PlaniaGuid,
				PlaniaProperty: $scope.selectedPlaniaProperty.PlaniaProperty,
				PlaniaDynamicLabelProperty: $scope.selectedPlaniaProperty.PlaniaDynamicLabelName,
				PlaniaDynamicLabelValue: $scope.selectedPlaniaProperty.PlaniaDynamicLabelValue,
				NvdbTypeId: $scope.objectType.NvdbTypeId,
				NvdbPropertyTypeId: $scope.selectedNvdbProperty.NvdbPropertyId,
				NvdbLabel: $scope.selectedNvdbProperty.NvdbLabel,
				IsTemplate: $scope.selectedPlaniaProperty.IsTemplate
			};
			svvTunnelRepository.post('PropertyMapping', model).then(function (response) {
				$modalInstance.close('saved');
			}, function (error) {
				svvTunnelRepository.growl(error, 'danger');
			});
		};

		$scope.cancel = function() {
			$modalInstance.dismiss('canceled');
		};
	}
})();
(function () {

    angular.module('Plania').config([
        '$provide', function ($provide) {

            $provide.decorator('AutoCompleteService', [
                '$delegate', function ($delegate, $localStorage) {
                    var service = $delegate;

					service.equipments = function (searchParam, page, pageSize, sorting) {
						if (!sorting || sorting.length === 0)
							sorting = { ID: 'asc' };
						var columns = ['Id', 'Description', 'Text20', 'Area.Id', 'Area.Description', 'Building.Id', 'Building.Description', 'Building.Estate.Id', 'Building.Estate.Description', 'Building.Estate.Guid'];
						return service.getAutoComplete('equipment/', searchParam, page, pageSize, sorting, function (r) {
							return service.getModel(r.Guid, r.Id, r.Description, r);
						}, columns);
					};

                    return service;
                }]);
        }
    ]);

})();

(function () {

	angular.module('Plania').config([
		'$provide', function ($provide) {

			$provide.decorator('CommonService', [
				'$delegate', '$localStorage', function ($delegate, $localStorage) {
					var service = $delegate;

					service.clearFilterData = function () {
						delete service.filterData;
						service.filterData = { isLoaded: false };
						service.setEmptyEstate();
						service.setEmptyBuilding();
						service.setEmptyDataOwner();
						service.setEmptySelection();
					};

					service.setEmptyEstate = function () { service.filterData.selectedEstate = { Name: 'Velg eiendom', Guid: '' }; };
					service.setEmptyEstate();
					service.setEmptyBuilding();
					service.setEmptyDataOwner();
					service.setEmptySelection();

					service.setEstate = function(estate) {
						if (!estate) return;
						service.filterData.selectedEstate.Guid = estate.Guid;
						if (!estate.Name)
							service.filterData.selectedEstate.Name = estate.Id + " - " + estate.Description;
						else {
							service.filterData.selectedEstate.Name = estate.Name;
						}
						$localStorage.filterData = service.filterData;
					};

					service.getFilterData = function() {
						if (!service.filterData.isLoaded) {
							var storageFilterData = angular.fromJson($localStorage.filterData);

							if (storageFilterData) {
								service.setBuilding(storageFilterData.selectedBuilding);
								service.setDataOwner(storageFilterData.selectedDataOwner);
								service.setSelectedSelection(storageFilterData.selectedSelection);
								service.setEstate(storageFilterData.selectedEstate);
							}
							service.filterData.isLoaded = true;
						}

						return service.filterData;
					};

					service.disableWebMenuNavigation = function () {
						return service.getFilterData().selectedEstate.Guid.length === 0;
					};

					return service;
				}]);
		}
	]);

})();
(function () {

	angular.module('Plania').controller('DeviationController', ['$scope', 'Repository', '$stateParams', '$modalInstance', '$modal', '$localStorage', 'TranslationService', 'Constants', '$rootScope', 'DeviationService', 'RegisteredFieldService', controller]);

	function controller($scope, repository, $stateParams, $modalInstance, $modal, $localStorage, translationService, constants, $rootScope, deviationService, registeredFieldService) {
		var isModal = $stateParams.isModal;
		$scope.isUpdate = $stateParams.guid ? true : false;

		$scope.model = {};
		$scope.modelDto = {};
		$scope.modelIsLoaded = false;
		if ($stateParams.guid) $scope.model.Guid = $stateParams.guid;
		$scope.parentEntity = $stateParams.parentEntity;
		$scope.disableEntityInput = $stateParams.disableEntityInput;

		$scope.activateAutocomplete = false;
		$scope.viewMode = (isModal || !$scope.isUpdate) ? false : true;
		$scope.filterOnBuilding = $localStorage.generalOptions.InspectedEntityLocation === constants.inspectedEntityLocation.building && $scope.parentEntity === 'WorkOrder';
		$scope.filterOnEstate = $localStorage.generalOptions.InspectedEntityLocation === constants.inspectedEntityLocation.estate && $scope.parentEntity === 'WorkOrder';
		$scope.reloadDocumentTable = false;
		$scope.isDocumentsCollapsed = true;
		$scope.defaultDocumentCategory = { Guid: repository.commonService.getFilterData().selectedDataOwner.GuidWoXEqDocumentCategory, Name: repository.commonService.getFilterData().selectedDataOwner.WoXEqDocumentCategory };

		$scope.toggleViewMode = function () {
			$scope.viewMode = !$scope.viewMode;
		};

		var updateAccess = function (status) {
			if (status && status === 'Closed') {
				$scope.restrictEdit = true;
				$scope.restrictDelete = true;
			}
			else if ($scope.isUpdate) {
				var checkOtherDO = $scope.model.GuidDataOwner !== repository.commonService.getFilterData().selectedDataOwner.Guid;
				$scope.restrictEdit = !repository.authService.hasEditAccess(repository.commonService.prefix.Deviation, checkOtherDO);
				$scope.restrictDelete = !repository.authService.hasDeleteAccess(repository.commonService.prefix.Deviation, checkOtherDO);
			} else {
				$scope.restrictEdit = !repository.authService.hasCreateAccess(repository.commonService.prefix.Deviation);
				$scope.restrictDelete = !repository.authService.hasDeleteAccess(repository.commonService.prefix.Deviation);
			}
		};

		$scope.canCloseDeviation = function (guidWorkOrder) {
			if ($scope.model.Status === 'Closed') return false;

			if ($localStorage.generalOptions.CloseDeviationFromWoOnly)
				return guidWorkOrder && $scope.model.GuidWorkOrder === guidWorkOrder;
			else
				return guidWorkOrder ? $scope.model.GuidWorkOrder === guidWorkOrder : true;
		};

		$scope.closeDeviation = function () {
			swal({
				title: translationService.translate('web-swal-close-Deviation', 'Bekreft lukking av avvik'),
				text: translationService.translate('web-swal-close-Deviation-message', 'Er avviket klar til å bli lukket?'),
				type: "info",
				showCancelButton: true,
				confirmButtonColor: "#2196f3",
				confirmButtonText: translationService.translate('web-swal-deviation-button-confirm', 'Ja, Lukk avviket!'),
				cancelButtonText: translationService.translate('web-button-cancel', 'Avbryt'),
				closeOnConfirm: false,
				showLoaderOnConfirm: true
			}, function () {
				window.onkeydown = null;
				window.onfocus = null;
				$scope.model.RequestAction = "Close";
				repository.updateSingleDictionary(repository.apiData.deviation.url, $scope.model).then(function (result) {
					swal(translationService.translate('web-swal-deviation-success', 'Avviket ble lukket!'), '', "success");
					$scope.goBack('deviation.edit', { guid: $scope.model.Guid, menuGuid: $scope.navigation.params.menuGuid });
				});
				$scope.model.RequestAction = null;
			});
		};

		$scope.closeDeviationDirectly = function () {
			$modal.open({
				templateUrl: 'app/deviation/views/closeDeviationDirectlyModal.html',
				controller: 'CloseDeviationDirectlyModalController',
				resolve: {
					params: function () {
						return {
							guid: $scope.model.Guid
						};
					}
				},
			}).result.then(function (result) { //Ok
				getDeviation();

			});
		};

		//Prefill
		if ($stateParams.building) {
			$scope.model.Building = $stateParams.building;
			$scope.model.GuidBuilding = $stateParams.building.guid;
		}

		if ($stateParams.estate) {
			$scope.model.Estate = $stateParams.estate;
			$scope.model.GuidEstate = $stateParams.estate.guid;
		}

		if ($stateParams.area) {
			$scope.model.Area = $stateParams.area;
			$scope.model.GuidArea = $stateParams.area.guid;
		}

		if ($stateParams.equipment) {
			$scope.model.Equipment = $stateParams.equipment;
			$scope.model.GuidEquipment = $stateParams.equipment.guid;
		}

		var columns = [
			"User2.RealName", "User1.RealName", "Estate.Id", "Estate.Description", "Building.Id", "Building.Description",
			"Area.Id", "Area.Description", "Equipment.Id", "Equipment.Description",
			"DeviationType.Id", "DeviationType.Description",
			'ControlListItemAnswer.Value',
			'ControlListItemAnswer.ControlListItem.Name',
			'ControlListItemAnswer.ControlListXEntity.Guid',
			'ControlListItemAnswer.ControlListXEntity.Equipment.Id', 'ControlListItemAnswer.ControlListXEntity.Equipment.Description',
			'ControlListItemAnswer.ControlListXEntity.Area.Id', 'ControlListItemAnswer.ControlListXEntity.Area.Description',
			'ControlListItemAnswer.ControlListXEntity.ControlList.Name', 'ControlListItemAnswer.ControlListXEntity.ControlList.Id', 'ControlListItemAnswer.ControlListXEntity.ControlList.Description',

			// WorkOrder columns
			'ControlListItemAnswer.ControlListXEntity.WorkOrder.Id', 'ControlListItemAnswer.ControlListXEntity.WorkOrder.Description', 'ControlListItemAnswer.ControlListXEntity.WorkOrder.Status', 'ControlListItemAnswer.ControlListXEntity.WorkOrder.DueDate', 'ControlListItemAnswer.ControlListXEntity.WorkOrder.GuidProject', 'ControlListItemAnswer.ControlListXEntity.WorkOrder.EndDate', 'ControlListItemAnswer.ControlListXEntity.WorkOrder.GuidPeriodicTask',
			'ControlListItemAnswer.ControlListXEntity.WorkOrder.Project.Id', 'ControlListItemAnswer.ControlListXEntity.WorkOrder.Project.Id',
			"CorrectiveWorkOrder.Id", "CorrectiveWorkOrder.Description", "CorrectiveWorkOrder.Status", "CorrectiveWorkOrder.DueDate", "CorrectiveWorkOrder.GuidProject", "CorrectiveWorkOrder.EndDate", "CorrectiveWorkOrder.GuidPeriodicTask",
			"CorrectiveWorkOrder.Project.Id", "CorrectiveWorkOrder.Project.Id",
			"InspectionWorkOrder.Id", "InspectionWorkOrder.Description", "InspectionWorkOrder.Status", "InspectionWorkOrder.DueDate", "InspectionWorkOrder.GuidProject", "InspectionWorkOrder.EndDate", "InspectionWorkOrder.GuidPeriodicTask",
			"InspectionWorkOrder.Project.Id", "InspectionWorkOrder.Project.Id",
		];

		var getDeviation = function () {
			repository.getMainModel(repository.apiData.deviation.url, $scope.model.Guid, JSON.stringify(columns)).then(
				function (result) {
					$scope.model = result.Data;
					$scope.reloadDocumentTable = true;
					updateAccess($scope.model.Status);
					//setProperties();
					setTimeout(function () { $scope.activateAutocomplete = true; }, 250);
					$scope.modelIsLoaded = true;
				},
				function (error) {
					repository.growl(error, 'danger');
				});
		};

		if ($scope.isUpdate) {
			getDeviation();
		} else {
			if (!isModal) {
				var selectedBuilding = repository.commonService.getFilterData().selectedBuilding;
				if (selectedBuilding.Guid) {
					$scope.model.GuidBuilding = selectedBuilding.Guid;
					$scope.model.Building = { Caption: selectedBuilding.Name };

					if (selectedBuilding.Estate) {
						$scope.model.GuidEstate = selectedBuilding.Estate.Guid;
						$scope.model.Estate = selectedBuilding.Estate;
					}
				}
			}

			var selectedEstate = repository.commonService.getFilterData().selectedEstate;
			if (selectedEstate && selectedEstate.Guid !== '') {
				$scope.model.GuidEstate = selectedEstate.Guid;
				$scope.modelDto.estate = selectedEstate.Name;
			}

			$scope.activateAutocomplete = true;
			$scope.modelIsLoaded = true;
		}

		$scope.saveAction = function (action) {
			if ($scope.model.DeadlineDate)
				$scope.model.DeadlineDate = new Date($scope.model.DeadlineDate).toISOString();

			if ($scope.isUpdate) {
				repository.updateSingleDictionary(repository.apiData.deviation.url, $scope.model).then(function (result) {
					repository.growl(translationService.translate('web-deviation-deviationUpdated', 'Avvik oppdatert'), 'success');
					if (isModal)
						$modalInstance.close('ok');
					else {
						$scope.goBack(action, { guid: $scope.model.Guid, menuGuid: $scope.navigation.params.menuGuid });
						$scope.model = result;
					}
				}).catch(function (error) {
					repository.growl(error, 'danger');
				});
			} else {
				$scope.model.GuidInspectionWorkOrder = $stateParams.GuidInspectionWorkOrder;
				repository.createSingleDictionary(repository.apiData.deviation.url, $scope.model)
					.then(function (result) {
						repository.growl(translationService.translate('web-deviation-deviationAdded', "Avvik har blitt lagt til"), 'success');

						if (action === 'close') {
							$modalInstance.close('ok');
						} else {
							if (!isModal) {
								$scope.viewMode = true;
								repository.commonService.setLastRegisterGuid('deviation.list', result.Guid);
								$scope.goBack(action, { guid: result.Guid, menuGuid: $scope.navigation.params.menuGuid });
							}

							$scope.model.Guid = result.Guid;
							getDeviation();
							$scope.isUpdate = true;
						}
					}).catch(function (error) {
					repository.growl(error, 'danger');
				});
			}
		};

		$scope.$on($scope.events.newSelection, function () {
			updateAccess();
		});

		$scope.autoCompleteFilter = function (filterName) {
			var filter = {};

			var estateFieldRule = registeredFieldService.getLocalRegisteredField(repository.apiData.deviation.prefix, 'GuidEstate');
			var isEstateHidden = estateFieldRule && estateFieldRule.Hidden;

			switch (filterName) {
				case "building":
					if ($scope.model.GuidEstate) {
						if (!isEstateHidden) {
							filter.PropertyFilter = [{ Property: 'GuidEstate', Operator: '=', Value: $scope.model.GuidEstate }];
						}
					}
					return filter;
				case "area":
					filter = { GuidBuilding: $scope.model.GuidBuilding ? $scope.model.GuidBuilding : null };
					if ($scope.model.GuidEstate && !isEstateHidden) {
						filter.PropertyFilter = [{ Property: 'Building.GuidEstate', Operator: '=', Value: $scope.model.GuidEstate }];
					}
					return filter;
				case "equipment":
					filter = { GuidBuilding: $scope.model.GuidBuilding, hasConditionControl: true, PropertyFilter: [] };
					if ($scope.model.GuidEstate && !$scope.model.GuidBuilding && !isEstateHidden) {
						filter.PropertyFilter = [{ Property: 'Building.GuidEstate', Operator: '=', Value: $scope.model.GuidEstate }];
					}
					if ($localStorage.generalOptions.FilterDeviationByEqPrefix && $scope.model.GuidDeviationType) {
						var id = $scope.model.DeviationType.Caption.substr(0, 3).trim();
						filter.PropertyFilter.push({ Property: 'Id', Operator: 'StartsWith', Value: id });
					}
					filter.PropertyFilter.push({ Property: 'IsTemplate', Operator: '=', Value: false });
					return filter;
				case "deviationType":
					if ($localStorage.generalOptions.FilterDeviationByEqPrefix && $scope.model.GuidEquipment) {
						return { PropertyFilter: [{ Property: 'Id', Operator: 'StartsWith', Value: $scope.model.Equipment.Caption.substr(0, 3).trim() }] };
					}
					return {};
			}
		};

		$scope.cancel = function () {
			$modalInstance.dismiss('canceled');
		};

		$scope.onEstateSelect = function (estate) {
			if (!estate) {
				$scope.model.GuidEstate = "";
				return;
			}

			if ($scope.model.GuidEstate !== estate.Guid) {
				$scope.model.GuidBuilding = "";
				$scope.model.Building = null;
				$scope.model.GuidEquipment = "";
				$scope.model.Equipment = null;
				$scope.model.GuidArea = "";
				$scope.model.Area = null;
			}

			$scope.model.GuidEstate = estate.Guid;
		};

		$scope.onBuildingSelect = function (building) {
			if (!building) {
				$scope.model.GuidBuilding = "";
				return;
			}

			if ($scope.model.GuidBuilding !== building.Guid) {
				$scope.model.GuidEquipment = "";
				$scope.model.Equipment = null;
				$scope.model.GuidArea = "";
				$scope.model.Area = null;
			}

			$scope.model.GuidBuilding = building.Guid;

			if (!$scope.model.GuidEstate || $scope.model.GuidEstate === "") {
				$scope.model.GuidEstate = building.GuidEstate;
				$scope.model.Estate = building.Estate;
			}
		};

		$scope.onAreaSelect = function (area) {
			if (!area) {
				$scope.model.GuidArea = "";
				return;
			}

			$scope.model.GuidArea = area.Guid;

			if (!$scope.model.GuidBuilding || $scope.model.GuidBuilding === "") {
				$scope.model.GuidBuilding = area.GuidBuilding;
				$scope.model.Building = area.Building;
			}

			if (!$scope.model.GuidEstate || $scope.model.GuidEstate === "") {
				$scope.model.GuidEstate = area.Building.Estate.Guid;
				$scope.model.Estate = area.Building.Estate;
			}
		};

		$scope.onEquipmentSelect = function (equipment) {
			if (!equipment) {
				$scope.model.GuidEquipment = "";
				return;
			}

			$scope.model.GuidEquipment = equipment.Guid;

			if (!$scope.model.GuidEstate || $scope.model.GuidEstate === "") {
				$scope.model.GuidEstate = equipment.Building.Estate.Guid;
				$scope.model.Estate = equipment.Building.Estate;
			}

			if (!$scope.model.GuidBuilding || $scope.model.GuidBuilding === "") {
				$scope.model.GuidBuilding = equipment.GuidBuilding;
				$scope.model.Building = equipment.Building;
			}

			if (equipment.GuidArea) {
				$scope.model.GuidArea = equipment.GuidArea;
				$scope.model.Area = equipment.Area;
			}
		};

		$scope.onDeviationTypeSelect = function (deviationType) {
			if (!deviationType) {
				$scope.model.GuidDeviationType = "";
				$scope.model.DeviationType = null;
				return;
			}

			$scope.model.GuidDeviationType = deviationType.Guid;
		};

		$scope.openControlList = function () {
			$modal.open({
				templateUrl: 'app/controlList/views/controlListCompletionModal.html',
				size: 'lg',
				controller: 'ControlListCompletionModalController',
				resolve: {
					params: function () {
						return {
							workOrderCaption: $scope.model.ControlListItemAnswer.ControlListXEntity.WorkOrder.Caption,
							controlList: $scope.model.ControlListItemAnswer.ControlListXEntity.ControlList,
							controlListXEntity: $scope.model.ControlListItemAnswer.ControlListXEntity,
							restrictEdit: true
						};
					}
				}
			}).result.then(function (result) {
			}, function () {
				//cancel
			});
		};

		$scope.createWorkOrder = function () {
			deviationService.createWorkOrder($scope.model);
		};

		var getMenuLink = function (url, text, icon) {
			var htmlText = '<a class="dropdown-item" tabindex= "-1" href="' + url + '" >';
			if (icon)
				htmlText += '<i class="zmdi ' + icon + ' zmdi-hc-fw zmdi-hc-lg"></i> ';
			else
				htmlText += '<i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ';
			htmlText += text + '</a>';

			return {
				html: htmlText,
				isHref: true
			};
		};

		$scope.originContextMenu = function () {
			var options = [];

			if ($scope.hasReadAccess('ControlListXEntity') && $scope.model.GuidControlListItemAnswer) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#"><i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ' + translationService.translate('web-deviation-originContextMenu-viewInspectionControlListXEntity', 'Åpne kontrollisten') + '</a >',
					click: function ($itemScope, $event, modelValue, text, $li) {
						$scope.openControlList();
					}
				});
			}

			if ($scope.hasReadAccess('WorkOrder') && $scope.model.GuidInspectionWorkOrder && repository.enableWebNavigation)
				options.push(getMenuLink($rootScope.navigation.href('workOrder.edit', { guid: $scope.model.GuidInspectionWorkOrder }), translationService.translate('web-deviation-originContextMenu-viewInspectionWorkOrder', 'Gå til arbeidsordre')));
			if ($scope.hasReadAccess('Project') && $scope.model.GuidInspectionWorkOrder && $scope.model.InspectionWorkOrder && $scope.model.InspectionWorkOrder.GuidProject && repository.enableWebNavigation)
				options.push(getMenuLink($rootScope.navigation.href('project.edit', { guid: $scope.model.InspectionWorkOrder.GuidProject }), translationService.translate('web-deviation-originContextMenu-viewInspectionProject', 'Gå til prosjekt')));

			if ($scope.hasReadAccess('PeriodicTask') && $scope.model.GuidInspectionWorkOrder && $scope.model.InspectionWorkOrder && $scope.model.InspectionWorkOrder.GuidPeriodicTask && repository.enableWebNavigation)
				options.push(getMenuLink($rootScope.navigation.href('periodicTask.edit', { guid: $scope.model.InspectionWorkOrder.GuidPeriodicTask }), translationService.translate('web-deviation-originContextMenu-viewInspectionPeriodicTask', 'Gå til periodisk rutine')));

			if (options.length === 0) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#">' + translationService.translate('web-deviation-originContextMenu-empty', 'Ingen aksjoner tilgjengelig') + '</a>',
					enabled: false
				});
			}

			return options;
		};

		//Svv specific
		$scope.shouldShowNvdbLookup = function () {
			if ($scope.model.Equipment && $scope.model.Equipment.Caption) {
				var caption = $scope.model.Equipment.Caption;
				if (caption.split('-')[0].trim().length === 3) return true;
			}
			return false;
		};

		$scope.onNvdbLookupClicked = function () {
			$modal.open({
				templateUrl: 'customizations/10088/nvdbEquipmentLookup.html',
				size: 'lg',
				controller: 'NvdbEquipmentLookupController',
				resolve: {
					params: function () {
						return {
							guidBuilding: $scope.model.GuidBuilding,
							guidEquipment: $scope.model.GuidEquipment
						};
					}
				}
			}).result.then(function (result) {
				$scope.model.Equipment.Caption = result.Caption;
				$scope.model.GuidEquipment = result.GuidEquipment;
			}, function () {
				//cancel
			});
		};
		//end svv specific

		$scope.followUpContextMenu = function () {
			var options = [];

			if ($scope.hasEditAccess('Deviation') && $scope.model.GuidCorrectiveWorkOrder && $scope.model.CorrectiveWorkOrder && !$scope.model.CorrectiveWorkOrder.EndDate && $scope.canCloseDeviation($scope.model.GuidCorrectiveWorkOrder)) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#"><i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ' + translationService.translate('web-deviation-followUpContextMenu-closeDeviationFromCorrective', 'Lukk avviket via') + ' ' + $scope.model.CorrectiveWorkOrder.Caption + '</a >',
					click: function () {
						$scope.closeDeviation();
					}
				});
			}

			if ($scope.hasEditAccess('Deviation') && !$scope.model.GuidCorrectiveWorkOrder && $scope.model.GuidInspectionWorkOrder && $scope.model.InspectionWorkOrder && !$scope.model.InspectionWorkOrder.EndDate && $scope.canCloseDeviation($scope.model.GuidInspectionWorkOrder)) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#"><i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ' + translationService.translate('web-deviation-followUpContextMenu-closeDeviationFromInspection', 'Lukk avviket via') + ' ' + $scope.model.InspectionWorkOrder.Caption + '</a >',
					click: function () {
						$scope.closeDeviation();
					}
				});
			}

			if ($scope.hasEditAccess('Deviation') && !$scope.model.GuidCorrectiveWorkOrder && !$scope.model.GuidInspectionWorkOrder && $scope.canCloseDeviation()) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#"><i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ' + translationService.translate('web-deviation-followUpContextMenu-closeDeviationFromDirectly', 'Lukk avviket direkte uten arbeidsordre')+ '</a >',
					click: function () {
						$scope.closeDeviation();
					}
				});
			}

			if ($scope.hasReadAccess('WorkOrder') && $scope.model.GuidCorrectiveWorkOrder && repository.enableWebNavigation)
				options.push(getMenuLink($rootScope.navigation.href('workOrder.edit', { guid: $scope.model.GuidCorrectiveWorkOrder }), translationService.translate('web-deviation-followUpContextMenu-viewCorrectiveWorkOrder', 'Gå til arbeidsordre')));

			if ($scope.hasReadAccess('Project') && $scope.model.GuidCorrectiveWorkOrder && $scope.model.CorrectiveWorkOrder && $scope.model.CorrectiveWorkOrder.GuidProject && repository.enableWebNavigation)
				options.push(getMenuLink($rootScope.navigation.href('project.edit', { guid: $scope.model.CorrectiveWorkOrder.GuidProject }), translationService.translate('web-deviation-followUpContextMenu-viewCorrectiveProject', 'Gå til prosjekt')));

			if ($scope.hasReadAccess('PeriodicTask') && $scope.model.GuidCorrectiveWorkOrder && $scope.model.CorrectiveWorkOrder && $scope.model.CorrectiveWorkOrder.GuidPeriodicTask && repository.enableWebNavigation)
				options.push(getMenuLink($rootScope.navigation.href('periodicTask.edit', { guid: $scope.model.CorrectiveWorkOrder.GuidPeriodicTask }), translationService.translate('web-deviation-followUpContextMenu-viewCorrectivePeriodicTask', 'Gå til periodisk rutine')));

			if ($scope.hasEditAccess('Deviation') && $scope.model.Status === 'InWorks' && $scope.model.GuidCorrectiveWorkOrder && !$scope.model.CorrectiveWorkOrder.EndDate) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#"><i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ' + translationService.translate('web-deviation-followUpContextMenu-removeFromWorkOrder', 'Koble fra arbeidsordre') + '</a >',
					click: function () {
						swal({
							title: translationService.translate('web-deviation-followUpContextMenu-removeFromWorkOrder-swalTitle', 'Bekreft frakobling av avvik'),
							text: translationService.translate('web-deviation-followUpContextMenu-removeFromWorkOrder-swalMessage', 'Er du sikker på at du vil koble dette avviket ifra arbeidsordren?'),
							type: "warning",
							showCancelButton: true,
							confirmButtonColor: "#f44336",
							confirmButtonText: translationService.translate('web-deviation-followUpContextMenu-removeFromWorkOrder-swalConfirm', 'Ja, koble fra!'),
							cancelButtonText: translationService.translate('web-button-cancel', 'Avbryt'),
							closeOnConfirm: false,
							showLoaderOnConfirm: true
						}, function () {
							window.onkeydown = null;
							window.onfocus = null;
							$scope.model.RequestAction = "ResetCorrectiveWorkorder";
							repository.updateSingleDictionary(repository.apiData.deviation.url, $scope.model).then(function (result) {
								swal(translationService.translate('web-deviation-followUpContextMenu-removeFromWorkOrder-success', 'Avviket ble frakoblet arbeidsordren'), result.Caption, "success");
								$scope.goBack('deviation.edit', { guid: $scope.model.Guid, menuGuid: $scope.navigation.params.menuGuid });
							}, function (error) {
								swal('Error', error, "error");
							});
						});
					}
				});
			}

			if ($scope.hasCreateAccess('WorkOrder') && $scope.model.Status !== 'Closed' && !$scope.model.GuidCorrectiveWorkOrder) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#"><i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ' + translationService.translate('web-deviation-followUpContextMenu-createWorkOrder', 'Opprett ny arbeidsordre for utbedring av avvik') + '</a >',
					click: function () {
						$scope.createWorkOrder();
					}
				});
			}

			if ($scope.hasReadAccess('WorkOrder') && $scope.model.Status !== 'Closed' && $scope.hasEditAccess('Deviation') && !$scope.model.GuidCorrectiveWorkOrder) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#"><i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ' + translationService.translate('web-deviation-followUpContextMenu-addToExistingWo', 'Koble til eksisterende arbeidsordre') + '</a >',
					click: function () {
						$modal.open({
							templateUrl: 'app/common/views/singleSelectModal.html',
							controller: 'SingleSelectModalController',
							size: 'lg',
							resolve: {
								modalParams: function () {
									return {
										title: translationService.translate('web-deviation-followUpContextMenu-addToExistingWo-modalTitle', 'Velg arbeidsordre avviket skal kobles til'),
										url: repository.apiData.workOrder.url,
										sorting: { 'Id': 'desc' },
										filter: { PropertyFilter: [{ Property: 'EndDate', Operator: '=', Value: null }] },
										columns: [
											{ title: translationService.translate('web-workOrder-Id', 'Ao Nr'), property: 'Id' },
											{ title: translationService.translate('web-workOrder-Description', 'Beskrivelse'), property: 'Description', PropertyType: 'String' },
											{ title: translationService.translate('web-workOrder-Building-Id', 'Bygg Id'), property: 'Building.Id' },
											{ title: translationService.translate('web-workOrder-Building-Description', 'Byggbeskrivelse'), property: 'Building.Description', PropertyType: 'String' },
										]
									};
								}
							}
						}).result.then(function (selectedEntity) {
							$scope.model.GuidCorrectiveWorkOrder = selectedEntity.Guid;
							$scope.saveAction('deviation.edit');
						});
					}
				});
			}

			if ($scope.model.Status !== 'Closed' && $scope.hasEditAccess('Deviation') && !$scope.model.GuidCorrectiveWorkOrder) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#"><i style="visibility:hidden;" class="zmdi zmdi-case zmdi-hc-fw zmdi-hc-lg"></i> ' + translationService.translate('web-deviation-followUpContextMenu-closeDeviationDirectly', 'Lukk avvik direkte') + '</a >',
					click: function () {
						$scope.closeDeviationDirectly();
					}
				});
			}

			if (options.length === 0) {
				options.push({
					html: '<a class="dropdown-item" tabindex= "-1" href= "#">' + translationService.translate('web-deviation-followUpContextMenu-empty', 'Ingen aksjoner tilgjengelig') + '</a>',
					enabled: false
				});
			}
			return options;
		};
	}
})();

(function () {
	angular.module('Plania').controller('NvdbChangeSetListController', ['$scope', 'svvTunnelRepository', 'ngTableParams', '$modal', 'Repository',  controller]);

	function controller($scope, svvTunnelRepository, ngTableParams, $modal, repository) {
		var nvdbApiUrl = 'NvdbChangeSet';

		$scope.changeSetTable = new ngTableParams({
				page: 1,
				count: 10,
				sorting: { Guid: 'asc' },
				filter: { searchString: '' }
			},
			{
				total: 0,
				counts: [10, 20, 50],
				filterDelay: 10,
				getData: function ($defer, params) {

					var url = nvdbApiUrl +
						'?page=' +
						(params.page() - 1) +
						'&pageSize=' +
						params.count() +
						'&search=' +
						params.filter().searchString +
						'&dataOwner=' + repository.commonService.getFilterData().selectedDataOwner.Guid;

					svvTunnelRepository.get(url, {}).then(function (response) {
							var result = response.data;
							$scope.changeSetTable.settings().total = result.TotalCount;
							$defer.resolve(result.List);
						},
						function (error) {
							svvTunnelRepository.growl(error, 'danger');
						});
				}
			});

		$scope.openChangeSetModal = function (changeSet) {
			$modal.open({
				templateUrl: 'customizations/10088/nvdbChangeSetModal.html',
				size: 'xl',
				controller: 'NvdbChangeSetModalController',
				resolve: {
					params: function () {
						return {
							nvdbId: changeSet.NvdbId,
							nvdbTypeId: changeSet.NvdbTypeId,
							selectedNvdbChangeSetId: changeSet.NvdbChangeSetId
						};
					}
				}
			}).result.then(function (result) {
			}, function () {
				//cancel
			});
		}

	}
})();

(function () {
	angular.module('Plania').controller('NvdbChangeSetModalController', ['$scope', 'params', '$modalInstance', 'svvTunnelRepository', 'ngTableParams', 'SignalR', 'Repository', controller]);

	function controller($scope, params, $modalInstance, svvTunnelRepository, ngTableParams, signalR, repository) {
		$scope.model = {};
		$scope.model.nvdbId = params.nvdbId;
		$scope.model.nvdbTypeId = params.nvdbTypeId;
		$scope.selectedNvdbChangeSetId = params.selectedNvdbChangeSetId;

		$scope.tabs = [
			{
				title: 'Nytt endringssett',
				active: true,
				visible: true
			},
			{
				title: 'Endringssett',
				active: false,
				visible: true
			}
		];
		if ($scope.selectedNvdbChangeSetId) {
			$scope.tabs[1].active = true;
			$scope.tabs[0].visible= false;
		}

		$scope.changeSetProcessing = false;
		$scope.statusLog = [];
		$scope.showDetailsPrompt = false;
		$scope.firstTabVisible = true;
		$scope.showFormattedStatus = false;
		$scope.syncinfoviewmodel = null;
		$scope.dataOwner = repository.commonService.getFilterData().selectedDataOwner.Guid;
		$scope.includeDryRuns = false;

		svvTunnelRepository.get('nvdbcard/' + $scope.model.nvdbId, {}).then(function (result) {
			$scope.model.nvdbEntity = result.data;
			svvTunnelRepository.get('NvdbChangeSet/NvdbProperties/' + $scope.model.nvdbTypeId + '?dataowner=' + $scope.dataOwner, {}).then(function (propertiesResult){
				$scope.AllProperties = propertiesResult.data.Egenskapstyper;
				setAvailableProperties();
			}, function(propertiesError){
				svvTunnelRepository.growl(propertiesError.data.Message, 'danger');
			});
		}, function (error){
			svvTunnelRepository.growl(error.data.Message, 'danger');
		});

		svvTunnelRepository.get('nvdbcard/syncinfoviewmodel/' + $scope.model.nvdbId, {}).then(function (result) {
			$scope.syncinfoviewmodel = result.data;
		});

		function setAvailableProperties (){
			$scope.availableProperties = _.filter($scope.AllProperties, function(property){
				if (property.Navn !== 'Driftsmerking' && property.Navn !== 'Driftsmerking TFM, lokasjonskode') return false;
				if (property.Datatype === 'Liste') return false;
				var existingProperty = _.find($scope.model.nvdbEntity.Egenskaper, function (egenskap) {return egenskap.Navn === property.Navn;});
				if (existingProperty){
					property.Verdi = existingProperty.Verdi;
					property.OldVerdi = existingProperty.Verdi;
				}

				return true;
			});
		}

		function getChangeSetDto() {
			var changeSetPropertes = _.filter($scope.availableProperties, function(egenskap) {
				if (egenskap.Verdi !== egenskap.OldVerdi)
					return true;
			});

			var mappedProperties = _.map(changeSetPropertes, function(egenskap){
				return {
					NvdbPropertyId: egenskap.Id,
					NvdbPropertyLabel: egenskap.Navn,
					NewPropertyValue: egenskap.Verdi,
					OldPropertyValue: egenskap.OldVerdi
				};
			});

			var dto = {
				NvdbTypeId: $scope.model.nvdbEntity.Metadata.Type.Id,
				NvdbId: $scope.model.nvdbEntity.Id,
				Versjon: $scope.model.nvdbEntity.Metadata.Versjon,
				LastModifiedInNvdb: $scope.model.nvdbEntity.Metadata.Sist_Modifisert,
				ChangeSetProperties: mappedProperties
			};

			return dto;
		}

		$scope.validateChangeSet = function(){
			$scope.statusLog = [];

			var dto = getChangeSetDto();
			if (dto.ChangeSetProperties.length === 0)return;
			var changeSetText = '';
			_.forEach(dto.ChangeSetProperties, function(prop){
				if (prop.OldPropertyValue)
					changeSetText += prop.NvdbPropertyLabel + ' endres fra: ' + prop.OldPropertyValue + ' til: ' + prop.NewPropertyValue;
				else
					changeSetText += prop.NvdbPropertyLabel + ' legges til med verdi: ' + prop.NewPropertyValue;
			});
			swal({
					title: 'Endring vil bli prøvekjørt',
					text: 'Følgende endringer vil bli prøvekjørt til NVDB  \r\n ' + changeSetText,
					type: "info",
					showCancelButton: true,
					confirmButtonColor: "#337ab7",
					confirmButtonText: 'Bekreft',
					cancelButtonText: 'Avbryt',
					closeOnConfirm: true
				},
				function() {
					window.onkeydown = null;
					window.onfocus = null;

					svvTunnelRepository.post('NvdbChangeSet?isDryRun=true' + '&dataowner=' + $scope.dataOwner, dto).then(function (result){
						$scope.includeDryRuns = true;
					}, function (error){
						svvTunnelRepository.growl(error.data.Message, 'danger');
					});
				});
		};

		$scope.executeChangeSet = function(){
			$scope.statusLog = [];

			var dto = getChangeSetDto();
			if (dto.ChangeSetProperties.length === 0)return;
			var changeSetText = '';
			_.forEach(dto.ChangeSetProperties, function(prop){
				changeSetText += prop.NvdbPropertyLabel + ' endres fra ' + prop.OldPropertyValue + ' til ' + prop.NewPropertyValue;
			});

			swal({
					title: 'Endring vil bli sendt',
					text: 'Følgende endringer vil bli sendt til NVDB  \r\n ' + changeSetText,
					type: "info",
					showCancelButton: true,
					confirmButtonColor: "#337ab7",
					confirmButtonText: 'Bekreft',
					cancelButtonText: 'Avbryt',
					closeOnConfirm: true
				},
				function() {
					window.onkeydown = null;
					window.onfocus = null;

					svvTunnelRepository.post('NvdbChangeSet?isDryRun=false' + '&dataowner=' + $scope.dataOwner, dto).then(function (result){

					}, function (error){
						svvTunnelRepository.growl(error.data.Message, 'danger');
					});
				});
		};

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

		$scope.selectRow = function(row){
			$scope.selectedRow = row;
			if ($scope.selectedRow.StatusJson)
				$scope.selectedRow.FormattedStatus = JSON.parse($scope.selectedRow.StatusJson);
			if ($scope.selectedRow.ChangesJson)
				$scope.selectedRow.FormattedChanges = JSON.parse($scope.selectedRow.ChangesJson);
		};

		initializeSignalR();
		function initializeSignalR() {
			var signalRMethodName = 'nvdbChangeSet_nvdbId_' +  $scope.model.nvdbId;

			signalR.on(signalRMethodName, function(progress) {
				if (progress.Finished === true){
					if (progress.Message)
						$scope.selectedNvdbChangeSetId = progress.Message;
					$scope.changeSetProcessing = false;
					$scope.showDetailsPrompt = true;
					$scope.changeSetTable.reload();
					return;
				}
				$scope.changeSetProcessing = true;
				$scope.statusLog.push(progress.Message);
			});

			$scope.$on('$destroy', function () {
				signalR.off(signalRMethodName);
			});
		}

		$scope.navigateToDetails = function (){
			$scope.firstTabVisible = false;
		}

		$scope.getStatus = function(changeSetId) {
			svvTunnelRepository.get('NvdbChangeSet' + '/GetStatus?changeSetId=' + changeSetId + '&dataowner=' + $scope.dataOwner, {}).then(function (response) {
					var result = response.data;
					$scope.changeSetTable.reload();
				},
				function (error) {
					svvTunnelRepository.growl(error, 'danger');
				});
		}

		$scope.onDryRunToggled = function (){
			$scope.includeDryRuns = !$scope.includeDryRuns;
			$scope.changeSetTable.reload();
		};

		$scope.changeSetTable = new ngTableParams({
				page: 1,
				count: 10,
				sorting: { Guid: 'asc' },
				filter: { searchString: '' }
			},
			{
				total: 0,
				counts: [10, 20, 50],
				filterDelay: 10,
				getData: function ($defer, params) {
					var url = 'NvdbChangeSet' +
						'?page=' +
						(params.page() - 1) +
						'&pageSize=' +
						params.count() +
						'&search=' +
						params.filter().searchString +
						'&nvdbID=' + $scope.model.nvdbId +
						'&includeDryRuns=' + $scope.includeDryRuns +
						'&dataowner=' + $scope.dataOwner;
					svvTunnelRepository.get(url, {}).then(function (response) {
							var result = response.data;
							$scope.changeSetTable.settings().total = result.TotalCount;
							if ($scope.selectedNvdbChangeSetId)
							{
								var selectedRow = _.find(result.List, function(row){
									return row.NvdbChangeSetId === $scope.selectedNvdbChangeSetId;
								});
								if (selectedRow)
									$scope.selectRow(selectedRow);
							} else if ($scope.selectedRow){
								var selectedRow = _.find(result.List, function(row){
									return row.NvdbChangeSetId === $scope.selectRow.NvdbChangeSetId;
								});
								if (selectedRow)
									$scope.selectRow(selectedRow);
							}
							$defer.resolve(result.List);
						},
						function (error) {
							svvTunnelRepository.growl(error, 'danger');
						});
				}
			});
	}
})();

(function () {
	angular.module('Plania').controller('nvdbEquipmentController', ['$scope', 'svvTunnelRepository', 'CommonService', 'ngTableParams', controller]);

	function controller($scope, svvTunnelRepository, commonService, ngTableParams) {
		$scope.nvdbEquipmentTable = new ngTableParams({
			page: 1,
			count: 10,
			sorting: { Guid: 'asc' },
			filter: { searchString: '' }
		},
			{
				total: 0,
				counts: [10, 20, 50],
				filterDelay: 10,
				getData: function ($defer, params) {
					svvTunnelRepository.get('WeatherStation?GuidDataOwner=' + commonService.filterData.selectedDataOwner.Guid, {}).then(function (response) {
						$defer.resolve(response.data);
					}, function (error) {
						svvTunnelRepository.growl(error, 'danger');
					});
				}
			});

		$scope.createEquipment = function (row) {
			svvTunnelRepository.post('WeatherStation?GuidDataOwner=' + commonService.filterData.selectedDataOwner.Guid, row).then(function (response) {
				svvTunnelRepository.growl('Anlegg opprettet', 'success');
				$scope.nvdbEquipmentTable.reload();
			}, function (error) {
				svvTunnelRepository.growl(error, 'danger');
			});
		};

		$scope.$on($scope.events.newSelection, function () {
			$scope.nvdbEquipmentTable.reload();
		});
	}
})();
(function () {
	angular.module('Plania').controller('NvdbEquipmentLookupController', ['$scope', 'params', '$modalInstance', 'svvTunnelRepository', 'ngTableParams', '$filter', controller]);

	function controller($scope, params, $modalInstance, svvTunnelRepository, ngTableParams, $filter) {
		$scope.model = {
			GuidBuilding: params.guidBuilding,
			GuidEquipment: params.guidEquipment,
			NvdbObjekt: null
		};

		$scope.equipmentLookup = {};
		$scope.lookupResultTable = null;
		$scope.isTableView = true;

		$scope.search = { term: '' };

		$scope.getLookupResults = function() {
			var url = 'nvdbEquipmentLookup/?guidBuilding=' + $scope.model.GuidBuilding +
				'&guidEquipment=' + $scope.model.GuidEquipment;

			svvTunnelRepository.get(url, {}).then(
				function (response) {
					$scope.equipmentLookup = response.data;
					var data = $scope.equipmentLookup.LookupResults;
					$scope.lookupResultTable = new ngTableParams({
						page: 1,
						count: 10,
						filter: $scope.search
					},
						{
						total: data.length,
						getData: function ($defer, params) {
							var filteredData = params.filter().term ?
								$filter('filter')(data, params.filter().term)
								: data;

							params.total(filteredData.length);
							$defer.resolve(filteredData.slice((params.page() - 1)
								* params.count(), params.page() * params.count()));
						} 
					});
				},
				function (error) {
					svvTunnelRepository.growl(error, 'danger');
				}
			);
		}

		$scope.selectRow = function(lookupResultRow) {
			$scope.selectedLookupResult = _.find($scope.equipmentLookup.LookupResults, function(lookupResult) {
				return lookupResultRow.NvdbObjekt.Id === lookupResult.NvdbObjekt.Id;
			});
		};

		$scope.isSelected = function (id) {
			if (!$scope.selectedLookupResult) return false;
			return $scope.selectedLookupResult.NvdbObjekt.Id === id;
		};

		$scope.getProperty = function (propertyName, nvdbObjekt) {
			var property = _.find(nvdbObjekt.Egenskaper, { "Navn": propertyName });
			if (property) return property.Verdi;
			return "";
		};

		$scope.toggleDetails = function() {
			$scope.isTableView = !$scope.isTableView;
			$scope.isDetailsView = !$scope.isDetailsView;
		};

		$scope.canSave = function() {
			if ($scope.selectedLookupResult) return true;
		};

		$scope.saveAction = function () {
			$scope.model.NvdbObjekt = $scope.selectedLookupResult.NvdbObjekt;

			svvTunnelRepository.post('nvdbEquipmentLookup', $scope.model).then(
				function (response) {
					$modalInstance.close(response.data);
				},
				function(error) {
					svvTunnelRepository.growl(error, 'danger');
				}
			);
		};

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

(function () {

	var app = angular.module('Plania');

	app.directive('nvdbInformation', function () {
		return {
			restrict: 'E',
			scope: {
				nvdbId: '=nvdbId',
				objectType: '=objectType'
			},
			controller: ['$scope', 'svvTunnelRepository', '$modal', controller],
			templateUrl: 'customizations/10088/nvdbInformation.html'
		};
	});

	function controller(scope, svvTunnelRepository, $modal) {
		scope.model = {};

		function fetchFromNvdb() {
			svvTunnelRepository.get('nvdbcard/' + scope.nvdbId, {}).then(function (result) {
				if (result.status === 200) {
					scope.model.nvdbEntity = result.data;
					scope.nvdbTypeId = result.data.Metadata.Type.Id;
				} else {
					scope.errorMessage = result.data.message;
				}
			});

			svvTunnelRepository.get('nvdbcard/syncinfo/' + scope.nvdbId, {}).then(function (result) {
				scope.model.syncInformation = result.data;
			});
		}

		if (scope.nvdbId) {
			fetchFromNvdb();
		}

		scope.$watch('nvdbId', function (newValue, oldValue) {
			if (newValue === oldValue) return;
			if (!newValue) return;

			fetchFromNvdb();
		});

		scope.synchronizeEnitity = function () {
			var syncAction = scope.objectType;
			var url = 'nvdbcard/sync/' + scope.nvdbId + '/' + scope.nvdbTypeId + '/' + syncAction;

			svvTunnelRepository.put(url, {}).then(function(result) {
				svvTunnelRepository.growl('Synkronisering fullført, oppdater siden for å hente nyeste data', 'success');
			});
		};

		scope.synchronizeChildren = function () {
			var syncAction = 'EquipmentHierarchy';
			var url = 'nvdbcard/sync/' + scope.nvdbId + '/' + scope.nvdbTypeId + '/' + syncAction;
			swal({
				title: 'Synkronisering av anleggshierarki',
				text: 'Synkronisering kan ta lang tid og vil bli utført i bakgrunnen, se logg for status',
				type: 'warning',
				showCancelButton: true,
				closeOnConfirm: false
			}, function () {
				svvTunnelRepository.put(url, {}).then(function (result) {
					swal('Synkronisering startet', '', "success");
				});
			});
		};

		scope.openChangeSetModal = function() {
			$modal.open({
				templateUrl: 'customizations/10088/nvdbChangeSetModal.html',
				size: 'xl',
				controller: 'NvdbChangeSetModalController',
				resolve: {
					params: function () {
						return {
							nvdbId: scope.model.nvdbEntity.Id,
							nvdbTypeId: scope.model.nvdbEntity.Metadata.Type.Id
						};
					}
				}
			}).result.then(function (result) {
			}, function () {
				//cancel
			});
		};
	}
})();

(function () {
	angular.module('Plania').controller('propertyMappingController', ['$scope', 'svvTunnelRepository', 'CommonService', 'ngTableParams', '$modal', controller]);

	function controller($scope, svvTunnelRepository, commonService, ngTableParams, $modal) {

		$scope.categories = [
			{ prefix: 'Estate', title: 'Eiendommer' },
			{ prefix: 'Building', title: 'Bygninger' },
			{ prefix: 'Equipment', title: 'Anlegg' }
		];

		$scope.onCategorySelected = function () {
			svvTunnelRepository.get('propertymappingtypes/' + $scope.selectedCategory.prefix, {}).then(
				function(response) {
					if (response.data) {
						$scope.objectTypes = response.data;
						$scope.objectTypes.unshift({ ObjectTypeName: 'Alle', PlaniaGuid: null });
					}
				});
		};

		$scope.nvdbPropertyMappingTable = null;

		$scope.onObjectTypeSelected = function () {
			if ($scope.selectedObjectType === null) return;

			if ($scope.nvdbPropertyMappingTable) {
				$scope.nvdbPropertyMappingTable.reload();
			} else {
				$scope.nvdbPropertyMappingTable = new ngTableParams({
						sorting: { Category: 'asc' },
						filter: { searchString: '' }
					},
					{
						getData: function ($defer, params) {

							var url = 'PropertyMapping' +
								'?CategoryPrefix=' +
								$scope.selectedCategory.prefix;

							if ($scope.selectedObjectType.PlaniaGuid) {
								url = url + '&CategoryPlaniaGuid=' + $scope.selectedObjectType.PlaniaGuid;
							}

							if ($scope.showOnlyDifferent === true) {
								url = url + '&OnlyDifferent=' + $scope.showOnlyDifferent;
							}

							svvTunnelRepository.get(url, {}).then(function (response) {
									$defer.resolve(response.data);
								},
								function (error) {
									svvTunnelRepository.growl(error, 'danger');
								});
						}
					}
				);
			}
		};

		$scope.addNewMappingdisabled = function () {
			if ($scope.selectedObjectType && $scope.selectedObjectType.ObjectTypeName !== 'Alle') {
				return false;
			}
			return true;
		}

		$scope.onShowOnlyDifferentSelected = function () {
			if ($scope.nvdbPropertyMappingTable) {
				$scope.nvdbPropertyMappingTable.reload();
			}
		};

		$scope.updateMapping = function (row) {
			svvTunnelRepository.put('PropertyMapping?action=fixlabel', row).then(function (response) {
				$scope.nvdbPropertyMappingTable.reload();
				svvTunnelRepository.growl('Egenskapsmapping oppdatert', 'success');
			}, function (error) {
				svvTunnelRepository.growl(error, 'danger');
			});
		};

		$scope.disableMapping = function (row) {
			svvTunnelRepository.put('PropertyMapping?action=disable', row).then(function(response) {
				$scope.nvdbPropertyMappingTable.reload();
				svvTunnelRepository.growl('Egenskapsmapping oppdatert', 'success');
			}, function (error) {
				svvTunnelRepository.growl(error, 'danger');
			});
		};

		$scope.deleteMapping = function (row) {
			svvTunnelRepository.delete('PropertyMapping', row).then(function(response) {
				$scope.nvdbPropertyMappingTable.reload();
				svvTunnelRepository.growl('Egenskapsmapping slettet', 'success');
			}, function(error) {
				svvTunnelRepository.growl(error, 'danger');
			});
		};

		$scope.addNewMapping = function () {
			$modal.open({
				templateUrl: 'customizations/10088/addPropertyMappingModal.html',
				controller: 'addPropertyMappingController',
				resolve: {
					params: function() {
						return {
							Category: $scope.selectedCategory,
							ObjectType: $scope.selectedObjectType
						};
					}
				}
			}).result.then(function (result) {
				if (result === 'saved') {
					$scope.nvdbPropertyMappingTable.reload();
				}
			});
		};
	}
})();
(function () {

	angular.module('Plania').config([
		'$provide', function ($provide) {

			$provide.decorator('Repository', [
				'$delegate', function ($delegate) {
					var service = $delegate;

					service.getFilter = function (filter) {

						var tmpFilter = _.clone(filter) || {};
						tmpFilter.GuidBuilding = '';
						tmpFilter.GuidSelection = '';
						tmpFilter.GuidDataOwner = '';
						tmpFilter.GuidEstate = '';

						if (tmpFilter.isBuildingDependent !== false)
							tmpFilter.isBuildingDependent = true;

						if (service.commonService.getFilterData().selectedBuilding.Guid && tmpFilter.isBuildingDependent && !tmpFilter.excludeBuilding) tmpFilter.GuidBuilding = service.commonService.getFilterData().selectedBuilding.Guid;
						if (service.commonService.getFilterData().selectedSelection.Guid) tmpFilter.GuidSelection = service.commonService.getFilterData().selectedSelection.Guid;
						if (service.commonService.getFilterData().selectedDataOwner.Guid) tmpFilter.GuidDataOwner = service.commonService.getFilterData().selectedDataOwner.Guid;
						if (service.commonService.getFilterData().selectedEstate.Guid) tmpFilter.GuidEstate = service.commonService.getFilterData().selectedEstate.Guid;

						return tmpFilter;
					};


					service.filterKeyWords = [
						'@GuidLoggedInPerson',
						"@GuidLoggedInPersonDepartment",
						'@GuidLoggedInPersonResourceGroup',
						'@GuidUser',
						'@GuidUserCustomer',
						'@GuidCurrentBuilding',
						'@GuidSupplier',
						'@GuidCurrentProperty' //svv specific , rest is standard
					];

					service.prefillKeyWords = [
						'@LoggedInPerson',
						'@User',
						'@CurrentBuilding',
						'@UserSupplier',
						'@UserCustomer',
						'@GuidCurrentProperty' //svv specific, rest is standard
					];

					service.GetKeywordValue = function (value) {
						if (angular.isUndefined(value) || value === null) return "";

						value = value.toString().replace('@GuidUserCustomer', service.authService.getUserData().guidCustomer);
						value = value.toString().replace('@GuidUser', service.authService.getUserData().guidUser);
						value = value.toString().replace('@GuidLoggedInPersonDepartment', service.authService.getUserData().guidPersonDepartment);
						value = value.toString().replace('@GuidLoggedInPersonResourceGroup', service.authService.getUserData().guidPersonResourceGroup);
						value = value.toString().replace('@GuidLoggedInPerson', service.authService.getUserData().guidPerson);
						value = value.toString().replace('@Today', moment().utc().startOf('day').hours(0).toISOString());
						value = value.toString().replace('@Month', moment().utc().subtract(1, 'month').toISOString());
						value = value.toString().replace('@Year', moment().utc().subtract(1, 'year').toISOString());
						value = value.toString().replace('@CurrentYear', moment().utc().startOf('year').toISOString());
						if (service.commonService.getFilterData().selectedBuilding && service.commonService.getFilterData().selectedBuilding.Guid !== "") {
							value = value.toString().replace('@GuidCurrentBuilding', service.commonService.getFilterData().selectedBuilding.Guid);
						}
						if (service.authService.getUserData().guidSupplier) {
							value = value.toString().replace('@GuidSupplier', service.authService.getUserData().guidSupplier);
						} else {
							value = value.toString().replace('@GuidSupplier', '');
						}

						//svv specific
						value = value.toString().replace("@GuidCurrentProperty",
							service.commonService.getFilterData().selectedEstate.Guid);

						return value;
					};

					return service;
				}]);
		}
	]);

})();

(function() {
	var app = angular.module('Plania');

	app.config([
		'$stateProvider', function(stateProvider) {

			stateProvider.state({
				name: 'SyncInformation',
				url: '/syncInformation',
				templateUrl: 'customizations/10088/syncInformation.html',
				controller: 'syncInformationController',
				backNavigation: true
			});

			stateProvider.state({
				name: 'nvdbEquipment',
				url: '/nvdbEquipment',
				templateUrl: 'customizations/10088/nvdbEquipment.html',
				controller: 'nvdbEquipmentController',
				backNavigation: true
			});

			stateProvider.state({
				name: 'propertyMapping',
				url: '/propertyMapping',
				templateUrl: 'customizations/10088/propertyMapping.html',
				controller: 'propertyMappingController',
				backNavigation: true
			});

			stateProvider.state({
				name: 'changeSetList',
				url: '/changeSetList',
				templateUrl: 'customizations/10088/nvdbChangeSetList.html',
				controller: 'NvdbChangeSetListController',
				backNavigation: true
			});
		}
	]);
})();

(function () {
	angular.module('Plania').controller('SelectedEstateController', ['$scope', '$rootScope', 'Repository', controller]);

	function controller($scope, $rootScope, repository) {
		$scope.filter = {};
		$scope.totalCount = 0;
		$scope.count = 30;
		$scope.estates = [];

		$scope.selectedEstate = repository.commonService.getFilterData().selectedEstate;

		$scope.getEstates = function () {
			var storedSelection = repository.commonService.getFilterData().selectedSelection;
			if (storedSelection.Guid)
				$scope.filter.LimitEstatesOnBuildingSelection = storedSelection.Guid ? true : false;

			repository.GetPaginated(repository.apiData.estate.url, 0, $scope.count, { id: "asc" }, $scope.filter).then(function (result) {
				$scope.estates = result.List;
				$scope.totalCount = result.TotalCount;
			}, function (error) {
				$scope.$emit($scope.events.newToast, { message: error, type: 'error' });
			});
		}

		$scope.getEstates();

		$scope.addMoreData = function () {
			$scope.count += 100;
			$scope.getEstates();
		};

		var guidSelectedDataowner = repository.commonService.getFilterData().selectedDataOwner.Guid;

		$scope.changeEstate = function (selected) {
			repository.commonService.setEstate(selected);
			$rootScope.$broadcast($rootScope.events.newSelection, true, true);
		}

		$scope.setEmptyEstate = function () {
			repository.commonService.setEmptyEstate();
			repository.commonService.setEmptyBuilding();
			$rootScope.$broadcast($rootScope.events.newSelection, true, true);
		}

		$scope.$on($scope.events.newSelection, function () {
			if (guidSelectedDataowner !== repository.commonService.getFilterData().selectedDataOwner.Guid) {
				guidSelectedDataowner = repository.commonService.getFilterData().selectedDataOwner.Guid;
				repository.commonService.setEmptyEstate();
			}
			$scope.selectedEstate = repository.commonService.getFilterData().selectedEstate;
			$scope.getEstates();
		});
	}
})();

(function () {
	angular.module('Plania').factory('svvTunnelRepository', ['$http', 'config', 'authService', 'growlService', '$cacheFactory', '$q', svvTunnelRepository]);

	function svvTunnelRepository($http, config, authService, growlService, $cacheFactory, $q) {
		var cache = $cacheFactory('svvTunnelRepositoryHttpOnce');

		var httpConfig = function (relativeUrl, method, data) {
			return authService.refreshAuthentication().then(function (result) {
				return {
					method: method,
					url: encodeURI(config.baseUrl + 'svvtunnel/' + relativeUrl),
					headers: {
						'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
					},
					data: jQuery.param(data)
				};
			});
		};

		var getCall = function (relativeUrl) {
			var deferred = $q.defer();
			handleGet(relativeUrl)
				.then(function (apiResponse) {
					var result = apiResponse;

					if (apiResponse.status === 200) {
						deferred.resolve(result);
					} else {
						deferred.reject(getErrorMessageFromStatus(apiResponse.status, result));
					}
				}, function (error) {
					deferred.reject(error);
				});
			return deferred.promise;
		};

		function handleGet(relativeUrl) {
			return httpConfig(relativeUrl, 'GET', {}).then(function (result) {
				var promise = cache.get(relativeUrl);
				if (promise && promise.$$state.status === 0) {
					// return any pending promises for the same URL
					return promise;
				}
				return cache.put(relativeUrl, $http(result));
			});
		};

		function postCall(relativeUrl, data) {
			var deferred = $q.defer();
			handlePost(relativeUrl, data)
				.then(function (apiResponse) {
					var result = apiResponse;

					if (apiResponse.status === 200) {
						deferred.resolve(result);
					} else {
						deferred.reject(getErrorMessageFromStatus(apiResponse.status, result));
					}
				}, function (error) {
					deferred.reject(error);
				});
			return deferred.promise;
		};

		function handlePost(relativeUrl, data) {
			return httpConfig(relativeUrl, 'POST', data)
				.then(function (result) {
					return $http(result);
				});
		};

		function putCall(relativeUrl, data) {
			var deferred = $q.defer();
			handlePut(relativeUrl, data)
				.then(function (apiResponse) {
					var result = apiResponse;

					if (apiResponse.status === 200) {
						deferred.resolve(result);
					} else {
						deferred.reject(getErrorMessageFromStatus(apiResponse.status, result));
					}
				}, function (error) {
					deferred.reject(error);
				});
			return deferred.promise;
		};

		function handlePut (relativeUrl, data) {
			return httpConfig(relativeUrl, 'PUT', data)
				.then(function (result) {
					return $http(result);
				});
		};

		function deleteCall(relativeUrl, data) {
			var deferred = $q.defer();
			handleDelete(relativeUrl, data)
				.then(function (apiResponse) {
					var result = apiResponse;

					if (apiResponse.status === 200) {
						deferred.resolve(result);
					} else {
						deferred.reject(getErrorMessageFromStatus(apiResponse.status, result));
					}
				}, function (error) {
					deferred.reject(error);
				});
			return deferred.promise;
		};

		function handleDelete (relativeUrl, data) {
			return httpConfig(relativeUrl, 'DELETE', data)
				.then(function (result) {
					return $http(result);
				});
		};

		var growl = function (message, type) {
			growlService.growl(message, type, { enter: 'animated fadeInRight', exit: 'animated fadeOutRight' });
		}

		function getStringFromErrorObject(error) {
			if (error && typeof error === 'object') {
				if (error.message && error.message !== "") {
					return error.message;
				}
				if (error.data && typeof error.data === 'string') {
					return error.data;
				}
				if (error.data && Array.isArray(error.data)) {
					return error.data;
				}
				if (error.data.message && typeof error.data.message === 'string')
					return error.data.message;
			}
			return error;
		};

		function getErrorMessageFromStatus(status, error) {
			var message = getStringFromErrorObject(error);
			if (typeof message === 'string' && message.length > 0) {
				return message;
			}

			if (Array.isArray(message)) {
				return message;
			}

			switch (status) {
				case 401:
					return authService.getUserData().isAuthenticated ? "Mangler tilgang" : "Du må logge inn for å se denne informasjonen";
				case 404:
					return "Ingen data funnet";
				case 409:
					return "Konflikt i Api";
				default:
					return "Ukjent feil oppstod. Http status kode: " + status;
			}
		};


		return {
			get: getCall,
			post: postCall,
			put: putCall,
			delete: deleteCall,
			growl: growl
		};
	}
})();

(function () {
	angular.module('Plania').controller('syncInformationController', ['$scope', 'svvTunnelRepository', 'ngTableParams', controller]);

	function controller($scope, svvTunnelRepository, ngTableParams) {
		var nvdbApiUrl = 'SyncInformation';

		$scope.nvdbTable = new ngTableParams({
			page: 1,
			count: 10,
			sorting: { Guid: 'asc' },
			filter: { searchString: '' }
		},
			{
				total: 0,
				counts: [10, 20, 50],
				filterDelay: 10,
				getData: function ($defer, params) {

					var url = nvdbApiUrl +
						'?page=' +
						(params.page() - 1) +
						'&pageSize=' +
						params.count() +
						'&search=' +
						params.filter().searchString +
						'&action=syncInformations';

					svvTunnelRepository.get(url, {}).then(function (response) {
						var result = response.data;
						$scope.nvdbTable.settings().total = result.TotalCount;
						$defer.resolve(result.List);
					},
						function (error) {
							svvTunnelRepository.growl(error, 'danger');
						});
				}
			});


	}
})();
//# sourceMappingURL=custom.js.map