ing-web-es 1.0.0

package/start.ingbusiness.pl/scripts/data-gemius-event.js

@@ -0,0 +1,119 @@
+'use strict';
+
+angular.module('commons').directive('gemiusEvent', ['$injector', '$rootScope', function($injector, $rootScope) {
+
+    var CHARACTER_LIMIT_FOR_GEMIUS = 60;
+    var PARAM_NAMES = {
+        GEMIUS_PARAMS_PREFIX: 'parGemiusParam',
+        REPLACE_BR_TAGS_WITH_SPACES: 'parGemiusRemoveBreaks'
+    };
+
+    var filteringFunctions = {
+        normalize: function(str) {
+            return $injector.has('stringUtils') ? $injector.get('stringUtils').removeAccents(str) : str;
+        },
+        replaceBrTagsWithSpaces: function(str) {
+            return str.replace(/<br\/>-/g, ' ');
+        },
+        cut: function(str) {
+            return str.length <= CHARACTER_LIMIT_FOR_GEMIUS ? str : str.substring(0, CHARACTER_LIMIT_FOR_GEMIUS);
+        }
+    };
+
+    var GemiusParam = function(attrName, attrValue, filterFunctions) {
+        var filteredValue = attrValue;
+        for (var i = 0; i < filterFunctions.length; i++) {
+            var filter = filterFunctions[i];
+            filteredValue = filter(filteredValue);
+        }
+        this.gemiusString = attrName + '=' + filteredValue;
+    };
+
+    var resolveGemiusParameter = function(attrName, attrs, filterFunctions) {
+        if (!attrs.hasOwnProperty(attrName) || attrName.indexOf(PARAM_NAMES.GEMIUS_PARAMS_PREFIX) !== 0) {
+            return null;
+        }
+        return new GemiusParam(attrName.substring(PARAM_NAMES.GEMIUS_PARAMS_PREFIX.length), attrs[attrName], filterFunctions);
+    };
+
+    var resolveFilterFunctions = function(attributes) {
+        var filters = [];
+        filters.push(filteringFunctions.normalize);
+        if (attributes.hasOwnProperty(PARAM_NAMES.REPLACE_BR_TAGS_WITH_SPACES)) {
+            filters.push(filteringFunctions.replaceBrTagsWithSpaces)
+        }
+        filters.push(filteringFunctions.cut);
+        return filters;
+    };
+
+    var resolveGemiusParameters = function(attrs) {
+        var filterFunctions = resolveFilterFunctions(attrs);
+        var gemiusParameters = [];
+        for (var attrName in attrs) {
+            var gemiusParameter = resolveGemiusParameter(attrName, attrs, filterFunctions);
+            if (gemiusParameter != null) {
+                gemiusParameters.push(gemiusParameter.gemiusString);
+            }
+        }
+        return gemiusParameters;
+    };
+
+    return {
+        link: function($scope, $element, $attributes) {
+            if (!$injector.has('gemiusService') || $injector.get('gemiusService').isGemiusLoggingEnabled()) {
+                var event = $attributes.gemiusEvent;
+                var directiveParameters = $scope.$eval($attributes.gemiusParameters);
+                if (directiveParameters == null) {
+                    directiveParameters = resolveGemiusParameters($attributes);
+                }
+                var directiveTimingParameter = $attributes.gemiusTimingParameter;
+                var directiveRequestIntervalParameter = $attributes.gemiusRequestIntervalParameter;
+                $attributes.$observe('gemiusParameters', function(newValue) {
+                    if (newValue) {
+                        directiveParameters = $scope.$eval(newValue);
+                    }
+                });
+                var enterElementTime = 0;
+                if (event.match(/^mouseover|mouseenter$/)) {
+                    $element.on(event, function() {
+                        enterElementTime = new Date();
+                    });
+                    event = 'mouseleave';
+                }
+                $element.on(event, function() {
+                    if (directiveParameters) {
+                        if (event === 'mouseleave') {
+                            if (new Date() - enterElementTime < 200) {
+                                return;
+                            }
+                        }
+                        replaceSpacesWithUnderLine(directiveParameters);
+                        var params = directiveParameters.slice();
+                        if (directiveTimingParameter) {
+                            directiveTimingParameter = $injector.has('stringUtils') ? $injector.get('stringUtils').removeAccents(directiveTimingParameter)
+                                .replace(/ /g, '_').toLowerCase() : directiveTimingParameter.replace(/ /g, '_').toLowerCase();
+                            params.push('timing_start=' + directiveTimingParameter);
+                            params.push('timing_time=' + new Date().getTime());
+                            var finishParameters = {
+                                eventName: directiveTimingParameter,
+                                requestInterval: directiveRequestIntervalParameter
+                            };
+                            $rootScope.clickedElementId = directiveTimingParameter;
+                            $rootScope.gemiusTimingEvents = [];
+                            $rootScope.gemiusTimingEvents[directiveTimingParameter] = finishParameters;
+                        }
+                        params.unshift('_action_', getGemiusID());
+                        gemius_event.apply(null, params);
+                    }
+                });
+            }
+
+            function replaceSpacesWithUnderLine(directiveParameters) {
+                for (var i = 0; i < directiveParameters.length; i++) {
+                    directiveParameters[i] = $injector.has('stringUtils') ? $injector.get('stringUtils').removeAccents(directiveParameters[i])
+                        .replace(/ /g, '_').toLowerCase() : directiveParameters[i].replace(/ /g, '_').toLowerCase();
+                }
+            }
+        }
+    };
+}]);

package/start.ingbusiness.pl/scripts/dir-critical-message.js

@@ -0,0 +1,9 @@
+loginApp.directive('dirCriticalMessage', [function() {
+    return {
+        restrict: 'E',
+        templateUrl: 'dir-critical-message/dir-critical-message.html?v=202110040949',
+        controller: ['$scope', 'criticalMessageService', function($scope, criticalMessageService) {
+            $scope.criticalMessageService = criticalMessageService;
+        }]
+    };
+}]);

package/start.ingbusiness.pl/scripts/dir-help-panel-content.js

@@ -0,0 +1,29 @@
+loginApp.directive('dirHelpPanelContent', ['helpPanelService', 'helpPanelPasswordService', '$rootScope', function(helpPanelService, helpPanelPasswordService, $rootScope) {
+    $rootScope.$on('$stateChangeSuccess',
+        function(event, toState, toParams, fromState, fromParams) {
+            helpPanelService.additionalStyleClass = null;
+            if (!helpPanelService.hideInformationHolder && shouldClosePanel()) {
+                helpPanelService.hideHelpPanel();
+            }
+
+            function shouldClosePanel() {
+                if (toState.params && toState.params.navLinks) {
+                    if (helpPanelService.showFirstLoginHelp) {
+                        return !toState.params.navLinks.showFirstLogin;
+                    } else if (helpPanelService.isForgotLoginHelpPanel()) {
+                        return !toState.params.navLinks.showForgotLogin;
+                    }
+                }
+                return true;
+            }
+        });
+
+    return {
+        restrict: 'E',
+        templateUrl: 'dir-help-panel-content/dir-help-panel-content.html?v=202110040949',
+        controller: ['$scope', function($scope) {
+            $scope.helpPanelService = helpPanelService;
+            $scope.helpPanelPasswordService = helpPanelPasswordService;
+        }]
+    };
+}]);

package/start.ingbusiness.pl/scripts/dir-login-keyboard.js

@@ -0,0 +1,346 @@
+'use strict';
+
+loginApp
+    .directive(
+        'dirLoginKeyboard',
+        [
+            '$document',
+            '$timeout',
+            function($document, $timeout) {
+                return {
+                    restrict: 'A',
+                    templateUrl: 'dir-login-keyboard/dir-login-keyboard.html?v=202110040949',
+                    link: function(scope, element) {
+
+                        var maskPage = false,
+                            certPassPage = false,
+                            changePassPage = false,
+                            x = 0,
+                            y = 0,
+                            inputField = null,
+                            temp_tabindex = 1,
+                            moveX = 0,
+                            startPos = 0,
+                            ctl = null,
+                            tabindex = 0;
+
+                        scope.isShiftEnabled = false;
+                        scope.uppercase = false;
+                        scope.uppercaseCaps = false;
+                        scope.isAltEnabled = false;
+                        var keyboardEventsBound = false;
+
+                        scope.openDefaultKeyboard = function($event, tabindex, gemiusDefaultParameters) {
+                            var gemiusParamsCloseKeyboard = gemiusDefaultParameters.concat(['klawiatura_ekranowa=zamknij', 'metoda=onclick']);
+                            var gemiusParamsUseKeyboard = gemiusDefaultParameters.concat(['klawiatura_ekranowa=uzyj', 'metoda=onclick']);
+                            scope.openKeyboard($event, tabindex, gemiusParamsCloseKeyboard, gemiusParamsUseKeyboard);
+                        };
+
+                        scope.openKeyboard = function($event, tabindex, gemiusParametersCloseButton, gemiusParametersUseKeyboard) {
+                            if (!keyboardEventsBound) {
+                                bindLoginKeyboardEvents();
+                                keyboardEventsBound = true;
+                            }
+
+                            scope.gemiusParametersCloseButton = gemiusParametersCloseButton;
+                            scope.gemiusParametersUseKeyboard = gemiusParametersUseKeyboard;
+                            jumpToView(tabindex);
+                            $event.stopPropagation();
+                            if (maskPage && (startPos !== 0)) {
+                                startPos++;
+                                tabindex = startPos;
+                            }
+                            inputField = angular.element('input[tabindex=' + tabindex + ']');
+                            inputField.focus();
+                        };
+
+                        scope.openMaskKeyboard = function($event, gemiusDefaultKeyboardParams) {
+                            maskPage = true;
+                            scope.openDefaultKeyboard($event, 1, gemiusDefaultKeyboardParams);
+                        };
+
+                        scope.openChangePassKeyboard = function($event, tabindex, gemiusParametersCloseButton, gemiusParametersUseKeyboard) {
+                            changePassPage = true;
+                            scope.openKeyboard($event, tabindex, gemiusParametersCloseButton, gemiusParametersUseKeyboard);
+                        };
+
+                        scope.openCertPassKeyboard = function($event, tabindex, gemiusParametersCloseButton, gemiusParametersUseKeyboard) {
+                            certPassPage = true;
+                            scope.openKeyboard($event, tabindex, gemiusParametersCloseButton, gemiusParametersUseKeyboard);
+                        };
+
+                        scope.openAdministrationKeyboard = function($event, tabindex, moveXParameter) {
+                            moveX = moveXParameter;
+                            scope.openKeyboard($event, tabindex);
+                        };
+
+                        scope.closeKeyboard = function() {
+                            scope.toogleKeyboard = false;
+                            inputField = null;
+                        };
+
+                        scope.inputChange = function($event) {
+                            inputField = angular.element($event.currentTarget);
+                        };
+
+                        function bindLoginKeyboardEvents() {
+                            angular.element('input').on('focus', function($event) {
+                                inputField = angular.element($event.currentTarget);
+                                ctl = $event.currentTarget;
+                                startPos = ctl.selectionStart;
+                            });
+
+                            angular.element('input').on('click', function($event) {
+                                ctl = $event.currentTarget;
+                                startPos = ctl.selectionStart;
+                            });
+                        }
+
+                        scope.holderClicked = function() {
+                            if (inputField != null && !maskPage) {
+                                inputField.focus();
+                            }
+                        };
+
+                        scope.keyboardClickForGemiuse = function() {
+                            if (scope.gemiusParametersUseKeyboard) {
+                                var parameters = ['_action_', getGemiusID()];
+                                gemius_event.apply(null, parameters.concat(scope.gemiusParametersUseKeyboard.toString().split(',')));
+                            }
+                        };
+
+                        scope.keyClicked = function($event) {
+                            var el = angular.element($event.currentTarget),
+                                character = '';
+                            scope.keyboardClickForGemiuse();
+                            isManipulationOnKeyboardKeys($event);
+                            fillCharacter(el, character);
+                        };
+
+                        function isManipulationOnKeyboardKeys($event) {
+                            var el = angular.element($event.currentTarget);
+                            if (el.hasClass('return')) {
+                                $event.stopPropagation();
+                                $timeout(function() {
+                                    angular.element('.submit-btn').triggerHandler('click');
+                                }, 0);
+                            }
+
+                            if (el.hasClass('right-shift') || el.hasClass('left-shift')) {
+                                scope.isShiftEnabled = !scope.isShiftEnabled;
+                                scope.uppercase = !scope.uppercase;
+                            }
+
+                            if (el.hasClass('capslock')) {
+                                scope.uppercaseCaps = !scope.uppercaseCaps;
+                            }
+
+                            if (el.hasClass('left-alt') || el.hasClass('right-alt')) {
+                                scope.isAltEnabled = !scope.isAltEnabled;
+                            }
+
+                            if (el.hasClass('letter') || el.hasClass('symbol')) {
+                                scope.isShiftEnabled = false;
+                                scope.uppercase = false;
+                                scope.isAltEnabled = false;
+                            }
+                        }
+
+                        function fillCharacter(el, character) {
+                            character = readCharacter(el, character);
+                            if (character === '') {
+                                return;
+                            }
+                            if (el.hasClass('uppercase')) {
+                                character = character.toUpperCase();
+                            }
+
+                            insertCharacter(character);
+                        }
+
+                        function readCharacter(el, character) {
+                            if (el.hasClass('letter') || el.hasClass('symbol')) {
+                                return el.find('span:visible').text();
+                            } else if (el.hasClass('space')) {
+                                return ' ';
+                            } else if (el.hasClass('tab')) {
+                                return '';
+                            } else {
+                                return character;
+                            }
+                        }
+
+                        function insertCharacter(character) {
+                            var newInputValue;
+                            var newCaretPosition = null;
+                            if (maskPage) {
+                                newInputValue = character;
+                            } else {
+                                var maxlength = inputField.attr('maxlength');
+                                if (maxlength && inputField.val().length == maxlength) {
+                                    newInputValue = inputField.val();
+                                } else {
+                                    var str = inputField.val();
+                                    var caretPosition = getCaretPosition();
+                                    newCaretPosition = caretPosition + 1;
+                                    newInputValue = str.substr(0, caretPosition) + character + str.substr(caretPosition);
+                                    startPos = newCaretPosition;
+                                    tabindex = startPos;
+                                }
+                            }
+                            inputField.val(newInputValue);
+                            if (newCaretPosition) {
+                                setCaretPosition(newCaretPosition);
+                            }
+                            inputField.trigger('change');
+                        }
+
+                        function setCaretPosition(newCaretPosition) {
+                            inputField[0].setSelectionRange(newCaretPosition, newCaretPosition);
+                        }
+
+                        scope.pressDeleteKey = function() {
+                            var value = inputField.val();
+                            scope.keyboardClickForGemiuse();
+
+                            if (maskPage) {
+                                var tabindex = inputField.attr('tabindex');
+                                --tabindex;
+                                if (tabindex < 1) {
+                                    tabindex = 1;
+                                }
+                                startPos = tabindex;
+                                if (value !== "") {
+                                    inputField.val('');
+                                    inputField.trigger('change');
+                                } else {
+                                    inputField = angular.element('input[tabindex=' + tabindex + ']');
+                                    inputField.val('');
+                                    inputField.trigger('change');
+                                    inputField.focus();
+                                    var field = getModelField(inputField);
+                                    field.fieldValueDeleted = false;
+                                }
+                            } else {
+                                var caretPosition = getCaretPosition();
+                                var newCaretPosition = caretPosition - 1;
+                                var part1 = value.substr(0, caretPosition - 1);
+                                var part2 = value.substr(caretPosition);
+                                startPos = newCaretPosition;
+                                inputField.val(part1 + part2);
+                                inputField.trigger('change');
+                                ctl.setSelectionRange(newCaretPosition, newCaretPosition);
+                            }
+                        };
+
+                        function getModelField(inputField) {
+                            var inputNumber = inputField.attr('id').match(/input(\d+)/)[1];
+                            return scope.maskFields[inputNumber - 1];
+                        }
+
+                        function isSpecial(el) {
+                            if (el.hasClass('left-alt') || el.hasClass('right-alt') ||
+                                el.hasClass('right-shift') || el.hasClass('left-shift') ||
+                                el.hasClass('capslock')) {
+                                return true;
+                            } else {
+                                return false;
+                            }
+                        }
+
+
+                        function getCaretPosition() {
+                            return inputField[0].selectionStart;
+                        }
+
+                        function checkInput(input) {
+                            var tabindex = input.attr('tabindex');
+                            if (temp_tabindex < tabindex) {
+                                temp_tabindex = tabindex;
+                            }
+                        }
+
+                        function focusInput(input, maskPage, el) {
+                            if (maskPage && !isSpecial(el)) {
+                                tabindex = input.attr('tabindex');
+                                ++tabindex;
+                                startPos = tabindex;
+
+                                input = angular.element('input[tabindex=' + tabindex + ']');
+                                if (input.attr('tabindex')) {
+                                    temp_tabindex = tabindex;
+                                } else {
+                                    input = angular.element('input[tabindex=' + temp_tabindex + ']');
+                                }
+                            }
+                            return input;
+                        }
+
+                        function jumpToView(tabindex) {
+                            var jumpTo;
+                            if (certPassPage) {
+                                jumpTo = angular.element('#certificate-instruction-text');
+                                certPassPage = false;
+                            } else {
+                                jumpTo = angular.element('#contentHolder');
+                            }
+
+                            angular.element('body,html').animate({
+                                'scrollTop': jumpTo.offset().top
+                            }, 200, 'linear', function() {
+                                initPosition(tabindex);
+                                scope.toogleKeyboard = true;
+                                scope.$apply();
+                            });
+                        }
+
+                        function initPosition(tabindex) {
+                            var elementPosition = angular.element('input[tabindex=' + tabindex + ']');
+                            var clientRect = elementPosition[0].getBoundingClientRect();
+
+                            if (maskPage) {
+                                x = clientRect.left;
+                                y = clientRect.top + 78;
+                            } else if (changePassPage && tabindex == 2) {
+                                x = clientRect.left;
+                                y = clientRect.top + 90;
+                            } else {
+                                x = clientRect.left;
+                                y = clientRect.top + 64;
+                            }
+
+                            element.css({
+                                top: y + 'px',
+                                left: (x + moveX) + 'px'
+                            });
+                        }
+
+                        (function() {
+                            var startX = 0,
+                                startY = 0;
+                            element.on('mousedown', function(event) {
+                                event.preventDefault();
+                                startX = event.pageX - x;
+                                startY = event.pageY - y;
+                                $document.on('mousemove', mousemove);
+                                $document.on('mouseup', mouseup);
+                            });
+
+                            function mousemove(event) {
+                                y = event.pageY - startY;
+                                x = event.pageX - startX;
+                                element.css({
+                                    top: y + 'px',
+                                    left: (x + moveX) + 'px'
+                                });
+                            }
+
+                            function mouseup() {
+                                $document.unbind('mousemove', mousemove);
+                                $document.unbind('mouseup', mouseup);
+                            }
+                        })();
+                    }
+                };
+            }
+        ]);

package/start.ingbusiness.pl/scripts/dir-login-validation.js

@@ -0,0 +1,20 @@
+loginApp.directive('dirLoginValidation', ['loginValidationService', function(loginValidationService) {
+    return {
+        restrict: 'E',
+        templateUrl: 'dir-login-validation/dir-login-validation.html?v=202110040949',
+        scope: {
+            modelName: '='
+        },
+        link: function(scope) {
+            scope.error = '';
+            scope.messageParams = {};
+
+            scope.$watch(function() {
+                return loginValidationService.getResult(scope.modelName).timestamp;
+            }, function() {
+                scope.error = loginValidationService.getResult(scope.modelName).error;
+                scope.messageParams = loginValidationService.getResult(scope.modelName).messageParams;
+            });
+        }
+    };
+}]);

package/start.ingbusiness.pl/scripts/dir-nav-links.js

@@ -0,0 +1,26 @@
+loginApp.directive('dirNavLinks', ['$state', 'helpPanelService', 'loginService', function($state, helpPanelService, loginService) {
+    return {
+        restrict: 'E',
+        templateUrl: 'dir-nav-links/dir-nav-links.html?v=202110040949',
+        link: function(scope) {
+            scope.goToUnlockScreen = function() {
+                $state.go('unlockUser');
+            };
+            scope.navLinks = $state.params.navLinks;
+            scope.smsReasonForGemius = $state.params.smsReasonForGemius ? $state.params.smsReasonForGemius : null;
+            scope.smsDailyNumber = $state.params.smsDailyNumber ? $state.params.smsDailyNumber : null;
+
+            scope.gemiusFirstLoginLinkParams = ['miejsce=' + scope.navLinks.gemiusParamMiejsce];
+            if (scope.navLinks.gemiusParamMiejsce == 'ekrany_logowania_podaj_sms') {
+                scope.gemiusFirstLoginLinkParams.push('powod_sms=' + scope.smsReasonForGemius, 'numer_sms=' + scope.smsDailyNumber);
+            }
+            scope.gemiusFirstLoginLinkParams.push('link=pierwsze_logowanie', 'metoda=onclick');
+
+            scope.helpPanelService = helpPanelService;
+
+            loginService.isTppLogin().then(function(result) {
+                scope.tppLogin = result;
+            });
+        }
+    };
+}]);

package/start.ingbusiness.pl/scripts/dir-title.js

@@ -0,0 +1,21 @@
+'use strict';
+
+loginApp.directive('dirTitle', ['$state', 'requestService', function($state, requestService) {
+    return {
+        restrict: 'E',
+        templateUrl: 'dir-title/dir-title.html?v=202110040949',
+        transclude: true,
+        scope: {
+            title: '=',
+            titleBoxClass: '@',
+            titleClass: '@',
+            gemiusParams: '='
+        },
+        link: function(scope) {
+            scope.backToAlias = function() {
+                requestService.abortPendingRequest();
+                $state.go('alias');
+            };
+        }
+    };
+}]);

package/start.ingbusiness.pl/scripts/gemius-init.js

@@ -0,0 +1,12 @@
+var gemius_identifier = '1vAwq2O5b1nIlHZtEIIo0HXWHXKZP0cSnzMNvIVEBtr.O7';
+
+function gemius_pending(i) {
+    window[i] = window[i] || function() {
+        var x = window[i + '_pdata'] = window[i + '_pdata'] || [];
+        x[x.length] = arguments;
+    };
+};
+gemius_pending('gemius_hit');
+gemius_pending('gemius_event');
+gemius_pending('pp_gemius_hit');
+gemius_pending('pp_gemius_event');

package/start.ingbusiness.pl/scripts/gemiusID.js

@@ -0,0 +1,32 @@
+'use strict';
+
+function getGemiusID() {
+    return '1vAwq2O5b1nIlHZtEIIo0HXWHXKZP0cSnzMNvIVEBtr.O7';
+};
+
+var gemiusStates = {
+    'loginError': 'błąd logowania',
+    'sessionExpired': 'sesja wygasła',
+    'certLoginAuth': 'logowanie certyfikatem',
+    'changePassword': 'zmiana hasła',
+    'loginAlias': 'logowanie - alias',
+    'maskLogin': 'logowanie hasło',
+    'mobileAuthorization': 'logowanie - autoryzacja mobilna',
+    'smsAuthorization': 'logowania - autoryzacja sms',
+    'unlockEToken1': 'odblokowanie certyfikatu - krok 1',
+    'unlockEToken2': 'odblokowanie certyfikatu - krok 2',
+    'unlockEToken3': 'odblokowanie certyfikatu - krok 3',
+    'unlockETokenError': 'błąd odblokowania certyfikatu',
+    'unlockUser': 'odblokowanie użytkownika',
+    'unlockUserResult': 'odblokowanie użytkownika - rezultat',
+    'logoutCert': 'wylogowanie - certyfikat',
+    'logoutSms': 'wylogowanie - sms',
+    'activateCertInsertSms': 'aktywacja certyfikatu - kod sms',
+    'activateCertSuccess': 'aktywacja certyfikatu - zakończona',
+    'activateCertTooManyErrors': 'aktywacja certyfikatu',
+    'activateNewCert': 'aktywacja certyfikatu',
+    'invalidateCertificate': 'Błąd generowania certyfikatu',
+    'newCert': 'generowanie certyfikatu do systemu ING',
+    'renewCert': 'odnowienie certyfikatu',
+    'starterKitLogin': 'generowanie certyfikatu do systemu ING'
+};