/* Minification failed. Returning unminified contents.
(13709,18-19): run-time error JS1300: Strict-mode does not allow assignment to undefined variables: i
(13709,40-41): run-time error JS1294: Strict-mode does not allow ++ or -- on certain objects: i
(9092,108-109): run-time error JS1013: Syntax error in regular expression: ,
(3495,62-75): run-time error JS1300: Strict-mode does not allow assignment to undefined variables: _selectedLand
 */
(function () {
    'use strict';

    angular.isUndefinedOrNull = function (input) {
        return angular.isUndefined(input) || input === null;
    };

    angular.isNullOrEmpty = function (input) {
        if (angular.isUndefinedOrNull(input)) return true;

        return input.length < 1;
    };

    angular.isNullOrWhitespace = function (input) {

        if (angular.isNullOrEmpty(input)) return true;

        if (angular.isString(input)) return input.replace(/\s/g, '').length < 1;

        return false;
    };

    var _AngularIsDate = angular.isDate;
    angular.isDate = function (date) {
        if (_AngularIsDate(date)) return true;
        return date instanceof moment && date.isValid();
    };

    angular.convertDateStringsToDates = function (input) {
        // Ignore things that aren't objects.
        if (typeof input !== "object") return input;

        for (var key in input) {
            if (!input.hasOwnProperty(key)) continue;

            var value = input[key];
            // Check for string properties which look like dates.
            if (typeof value === "string") {
                var result = Date.FromApi(value);
                if (angular.isDate(result)) input[key] = result;
            } else if (typeof value === "object") {
                // Recurse into object
                input[key] = angular.convertDateStringsToDates(value);
            }
        }

        return input;
    };

    angular.convertDatesToDateStrings = function (input) {
        // Ignore things that aren't objects.
        if (typeof input !== "object") return input;

        for (var key in input) {
            if (!input.hasOwnProperty(key)) continue;
            var value = input[key];
            if (value instanceof Date) {
                input[key] = value.toISOString();
            } else if (value instanceof moment) {
                input[key] = value.format('YYYY-MM-DDTHH:mm:ss.SSS');
            } else if (typeof value === "object") {
                // Recurse into object
                input[key] = angular.convertDatesToDateStrings(value);
            }
        }

        return input;
    };

    angular.utoa = function (str) {
        return window.btoa(unescape(encodeURIComponent(str)));
    };
    // base64 encoded ascii to ucs-2 string
    angular.atou = function (str) {
        return decodeURIComponent(escape(window.atob(str)));
    };

})();;
(function () {
    // Production steps of ECMA-262, Edition 5, 15.4.4.19
    // Reference: http://es5.github.io/#x15.4.4.19
    if (!Array.prototype.map) {
        Array.prototype.map = function (callback, thisArg) {

            var T, A, k;
            if (this == null) {
                throw new TypeError(' this is null or not defined');
            }

            // 1. Let O be the result of calling ToObject passing the |this| 
            //    value as the argument.
            var O = Object(this);

            // 2. Let lenValue be the result of calling the Get internal 
            //    method of O with the argument "length".
            // 3. Let len be ToUint32(lenValue).
            var len = O.length >>> 0;

            // 4. If IsCallable(callback) is false, throw a TypeError exception.
            // See: http://es5.github.com/#x9.11
            if (typeof callback !== 'function') {
                throw new TypeError(callback + ' is not a function');
            }

            // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
            if (arguments.length > 1) {
                T = thisArg;
            }

            // 6. Let A be a new array created as if by the expression new Array(len) 
            //    where Array is the standard built-in constructor with that name and 
            //    len is the value of len.
            A = new Array(len);

            // 7. Let k be 0
            k = 0;

            // 8. Repeat, while k < len
            while (k < len) {

                var kValue, mappedValue;

                // a. Let Pk be ToString(k).
                //   This is implicit for LHS operands of the in operator
                // b. Let kPresent be the result of calling the HasProperty internal 
                //    method of O with argument Pk.
                //   This step can be combined with c
                // c. If kPresent is true, then
                if (k in O) {

                    // i. Let kValue be the result of calling the Get internal 
                    //    method of O with argument Pk.
                    kValue = O[k];

                    // ii. Let mappedValue be the result of calling the Call internal 
                    //     method of callback with T as the this value and argument 
                    //     list containing kValue, k, and O.
                    mappedValue = callback.call(T, kValue, k, O);

                    // iii. Call the DefineOwnProperty internal method of A with arguments
                    // Pk, Property Descriptor
                    // { Value: mappedValue,
                    //   Writable: true,
                    //   Enumerable: true,
                    //   Configurable: true },
                    // and false.

                    // In browsers that support Object.defineProperty, use the following:
                    // Object.defineProperty(A, k, {
                    //   value: mappedValue,
                    //   writable: true,
                    //   enumerable: true,
                    //   configurable: true
                    // });

                    // For best browser support, use the following:
                    A[k] = mappedValue;
                }
                // d. Increase k by 1.
                k++;
            }

            // 9. return A
            return A;
        };
    }

    // Production steps of ECMA-262, Edition 5, 15.4.4.17
    // Reference: http://es5.github.io/#x15.4.4.17
    if (!Array.prototype.some) {
        Array.prototype.some = function (fun/*, thisArg*/) {
            'use strict';

            if (this == null) {
                throw new TypeError('Array.prototype.some called on null or undefined');
            }

            if (typeof fun !== 'function') {
                throw new TypeError();
            }

            var t = Object(this);
            var len = t.length >>> 0;

            var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
            for (var i = 0; i < len; i++) {
                if (i in t && fun.call(thisArg, t[i], i, t)) {
                    return true;
                }
            }

            return false;
        };
    }

    if (!Array.prototype.distinct) {
        Array.prototype.distinct = function () {
            var j = {};
            this.forEach(function (v) { j[v + '::' + typeof v] = v; });
            return Object.keys(j).map(function (v) { return j[v]; });
        };
    }
})();;
(function () {
    'use strict';

    moment.tz.setDefault("Europe/Brussels");
    moment.fn.toJSON = function () { return this.format(); };

    // Helper
    function pad(number) {
        if (number < 10) {
            return '0' + number;
        }
        return number;
    }

    // Statics
    Date.Now = function () {
        return moment();
    };

    Date.Today = function () {
        return moment().startOf('date');
    };

    Date.Tomorrow = function () {
        return Date.Today().add(1, 'd');
    };

    Date.Yesterday = function () {
        return Date.Today().subtract(1, 'd');
    };

    Date.FromMoment = function (date) {
        if (date instanceof moment && date.isValid())
            return new Date(date.format('YYYY-MM-DDTHH:mm:ss.SSS'));
        else
            return null;
    };

    Date.FromApi = function (dateString) {
        if (!angular.isString(dateString)) return dateString;

        // Try with formats
        var date = moment(dateString, [moment.ISO_8601, "DD-MM-YYYY HH:mm:ss", "YYYY-MM-DD HH:mm:ss"], true);
        if (date.isValid()) return date;

        // Give up
        return dateString;
    };

    // Aditions
    Date.prototype.compareDate = function (d) {
        if (this.getFullYear() !== d.getFullYear()) return this.getFullYear() - d.getFullYear();
        if (this.getMonth() !== d.getMonth()) return this.getMonth() - d.getMonth();
        return this.getDate() - d.getDate();
    };

    // Patches
    var _DatetoJSON = Date.prototype.toJSON;
    Date.prototype.toJSON = function () {
        try {
            return _DatetoJSON.call(this);
        } catch (e) {
            if (e instanceof RangeError) {
                return null;
            }
            throw e;
        }
    };

    Date.prototype.toISOString = function () {
        return this.getFullYear() +
          '-' + pad(this.getMonth() + 1) +
          '-' + pad(this.getDate()) +
          'T' + pad(this.getHours()) +
          ':' + pad(this.getMinutes()) +
          ':' + pad(this.getSeconds()) +
          '.' + (this.getMilliseconds() / 1000).toFixed(3).slice(2, 5);
    };
    Date.prototype.toShortISOString = function () {
        return this.getFullYear() +
            '-' + pad(this.getMonth() + 1) +
            '-' + pad(this.getDate());
    };
})();;
(function () {
    'use strict';

    if (!Object.keys) {
        Object.keys = (function() {
            'use strict';
            var hasOwnProperty = Object.prototype.hasOwnProperty,
                hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),
                dontEnums = [
                  'toString',
                  'toLocaleString',
                  'valueOf',
                  'hasOwnProperty',
                  'isPrototypeOf',
                  'propertyIsEnumerable',
                  'constructor'
                ],
                dontEnumsLength = dontEnums.length;

            return function(obj) {
                if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
                    throw new TypeError('Object.keys called on non-object');
                }

                var result = [], prop, i;

                for (prop in obj) {
                    if (hasOwnProperty.call(obj, prop)) {
                        result.push(prop);
                    }
                }

                if (hasDontEnumBug) {
                    for (i = 0; i < dontEnumsLength; i++) {
                        if (hasOwnProperty.call(obj, dontEnums[i])) {
                            result.push(dontEnums[i]);
                        }
                    }
                }
                return result;
            };
        }());
    }

    if (!Object.parseFileName) {
        Object.parseFileName = (function () {
            'use strict';

            return function (obj) {
                var disposition = obj('Content-Disposition');
                if (disposition && (disposition.indexOf('attachment') !== -1 || disposition.indexOf('inline') !== -1)) {
                    var filenameRegex = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/;
                    var matches = filenameRegex.exec(disposition);
                    if (matches !== null && matches[1]) {
                        return matches[1].replace(/['"]/g, '');
                    }
                }
                return "download.bin";
            };
        }());
    }

})();;
(function () {

    'use strict';

    var app = angular.module('theApp', [
        // Angular modules
        'ngAnimate',            // animations
        'ngCookies',
        'ngRoute',              // route
        'ngResource',         // resource
        'ngMessages',
        'ngSanitize',
        'ngTouch',
        "blockUI",

        'ui.router',
        'ui.bootstrap',

        // Custom modules 
        'AppService',           // common functions, logger, spinner
        'lez.landenpicker',

        //TINK
        'toaster',
        //'tink.datepicker',
        'tink.modal',
        'tink.upload',

        // Locale
        'tmh.dynamicLocale'

    ]);

    app.config(function (tmhDynamicLocaleProvider) {
        tmhDynamicLocaleProvider.localeLocationPattern('bower_components/angular/angular-locale_{{locale}}.js');
        tmhDynamicLocaleProvider.defaultLocale('nl-be');
    });

    app.config(function ($httpProvider, $stateProvider, $urlRouterProvider, $compileProvider, $locationProvider, appConfig, blockUIConfig) {

        blockUIConfig.autoBlock = false;

        disableCaching($httpProvider);

        $locationProvider.html5Mode(true);

        $urlRouterProvider.rule(function ($injector, $location) {
            var path = $location.path(), normalized = path.toLowerCase();
            if (normalized[normalized.length - 1] === '/') normalized = normalized.substr(0, normalized.length - 1);
            if (path !== normalized) $location.replace().path(normalized);
        });

        $urlRouterProvider.otherwise('/');


        $stateProvider
            .state('login', {
                reloadOnSearch: false,
                url: '/login?Taal&p&{eid:bool}',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'LoginResolverController',
                controllerAs: 'ctrl'
            })
            .state('authentication', {
                reloadOnSearch: false,
                url: '*path/authenticate?code&m&lng&a',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'AuthenticationResolverController',
                controllerAs: 'ctrl'
            })
            .state('aanvraag', {
                reloadOnSearch: false,
                url: '/{ANR:int}?Taal',
                params: {
                    'f': undefined
                },
                templateUrl: 'app/views/scherm/aanvraagDetail.html',
                controller: 'AanvraagResolverController',
                controllerAs: 'ctrl'
            })
            .state('ogone', { // Nesting ogone as aanvraag.ogone with /{OSTAT} as url does not work
                reloadOnSearch: false,
                url: '/{ANR:int}/{OSTAT:(?:accepted|cancelled|declined|error|timedout)}',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'PaymentResolverController',
                controllerAs: 'ctrl'
            })
            .state('eloketactie', {
                reloadOnSearch: false,
                url: '/{ANR:int}/{ELOK_ACTIE:(?:copy|renew)}',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'EloketResolverController',
                controllerAs: 'ctrl'
            })
            .state('dagpas', {
                reloadOnSearch: false,
                url: '/dagpas?Taal',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'DagpasResolverController',
                controllerAs: 'ctrl'
            })
            .state('boetenummer', {
                reloadOnSearch: false,
                url: '/boete?Taal',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'BoeteResolverController',
                controllerAs: 'ctrl'
            })
            .state('chat', {
                reloadOnSearch: false,
                url: '*path/chat?RedirectUrl',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'ChatResolverController',
                controllerAs: 'ctrl'
            })
            .state('infokiosk', {
                reloadOnSearch: false,
                url: '/infokiosk/{kioskId}?Taal',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'InfoKioskResolverController',
                controllerAs: 'ctrl'
            })
            .state('default', {
                reloadOnSearch: false,
                url: '/?Taal&p',
                templateUrl: 'app/views/scherm/loading.html',
                controller: 'DefaultResolverController',
                controllerAs: 'ctrl'
            })
            .state('main', {
                reloadOnSearch: false,
                abstract: true,
                resolve: {
                    Enums: 'appEnums',
                    Constants: 'appConstants',
                    errorService: 'LEZErrorService',
                    filterService: 'FilterService',
                    parameterService: 'ParameterService',
                    addressService: 'AddressService',
                    meertaligheid: ['MeertaligheidService', function (MeertaligheidService) {
                        return MeertaligheidService.init();
                    }]
                },
                templateUrl: 'app/views/scherm.html'
            })
            .state('main.scherm', {
                reloadOnSearch: false,
                abstract: true,
                resolve: {
                    navigatieService: 'NavigatieService',
                    parameterHelperService: 'ParameterHelperService',

                    scherm: function (navigatieService) {
                        console.log('Scherm ' + navigatieService.huidigScherm().schermNr);
                        return navigatieService.huidigScherm();
                    },
                    algemeenSchermData: function (meertaligheid, filterService) {
                        return filterService.filter(meertaligheid, { schermtype: 'Algemeen' });
                    },
                    _data: function (meertaligheid, scherm, filterService) {
                        return filterService.filter(meertaligheid, { scherm: scherm.schermNr });
                    },
                    condities: function (_data) {
                        var condities = {};

                        for (var i = 0, len = _data.length; i < len; ++i) {
                            var row = _data[i];
                            if (!row.visible || !angular.isString(row.conditie)) continue;
                            var matches = row.conditie.match(/^([^\[\]]+)(?:\[([^\[\]]+)\])*$/);
                            if (matches) condities[matches[1]] = 1;
                            else console.debug("Conditie Matching Error: " + row.conditie);
                        }

                        return Object.keys(condities);
                    },
                    conditiesCalled: function ($q, condities, parameterHelperService) {
                        var promises = [];
                        for (var i = 0, len = condities.length; i < len; ++i) promises.push(parameterHelperService.bereken(condities[i]));
                        return $q.all(promises).then(function () { return true; });
                    },
                    schermData: function (conditiesCalled, _data, parameterService, filterService) {
                        if (conditiesCalled !== true) throw "Did not verify conditions!";
                        var data = filterService.filterToegestaan(_data, parameterService);
                        return filterService.filterKeuzeOpties(data, parameterService);
                    }
                },
                views: {
                    'info': {
                        templateUrl: 'app/views/scherm/info.html',
                        resolve: {
                            titel: function (algemeenSchermData, filterService) {
                                return filterService.filter(algemeenSchermData, { naam: 'InfoHeader' }).shift();
                            },
                            afbeelding: function (schermData, filterService) {
                                var afbeeldingen = filterService.filter(schermData, { naam: 'Image' });
                                var afbeelding = afbeeldingen.shift();

                                if (angular.isUndefinedOrNull(afbeelding)) return;
                                if (angular.isNullOrWhitespace(afbeelding.nl)) afbeelding.visible = false;

                                return afbeelding;
                            },
                            bestand: function (schermData, filterService) {
                                var bestanden = filterService.filter(schermData, { naam: 'Info', itemtype: 'Popup' });
                                var bestand = bestanden.shift();

                                if (angular.isUndefinedOrNull(bestand)) return;
                                if (angular.isNullOrWhitespace(bestand.nl)) bestand.visible = false;

                                return bestand;
                            },
                            label: function (bestand, schermData, filterService) {
                                if (angular.isUndefinedOrNull(bestand)) return;
                                return filterService.filter(schermData, { naam: 'Info', itemtype: 'Label', itemnr: bestand.itemnr }).shift();
                            },
                            infobuttons: function (schermData, filterService) {
                                return filterService.filter(schermData, { type: 'Infobutton', visible: true });
                            }
                        },
                        controller: 'InfoController',
                        controllerAs: 'ctrl'
                    },
                    'parameters': {
                        templateUrl: 'app/views/scherm/parameters.html',
                        resolve: {
                            titel: function (algemeenSchermData, filterService) { return filterService.filter(algemeenSchermData, { naam: 'ParameterHeader' }).shift(); }
                        },
                        controller: 'ParameterController',
                        controllerAs: 'ctrl'
                    },
                    '': {
                        templateUrl: 'app/views/scherm/detail.html'
                    }
                }
            })
            .state('main.scherm.detail', {
                reloadOnSearch: false,
                abstract: true,
                views: {
                    'header': {
                        templateUrl: 'app/views/scherm/detail/header.html',
                        resolve: {
                            titel: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Titel' }).shift(); }
                        },
                        controller: function ($scope, titel) {
                            $scope.titel = titel;
                        }
                    },
                    'body': {
                        templateUrl: 'app/views/scherm/detail/body.html',
                        resolve: {
                            tekstTop: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Teksttop' }).shift(); },
                            tekstMid: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Tekstmid' }).shift(); },
                            tekstBot: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Tekstbot' }).shift(); }
                        },
                        controller: 'BodyController'
                    },
                    'footer': {
                        templateUrl: 'app/views/scherm/detail/footer.html',
                        resolve: {
                            navBegin: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Navbegin' }).shift(); },
                            navTerug: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Navterug' }).shift(); },
                            navVlg: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Navvlg' }).shift(); },
                            navVal: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Navval' }).shift(); },
                            navVul: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Navvul' }).shift(); },
                            navExit: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Navexit' }).shift(); },
                            navAan: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Navaan' }).shift(); },
                            linkLabel: function (schermData, filterService) { return filterService.filter(schermData, { naam: 'Link', itemtype: 'Label' }).shift(); },
                            link: function (schermData, filterService) {  return filterService.filter(schermData, { naam: 'Link', itemtype: 'Content' }).shift(); }
                        },
                        controller: 'NavigatieController'
                    }
                }
            })
            .state('main.scherm.detail.default', {
                reloadOnSearch: false,
                url: '*path?Taal&p',
                resolve: {
                    validationService: 'ValidationService',
                    viewData: function (schermData, filterService) {
                        function _neq(actual, expected) { return actual !== expected; }

                        var data = filterService.filter(schermData, { type: 'Tekst' }, _neq);
                        data = filterService.filter(data, { type: 'Navbut' }, _neq);
                        data = filterService.filter(data, { naam: 'Info' }, _neq);
                        data = filterService.filter(data, { naam: 'Titel' }, _neq);
                        data = filterService.filter(data, { naam: 'Link' }, _neq);
                        data = filterService.filter(data, { naam: 'Image' }, _neq);
                        data = filterService.filter(data, { type: 'Infobutton' }, _neq);

                        return data;
                    }
                },
                views: {
                    'Default': {
                        templateUrl: 'app/views/scherm/detail/parts/form.html',
                        resolve: {
                            vragen: function (viewData, filterService) {
                                var vragen = [];
                                var labels = filterService.filter(viewData, { itemtype: 'Label', visible: true });
                                var tooltips = filterService.filter(viewData, { itemtype: 'Tooltip' });

                                for (var i = 0, len = labels.length; i < len; ++i) {
                                    var label = labels[i];
                                    var tooltip = filterService.filter(tooltips, { itemNr: label.itemNr }).shift();
                                    vragen.push({ label: label, tooltip: tooltip, type: label.type });
                                }

                                return vragen;
                            },
                            params: function (vragen) {
                                var params = {};

                                for (var i = 0, len = vragen.length; i < len; ++i) {
                                    var label = vragen[i].label;
                                    if (!label.visible) continue;
                                    params[label.param] = true;
                                }

                                return Object.keys(params);
                            }
                        },
                        controller: 'DefaultViewController',
                        controllerAs: 'ctrl'
                    },
                    'Tarief': {
                        templateUrl: 'app/views/scherm/detail/parts/tarief.html',
                        resolve: {
                            tableHeaders: function (viewData, filterService) { return filterService.filter(viewData, { type: 'Tablehead', itemtype: 'Label' }); },
                            BDAT: function (viewData, filterService) {
                                var label = filterService.filter(viewData, { naam: 'Datum', itemtype: 'Label', param: 'BDAT' }).shift();
                                if (angular.isUndefined(label)) return undefined;
                                var tooltip = filterService.filter(viewData, { naam: 'Datum', itemtype: 'Tooltip', itemNr: label.itemNr }).shift();
                                return { label: label, tooltip: tooltip };
                            },
                            EDAT: function (viewData, filterService) {
                                var label = filterService.filter(viewData, { naam: 'Datum', itemtype: 'Label', param: 'EDAT' }).shift();
                                if (angular.isUndefined(label)) return undefined;
                                var tooltip = filterService.filter(viewData, { naam: 'Datum', itemtype: 'Tooltip', itemNr: label.itemNr }).shift();
                                var overschrijdingMessage = filterService.filter(viewData, { naam: 'Datum', itemtype: 'Message', itemNr: label.itemNr }).shift();
                                return { label: label, tooltip: tooltip, overschrijding: overschrijdingMessage };
                            },
                            EDAT_ONEINDIG: function (viewData, filterService) { return filterService.filter(viewData, { naam: 'Datum', itemtype: 'Oneindig', param: 'EDAT' }).shift(); }
                        },
                        controller: 'TariefViewController',
                        controllerAs: 'ctrl'
                    },
                    'MultiForm': {
                        templateUrl: 'app/views/scherm/detail/parts/form.html',
                        resolve: {
                            vragen: function (viewData, filterService) {
                                var vragen = [];
                                var labels = filterService.filter(viewData, { itemtype: 'Label', visible: true });
                                var tooltips = filterService.filter(viewData, { itemtype: 'Tooltip' });

                                for (var i = 0, len = labels.length; i < len; ++i) {
                                    var label = labels[i];
                                    var tooltip = filterService.filter(tooltips, { itemNr: label.itemNr }).shift();
                                    vragen.push({ label: label, tooltip: tooltip, type: label.type });
                                }

                                return vragen;
                            },
                            params: function (vragen) {
                                var params = {};

                                for (var i = 0, len = vragen.length; i < len; ++i) {
                                    var label = vragen[i].label;
                                    if (!label.visible) continue;
                                    params[label.param] = true;
                                }

                                return Object.keys(params);
                            },
                            landenService: 'LezLandenService'
                        },
                        controller: 'MultiFormViewController',
                        controllerAs: 'ctrl'
                    },
                    'Overzicht': {
                        templateUrl: 'app/views/scherm/detail/parts/overzicht.html',
                        controller: 'OverzichtViewController',
                        controllerAs: 'ctrl'
                    },
                    'AanvraagSoort': {
                        templateUrl: 'app/views/scherm/detail/parts/aanvraagsoort.html',
                        resolve: {
                            vragen: function (viewData, filterService) {
                                var vragen = [];
                                var labels = filterService.filter(viewData, { itemtype: 'Label', visible: true });
                                var tooltips = filterService.filter(viewData, { itemtype: 'Tooltip' });

                                for (var i = 0, len = labels.length; i < len; ++i) {
                                    var label = labels[i];
                                    var tooltip = filterService.filter(tooltips, { itemNr: label.itemNr }).shift();
                                    vragen.push({ label: label, tooltip: tooltip, type: label.type });
                                }

                                return vragen;
                            },
                            subtitels: function (viewData, filterService) { return filterService.filter(viewData, { type: 'Subtit', visible: true }); }
                        },
                        controller: 'AanvraagSoortViewController',
                        controllerAs: 'ctrl'
                    },
                    'Whitelist': {
                        templateUrl: 'app/views/scherm/detail/parts/whitelist.html',
                        resolve: {
                            tableHeaders: function (viewData, filterService) { return filterService.filter(viewData, { type: 'Tablehead', itemtype: 'Label' }); },
                            einddatum_onbepaald: function (viewData, filterService) { return filterService.filter(viewData, { type: 'Tablehead', itemtype: 'Oneindig', param: 'WLEDAT' }).shift(); },
                            begindatum_onbepaald: function (viewData, filterService) { return filterService.filter(viewData, { type: 'Tablehead', itemtype: 'Oneindig', param: 'WLBDAT' }).shift(); }
                        },
                        controller: 'WhitelistViewController',
                        controllerAs: 'ctrl'
                    },
                    'Bijlage': {
                        templateUrl: 'app/views/scherm/detail/parts/bijlagen.html',
                        controller: 'BijlagenViewController',
                        controllerAs: 'ctrl'
                    },
                    'Dagpas': {
                        templateUrl: 'app/views/scherm/detail/parts/dagpas.html',
                        controller: 'DagpasViewController',
                        controllerAs: 'ctrl'
                    },
                    'Infokiosk': {
                        templateUrl: 'app/views/scherm/detail/parts/infokiosk.html',
                        controller: 'InfokioskViewController',
                        controllerAs: 'ctrl'
                    },
                    'InfoMenu': {
                        templateUrl: 'app/views/scherm/detail/parts/infomenu.html',
                        controller: 'InfomenuViewController',
                        controllerAs: 'ctrl'
                    }
                }
            })
            ;

        $compileProvider.debugInfoEnabled(appConfig.enableDebug);

    })
        .run(function ($rootScope, $state, LEZErrorService, AppStatusService, NavigatieService, ParameterService, appEnums) {
            $rootScope.$on('$stateNotFound', function (event, unfoundState, fromState, fromParams) {
                console.log('Kon ' + unfoundState.to + ' niet laden.');
                event.preventDefault(); // Trigger 'transition aborted' error.
            });

            //$rootScope.$on('$stateChangeSuccess', function (event, toState, toParams, fromState, fromParams, error) { });

            $rootScope.$on('$stateChangeError', function (event, toState, toParams, fromState, fromParams, error) {
                event.preventDefault(); // Stop the redirect
                if (angular.isUndefinedOrNull(error) || error.handled === true) return; // Errors are already handled.
                LEZErrorService.error('ERR_EX_01');
            });

            $rootScope.$on('$stateChangeStart', function (event, toState, toParams, fromState, fromParams) {
                if (AppStatusService.isOffline()) {
                    NavigatieService.start(appEnums.NavigatieActies.Offline);
                    if (toState.name !== 'main.scherm.detail.default') {
                        event.preventDefault();
                        $state.transitionTo('main.scherm.detail.default', toParams, { location: true, reload: true, inherit: false, notify: true });
                    }
                }
                else if (AppStatusService.isMaintenance()) {
                    if (!ParameterService.equals(appEnums.Parameters.Kanaal, [appEnums.Kanaal.DLloket, appEnums.Kanaal.BackOffice])) {
                        NavigatieService.start(appEnums.NavigatieActies.Maintenance);
                        AppStatusService.setMaintenanceShown();
                        if (toState.name !== 'main.scherm.detail.default') {
                            event.preventDefault();
                            $state.transitionTo('main.scherm.detail.default', toParams, { location: true, reload: true, inherit: false, notify: true });
                        }
                    }
                }
            });
        });

    function disableCaching($httpProvider) {
        if (!$httpProvider.defaults.headers.get) {
            $httpProvider.defaults.headers.get = {};
        }
        //disable IE ajax request caching
        $httpProvider.defaults.headers.get['If-Modified-Since'] = 'Mon, 26 Jul 1997 05:00:00 GMT';
        // extra
        $httpProvider.defaults.headers.get['Cache-Control'] = 'no-cache';
        $httpProvider.defaults.headers.get['Pragma'] = 'no-cache';
    }

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

    angular.module('theApp').factory('Bijlage', ['Code', function (Code) {
        
        /* Constructor */
        function Bijlage(id, soort, aanvraagId, documentNaam, data) {
            this.id = id;
            this.soort = soort;
            this.aanvraagId = aanvraagId;
            this.documentNaam = documentNaam;
            this.data = data;
        }

        /* Public methods */
        Bijlage.prototype.GetData = function () { return this.data; };
        Bijlage.prototype.GetModel = function () {
            return {
                id: this.id,
                soortId: this.soort ? this.soort.id : null,
                aanvraagId: this.aanvraagId,
                opmerking: this.opmerking
            };
        };

        /* Private properties */
        
        /* Private function  */
        
        /* Static Methods */
        Bijlage.build = function (data) {
            if (angular.isUndefinedOrNull(data)) return;
            return new Bijlage(data.id, Code.build(data.soort), data.aanvraagId, data.documentNaam, data.data);
        };
        Bijlage.apiResponseTransformer = function (responseData) {
            if (angular.isArray(responseData)) return responseData.map(Bijlage.build).filter(Boolean);
            else return Bijlage.build(responseData);
        };

        /* Return the constructor function */
        return Bijlage;
    }]);
})();;
(function () {
    'use strict';

    angular.module('theApp').factory('Code', ['appEnums', function (Enums) {
        
        /* Constructor */
        function Code(id, isActief, soort, parameterValue, customField, nl, fr, en, de) {
            this.id = id;
            this.isActief = isActief;
            this.soort = soort;
            this.param = Code.getParam(soort);
            this.parameterValue = parameterValue;
            this.customField = customField;
            this.nl = nl;
            this.fr = fr;
            this.en = en;
            this.de = de;
        }

        /* Public methods */
        //TheClass.prototype.theMethod = function () { };

        /* Private properties */
        var soortToParam = {
            'FO_AppStatus': null,
            'AanvraagSoort': Enums.Parameters.AanvraagSoort,
            'AanvraagStatus': Enums.Parameters.AanvraagStatus,
            'AanvraagType': Enums.Parameters.AanvraagType,
            'AanvraagDuur': Enums.Parameters.Termijn,
            'AStadStatus': Enums.Parameters.AStadStatus,
            'Betaalmethode': Enums.Parameters.Betaling.Methode,
            'BijlageSoortIn': Enums.Parameters.Bijlagen.Bijlagen,
            'BijlageSoortUit': Enums.Parameters.Documenten,
            'BrandstofType': Enums.Parameters.Voertuig.BrandstofType,
            'COC': Enums.Parameters.Voertuig.Gelijkvormigheidscode,
            'ErkendeOpdrachtgever': Enums.Parameters.Opdracht.Opdrachtgever,
            'ErkendeOpdrachtgeverNoodsituaties': Enums.Parameters.Opdracht.OpdrachtgeverNoodsituatie,
            'KanaalToevoeging': Enums.Parameters.Kanaal,
            'Loket': Enums.Parameters.Medewerker.Loket,
            'RoetfilterType': Enums.Parameters.Voertuig.Roetfilter,
            'Taal': Enums.Parameters.Taal,
            'VoertuigAard': Enums.Parameters.Voertuig.Aardcode,
            'VoertuigCategorie': Enums.Parameters.Voertuig.VoertuigCategorie,
            'Kanteldatums': Enums.Parameters.Kanteldatums,

            // SPECIAL CASES
            'GVCA': Enums.Parameters.Voertuig.GelijkvormigheidscodeLandbouw,
            'GVCT': Enums.Parameters.Voertuig.GelijkvormigheidscodeAndere
        };
        var paramToSoort = _.invert(soortToParam);

        /* Private function  */
        function checkSoort(soort) {
            return angular.isDefined(soortToParam[soort]);
        }

        /* Static Methods */
        Code.getSoort = function (param) {
            return paramToSoort[param];
        };
        Code.getParam = function (soort) {
            return soortToParam[soort];
        };

        Code.build = function (data) {
            if (angular.isUndefinedOrNull(data) || !checkSoort(data.soort)) return; // Ongekende soort
            return new Code(data.id, data.isActief, data.soort, data.parameterValue, data.customField, data.nl, data.fr, data.en, data.de);
        };
        Code.apiResponseTransformer = function (responseData) {
            if (angular.isArray(responseData)) return responseData.map(Code.build).filter(Boolean);
            else return Code.build(responseData);
        };

        /* Return the constructor function */
        return Code;
    }]);
})();;
(function () {
    'use strict';

    angular.module('theApp').factory('ErrorMessage', function () {

        /* Constructor */
        function ErrorMessage(id, nl, fr, en, de) {
            this.id = id;
            this.nl = nl;
            this.fr = fr;
            this.en = en;
            this.de = de;
        }

        ErrorMessage.prototype.setValues = function () {
            var errorMessage = this;
            for (var i = arguments.length - 1; i >= 0; --i) {
                var arg = '' + arguments[i];
                var search = '$' + i;
                angular.forEach(['nl', 'fr', 'en', 'de'], function (item) {
                    if (angular.isString(errorMessage[item]))
                        errorMessage[item] = errorMessage[item].replace(search, arg);
                });
            }
        };

        /* Static Methods */
        ErrorMessage.build = function (data) {
            if (angular.isUndefinedOrNull(data)) return;
            return new ErrorMessage(data.id, data.nl, data.fr, data.en, data.de);
        };
        ErrorMessage.apiResponseTransformer = function (responseData) {
            if (angular.isArray(responseData)) return responseData.map(ErrorMessage.build).filter(Boolean);
            else return ErrorMessage.build(responseData);
        };

        /* Return the constructor function */
        return ErrorMessage;
    });

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

    angular.module('theApp').factory('Tarief', ['Code', 'LEZErrorService', function (Code, errorService) {

        /* Constructor */
        function Tarief(id, bedrag, btw, kassaCode, duur, eenheid, aanvraagType, aanvraagSoort, tariefType, brandstofType, euronorm, voertuigCategorie) {
            this.id = id;

            this.bedrag = bedrag;
            this.btw = btw;
            this.kassaCode = kassaCode;

            this.duur = duur;
            this.eenheid = eenheid;

            this.aanvraagType = aanvraagType;
            this.aanvraagSoort = aanvraagSoort;
            this.tariefType = tariefType;
            this.brandstofType = brandstofType;
            this.euronorm = euronorm;
            this.voertuigCategorie = voertuigCategorie;


            function _omschrijving(taal) {
                var teksts = [];
                if (!angular.isUndefinedOrNull(aanvraagSoort)) teksts.push(aanvraagSoort[taal]);
                //if (!angular.isUndefinedOrNull(euronorm)) teksts.push(euronorm[taal]);
                //if (!angular.isUndefinedOrNull(brandstofType)) teksts.push(brandstofType[taal]);
                return teksts.join(' ');
            }

            function _duurtijd(taal) {
                if (angular.isUndefinedOrNull(eenheid)) return;
                return duur + ' ' + eenheid[taal];
            }

            this.omschrijving = {
                nl: _omschrijving('nl'),
                fr: _omschrijving('fr'),
                en: _omschrijving('en'),
                de: _omschrijving('de'),
                visible: true
            };

            this.duurtijd = {
                nl: _duurtijd('nl'),
                fr: _duurtijd('fr'),
                en: _duurtijd('en'),
                de: _duurtijd('de'),
                visible: true
            };
        }

        /* Public methods */
        Tarief.prototype.getEindDatum = function (beginDatum) {
            if (angular.isUndefinedOrNull(beginDatum)) return undefined;

            var datum = beginDatum.clone();
            var dag = datum.date();
            switch (this.eenheid.customField) {
                case 'D':
                    datum.add(this.duur, 'd');
                    break;
                case 'W':
                    datum.add(this.duur, 'w');
                    break;
                case 'M':
                    datum.add(this.duur, 'M');
                    break;
                case 'Y':
                    datum.add(this.duur, 'y');
                    break;
                default:
                    errorService.error('ERR_PARAM_01B');
                    return undefined;
            }

            // De nieuwe maand is korter dan de vorige
            if ((this.eenheid.customField === 'M' || this.eenheid.customField === 'Y') && dag > datum.date()) {
                // Laatste dag van de (vorige) maand - month(X) trimt het aantal dagen naar het aantal dagen van de maand
                datum = moment([datum.year(), 0, 31]).month(datum.month());
                datum.hour(23);
                datum.minute(59);
                datum.second(59);
                datum.millisecond(99);
            }
            else if (this.eenheid.customField === 'D' && this.duur === 1) {
                datum.hour(6);
                datum.minute(0);
                datum.second(0);
                datum.millisecond(0);
            } else if (datum !== undefined) {
                datum.add(-1, 'd');
                datum.hour(23);
                datum.minute(59);
                datum.second(59);
                datum.millisecond(99);
            }

            return datum;
        };

        /* Private properties */

        /* Private function */

        /* Static Methods */

        Tarief.build = function (data) {
            if (angular.isUndefinedOrNull(data)) return;
            return new Tarief(data.id, data.bedrag, data.btw, data.kassaCode, data.duur, Code.build(data.eenheidLooptijd), Code.build(data.aanvraagType), Code.build(data.aanvraagSoort), Code.build(data.tariefType), Code.build(data.brandstofType), Code.build(data.euronorm), Code.build(data.voertuigCategorie));
        };

        Tarief.apiResponseTransformer = function (responseData) {
            if (angular.isArray(responseData)) return responseData.map(Tarief.build).filter(Boolean);
            else return Tarief.build(responseData);
        };

        /* Return the constructor function */
        return Tarief;
    }]);

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

    angular.module('theApp').factory('ValidationMessage', function () {

        /* Constructor */
        function ValidationMessage(id, nl, fr, en, de) {
            this.id = id;
            this.nl = nl;
            this.fr = fr;
            this.en = en;
            this.de = de;
        }

        ValidationMessage.prototype.setValues = function () {
            var validationMessage = this;
            for (var i = arguments.length - 1; i >= 0; --i) {
                var arg = arguments[i];
                var search = '$' + i;
                angular.forEach(['nl', 'fr', 'en', 'de'], function (item) {
                    if (!angular.isString(validationMessage[item])) return;
                    var value = angular.isObject(arg) ? arg[item] : '' + arg;
                    validationMessage[item] = validationMessage[item].replace(search, value);
                });
            }
        };

        /* Static Methods */
        ValidationMessage.build = function (data) {
            return new ValidationMessage(data.id, data.nl, data.fr, data.en, data.de);
        };
        ValidationMessage.apiResponseTransformer = function (responseData) {
            if (angular.isArray(responseData)) return responseData.map(ValidationMessage.build).filter(Boolean);
            else return ValidationMessage.build(responseData);
        };

        /* Return the constructor function */
        return ValidationMessage;
    });

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

    angular.module('theApp').factory('ValidationResult', function (ValidationMessage) {
        
        /* Constructor */
        function ValidationResult(result, messages) {
            this.result = result;
            this.messages = messages;
        }

        /* Private Properties */

        /* Private Methods */
        function checkResult(result) {
            switch (result)
            {
                case ValidationResult.Error:
                case ValidationResult.Warning:
                case ValidationResult.Success:
                case ValidationResult.Info:
                    return true;
                default:
                    return false;
            }
        }

        /* Public Methods */
        ValidationResult.prototype.isValid = function () {
            return this.result !== ValidationResult.Error;
        };

        ValidationResult.prototype.getCssClass = function () {
            switch (this.result) {
                case ValidationResult.Error:
                    return 'invalid';
                case ValidationResult.Warning:
                    return 'warning';
                case ValidationResult.Success:
                    return 'valid';
            }
        };

        ValidationResult.prototype.getMessageCssClass = function () {
            switch (this.result) {
                case ValidationResult.Error:
                    return 'field-problem';
                case ValidationResult.Warning:
                    return 'text-warning';
                case ValidationResult.Success:
                    return 'text-success';
                case ValidationResult.Info:
                    return 'text-info';
            }
        };

        ValidationResult.prototype.isMoreSevereThan = function (other) {
            if (this.result === other.result) return false;
            else if (this.result === ValidationResult.Error) return true;
            else if (this.result === ValidationResult.Warning && other.result !== ValidationResult.Error) return true;
            else if (this.result === ValidationResult.Info && other.result !== ValidationResult.Warning && other.result !== ValidationResult.Error) return true;
            else return false;
        };

        /* Static Properties */
        ValidationResult.Error = 'Error';
        ValidationResult.Warning = 'Warning';
        ValidationResult.Success = 'Success';
        ValidationResult.Info = 'Info';

        /* Static Methods */
        ValidationResult.CreateSuccessResult = function () { return new ValidationResult(ValidationResult.Success, []); };

        ValidationResult.build = function (data) {
            if (!checkResult(data.result)) return;
            return new ValidationResult(data.result, data.messages.map(ValidationMessage.build).filter(Boolean));
        };
        ValidationResult.apiResponseTransformer = function (responseData) {
            if (angular.isArray(responseData)) return responseData.map(ValidationResult.build).filter(Boolean);
            else return ValidationResult.build(responseData);
        };

        /* Return the constructor function */
        return ValidationResult;
    });
})();;
(function () {
    'use strict';

    angular.module('theApp').factory('Validator', function (ValidationResult) {
        
        /* Constructor */
        function Validator(validationMethods) {
            this.validationMethods = validationMethods;
        }

        /* Public Methods */
        Validator.prototype.validate = function (value) {
            var validationResult = new ValidationResult(ValidationResult.Success, []);

            for (var i = 0, len = this.validationMethods.length; i < len; ++i) {
                var res = this.validationMethods[i](value);
                
                if (res.result === validationResult.result)
                {
                    // Add messages when on the same level of severity
                    validationResult.messages = validationResult.messages.concat(res.messages);
                }
                else if (res.isMoreSevereThan(validationResult))
                {
                    // Override if the new validation result is of higer severity than the result of previous validations
                    validationResult.result = res.result;
                    validationResult.messages = res.messages;
                }
            }

            return validationResult;
        };

        /* Return the constructor function */
        return Validator;
    });

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

    var ctrlName = "BodyController";
    var theController = function ($scope, scherm, tekstTop, tekstMid, tekstBot, meertaligheidService) {
        $scope.tekstTop = tekstTop;
        $scope.tekstMid = tekstMid;
        $scope.tekstBot = tekstBot;
        
        $scope.view = 'Default';

        if ($scope.tekstTop)
            $scope.view = $scope.tekstTop.schermtype;
        else if ($scope.tekstMid)
            $scope.view = $scope.tekstMid.schermtype;
        else if ($scope.tekstBot)
            $scope.view = $scope.tekstBot.schermtype;
        else {
            // schermen zonder top/mid/bot tekst
            var item = meertaligheidService.get({ scherm: scherm.schermNr }).shift();
            if (item) $scope.view = item.schermtype;
        }

        // AWESOME HACK - 94 zonder parameters
        if ($scope.view === 'Infokiosk') {
            $scope.$emit('toonParametersHack', false);
        } else {
            $scope.$emit('toonParametersHack', true);
        }

        $scope.showEuronorm = scherm.schermNr === 33;
    };
    theController.$inject = ['$scope', 'scherm', 'tekstTop', 'tekstMid', 'tekstBot', 'MeertaligheidService'];
    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "ChatContainerController";
    var theController = function (appService, appConfig, Enums, parameterService, codeService, meertaligheidService, $scope) {
        appService.logger.creation(ctrlName);
        var chatctrl = this;

        var _chatActive = false;

        chatctrl.language = Enums.Taal.Nederlands.toLowerCase();
        chatctrl.isVisible = false;
        chatctrl.urlwhenunavailable = appConfig.chatInfoUrl;

        function _setTaal(taal) {
            chatctrl.language = taal;
            _setVisibility();
        }

        function _setVisibility() {
            if (chatctrl.language !== Enums.Taal.Nederlands) {
                chatctrl.isVisible = false;
                return;
            }
            if (!_chatActive) {
                chatctrl.isVisible = false;
                return;
            }
            if (parameterService.equals(Enums.Parameters.AanvraagType, Enums.AanvraagType.Dagpas)) {
                chatctrl.isVisible = false;
                return;
            }
            if (!parameterService.equals(Enums.Parameters.Kanaal, [ Enums.Kanaal.Checktool,
                                                                    Enums.Kanaal.EloketAprofiel,
                                                                    Enums.Kanaal.EloketEmail,
                                                                    Enums.Kanaal.BackOffice,
                                                                    Enums.Kanaal.DLloket])) {
                chatctrl.isVisible = false;
                return;
            }

            chatctrl.isVisible = true;
            _setButtonTexts();
        }

        init();

        function init() {
            appService.logger.init(ctrlName);
            _fetchChatActive();
            _setTaal(parameterService.get(Enums.Parameters.Taal, true));
        }

        $scope.$on(Enums.Parameters.Taal, function (e, newValue) {
            if (chatctrl.language === newValue) return;
            _setTaal(newValue);
        });

        $scope.$on(Enums.Parameters.AanvraagType, _setVisibility);
        $scope.$on(Enums.Parameters.Kanaal, _setVisibility);

        function _fetchChatActive() {
            codeService.getByTechnischeSleutel('CHAT_ACTIVE')
                                     .then(function (code) {
                                         return angular.isObject(code) && code.isActief;
                                     })
                                     .then(function (result) {
                                         _chatActive = result;
                                         _setVisibility();
                                     });
        }

        function _setButtonTexts() {
            var buttontextObject = meertaligheidService.get({ scherm: 0, naam: 'ChatBtn', type: 'Linkbut' }).shift();
            var buttontextNoAgentObject = meertaligheidService.get({ scherm: 0, naam: 'ChatBtnNoAgent', type: 'Linkbut' }).shift();
            var taal = angular.isString(chatctrl.language) ? chatctrl.language.toLowerCase() : Enums.Taal.Nederlands.toLowerCase();
            
            if (angular.isDefined(buttontextObject) && buttontextObject !== null) {
                if (angular.isNullOrWhitespace(buttontextObject[taal])) {
                    chatctrl.buttontext = buttontextObject.nl;
                }
                else {
                    chatctrl.buttontext = buttontextObject[taal];
                }
            }

            if (angular.isDefined(buttontextNoAgentObject) && buttontextNoAgentObject !== null) {
                if (angular.isNullOrWhitespace(buttontextNoAgentObject[taal])) {
                    chatctrl.buttontextnoagent = buttontextNoAgentObject.nl;
                }
                else {
                    chatctrl.buttontextnoagent = buttontextNoAgentObject[taal];
                }
            }
        }
    };

    theController.$inject = ['AppService', 'appConfig', 'appEnums', 'ParameterService', 'CodeService', 'MeertaligheidService', '$scope'];

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "InfoController";
    var theController = function (Enums, $scope, $cookies, parameterService, titel, afbeelding, label, bestand, infobuttons) {
        $scope.titel = titel;
        $scope.afbeelding = afbeelding;
        $scope.label = label;

        if (!parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.InformatieKiosk, Enums.Kanaal.InformatieKioskChecktool])) {
            $scope.bestand = bestand;
        }
        else {
            // Enkel bij infokiosk?
            $scope.infobuttons = infobuttons;
        }


        if (angular.isUndefined($cookies.getObject('showInfo'))) $cookies.putObject('showInfo', true);

        $scope.toggleInfo = function () {
            var show = $cookies.getObject('showInfo');
            $cookies.putObject('showInfo', !show);
        };
        $scope.hasInfo = (!angular.isUndefinedOrNull(afbeelding) && afbeelding.visible) ||
                         (!angular.isUndefinedOrNull(bestand) && bestand.visible) ||
                         (angular.isArray($scope.infobuttons) && $scope.infobuttons.length > 0);
        $scope.showInfo = function () {
            return $cookies.getObject('showInfo') && $scope.hasInfo;
        };
    };

    theController.$inject = ['appEnums', '$scope', '$cookies', 'ParameterService', 'titel', 'afbeelding', 'label', 'bestand', 'infobuttons'];
    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "LEZController";
    var theController = function (config, Enums, Constants, errorMessageService, validationMessageService, navigatieService, meertaligheidService, errorService, parameterService, $q, $rootScope, $timeout, $anchorScroll, $location, Tarief, tmhDynamicLocale) {
        var ctrl = this;

        // ++ Private Data ++
        var _delay = 5000;

        // ++ Public Data ++
        ctrl.isLoading = true;
        ctrl.isLoaded = false;
        ctrl.environment = config.environment;
        ctrl.language = parameterService.get(Enums.Parameters.Taal, true);
        ctrl.titel = undefined;
        ctrl.subtitel = undefined;
        ctrl.mode = $rootScope.mode;

        ctrl.showParametersAndInfo = true;

        ctrl.showHeader = function () {
            try {
                switch (navigatieService.huidigScherm().schermNr) {
                    case 94:
                        return false;
                    default:
                        return true;
                }
            } catch (ex) { return false; }
        };

        ctrl.ariaExpanded = false;
        ctrl.setAriaExpanded = function () {
            ctrl.ariaExpanded = !ctrl.ariaExpanded;
        };

        ctrl.reset = function () {
            navigatieService.annuleren();
        };

        ctrl.isInfokiosk = function () {
            return !parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.Checktool, Enums.Kanaal.EloketAprofiel, Enums.Kanaal.EloketEmail, Enums.Kanaal.BackOffice, Enums.Kanaal.DLloket, Enums.Kanaal.ParkeerMeter]);
        };

        ctrl.getFooter = function () {
            if (ctrl.isInfokiosk()) {
                return { nl: "<span>&copy; " + config.copyrightYear + " Antwerpen" };
            } else {
                var url = "https://www.slimnaarantwerpen.be/nl/lez-toegankelijkheidsverklaring-tool";
                var label = "Toegankelijksheidsverklaring";

                switch (ctrl.language) {
                    case 'FR':
                        url = "https://www.slimnaarantwerpen.be/fr/lez-declaration-d-accessibilite-d-outil-lez";
                        label = "Declaration d'Accessibilité";
                        break;
                    case 'DE':
                        url = "https://www.slimnaarantwerpen.be/de/lez-erklarung-zur-barrierefreiheit-lez-tool";
                        label = "Erklärung zur Barrierefreiheit";
                        break;
                    case 'EN':
                        url = "https://www.slimnaarantwerpen.be/en/lez-accessibility-statement-lez-tool";
                        label = "Accessibility Statement";
                        break;
                    default:
                        break;
                }

                return { nl: "<span>&copy; " + config.copyrightYear + " Antwerpen.be | </span > <a href=\"https://www.antwerpen.be/nl/info/5310f241aaa8a74f6c8b458d/a-stad-uw-privacy-en-hoe-gebruiken\" target=\"_blank\">Privacy &amp; gebruiksvoorwaarden</a> | <a href=\" " + url + " \" target=\"_blank\">" + label + "</a>" };
            }
        };

        // ++ Initialization ++
        _init();

        // ++ Private Methods ++
        function _init() {
            var onLoadFailed = function(error) {
                if (_delay === 5000)
                    errorService.error('ERR_EX_02', error.ErrorCodes);

                _delay = (_delay + 500) * 1.25;
                if (_delay > 300000) _delay = 300000; // 5 Minutes
                $timeout(_init, _delay);
                throw undefined;
            };

            var laadDataServices = function () {
                return $q.all([errorMessageService.init(), validationMessageService.init(), meertaligheidService.init()])
                    .then(undefined, onLoadFailed);
            };
            var initializeerValiabelen = function (result) {
                ctrl.isLoaded = true;
                ctrl.titel = meertaligheidService.get({ scherm: 0, naam: 'Titel' }).shift();
                ctrl.subtitel = meertaligheidService.get({ scherm: 0, naam: 'SubTitel' }).shift();
                ctrl.talen = meertaligheidService.get({ scherm: 0, naam: 'Taal', visible: true });
            };

            ctrl.isLoading = true;
            laadDataServices().then(initializeerValiabelen)
                              .finally(function () {
                                    ctrl.isLoading = false;
                                });

            $rootScope.$watch(function () { return ctrl.language; }, function (newValue, oldValue) {
                if (newValue === oldValue) return;
                parameterService.set(Enums.Parameters.Taal, newValue);
                $location.search(Enums.Parameters.Taal, newValue);
                switch (newValue) {
                    case Enums.Taal.Duits:
                        tmhDynamicLocale.set('de-de');
                        break;
                    case Enums.Taal.Frans:
                        tmhDynamicLocale.set('fr-fr');
                        break;
                    case Enums.Taal.Engels:
                        tmhDynamicLocale.set('en-gb');
                        break;
                    case Enums.Taal.Nederlands:
                    default:
                        tmhDynamicLocale.set('nl-be');
                        break;
                }
                moment.tz.setDefault("Europe/Brussels");
            });

            $rootScope.$on(Enums.Parameters.Taal, function (e, newValue) {
                if (ctrl.language === newValue) return;
                ctrl.language = newValue;
            });

            $rootScope.$on('toonParametersHack', function (e, newValue) {
                ctrl.showParametersAndInfo = newValue;
            });

            ctrl.scrollToTop = function () {
                $anchorScroll();
            };

            $rootScope.$watch('mode', function (newValue, oldValue) {
                if (newValue === oldValue) return;
                var element = angular.element('#skeleton');
                element.removeAttr('style');
                ctrl.mode = newValue;
            });

            $timeout(function () {
                if ($rootScope.mode) return;
                $rootScope.mode = 'master';
            },400);


            switch (config.environment){
                case 'LOCAL':
                case 'DEV':
                    _testDates();
                    break;
            }
        }

        function _testDates() {
            function _testBerekenEindDatum(startDatumString, duur, eenheid) {
                var date = moment.tz(startDatumString, "YYYY-MM-DD", "Europe/Brussels");
                var type = "";
                switch (eenheid) {
                    case 'D':
                        type = duur > 1 ? "Dagen" : "Dag";
                        break;
                    case 'W':
                        type = duur > 1 ? "Weken" : "Week";
                        break;
                    case 'M':
                        type = duur > 1 ? "Maanden" : "Maand";
                        break;
                    case 'Y':
                        type = duur > 1 ? "Jaren" : "Jaar";
                        break;
                }

                var tarief = new Tarief(null, null, null, null, duur, { customField: eenheid }, null, null, null, null, null, null);

                console.log(date.format("DD/MM/YYYY HH:mm:SS Z") + " + " + duur + " " + type + " =\r\n" + tarief.getEindDatum(date).format("DD/MM/YYYY HH:mm:SS Z"));
            }

            function _testConstant(date) {
                console.log(date.format("DD/MM/YYYY HH:mm:SS Z") + " - " + (date.isValid() ? "Valid" : "InValid"));
            }

            // Februari
            _testBerekenEindDatum("2017-01-28", 1, 'M');
            _testBerekenEindDatum("2017-01-29", 1, 'M');
            _testBerekenEindDatum("2017-01-30", 1, 'M');
            _testBerekenEindDatum("2017-01-31", 1, 'M');
            _testBerekenEindDatum("2017-02-01", 1, 'M');
            _testBerekenEindDatum("2017-02-02", 1, 'M');
            // Schrikkeljaar
            _testBerekenEindDatum("2016-01-29", 1, 'M');
            _testBerekenEindDatum("2016-01-30", 1, 'M');
            _testBerekenEindDatum("2016-01-31", 1, 'M');
            _testBerekenEindDatum("2016-02-01", 1, 'M');
            _testBerekenEindDatum("2016-02-02", 1, 'M');

            _testBerekenEindDatum("2016-03-01", 1, 'Y');
            _testBerekenEindDatum("2016-02-29", 1, 'Y');
            _testBerekenEindDatum("2016-02-28", 1, 'Y');
            _testBerekenEindDatum("2016-03-01", 4, 'Y');
            _testBerekenEindDatum("2016-02-29", 4, 'Y');
            _testBerekenEindDatum("2016-02-28", 4, 'Y');

            _testBerekenEindDatum("2017-01-31", 1, 'D');
            _testBerekenEindDatum("2017-01-01", 1, 'D');
            _testBerekenEindDatum("2017-01-01", 2, 'D');

            _testBerekenEindDatum("2017-12-18", 1, 'D');

            _testBerekenEindDatum("2017-11-30", 3, 'M');
            _testBerekenEindDatum("2017-10-31", 6, 'M');

            _testBerekenEindDatum("2017-02-01", 2, 'W');

            console.log("Const Dates:");
            _testConstant(Constants.Datums.getLEZStartDatum());
            _testConstant(Constants.Datums.getLEZBoeteDatum());
            _testConstant(Constants.Datums.getEindDatum_2019());
            _testConstant(Constants.Datums.getEindDatum_2024());
            _testConstant(Constants.Datums.getEindDatum_2099());
        }
    };

    theController.$inject = ['appConfig', 'appEnums', 'appConstants', 'ErrorMessageService', 'ValidationMessageService', 'NavigatieService', 'MeertaligheidService', 'LEZErrorService', 'ParameterService', '$q', '$rootScope', '$timeout', '$anchorScroll', '$location', 'Tarief', 'tmhDynamicLocale'];

    angular.module('theApp').controller(ctrlName, theController);
})();
;
(function() {
    'use strict';

    var ctrlName = "NavigatieController";
    var theController = function (Enums, $scope, navigatieService, parameterService, scherm, navBegin, navTerug, navVlg, navVal, navVul, navExit, navAan, linkLabel, link) {
        $scope.navBegin = navBegin;
        $scope.navTerug = navTerug;
        $scope.navVlg = navVlg;
        $scope.navVal = navVal;
        $scope.navVul = navVul;
        $scope.navExit = navExit;
        $scope.navAan = navAan;

        if (!parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.InformatieKiosk, Enums.Kanaal.InformatieKioskChecktool])) {
            $scope.link = { label: linkLabel, content: link };
        }

        function _canNotGoBack() {
            return navigatieService.isEersteScherm(scherm.schermNr);
        }

        function _inValidOptionSelected() {
            var option;
            if (angular.isObject(scherm.selectedValues)) {
                option = scherm.selectedValues[Enums.Parameters.Keuzes.Lus]; // Huidig scherm gekozen optie voorrang op parameterService
            }

            if (
                angular.isUndefinedOrNull(option) ||
                !parameterService.equals(Enums.Parameters.VolledigheidAanvraag, ['1', '2', '3'])
            ) {
                return true;
            }

            return false;
        }

        if (angular.isDefined(navBegin))
            navBegin.isDisabled = _canNotGoBack;
        if (angular.isDefined(navTerug))
            navTerug.isDisabled = _canNotGoBack;

        if (angular.isDefined(navVlg)) {
            navVlg.isDisabled = function () { return scherm.isValid() == false; };
            // force hidden "onderzoek" button on screen 41.
            // else let backoffice handle showing buttons.
            // @see LEZ-1387
            if (scherm.schermNr === 41) {
                navVlg.isVisible = function () {
                    return false;
                };
            }
        }

        if (angular.isDefined(navVal))
            navVal.isDisabled = _inValidOptionSelected;
        if (angular.isDefined(navVul))
            navVul.isDisabled = _inValidOptionSelected;
        if (angular.isDefined(navExit))
            navExit.isDisabled = function () { return false; };
        if (angular.isDefined(navAan)){
            navAan.isDisabled = function () {
                var option = scherm.selectedValues[Enums.Parameters.Keuzes.Lus]; // Huidig scherm gekozen optie voorrang op parameterService

                if (angular.isUndefinedOrNull(option)) {
                    if (scherm.schermNr === 41) {
                        return true;
                    } else {
                        option = parameterService.get(Enums.Parameters.Keuzes.Lus);
                    }
                }

                if (angular.isUndefined(option)) {
                    return true;
                }

                return false;
            };
            navAan.isVisible = function () {
                if (!navAan.visible) return false;
                if (parameterService.equals(Enums.Parameters.VolledigheidLus + '[11]', [3, 4])) {
                    // Indien de optie dagpas zichtbaar is, enkel tonen indien NIET de enige optie
                    for (var i = 1; i <= 14; ++i){
                        if (i === 11) continue;
                        if (parameterService.equals(Enums.Parameters.VolledigheidLus + '[' + i + ']', [3, 4])) return true;
                    }
                    return false;
                }
                else return true;
            };
        }
    };

    angular.module('theApp').controller(ctrlName, theController);
})();
;
(function () {
    'use strict';

    var ctrlName = "ParameterController";
    var theController = function (titel, parameterService, Enums, Constants, landenService) {
        var ctrl = this;

        var currentLanguage = parameterService.get(Enums.Parameters.Taal, true).toLowerCase();

        ctrl.titel = titel;

        getCountries();

        var countriesCollection;
        function getCountries () {
            landenService.getAll().then(function (countries) {
                countriesCollection = countries;
            });
        }

        ctrl.isIngevuld = function (parameter) {
            return parameter.param.visible && parameter.parvalue;
        };

        ctrl.hasParams = function () {
            var params = parameterService.getAll();
            for (var prop in params) {
                if (params.hasOwnProperty(prop) && params[prop].param && params[prop].param.visible && params[prop].parvalue) {
                    return true;
                }
            }
            return false;
        };

        ctrl.getParams = function () {
            var params = parameterService.getAll();

            return params;
        };

        ctrl.getFullCountryName = function (countryCode) {
            if (countriesCollection && countriesCollection.listOfLandCodeModel) {
                var selectedCountry = countriesCollection.listOfLandCodeModel.filter(function (country) {
                    return (country.isoAlpha2 === countryCode.parvalue);
                });

                return countryCode.parvalue + ' - ' + selectedCountry[0][currentLanguage + '_short'];
            } else {
                return countryCode.parvalue;
            }
        };

        ctrl.getGHKDATLabelForCurrentLanguage = function () {
            return Enums.LabelTranslations[currentLanguage];
        };

        ctrl.isGHKDATUndefined = function (GHKDAT) {
            var format = 'DD/MM/YYYY HH:mm:ss';
            var selectedDate = moment(GHKDAT.parvalue).format(format);
            var outerEndDate = Constants.Datums.getEindDatum_2099().format(format);

            if (selectedDate === outerEndDate) {
                return true;
            }

            return false;
        };
    };

    theController.$inject = ['titel', 'parameterService', 'Enums', 'Constants', 'LezLandenService'];

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "ConfirmModalController";
    var theController = function ($modalInstance, $timeout, params, meertaligheidService) {
        var ctrl = this;
        ctrl.isLoading = true;

        init();
        function init() {
            ctrl.isLoading = true;

            if (angular.isUndefined(params) || angular.isUndefined(params.type)) {
                $modalInstance.$dismiss();
                return;
            }

            // Scherm items ophalen
            var items = meertaligheidService.get({ scherm: 0, type: params.type });

            // Controleren of er items zijn
            if (!angular.isArray(items) || items.length < 1) {
                items = [
                    { naam: 'Ok', visible: true, nl: 'Ok' },
                    { naam: 'Annuleren', visible: true, nl: 'Annuleren', en: 'Cancel', fr: 'Annuler', de: 'Abbrechen' },
                    { naam: 'Teksttop', visible: true, nl: 'Bent u zeker?', en: 'Are you sure?', fr: 'Es-tu sûr?', de: 'Bist du sicher?' }
                ];
            }

            for (var i = 0, len = items.length; i < len; ++i) {
                var item = items[i];
                switch (item.naam) {
                    case 'Ok':
                        ctrl.okLabel = item;
                        break;
                    case 'Annuleren':
                        ctrl.annulerenLabel = item;
                        break;
                    case 'Teksttop':
                        ctrl.tekstTop = item;
                        break;
                }
            }

            $timeout(function () {
                var modals = document.getElementsByClassName('modal');
                if (modals.length > 0)  modals[0].classList.add("modal-sm");
            }, 0);

            ctrl.isLoading = false;
        }

        ctrl.onOk = function () {
            $modalInstance.$close();
        };

        ctrl.onCancel = function () {
            $modalInstance.$dismiss();
        };
    };

    theController.$inject = ['$modalInstance', '$timeout', 'params', 'MeertaligheidService'];
    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "ImageModalController";
    var theController = function ($modalInstance, params) {
        var ctrl = this;
        ctrl.isLoading = true;

        init();
        function init() {
            ctrl.isLoading = true;

            if (angular.isUndefined(params) || angular.isUndefined(params.data)) {
                $modalInstance.$dismiss();
                return;
            }
            
            ctrl.item = params.data;

            ctrl.isLoading = false;
        }

        ctrl.close = function () {
            $modalInstance.$close();
        };
    };

    theController.$inject = ['$modalInstance', 'params'];
    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "InfoSchermModalController";
    var theController = function ($modalInstance, params, meertaligheidService) {
        var ctrl = this;
        ctrl.isLoading = true;

        init();
        function init() {
            ctrl.isLoading = true;

            if (angular.isUndefined(params) || angular.isUndefined(params.scherm)) {
                $modalInstance.$dismiss();
                return;
            }

            if (angular.isString(params.scherm)) params.scherm = parseInt(params.scherm);
            
            // Scherm items ophalen
            var items = meertaligheidService.get({ scherm: params.scherm });
            ctrl.items = items;

            // Controleren of er items zijn en of het om een infoscherm gaat
            if (!angular.isArray(ctrl.items) || ctrl.items.length < 1 || ctrl.items[0].schermtype !== 'InfoScherm') {
                $modalInstance.$dismiss();
                return;
            }

            ctrl.isLoading = false;
        }

        ctrl.close = function () {
            $modalInstance.$close();
        };
    };

    theController.$inject = ['$modalInstance', 'params', 'MeertaligheidService'];
    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "AanvraagResolverController";
    var theController = function (Enums, Constants, errorService, authenticatieService, aanvraagService, bijlagenService, parameterService, parameterHelperService, navigatieService, formatterService, meertaligheidService, validationService, $stateParams, $state, $anchorScroll) {
        var ctrl = this;

        init();

        function init() {
            ctrl.isLoading = true;
            ctrl.isError = false;

            navigatieService.start();

            var onAuthError = function (error) {
                errorService.error('ERR_AUTH_02', error.ErrorCodes);
                ctrl.isError = true;
                throw undefined;
            };
            var aanvraagLaadError = function (error) {
                var errorCode = 'ERR_AVR_01';
                switch (error.status)
                {
                    case 401:
                        if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.EloketEmail)) {
                            authenticatieService.setUser(undefined);
                            authenticatieService.login($stateParams[Enums.Parameters.AanvraagNummer]);
                            errorCode = 'ERR_AUTH_03';
                        }
                        else
                            errorCode = 'ERR_AUTH_02';
                        break;
                    case 404:
                        errorCode = 'ERR_AVR_01A';
                        break;
                }
                errorService.error(errorCode, error.ErrorCodes);
                ctrl.isError = true;
                throw undefined;
            };
            var aanvraagLaadSucces = function (aanvraag) {
                if (angular.isUndefined(aanvraag)) {
                    errorService.error('ERR_AVR_01A');
                    ctrl.isError = true;
                    throw undefined;
                }

                var params = Object.keys(aanvraag);
                for (var i = 0, len = params.length; i < len; ++i) {
                    var param = params[i];

                    switch (param) {
                        case 'EloketActies':
                        case 'StatusBoodschap':
                        case 'StatusBoodschapStijl':
                        case Enums.Parameters.Betaling.Methode:
                        case Enums.Parameters.Voertuig.ChassisNummer:
                            continue;
                        case Enums.Parameters.Medewerker.Loket:
                        case Enums.Parameters.Medewerker.Identificatie:
                        case Enums.Parameters.Medewerker.Naam:
                            if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.DLloket, Enums.Kanaal.BackOffice]))
                                continue;
                            break;
                    }

                    parameterService.set(param, aanvraag[param]);
                }

                return aanvraag;
            };
            var laadAanvraag = function () {
                var getUserData = function (){
                    var userdata = {
                        kanaal: parameterService.get(Enums.Parameters.Kanaal),
                        ignoreType: $stateParams['f'] ? true : false
                    };
                    switch (userdata.kanaal)
                    {
                        case Enums.Kanaal.EloketAprofiel:
                            userdata.userId = parameterService.get(Enums.Parameters.Gebruiker.Identificatie);
                            userdata.userToken = parameterService.get(Enums.Parameters.Gebruiker.Token);
                            break;
                        case Enums.Kanaal.EloketEmail:
                            userdata.mail = parameterService.get(Enums.Parameters.Aanvrager.Email);
                            userdata.datum = parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                            break;
                        case Enums.Kanaal.DLloket:
                        case Enums.Kanaal.BackOffice:
                            userdata.userId = parameterService.get(Enums.Parameters.Medewerker.Identificatie);
                            userdata.userToken = parameterService.get(Enums.Parameters.Medewerker.Token);
                            break;
                    }
                    return userdata;
                };
                return aanvraagService.getById($stateParams[Enums.Parameters.AanvraagNummer], getUserData()).then(aanvraagLaadSucces, aanvraagLaadError);
            };
            var laadBijlagen = function (aanvraag) {
                return bijlagenService.init(aanvraag[Enums.Parameters.AanvraagNummer])
                                      .then(function () { return aanvraag; }, function () { ctrl.isError = true; throw undefined; });
            };
            var laadTeksten = function (aanvraag) {
                var zoekLegende = function (naam) { return meertaligheidService.get({ scherm: 84, type: 'Legendes', naam: naam }).shift(); };
                var zoekEmpty = function (naam) { return meertaligheidService.get({ scherm: 84, type: 'Empty', naam: naam }).shift(); };
                var zoekLabel = function (parameter) { return meertaligheidService.get({ scherm: 84, type: 'Tekstfield', param: parameter }).shift(); };
                var zoekMeertaligheid = function (parameter, value) { return meertaligheidService.get({ scherm: 0, itemtype: 'Content', param: parameter, parvalue: value }).shift(); };

                var _asValue = function (parameter, aanvraag) {
                    if (angular.isUndefined(aanvraag[parameter])) return undefined;
                    return { label: zoekLabel(parameter), value: aanvraag[parameter] };
                };
                var _asParameterValue = function (parameter, aanvraag) {
                    if (angular.isUndefined(aanvraag[parameter])) return undefined;
                    return { label: zoekLabel(parameter), value: { parvalue: aanvraag[parameter] } };
                };
                var _asNederlands = function (parameter, aanvraag) {
                    if (angular.isUndefined(aanvraag[parameter])) return undefined;
                    return { label: zoekLabel(parameter), value: { nl: aanvraag[parameter] } };
                };
                var _asMeertaligheid = function (parameter, aanvraag) {
                    var value = aanvraag[parameter];
                    if (angular.isUndefined(value) && (parameter === Enums.Parameters.Voertuig.Euronorm || parameter === Enums.Parameters.Voertuig.EuronormVerrijkt)) value = aanvraag['VDI_' + parameter];
                    if (angular.isUndefined(value)) return undefined;
                    return { label: zoekLabel(parameter), value: zoekMeertaligheid(parameter, value) };
                };
                var _asDate = function (parameter, aanvraag, includeTime) {
                    if (angular.isUndefined(aanvraag[parameter])) return undefined;
                    return { label: zoekLabel(parameter), value: { nl: formatterService.toDisplayValue(aanvraag[parameter], 'DD/MM/YYYY' + (includeTime ? ' HH:mm' : '')) } };
                };
                var _asJaNeen = function (parameter, aanvraag) {
                    if (angular.isUndefined(aanvraag[parameter])) return undefined;
                    return { label: zoekLabel(parameter), value: aanvraag[parameter] ? Constants.Meertaligheid.Ja : Constants.Meertaligheid.Neen };
                };

                var _cleanUp = function (object) {
                    var keys = Object.keys(object);
                    for (var i = 0, len = keys.length; i < len; ++i) {
                        if (angular.isUndefined(object[keys[i]]))
                            delete object[keys[i]];
                    }

                    if (Object.keys(object).length <= 0)
                        return undefined;
                    else
                        return object;
                };

                // Legendes
                ctrl.legends = {
                    voertuig: zoekLegende('Voertuig'),
                    aanvraag: zoekLegende('Aanvraag'),
                    betaling: zoekLegende('Betaling'),
                    bijlagen: zoekLegende('Bijlagen'),
                    documenten: zoekLegende('Documenten')
                };

                // Empty
                ctrl.empty = {
                    bijlagen: zoekEmpty('Bijlagen'),
                    documenten: zoekEmpty('Documenten')
                };

                // Overzicht
                ctrl.status = _asValue(Enums.Parameters.AanvraagStatus, aanvraag);
                ctrl.referentieNummer = _asParameterValue(Enums.Parameters.AanvraagNummer, aanvraag);
                ctrl.laatstBijgewerkt = _asDate(Enums.Parameters.AStadStatusDatum, aanvraag, true);

                // Voertuig Gegevens
                ctrl.voertuig = {
                    nummerplaat: _asParameterValue(Enums.Parameters.Voertuig.Nummerplaat, aanvraag),
                    landcode: _asParameterValue(Enums.Parameters.Voertuig.Landcode, aanvraag),

                    categorie: _asMeertaligheid(Enums.Parameters.Voertuig.Categorie, aanvraag),
                    brandstoftype: _asMeertaligheid(Enums.Parameters.Voertuig.BrandstofTypeUitgebreid, aanvraag),
                    euronorm: _asMeertaligheid(Enums.Parameters.Voertuig.Euronorm, aanvraag)
                    
                };

                if (parameterHelperService.isVerrijkt())
                    ctrl.voertuig.euronormVerrijkt = _asMeertaligheid(Enums.Parameters.Voertuig.EuronormVerrijkt, aanvraag);
                if (parameterHelperService.isGecorrigeerd())
                    ctrl.voertuig.euronormGecorrigeerd = _asMeertaligheid(Enums.Parameters.Voertuig.EuronormGecorrigeerd, aanvraag);

                ctrl.voertuig = _cleanUp(ctrl.voertuig);

                // Aanvraag Gegevens
                ctrl.aanvraag = {
                    id: ctrl.referentieNummer,
                    type: _asMeertaligheid(Enums.Parameters.AanvraagType, aanvraag),
                    soort: _asMeertaligheid(Enums.Parameters.AanvraagSoort, aanvraag),

                    // Periode
                    startDatum: _asDate(Enums.Parameters.BeginDatum, aanvraag, true),
                    eindDatum: _asDate(Enums.Parameters.EindDatum, aanvraag, true),
                    duur:  _asValue(Enums.Parameters.Termijn, aanvraag)
                };
                ctrl.aanvraag = _cleanUp(ctrl.aanvraag);
                
                // Facturatie en Betaling
                if (angular.isDefined(aanvraag[Enums.Parameters.Tarief])) {
                    ctrl.betaling = {
                        btwnummer: _asParameterValue(Enums.Parameters.Bedrijf.BTWNummer, aanvraag),

                        bedrag: _asNederlands(Enums.Parameters.Betaling.Bedrag, aanvraag),

                        OGMS: _asNederlands(Enums.Parameters.Betaling.Mededeling, aanvraag),
                        betaald: _asJaNeen(Enums.Parameters.Betaling.IsBetaald, aanvraag)
                    };
                    ctrl.betaling = _cleanUp(ctrl.betaling);
                }

                // Bijlagen
                ctrl.bijlagen = bijlagenService.getAll();

                // Documenten
                ctrl.documenten = bijlagenService.getDocumenten();

                return aanvraag;
            };
            var toonKnoppen = function (aanvraag) {
                ctrl.acties = {};
                for (var i = 0, len = aanvraag.EloketActies.length; i < len; ++i) {
                    var actie = aanvraag.EloketActies[i];
                    switch (actie.parameterValue) {
                        case 'ACTIE_VERL':
                            ctrl.magVerlengen = true;
                            ctrl.acties.verlengen = actie;
                            break;
                        case 'ACTIE_KOPIER':
                            ctrl.magKopieren = true;
                            ctrl.acties.kopieren = actie;
                            break;
                        case 'ACTIE_TOEVOEGEN':
                            ctrl.magToevoegen = true;
                            ctrl.acties.toevoegen = actie;
                            break;
                        case 'ACTIE_INDIENEN':
                            ctrl.magIndienen = true;
                            ctrl.acties.indienen = actie;
                            break;
                        case 'ACTIE_VERWIJDERENCONCEPT':
                            ctrl.magVerwijderen = true;
                            ctrl.acties.verwijderen = actie;
                            break;
                        case 'ACTIE_WIJZIGEN':
                            ctrl.magWijzigen = true;
                            ctrl.acties.wijzigen = actie;
                            break;
                        case 'ACTIE_BIJLAGENBEHEREN':
                            ctrl.magBijlagenBeheren = true;
                            ctrl.acties.bijlagenBeheren = actie;
                            break;
                    }
                }

                if (validationService.validate(Enums.Parameters.BeginDatum, aanvraag).isValid()) {
                    ctrl.kanBijlagenBeheren = true;
                    parameterHelperService.bereken(Enums.Parameters.VolledigheidAanvraag).then(function (res) {
                        if (res === 2) ctrl.kanIndienen = true;
                    });
                }

                if (ctrl.magVerlengen)
                    parameterHelperService.bereken(Enums.Parameters.VerlengbaarheidAanvraag).then(function (res) { if (res === true) ctrl.kanVerlengen = true; });
                if (ctrl.magKopieren)
                    parameterHelperService.bereken(Enums.Parameters.KopieerbaarheidAanvraag).then(function (res) { if (res === true) ctrl.kanKopieren = true; });

                return aanvraag;
            };
            var toonStatusBoodschap = function (aanvraag) {
                if (aanvraag.StatusBoodschap) {
                    ctrl.statusBoodschap = {
                        meertaligheid: aanvraag.StatusBoodschap,
                        style: !angular.isNullOrWhitespace(aanvraag.StatusBoodschapStijl) ? aanvraag.StatusBoodschapStijl : 'color: #000000; background-color: #EEEEEE; border-color: #000000;'
                    };
                }
                return aanvraag;
            };
            var laadInfoKnoppen = function (aanvraag) {
                ctrl.infobuttons = meertaligheidService.get({ scherm: 84, type: 'Infobutton', visible: true });
                return aanvraag;
            };
            
            authenticatieService.login($stateParams[Enums.Parameters.AanvraagNummer], $stateParams['f']) // Login requesten
                                .then(undefined, onAuthError)
                                .then(laadAanvraag) // Aanvraag laden
                                .then(laadBijlagen) // Bijlagen laden
                                .then(laadTeksten) // Teksten laden
                                .then(toonKnoppen) // Toon de mogelijke knoppen
                                .then(toonStatusBoodschap) // Status boodschap tonen
                                .then(laadInfoKnoppen) // Info knoppen tonen
                                .finally(function () { ctrl.isLoading = false; });
        }

        function _magVerwijderen() {
            if (!angular.isObject(ctrl.acties.verwijderen)) return false;

            var taal = parameterService.get(Enums.Parameters.Taal);
            var tekst = ctrl.acties.verwijderen[taal];
            tekst = tekst ? tekst : ctrl.acties.verwijderen.nl;
            
            return confirm(tekst + "?");
        }

        // Acties
        ctrl.verlengen = function () {
            _navigate(Enums.NavigatieActies.Verlengen);
        };
        ctrl.kopieren = function () {
            _navigate(Enums.NavigatieActies.Kopieren);
        };
        ctrl.toevoegen = function () {
            parameterService.clearAll();
            bijlagenService.init();
            _navigate(Enums.NavigatieActies.Toevoegen);
        };
        ctrl.indienen = function () {
            _navigate(Enums.NavigatieActies.Indienen);
        };
        ctrl.verwijderen = function () {
            ctrl.isDeleting = true;
            if (!_magVerwijderen()) {
                ctrl.isDeleting = false;
                return;
            }
            aanvraagService.remove(parameterService.get(Enums.Parameters.AanvraagNummer)).then(function () {
                errorService.success('SUC_AVR_02', undefined, [parameterService.get(Enums.Parameters.AanvraagNummer)]);
                parameterService.clearAll();
                _navigate(Enums.NavigatieActies.Verwijderen);
            }, function (error) {
                var ERR_MSG = 'ERR_AVR_02';
                if (error.ErrorCodes) {
                    // Filter ErrorCodes, indien 0804 er in zit, ERR_AVR_02A
                    for (var i = 0, len = error.ErrorCodes.length; i < len; ++i) {
                        if (error.ErrorCodes[i] === '0804') ERR_MSG = 'ERR_AVR_02A';
                    }
                }
                errorService.error(ERR_MSG, error.ErrorCodes);
            })
            .finally(function () { ctrl.isDeleting = false; });
        };
        ctrl.wijzigen = function () {
            _navigate(Enums.NavigatieActies.Wijzigen);
        };
        ctrl.beheerBijlagen = function () {
            _navigate(Enums.NavigatieActies.BijlagenBeheren);
        };

        function _navigate(actie) {
            navigatieService.start(actie);
            $state.transitionTo('main.scherm.detail.default', {}, { location: true, notify: true, inherit: false, reload: true });
            $anchorScroll();
        }

        // Extra functionaliteit
        ctrl.download = function (aanvraagId, bijlageId) {
            bijlagenService.download(aanvraagId, bijlageId)
                .then(undefined, function (error) {
                    errorService.error('ERR_SRV_06', error.ErrorCodes);
                });
        };
    };

    theController.$inject = ['appEnums', 'appConstants', 'LEZErrorService', 'AuthenticatieService', 'AanvraagService', 'BijlagenService', 'ParameterService', 'ParameterHelperService', 'NavigatieService', 'FormatterService', 'MeertaligheidService', 'ValidationService', '$stateParams', '$state', '$anchorScroll'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "AuthenticationResolverController";
    var theController = function (Enums, errorService, parameterService, gebruikerService, authenticatieService, navigatieService, $stateParams, $state, $location, $cookies, $window) {
        var ctrl = this;
        ctrl.isLoading = true;

        if (angular.isDefined($stateParams.m))
            gebruikerService.validateMedewerkerData($stateParams.m).then(_onMedewerkerSuccess, _onMedewerkerError).finally(function () { ctrl.isLoading = false; });
        else if (angular.isDefined($stateParams.code))
            gebruikerService.getUserData($stateParams.code).then(_onUserSuccess, _onUserError).finally(function () { ctrl.isLoading = false; });
        else if (angular.isDefined($stateParams.a))
            _onAnoniemLogin($stateParams.a);

        // A-profiel User Login
        function _onUserSuccess(user) {
            if (angular.isUndefinedOrNull(user)) return _onUserError();
            if (angular.isDefined($stateParams.lng)) {
                var language = $stateParams.lng.toUpperCase();
                user.Taal = language;
                parameterService.set(Enums.Parameters.Taal, language);
            }
            user.ProfileType = Enums.Auth.ProfielTypes.AProfiel;
            
            var parameters = $cookies.get('LEZParams');
            if (angular.isString(parameters)) parameters = angular.fromJson(parameters);
            if (angular.isObject(parameters)) {
                // LEZ-967 - Restore and redirect
                angular.forEach(parameters, function (parvalue, param) { parameterService.prefill(param, parvalue); });
                authenticatieService.setUser(user);
                authenticatieService.login()
                    .finally(function () {
                        navigatieService.start(Enums.NavigatieActies.Restore)
                            .finally(function () {
                                $cookies.remove('LEZParams');
                                $cookies.remove('LEZAuthCallbackRedirectUrl');
                                $state.go('main.scherm.detail.default');
                            });
                    });
            }
            else {
                authenticatieService.setUser(user);
                navigatieService.start();
                setAuthCallbackRedirectUrl();
            }
        }

        function _onUserError(error) {
            $cookies.remove('LEZsessionuser');
            errorService.error('ERR_AUTH_01A', error.ErrorCodes);
            $state.go('main.scherm.detail.default');
        }

        // Medewerker Login
        function _onMedewerkerSuccess(medewerker) {
            if (angular.isUndefinedOrNull(medewerker)) return _onMedewerkerError();

            parameterService.set(Enums.Parameters.Medewerker.Identificatie, medewerker.userId);
            parameterService.set(Enums.Parameters.Medewerker.Naam, medewerker.userName);
            parameterService.set(Enums.Parameters.Medewerker.Token, medewerker.token);
            if (angular.isDefined(medewerker.loket))
                parameterService.set(Enums.Parameters.Medewerker.Loket, medewerker.loket.nl);
            if (angular.isDefined(medewerker.kanaal))
                parameterService.set(Enums.Parameters.Kanaal, medewerker.kanaal.parameterValue);
            if (!angular.isNullOrWhitespace(medewerker.taal))
                parameterService.set(Enums.Parameters.Taal, medewerker.taal);
            if (!angular.isNullOrWhitespace(medewerker.kassaToepassing))
                parameterService.set(Enums.Parameters.Medewerker.KassaToepassing, medewerker.kassaToepassing);

            parameterService.clear([
                Enums.Parameters.Gebruiker.Identificatie,
                Enums.Parameters.Gebruiker.Token,
                Enums.Parameters.Aanvrager.Naam,
                Enums.Parameters.Aanvrager.Voornaam,
                Enums.Parameters.Aanvrager.Email
            ]);

            navigatieService.start();
            $location.url($stateParams.path);
        }

        function _onMedewerkerError(error) {
            if (angular.isUndefined(error)) error = { ErrorCodes: [] };
            errorService.error('ERR_AUTH_01B', error.ErrorCodes);
            $state.go('main.scherm.detail.default');
        }

        // Anonieme Login
        function _onAnoniemLogin(a) {
            var user = authenticatieService.userIsAnoniem();
            if (user.Token === a) setAuthCallbackRedirectUrl();
            else {
                $cookies.remove('LEZsessionuser');
                errorService.error('ERR_AUTH_01A', error.ErrorCodes);
                $state.go('main.scherm.detail.default');
            }
        }

        // Other
        function setAuthCallbackRedirectUrl() {
            var url = $cookies.get('LEZAuthCallbackRedirectUrl');

            if (angular.isString(url) && url.length > 0) 
                $window.location = url;
            else
                $state.go('main.scherm.detail.default');

            $cookies.remove('LEZAuthCallbackRedirectUrl');
        }
    };

    theController.$inject = ['appEnums', 'LEZErrorService', 'ParameterService', 'GebruikerService', 'AuthenticatieService', 'NavigatieService', '$stateParams', '$state', '$location', '$cookies', '$window'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "BoeteResolverController";
    var theController = function (Enums, navigatieService, $stateParams, $state, parameterService, authenticatieService) {
        var ctrl = this;

        init();

        function init() {
            ctrl.isLoading = true;
            ctrl.isError = false;

            var isAProfiel = authenticatieService.userIsAprofiel();
            var isAnoniem = authenticatieService.userIsAnoniem();

            if (isAProfiel) {
                parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.EloketAprofiel);

                parameterService.set(Enums.Parameters.Aanvrager.Naam, isAProfiel.Familienaam);
                parameterService.set(Enums.Parameters.Aanvrager.Voornaam, isAProfiel.Voornaam);
                parameterService.set(Enums.Parameters.Aanvrager.Email, isAProfiel.Email);
            } else if (isAnoniem) {
                parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.EloketEmail);
                parameterService.set(Enums.Parameters.Aanvrager.Email, isAnoniem.Email);
            } else {
                parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.Checktool);
            }

            navigatieService.start(Enums.NavigatieActies.BoeteNummer);

            var parameters = {};
            parameters[Enums.Parameters.Taal] = $stateParams[Enums.Parameters.Taal];
            $state.go('default', parameters);
        }
    };

    theController.$inject = ['appEnums', 'NavigatieService', '$stateParams', '$state', 'ParameterService', 'AuthenticatieService'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "ChatResolverController";
    var theController = function ($stateParams, $window, $rootScope, errorService) {
        var ctrl = this;
        ctrl.isLoading = true;
        $rootScope.mode = 'blank';

        var redirectUrl = $stateParams.RedirectUrl;

        if (angular.isNullOrWhitespace(redirectUrl)) {
            errorService.error('ERR_CHA_02');
        }
        else {
            $window.location = decodeURIComponent(redirectUrl);
        }
    };

    theController.$inject = ['$stateParams', '$window', '$rootScope', 'LEZErrorService'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "DagpasResolverController";
    var theController = function (Enums, parameterService, navigatieService, $stateParams, $state) {
        var ctrl = this;
        ctrl.isLoading = true;

        var nummerplaat = parameterService.get(Enums.Parameters.Voertuig.Nummerplaat);
        var land = parameterService.get(Enums.Parameters.Voertuig.Landcode);

        parameterService.clearAll();

        if (!angular.isNullOrWhitespace(nummerplaat))
            parameterService.prefill(Enums.Parameters.Voertuig.Nummerplaat, nummerplaat);
        if (!angular.isNullOrWhitespace(land))
            parameterService.prefill(Enums.Parameters.Voertuig.Landcode, land);

        parameterService.set(Enums.Parameters.AanvraagType, Enums.AanvraagType.Dagpas);
        parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.EloketEmail);

        navigatieService.start(Enums.NavigatieActies.Dagpas);

        var parameters = {};
        parameters[Enums.Parameters.Taal] = $stateParams[Enums.Parameters.Taal];
        $state.go('default', parameters);
    };

    theController.$inject = ['appEnums', 'ParameterService', 'NavigatieService', '$stateParams', '$state'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "DefaultResolverController";
    var theController = function (Enums, errorService, parameterService, navigatieService, $stateParams, $state, $timeout) {
        var ctrl = this;
        ctrl.isLoading = true;

        _init();
        _zetTaal();

        function _init() {
            if (navigatieService.isStarted()) return;

            var params = $stateParams['p'];
            if (angular.isString(params)) {
                try {
                    parameterService.setEncodedQueryString(params);
                } catch (ex) {
                    errorService.error('ERR_PARAM_04');
                }
            }

            navigatieService.start();
        }

        function _zetTaal() {
            var taal = $stateParams[Enums.Parameters.Taal];
            if (angular.isString(taal)) {
                var matches = taal.trim().match(/^(NL|FR|EN|DE)$/i);
                if (matches) taal = matches[1].toUpperCase();
                else taal = undefined;
            } else taal = undefined;
            if (angular.isUndefined(taal)) taal = parameterService.get(Enums.Parameters.Taal, true);
            parameterService.set(Enums.Parameters.Taal, taal); // Taal zetten met de huidige waarde of de Default waarde.
        }

        $timeout(function () { $state.go('main.scherm.detail.default', $stateParams); }, 0, false);        
    };

    theController.$inject = ['appEnums', 'LEZErrorService', 'ParameterService', 'NavigatieService', '$stateParams', '$state', '$timeout'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "EloketResolverController";
    var theController = function (Enums, errorService, authenticatieService, aanvraagService, parameterService, parameterHelperService, navigatieService, $stateParams, $state, $anchorScroll) {
        var ctrl = this;
        init();

        function init() {
            ctrl.isLoading = true;
            ctrl.isError = false;

            ctrl.actie = $stateParams['ELOK_ACTIE'];

            navigatieService.start();

            var onAuthError = function (error) {
                errorService.error('ERR_AUTH_02', error.ErrorCodes);
                ctrl.isError = true;
                throw undefined;
            };
            var aanvraagLaadError = function (error) {
                var errorCode = 'ERR_AVR_01';
                switch (error.status) {
                    case 401:
                        if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.EloketEmail)) {
                            authenticatieService.setUser(undefined);
                            authenticatieService.login($stateParams[Enums.Parameters.AanvraagNummer]);
                            errorCode = 'ERR_AUTH_03';
                        }
                        else
                            errorCode = 'ERR_AUTH_02';
                        break;
                    case 404:
                        errorCode = 'ERR_AVR_01A';
                        break;
                }
                errorService.error(errorCode, error.ErrorCodes);
                ctrl.isError = true;
                throw undefined;
            };
            var aanvraagLaadSucces = function (aanvraag) {
                if (angular.isUndefined(aanvraag)) {
                    errorService.error('ERR_AVR_01A');
                    ctrl.isError = true;
                    throw undefined;
                }

                var params = Object.keys(aanvraag);
                for (var i = 0, len = params.length; i < len; ++i) {
                    var param = params[i];
                    switch (param) {
                        case 'EloketActies':
                        case 'StatusBoodschap':
                        case 'StatusBoodschapStijl':
                            continue;
                        case Enums.Parameters.Medewerker.Loket:
                        case Enums.Parameters.Medewerker.Identificatie:
                        case Enums.Parameters.Medewerker.Naam:
                            if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.DLloket, Enums.Kanaal.BackOffice]))
                                continue;
                            break;
                    }
                    parameterService.set(param, aanvraag[param]);
                }
            };
            var laadAanvraag = function () {
                var getUserData = function () {
                    var userdata = {
                        kanaal: parameterService.get(Enums.Parameters.Kanaal),
                        ignoreType: $stateParams['f'] ? true : false
                    };
                    switch (userdata.kanaal) {
                        case Enums.Kanaal.EloketAprofiel:
                            userdata.userId = parameterService.get(Enums.Parameters.Gebruiker.Identificatie);
                            userdata.userToken = parameterService.get(Enums.Parameters.Gebruiker.Token);
                            break;
                        case Enums.Kanaal.EloketEmail:
                            userdata.mail = parameterService.get(Enums.Parameters.Aanvrager.Email);
                            userdata.datum = parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                            break;
                        case Enums.Kanaal.DLloket:
                        case Enums.Kanaal.BackOffice:
                            userdata.userId = parameterService.get(Enums.Parameters.Medewerker.Identificatie);
                            userdata.userToken = parameterService.get(Enums.Parameters.Medewerker.Token);
                            break;
                    }
                    return userdata;
                };
                return aanvraagService.getById($stateParams[Enums.Parameters.AanvraagNummer], getUserData()).then(aanvraagLaadSucces, aanvraagLaadError);
            };
            var canDoAction = function () {
                if (angular.isNullOrWhitespace(ctrl.actie))
                    return false;
                else if (ctrl.actie === 'renew')
                    return parameterHelperService.bereken(Enums.Parameters.VerlengbaarheidAanvraag);
                else if (ctrl.actie === 'copy')
                    return parameterHelperService.bereken(Enums.Parameters.KopieerbaarheidAanvraag);
                else
                    return false;
            };
            var doAction = function (canDo) {
                if (canDo !== true)
                    navigatieService.start(Enums.NavigatieActies.Wijzigen);
                else if (ctrl.actie === 'renew')
                    navigatieService.start(Enums.NavigatieActies.Verlengen);
                else if (ctrl.actie === 'copy')
                        navigatieService.start(Enums.NavigatieActies.Kopieren);
                $state.transitionTo('main.scherm.detail.default', {}, { location: true, notify: true, inherit: false, reload: true });
                $anchorScroll();
            };

            authenticatieService.login($stateParams[Enums.Parameters.AanvraagNummer], $stateParams['f']) // Login requesten
                .then(undefined, onAuthError)
                .then(laadAanvraag) // Aanvraag laden
                .then(canDoAction) // Controleren of de actie mag worden uitgevoerd
                .then(doAction);
        }
    };

    theController.$inject = ['appEnums', 'LEZErrorService', 'AuthenticatieService', 'AanvraagService', 'ParameterService', 'ParameterHelperService', 'NavigatieService', '$stateParams', '$state', '$anchorScroll'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "InfoKioskResolverController";
    var theController = function (CONFIG, Enums, parameterService, $state, $stateParams, $timeout, infokioskService, errorService) {
        var ctrl = this;
        ctrl.isLoading = true;

        _init();

        function _init() {
            ctrl.isLoading = true;
            var kioskId = $stateParams.kioskId;
            infokioskService.getKioskInfo(kioskId)
                .then(function (result) {
                    if (!angular.isObject(result)) {
                        if (CONFIG.environment !== 'LOCAL')
                            throw undefined;
                        else {
                            result = {};
                            result[Enums.Parameters.Kiosk.Id] = kioskId;
                            result[Enums.Parameters.Kiosk.Naam] = 'TEST LOCAL';
                        }
                    }

                    parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk);
                    parameterService.set(Enums.Parameters.Kiosk.Id, result[Enums.Parameters.Kiosk.Id]);
                    parameterService.set(Enums.Parameters.Kiosk.Naam, result[Enums.Parameters.Kiosk.Naam]);
                    parameterService.clear(Enums.Parameters.Kiosk.SessieId);

                    var parameters = {};
                    parameters[Enums.Parameters.Taal] = $stateParams[Enums.Parameters.Taal];
                    $state.go('default', parameters);
                })
                .then(undefined, function (error) {
                    if (angular.isUndefined(error))
                        ctrl.errorMessage = errorService.get('ERR_IK_02'); // Kon de Kiosk niet bevestigen
                    else
                        ctrl.errorMessage = errorService.get('ERR_IK_01', error.ErrorCodes); // Tijdelijk niet beschikbaar

                    $timeout(_init, 15000);
                })
                .finally(function () {
                    ctrl.isLoading = false;
                });
        }

    };

    theController.$inject = ['appConfig', 'appEnums', 'ParameterService', '$state', '$stateParams', '$timeout', 'InfokioskService', 'ErrorMessageService'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "LoginResolverController";
    var theController = function (Enums, navigatieService, $stateParams, $state) {
        var ctrl = this;
        ctrl.isLoading = true;

        navigatieService.start($stateParams['eid'] ? Enums.NavigatieActies.Relog : Enums.NavigatieActies.Login);

        var parameters = { p: $stateParams['p'] };
        parameters[Enums.Parameters.Taal] = $stateParams[Enums.Parameters.Taal];
        $state.go('default', parameters);
    };

    theController.$inject = ['appEnums', 'NavigatieService', '$stateParams', '$state'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "PaymentResolverController";
    var theController = function (Enums, authenticatieService, parameterService, errorService, paymentService, navigatieService, $stateParams, $state) {
        var ctrl = this;

        ctrl.isLoading = true;

        var aanvraagNummer = $stateParams[Enums.Parameters.AanvraagNummer];
        authenticatieService.login(aanvraagNummer, true).then(init); // Make sure we are logged in before continue-ing

        function init() {  
            parameterService.set(Enums.Parameters.AanvraagNummer, aanvraagNummer);
            paymentService.processOgoneStatus(aanvraagNummer, $stateParams[Enums.Parameters.Betaling.Status])
                                .then(function (result) {
                                    if (!angular.isDefined(result.status)) throw { ErrorCodes: [] };

                                    parameterService.set(Enums.Parameters.Betaling.Status, result.status);
                                    if (result.status === 'ACC')
                                        errorService.success('SUC_PAY_01', undefined, [aanvraagNummer]);
                                })
                                .then(undefined, function (error) {
                                    errorService.error('ERR_PAY_01', error.ErrorCodes);
                                })
                                .finally(function () {
                                    var action = parameterService.equals(Enums.Parameters.Betaling.Status, 'ACC') ? Enums.NavigatieActies.Ogone : Enums.NavigatieActies.OgoneFailed;
                                    navigatieService.start(action);
                                    $state.go('default', $stateParams);
                                });
        }
    };

    theController.$inject = ['appEnums', 'AuthenticatieService', 'ParameterService', 'LEZErrorService', 'PaymentService', 'NavigatieService', '$stateParams', '$state'];

    angular.module('theApp').controller(ctrlName, theController);

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

    var ctrlName = "AanvraagSoortViewController";
    var theController = function (Enums, Constants, scherm, vragen, subtitels, parameterService, parameterHelperService, validationService) {
        var ctrl = this;

        ctrl.scherm = scherm;
        ctrl.categories = [];
        ctrl.validations = {};

        ctrl.validate = function (param, category, hideResult) {
            ctrl.validations[param] = validationService.validate(param, scherm.selectedValues);

            if (!ctrl.validations[param].isValid()) {
                scherm.setValid(false)
            } else {
                scherm.setValid(true);
                angular.forEach(ctrl.validations, function (res) {
                    if (res.isValid()) return;
                    scherm.setValid(false);
                });
            }

            if (category) {
                switch (category.titel.conditie) {
                    case Enums.Parameters.LusZichtbaarheid + '[1A]':
                        parameterService.set(Enums.Parameters.Verstrenging, false, true);
                        break;
                    case Enums.Parameters.LusZichtbaarheid + '[1B]':
                    case Enums.Parameters.LusZichtbaarheid + '[1C]':
                        parameterService.set(Enums.Parameters.Verstrenging, true, true);
                        break;
                }
            }

            if (hideResult) ctrl.validations[param].messages = [];
        };

        ctrl.getId = function (vraag) {
            var id = vraag.label.param;
            if (!angular.isNullOrWhitespace(vraag.label.parvalue)) id += '_' + vraag.label.parvalue;
            return id;
        };

        init();

        function init() {
            var regTechKenVraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[1]' });
            var regTechKen2020Vraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[15]' });
            var regEuroCorrigVraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[2]' });
            var regEuroCorrig2020Vraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[16]' });
            var ghcVrijstellingVraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[4]' });
            var ghcVrijstelling2020Vraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[17]' });
            var toelatingInwLEZDE3Vraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[5]' });
            var toelatingInwLEZDE4Vraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[18]' });
            var toelatingDE3Vraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[9]' });
            var toelatingDE4Vraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[22]' });
            var oldtimerVraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[6]' });
            var regRoetfilterVraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[3]' });
            var regAndereRedenVraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[12]' });
            var vrijstellingUitzVvVraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[13]' });
            var vrijstellingPrioVraag = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[14]' });

            // LEZ-1346
            var toelatingNoodsituatie = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[10]' && (x.label.conditievalue === '5' || x.label.conditievalue === '6' || x.label.conditievalue === '1' || x.label.conditievalue === '2' || x.label.conditievalue === '3' || x.label.conditievalue === '4') });
            var toelatingNoodsituatieBis = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[10]' && (x.label.conditievalue === '7' || x.label.conditievalue === '8' || x.label.conditievalue === '10' || x.label.conditievalue === '12' || x.label.conditievalue === '14' || x.label.conditievalue === '15') });
            var toelatingNoodsituatie2020 = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[23]' && (x.label.conditievalue === '5' || x.label.conditievalue === '6' || x.label.conditievalue === '1' || x.label.conditievalue === '2' || x.label.conditievalue === '3' || x.label.conditievalue === '4') });
            var toelatingNoodsituatie2020Bis = vragen.filter(function (x) { return x.label.conditie === 'VWD41B[23]' && (x.label.conditievalue === '20' || x.label.conditievalue === '21' || x.label.conditievalue === '11' || x.label.conditievalue === '22') });
            var toelatingWerken = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[7]' && (x.label.conditievalue === '5' || x.label.conditievalue === '6' || x.label.conditievalue === '1' || x.label.conditievalue === '2' || x.label.conditievalue === '3' || x.label.conditievalue === '4') });
            var toelatingWerkenBis = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[7]' && (x.label.conditievalue === '7' || x.label.conditievalue === '8' || x.label.conditievalue === '10' || x.label.conditievalue === '12' || x.label.conditievalue === '14' || x.label.conditievalue === '15') });
            var toelatingWerken2020 = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[20]' && (x.label.conditievalue === '5' || x.label.conditievalue === '6' || x.label.conditievalue === '1' || x.label.conditievalue === '2' || x.label.conditievalue === '3' || x.label.conditievalue === '4') });
            var toelatingWerken2020Bis = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[20]' && (x.label.conditievalue === '20' || x.label.conditievalue === '21' || x.label.conditievalue === '11' || x.label.conditievalue === '22') });

            // LEZ-1349
            var toelatingAmbulanteHandel = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[8]' });
            var toelatingAmbulanteHandel2020 = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[21]' });

            // LEZ-1351
            var toelatingLEZDagpas = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[11]' });
            var toelatingLEZDagpas2020 = vragen.filter(function(x) { return x.label.conditie === 'VWD41B[24]' });

            var canRegisterAsOldtimer = parameterHelperService.canRegisterAsOldtimer();
            var paramvalues = parameterService.getParametersObject();
            var kanteldatum1 = angular.isDefined(paramvalues[Enums.Parameters.Kanteldatum1]) ? moment(paramvalues[Enums.Parameters.Kanteldatum1], 'DD/MM/YYYY').toDate() : null;
            var kanteldatum2 = angular.isDefined(paramvalues[Enums.Parameters.Kanteldatum2]) ? moment(paramvalues[Enums.Parameters.Kanteldatum2], 'DD/MM/YYYY').toDate() : null;
            var today = new Date();

            for (var i = 0, subtitel; subtitel = subtitels[i]; ++i) {
                var categorie = { titel: subtitel, vragen: [] };
                var cond = function (value) { return false; };
                switch (subtitel.conditie) {
                    case Enums.Parameters.LusZichtbaarheid + '[1]': // "Dien een aanvraag in voor"
                       if (kanteldatum1 === null && kanteldatum2 === null) {
                            cond = function (value) {
                                value = '' + value;
                                return value == '3' || value == '4';
                            };
                        }
                        break;
                    case Enums.Parameters.LusZichtbaarheid + '[1A]': // Tonen voor "Opties voor 2019"
                    case Enums.Parameters.LusZichtbaarheid + '[1B]': // Tonen voor "Opties voor 2020"
                    case Enums.Parameters.LusZichtbaarheid + '[1C]': // Tonen voor zowel "Opties voor 2019" als "Opties voor 2020"
                        cond = function (value) {
                            value = '' + value;
                            return value == '3' || value == '4';
                        };
                        break;
                    case Enums.Parameters.LusZichtbaarheid + '[2]': // 1, te onderzoeken
                        cond = function (value) {
                            value = '' + value;
                            return value == '1';
                        };
                        break;
                    case Enums.Parameters.LusZichtbaarheid + '[3]': // 2, negatief => deze opties zijn niet mogelijk
                        cond = function (value) {
                            value = '' + value;
                            return value == '2';
                        };
                        break;
                }

                for (var j = 0, vraag; vraag = vragen[j]; ++j) {
                    if (vraag.label.param !== Enums.Parameters.Keuzes.Lus) continue;

                    if (today >= kanteldatum2) {
                        if (categorie.titel.conditie === Enums.Parameters.LusZichtbaarheid + '[1]') {
                            categorie.vragen.push(vraag);
                        }
                    } else {
                        if (cond(parameterService.get(Enums.Parameters.VolledigheidLus + '[' + vraag.label.parvalue + ']'))) {
                            //
                            // Tonen voor "Opties voor 2019"
                            //
                            if (categorie.titel.conditie === Enums.Parameters.LusZichtbaarheid + '[1A]') {
                                if (
                                    (
                                        kanteldatum2 !== null &&
                                        today < kanteldatum2
                                    ) &&
                                    (
                                        vraag === regTechKenVraag[0] ||
                                        vraag === toelatingDE3Vraag[0] ||
                                        vraag === regEuroCorrigVraag[0] ||
                                        vraag === ghcVrijstellingVraag[0] ||
                                        vraag === toelatingInwLEZDE3Vraag[0] ||
                                        vraag === toelatingWerken[0] ||
                                        vraag === toelatingWerkenBis[0] ||
                                        vraag === toelatingNoodsituatie[0] ||
                                        vraag === toelatingNoodsituatieBis[0] ||
                                        vraag === toelatingAmbulanteHandel[0] ||
                                        vraag === regRoetfilterVraag[0] ||
                                        (
                                            vraag === toelatingLEZDagpas[0] &&
                                            toelatingDE3Vraag.length === 0 &&
                                            toelatingInwLEZDE3Vraag.length === 0
                                        )
                                    )
                                ) {
                                    categorie.vragen.push(vraag);
                                }
                                //
                                // Tonen voor "Opties voor 2020"
                                //
                            } else if (categorie.titel.conditie === Enums.Parameters.LusZichtbaarheid + '[1B]') {
                                if (
                                    (
                                        kanteldatum1 !== null ||
                                        kanteldatum2 !== null ||
                                        today >= kanteldatum1 &&
                                        today < kanteldatum2
                                    ) &&
                                    (
                                        vraag === toelatingDE4Vraag[0] ||
                                        vraag === toelatingInwLEZDE4Vraag[0] ||
                                        vraag === toelatingWerken2020[0] ||
                                        vraag === toelatingWerken2020Bis[0] ||
                                        vraag === toelatingNoodsituatie2020[0] ||
                                        vraag === toelatingNoodsituatie2020Bis[0] ||
                                        vraag === toelatingAmbulanteHandel2020[0] ||
                                        (
                                            vraag === toelatingLEZDagpas2020[0] &&
                                            (
                                                toelatingDE3Vraag.length === 1 ||
                                                toelatingInwLEZDE3Vraag.length === 1
                                            ) &&
                                            toelatingDE4Vraag.length === 0 &&
                                            toelatingInwLEZDE4Vraag.length === 0
                                        ) ||
                                        (
                                            vraag === toelatingLEZDagpas2020[0] &&
                                            parameterService.equals(parameterHelperService.getHoogsteENParameter(), Enums.Euronorm.EuroIIIa)
                                        )
                                    )
                                ) {
                                    categorie.vragen.push(vraag);
                                } else if (
                                    (
                                        kanteldatum2 !== null &&
                                        today >= kanteldatum2
                                    ) &&
                                    (
                                        vraag === regTechKen2020Vraag[0] ||
                                        vraag === regEuroCorrig2020Vraag[0] ||
                                        vraag === toelatingDE4Vraag[0] ||
                                        vraag === ghcVrijstelling2020Vraag[0] ||
                                        vraag === toelatingInwLEZDE4Vraag[0] ||
                                        vraag === toelatingWerken2020[0] ||
                                        vraag === toelatingWerken2020Bis[0] ||
                                        vraag === toelatingNoodsituatie2020[0] ||
                                        vraag === toelatingNoodsituatie2020Bis[0] ||
                                        vraag === toelatingAmbulanteHandel2020[0] ||
                                        vraag === oldtimerVraag[0] ||
                                        vraag === regAndereRedenVraag[0] ||
                                        vraag === vrijstellingUitzVvVraag[0] ||
                                        vraag === vrijstellingPrioVraag[0] ||
                                        (
                                            vraag === toelatingLEZDagpas2020[0] &&
                                            toelatingDE4Vraag.length === 0 &&
                                            toelatingInwLEZDE4Vraag.length === 0
                                        )
                                    )
                                ) {
                                    categorie.vragen.push(vraag);
                                }
                                //
                                // Tonen voor zowel "Opties voor 2019" als "Opties voor 2020"
                                //
                            } else if (categorie.titel.conditie === Enums.Parameters.LusZichtbaarheid + '[1C]') {
                                if (
                                    (
                                        kanteldatum1 !== null &&
                                        kanteldatum2 !== null &&
                                        today >= kanteldatum1 &&
                                        today < kanteldatum2
                                    ) &&
                                    (
                                        vraag === regTechKen2020Vraag[0] ||
                                        vraag === regEuroCorrig2020Vraag[0] ||
                                        vraag === ghcVrijstelling2020Vraag[0] ||
                                        vraag === oldtimerVraag[0] ||
                                        vraag === regAndereRedenVraag[0] ||
                                        vraag === vrijstellingUitzVvVraag[0] ||
                                        vraag === vrijstellingPrioVraag[0] ||
                                        (
                                            vraag === toelatingLEZDagpas2020[0] &&
                                            toelatingDE3Vraag.length === 0 &&
                                            toelatingInwLEZDE3Vraag.length === 0 &&
                                            toelatingDE4Vraag.length === 0 &&
                                            toelatingInwLEZDE4Vraag.length === 0 &&
                                            !parameterService.equals(parameterHelperService.getHoogsteENParameter(), Enums.Euronorm.EuroIIIa)
                                        )
                                    )
                                ) {
                                    categorie.vragen.push(vraag);
                                }
                            } else {
                                categorie.vragen.push(vraag);
                            }

                        }
                    }
                }

                if (categorie.vragen.length > 0) ctrl.categories.push(categorie);
                if (ctrl.categories.length > 0 && canRegisterAsOldtimer && (paramvalues[Enums.Parameters.Kanaal] !== Enums.Kanaal.InformatieKiosk || paramvalues[Enums.Parameters.Kanaal] !== Enums.Kanaal.InformatieKioskChecktool))
                    ctrl.categories[0].vragen.splice(1);
            }

            if (ctrl.categories.length === 1 && ctrl.categories[0].vragen.length === 1) {
                scherm.selectedValues[Enums.Parameters.Keuzes.Lus] = ctrl.categories[0].vragen[0].label.parvalue;
            } else {
                scherm.selectedValues[Enums.Parameters.Keuzes.Lus] = getValue(Enums.Parameters.Keuzes.Lus, paramvalues);
            }

            // Validation
            ctrl.validate(Enums.Parameters.Keuzes.Lus, ctrl.categories[0], true);
        }

        function getValue(parameter, params) {
            var value = params[parameter];
            if (angular.isDefined(value)) return value;
            value = scherm.selectedValues[parameter];
            if (angular.isDefined(value)) return value;
            return parameterService.get(parameter, true, true);
        }
    };

    angular.module('theApp').controller(ctrlName, theController);
})();
;
(function () {
    'use strict';

    var ctrlName = "BijlagenViewController";
    var theController = function (Enums, meertaligheidService, navigatieService, parameterService, parameterHelperService, codeService, bijlagenService, Code, $q) {
        var ctrl = this;

        var scherm = navigatieService.huidigScherm();
        
        function getVWBIJL(soort) {
            if (angular.isUndefinedOrNull(soort)) return 0; 
            if (!angular.isString(soort.parameterValue)) return 0;
            var index = parseInt(soort.parameterValue);
            var voorwaarden = parameterService.get(Enums.Parameters.Bijlagen.Voorwaarden);
            return voorwaarden[index];
        }

        function _berekenFields() {
            for (var i = 0, len = ctrl.bijlageSoorten.length; i < len; ++i) {
                var soort = ctrl.bijlageSoorten[i];
                var vwbijl = getVWBIJL(soort);
                
                soort.visible = vwbijl > 0 && soort.isActief;
                soort.enabled = vwbijl > 1;
                soort.required = vwbijl > 2;
            }
        }

        ctrl.validate = function (soort) {
            var voorwaarden = parameterService.get(Enums.Parameters.Bijlagen.Voorwaarden);
            if (angular.isUndefined(voorwaarden)) {
                ctrl.scherm.setValid(false);
                parameterHelperService.bereken(Enums.Parameters.Bijlagen.Voorwaarden)
                    .then(function () {
                        _berekenFields();
                        ctrl.validate(soort);
                    }, function (reason) {
                        scherm.setValid(false);
                    });
                return;
            }

            scherm.setValid(isValid());
        };

        function isValid() {
            for (var i = 0, len = ctrl.bijlageSoorten.length; i < len; ++i) {
                var soort = ctrl.bijlageSoorten[i];
                var files = bijlagenService.getBySoort(soort);
                var hasItems = files.length > 0;
                if (soort.required && !hasItems) return false;
            }

            return true;
        }

        init();

        function init() {
            ctrl.isLoading = true;
            ctrl.files = {};
            ctrl.bijlageSoorten = [];
            scherm.setValid(false);

            ctrl.limitTekst = meertaligheidService.get({ scherm: scherm.schermNr, type: 'Legendes', naam: 'LimietTekst' }).shift();

            $q.all({
                'bijlagen': bijlagenService.init(parameterService.get(Enums.Parameters.AanvraagNummer)),
                'voorwaarden': parameterHelperService.bereken(Enums.Parameters.Bijlagen.Voorwaarden),
                'soorten': codeService.getByCodeSoort(Code.getSoort(Enums.Parameters.Bijlagen.Bijlagen))
            }).then(function (results) {
                ctrl.bijlageSoorten = results.soorten;
                ctrl.files = {};
                scherm.setValid(isValid());
                _berekenFields();
            }).finally(function () { ctrl.isLoading = false;});
        }
    };

    theController.$inject = ['appEnums', 'MeertaligheidService', 'NavigatieService', 'ParameterService', 'ParameterHelperService', 'CodeService', 'BijlagenService', 'Code', '$q'];

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "DagpasViewController";
    var theController = function (Enums, navigatieService, meertaligheidService, parameterService, validationService, errorService, tariefService, dagpasService) {
        var ctrl = this;

        ctrl.isLoading = true;
        ctrl.scherm = navigatieService.huidigScherm();
        ctrl.scherm.setValid(false);
        ctrl.validations = {};
        ctrl.minValue = function (param) {
            return validationService.getMinValue(param, ctrl.scherm.selectedValues);
        };
        ctrl.maxValue = function (param) {
            return validationService.getMaxValue(param, ctrl.scherm.selectedValues);
        };
        ctrl.dateChanged = function (hideValidation) {
            var beginDatum = ctrl.scherm.selectedValues[Enums.Parameters.BeginDatum];
            if (!angular.isDate(beginDatum)) {
                _validate();
                return;
            }

            ctrl.isLoading = true;

            ctrl.tarief = undefined;
            ctrl.scherm.selectedValues[Enums.Parameters.Tarief] = undefined;
            ctrl.scherm.selectedValues[Enums.Parameters.Termijn] = undefined;
            ctrl.scherm.selectedValues[Enums.Parameters.Betaling.Bedrag] = undefined;
            ctrl.scherm.selectedValues[Enums.Parameters.Betaling.KassaCode] = undefined;
            ctrl.scherm.selectedValues[Enums.Parameters.EindDatum] = undefined;

            var params = parameterService.getParametersObject();
            params.BDAT = beginDatum;

            tariefService.search(params)
                         .then(function (tarieven) {
                             var tarief = tarieven.shift();
                             if (!angular.isUndefined(tarief)) {
                                 ctrl.tarief = tarief;

                                 ctrl.scherm.selectedValues[Enums.Parameters.Tarief] = tarief.id;
                                 ctrl.scherm.selectedValues[Enums.Parameters.Termijn] = tarief.duurtijd;
                                 ctrl.scherm.selectedValues[Enums.Parameters.Betaling.Bedrag] = tarief.bedrag;
                                 ctrl.scherm.selectedValues[Enums.Parameters.Betaling.KassaCode] = tarief.kassaCode;
                                 ctrl.scherm.selectedValues[Enums.Parameters.EindDatum] = tarief.getEindDatum(beginDatum);
                             }
                             // Check for valid result
                             _validate();
                         }, function (error) {
                             errorService.error('ERR_SRV_02', error.ErrorCodes);
                         })
                        .finally(function () { ctrl.isLoading = false; });
        };

        init();

        function init() {
            var schermNr = ctrl.scherm.schermNr;
            var zoekField = function (param) { return meertaligheidService.get({ scherm: schermNr, type: 'Tekstfield', naam: 'Field', param: param }).shift(); };

            ctrl.dagpassen = {};
            dagpasService.searchCount(parameterService.getParametersObject())
                                    .then(function (res) {
                                        if (!angular.isUndefinedOrNull(res[Enums.Parameters.Dagpas.AantalDagpassenLopendJaar]))
                                            ctrl.dagpassen.aantalLopendJaar = { label: zoekField(Enums.Parameters.Dagpas.AantalDagpassenLopendJaar), value: { nl: res[Enums.Parameters.Dagpas.AantalDagpassenLopendJaar] } };
                                        if (!angular.isUndefinedOrNull(res[Enums.Parameters.Dagpas.AantalDagpassenVolgendJaar]))
                                            ctrl.dagpassen.aantalVolgendJaar = { label: zoekField(Enums.Parameters.Dagpas.AantalDagpassenVolgendJaar), value: { nl: res[Enums.Parameters.Dagpas.AantalDagpassenVolgendJaar] } };
                                    });

            ctrl.beginDatum = { label: meertaligheidService.get({ scherm: schermNr, type: 'Datepicker', naam: 'Datum', itemtype: 'Label', param: Enums.Parameters.BeginDatum }).shift() };
            if (angular.isDefined(ctrl.beginDatum.label)) ctrl.beginDatum.tooltip = meertaligheidService.get({ scherm: schermNr, type: 'Datepicker', naam: 'Datum', itemtype: 'Tooltip', itemnr: ctrl.beginDatum.label.itemnr }).shift();
            ctrl.eindDatum = { label: meertaligheidService.get({ scherm: schermNr, type: 'Tekstdatum', naam: 'Datum', param: Enums.Parameters.EindDatum }).shift() };
            if (angular.isDefined(ctrl.eindDatum.label)) ctrl.eindDatum.tooltip = meertaligheidService.get({ scherm: schermNr, type: 'Tekstdatum', naam: 'Datum', itemtype: 'Tooltip', itemnr: ctrl.eindDatum.label.itemnr }).shift();

            ctrl.geenTarief = meertaligheidService.get({ scherm: schermNr, type: 'Empty', naam: 'Tarief' }).shift();

            ctrl.tariefLabels = {
                omschrijving: zoekField(Enums.Parameters.Tarief),
                bedrag: zoekField(Enums.Parameters.Betaling.Bedrag)
            };

            ctrl.dateChanged(true);
        }

        function _validate(hideResult) {
            ctrl.scherm.setValid(false);

            ctrl.validations[Enums.Parameters.BeginDatum] = validationService.validate(Enums.Parameters.BeginDatum, ctrl.scherm.selectedValues);
            ctrl.validations[Enums.Parameters.Tarief] = validationService.validate(Enums.Parameters.Tarief, ctrl.scherm.selectedValues);
            ctrl.validations[Enums.Parameters.EindDatum] = validationService.validate(Enums.Parameters.EindDatum, ctrl.scherm.selectedValues);

            var isValid = true;
            angular.forEach(ctrl.validations, function (value, key) { if (!value.isValid()) isValid = false; });
            ctrl.scherm.setValid(isValid);

            if (hideResult) ctrl.validations[Enums.Parameters.BeginDatum].messages = [];
        }
    };

    theController.$inject = ['appEnums', 'NavigatieService', 'MeertaligheidService', 'ParameterService', 'ValidationService', 'LEZErrorService', 'TariefService', 'DagpasService'];

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "DefaultViewController";
    var theController = function (Enums, Constants, scherm, params, vragen, filterService, parameterService, validationService, ValidationResult) {
        var ctrl = this;

        ctrl.isInline = false;
        ctrl.scherm = scherm;
        ctrl.vragen = vragen;
        ctrl.validations = {};
        ctrl.options = {};

        ctrl.getTaal = function () { return parameterService.get(Enums.Parameters.Taal, true); };
        ctrl.getMaakKeuzeTekst = function () { return Constants.Meertaligheid.KeuzeTekst[ctrl.getTaal().toLowerCase()]; };
        ctrl.getFieldId = function (vraag) {
            var id = vraag.label.param;
            if (!angular.isNullOrWhitespace(vraag.label.parvalue)) id += '_' + vraag.label.parvalue;
            return id;
        };
        ctrl.minValue = function (param) {
            return validationService.getMinValue(param, ctrl.scherm.selectedValues);
        };
        ctrl.maxValue = function (param) {
            return validationService.getMaxValue(param, ctrl.scherm.selectedValues);
        };
        ctrl.hasAutocomplete = function () { return false; };
        ctrl.isDisabled = function (vraag) {
            if (vraag.label.visible !== true) return true;
            var conditie = vraag.label.conditie;
            if (angular.isUndefinedOrNull(conditie)) return false;
            switch (parameterService.get(conditie, true)) {
                case Enums.FieldOptions.Hidden:
                case Enums.FieldOptions.ReadOnly:
                    return true;
                case Enums.FieldOptions.Editable:
                case Enums.FieldOptions.Required:
                default:
                    return false;
            }
        };
        ctrl.isVisible = function (vraag) {
            if (vraag.label.visible !== true) return false;
            var conditie = vraag.label.conditie;
            if (angular.isUndefinedOrNull(conditie)) return true;
            var conditieValue = vraag.label.conditieValue;
            if (!angular.isUndefinedOrNull(conditieValue)) return parameterService.equals(conditie, conditieValue);
            switch (parameterService.get(conditie, true)) {
                case Enums.FieldOptions.Hidden:
                    if (angular.isDefined(vraag.label.param) && angular.isDefined(ctrl.scherm.selectedValues))
                        ctrl.scherm.selectedValues[vraag.label.param] = undefined;
                    return false;
                case Enums.FieldOptions.ReadOnly:
                case Enums.FieldOptions.Editable:
                case Enums.FieldOptions.Required:
                default:
                    return true;
            }
        };
        ctrl.isRequired = function (vraag) {
            if (ctrl.scherm.schermNr === 36) return false; // LEZ-849
            if (vraag.label.visible !== true) return false;
            var conditie = vraag.label.conditie;
            if (angular.isUndefinedOrNull(conditie)) return true;
            switch (parameterService.get(conditie, true)) {
                case Enums.FieldOptions.Required:
                    return true;
                case Enums.FieldOptions.Editable:
                case Enums.FieldOptions.ReadOnly:
                case Enums.FieldOptions.Hidden:
                    return false;
                default:
                    return true;
            }
        };
        ctrl.preventActions = function (event, param) {
            if (param === Enums.Parameters.Gebruiker.HerhalingEmail) // LEZ-826
                return event.preventDefault();
        };
        ctrl.needsDisabledDragAndDrop = function (param) {
            if (param === Enums.Parameters.Gebruiker.HerhalingEmail) // LEZ-826
                return true;
            return false;
        };

        ctrl.validate = function (param, hideResult) {
            var paramValue = ctrl.scherm.selectedValues[param];

            if (!_isValidSelection(param, paramValue)) {
                ctrl.scherm.selectedValues[param] = undefined;
                paramValue = undefined;
            }
            
            // Validate the parameter
            ctrl.validations[param] = validationService.validate(param, ctrl.scherm.selectedValues);

            if (param === Enums.Parameters.Voertuig.Nummerplaat)
                ctrl.validate(Enums.Parameters.Voertuig.DatumEersteInschrijving, (angular.isUndefined(ctrl.validations[Enums.Parameters.Voertuig.DatumEersteInschrijving]) || ctrl.validations[Enums.Parameters.Voertuig.DatumEersteInschrijving].messages.length === 0));

            // When not required and not filled in, clear the required message
            if (!ctrl.validations[param].isValid() && angular.isNullOrWhitespace(paramValue) && ctrl.scherm.schermNr !== 36) { // LEZ-849
                var required = false;
                for (var i = 0, len = ctrl.vragen.length; i < len; ++i) {
                    var v = ctrl.vragen[i];
                    if (v.label.param !== param) continue;
                    if (ctrl.isRequired(v)) {
                        required = true;
                        break;
                    }
                }

                if (!required && angular.isArray(ctrl.validations[param].messages)) {
                    ctrl.validations[param].messages.shift(); // Remove the first message, which is the validation of required
                    if (ctrl.validations[param].messages.length < 1) ctrl.validations[param].result = ValidationResult.Success;
                }
            }

            // Verify weather or not the screen is still valid
            if (!ctrl.validations[param].isValid()) ctrl.scherm.setValid(false);
            else {
                ctrl.scherm.setValid(true);
                angular.forEach(ctrl.validations, function (res) {
                    if (res.isValid()) return;
                    ctrl.scherm.setValid(false);
                });
            }

            // Hide messages for Datepickers
            if (hideResult) {
                var vraag = filterService.filter(vragen, { label: { param: param } });
                if (vraag.length > 0 && vraag[0].type === 'Datepicker') ctrl.validations[param].messages = [];
            }

            return;
        };
        
        init();

        function init() {
            var paramvalues = parameterService.getParametersObject();

            for (var i = 0, len = params.length; i < len; ++i) {
                var param = params[i];
                // Options
                getOptions(param);

                // Pre-select
                ctrl.scherm.selectedValues[param] = getValue(param, paramvalues);
                if (param === Enums.Parameters.Bedrijf.Land) _selectedLand = ctrl.scherm.selectedValues[param];

                // Validation
                ctrl.validate(param, true);
            }
            if (params.length < 1) ctrl.scherm.setValid(true);
        }

        function getValue(parameter, params) {
            var value = params[parameter];
            if (angular.isDefined(value)) return value;
            value = scherm.selectedValues[parameter];
            if (angular.isDefined(value)) return value;
            return parameterService.get(parameter, true, true);
        }

        function getOptions(param) {
            if (angular.isArray(vragen) === false) return;
            if (vragen.filter(function (vraag) { return vraag.label.param === param && vraag.label.type === 'Keuzelijst'; }).length < 1) return;
            parameterService.getOptions(param).then(function (options) { ctrl.options[param] = options; });
        }

        function _isValidSelection(param, paramValue) {
            if (angular.isUndefined(paramValue)) return false;
            else if (paramValue === null) return false;

            if (!angular.isArray(vragen)) return true;
            var results = vragen.filter(function (vraag) { return vraag.label.param === param && vraag.label.visible; });
            if (results.length < 1) return false;
            var type = vragen[0].label.type;
            switch (type) {
                case 'Qbutton':
                    return results.filter(function (vraag) { return vraag.label.parvalue === paramValue; }).length > 0;
                default:
                    return true;
            }
        }
    };

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "InfokioskViewController";
    var theController = function (scherm, meertaligheidService) {
        var ctrl = this;
        ctrl.afbeelding = undefined;
        ctrl.buttonsGroup1 = [];
        ctrl.buttonsGroup2 = [];

        init();
        function init() {
            // Afbeelding
            ctrl.afbeelding = meertaligheidService.get({ scherm: scherm.schermNr, type: 'Image', naam: 'HeaderImage' }).shift();

            // SubmitButtons
            var buttons = [];
            var btnLabels = meertaligheidService.get({ scherm: scherm.schermNr, type: 'Sbutton', itemtype: 'Label' });
            for (var i = 0, len = btnLabels.length; i < len; ++i) {
                var label = btnLabels[i];
                var image = meertaligheidService.get({ scherm: scherm.schermNr, type: 'Sbutton', itemNr: label.itemNr, itemtype: 'Image' }).shift();
                buttons.push({ label: label, image: image });
            }

            ctrl.subtitle = meertaligheidService.get({ scherm: scherm.schermNr, type: 'Titel2', naam: 'Subtit1' }).shift();
            if (angular.isDefined(ctrl.subtitle))
            {
                ctrl.buttonsGroup1 = buttons.slice(0,2);
                ctrl.buttonsGroup2 = buttons.slice(2);
            }
            else
            {
                ctrl.buttonsGroup1 = buttons;
                ctrl.buttonsGroup2 = [];
            }

            // Link
            ctrl.link = {
                label: meertaligheidService.get({ scherm: scherm.schermNr, type: 'Linkbut', itemtype: 'Label' }).shift(),
                link: meertaligheidService.get({ scherm: scherm.schermNr, type: 'Linkbut', itemtype: 'Link' }).shift()
            };

            // QR-Code
            ctrl.qrCode = meertaligheidService.get({ scherm: scherm.schermNr, type: 'Image', naam: 'Link' }).shift();
        }
    };

    theController.$inject = ['scherm', 'MeertaligheidService'];

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "InfomenuViewController";
    var theController = function (CONST, meertaligheidService) {
        var ctrl = this;
        ctrl.emptyMessage = CONST.Meertaligheid.Infopaginas;
        ctrl.paginas = [];

        ctrl.isLoading = true;

        init();
        function init() {
            ctrl.paginas = [];
            var titles = meertaligheidService.get({ schermtype: 'InfoScherm', naam: 'Titel' });
            for (var i = 0, len = titles.length; i < len; ++i) {
                var page = angular.copy(titles[i]);
                page.parvalue = page.scherm;
                ctrl.paginas.push(page);
            }
        }
    };

    theController.$inject = ['appConstants', 'MeertaligheidService'];

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "MultiFormViewController";
    var theController = function (Enums, Constants, scherm, params, vragen, parameterService, parameterHelperService, validationService, ValidationResult, filterService, addressService, landenService) {
        var ctrl = this;

        var _selectedLand = null;

        var countriesCollection = [];

        ctrl.isInline = true;
        ctrl.scherm = scherm;
        ctrl.vragen = vragen;
        ctrl.validations = {};
        ctrl.options = {};
        ctrl.autocomplete = {};
        ctrl.hiddenFields = [];

        ctrl.getTaal = function () { return parameterService.get(Enums.Parameters.Taal, true); };
        ctrl.getMaakKeuzeTekst = function () { return Constants.Meertaligheid.KeuzeTekst[ctrl.getTaal().toLowerCase()]; };
        ctrl.getFieldId = function (vraag) {
            var id = vraag.label.param;
            if (!angular.isNullOrWhitespace(vraag.label.parvalue)) id += '_' + vraag.label.parvalue;
            return id;
        };
        ctrl.minValue = function (param) {
            return validationService.getMinValue(param, ctrl.scherm.selectedValues);
        };
        ctrl.maxValue = function (param) {
            return validationService.getMaxValue(param, ctrl.scherm.selectedValues);
        };
        ctrl.hasAutocomplete = function (param) {
            switch (param) {
                case Enums.Parameters.Aanvrager.Gemeente:
                case Enums.Parameters.Bedrijf.Gemeente:
                case Enums.Parameters.Titularis.Gemeente:
                case Enums.Parameters.Gehandikapte.Gemeente:
                case Enums.Parameters.Aanvrager.Postcode:
                case Enums.Parameters.Bedrijf.Postcode:
                case Enums.Parameters.Titularis.Postcode:
                case Enums.Parameters.Gehandikapte.Postcode:
                    return true;
            }
            return false;
        };
        ctrl.isDisabled = function (vraag) {
            if (vraag.label.visible === false) return true;
            var conditie = vraag.label.conditie;
            if (angular.isUndefined(conditie) || conditie === null) return false;
            if (
                [Enums.Parameters.Aanvrager.Naam, Enums.Parameters.Aanvrager.Voornaam].some(param => vraag.label.param === param) && parameterService.get(vraag.label.param) === undefined &&  // LEZ-3797
                parameterService.get(Enums.Parameters.Kanaal) === Enums.Kanaal.EloketAprofiel // LEZ-3881
            ) {
                return false;
            }
            switch (parameterService.get(conditie, true)) {
                case Enums.FieldOptions.Hidden:
                case Enums.FieldOptions.ReadOnly:
                    return true;
                case Enums.FieldOptions.Editable:
                case Enums.FieldOptions.Required:
                default:
                    return false;
            }
        };
        ctrl.isVisible = function (vraag) {
            if (vraag.label.visible === false) return false;
            var conditie = vraag.label.conditie;
            if (angular.isUndefined(conditie) || conditie === null) return true;
            var conditieValue = vraag.label.conditieValue;
            if (angular.isDefined(conditieValue) && conditieValue !== null) return parameterService.equals(conditie, conditieValue);
            switch (parameterService.get(conditie, true)) {
                case Enums.FieldOptions.Hidden:
                    if (angular.isDefined(vraag.label.param) && angular.isDefined(ctrl.scherm.selectedValues))
                        ctrl.scherm.selectedValues[vraag.label.param] = undefined;
                    return false;
                case Enums.FieldOptions.ReadOnly:
                case Enums.FieldOptions.Editable:
                case Enums.FieldOptions.Required:
                default:
                    return true;
            }
        };
        ctrl.isRequired = function (vraag) {
            if (vraag.label.param === Enums.Parameters.Aanvrager.Heeft2eEmail) return false;
            if (ctrl.hiddenFields.length > 0) {
                if (ctrl.hiddenFields.indexOf(vraag.label.param) !== -1) return false;
            }
            if (vraag.label.visible === false) return false;
            if (
                [Enums.Parameters.Aanvrager.Naam, Enums.Parameters.Aanvrager.Voornaam].some(param => vraag.label.param === param) && parameterService.get(vraag.label.param) === undefined &&  // LEZ-3797
                parameterService.get(Enums.Parameters.Kanaal) === Enums.Kanaal.EloketAprofiel // LEZ-3881
            ) {
                return true;
            }
            var conditie = vraag.label.conditie;
            if (angular.isUndefined(conditie) || conditie === null) return true;
            switch (parameterService.get(conditie, true)) {
                case Enums.FieldOptions.Required:
                    return true;
                case Enums.FieldOptions.Editable:
                case Enums.FieldOptions.ReadOnly:
                case Enums.FieldOptions.Hidden:
                    return false;
                default:
                    return true;
            }
        };
        ctrl.preventActions = function (event, param) {
            if (param === Enums.Parameters.Gebruiker.HerhalingEmail) // LEZ-826
                return event.preventDefault();
        };
        ctrl.needsDisabledDragAndDrop = function (param) {
            if (param === Enums.Parameters.Gebruiker.HerhalingEmail) // LEZ-826
                return true;
            return false;
        };

        ctrl.validate = function (param, hideResult) {
            _validate(param, true, hideResult);
        };

        ctrl.isHidden = function (param) {
            if (ctrl.hiddenFields.indexOf(param) !== -1) {
                return true;
            } else {
                return false;
            }
        };

        function _validate(param, changed, hideResult) {
            var paramValue = ctrl.scherm.selectedValues[param];

            if (!_isValidSelection(param, paramValue)) {
                ctrl.scherm.selectedValues[param] = undefined;
                paramValue = undefined;
            }

            // START CUSTOM CODE - VALIDATE ON CHANGE
            if (changed) {
                var extraValues = [{ key: param, value: paramValue }];
                var bereken = function (parameter, extraValues) {
                    return parameterHelperService.bereken(parameter, extraValues)
                        .then(function (result) {
                            for (var i = 0, len = params.length; i < len; ++i) {
                                if (params[i] === param) continue;
                                _validate(params[i], false, hideResult);
                            }
                            return result;
                        });
                };
                switch (param) {
                    case Enums.Parameters.Bedrijf.BTWNummer:
                        if (angular.isString(paramValue)) {
                            paramValue = paramValue.toUpperCase().replace(/[\.\-\s]/g, '');

                            var land = (paramValue.length < 2) ? undefined : paramValue.substr(0, 2).toUpperCase();

                            var filteredCountries = countriesCollection.listOfLandCodeModel.filter(function(country) {
                                return country.isoAlpha2 === land;
                            });

                            if (land && filteredCountries.length === 1) {
                                ctrl.scherm.selectedValues[Enums.Parameters.Bedrijf.Land] = land;
                            }

                            ctrl.scherm.selectedValues[param] = paramValue;
                        }
                        bereken(Enums.Parameters.DirkParameters.VWD77, extraValues);
                        break;
                    case Enums.Parameters.Aanvrager.Email:
                        if (ctrl.scherm.schermNr !== 62)
                            _validate(Enums.Parameters.Gebruiker.HerhalingEmail, false, hideResult);
                    // No Break - Email & Tel hebben samen een invloed op VWD62!
                    case Enums.Parameters.Aanvrager.Telefoon:
                        if (ctrl.scherm.schermNr == 62) {
                            extraValues = [{ key: Enums.Parameters.Aanvrager.Email, value: ctrl.scherm.selectedValues[Enums.Parameters.Aanvrager.Email] },
                            { key: Enums.Parameters.Aanvrager.Telefoon, value: ctrl.scherm.selectedValues[Enums.Parameters.Aanvrager.Telefoon] }];
                            bereken(Enums.Parameters.DirkParameters.VWD62, extraValues);
                        }
                        break;
                    case Enums.Parameters.Aanvrager.Heeft2eEmail:
                        angular.forEach(ctrl.vragen, function (vraag) {
                            if (vraag.label.param === Enums.Parameters.Aanvrager.Email2) {
                                if (!angular.isDefined(ctrl.scherm.selectedValues[param]) || ctrl.scherm.selectedValues[param] === false) {
                                    ctrl.hiddenFields.push(Enums.Parameters.Aanvrager.Email2);
                                    if (angular.isDefined(ctrl.scherm.selectedValues[Enums.Parameters.Aanvrager.Email2])) {
                                        ctrl.scherm.selectedValues[Enums.Parameters.Aanvrager.Email2] = undefined;
                                    }
                                } else if (ctrl.scherm.selectedValues[param] === true) {
                                    for (var i = 0; i < ctrl.hiddenFields.length; i++) {
                                        if (ctrl.hiddenFields[i] === Enums.Parameters.Aanvrager.Email2) {
                                            ctrl.hiddenFields.splice(i, 1);
                                            if (!angular.isDefined(ctrl.scherm.selectedValues[Enums.Parameters.Aanvrager.Email2])) {
                                                ctrl.scherm.selectedValues[Enums.Parameters.Aanvrager.Email2] = '';
                                            }
                                        }
                                    }
                                }
                            };
                        });
                        break;
                    case Enums.Parameters.Betaling.Iban:
                        if (angular.isString(paramValue)) {
                            paramValue = paramValue.toUpperCase().replace(/[\-\s]/g, '');
                            ctrl.scherm.selectedValues[param] = paramValue;
                        }
                        bereken(Enums.Parameters.DirkParameters.VWD63, extraValues).then(function (result) { if (result === 0) ctrl.scherm.selectedValues[Enums.Parameters.Betaling.Bic] = undefined; });
                        break;
                    case Enums.Parameters.Betaling.Bic:
                        if (angular.isString(paramValue)) {
                            paramValue = paramValue.toUpperCase().replace(/[^A-Z0-9]/g, '');
                            ctrl.scherm.selectedValues[param] = paramValue;
                        }
                        break;
                    case Enums.Parameters.Bedrijf.Land:
                        if (_selectedLand !== paramValue) {
                            _selectedLand = paramValue;
                            _validate(Enums.Parameters.Bedrijf.BTWNummer, false, hideResult);
                        }
                        // else return;
                        break;
                    case Enums.Parameters.Aanvrager.Postcode:
                    case Enums.Parameters.Aanvrager.Gemeente:
                        _getAutocompleteOptions(Enums.Parameters.Aanvrager.Land, Enums.Parameters.Aanvrager.Postcode, Enums.Parameters.Aanvrager.Gemeente, param === Enums.Parameters.Aanvrager.Gemeente);
                        break;
                    case Enums.Parameters.Bedrijf.Postcode:
                    case Enums.Parameters.Bedrijf.Gemeente:
                        _getAutocompleteOptions(Enums.Parameters.Bedrijf.Land, Enums.Parameters.Bedrijf.Postcode, Enums.Parameters.Bedrijf.Gemeente, param === Enums.Parameters.Bedrijf.Gemeente);
                        break;
                    case Enums.Parameters.Titularis.Postcode:
                    case Enums.Parameters.Titularis.Gemeente:
                        _getAutocompleteOptions(Enums.Parameters.Titularis.Land, Enums.Parameters.Titularis.Postcode, Enums.Parameters.Titularis.Gemeente, param === Enums.Parameters.Titularis.Gemeente);
                        break;
                    case Enums.Parameters.Gehandikapte.Postcode:
                    case Enums.Parameters.Gehandikapte.Gemeente:
                        _getAutocompleteOptions(Enums.Parameters.Gehandikapte.Land, Enums.Parameters.Gehandikapte.Postcode, Enums.Parameters.Gehandikapte.Gemeente, param === Enums.Parameters.Gehandikapte.Gemeente);
                        break;
                }
            }
            // END CUSTOM CODE - VALIDATE ON CHANGE

            // Validate the parameter
            ctrl.validations[param] = validationService.validate(param, ctrl.scherm.selectedValues);

            // LEZ-1000 - Email niet verplicht op scherm 91 (Infokiosk)
            if (ctrl.scherm.schermNr === 91 && param === Enums.Parameters.Aanvrager.Email && !ctrl.validations[param].isValid() && angular.isNullOrWhitespace(paramValue)) {
                switch (getValue(Enums.Parameters.Kanaal, ctrl.scherm.selectedValues)) {
                    case Enums.Kanaal.InformatieKiosk:
                    case Enums.Kanaal.InformatieKioskChecktool:
                        ctrl.validations[param] = validationService.okResult();
                        break;
                }
            }

            // When not required and not filled in, clear the required message
            if (!ctrl.validations[param].isValid() && angular.isNullOrWhitespace(paramValue)) {
                var required = false;
                for (var i = 0, len = ctrl.vragen.length; i < len; ++i) {
                    var vraag = ctrl.vragen[i];
                    if (vraag.label.param !== param) continue;
                    if (ctrl.isRequired(vraag)) {
                        required = true;
                        break;
                    }
                }

                if (!required) {
                    ctrl.validations[param].messages.shift(); // Remove the first message, which is the validation of required
                    if (ctrl.validations[param].messages.length < 1) ctrl.validations[param].result = ValidationResult.Success;
                }
            }

            // Verify weather or not the screen is still valid
            if (!ctrl.validations[param].isValid()) ctrl.scherm.setValid(false);
            else {
                ctrl.scherm.setValid(true);
                angular.forEach(ctrl.validations, function (res) {
                    if (res.isValid()) return;
                    ctrl.scherm.setValid(false);
                });
            }

            // Hide messages for Datepickers
            if (hideResult) {
                var datepicker = filterService.filter(vragen, { label: { param: param, type: 'Datepicker' } });
                if (datepicker.length > 0) ctrl.validations[param].messages = [];
            }

            return;
        }

        init();

        function init() {
            var paramvalues = parameterService.getParametersObject();

            landenService.getAll().then(function (countries) {
                countriesCollection = countries;
            });

            for (var i = 0, len = params.length; i < len; ++i) {
                var param = params[i];
                // Options
                getOptions(param);

                // Pre-select
                ctrl.scherm.selectedValues[param] = getValue(param, paramvalues);
                if (param === Enums.Parameters.Bedrijf.Land) _selectedLand = ctrl.scherm.selectedValues[param];

                // Validation
                ctrl.validate(param, true);
            }

            if (params.length < 1) ctrl.scherm.setValid(true);
        }

        function getValue(parameter, params) {
            var value = params[parameter];
            if (angular.isDefined(value)) return value;
            value = scherm.selectedValues[parameter];
            if (angular.isDefined(value)) return value;
            return parameterService.get(parameter, true, true);
        }

        function getOptions(param) {
            if (angular.isArray(vragen) === false) return;
            if (vragen.filter(function (vraag) { return vraag.label.param === param && vraag.label.type === 'Keuzelijst'; }).length < 1) return;
            parameterService.getOptions(param).then(function (options) { ctrl.options[param] = options; });
        }

        function _isValidSelection(param, paramValue) {
            if (angular.isUndefined(paramValue)) return false;
            else if (paramValue === null) return false;

            if (!angular.isArray(vragen)) return true;
            var results = vragen.filter(function (vraag) { return vraag.label.param === param && vraag.label.visible; });
            if (results.length < 1) return false;
            var type = vragen[0].label.type;
            switch (type) {
                case 'Qbutton':
                    return results.filter(function (vraag) { return vraag.label.parvalue === paramValue; }).length > 0;
                default:
                    return true;
            }
        }

        function _getAutocompleteOptions(landParam, postcodeParam, gemeenteParam, isGemeente) {
            var sourceValues = {
                Land: getValue(landParam, {}),
                Taal: getValue(Enums.Parameters.Taal, {}),
                Gemeente: getValue(gemeenteParam, {}),
                Postcode: getValue(postcodeParam, {})
            };

            if (isGemeente)
                delete sourceValues.Postcode;
            else
                delete sourceValues.Gemeente;

            var validations = {
                Land: sourceValues.Land === 'BE',
                Postcode: !angular.isString(sourceValues.Postcode) || /^[0-9]{0,4}$/.test(sourceValues.Postcode),
                Gemeente: !angular.isString(sourceValues.Gemeente) || /^[0-9a-zA-Z\(\-\)\s]+$/.test(sourceValues.Gemeente)
            };

            var valid = validations.Land && (isGemeente || validations.Postcode) && (!isGemeente || validations.Gemeente);

            if (!valid) {
                if (isGemeente)
                    delete ctrl.autocomplete[gemeenteParam];
                else
                    delete ctrl.autocomplete[postcodeParam];
                return;
            }

            addressService.get(sourceValues.Postcode, sourceValues.Gemeente, sourceValues.Taal)
                .then(function (results) {
                    if (!angular.isArray(results)) {
                        ctrl.autocomplete = {};
                        return;
                    }
                    
                    // Bereken lijst met unieke gemeente namen & postcodes
                    var gemeentes = results.map(function (value) { return value.Gemeente; }).distinct();
                    var postcodes = results.map(function (value) { return value.Postcode; }).distinct();

                    if (isGemeente) {
                        // Auto complete gemeentes
                        ctrl.autocomplete[gemeenteParam] = gemeentes;

                        if (gemeentes.length === 0) return; // Geen opties, onderneem niets

                        var isMatch = new RegExp('^' + gemeentes[0], 'i');
                        if (!isMatch.test(sourceValues.Gemeente)) return; // Komt niet overeen met 1e waarde, onderneem niets

                        // --- SET GEMEENTE PARAMETER --- //

                        if (gemeentes.length === 1) {
                            // Set parameter (casing)
                            ctrl.scherm.selectedValues[gemeenteParam] = gemeentes[0];
                            // Clear autocomplete
                            delete ctrl.autocomplete[gemeenteParam];
                        }

                        // Auto complete postcode field
                        ctrl.autocomplete[postcodeParam] = postcodes;

                        if (postcodes.length !== 1) return; // Er zijn meerdere postcodes mogelijk dus niet automatisch invullen

                        // --- SET POSTCODE PARAMETER --- //

                        // Clear autocomplete
                        delete ctrl.autocomplete[postcodeParam];
                        // Set parameter
                        ctrl.scherm.selectedValues[postcodeParam] = postcodes[0];
                        // Verify validation
                        _validate(postcodeParam, false);
                    }
                    else {
                        // Auto complete postcodes
                        ctrl.autocomplete[postcodeParam] = postcodes;

                        if (postcodes.length === 0) return; // Geen opties, onderneem niets

                        if (postcodes.length !== 1 || postcodes[0].length !== sourceValues.Postcode.length) return; // Geen exacte match, onderneem niets

                        // --- SET POSTCODE PARAMETER --- //
                        // Clear autocomplete
                        delete ctrl.autocomplete[postcodeParam];
                        // Set parameter
                        ctrl.scherm.selectedValues[postcodeParam] = postcodes[0];

                        // Auto complete gemeente field
                        ctrl.autocomplete[gemeenteParam] = gemeentes;

                        if (gemeentes.length !== 1) return; // Er zijn meerdere gemeentes mogelijk dus niet autmatisch invullen

                        // --- SET GEMEENTE PARAMETER --- //

                        // Clear autocomplete
                        delete ctrl.autocomplete[gemeenteParam];
                        // Set value
                        ctrl.scherm.selectedValues[gemeenteParam] = gemeentes[0];
                        // Verify validation
                        _validate(gemeenteParam, false);
                    }
                });
        }
    };

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "OverzichtViewController";
    var theController = function (Enums, Constants, formatterService, parameterService, parameterHelperService, meertaligheidService, landenService) {
        var ctrl = this;

        _init(parameterService.getParametersObject());

        function _init(aanvraag) {
            getCountries();

            var countriesCollection;
            function getCountries() {
                landenService.getAll().then(function (countries) {
                    countriesCollection = countries;
                });
            }

            var zoekLegende = function (naam) { return meertaligheidService.get({ scherm: 83, type: 'Legendes', naam: naam }).shift(); };
            var zoekLabel = function (parameter) { return meertaligheidService.get({ scherm: 0, type: 'Textfield', itemtype: 'Label', param: parameter }).shift(); };
            var zoekMeertaligheid = function (parameter, value) { return meertaligheidService.get({ scherm: 0, itemtype: 'Content', param: parameter, parvalue: value }).shift(); };

            var _asValue = function (parameter, aanvraag) {
                if (angular.isUndefined(aanvraag[parameter])) return undefined;
                return { label: zoekLabel(parameter), value: aanvraag[parameter] };
            };
            var _asParameterValue = function (parameter, aanvraag) {
                if (angular.isUndefined(aanvraag[parameter])) return undefined;
                return { label: zoekLabel(parameter), value: { parvalue: aanvraag[parameter] } };
            };
            var _asNederlands = function (parameter, aanvraag) {
                if (angular.isUndefined(aanvraag[parameter])) return undefined;
                return { label: zoekLabel(parameter), value: { nl: aanvraag[parameter] } };
            };
            var _asMeertaligheid = function (parameter, aanvraag) {
                var value = aanvraag[parameter];
                if (angular.isUndefined(value) && (parameter === Enums.Parameters.Voertuig.Euronorm || parameter === Enums.Parameters.Voertuig.EuronormVerrijkt)) value = aanvraag['VDI_' + parameter];
                if (angular.isUndefined(value)) return undefined;
                return { label: zoekLabel(parameter), value: zoekMeertaligheid(parameter, value) };
            };
            var _asDate = function (parameter, aanvraag, includeTime) {
                if (angular.isUndefined(aanvraag[parameter])) return undefined;
                return { label: zoekLabel(parameter), value: { nl: formatterService.toDisplayValue(aanvraag[parameter], 'DD/MM/YYYY' + (includeTime ? ' HH:mm' : '')) } };
            };
            var _asJaNeen = function (parameter, aanvraag) {
                if (angular.isUndefined(aanvraag[parameter])) return undefined;
                return { label: zoekLabel(parameter), value: aanvraag[parameter] ? Constants.Meertaligheid.Ja : Constants.Meertaligheid.Neen };
            };

            var _cleanUp = function (object) {
                var keys = Object.keys(object);
                for (var i = 0, len = keys.length; i < len; ++i){
                    var key = keys[i];
                    if (angular.isUndefined(object[key]))
                        delete object[key];
                }

                if (Object.keys(object).length <= 0)
                    return undefined;
                else
                    return object;
            };

            // Legendes
            ctrl.legendes = {
                aanvraag: zoekLegende('Aanvraag'),
                periode: zoekLegende('Periode'),
                betaling: zoekLegende('Betaling'),
                voertuig: zoekLegende('Voertuig'),
                details: zoekLegende('Details'),
                aanvrager: zoekLegende('Aanvrager'),
                titularis: zoekLegende('Titularis'),
                gehandicapte: zoekLegende('Gehandicapte')
            };

            // Aanvraag
            ctrl.aanvraag = {
                id: _asParameterValue(Enums.Parameters.AanvraagNummer, aanvraag),
                status: _asValue(Enums.Parameters.AanvraagStatus, aanvraag),
                type: _asMeertaligheid(Enums.Parameters.AanvraagType, aanvraag),
                soort: _asMeertaligheid(Enums.Parameters.AanvraagSoort, aanvraag)
            };
            ctrl.aanvraag = _cleanUp(ctrl.aanvraag);

            // Periode
            ctrl.periode = {
                startDatum: _asDate(Enums.Parameters.BeginDatum, aanvraag, true),
                eindDatum: _asDate(Enums.Parameters.EindDatum, aanvraag, true),
                duur:  _asValue(Enums.Parameters.Termijn, aanvraag)
            };
            ctrl.periode = _cleanUp(ctrl.periode);

            // Betaling
            if (angular.isDefined(aanvraag[Enums.Parameters.Tarief])) {
                ctrl.betaling = {
                    tarief: _asParameterValue(Enums.Parameters.Tarief, aanvraag),
                    bedrag: _asNederlands(Enums.Parameters.Betaling.Bedrag, aanvraag),

                    // Facturatie gegevens
                    btwnummer: _asParameterValue(Enums.Parameters.Bedrijf.BTWNummer, aanvraag),
                    naam: _asParameterValue(Enums.Parameters.Bedrijf.Naam, aanvraag),
                    straat: _asParameterValue(Enums.Parameters.Bedrijf.Straat, aanvraag),
                    huisNummer: _asParameterValue(Enums.Parameters.Bedrijf.HuisNummer, aanvraag),
                    bus: _asParameterValue(Enums.Parameters.Bedrijf.Bus, aanvraag),
                    postcode: _asParameterValue(Enums.Parameters.Bedrijf.Postcode, aanvraag),
                    gemeente: _asParameterValue(Enums.Parameters.Bedrijf.Gemeente, aanvraag),
                    land: _asParameterValue(Enums.Parameters.Bedrijf.Land, aanvraag),

                    // Rekening gegevens
                    rekeningtTitularis: _asParameterValue(Enums.Parameters.Betaling.TitularisRekening, aanvraag),
                    iban: _asParameterValue(Enums.Parameters.Betaling.Iban, aanvraag),
                    bic: _asParameterValue(Enums.Parameters.Betaling.Bic, aanvraag),

                    // Extra betaling gegevens
                    OGMS: _asNederlands(Enums.Parameters.Betaling.Mededeling, aanvraag),
                    betaald: _asJaNeen(Enums.Parameters.Betaling.IsBetaald, aanvraag)
                };
                ctrl.betaling = _cleanUp(ctrl.betaling);
            }

            // Voertuig
            ctrl.voertuig = {
                isBedrijfsVoertuig: _asMeertaligheid(Enums.Parameters.IsBedrijfsVoertuig, aanvraag),

                nummerplaat: _asParameterValue(Enums.Parameters.Voertuig.Nummerplaat, aanvraag),
                landcode: _asParameterValue(Enums.Parameters.Voertuig.Landcode, aanvraag),

                categorie: _asMeertaligheid(Enums.Parameters.Voertuig.Categorie, aanvraag),
                aardcode: _asValue(Enums.Parameters.Voertuig.Aardcode, aanvraag),
                brandstoftypeUitgebreid: _asMeertaligheid(Enums.Parameters.Voertuig.BrandstofTypeUitgebreid, aanvraag),
                euronorm: _asMeertaligheid(Enums.Parameters.Voertuig.Euronorm, aanvraag),
                cocCodeA: _asValue(Enums.Parameters.Voertuig.GelijkvormigheidscodeAndere, aanvraag),
                cocCodeT: _asValue(Enums.Parameters.Voertuig.GelijkvormigheidscodeLandbouw, aanvraag),
                eersteInschrijvingsDatum: _asDate(Enums.Parameters.Voertuig.DatumEersteInschrijving, aanvraag, false),
                laatsteInschrijvingsDatum: _asDate(Enums.Parameters.Voertuig.DatumLaatsteInschrijving, aanvraag, false),
                massaRijklareToestand: _asParameterValue(Enums.Parameters.Voertuig.MassaRijklareToestand, aanvraag),
                maximaalToegelatenMassa: _asParameterValue(Enums.Parameters.Voertuig.MaximaalToegelatenMassa, aanvraag),
                bijkomendeZitplaatsen: _asParameterValue(Enums.Parameters.Voertuig.BijkomendeZitplaatsen, aanvraag),
                co2: _asParameterValue(Enums.Parameters.Voertuig.CO2Waarde, aanvraag),
                partikelMassaWaarde: _asParameterValue(Enums.Parameters.Voertuig.PartikelMassaWaarde, aanvraag),
                vermogen: _asParameterValue(Enums.Parameters.Voertuig.Vermogen, aanvraag)
            };

            if (parameterHelperService.isVerrijkt())
                ctrl.voertuig.euronormVerrijkt = _asMeertaligheid(Enums.Parameters.Voertuig.EuronormVerrijkt, aanvraag);
            if (parameterHelperService.isGecorrigeerd())
                ctrl.voertuig.euronormGecorrigeerd = _asMeertaligheid(Enums.Parameters.Voertuig.EuronormGecorrigeerd, aanvraag);

            ctrl.voertuig = _cleanUp(ctrl.voertuig);

            // Details

            //Aanvrager
            ctrl.aanvrager = {
                rijksregisterNummer: _asParameterValue(Enums.Parameters.Aanvrager.RijksregisterNummer, aanvraag),
                email: _asParameterValue(Enums.Parameters.Aanvrager.Email, aanvraag),
                naam: _asParameterValue(Enums.Parameters.Aanvrager.Naam, aanvraag),
                voornaam: _asParameterValue(Enums.Parameters.Aanvrager.Voornaam, aanvraag),
                straat: _asParameterValue(Enums.Parameters.Aanvrager.Straat, aanvraag),
                huisnr: _asParameterValue(Enums.Parameters.Aanvrager.HuisNummer, aanvraag),
                bus: _asParameterValue(Enums.Parameters.Aanvrager.Bus, aanvraag),
                postcode: _asParameterValue(Enums.Parameters.Aanvrager.Postcode, aanvraag),
                gemeente: _asParameterValue(Enums.Parameters.Aanvrager.Gemeente, aanvraag),
                land: _asParameterValue(Enums.Parameters.Aanvrager.Land, aanvraag),
                telefoon: _asParameterValue(Enums.Parameters.Aanvrager.Telefoon, aanvraag)
            };
            ctrl.aanvrager = _cleanUp(ctrl.aanvrager);

            //Titularis
            ctrl.titularis = {
                isBedrijf: _asMeertaligheid(Enums.Parameters.Titularis.IsBedrijf, aanvraag),
                btwnummer: _asParameterValue(Enums.Parameters.Titularis.BTWNummer, aanvraag),
                rijksregister: _asParameterValue(Enums.Parameters.Titularis.RijksregisterNummer, aanvraag),
                naam: _asParameterValue(Enums.Parameters.Titularis.Naam, aanvraag),
                voornaam: _asParameterValue(Enums.Parameters.Titularis.Voornaam, aanvraag),
                straat: _asParameterValue(Enums.Parameters.Titularis.Straat, aanvraag),
                huisnr: _asParameterValue(Enums.Parameters.Titularis.HuisNummer, aanvraag),
                bus: _asParameterValue(Enums.Parameters.Titularis.Bus, aanvraag),
                postcode: _asParameterValue(Enums.Parameters.Titularis.Postcode, aanvraag),
                gemeente: _asParameterValue(Enums.Parameters.Titularis.Gemeente, aanvraag),
                land: _asParameterValue(Enums.Parameters.Titularis.Land, aanvraag)
            };
            ctrl.titularis = _cleanUp(ctrl.titularis);

            //Gehandicapte
            ctrl.gehandicapte = {
                kaartNummer: _asParameterValue(Enums.Parameters.Gehandikapte.KaartNummer, aanvraag),
                vervalDatum: _asDate(Enums.Parameters.Gehandikapte.Vervaldatum, aanvraag, false),
                rijksregister: _asParameterValue(Enums.Parameters.Gehandikapte.RijksregisterNummer, aanvraag),
                naam: _asParameterValue(Enums.Parameters.Gehandikapte.Naam, aanvraag),
                voornaam: _asParameterValue(Enums.Parameters.Gehandikapte.Voornaam, aanvraag),
                straat: _asParameterValue(Enums.Parameters.Gehandikapte.Straat, aanvraag),
                huisnr: _asParameterValue(Enums.Parameters.Gehandikapte.HuisNummer, aanvraag),
                bus: _asParameterValue(Enums.Parameters.Gehandikapte.Bus, aanvraag),
                postcode: _asParameterValue(Enums.Parameters.Gehandikapte.Postcode, aanvraag),
                gemeente: _asParameterValue(Enums.Parameters.Gehandikapte.Gemeente, aanvraag),
                land: _asParameterValue(Enums.Parameters.Gehandikapte.Land, aanvraag)
            };
            ctrl.gehandicapte = _cleanUp(ctrl.gehandicapte);

            var currentLanguage = parameterService.get(Enums.Parameters.Taal, true).toLowerCase();

            ctrl.getFullCountryName = function (countryCode) {
                if (countriesCollection && countriesCollection.listOfLandCodeModel) {
                    var selectedCountry = countriesCollection.listOfLandCodeModel.filter(function (country) {
                        return (country.isoAlpha2 === countryCode.parvalue);
                    });

                    return countryCode.parvalue + ' - ' + selectedCountry[0][currentLanguage + '_short'];
                } else {
                    return countryCode.parvalue;
                }
            };

            ctrl.getGHKDATLabelForCurrentLanguage = function () {
                return Enums.LabelTranslations[currentLanguage];
            };

            ctrl.isGHKDATUndefined = function (GHKDAT) {
                var format = 'DD/MM/YYYY';
                var selectedDate = GHKDAT.nl;
                var outerEndDate = Constants.Datums.getEindDatum_2099().format(format);

                if (selectedDate === outerEndDate) {
                    return true;
                }

                return false;
            };
        }
    };

    theController.$inject = ['appEnums', 'appConstants', 'FormatterService', 'ParameterService', 'ParameterHelperService', 'MeertaligheidService', 'LezLandenService'];

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {
    'use strict';

    var ctrlName = "TariefViewController";
    var theController = function (Enums, Constants, scherm, tableHeaders, BDAT, EDAT, EDAT_ONEINDIG, parameterService, parameterHelperService, validationService, errorService) {
        var ctrl = this;

        ctrl.isTariefSelecteerbaar = angular.isArray(tableHeaders) && tableHeaders.length > 0;
        ctrl.tableHeaders = tableHeaders;
        ctrl.beginDatum = BDAT;
        ctrl.eindDatum = EDAT;
        ctrl.eindDatumOneindig = EDAT_ONEINDIG;
        ctrl.scherm = scherm;
        ctrl.validations = {};
        ctrl.isOldtimer = parameterHelperService.isOldtimer();
        ctrl.canRegisterAsOldtimer = parameterHelperService.canRegisterAsOldtimer();
        ctrl.oldTimerStartDate = parameterHelperService.calculateOldtimerStartDate();

        var _tarief = undefined;

        ctrl.isEindDatumVisible = function () {
            var eindDatum = scherm.selectedValues[Enums.Parameters.EindDatum];
            // NIET - Is de begin datum label niet zichtbaar
            if (!angular.isDefined(ctrl.beginDatum) || !angular.isDefined(ctrl.beginDatum.label) || !ctrl.beginDatum.label.visible) return false;
            // NIET - Is de eind datum label niet zichtbaar
            else if (!angular.isDefined(ctrl.eindDatum) || !angular.isDefined(ctrl.eindDatum.label) || !ctrl.eindDatum.label.visible) return false;
            // WEL - Is de eind datum editeerbaar
            else if (ctrl.isEindDatumEditable()) return true;
            // NIET - Is de datum groter dan onze 2099 eind datum
            else if (angular.isDate(eindDatum) && eindDatum.isSameOrAfter(Constants.Datums.getEindDatum_2099())) return false;
            // WEL - Alle andere gevallen
            else return true;
        };

        ctrl.minValue = function (param) {
            return validationService.getMinValue(param, ctrl.scherm.selectedValues);
        };

        ctrl.maxValue = function (param) {
            return validationService.getMaxValue(param, ctrl.scherm.selectedValues);
        };
        ctrl.isEindDatumEditable = function () {
            if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.BackOffice)) return true;
            return false;
        };

        ctrl.getTariefId = function () {
            if (angular.isObject(_tarief)) return _tarief.id;
            return ctrl.scherm.selectedValues[Enums.Parameters.Tarief];
        };

        ctrl.getBeginDatum = function () {
            return ctrl.scherm.selectedValues[Enums.Parameters.BeginDatum];
        };

        ctrl.tariefUpdated = function (tarief) {
            if (angular.isUndefined(tarief)) {
                _tarief = undefined;
                delete ctrl.scherm.selectedValues[Enums.Parameters.Tarief];
                delete ctrl.scherm.selectedValues[Enums.Parameters.Termijn];
                delete ctrl.scherm.selectedValues[Enums.Parameters.Betaling.Bedrag];
                delete ctrl.scherm.selectedValues[Enums.Parameters.Betaling.KassaCode];
            }
            else {
                _tarief = tarief;
                ctrl.scherm.selectedValues[Enums.Parameters.Tarief] = tarief.id;
                ctrl.scherm.selectedValues[Enums.Parameters.Termijn] = tarief.duurtijd;
                ctrl.scherm.selectedValues[Enums.Parameters.Betaling.Bedrag] = tarief.bedrag;
                ctrl.scherm.selectedValues[Enums.Parameters.Betaling.KassaCode] = tarief.kassaCode;
            }

            if (ctrl.isTariefSelecteerbaar) _validate(Enums.Parameters.Tarief);
            ctrl.scherm.selectedValues[Enums.Parameters.EindDatum] = _berekenEindDatum(true);
            _validate(Enums.Parameters.EindDatum, angular.isUndefined(tarief));
        };

        ctrl.beginDatumUpdated = function () {
            if (angular.isDate(ctrl.scherm.selectedValues[Enums.Parameters.BeginDatum])) {
                ctrl.scherm.selectedValues[Enums.Parameters.EindDatum] = _berekenEindDatum();
                _validate(Enums.Parameters.EindDatum);
            }
            _validate(Enums.Parameters.BeginDatum);
        };

        ctrl.eindDatumUpdated = function () {
            if (!ctrl.isEindDatumEditable()) return;
            var date = scherm.selectedValues[Enums.Parameters.EindDatum];
            if (angular.isDate(date)) {
                date.hours(23);
                date.minutes(59);
                date.seconds(59);
                date.milliseconds(99);
            }
            _validate(Enums.Parameters.EindDatum);
        };

        init();

        function init() {
            // Waardes resetten (buiten Tarief, BeginDatum en EindDatum)
            var tariefId = scherm.selectedValues[Enums.Parameters.Tarief];
            ctrl.tariefUpdated(_tarief);
            if (angular.isDefined(tariefId) && tariefId > 0) scherm.selectedValues[Enums.Parameters.Tarief] = tariefId;

            // Waardes ophalen uit ParameterService of uit SelectedValues
            var params = parameterService.getParametersObject();
            scherm.selectedValues[Enums.Parameters.Tarief] = _getValue(Enums.Parameters.Tarief, params);
            var today = moment();
            scherm.selectedValues[Enums.Parameters.BeginDatum] = ctrl.isOldtimer || ctrl.canRegisterAsOldtimer ? today : _getValue(Enums.Parameters.BeginDatum, params);

            if (!parameterService.get(Enums.Parameters.IsExtension)) {
                var LEZ2020StartDatum = Constants.Datums.getLEZ2020StartDatum();
                if (params[Enums.Parameters.AanvraagSoort] === Enums.AanvraagSoort.ToelatingDieselEuro4 || params[Enums.Parameters.AanvraagSoort] === Enums.AanvraagSoort.ToelatingInwonerDE4) {
                    if (today < LEZ2020StartDatum && parameterService.get(Enums.Parameters.Verstrenging)) {
                        scherm.selectedValues[Enums.Parameters.BeginDatum] = LEZ2020StartDatum;
                    } else {
                        scherm.selectedValues[Enums.Parameters.BeginDatum] = today;
                    }
                } else if (
                    params[Enums.Parameters.AanvraagSoort] === Enums.AanvraagSoort.ToelatingWerken ||
                    params[Enums.Parameters.AanvraagSoort] === Enums.AanvraagSoort.ToelatingAmbulanteHandel ||
                    params[Enums.Parameters.AanvraagSoort] === Enums.AanvraagSoort.ToelatingNoodsituatie
                ) {
                    if (parameterService.equals(Enums.Parameters.Voertuig.Euronorm, '3') || parameterService.equals(Enums.Parameters.Voertuig.Euronorm, '4')) {
                        scherm.selectedValues[Enums.Parameters.BeginDatum] = Date.Yesterday();
                    }
                }
            }

            if (ctrl.isEindDatumEditable()) scherm.selectedValues[Enums.Parameters.EindDatum] = _getValue(Enums.Parameters.EindDatum, params);
            else scherm.selectedValues[Enums.Parameters.EindDatum] = _berekenEindDatum();

            var isReopened = angular.isDefined(parameterService.get(Enums.Parameters.AanvraagNummer));

            // Validatie triggeren
            if (ctrl.isTariefSelecteerbaar) _validate(Enums.Parameters.Tarief, !isReopened);
            _validate(Enums.Parameters.BeginDatum, !isReopened);
            _validate(Enums.Parameters.EindDatum, !isReopened);
        }

        function _getValue(parameter, params) {
            var value = params[parameter];
            if (angular.isDefined(value)) return value;
            value = scherm.selectedValues[parameter];
            if (angular.isDefined(value)) return value;
            return parameterService.get(parameter, true, true);
        }

        function _validate(param, hideResult) {
            if (param === Enums.Parameters.EindDatum)
                ctrl.showOverschrijdingTekst = validateOverschrijding();

            // In geval van Checktool, voorkom dat er verder gegaan kan worden.
            if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.Checktool, Enums.Kanaal.InformatieKioskChecktool])) {
                scherm.setValid(false);
                return;
            }

            ctrl.validations[param] = validationService.validate(param, ctrl.scherm.selectedValues);

            // Extra valiatie op overlap
            switch (param) {
                case Enums.Parameters.BeginDatum:
                    validateOverlap();
                    break;
                case Enums.Parameters.EindDatum:
                    validateOverlap();
                    break;
            }

            // Is the screen still valid?
            if (!ctrl.validations[param].isValid()) ctrl.scherm.setValid(false);
            else {
                ctrl.scherm.setValid(true);
                angular.forEach(ctrl.validations, function (res) {
                    if (res.isValid()) return;
                    ctrl.scherm.setValid(false);
                });
            }

            function validateOverlap() {
                validationService.validateOverlap(ctrl.scherm.selectedValues)
                    .then(function (result) {
                        if (!ctrl.validations[Enums.Parameters.BeginDatum].isValid) return;
                        if (!ctrl.validations[Enums.Parameters.EindDatum].isValid) return;
                        if (result.result !== "Success") ctrl.validations[Enums.Parameters.BeginDatum] = result;
                    });
            }

            function validateOverschrijding() {
                // Overschrijding kan énkel voor toelatingen
                if (parameterService.equals(Enums.Parameters.AanvraagType, Enums.AanvraagType.Toelating) === false) return false;

                // Overschrijding kan énkel wanneer de twee data zijn gekend
                var begin = ctrl.scherm.selectedValues[Enums.Parameters.BeginDatum], einde = ctrl.scherm.selectedValues[Enums.Parameters.EindDatum];
                if (angular.isDate(begin) === false) return false;
                if (angular.isDate(einde) === false) return false;

                // Overschrijding kan enkel wanneer er effectief over de 2019 datum gegaan wordt.
                if (begin.isAfter(Constants.Datums.getEindDatum_2019()) || ctrl.canRegisterAsOldtimer || ctrl.isOldtimer) return false;
                if (einde.isSameOrBefore(Constants.Datums.getEindDatum_2019())) return false;

                // Er is geen sprake van overschrijding bij dag-tarieven
                if (_tarief !== undefined && _tarief.duur === 1 && _tarief.eenheid === 'D') return false;

                // Clip einddatum & return true to show the message
                ctrl.scherm.selectedValues[Enums.Parameters.EindDatum] = Constants.Datums.getEindDatum_2019();
                return true;
            }

            if (hideResult) {
                ctrl.validations[param].messages = [];
            }
        }

        function _berekenEindDatum(tariefChanged) {
            var result, eindDatum = ctrl.scherm.selectedValues[Enums.Parameters.EindDatum];
            if (ctrl.isEindDatumEditable() && !tariefChanged) {
                // LEZ-733 - Do not recalculate
                return eindDatum;
            }

            if (parameterService.equals(Enums.Parameters.AanvraagType, [Enums.AanvraagType.Dagpas, Enums.AanvraagType.Toelating])) {
                if (angular.isUndefined(_tarief)) {
                    // Nothing to Do - No Tarief selected yet
                    return eindDatum;
                } else if (!angular.isObject(_tarief) || angular.isUndefined(_tarief.duur) || angular.isUndefined(_tarief.eenheid)) {
                    // Invalid tarief selected
                    errorService.error('ERR_PARAM_01B');
                    return undefined;
                } else {
                    result = _tarief.getEindDatum(ctrl.scherm.selectedValues[Enums.Parameters.BeginDatum]);
                    if (angular.isDefined(result)) return result;
                    // Tarief could not calculate end date
                    errorService.error('ERR_PARAM_01B');
                    return undefined;
                }
            } else {
                result = _berekenEindDatumZonderTarief();
                if (angular.isDate(result)) return result;
                errorService.error('ERR_PARAM_01A');
                return undefined;
            }
        }

        function _berekenEindDatumZonderTarief() {
            switch (parameterService.get(Enums.Parameters.AanvraagSoort)) {
                case Enums.AanvraagSoort.VrijstellingPrioritairVoertuig:
                case Enums.AanvraagSoort.VrijstellingUitzonderlijkVervoer:
                    return Constants.Datums.getEindDatum_2099();
                case Enums.AanvraagSoort.RegistratieAnderType:
                    return Constants.Datums.getEindDatum_2024();
                case Enums.AanvraagSoort.VrijstellingRolstoellift:
                case Enums.AanvraagSoort.VrijstellingAangepastVoertuig:
                case Enums.AanvraagSoort.VrijstellingVerhoogdeTegemoetkoming:
                    var selectedStartDate = ctrl.scherm.selectedValues[Enums.Parameters.BeginDatum].clone();
                    var lez2020Date = Constants.Datums.getLEZ2020StartDatum();

                    if (parameterService.get(Enums.Parameters.Gehandikapte.Vervaldatum)) {
                        var disabilityCardExpiryDate = parameterService.get(Enums.Parameters.Gehandikapte.Vervaldatum).clone();

                        if (disabilityCardExpiryDate.isBefore(Constants.Datums.getEindDatum_2024())) {
                            disabilityCardExpiryDate.hours(23);
                            disabilityCardExpiryDate.minutes(59);
                            disabilityCardExpiryDate.seconds(59);
                            disabilityCardExpiryDate.milliseconds(99);

                            return disabilityCardExpiryDate;
                        }
                    }

                    if (selectedStartDate.isSameOrAfter(lez2020Date)) {
                        selectedStartDate.add(5, 'years').subtract(1, 'days');
                        selectedStartDate.hours(23);
                        selectedStartDate.minutes(59);
                        selectedStartDate.seconds(59);
                        selectedStartDate.milliseconds(99);

                        return selectedStartDate;
                    } else {
                        return Constants.Datums.getEindDatum_2024();
                    }
                case Enums.AanvraagSoort.RegistratieTechnischeKenmerken:
                case Enums.AanvraagSoort.RegistratieTechnischeKenmerkenBE:
                case Enums.AanvraagSoort.RegistratieCorrectieEuronormCertificaat:
                case Enums.AanvraagSoort.RegistratieCorrectieEuronorm:
                case Enums.AanvraagSoort.RegistratieRoetfilterPremie:
                case Enums.AanvraagSoort.RegistratieRoetfilterDieselEuro3:
                case Enums.AanvraagSoort.RegistratieIngebouwdeRoetfilter:
                    var hoogsteEuronorm = parameterService.get(parameterHelperService.getHoogsteENParameter());
                    var brandstofType = parameterService.get(Enums.Parameters.Voertuig.BrandstofType);
                    var voertuigCategorie = parameterService.get(Enums.Parameters.Voertuig.Categorie);

                    if (voertuigCategorie === 'T') {
                        var landbouwVermogen = parameterService.get(Enums.Parameters.Voertuig.Vermogen);
                        switch (hoogsteEuronorm) {
                            case Enums.Euronorm.EuroV:
                                return Constants.Datums.getEindDatum_2099();
                            case Enums.Euronorm.EuroIV:
                            case Enums.Euronorm.EuroIIIb:
                            case Enums.Euronorm.EuroIIIa:
                            case Enums.Euronorm.EuroII:
                            case Enums.Euronorm.EuroI:
                            case Enums.Euronorm.Euro0:
                                if (landbouwVermogen < Enums.Parameters.MaxVermogen) {
                                    return Constants.Datums.getEindDatum_2028();
                                }

                                if (hoogsteEuronorm === Enums.Euronorm.EuroIV) return Constants.Datums.getEindDatum_2027();
                                if (hoogsteEuronorm === Enums.Euronorm.EuroIIIb) return Constants.Datums.getEindDatum_2024();

                                return Constants.Datums.getEindDatum_2019();
                            default:
                                return Constants.Datums.getEindDatum_2019();
                        }
                    }

                    switch (brandstofType) {
                        case Enums.BrandstofType.Elektrisch:
                            return Constants.Datums.getEindDatum_2099();
                        case Enums.BrandstofType.Benzine:
                            switch (hoogsteEuronorm) {
                                case Enums.Euronorm.EuroIV:
                                case Enums.Euronorm.Euro6d:
                                case Enums.Euronorm.Euro6dTemp:
                                case Enums.Euronorm.Euro6:
                                case Enums.Euronorm.Euro5:
                                case Enums.Euronorm.Euro4:
                                    return Constants.Datums.getEindDatum_2099();
                                case Enums.Euronorm.Euro3:
                                    return Constants.Datums.getEindDatum_2027();
                                case Enums.Euronorm.EuroIIIb:
                                case Enums.Euronorm.Euro2:
                                    return Constants.Datums.getEindDatum_2024();
                                case Enums.Euronorm.EuroIIIa:
                                case Enums.Euronorm.EuroII:
                                case Enums.Euronorm.EuroI:
                                case Enums.Euronorm.Euro1:
                                default:
                                    return Constants.Datums.getEindDatum_2019();
                            } // Switch - Euronorm
                        case Enums.BrandstofType.Diesel:
                            switch (hoogsteEuronorm) {
                                case Enums.Euronorm.EuroIV:
                                case Enums.Euronorm.Euro6d:
                                    return Constants.Datums.getEindDatum_2099();
                                case Enums.Euronorm.Euro6dTemp:
                                case Enums.Euronorm.Euro6:
                                    if (parameterService.equals(Enums.Parameters.Voertuig.Categorie, [Enums.VoertuigCategorien.Bus, Enums.VoertuigCategorien.ZwareVrachtwagen]))
                                        return Constants.Datums.getEindDatum_2099();
                                    else {
                                        var mrt = parameterService.get(Enums.Parameters.Voertuig.MassaRijklareToestand);
                                        if (!angular.isNumber(mrt)) {
                                            if (parameterService.equals(Enums.Parameters.Voertuig.Categorie, [Enums.VoertuigCategorien.Busje, Enums.VoertuigCategorien.LichteVrachtwagen]))
                                                return Constants.Datums.getEindDatum_2099();
                                            else
                                                return Constants.Datums.getEindDatum_2027_sept();
                                        }
                                        else if (mrt > 2585)
                                            return Constants.Datums.getEindDatum_2099();
                                        else
                                            return Constants.Datums.getEindDatum_2027_sept();
                                    }
                                case Enums.Euronorm.EuroIIIb:
                                case Enums.Euronorm.Euro5:
                                    return Constants.Datums.getEindDatum_2024();
                                case Enums.Euronorm.EuroIIIa:
                                case Enums.Euronorm.EuroII:
                                case Enums.Euronorm.EuroI:
                                case Enums.Euronorm.Euro4:
                                case Enums.Euronorm.Euro3:
                                case Enums.Euronorm.Euro2:
                                case Enums.Euronorm.Euro1:
                                default:
                                    return Constants.Datums.getEindDatum_2019();
                            } // Switch - Euronorm
                        default: // Ongekende (vereenvoudigde) brandstoftype
                            return Constants.Datums.getEindDatum_2099();
                    } // Switch - BrandstofType
            } // Switch - AanvraagSoort
            return Constants.Datums.getEindDatum_2019();
        } // Einde function _berekenEindDatumZonderTarief()
    };

    angular.module('theApp').controller(ctrlName, theController);
})();
;
(function () {
    'use strict';

    var ctrlName = "WhitelistViewController";
    var theController = function (Enums, Constants, scherm, tableHeaders, begindatum_onbepaald, einddatum_onbepaald, parameterService) {
        var ctrl = this;

        ctrl.scherm = scherm;

        ctrl.tableHeaders = tableHeaders;
        ctrl.begindatum_onbepaald = begindatum_onbepaald;
        ctrl.einddatum_onbepaald = einddatum_onbepaald;
        ctrl.whitelist = parameterService.get(Enums.Parameters.Hotlist.Lijst);
        ctrl.showWhitelist = angular.isArray(ctrl.whitelist) && ctrl.whitelist.length > 0;
        ctrl.empty = { nl: 'Je voertuig komt niet voor op de whitelist.', en: 'Your vehicle is not whitelisted.', fr: 'Votre véhicule n\'est pas sur la liste blanche', de: 'Ihr Fauhrzeug ist nicht werkseitig.' };

        _init();

        function _init() {
            ctrl.scherm.setValid(true);
        }

        ctrl.formatDate = function (date) {
            if (!angular.isDate(date)) return '-';
            else return date.format('DD/MM/YYYY - HH:mm:ss');
        };
        ctrl.isOnbepaaldEinde = function (date) {
            if (angular.isUndefinedOrNull(date)) return true;
            return Constants.Datums.getEindDatum_2099().subtract(1, 'd').isBefore(date);
        };
        ctrl.isOnbepaaldBegin = function (date) {
            if (angular.isUndefinedOrNull(date)) return true;
            return Date.Tomorrow().isAfter(date);
        };
    };

    angular.module('theApp').controller(ctrlName, theController);
})();;
(function () {

    'use strict';

    var directiveName = "dropDisable";
    var theDirective = function () {
        return {
            restrict: 'A',
            link: function (scope, element, attrs) {
                var handler = function (event) {
                    if (attrs.dropDisable && !scope.$eval(attrs.dropDisable)) return true;

                    event.preventDefault();
                    return false;
                }

                element.on('dragstart', handler);
                element.on('dragleave', handler);
                element.on('dragexit', handler);
                element.on('dragenter', handler);
                element.on('dragover', handler);
                element.on('drop', handler);
            }

        };
    };

    theDirective.$inject = [];
    angular.module('theApp').directive(directiveName, theDirective);
})();;
(function () {

    'use strict';

    var directiveName = "imageFile";
    var theDirective = function (cachedFileService, $sce) {
        return {
            restrict: 'E',
            templateUrl: 'app/views/directives/imageFile.html',
            scope: {
                data: '=',
                hideTitle: '='
            },
            link: function (scope, elem, attrs) {
                scope.isLoading = false;
                scope.base64String = undefined;
                scope.notFound = {
                    src: $sce.trustAsResourceUrl('Content/images/ImageNotFound.jpg'),
                    tekst: 'De afbeelding kon niet geladen worden.' // TODO: koppel aan meertaligheid
                };

                scope.$watch('data.id', changeImage);
                scope.$on('Taal', changeImage);

                function changeImage() {
                    scope.base64String = undefined;

                    if (angular.isUndefined(scope.data) || !scope.data.visible) return;

                    scope.isLoading = true;

                    cachedFileService.getImage(scope.data)
                        .then(function (base64String) {
                            scope.base64String = base64String;
                        })
                        .finally(function () {
                            scope.isLoading = false;
                        });
                }
            }
        };
    };

    theDirective.$inject = ['CachedFileService', '$sce'];
    angular.module('theApp').directive(directiveName, theDirective);
})();;
(function () {
    'use strict';

    angular.module('theApp').directive('lezAutocomplete', [function () {
        return {
            restrict: 'E',
            scope: {
                options: '='
            },
            templateUrl: 'templates/autocomplete.html',
            replace: true,
            transclude: true,
            link: function (scope, element, attr) {
                function areSameElement(element, source) {
                    if (element === undefined) return false;
                    if (element === source) return true;
                    if (element.id === source.id) return true;
                    if (element.id + 'autocomplete-list' === source.id) return true;
                    return false;
                }

                // Close all lists (except for the one)
                function closeAllLists(elmnt) {
                    scope.currentFocus = -1;
                    if (areSameElement(elmnt, scope.input)) return;
                    var x = document.getElementsByClassName("autocomplete-items");
                    for (var i = 0; i < x.length; i++) {
                        if (areSameElement(elmnt, x[i])) continue;
                        x[i].parentNode.removeChild(x[i]);
                    }
                }

                // Mark one item as active
                function addActive(x) {
                    if (!x) return false;
                    // Remove the active class from all items
                    removeActive(x);
                    // Limit the currentFocus
                    if (scope.currentFocus >= x.length) scope.currentFocus = 0;
                    if (scope.currentFocus < 0) scope.currentFocus = x.length - 1;
                    // Add the active class to the one item
                    x[scope.currentFocus].classList.add("autocomplete-active");
                }

                // Remove the active class from all items
                function removeActive(x) {
                    for (var i = 0; i < x.length; i++)  x[i].classList.remove("autocomplete-active");
                }

                // Update the contents of the lists
                function updateAutocompleteList() {
                    closeAllLists();

                    var val = scope.input.value ? scope.input.value : '';
                    var arr = scope.options;

                    if (!angular.isArray(arr) || arr.length === 0) return;


                    var a = document.createElement("DIV");
                    a.setAttribute("id", scope.input.id + "autocomplete-list");
                    a.setAttribute("class", "autocomplete-items");
                    scope.input.parentNode.appendChild(a);

                    var b;
                    for (var i = 0; i < arr.length; i++) {
                        // Filter the list
                        if (val.length > 0 && arr[i].substr(0, val.length).toUpperCase() !== val.toUpperCase()) continue;
                        // Create a div for each element
                        b = document.createElement("DIV");
                        b.innerHTML = "<strong>" + arr[i].substr(0, val.length) + "</strong>";
                        b.innerHTML += arr[i].substr(val.length);
                        b.innerHTML += "<input type='hidden' value='" + arr[i] + "'>";
                        b.addEventListener("click", function (e) {
                            var jq = $(scope.input);
                            jq.val(this.getElementsByTagName("input")[0].value);
                            //jq.trigger('input');
                            jq.trigger('change');
                            closeAllLists();
                        });
                        a.appendChild(b);
                    }
                }


                // Initialize
                scope.input = element.find('input')[0];
                scope.currentFocus = -1;

                scope.$watch('options', updateAutocompleteList);
                scope.input.addEventListener('click', updateAutocompleteList);
                //scope.input.addEventListener('input', updateAutocompleteList);
                scope.input.addEventListener('keydown', function (e) {
                    var x = document.getElementById(this.id + 'autocomplete-list');
                    if (x) x = x.getElementsByTagName('div');
                    if (e.keyCode === 40) { // down
                        scope.currentFocus++;
                        addActive(x);
                    } else if (e.keyCode === 38) { // up
                        scope.currentFocus--;
                        addActive(x);
                    } else if (e.keyCode === 13) { // enter
                        // prevent the form from being submitted
                        e.preventDefault();
                        if (scope.currentFocus > -1) {
                            if (x) x[scope.currentFocus].click();
                        }
                    }
                });

                scope.form = element.closest('form');
                if (scope.form) {
                    $(scope.input).focus(function () { $(scope.form).attr('autocomplete', 'off'); });
                    $(scope.input).blur(function () { $(scope.form).attr('autocomplete', 'on'); });
                }

                document.addEventListener("click", function (e) {
                    closeAllLists(e.target);
                });
            }
        };
    }]);

    angular.module('theApp').run(['$templateCache', function ($templateCache) {
        'use strict';

        $templateCache.put('templates/autocomplete.html',
            '<div class="autocomplete"><ng-transclude></ng-transclude></div>'
        );
    }]);
})();;
(function () {
    'use strict';

    var directiveName = "";
    angular.module('theApp').directive('lezBijlagenUpload', ['BijlagenService', 'LEZErrorService', function (bijlagenService, errorService) {
        return {
            restrict: 'E',
            scope: {
                ngChange: '=',
                ngEnabled: '=',
                ngModel: '=',
                ngRequired: '=',
                bijlageSoort: '=',
                limitTekst: '='
            },
            templateUrl: 'app/views/directives/bijlagenUpload.html',
            replace: true,
            link: function (scope, element, attrs) {
                scope.maxFileSizeBytes = 5300000;
                scope.validFileTypes = {
                    mimeTypes: ['image/jpeg', 'image/gif', 'image/png', 'application/pdf', 'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
                    extensions: ['jpg', 'gif', 'png', 'pdf', 'doc', 'docx']
                };
                scope.isLoading = true;

                scope.$watch('bijlageSoort', function (bijlageSoort) {
                    scope.bijlagen = bijlagenService.getBySoort(bijlageSoort);
                });

                scope.download = function (bijlage) {
                    bijlagenService.download(bijlage.aanvraagId, bijlage.id)
                        .then(undefined, function (error) {
                            errorService.error('ERR_BIJL_01', error.ErrorCodes, [bijlage.documentNaam]);
                        });
                };

                scope.delete = function (bijlage) {
                    bijlagenService.verwijder(bijlage);
                    scope.bijlagen = bijlagenService.getBySoort(scope.bijlageSoort);
                };
            }
        };
    }]);
})();;
(function () {
    'use strict';

    angular.module('theApp').directive('lezCodepicker', ['CodeService', function (codeService) {
        return {
            restrict: 'E',
            scope: {
                ngChange: '&',
                ngModel: '=',
                codeSoort: '@',
                taal: '@',
                empty: '@',
                selectClass: '@'
            },
            templateUrl: 'templates/codepicker.html',
            replace: true,
            link: function (scope, element, attr) {

                codeService.getByCodeSoort(scope.codeSoort).then(function (response) {
                    scope.codes = response;
                });

                scope.$watch('ngModel', function (newValue, oldValue){
                    if (newValue === oldValue) return;
                    if (angular.isDefined(scope.ngChange))
                        scope.ngChange();
                });

                scope.getTekst = function (meertaligheid) {
                    var taal = angular.isString(scope.taal) ? scope.taal.toLowerCase() : 'nl';
                    if (angular.isNullOrWhitespace(meertaligheid[taal]))
                        return meertaligheid.nl;
                    else return meertaligheid[taal];
                };
            }
        };
    }]);

    angular.module('theApp').run(['$templateCache', function ($templateCache) {
        'use strict';

        $templateCache.put('templates/codepicker.html',
            "<div class=select>\n" +
            //"<select id=codepicker ng-model=ngModel class={{selectClass}} ng-options=\"code as code.{{taal ? taal.toLowerCase() : 'nl'}} for code in codes track by code.id | orderBy:'{{taal ? taal.toLowerCase() : 'nl'}}'\">\n" +
            "<select id=codepicker ng-model=ngModel class={{selectClass}} ng-options=\"code as getTekst(code) for code in codes track by code.id\">\n" +
            "<option value=''>{{empty}}</option>\n" +
            "</select>\n" +
            "</div>"
        );
    }]);
})();;
(function () {
    'use strict';

    angular.module('theApp').config(['uibDatepickerConfig', function (uibDatepickerConfig) {
        uibDatepickerConfig.formatDay = 'd';
        uibDatepickerConfig.startingDay = 1;
        uibDatepickerConfig.showWeeks = false;
    }]);

    angular.module('theApp').directive('lezDatepicker', ['$timeout', '$window', function ($timeout, $window) {
        return {
            restrict: 'E',
            require: ['ngModel'],
            replace: false,
            templateUrl: 'templates/lezDatepicker.html',
            scope: {
                id: '@',
                name: '@',
                format: '@',
                ngModel: '=?',
                isRequired: '=?',
                isDisabled: '=?',
                ngChange: '&',
                minDate: '=?',
                maxDate: '=?'
            },
            link: function (scope, element, attr) {
                // Conversion methods
                function _toDate(date) {
                    if (date === null || !angular.isDate(date))
                        return null;
                    else if (date instanceof moment && date.isValid())
                        return Date.FromMoment(date);
                    else
                        return new Date(date);
                }
                function _toMoment(date) {
                    if (date === null || !angular.isDate(date))
                        return undefined;
                    else if (date instanceof moment && date.isValid())
                        return date.clone();
                    else {
                        return moment(date.toISOString(), moment.ISO_8601, true);
                    }
                }

                // Initialization
                scope.isTouch = function () {
                    var isDateSupported = function () {
                        var i = document.createElement('input');
                        i.setAttribute('type', 'date');
                        return i.type !== 'text';
                    };
                    var isNative = /(ip(a|o)d|iphone|android)/ig.test($window.navigator.userAgent);
                    return ('createTouch' in $window.document) && isNative && isDateSupported();
                }();
                scope.isRequired = scope.isRequired || false;
                scope.isDisabled = scope.isDisabled || false;
                scope.format = scope.format || 'dd/MM/yyyy';
                scope.date = _toDate(scope.ngModel);
                if (!scope.isDisabled) scope.ngModel = _toMoment(scope.date);

                // Model-Date binding
                scope.$watch('ngModel', function (newValue, oldValue) {
                    if (oldValue == newValue) return; // Zelfde waarde (geen change)
                    var d1 = moment(newValue || ''), d2 = moment(oldValue || '');
                    if (d1.isSame(d2) || (!d1.isValid() && !d2.isValid())) return; // Zelfde (ongeldige) datum (geen change)
                    var newDate = _toDate(newValue);
                    d1 = moment(newDate || ''); d2 = moment(scope.date || '');
                    if (d1.isSame(d2) || (!d1.isValid() && !d2.isValid())) return; // Zelfde (ongeldige) datum (geen change)
                    scope.date = newDate;
                });

                // Date-Model binding
                scope.onTouchChange = function () {
                    if (!scope.isTouch) return;
                    var value = element.find('input')[0].value;
                    if (angular.isString(value) && value.length > 0)
                        scope.date = moment(value, 'YYYY-MM-DD').toDate();
                    else
                        scope.date = null;
                    _onDateChange();
                };
                scope.$watch(function () { return element.find('input')[0].value; }, function (newValue, oldValue) {
                    if (scope.isDisabled) return;
                    if (scope.isTouch) return;
                    if (newValue == oldValue) return;
                    if (!angular.isString(newValue)) return;

                    var el = element.find('input')[0];
                    if (!el) return;

                    var value = newValue.replace(/[^\d\/\-\s\:\.]/g, '');
                    if (newValue != value)
                        el.value = newValue = value;

                    if (newValue.length > scope.format.length)
                        el.value = newValue = newValue.substring(0, scope.format.length);

                    value = newValue.replace(/[^\d]/g, '');
                    var j = 0;
                    var tmp = '';
                    for (var i = 0; i < scope.format.length && j < value.length; ++i) {
                        switch (scope.format[i]) {
                            case '-':
                            case ' ':
                            case '/':
                            case ':':
                            case 'T':
                                tmp += scope.format[i];
                                break;
                            default:
                                tmp += value[j++];
                                break;
                        }
                    }

                    var momentDateFormat = scope.format.replace(/d/g, 'D').replace(/y/g, 'Y');
                    var date = moment(tmp, momentDateFormat, true);
                    if (date.isValid()) {
                        scope.date = Date.FromMoment(date);
                        scope.close();
                    }
                    else
                        scope.date = null;

                    if (tmp.length === scope.format.length)
                        el.value = tmp;

                    if (angular.isString(oldValue) && value == oldValue.replace(/[^\d]/g, '')) return; // no actual change, just the formatting

                    // Force 'change' if it is 'invalid' but 'complete'
                    _onDateChange(!date.isValid() && (el.value.length === scope.format.length));
                });

                function _onDateChange(force) {
                    var original = scope.ngModel;
                    scope.ngModel = _toMoment(scope.date);
                    if (!angular.isDate(scope.ngModel))
                        scope.ngModel = undefined;

                    if (!force) {
                        var d1 = moment(original || ''), d2 = moment(scope.ngModel || '');
                        if (d1.isSame(d2) || (!d1.isValid() && !d2.isValid())) return; // Zelfde (ongeldige) datum (geen change)
                    }
                    else {
                        if (angular.isUndefined(scope.ngModel))
                            scope.ngModel = moment(NaN); // Select invalid date for validation
                    }

                    $timeout(scope.ngChange, 0);
                }

                // Ui-Bootstrap Datepicker
                scope.dateOptions = {
                    minDate: scope.minDate,
                    maxDate: scope.maxDate,
                    customClass: function (params) {
                        var d1 = moment(params.date), d2 = moment(scope.date);
                        if (!d1.isValid() || !d2.isValid()) return '';
                        if (d1.isSame(d2.startOf(params.mode))) return 'highlight';
                        return '';
                    },
                    datepickerMode: 'day'
                };
                scope.popup = {
                    opened: false
                };

                scope.$watch('minDate', function (newValue, oldValue) {
                    if (oldValue == newValue) return;
                    scope.dateOptions.minDate = newValue;
                });
                scope.$watch('maxDate', function (newValue, oldValue) {
                    if (oldValue == newValue) return;
                    scope.dateOptions.minDate = newValue;
                });

                scope.open = function () {
                    if (scope.isDisabled) return;
                    scope.dateOptions.datepickerMode = angular.isDate(scope.ngModel) ? 'day' : 'year';
                    scope.popup.opened = true;
                    element.find('input')[0].focus();
                };
                scope.close = function () {
                    scope.popup.opened = false;
                };
                scope.toggle = function () {
                    scope.popup.opened ? scope.close() : scope.open();
                };

                function _disableTabFocus() {
                    var el = element.find('.uib-yearpicker')[0];
                    if (el) el.tabIndex = -1;
                    el = element.find('.uib-monthpicker')[0];
                    if (el) el.tabIndex = -1;
                    el = element.find('.uib-daypicker')[0];
                    if (el) el.tabIndex = -1;
                }
                function _closeOnSelect(evt) {
                    var dayButtons = $(evt.currentTarget).find('.uib-day');
                    for (var i = 0; i < dayButtons.length; ++i) {
                        if (!$.contains(dayButtons[i], evt.target)) continue;
                        element.find('input')[0].focus();
                        $timeout(scope.close, evt.touches ? 100 : 0);
                        break;
                    }
                }

                scope.$watch('popup.opened', function (newValue, oldValue) {
                    if (newValue == oldValue) return;
                    if (!newValue) return;
                    $timeout(function () {
                        _disableTabFocus();
                        var el = element.find('.uib-datepicker')[0];
                        if (!el) return;
                        var fnc =  function (evt) {
                            _disableTabFocus();
                            _closeOnSelect(evt);
                        };
                        el.addEventListener('click', fnc);
                        el.addEventListener('touchend', fnc);
                    }, 1);
                });
                element[0].addEventListener('focusin', function (evt) {
                    if (evt.srcElement && $(evt.srcElement).hasClass('datepicker-icon')) return;
                    $timeout(scope.open, 0);
                });

                element[0].addEventListener('focusout', function (evt) {
                    var newTarget = evt.relatedTarget || evt.toElement;
                    if ($.contains(element[0], newTarget)) return; // New target is a sub-element, do not lose focus
                    if (!newTarget || newTarget === null) return;
                    $timeout(scope.close, 0);
                });
            }
        };
    }]);

    angular.module('theApp').run(['$templateCache', function ($templateCache) {
        'use strict';

        $templateCache.put('templates/lezDatepicker.html',
            '<div class="LEZDatePicker">' +
            '<div ng-if="isTouch">' +
            '<input id="{{id}}" name="{{name}}" type="date" pattern="[0-9]{4}-[0-9]{2}-[0-9]{2}" class="field full" ng-model="date" ng-change="onTouchChange();" ng-required="isRequired" ng-disabled="isDisabled" min="{{::dateOptions.minDate | date:\'yyyy-MM-dd\'}}" max="{{::dateOptions.maxDate | date:\'yyyy-MM-dd\'}}"/>' +
            '</div>' +
            '<div ng-if="!isTouch">' +
            '<div ng-click="open()">' +
            '<input id="{{id}}" name="{{name}}" type="text" placeholder="{{format.toLowerCase()}}" class="field full" ng-model="date" uib-datepicker-popup="{{format}}" is-open="popup.opened" datepicker-options="dateOptions" ng-required="isRequired" ng-disabled="isDisabled" on-open-focus="false" show-button-bar="false" uib-datepicker-popup="dd/MM/yyyy" />' +
            '<span ng-show="!isDisabled" class="datepicker-icon" ng-click="toggle(); $event.stopPropagation();" tabindex="-1"><i class="fa fa-calendar"></i></span>' +
            '</div>' +
            '</div>' +
            '</div>'
        );
    }]);
})();;
(function () {
    'use strict';

    angular.module('theApp').directive('lezEuronorm', ['appEnums', 'MeertaligheidService', 'ParameterService', function (Enums, meertaligheidService, parameterService) {
        return {
            restrict: 'E',
            templateUrl: 'templates/euronorm.html',
            replace: true,
            link: function (scope, element, attr) {
                var euronorm = parameterService.get(Enums.Parameters.Voertuig.EuronormVerrijkt);
                var parameter = Enums.Parameters.Voertuig.EuronormVerrijkt;
                if (angular.isUndefined(euronorm)) {
                    euronorm = parameterService.get(Enums.Parameters.Voertuig.Euronorm);
                    parameter = Enums.Parameters.Voertuig.Euronorm;
                }
                if (angular.isUndefined(euronorm)) return;

                scope.euronorm = meertaligheidService.get({ scherm: 0, itemtype: 'Content', param: parameter, parvalue: euronorm }).shift();
            }
        };
    }]);

    angular.module('theApp').run(['$templateCache', function ($templateCache) {
        'use strict';

        $templateCache.put('templates/euronorm.html',
            '<div ng-show="euronorm" class="text-center box-highlight-primary" meertaligheid="{{ {html: euronorm} }}"></div>'
        );
    }]);
})();;
(function () {
    'use strict';

    angular.module('theApp').directive('lezImageButton', ['ModalService', function (modalService) {
        return {
            restrict: 'E',
            replace: true,
            transclude: false,
            scope: {
                data: '='
            },
            template: '<a href="" ng-click="openModal()"><image-file data="data" ng-show="data && data.visible"></image-file></a>',
            link: function (scope, element, attr) {
                scope.openModal = function () {
                    if (angular.isUndefined(scope.data)) return;
                    return modalService.toonModal({
                        template: 'image.html',
                        controller: 'ImageModalController',
                        params: { data: scope.data }
                    });
                };
            }
        };
    }]);
})();
;
(function () {
    'use strict';

    angular.module('theApp').directive('lezInfoButton', ['ModalService', function (modalService) {
        return {
            restrict: 'E',
            replace: true,
            transclude: false,
            scope: {
                data: '='
            },
            template: '<button type="button" meertaligheid="{{ { html: data } }}" ng-click="openModal(data.parvalue)" class="button transparent text-left"></button>',
            link: function (scope, element, attr) {
                scope.openModal = function (schermNr) {
                    if (angular.isUndefined(schermNr)) return;
                    return modalService.toonModal({
                        template: 'infoscherm.html',
                        controller: 'InfoSchermModalController',
                        params: { scherm: schermNr }
                    });
                };
            }
        };
    }]);
})();;
(function () {
    'use strict';

    angular.module('theApp').directive('lezNumeric', [function () {
        return {
            restrict: 'E',
            replace: true,
            transclude: false,
            scope: {
                lezModel: '=',
                lezChange: '&'
            },
            template: '<input ng-model="myModel" />',
            link: function (scope, element, attr) {
                scope.myModel = scope.lezModel;
                scope.$watch('lezModel', function (newValue, oldValue) {
                    if (newValue === oldValue) return;
                    if (isValidNumber(scope.myModel) && scope.lezModel !== parseFloat(scope.myModel)) scope.myModel = scope.lezModel;
                    scope.lezChange();
                });
                scope.$watch('myModel', function (newValue, oldValue) {
                    if (newValue === oldValue) return;
                    if (!angular.isString(newValue)) {
                        scope.lezModel = scope.myModel = undefined;
                        return;
                    }
                    newValue = newValue.replace(/[^\d\-\.,]/g, '');
                    newValue = newValue.replace(/,/g, '.');

                    scope.myModel = newValue;
                    if (newValue === oldValue) return;
                    
                    if (isValidNumber(newValue))
                        scope.lezModel = parseFloat(newValue);
                    else
                        scope.lezModel = undefined;
                });

                function isValidNumber(number) {
                    if (angular.isNullOrWhitespace(number)) return false;

                    var matches = number.match(/^\-?\d+$/); // Integer values
                    if (matches) return true;
                    matches = number.match(/^\-?\d*\.\d+$/); // Decimal values
                    if (matches) return true;

                    return false;
                }
            }
        };
    }]);
})();;
(function () {
    'use strict';

    angular.module('theApp').directive('lezSubmitButton', ['NavigatieService', 'ParameterService', '$state', '$stateParams', '$anchorScroll', function (navigatieService, parameterService, $state, $stateParams, $anchorScroll) {
        return {
            restrict: 'E',
            replace: true,
            transclude: false,
            scope: {
                data: '=',
                hideTitle: "="
            },
            template: '<button type="button" ng-click="submit(data)" ng-show="data && (data.label.visible || data.image.visible)" class="button big transparent smallicon" ng-disabled="data.isLoading"><image-file data="data.image" ng-show="data.image && data.image.visible" hide-title="hideTitle"></image-file><span ng-show="data.label && data.label.visible"><br/><span class="button-text" meertaligheid="{{ { html: data.label } }}"></span></span></button>',
            link: function (scope, element, attr) {
                scope.submit = function (button) {
                    if (button.isLoading) return;
                    if (angular.isDefined(scope.data) && angular.isDefined(scope.data.label)) {
                        if (angular.isDefined(scope.data.label.param) && angular.isDefined(scope.data.label.parvalue))
                            parameterService.set(scope.data.label.param, scope.data.label.parvalue);
                        button.isLoading = true;
                        navigatieService.volgende().then(function (result) {
                            if (result.doReload) {
                                $state.transitionTo($state.current, $stateParams, { location: true, reload: true, inherit: false, notify: true });
                                $anchorScroll();
                            }
                            else button.isLoading = false;
                        }, function () { $timeout(function () { button.isLoading = false; }, 1000); });
                    }
                };
            }
        };
    }]);
})();;
(function () {
    'use strict';

    var directiveName = "lezLogin";
    var theDirective = function (authenticatieService, meertaligheidService, filterService, parameterService) {
        return {
            restrict: 'E',
            replace: true,
            template:
                '<div class="quick-menu-item login" ng-show="IsUserMode()" ng-hide="isLoading">' +
                '	<a ng-if="!IsLoggedIn()" ng-click="signIn()" class="button has-icon" alt="" ng-hide="!loginLabel.visible">' +
                '		<span class="fa fa-user"></span>' +
                '		<span class="button-text" meertaligheid="{{ { html: loginLabel } }}"></span>' +
                '	</a>' +
                '	<a ng-if="IsLoggedIn()" ng-click="signOut()" class="button has-icon" alt="">' +
                '		<span class="fa fa-user"></span>' +
                '		<span class="button-text">{{getUser().DisplayName}} (<span meertaligheid="{{ { html: logoutLabel } }}"></span>)</span>' +
                '	</a>' +
                '</div>',

            link: function (scope, elem, attrs) {
                scope.isLoading = true;
                meertaligheidService.getAll().then(function (response) {
                    scope.loginLabel = meertaligheidService.get({ naam: 'Login', scherm: 0, type: 'Titel4' }).shift();
                    scope.logoutLabel = meertaligheidService.get({ naam: 'Logout', scherm: 0, type: 'Titel4' }).shift();
                    scope.isLoading = false;
                });

                scope.signIn = function () { authenticatieService.login(); };
                scope.signOut = function () { authenticatieService.signout(); };

                scope.IsLoggedIn = function () {
                    return !angular.isUndefined(authenticatieService.userIsAuthenticated());
                };

                scope.IsUserMode = function () {
                    return angular.isUndefined(authenticatieService.userIsMedewerker());
                };

                scope.getUser = function () {
                    return authenticatieService.userIsAuthenticated();
                };
            }
        };
    };

    theDirective.$inject = ['AuthenticatieService', 'MeertaligheidService', 'FilterService', 'ParameterService'];

    angular.module('theApp').directive(directiveName, theDirective);

})();;
(function () {
    'use strict';
    var directiveName = "meertaligheid";
    var theDirective = function (Enums, parameterService, formatterService, $sce) {
        return {
            restrict: 'A',
            link: function (scope, element, attrs) {

                scope.$watch(function () {
                    return scope.$eval(attrs.meertaligheid);
                }, init, true);
                scope.$on(Enums.Parameters.Taal, init);
                scope.$on(Enums.Parameters.Kanaal, init);

                function _replaceLink(element) {
                    $(element).replaceWith(function () {
                        return $('<span>', {
                            id: this.id,
                            'class': this.className,
                            html: $(this).html()
                        });
                    });
                }
                function _removeStyle(element) {
                    element.removeAttribute('style');
                }

                function isVisible(meertaligheid) {
                    if (angular.isUndefinedOrNull(meertaligheid)) return false;
                    meertaligheid.visible = angular.isDefined(meertaligheid.visible) ? meertaligheid.visible : true;
                    return meertaligheid.visible && !angular.isNullOrWhitespace(getTekst(meertaligheid));
                }

                function getTekst(meertaligheid) {
                    var taal = parameterService.get(Enums.Parameters.Taal, true).toLowerCase();
                    var tekst = meertaligheid[taal]; // Tekst in gekozen taal
                    if (angular.isNullOrWhitespace(tekst)) tekst = meertaligheid.nl; // Tekst in default taal (nl)
                    if (angular.isNullOrWhitespace(tekst)) tekst = formatterService.toDisplayValue(meertaligheid.parvalue); // Parameter waarde van het element, geformateerd
                    return tekst;
                }

                function init() {
                    scope.meertaligheid = scope.$eval(attrs.meertaligheid);
                    if (angular.isUndefined(scope.meertaligheid)) return;

                    if (angular.isObject(scope.meertaligheid.html)) {
                        if (isVisible(scope.meertaligheid.html)) {
                            $(element).html(getTekst(scope.meertaligheid.html));

                            if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.InformatieKiosk, Enums.Kanaal.InformatieKioskChecktool])) {
                                var links = element.find('a');
                                links.each(function () {
                                    _replaceLink(this);
                                });
                            }

                            // Remove all styling provided
                            var subElements = element.find('*');
                            subElements.each(function () {
                                _removeStyle(this);
                            });
                        }
                        else {
                            $(element).hide();
                            return; // Nothing else matters
                        }
                    }

                    if (angular.isObject(scope.meertaligheid.title)) {
                        if (isVisible(scope.meertaligheid.title))
                            $(element).attr('title', getTekst(scope.meertaligheid.title));
                        else
                            $(element).attr('title', undefined);
                    }

                    if (angular.isObject(scope.meertaligheid.alt)) {
                        if (isVisible(scope.meertaligheid.alt))
                            $(element).attr('alt', getTekst(scope.meertaligheid.alt));
                        else
                            $(element).attr('alt', undefined);
                    }

                    if (angular.isObject(scope.meertaligheid.href)) {
                        if (isVisible(scope.meertaligheid.href)) {
                            var url = getTekst(scope.meertaligheid.href);
                            if (!/^https?:\/\//i.test(url)) url = "http://" + url;
                            $(element).attr('href', $sce.trustAsResourceUrl(url));
                        }
                        else
                            $(element).attr('href', undefined);

                        if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.InformatieKiosk, Enums.Kanaal.InformatieKioskChecktool])) {
                            _replaceLink(element);
                        }
                    }

                    $(element).show();
                }
            }
        };
    };
    theDirective.$inject = ['appEnums', 'ParameterService', 'FormatterService', '$sce'];
    angular.module('theApp').directive(directiveName, theDirective);
})();;
(function () {

    'use strict';
    var directiveName = "navigatie";
    var theDirective = function (logger, navigatieService, parameterService, Enums, $timeout, $state, $stateParams, $anchorScroll, toaster) {
        return {
            restrict: 'E',
            templateUrl: 'app/views/directives/navigatie.html',
            scope: {
                navterug: '=',
                navbegin: '=',
                navvlg: '=',
                navval: '=',
                navvul: '=',
                navexit: '=',
                navaan: '=',
                hyperlink: '='
            },
            link: function (scope, elem, attrs) {
                logger.creation(directiveName);

                init();

                function init() {
                    if (angular.isDefined(scope.navterug)) scope.navterug.isLoading = false;
                    if (angular.isDefined(scope.navbegin)) scope.navbegin.isLoading = false;
                    if (angular.isDefined(scope.navvlg)) scope.navvlg.isLoading = false;
                    if (angular.isDefined(scope.navval)) scope.navval.isLoading = false;
                    if (angular.isDefined(scope.navvul)) scope.navvul.isLoading = false;
                    if (angular.isDefined(scope.navexit)) scope.navexit.isLoading = false;
                    if (angular.isDefined(scope.navaan)) scope.navaan.isLoading = false;
                }

                function _performAction(button, action) {
                    if (angular.isUndefined(button) || angular.isUndefined(action)) return;

                    // Foutboodschappen opkuisen
                    toaster.clear();

                    button.isLoading = true;
                    action().then(function (result) {
                        if (result.doReload) {
                            $state.transitionTo($state.current, $stateParams, { location: true, reload: true, inherit: false, notify: true });
                            $anchorScroll();
                        }
                        else button.isLoading = false;
                    }, function () { button.isLoading = false; });
                }
                scope.actie = function (button) {
                    if (angular.isUndefined(button)) return;

                    if (button === scope.navbegin) _performAction(scope.navbegin, function () { return navigatieService.annuleren(true); });
                    if (button === scope.navterug) _performAction(scope.navterug, navigatieService.vorige);
                    if (button === scope.navvlg) _performAction(scope.navvlg, navigatieService.volgende);
                    if (button === scope.navval) _performAction(scope.navval, navigatieService.opslaan);
                    if (button === scope.navexit) _performAction(scope.navexit, navigatieService.exit);
                    if (button === scope.navvul) {
                        if (button.conditievalue === '1') {
                            var selectedOption = parameterService.get(Enums.Parameters.SelectedRequestOption);
                            switch (selectedOption) {  
                                case '3':
                                case '4':
                                case '5':
                                case '7':
                                case '8':
                                case '10':
                                case '17':
                                case '18':
                                case '20':
                                case '21':
                                case '23':
                                    _performAction(scope.navvul, navigatieService.volgende);
                                    break;
                                default:
                                    _performAction(scope.navvul, navigatieService.aanvullen);
                                    break;
                            };
                        } else {
                            _performAction(scope.navvul, navigatieService.aanvullen);
                        }
                    };
                    if (button === scope.navaan) {
                        var selectedOption = parameterService.get(Enums.Parameters.SelectedRequestOption);
                        switch (selectedOption) {
                            case '1':
                            case '3':
                            case '4':
                            case '5':
                            case '7':
                            case '8':
                            case '10':
                            case '15':
                            case '17':
                            case '18':
                            case '20':
                            case '21':
                            case '23':
                                _performAction(scope.navaan, navigatieService.volgende);
                                break;
                            default:
                                _performAction(scope.navaan, navigatieService.login);
                                break;
                        };
                    };
                };

                scope.isDisabled = function (button) {
                    if (button === scope.navval) {
                        return false;
                    }

                    return (angular.isUndefined(button) || (angular.isDefined(button.isDisabled) && button.isDisabled()) || scope.isLoading());
                };

                scope.isVisible = function (button) {
                    if (!angular.isDefined(button)) return false;
                    if (angular.isDefined(button.isVisible)) return button.isVisible();
                    else return button.visible;
                };

                scope.isLoading = function (button) {
                    if (angular.isDefined(button)) return button.isLoading;

                    // Is anything else loading?
                    if (angular.isDefined(scope.navbegin) && scope.navbegin.isLoading) return true;
                    if (angular.isDefined(scope.navterug) && scope.navterug.isLoading) return true;
                    if (angular.isDefined(scope.navvlg) && scope.navvlg.isLoading) return true;
                    if (angular.isDefined(scope.navval) && scope.navval.isLoading) return true;
                    if (angular.isDefined(scope.navvul) && scope.navvul.isLoading) return true;
                    if (angular.isDefined(scope.navexit) && scope.navexit.isLoading) return true;
                    if (angular.isDefined(scope.navaan) && scope.navaan.isLoading) return true;
                };
            }
        };
    };

    theDirective.$inject = ['Logger', 'NavigatieService', 'ParameterService', 'appEnums', '$timeout', '$state', '$stateParams', '$anchorScroll', 'toaster'];
    angular.module('theApp').directive(directiveName, theDirective);
})();
;
(function () {

    'use strict';

    var directiveName = "otherFile";
    var theDirective = function (fileService, cachedFileService, $timeout) {
        return {
            restrict: 'E',
            templateUrl: 'app/views/directives/otherFile.html',
            scope: {
                hoofding: '=',
                data: '='
            },
            link: function (scope, elem, attrs) {
                scope.enabled = true;

                scope.downloadFile = function () {
                    if (angular.isUndefined(scope.data) || !scope.data.visible) return;

                    scope.enabled = false;
                    cachedFileService.downloadFile(scope.data)
                        .then(function (file) {
                            if (file === undefined) return;
                            fileService.viewInBrowser(file.fileName, file.contentType, file.data);
                        })
                        .finally(function () {
                            $timeout(function () { scope.enabled = true; }, 1000);
                        });
                };
            }
        };
    };

    theDirective.$inject = ['FileService', 'CachedFileService', '$timeout'];
    angular.module('theApp').directive(directiveName, theDirective);
})();;
(function () {
    'use strict';

    var directiveName = "tariefTabel";
    var theDirective = function (Enums, tariefService, parameterService, errorService) {
        return {
            restrict: 'E',
            templateUrl: 'app/views/directives/tariefTabel.html',
            scope: {
                onChange: '=?',
                beginDatum: '=?',
                headers: '=?',
                empty: '@',
                selectedId: '=?'
            },
            link: function (scope, elem, attrs) {
                _laadTarieven(scope.beginDatum);

                scope.selected = undefined;

                scope.$watch('beginDatum', _laadTarieven);
                scope.$watch('selectedId', _selectieGewijzigd);
                scope.onClick = function (tarief) {
                    if (!angular.isObject(tarief)) return;
                    if (angular.isObject(scope.selected) && scope.selected.id === tarief.id) {
                        scope.selected = undefined;
                        scope.onChange(scope.selected);
                    }
                    else {
                        scope.selected = tarief;
                        scope.onChange(scope.selected);
                    }

                };

                function _laadTarieven(bdat, oldbdat) {
                    if (bdat === oldbdat) return;

                    if (angular.isUndefined(bdat)) return;

                    scope.isLoading = true;
                    scope.tarieven = [];

                    var params = {};
                    params[Enums.Parameters.Taal] = parameterService.get(Enums.Parameters.Taal);
                    params[Enums.Parameters.AanvraagType] = parameterService.get(Enums.Parameters.AanvraagType);
                    params[Enums.Parameters.AanvraagSoort] = parameterService.get(Enums.Parameters.AanvraagSoort);
                    params[Enums.Parameters.Voertuig.Categorie] = parameterService.get(Enums.Parameters.Voertuig.Categorie);
                    params[Enums.Parameters.Voertuig.Euronorm] = parameterService.get(Enums.Parameters.Voertuig.Euronorm);
                    params[Enums.Parameters.Voertuig.EuronormVerrijkt] = parameterService.get(Enums.Parameters.Voertuig.EuronormVerrijkt);
                    params[Enums.Parameters.Voertuig.EuronormGecorrigeerd] = parameterService.get(Enums.Parameters.Voertuig.EuronormGecorrigeerd);
                    params[Enums.Parameters.Voertuig.BrandstofType] = parameterService.get(Enums.Parameters.Voertuig.BrandstofType);
                    params[Enums.Parameters.BeginDatum] = bdat;
                    tariefService.search(params)
                        .then(function (tarieven) { scope.tarieven = tarieven; }, function (error) { errorService.error('ERR_SRV_02', error.ErrorCodes); })
                        .finally(function () {
                            if (angular.isDefined(scope.selectedId)) {
                                _selectieGewijzigd(scope.selectedId, undefined);
                            }

                            scope.isLoading = false;
                        });
                }

                function _selectieGewijzigd(selectedId, oldSelectedId) {
                    if (selectedId === oldSelectedId) return;
                    if (angular.isUndefined(selectedId)) return;
                    scope.selected = scope.tarieven.filter(function (tar) { return tar.id === selectedId; }).shift();
                    scope.onChange(scope.selected);
                }
            }
        };
    };

    theDirective.$inject = ['appEnums', 'TariefService', 'ParameterService', 'LEZErrorService'];

    angular.module('theApp').directive(directiveName, theDirective);

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

    var directiveName = "validationMessages";
    var theDirective = function () {
        return {
            restrict: 'E',
            template: '<div ng-if="validation().messages.length > 0">' +
                '<ul class="list-unstyled" ng-repeat="message in validation().messages" >' +
                '<li><p class="{{validation().getMessageCssClass()}}" meertaligheid="{{ { html: message } }}"></p></li>' +
                '</ul>' +
                '</div>',
            scope: {
                validation: '&'
            },
            link: function (scope, elem, attrs) {
            }
        };
    };

    theDirective.$inject = [];

    angular.module('theApp').directive(directiveName, theDirective);

})();;
(function () {

    'use strict';

    var componentName = "AppStatusService";
    var theComponent = function (appService, codeService, $q) {

        var _offline = false, _maintenance = false, _maintenance_shown = false;

        function _init() {
            _fetchOffline();
            _fetchMaintenance();

            setInterval(_fetchOffline, 60000);
            setInterval(_fetchMaintenance, 300000);
        }

        function _fetchOffline() {
            codeService.getByTechnischeSleutel('APP_OFFLINE')
                                     .then(function (code) { return angular.isObject(code) && code.isActief; })
                                     .then(function (result) { _offline = result; });
        }

        function _fetchMaintenance() {
            codeService.getByTechnischeSleutel('APP_MAINTENANCE')
                                     .then(function (code) { return angular.isObject(code) && code.isActief; })
                                     .then(function (result) { _maintenance = result; });
        }


        _init();

        /* +++++ public interface +++++ */

        function _isOffline() {
            return _offline;
        }

        function _isMaintenance() {
            return _maintenance && !_maintenance_shown;
        }

        function _setMaintenanceShown() {
            _maintenance_shown = true;
        }

        appService.logger.creation(componentName);

        return {
            isOffline: _isOffline,
            isMaintenance: _isMaintenance,

            setMaintenanceShown: _setMaintenanceShown
        };

    };

    theComponent.$inject = ['AppService', 'CodeService', '$q'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function () {

    'use strict';

    var componentName = "AuthenticatieService";
    var theComponent = function (appService, appConfig, Enums, parameterService, formatterService, aanvraagService, $q, $window, $cookies, $location, $state) {
        
        function _authenticate_Aprofiel(deferred) {
            // Retrieve user
            var user = _userIsAprofiel();
            if (angular.isUndefined(user)) {
                // LEZ-967 - Resetten na login enkel indien NPL niet gekend
                var needsReset = angular.isNullOrWhitespace(parameterService.get(Enums.Parameters.Voertuig.Nummerplaat));
                if (!needsReset)
                {
                    $cookies.put('LEZParams', angular.toJson(parameterService.getParametersObject()));
                }

                // Initiate login procedure
                $cookies.put('LEZAuthCallbackRedirectUrl', $window.location);
                var authParams = appConfig.auth.params;
                authParams.lng = parameterService.get('Taal', true).toLowerCase();
                var loginPath = appConfig.auth.authorizationEndpoint + formatterService.toQueryString(authParams);
                $window.location = loginPath;
                return;
            }
            // Set user parameters
            parameterService.set(Enums.Parameters.Gebruiker.Identificatie, user.Id);
            parameterService.set(Enums.Parameters.Gebruiker.Token, user.Token);
            parameterService.set(Enums.Parameters.Aanvrager.Naam, user.Familienaam);
            parameterService.set(Enums.Parameters.Aanvrager.Voornaam, user.Voornaam);
            parameterService.set(Enums.Parameters.Aanvrager.Email, user.Email);
            parameterService.set(Enums.Parameters.Taal, user.Taal);
            parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.EloketAprofiel);
            // Resolve
            deferred.resolve('A-Profiel gebruiker is ingelogd.');
        }

        function _authenticate_Anoniem(deferred, isEIDRequired) {
            // Retrieve user
            var user = _userIsAnoniem(isEIDRequired);
            if (angular.isUndefined(user)) {
                // Initiate login procedure
                $cookies.put('LEZAuthCallbackRedirectUrl', $window.location);
                $state.transitionTo('login', { Taal: parameterService.get(Enums.Parameters.Taal), eid: 1 }, { location: false, reload: true, notify: true, inherit: false });
                return;
            }
            // Set user parameters
            parameterService.set(Enums.Parameters.Aanvrager.Email, user.Email);
            if (isEIDRequired) parameterService.set(Enums.Parameters.Voertuig.DatumEersteInschrijving, user.Datum);
            parameterService.set(Enums.Parameters.Taal, user.Taal);
            parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.EloketEmail);
            // Resolve
            deferred.resolve('Anonieme gebruiker is ingelogd.');
        }

        function _authenticate_Medewerker(deferred) {
            // Retrieve user
            var user = _userIsMedewerker();
            if (angular.isUndefined(user)) {
                // Initiate login procedure - There is none
                return deferred.reject('Medewerker niet ingelogd.');
            }
            // Set user parameters - Already set
            // Resolve
            deferred.resolve('Medewerker is ingelogd.');
        }

        /* +++++ exposed methods +++++ */

        function _userIsAuthenticated() {
            var user = _userIsMedewerker();
            if (!angular.isUndefined(user)) return user;
            user = _userIsAprofiel();
            if (!angular.isUndefined(user)) return user;
            user = _userIsAnoniem();
            if (!angular.isUndefined(user)) return user;

            return undefined;
        }

        function _userIsAprofiel() {
            // Get User Object
            var user = $cookies.getObject('LEZsessionuser');
            // Validate User Object
            if (angular.isUndefinedOrNull(user))
                return undefined;
            if (!angular.isString(user.ProfileType) || user.ProfileType !== Enums.Auth.ProfielTypes.AProfiel)
                return undefined;
            if (!angular.isString(user.Id) || user.Id.length <= 0)
                return undefined;
            if (!angular.isString(user.Token) || user.Token.length <= 0)
                return undefined;
            if (!angular.isString(user.Email) || user.Email.length <= 0)
                return undefined;
            // Create the display name
            if (user.Voornaam && user.Familienaam) {
                user.DisplayName = user.Voornaam + ' ' + user.Familienaam;
            } else {
                user.DisplayName = user.Email;
            }
            // Return the user
            return user;
        }

        function _userIsAnoniem(isEIDRequired) {
            // Get User Object
            var user = $cookies.getObject('LEZsessionuser');
            // Validate User Object
            if (angular.isUndefinedOrNull(user))
                return undefined;
            if (!angular.isString(user.ProfileType) || user.ProfileType !== Enums.Auth.ProfielTypes.Anoniem)
                return undefined;
            if (!angular.isString(user.Email) || user.Email.length <= 0)
                return undefined;
            if (!angular.isString(user.Token) || user.Token.length <= 0)
                return undefined;
            if (isEIDRequired && angular.isUndefinedOrNull(user.Datum))
                return undefined;
            // Create the display name
            user.DisplayName = user.Email;
            // Return the user
            return user;
        }

        function _userIsMedewerker() {
            // Get User Object
            var user = {
                Naam: parameterService.get(Enums.Parameters.Medewerker.Naam),
                Token: parameterService.get(Enums.Parameters.Medewerker.Token),
                Kanaal: parameterService.get(Enums.Parameters.Kanaal),
                Loket: parameterService.get(Enums.Parameters.Medewerker.Identificatie),
                ProfileType: Enums.Auth.ProfielTypes.Medewerker,
                KassaToepassing: parameterService.get(Enums.Parameters.Medewerker.KassaToepassing)
            };
            // Validate User Object
            if (angular.isUndefinedOrNull(user))
                return undefined;
            if (!angular.isString(user.Loket) || user.Loket.length <= 0)
                return undefined;
            if (!angular.isString(user.Token) || user.Token.length <= 0)
                return undefined;
            // Create the display name
            user.DisplayName = user.Naam;
            // Return the user
            return user;
        }

        function _login(aanvraagId, doIgnoreType) {
            var deferred = $q.defer();
            
            if (angular.isDefined(aanvraagId))
            {
                aanvraagService.authentication(aanvraagId).then(function (result) {
                    if (angular.isDefined(result.taal)) parameterService.set(Enums.Parameters.Taal, result.taal);

                    if (!doIgnoreType && result.type === Enums.AanvraagType.Dagpas && (result.methode === Enums.Kanaal.EloketAprofiel || result.methode === Enums.Kanaal.EloketEmail))
                        return deferred.reject('Dagpassen mogen niet geopend worden in de front-office toepassing.');
                    
                    switch (result.methode) {
                        case Enums.Kanaal.EloketAprofiel:
                            _authenticate_Aprofiel(deferred);
                            break;
                        case Enums.Kanaal.EloketEmail:
                            if (result.type === Enums.AanvraagType.Dagpas)
                                _authenticate_Anoniem(deferred, false);
                            else
                                _authenticate_Anoniem(deferred, true);
                            break;
                        case Enums.Kanaal.BackOffice:
                        case Enums.Kanaal.DLloket:
                            var user = _userIsMedewerker();
                            if (angular.isObject(user) && user.Kanaal === result.methode)
                                deferred.resolve('Medewerker is ingelogd!');
                            else if (angular.isDefined(user))
                                deferred.reject('De medewerker bezit niet de juiste rechten om deze aanvraag te openen.');
                            else
                                deferred.reject('Backoffice medewerkers dienen al reeds te zijn ingelogd.');
                            break;
                        case Enums.Kanaal.ParkeerMeter:
                            deferred.reject('Aanvragen van parkeermeters mogen niet geopend worden in de front-office toepassing.');
                            break;
                        case Enums.Kanaal.InformatieKiosk:
                            deferred.reject('Aanvragen van informatie kiosken mogen niet geopend worden in de front-office toepassing.');
                            break;
                        default:
                            deferred.reject('Ongekende aanvraag kanaal, kan niet openen.');
                            break;
                    }
                }, function () { _authenticate_Aprofiel(deferred); });
            }
            else
            {
                var user = _userIsAuthenticated();
                user = user ? user : {};
                switch (user.ProfileType)
                {
                    case Enums.Auth.ProfielTypes.Medewerker:
                        _authenticate_Medewerker(deferred);
                        break;
                    case Enums.Auth.ProfielTypes.Anoniem:
                        _authenticate_Anoniem(deferred);
                        break;
                    case Enums.Auth.ProfielTypes.AProfiel:
                    default:
                        _authenticate_Aprofiel(deferred);
                        break;
                }
            }

            return deferred.promise;
        }

        function _setUser(user, doReload) {
            $cookies.putObject('LEZsessionuser', user);
            if (doReload)
            {
                $state.transitionTo('authentication', { a: user.Token }, { location: true, reload: true, notify: true, inherit: false });
            }
        }

        function _signout(doNotReload) {
            $cookies.remove('LEZsessionuser');
            $cookies.remove('LEZAuthCallbackRedirectUrl');

            if (doNotReload) return;

            var search = {};
            search[Enums.Parameters.Taal] = parameterService.get(Enums.Parameters.Taal, true);
            $location.search(search);
            $window.location.reload();
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            login: _login,
            setUser: _setUser,
            signout: _signout,
            userIsAuthenticated: _userIsAuthenticated,
            userIsAprofiel: _userIsAprofiel,
            userIsAnoniem: _userIsAnoniem,
            userIsMedewerker: _userIsMedewerker
        };

    };

    theComponent.$inject = ['AppService', 'appConfig', 'appEnums', 'ParameterService', 'FormatterService', 'AanvraagService', '$q', '$window', '$cookies', '$location', '$state'];

    angular.module('theApp').factory(componentName, theComponent);

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

    var componentName = "BijlagenService";
    var theComponent = function (appService, bijlageService, errorService, $q, Bijlage) {
        var _current = [];
        var _removed = [];
        var _documenten = [];

        /* +++++ exposed methods +++++ */
        function _init(aanvraagId) {
            _current = [];
            _removed = [];
            _documenten = [];
            if (angular.isNullOrWhitespace(aanvraagId)) {
                var deferred = $q.defer();
                deferred.resolve();
                return deferred.promise;
            }
            else
                return bijlageService
                        .getAll(aanvraagId)
                        .then(function (bijlagen) {
                            _current = bijlagen.filter(function (bijl) { return !angular.isDefined(bijl.soort) || bijl.soort.param === 'BIJL'; });
                            _documenten = bijlagen.filter(function (bijl) { return angular.isDefined(bijl.soort) && bijl.soort.param === 'DOC'; });
                            _removed = [];
                        }, function (error) {
                            errorService.error('ERR_SRV_06', error.ErrorCodes);
                            throw error;
                        });
        }

        function _getDocumenten() {
            var result = [];
            for (var i = 0, len = _documenten.length; i < len; ++i) result.push(_documenten[i]);
            return result;
        }

        function _getAll() {
            var result = [];
            for (var i = 0, len = _current.length; i < len; ++i) result.push(_current[i]);
            return result;
        }

        function _getBySoort(soort) {
            if (angular.isUndefinedOrNull(soort)) return [];

            var result = [];
            for (var i = 0, len = _current.length; i < len; ++i) {
                var bijlage = _current[i];
                if (angular.isUndefinedOrNull(bijlage.soort)) continue;
                if (bijlage.soort.id === soort.id) result.push(bijlage);
            }
            return result;
        }

        function _download(aanvraagId, bijlageId) {
            return bijlageService.download(aanvraagId, bijlageId);
        }

        function _add(file, options) {
            _current.push(new Bijlage(0, options.soort, null, file.name, file));
        }

        function _remove(file) {
            var index = -1;
            var bijlage;
            for (var i = 0, len = _current.length; i < len; ++i) {
                bijlage = _current[i];
                if (bijlage.data !== file) continue;
                index = i;
                break;
            }
            if (index === -1) return;

            bijlage = _current.splice(index, 1).shift();
            if (bijlage.id > 0) _removed.push(bijlage);
        }

        function _verwijder(bijlage) {
            var index = -1;
            for (var i = 0, len = _current.length; i < len; ++i) {
                var b = _current[i];
                if (b !== bijlage) continue;
                index = i;
                break;
            }
            if (index === -1) return;

            bijlage = _current.splice(index, 1).shift();
            if (bijlage.id > 0) _removed.push(bijlage);
        }

        function _commit(aanvraagId) {
            var actions = [];
            var i = 0, len = 0;
            for (i = 0, len = _current.length; i < len; ++i) {
                var bijlage = _current[i];
                if (bijlage.id > 0) continue;
                (function (aanvraagId, bijlage) {
                    bijlage.aanvraagId = aanvraagId;
                    actions.push(bijlageService.add(aanvraagId, bijlage)
                                        .then(function (result) {
                                            bijlage.id = result.id;
                                            errorService.success('SUC_BIJL_03A', undefined, [bijlage.documentNaam]);
                                        }, function (error) {
                                            errorService.error('ERR_BIJL_03', error.ErrorCodes, [bijlage.documentNaam]);
                                            throw error;
                                        }));
                })(aanvraagId, _current[i]);
            }
            for (i = 0, len = _removed.length; i < len; ++i) {
                (function (bijlage) {
                    actions.push(bijlageService.remove(aanvraagId, bijlage.id)
                                    .then(function () {
                                        errorService.success('SUC_BIJL_02A', undefined, [bijlage.documentNaam]);
                                        var index = -1;
                                        for (var j = 0, b; b = _removed[j]; ++j) {
                                            if (b.id !== bijlage.id) continue;
                                            index = j;
                                            break;
                                        }
                                        _removed.splice(index, 1);

                                    }, function (error) {
                                        errorService.error('ERR_BIJL_02A', error.ErrorCodes, [bijlage.documentNaam]);
                                        _current.push(bijlage);
                                        throw reason;
                                    }));
                })(_removed[i]);
            }

            return $q.all(actions);
        }


        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            init: _init,
            getDocumenten: _getDocumenten,
            getAll: _getAll,
            getBySoort: _getBySoort,
            download: _download,
            add: _add,
            remove: _remove,
            verwijder: _verwijder,
            commit: _commit
        };

    };

    theComponent.$inject = ['AppService', 'BijlageService', 'LEZErrorService', '$q', 'Bijlage'];

    angular.module('theApp').factory(componentName, theComponent);

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

    var serviceName = "CachedFileService";
    var theFileService = function (Enums, appConfig, lezErrorService, $http, $q, $rootScope) {
        var _url = appConfig.apiUrl + "meertaligheid/";

        var _cache = {};
        var _taal = Enums.Taal.Nederlands;

        function _clearCache() {
            _cache = {};
        }

        function _getCache(id) {
            if (angular.isDefined(_cache[id])) return _cache[id];
            _cache[id] = { status: false };
            return _cache[id];
        }

        function _getFile(id, taal) {
            if (angular.isUndefined(taal)) taal = Enums.Taal.Nederlands;

            var requestUrl = _url + "download/" + id;
            var params = { responseType: "arraybuffer", params: { taal: taal } };

            var getResult = $http.get(requestUrl, params).then(
                            function (response) {
                                var contentType = response.headers('content-type') || 'application/octet-stream';
                                var fileName = Object.parseFileName(response.headers);
                                return { fileName: fileName, contentType: contentType, data: response.data };
                            });

            var deferred = $q.defer();

            getResult.then(
                function (result) {
                    deferred.resolve(result);
                },
                function (reason) {
                    // Retry to Download Dutch Version
                    if (taal === Enums.Taal.Nederlands) deferred.reject(reason);
                    else _getFile(id)
                            .then(function (result) { deferred.resolve(result); },
                                    function (reason) { deferred.reject(reason); });
                });

            return deferred.promise;
        }

        function _getBase64String(id, taal) {
            if (angular.isNullOrWhitespace(taal)) taal = Enums.Taal.Nederlands;

            var requestUrl = _url + "image/" + id + "?taal=" + taal;

            var getResult = $http.get(requestUrl).then(
                                function (response) {
                                    var base64 = response.data;
                                    if (angular.isUndefinedOrNull(base64) || base64.length <= 0)
                                        throw { status: 500, statusText: "Internal Server Error" };
                                    else return base64;
                                });

            var deferred = $q.defer();

            getResult.then(
                function (result) {
                    deferred.resolve(result);
                },
                function (reason) {
                    // Retry to Download Dutch Version
                    if (taal === Enums.Taal.Nederlands) deferred.reject(reason);
                    else _getBase64String(id)
                            .then(function (result) { deferred.resolve(result); },
                                  function (reason) { deferred.reject(reason); });
                });

            return deferred.promise;
        }
        
        /* +++++ exposed methods +++++ */

        function _downloadFile(data) {
            var cacheItem = _getCache('file_' + data.id);
            if (cacheItem.status === true) return cacheItem.promise;

            var taal = angular.isNullOrWhitespace(data[_taal.toLowerCase()]) ? Enums.Taal.Nederlands : _taal;

            cacheItem.status = true;
            cacheItem.promise = _getFile(data.id, taal).then(
                        function (file) {
                            if (file.fileName === "download.bin") file.fileName = data[taal];
                            cacheItem.status = true;
                            return file;
                        },
                        function (error) {
                            cacheItem.status = false;
                            lezErrorService.error('ERR_BIJL_01', error.ErrorCodes, [data[taal]]);
                        });

            return cacheItem.promise;
        }

        function _getImage(data) {
            var cacheItem = _getCache('image_' + data.id);
            if (cacheItem.status === true) return cacheItem.promise;

            var taal = angular.isNullOrWhitespace(data[_taal.toLowerCase()]) ? Enums.Taal.Nederlands : _taal;

            cacheItem.status = true;
            cacheItem.promise = _getBase64String(data.id, taal).then(
                        function (base64) {
                            cacheItem.status = true;
                            return base64;
                        },
                        function (error) {
                            cacheItem.status = false;
                            lezErrorService.debug('ERR_BIJL_01', error.ErrorCodes, [data[taal]]);
                            return undefined;
                        });

            return cacheItem.promise;
        }

        $rootScope.$on(Enums.Parameters.Taal, function (e, taal) {
            if (taal === _taal) return;
            _clearCache();
            _taal = taal ? taal : Enums.Taal.Nederlands;
        });

        /* +++++ public interface +++++ */

        return {
            downloadFile: _downloadFile,
            getImage: _getImage
        };
    };

    theFileService.$inject = ['appEnums', 'appConfig', 'LEZErrorService', '$http', '$q', '$rootScope' ];
    angular.module('theApp').factory(serviceName, theFileService);
})();
;
(function () {

    'use strict';

    var componentName = "LEZErrorService";
    var theComponent = function (appService, errorMessageService, toaster, $rootScope) {

        var _titles = {
            "success": { nl: 'Gelukt', en: 'Success', fr: 'Succès', de: 'Erfolg' },
            "error": { nl: 'Fout', en: 'Error', fr: 'Erreur', de: 'Fehler' },
            "warning": { nl: 'Waarschuwing', en: 'Warning', fr: 'Avertissement', de: 'Warnung' },
            "debug": { nl: 'Debug', en: 'Debug', fr: 'Déboguer', de: 'Debuggen' }
        };

        var _taal = "nl";
        $rootScope.$on('Taal', function (undef, taal) { if (angular.isString(taal)) _taal = taal.toLowerCase(); });

        function _getTitle(type) {
            if (angular.isUndefined(_titles[type])) return undefined;
            if (angular.isNullOrWhitespace(_titles[type][_taal]))
                return _titles[type].nl;
            else
                return _titles[type][_taal];
        }

        function _getMessage() {
            var errorId = arguments[0];
            var errorCodes = arguments[1];
            var args = arguments[2];
            var message = errorMessageService.get(errorId);
            if (angular.isUndefined(message)) {
                if (angular.isArray(errorCodes) && errorCodes.length > 0)
                    return errorCodes.join(', ');
                else
                    return undefined;
            }

            if (angular.isArray(args) && args.length > 0) message.setValues.apply(message, args);

            var msg = message[_taal];
            if (angular.isNullOrWhitespace(msg))
                msg = message.nl;

            if (angular.isArray(errorCodes) && errorCodes.length > 0)
                msg += ' (' + errorCodes.join(', ') + ')';

            return msg;
        }

        /* +++++ exposed methods +++++ */
        function _success() {
            var title = _getTitle("success");
            var message = _getMessage.apply(this, arguments);

            appService.logger.debug(title + ': ' + message);
            toaster.success(title, message);
        }

        function _error() {
            var title = _getTitle("error");
            var message = _getMessage.apply(this, arguments);

            appService.logger.error(title + ': ' + message);
            toaster.error(title, message);
        }

        function _warning() {
            var title = _getTitle("warning");
            var message = _getMessage.apply(this, arguments);

            appService.logger.warn(title + ': ' + message);
            toaster.warning(title, message);
        }

        function _debug() {
            var title = _getTitle("debug");
            var message = _getMessage.apply(this, arguments);

            appService.logger.debug(title + ": " + message);
        }

        function _message(message) {
            var title = _getTitle("error");

            if (angular.isNullOrWhitespace(message[_taal]))
                toaster.error(title, message.nl);
            else
                toaster.error(title, message[_taal]);
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            success: _success,
            error: _error,
            warning: _warning,
            debug: _debug,

            // Multi-Lang. Message
            message: _message
        };

    };

    theComponent.$inject = ['AppService', 'ErrorMessageService', 'toaster', '$rootScope'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function () {

    'use strict';

    var serviceName = "NavigatieService";
    var theRepository = function (Config, Enums, Constants, appService, $q, $state, parameterService, parameterHelperService, lezErrorService, aanvraagService, whitelistService, paymentService, authenticatieService, bijlagenService, dagpasService, infokioskService, tellerService, $window, blockUI, modalService, codeService) {

        var _history = [];
        var _schermen = {};
        var _kanteldatum1;
        var _kanteldatum2;

        function init() {
            appService.logger.init(serviceName);

            _schermen = {};

            laadSchermen();
        }

        /*** HELPER FUNCTIES DIE MEERMAALS GEBRUIKT WORDEN ***/

        /// Deze functie berekend de Verrijkte Euronorm, daarna de EuronormVoorwaarden en vervolgens zal het afhankelijk van het resultaat navigeren naar scherm 33 (Gecorrigeerde Euronorm) of naar 41 (Keuze Aanvraag Soort)
        function _berekenVerrijkteEuronorm(resolve, reject) {
            // Opzetten van help methodes
            var isMrtNodig = function (euronorm) {
                if (euronorm === undefined) return false;

                // Indien reeds gekend, is het niet meer nodig
                var mrt = parameterService.get(Enums.Parameters.Voertuig.MassaRijklareToestand);
                if (angular.isNumber(mrt)) return false;

                if (euronorm === null) {
                    // Wanneer de euronorm niet berekend kan worden, heb je de mrt écht nodig
                    parameterService.set(Enums.Parameters.Voertuig.MassaRijklareToestandVerplicht, true);
                    return true;
                }

                parameterService.set(Enums.Parameters.Voertuig.MassaRijklareToestandVerplicht, false);

                // Indien MRT scherm al reeds is getoond, slaag het dan verder over
                if (!angular.isNullOrWhitespace(mrt)) return false;

                if (euronorm === Enums.Euronorm.Euro6 || euronorm === Enums.Euronorm.Euro6dTemp) {
                    // Enkel diesel Euro6 (M1, M2, N1 en N2) voertuigen hebben mrt nodig voor hun eind datum te berekenen
                    if (parameterService.equals(Enums.Parameters.Voertuig.BrandstofType, Enums.BrandstofType.Diesel) &&
                        parameterService.equals(Enums.Parameters.Voertuig.Categorie, [Enums.VoertuigCategorien.Personenwagen, Enums.VoertuigCategorien.Busje, Enums.VoertuigCategorien.Bestelwagen, Enums.VoertuigCategorien.LichteVrachtwagen]))
                        return true;
                }

                return false;
            };
            var berekenEuronormVoorwaarden = function () {
                return parameterHelperService.bereken(Enums.Parameters.DirkParameters.EuronormVoorwaarden);
            };
            var onResult = function (result) {
                if (result === 1) {
                    // Corrigeren is mogelijk
                    parameterService.set(Enums.Parameters.LusParameters.EuronormGecorrigeerd, 0);
                    parameterService.set(Enums.Parameters.LusParameters.EuronormAndere, 0);
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerd);
                    resolve(_schermen[33]);
                } else
                    resolve(_schermen[41]);
            };
            var onError = function (reason) {
                resolve(_schermen[41]);
            };


            var onVerrijkteEuronorm = function (verrijkteEuronorm) {
                if (isMrtNodig(verrijkteEuronorm)) {
                    resolve(_schermen[15]);
                    return;
                }

                switch (verrijkteEuronorm) {
                    case Enums.Euronorm.Euro6dTemp:
                    case Enums.Euronorm.Euro6:
                    case Enums.Euronorm.Euro6d:
                    case Enums.Euronorm.Euro5:
                    case Enums.Euronorm.Euro4:
                    case Enums.Euronorm.Euro3:
                    case Enums.Euronorm.Euro2:
                    case Enums.Euronorm.Euro1:
                    case Enums.Euronorm.Euro0:
                    case Enums.Euronorm.EuroIV:
                    case Enums.Euronorm.EuroIIIb:
                    case Enums.Euronorm.EuroIIIa:
                    case Enums.Euronorm.EuroII:
                    case Enums.Euronorm.EuroI:
                        // De verrijkte euronorm is reeds gekend
                        berekenEuronormVoorwaarden().then(onResult, onError);
                        return;
                }

                // Datum Eerste inschrijving is noodzakelijk om verder te kunnen gaan met verrijken
                var date = parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                if (!angular.isDate(date)) {
                    resolve(_schermen[10]);
                    return;
                }

                parameterHelperService.bereken(Enums.Parameters.Voertuig.EuronormVerrijkt)
                    .then(onVerrijkteEuronorm, onError);
            };

            // Euronorm controleren
            var euronorm = parameterService.get(Enums.Parameters.Voertuig.Euronorm, false, true);
            // Diesel Euro 6 (M1, M2, N1, N2) heeft een speciale eind datum afh van MRT
            if (isMrtNodig(euronorm)) {
                resolve(_schermen[15]);
                return;
            }

            switch (euronorm) {
                case Enums.Euronorm.Euro6d:
                case Enums.Euronorm.Euro6dTemp:
                case Enums.Euronorm.Euro6:
                case Enums.Euronorm.EuroIV:
                case Enums.Euronorm.EuroIIIb:
                    // Hoge euronormen moeten niet verrijkt of gecorrigeerd worden
                    resolve(_schermen[41]);
                    return;
                case Enums.Euronorm.NietVermeld:
                    // NietVermeld dus verder gaan met verrijking op voorwaarde dat voertuigcategorie niet T is.
                    var voertuigCategorie = parameterService.get(Enums.Parameters.Voertuig.Categorie);
                    if (voertuigCategorie === 'T') {
                        berekenEuronormVoorwaarden().then(onResult, onError);
                    }
                    break;
                default:
                    // Indien EN <> NietVermeld, is er geen verrijking nodig
                    berekenEuronormVoorwaarden().then(onResult, onError);
                    return;
            }

            // Verrijkte Euronorm (van VDI) controleren
            var verrijkteEuronorm = parameterService.get(Enums.Parameters.Voertuig.EuronormVerrijkt, false, true);
            onVerrijkteEuronorm(verrijkteEuronorm);
        }

        /// Deze functie bekijkt of de Gecorrigeerde Euronorm de hoogste is en zal afhankelijk controleren of dit volstaat voor het indienen van de correctie
        function _controleerGecorrigeerdeEuronormResultaat(keuzeParameter) {
            var hoogste = parameterHelperService.getHoogsteENParameter();
            if (hoogste === Enums.Parameters.Voertuig.EuronormGecorrigeerd) {
                switch (parameterService.get(Enums.Parameters.Voertuig.Categorie)) {
                    case Enums.VoertuigCategorien.Landbouwvoertuig:
                        var gecorrigeerdeEuronormLandbouw = parameterService.get(Enums.Parameters.Voertuig.EuronormGecorrigeerdLandbouw);
                        if (parameterHelperService.ENCompare(gecorrigeerdeEuronormLandbouw, Enums.Euronorm.EuroIIIa) > 0)
                            parameterService.set(keuzeParameter, 2);
                        else if (parameterHelperService.ENCompare(gecorrigeerdeEuronormLandbouw, Enums.Euronorm.EuroIIIa) === 0)
                            parameterService.set(keuzeParameter, 1);
                        return;
                    case Enums.VoertuigCategorien.Personenwagen:
                    case Enums.VoertuigCategorien.Busje:
                    case Enums.VoertuigCategorien.Bus:
                    case Enums.VoertuigCategorien.Bestelwagen:
                    case Enums.VoertuigCategorien.LichteVrachtwagen:
                    case Enums.VoertuigCategorien.ZwareVrachtwagen:
                        var gecorrigeerdeEuronorm = parameterService.get(Enums.Parameters.Voertuig.EuronormGecorrigeerd);
                        if (parameterService.equals(Enums.Parameters.Voertuig.BrandstofType, Enums.BrandstofType.Benzine) && parameterHelperService.ENCompare(gecorrigeerdeEuronorm, Enums.Euronorm.Euro2) >= 0)
                            parameterService.set(keuzeParameter, 2);
                        else if (parameterService.equals(Enums.Parameters.Voertuig.BrandstofType, Enums.BrandstofType.Benzine) && parameterHelperService.ENCompare(gecorrigeerdeEuronorm, Enums.Euronorm.Euro1) === 0)
                            parameterService.set(keuzeParameter, 1);
                        else if (parameterService.equals(Enums.Parameters.Voertuig.BrandstofType, Enums.BrandstofType.Diesel) && parameterHelperService.ENCompare(gecorrigeerdeEuronorm, Enums.Euronorm.Euro5) >= 0)
                            parameterService.set(keuzeParameter, 2);
                        else if (parameterService.equals(Enums.Parameters.Voertuig.BrandstofType, Enums.BrandstofType.Diesel) && parameterHelperService.ENCompare(gecorrigeerdeEuronorm, Enums.Euronorm.Euro4) === 0)
                            parameterService.set(keuzeParameter, 1);
                        else
                            parameterService.set(keuzeParameter, 0);
                        return;
                }
            }

            parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerd);
            parameterService.set(keuzeParameter, 0);
        }

        /// Gratis: Geen tarief of een tarief van 0,00€.
        function _isGratis() {
            return angular.isUndefined(parameterService.get(Enums.Parameters.Tarief)) || parameterService.equals(Enums.Parameters.Betaling.Bedrag, '0,00€');
        }

        /// Deze functie bewaart enkel de parameters die nodig zijn voor een Dagpas aan te kopen. Het geeft de oude parameters terug.
        function _zetDagpasParameters() {
            var params = parameterService.getParametersObject();
            parameterService.clearAll();
            angular.forEach([
                Enums.Parameters.Voertuig.Nummerplaat,
                Enums.Parameters.Voertuig.Landcode,
                Enums.Parameters.Kiosk.Naam,
                Enums.Parameters.Kiosk.SessieId], function (param) {
                if (angular.isDefined(params[param]))
                    parameterService.set(param, params[param]);
            });
            var kanaal = parameterService.get(Enums.Parameters.Kanaal);
            if (angular.isUndefined(kanaal) || kanaal === Enums.Kanaal.Checktool || kanaal === Enums.Kanaal.EloketAprofiel) parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.EloketEmail);
            else if (kanaal === Enums.Kanaal.InformatieKioskChecktool) parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk);
            parameterService.set(Enums.Parameters.Keuzes.Lus, '11');
            parameterService.set(Enums.Parameters.AanvraagType, Enums.AanvraagType.Dagpas);
            parameterService.set(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingDagpas);
            return params;
        }

        /// Deze functie bereid alles voor, voor de verlenging. Het geeft de oude parameters terug.
        function _startVerlenging() {
            var params = parameterService.getParametersObject();

            // Bereken of bijlagen nodig zijn
            parameterHelperService.bereken(Enums.Parameters.VerlengbaarheidBijlagen);
            bijlagenService.init();

            // Wissen van tarief/datums
            _schermen[55].wisParameters();
            // Wissen van aanvraagnummer
            parameterService.clear(Enums.Parameters.AanvraagNummer);

            //Wissen van chassisnummer
            parameterService.clear(Enums.Parameters.Voertuig.ChassisNummer);

            // Zetten van verlening gegevens
            parameterService.set(Enums.Parameters.BasisAanvraagNummer, params[Enums.Parameters.AanvraagNummer]);    

            parameterService.set(Enums.Parameters.IsExtension, true);
            parameterService.set(Enums.Parameters.ApplicationEndDate, params[Enums.Parameters.EindDatum]);

            var newStartDate;
            if (!angular.isDate(params[Enums.Parameters.EindDatum])) {
                newStartDate = Date.Today();
            } else if (params[Enums.Parameters.EindDatum].isBefore(Date.Today())) {
                newStartDate = Date.Today();
            } else {
                newStartDate = params[Enums.Parameters.EindDatum].add(1, 'd').startOf('day');
            }

            parameterService.set(Enums.Parameters.BeginDatum, newStartDate);

            // Return original params for when we undo
            return params;
        }

        // Deze functie bereid alles voor, voor het kopieren.
        function _startKopieren() {
            var params = parameterService.getParametersObject();
            parameterService.clearAll();

            function setValue(parameter, values) {
                parameterService.set(parameter, values[parameter], true);
            }

            function setValues(object, values) {
                for (var p in object) {
                    if (object.hasOwnProperty(p)) {
                        setValue(object[p], values);
                    }
                }
            }

            function prefillValue(parameter, values) {
                parameterService.prefill(parameter, values[parameter]);
            }

            function prefillValues(object, values) {
                for (var p in object) {
                    if (object.hasOwnProperty(p)) {
                        prefillValue(object[p], values);
                    }
                }
            }

            // User gegevens
            setValue(Enums.Parameters.Kanaal, params);
            setValue(Enums.Parameters.Aanvrager.Email, params);
            setValues(Enums.Parameters.Gebruiker.Identificatie, params);
            setValues(Enums.Parameters.Gebruiker.Token, params);
            setValue(Enums.Parameters.Medewerker.Naam, params);
            setValue(Enums.Parameters.Medewerker.Token, params);
            setValue(Enums.Parameters.Medewerker.Identificatie, params);
            setValue(Enums.Parameters.Medewerker.KassaToepassing, params);
            // Persoonsgegevens
            prefillValues(Enums.Parameters.Aanvrager, params);
            // Bedrijfsgegevens
            prefillValues(Enums.Parameters.Bedrijf, params);
            prefillValue(Enums.Parameters.IsBedrijfsVoertuig, params);
            // Financiële gegevens
            prefillValue(Enums.Parameters.Betaling.TitularisRekening, params);
            prefillValue(Enums.Parameters.Betaling.Iban, params);
            prefillValue(Enums.Parameters.Betaling.Bic, params);

            return params;
        }

        /// Deze functie returnt een functie die het zetten van de parameters ongedaan maakt.
        function _undoZetParameters(huidigScherm, params, standaardWis) {
            return function () {
                parameterService.clearAll();
                angular.forEach(params, function (item, key) {
                    parameterService.set(key, item);
                });
                standaardWis();
                huidigScherm.wisParameters = standaardWis;
            };
        }

        // Deze functie berekend de aanvraag soort en type op basis van de keuze van de gebruiker.
        function _berekenAanvraagSoort(keuze) {
            var soort, type;

            if (angular.isNumber(keuze)) {
                keuze = '' + keuze;
            }

            switch (keuze) {
                case '1':
                case '15':
                    if (parameterService.equals(Enums.Parameters.IsBelgischVoertuig, 'J') || parameterService.equals(Enums.Parameters.IsNederlandsVoertuig, 'J')) {
                        soort = Enums.AanvraagSoort.RegistratieTechnischeKenmerkenBE;
                    } else {
                        soort = Enums.AanvraagSoort.RegistratieTechnischeKenmerken;
                    }
                    type = Enums.AanvraagType.Registratie;
                    break;
                case '2':
                case '16':
                    if (parameterService.equals(Enums.Parameters.LusParameters.EuronormGecorrigeerd, 1) || parameterService.equals(Enums.Parameters.LusParameters.EuronormGecorrigeerd, 2))
                        soort = Enums.AanvraagSoort.RegistratieCorrectieEuronormCertificaat;
                    else if (parameterService.equals(Enums.Parameters.LusParameters.EuronormAndere, 1) || parameterService.equals(Enums.Parameters.LusParameters.EuronormAndere, 2))
                        soort = Enums.AanvraagSoort.RegistratieCorrectieEuronorm;
                    type = Enums.AanvraagType.Registratie;
                    break;
                case '3':
                    if (parameterService.equals(Enums.Parameters.LusParameters.RoetfilterVlaanderen, true))
                        soort = Enums.AanvraagSoort.RegistratieRoetfilterPremie;
                    else if (parameterService.equals(Enums.Parameters.LusParameters.RoetfilterAnderen, true))
                        soort = Enums.AanvraagSoort.RegistratieRoetfilterDieselEuro3;
                    else if (parameterService.equals(Enums.Parameters.LusParameters.RoetfilterIngebouwd, true))
                        soort = Enums.AanvraagSoort.RegistratieIngebouwdeRoetfilter;
                    type = Enums.AanvraagType.Registratie;
                    break;
                case '4':
                case '17':
                    if (parameterService.equals(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig, true))
                        soort = Enums.AanvraagSoort.VrijstellingAangepastVoertuig;
                    else if (parameterService.equals(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming, true))
                        soort = Enums.AanvraagSoort.VrijstellingVerhoogdeTegemoetkoming;
                    else if (parameterService.equals(Enums.Parameters.LusParameters.GehandikapteRolstoellift, true))
                        soort = Enums.AanvraagSoort.VrijstellingRolstoellift;
                    type = Enums.AanvraagType.Vrijstelling;
                    break;
                case '5':
                    soort = Enums.AanvraagSoort.ToelatingInwoner;
                    type = Enums.AanvraagType.Toelating;
                    break;
                case '6':
                    soort = Enums.AanvraagSoort.ToelatingOldtimer;
                    type = Enums.AanvraagType.Toelating;
                    break;
                case '7':
                case '20':
                    soort = Enums.AanvraagSoort.ToelatingWerken;
                    type = Enums.AanvraagType.Toelating;
                    break;
                case '8':
                case '21':
                    soort = Enums.AanvraagSoort.ToelatingAmbulanteHandel;
                    type = Enums.AanvraagType.Toelating;
                    break;
                case '9':
                    soort = Enums.AanvraagSoort.ToelatingDieselEuro3;
                    type = Enums.AanvraagType.Toelating;
                    break;
                case '10':
                case '23':
                    soort = Enums.AanvraagSoort.ToelatingNoodsituatie;
                    type = Enums.AanvraagType.Toelating;
                    break;
                case '11':
                case '24':
                    soort = Enums.AanvraagSoort.ToelatingDagpas;
                    type = Enums.AanvraagType.Dagpas;
                    break;
                case '12':
                    soort = Enums.AanvraagSoort.VrijstellingPrioritairVoertuig;
                    type = Enums.AanvraagType.Vrijstelling;
                    break;
                case '13':
                    soort = Enums.AanvraagSoort.VrijstellingUitzonderlijkVervoer;
                    type = Enums.AanvraagType.Vrijstelling;
                    break;
                case '14':
                    soort = Enums.AanvraagSoort.RegistratieAnderType;
                    type = Enums.AanvraagType.Registratie;
                    break;
                case '18':
                    soort = Enums.AanvraagSoort.ToelatingInwonerDE4;
                    type = Enums.AanvraagType.Toelating;
                    break;
                case '22':
                    soort = Enums.AanvraagSoort.ToelatingDieselEuro4;
                    type = Enums.AanvraagType.Toelating;
                    break;
            }

            parameterService.set(Enums.Parameters.AanvraagType, type);
            parameterService.set(Enums.Parameters.AanvraagSoort, soort);
        }

        // Deze functie navigeert naar het bijlagen scherm 78, tenzij het om een infokiosk gaat, of als het scherm overgeslagen mag worden omdat er geen nodig zijn
        function _openBijlageScherm(resolve, reject) {
            if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk)) {
                infokioskService.startScan()
                    .then(function (status) {
                        // Na het scannen wordt de aanvraag voor het eerst bewaard.
                        if (status === Enums.InfokioskStatus.Klaar)
                            _bewaar().then(function () {
                                resolve(_schermen[83]);
                            }, function () {
                                reject(undefined);
                            });
                        else
                            reject(undefined);
                    }, function () {
                        reject(undefined);
                    });
                return;
            }

            if (parameterService.equals(Enums.Parameters.VerlengbaarheidBijlagen, true)) {
                // Indien bijlagen reeds OK zijn, skip scherm 78 en ga verder.
                _schermen[78].volgende().then(function (result) {
                    resolve(result);
                }, function (reason) {
                    reject(reason);
                });
                return;
            }

            // Overgaan naar bijlage scherm indien <> InfoKiosk
            parameterHelperService.bereken(Enums.Parameters.Bijlagen.Voorwaarden).then(function (result) {
                if (!result.some(function (val) {
                    return val >= 3;
                })) {
                    // LEZ-1072 - Skip bijlagen scherm indien geen bijlagen verplicht zijn
                    _schermen[78].volgende().then(function (result) {
                        resolve(result);
                    }, function (reason) {
                        reject(reason);
                    });
                    return;
                }

                resolve(_schermen[78]);
            }, function (reason) {
                reject(reason);
            });
        }

        // Deze functie gaat over tot het betaalkeuze scherm, tenzij het om een infokiosk gaat
        function _openBetaalScherm(resolve, reject) {
            var isInfoKiosk = parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk);

            // Gratis aanvragen skippen naar scherm 60
            if (_isGratis()) {
                // Bewaar de aanvraag
                _bewaar(true).then(function (result) {
                    resolve(_schermen[60]);
                }, function () {
                    return reject(undefined);
                });
                return;
            }

            // Dagpas betaalmethode forceren
            if (parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingDagpas)) {
                if (isInfoKiosk)
                    parameterService.set(Enums.Parameters.Betaling.Methode, Enums.BetaalMethode.InfoKioskTerminal);
                else
                    parameterService.set(Enums.Parameters.Betaling.Methode, Enums.BetaalMethode.Online);
            }

            var betaalMethode = parameterService.get(Enums.Parameters.Betaling.Methode, false);
            // Undo changes from LEZ-1890 (https://jira.antwerpen.be/browse/LEZ-1890)
            if (angular.isNullOrWhitespace(betaalMethode)) {
                resolve(_schermen[56]); // Overgaan naar betaalkeuze
                return;
            }

            var onBewaard = function () {
                switch (parameterService.get(Enums.Parameters.Betaling.Methode, false)) {
                    case Enums.BetaalMethode.Online:
                        // Ogone
                        paymentService.getOgone(parameterService.get(Enums.Parameters.AanvraagNummer))
                            .then(function (result) {
                                $window.location = result.ogoneUrl;
                            }, function (error) {
                                _schermen[56].wisParameters();
                                lezErrorService.error('ERR_SRV_05', error.ErrorCodes);
                                reject(undefined);
                                $state.transitionTo('ogone', {
                                    ANR: parameterService.get(Enums.Parameters.AanvraagNummer),
                                    OSTAT: 'error'
                                });
                            });
                        return;
                    case Enums.BetaalMethode.InfoKioskTerminal:
                        // Infokiosk terminal
                        infokioskService.startPayment()
                            .then(infokioskService.processPayment)
                            .then(function (result) { // Betaling afronden
                                if (!angular.isDefined(result.status)) throw {ErrorCodes: []};
                                parameterService.set(Enums.Parameters.Betaling.Status, result.status);
                                if (result.status === 'ACC')
                                    lezErrorService.success('SUC_PAY_01', undefined, [parameterService.get(Enums.Parameters.AanvraagNummer)]);
                            })
                            .catch(function (error) {
                                lezErrorService.error('ERR_PAY_01', error.ErrorCodes);
                            })
                            .finally(function () {
                                // LEZ-1000 - Auto print ticket on IK met email == null
                                var isSuccesvolDagpas = parameterService.equals(Enums.Parameters.AanvraagType, Enums.AanvraagType.Dagpas) && parameterService.equals(Enums.Parameters.Betaling.Status, 'ACC');
                                var email = parameterService.get(Enums.Parameters.Aanvrager.Email);
                                if (isSuccesvolDagpas && angular.isNullOrWhitespace(email))
                                    _printTicket().finally(function () {
                                        resolve(_schermen[58]);
                                    }); // Force print on Dagpas Accepted
                                else
                                    resolve(_schermen[58]);
                            });
                        return;
                    default:
                        // Overschrijving of andere betaal methoden
                        _printTicket().then(function () {
                            resolve(_schermen[57]);
                        }, function () {
                            reject(undefined);
                        });
                        return;
                }
            };

            if (parameterService.equals(Enums.Parameters.Kiosk.Betaal, 'J')) {
                _bewaar(Enums.BewaarActies.RetryPay).then(onBewaard, function () {
                    return reject(undefined);
                });
            } else if (parameterService.isDirty()) {
                // Aanvraag indienen voor overgaan tot betaling
                _bewaar(true).then(onBewaard, function () {
                    return reject(undefined);
                });
            } else {
                onBewaard();
            }
        }

        // Deze functie start het printen, tenzij het niet om een infokiosk gaat
        function _printTicket() {
            if (!parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk)) {
                return $q(function (resolve, reject) {
                    resolve();
                });
            }

            return infokioskService.startPrint()
                .then(function (status) {
                    switch (status) {
                        case Enums.InfokioskStatus.Initieel:
                        case Enums.InfokioskStatus.Klaar:
                            return status;
                        case Enums.InfokioskStatus.Geannuleerd:
                            throw undefined; // Not a real error, but prevent continue-ing
                        case Enums.InfokioskStatus.Fout:
                        default:
                            lezErrorService.error('ERR_IK_32');
                            throw undefined;
                    }
                });
        }

        /*** EINDE HELPER FUNCTIES ***/

        // Screen initialization
        function laadSchermen() {
            var _toSelectedValues = function (valueArray) {
                var selectedValues = {};
                angular.forEach(valueArray, function (item) {
                    selectedValues[item.key] = item.value;
                });
                return selectedValues;
            };
            var _emptyFunction = function () {
            };

            _schermen[1] = {
                // Login Scherm
                schermNr: 1,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Kanaal, value: Enums.Kanaal.EloketAprofiel}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Kanaal)) {
                            case Enums.Kanaal.Checktool:
                                resolve(_schermen[2]);
                                break;
                            case Enums.Kanaal.EloketAprofiel:
                                authenticatieService.login()
                                    .then(function (result) {
                                        // LEZ-967 - Resetten na login enkel indien NPL niet gekend
                                        var needsReset = angular.isNullOrWhitespace(parameterService.get(Enums.Parameters.Voertuig.Nummerplaat));
                                        if (needsReset) resolve(_schermen[2]);
                                        else {
                                            const redirectTo = parameterService.get(Enums.Parameters.Redirect);
                                            resolve((typeof redirectTo != "undefined") ? _schermen[redirectTo] : _schermen[41]);
                                        }
                                    }, function (error) {
                                        _schermen[1].wisParameters();
                                        lezErrorService.error('ERR_AUTH_01A', error.ErrorCodes);
                                        reject(undefined);
                                    });
                                break;
                            case Enums.Kanaal.EloketEmail:
                                resolve(_schermen[91]);
                                break;
                            default:
                                reject("Deze keuze is momenteel niet toegankelijk.");
                        }
                    });
                },
                wisParameters: function () {
                    switch (parameterService.get(Enums.Parameters.Kanaal)) {
                        case Enums.Kanaal.EloketAprofiel:
                            authenticatieService.signout(true);
                            break;
                        case Enums.Kanaal.EloketEmail:
                            // Already signed out
                            break;
                    }
                    parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.Checktool);
                }
            };
            _schermen[2] = {
                schermNr: 2,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        resolve(_schermen[36]);
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[6] = {
                schermNr: 6,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Voertuig.Categorie, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        // De parameter VC wordt gezet op dit scherm, afh van de waarde navigeer je naar een ander scherm.
                        switch (parameterService.get(Enums.Parameters.Voertuig.Categorie)) {
                            case Enums.VoertuigCategorien.Landbouwvoertuig:
                                resolve(_schermen[9]);
                                return;
                            case Enums.VoertuigCategorien.Andere:
                                resolve(_schermen[41]);
                                return;
                            case Enums.VoertuigCategorien.NietVermeld:
                                resolve(_schermen[28]);
                                return;
                            default:
                                resolve(_schermen[7]);
                                return;
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.Categorie);
                }
            };
            _schermen[7] = {
                schermNr: 7,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.BrandstofTypeUitgebreid,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Voertuig.BrandstofTypeUitgebreid)) {
                            case Enums.BrandstofType.Elektrisch:
                            case Enums.BrandstofType.Waterstof:
                                parameterService.set(Enums.Parameters.Voertuig.BrandstofType, Enums.BrandstofType.Elektrisch);
                                parameterService.clear(Enums.Parameters.Voertuig.Euronorm);
                                break;
                            case Enums.BrandstofType.HybrideBenzine:
                            case Enums.BrandstofType.HybrideLiquid:
                            case Enums.BrandstofType.HybrideDiesel:
                                parameterService.clear(Enums.Parameters.Voertuig.BrandstofType);
                                parameterService.clear(Enums.Parameters.Voertuig.Euronorm);
                                break;
                            case Enums.BrandstofType.Benzine:
                            case Enums.BrandstofType.LPG:
                            case Enums.BrandstofType.CNG:
                            case Enums.BrandstofType.BE:
                                parameterService.set(Enums.Parameters.Voertuig.BrandstofType, Enums.BrandstofType.Benzine);
                                break;
                            case Enums.BrandstofType.Diesel:
                                parameterService.set(Enums.Parameters.Voertuig.BrandstofType, Enums.BrandstofType.Diesel);
                                break;
                        }

                        switch (parameterService.get(Enums.Parameters.Voertuig.BrandstofType)) {
                            case Enums.BrandstofType.Elektrisch:
                                resolve(_schermen[41]);
                                return;
                            case Enums.BrandstofType.Diesel:
                            case Enums.BrandstofType.Benzine:
                                resolve(_schermen[8]);
                                return;
                            default:
                                resolve(_schermen[38]);
                                return;
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.BrandstofTypeUitgebreid);
                    parameterService.clear(Enums.Parameters.Voertuig.BrandstofType);
                }
            };
            _schermen[8] = {
                // Keuze Euronorm
                schermNr: 8,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Voertuig.Euronorm, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenVerrijkteEuronorm(resolve, reject);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.Euronorm);

                    // Opkuisen Verrijking
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormVerrijkt);
                    parameterService.clear(Enums.Parameters.DirkParameters.EuronormVoorwaarden);
                }
            };
            _schermen[9] = {
                schermNr: 9,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Voertuig.Euronorm, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        let selectedEuroNorm = parameterService.get(Enums.Parameters.Voertuig.Euronorm);

                        switch (selectedEuroNorm) {
                            case 'NV':
                            case 'I':
                            case 'II':
                            case 'IIIa':
                            case 'IIIb':
                            case 'IV':
                                resolve(_schermen[99]);
                                break;
                            default:
                                resolve(_schermen[41]);
                                break;
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.Euronorm);
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormVerrijkt);
                    parameterService.clear(Enums.Parameters.DirkParameters.EuronormVoorwaarden);
                }
            };
            _schermen[10] = {
                schermNr: 10,
                stapNr: 2,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.DatumEersteInschrijving,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenVerrijkteEuronorm(resolve, reject);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.DatumEersteInschrijving);

                    // Undo berekening Verrijkte Euronorm
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormVerrijkt);
                    parameterService.clear(Enums.Parameters.DirkParameters.EuronormVoorwaarden);
                }
            };
            _schermen[12] = {
                schermNr: 12,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.IsGehandikapt, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.IsGehandikapt)) {
                            case 'J':
                            case 'JT':
                            case 'JB':
                                resolve(_schermen[32]);
                                return;
                            case 'N':
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig, false);
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming, false);

                                if (parameterService.equals(Enums.Parameters.HeeftRolstoellift, 'J')) {
                                    parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, true);


                                } else {
                                    parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, false);
                                }

                                resolve(_schermen[51]);
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.IsGehandikapt);
                }
            };
            _schermen[13] = {
                schermNr: 13,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.HeeftVerhoogdeTegemoetkoming,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.HeeftVerhoogdeTegemoetkoming)) {
                            case 'J':
                                resolve(_schermen[12]);
                                return;
                            case 'N':
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming, false);

                                if (parameterService.equals(Enums.Parameters.HeeftRolstoellift, 'J')) {
                                    parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, true);

                                } else {
                                    parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, false);
                                }

                                resolve(_schermen[51]);
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.HeeftVerhoogdeTegemoetkoming);
                }
            };
            _schermen[14] = {
                schermNr: 14,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Keuzes.AangepastVoertuig, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var keuze = parameterService.get(Enums.Parameters.Keuzes.AangepastVoertuig);
                        switch (keuze) {
                            case '1':
                                parameterService.set(Enums.Parameters.IsAangepastVoertuig, 'J');
                                parameterService.set(Enums.Parameters.HeeftRolstoellift, 'J');
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, true);
                                resolve(_schermen[51]);
                                break;
                            case '2':
                                parameterService.set(Enums.Parameters.IsAangepastVoertuig, 'J');
                                parameterService.set(Enums.Parameters.HeeftRolstoellift, 'N');

                                resolve(_schermen[12]);
                                break;
                            case '3':
                                parameterService.set(Enums.Parameters.IsAangepastVoertuig, 'N');
                                parameterService.set(Enums.Parameters.HeeftRolstoellift, 'N');
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig, false);

                                if (parameterService.equals(Enums.Parameters.IsBelgischVoertuig, 'J'))
                                    resolve(_schermen[13]);
                                else
                                    resolve(_schermen[51]);
                                break;
                            default:
                                reject("Er werd geen volgend scherm gevonden.");
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Keuzes.AangepastVoertuig);
                    parameterService.clear(Enums.Parameters.IsAangepastVoertuig);
                    parameterService.clear(Enums.Parameters.HeeftRolstoellift);

                    parameterService.clear(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig);
                    parameterService.clear(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming);
                    parameterService.clear(Enums.Parameters.LusParameters.GehandikapteRolstoellift);
                }
            };
            _schermen[15] = {
                schermNr: 15,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.MassaRijklareToestand,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        // LEZ-1016 - MRT op 0 zetten indien niet gekend
                        var mrt = parameterService.get(Enums.Parameters.Voertuig.MassaRijklareToestand);
                        if (angular.isNullOrWhitespace(mrt))
                            parameterService.set(Enums.Parameters.Voertuig.MassaRijklareToestand, '0');
                        _berekenVerrijkteEuronorm(resolve, reject);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.MassaRijklareToestand);
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormVerrijkt);
                    parameterService.clear(Enums.Parameters.DirkParameters.EuronormVoorwaarden);
                }
            };
            _schermen[16] = {
                schermNr: 16,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Voertuig.Roetfilter, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Voertuig.Roetfilter)) {
                            case Enums.RoetfilterType.Ingebouwd:
                                parameterService.set(Enums.Parameters.Voertuig.RoetfilterPremieVlaanderen, 'N');
                                resolve(_schermen[76]);
                                return;
                            case Enums.RoetfilterType.Neen:
                                resolve(_schermen[46]);
                                return;
                            case Enums.RoetfilterType.AchterafGeinstalleerd:
                                if (parameterService.equals(Enums.Parameters.IsBelgischVoertuig, 'J')) {
                                    parameterService.clear(Enums.Parameters.Voertuig.RoetfilterPremieVlaanderen);
                                    resolve(_schermen[26]);
                                } else {
                                    parameterService.set(Enums.Parameters.LusParameters.RoetfilterAnderen, true);
                                    parameterService.set(Enums.Parameters.Voertuig.RoetfilterPremieVlaanderen, 'N');
                                    resolve(_schermen[46]);
                                }
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.LusParameters.RoetfilterVlaanderen);
                    parameterService.clear(Enums.Parameters.LusParameters.RoetfilterAnderen);
                    parameterService.clear(Enums.Parameters.LusParameters.RoetfilterIngebouwd);
                    parameterService.clear(Enums.Parameters.Voertuig.Roetfilter);
                    parameterService.clear(Enums.Parameters.Voertuig.RoetfilterPremieVlaanderen);
                }
            };
            _schermen[17] = {
                schermNr: 17,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.IsInwonerLEZ, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.IsInwonerLEZ)) {
                            case 'J':
                                resolve(_schermen[27]);
                                return;
                            case 'N':
                                parameterService.set(Enums.Parameters.LusParameters.Bewoner, false);
                                resolve(_schermen[52]);
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.IsInwonerLEZ);

                    parameterService.clear(Enums.Parameters.LusParameters.Bewoner);
                }
            };
            _schermen[18] = {
                schermNr: 18,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        if (parameterService.equals(Enums.Parameters.Voertuig.Euronorm, Enums.Euronorm.Euro3) ||
                            parameterService.equals(Enums.Parameters.Voertuig.EuronormVerrijkt, Enums.Euronorm.Euro3) ||
                            parameterService.equals(Enums.Parameters.Voertuig.EuronormGecorrigeerd, Enums.Euronorm.Euro3))
                            resolve(_schermen[16]);
                        else
                            resolve(_schermen[12]);
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[26] = {
                schermNr: 26,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.RoetfilterPremieVlaanderen,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Voertuig.RoetfilterPremieVlaanderen)) {
                            case 'J':
                                parameterService.set(Enums.Parameters.LusParameters.RoetfilterAnderen, false);
                                parameterService.set(Enums.Parameters.LusParameters.RoetfilterVlaanderen, true);
                                break;
                            case 'N':
                                parameterService.set(Enums.Parameters.LusParameters.RoetfilterAnderen, true);
                                parameterService.set(Enums.Parameters.LusParameters.RoetfilterVlaanderen, false);
                                break;
                        }

                        resolve(_schermen[46]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.RoetfilterPremieVlaanderen);
                }
            };
            _schermen[27] = {
                schermNr: 27,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.IsInwonerLEZMetVerhoogdeTegemoetkoming,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.IsInwonerLEZMetVerhoogdeTegemoetkoming)) {
                            case 'J':
                                parameterService.set(Enums.Parameters.LusParameters.Bewoner, true);
                                resolve(_schermen[52]);
                                return;
                            case 'N':
                                parameterService.set(Enums.Parameters.LusParameters.Bewoner, false);
                                resolve(_schermen[52]);
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.IsInwonerLEZMetVerhoogdeTegemoetkoming);
                }
            };
            _schermen[28] = {
                schermNr: 28,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Voertuig.Aardcode, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Voertuig.Aardcode)) {
                            case 'TL':
                            case 'TT':
                                parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.Landbouwvoertuig);
                                resolve(_schermen[9]);
                                return;
                            case 'AA':
                            case 'AB':
                            case 'AC':
                            case 'AD':
                            case 'AE':
                            case 'AF':
                            case 'CL':
                            case 'SD':
                            case 'SC':
                            case 'AZ':
                            case 'SW':
                            case 'VP':
                            case 'LS':
                            case 'OM':
                                parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.Personenwagen);
                                resolve(_schermen[7]);
                                return;
                            case 'CT':
                            case 'FA':
                            case 'LT':
                                parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.Bestelwagen);
                                resolve(_schermen[7]);
                                return;
                            case 'SA':
                            case 'VC':
                            case 'LV':
                            case 'TB':
                            case 'BP':
                            case 'SB':
                                resolve(_schermen[29]);
                                return;
                            case 'BC':
                            case 'CV':
                            case 'DT':
                            case 'LC':
                            case 'TR':
                            case 'KM':
                            case 'KG':
                            case 'SF':
                                resolve(_schermen[30]);
                                return;
                            case 'ZZ':
                            case 'TP':
                            case 'LA':
                            case 'MT':
                            case '99':
                                resolve(_schermen[41]);
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    if (parameterService.equals(Enums.Parameters.Voertuig.Aardcode, ['AA', 'AB', 'AC', 'AD', 'AE', 'AF', 'CL', 'SD', 'SC', 'AZ', 'SW', 'VP', 'LS', 'OM', 'CT', 'FA', 'LT', 'TL', 'TT']))
                        parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.NietVermeld);

                    parameterService.clear(Enums.Parameters.Voertuig.Aardcode);
                }
            };
            _schermen[29] = {
                schermNr: 29,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.BijkomendeZitplaatsen,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var zitplaatsen = parameterService.get(Enums.Parameters.Voertuig.BijkomendeZitplaatsen);
                        switch (parameterService.get(Enums.Parameters.Voertuig.Aardcode)) {
                            case 'SA':
                            case 'VC':
                            case 'LV':
                            case 'TB':
                                if (zitplaatsen <= 9) {
                                    parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.Personenwagen);
                                    resolve(_schermen[7]);
                                } else
                                    resolve(_schermen[30]);
                                return;
                            case 'BP':
                            case 'SB':
                                if (zitplaatsen <= 7)
                                    resolve(_schermen[30]);
                                else if (zitplaatsen <= 9) {
                                    parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.Personenwagen);
                                    resolve(_schermen[7]);
                                } else
                                    resolve(_schermen[61]);
                                return;

                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    if (parameterService.equals(Enums.Parameters.Voertuig.Aardcode, ['OM', 'SA', 'VC', 'BP', 'SB']))
                        parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.NietVermeld);

                    parameterService.clear(Enums.Parameters.Voertuig.BijkomendeZitplaatsen);
                }
            };
            _schermen[30] = {
                schermNr: 30,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.MaximaalToegelatenMassa,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var mtm = parameterService.get(Enums.Parameters.Voertuig.MaximaalToegelatenMassa);
                        var categorie = undefined;
                        switch (parameterService.get(Enums.Parameters.Voertuig.Aardcode)) {
                            case 'SA':
                            case 'VC':
                            case 'LV':
                            case 'TB':
                            case 'BC':
                                if (mtm <= 5000) categorie = Enums.VoertuigCategorien.Busje;
                                else categorie = Enums.VoertuigCategorien.Bus;
                                break;
                            case 'DT':
                            case 'LC':
                            case 'TR':
                            case 'CV':
                            case 'KM':
                            case 'SF':
                            case 'KG':
                                if (mtm <= 3500) categorie = Enums.VoertuigCategorien.Bestelwagen;
                                else if (mtm <= 12000) categorie = Enums.VoertuigCategorien.LichteVrachtwagen;
                                else categorie = Enums.VoertuigCategorien.ZwareVrachtwagen;
                                break;
                            case 'BP':
                            case 'SB':
                                resolve(_schermen[31]);
                                return;
                        }

                        if (categorie !== undefined) {
                            parameterService.set(Enums.Parameters.Voertuig.Categorie, categorie);
                            if (categorie === Enums.VoertuigCategorien.ZwareVrachtwagen && parameterService.equals(Enums.Parameters.Voertuig.Aardcode, ['SF', 'KG']))
                                resolve(_schermen[41]);
                            else
                                resolve(_schermen[7]);

                            return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    if (!parameterService.equals(Enums.Parameters.Voertuig.Aardcode, ['BP', 'SB'])) parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.NietVermeld);
                    parameterService.clear(Enums.Parameters.Voertuig.MaximaalToegelatenMassa);
                }
            };
            _schermen[31] = {
                schermNr: 31,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.MassaRijklareToestand,
                    value: undefined
                },
                    {key: Enums.Parameters.Voertuig.MassaRijklareToestandVerplicht, value: true}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var maxMassa = parameterService.get(Enums.Parameters.Voertuig.MaximaalToegelatenMassa);
                        var massa = parameterService.get(Enums.Parameters.Voertuig.MassaRijklareToestand);
                        var zitplaatsen = parameterService.get(Enums.Parameters.Voertuig.BijkomendeZitplaatsen) - 1;

                        if (maxMassa - (massa + (zitplaatsen * 68)) > (zitplaatsen * 68))
                            parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.Bestelwagen);
                        else
                            parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.Personenwagen);

                        resolve(_schermen[7]);
                    });
                },
                wisParameters: function () {
                    parameterService.set(Enums.Parameters.Voertuig.Categorie, Enums.VoertuigCategorien.NietVermeld);
                    parameterService.clear(Enums.Parameters.Voertuig.MassaRijklareToestand);
                }
            };
            _schermen[32] = {
                schermNr: 32,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.IsGehandikapt, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.IsGehandikapt)) {
                            case 'JT':
                            case 'JB':
                                resolve(_schermen[49]);
                                return;
                            case 'N':
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig, false);
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming, false);

                                if (parameterService.equals(Enums.Parameters.HeeftRolstoellift, 'J')) {
                                    parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, true);

                                } else {
                                    parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, false);
                                }

                                resolve(_schermen[51]);
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.set(Enums.Parameters.IsGehandikapt, 'J');
                }
            };
            _schermen[33] = {
                schermNr: 33,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Keuzes.EuronormCorrigeren,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        parameterService.clear(Enums.Parameters.Voertuig.Gelijkvormigheidscode);
                        parameterService.clear(Enums.Parameters.Voertuig.GelijkvormigheidscodeLandbouw);
                        parameterService.clear(Enums.Parameters.Voertuig.GelijkvormigheidscodeAndere);
                        parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerd);
                        parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerdLandbouw);
                        parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerdAndere);

                        var keuze = parameterService.get(Enums.Parameters.Keuzes.EuronormCorrigeren);
                        if (angular.isNumber(keuze)) {
                            keuze = '' + keuze;
                            parameterService.set(Enums.Parameters.Keuzes.EuronormCorrigeren, keuze);
                        }

                        switch (keuze) {
                            case '1':
                                switch (parameterService.get(Enums.Parameters.Voertuig.Categorie)) {
                                    case Enums.VoertuigCategorien.Landbouwvoertuig:
                                        resolve(_schermen[35]);
                                        return;
                                    case Enums.VoertuigCategorien.Personenwagen:
                                    case Enums.VoertuigCategorien.Busje:
                                    case Enums.VoertuigCategorien.Bus:
                                    case Enums.VoertuigCategorien.Bestelwagen:
                                    case Enums.VoertuigCategorien.LichteVrachtwagen:
                                    case Enums.VoertuigCategorien.ZwareVrachtwagen:
                                    default:
                                        resolve(_schermen[34]);
                                        return;
                                }
                            case '2':
                                switch (parameterService.get(Enums.Parameters.Voertuig.Categorie)) {
                                    case Enums.VoertuigCategorien.Landbouwvoertuig:
                                        resolve(_schermen[43]);
                                        return;
                                    case Enums.VoertuigCategorien.Personenwagen:
                                    case Enums.VoertuigCategorien.Busje:
                                    case Enums.VoertuigCategorien.Bus:
                                    case Enums.VoertuigCategorien.Bestelwagen:
                                    case Enums.VoertuigCategorien.LichteVrachtwagen:
                                    case Enums.VoertuigCategorien.ZwareVrachtwagen:
                                    default:
                                        resolve(_schermen[42]);
                                        return;
                                }
                            case '3':
                                resolve(_schermen[41]);
                                return;
                        }
                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Keuzes.EuronormCorrigeren);
                }
            };
            _schermen[34] = {
                schermNr: 34,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.GelijkvormigheidscodeAndere,
                    value: undefined
                }]),
                volgende: function () {
                    parameterService.set(Enums.Parameters.Voertuig.Gelijkvormigheidscode, parameterService.get(Enums.Parameters.Voertuig.GelijkvormigheidscodeAndere));
                    return parameterHelperService.bereken(Enums.Parameters.Voertuig.EuronormGecorrigeerd)
                        .then(function (result) {
                                _controleerGecorrigeerdeEuronormResultaat(Enums.Parameters.LusParameters.EuronormGecorrigeerd);
                                return _schermen[45];
                            },
                            function () {
                                throw "De gecorrigeerde Euronorm kon niet worden berekend.";
                            });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.Gelijkvormigheidscode);
                    parameterService.clear(Enums.Parameters.Voertuig.GelijkvormigheidscodeAndere);
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerd);

                    parameterService.clear(Enums.Parameters.LusParameters.EuronormGecorrigeerd);
                }
            };
            _schermen[35] = {
                schermNr: 35,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.GelijkvormigheidscodeLandbouw,
                    value: undefined
                }]),
                volgende: function () {
                    parameterService.set(Enums.Parameters.Voertuig.Gelijkvormigheidscode, parameterService.get(Enums.Parameters.Voertuig.GelijkvormigheidscodeLandbouw));
                    return parameterHelperService.bereken(Enums.Parameters.Voertuig.EuronormGecorrigeerd)
                        .then(function (result) {
                                _controleerGecorrigeerdeEuronormResultaat(Enums.Parameters.LusParameters.EuronormGecorrigeerd);
                                return _schermen[45];
                            },
                            function () {
                                throw "Gecorrigeerde Euronorm kon niet worden berekend.";
                            });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.Gelijkvormigheidscode);
                    parameterService.clear(Enums.Parameters.Voertuig.GelijkvormigheidscodeLandbouw);
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerd);

                    parameterService.clear(Enums.Parameters.LusParameters.EuronormGecorrigeerd);
                }
            };
            _schermen[36] = {
                schermNr: 36,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Voertuig.Nummerplaat, value: undefined},
                    {key: Enums.Parameters.Voertuig.DatumEersteInschrijving, value: undefined},
                    {key: Enums.Parameters.Voertuig.Landcode, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        codeService.getByTechnischeSleutel(Enums.Parameters.Kanteldatum1).then(function (result) {
                            var kd1 = result.customField;
                            parameterService.set(Enums.Parameters.Kanteldatum1, kd1);
                            _kanteldatum1 = moment(kd1, 'DD/MM/YYYY').toDate()
                        });

                        codeService.getByTechnischeSleutel(Enums.Parameters.Kanteldatum2).then(function (result) {
                            var kd2 = result.customField;
                            parameterService.set(Enums.Parameters.Kanteldatum2, kd2);
                            _kanteldatum2 = moment(kd2, 'DD/MM/YYYY').toDate()
                        });

                        var nummerplaat = parameterService.get(Enums.Parameters.Voertuig.Nummerplaat);
                        if (angular.isNullOrWhitespace(nummerplaat)) parameterService.clear(Enums.Parameters.Voertuig.Nummerplaat);
                        else {
                            nummerplaat = nummerplaat.replace(/[\-\s]/g, ''); // Ignore - and whitespace
                            nummerplaat = nummerplaat.toUpperCase();
                            parameterService.set(Enums.Parameters.Voertuig.Nummerplaat, nummerplaat);
                        }

                        switch (parameterService.get(Enums.Parameters.Voertuig.Landcode)) {
                            case 'BE':
                                parameterService.set(Enums.Parameters.IsBelgischVoertuig, 'J');
                                break;
                            default:
                                parameterService.set(Enums.Parameters.IsBelgischVoertuig, 'N');
                                break;
                        }

                        if (parameterService.equals(Enums.Parameters.AanvraagType, Enums.AanvraagType.Dagpas)) {
                            _schermen[36].wisParameters = _undoZetParameters(_schermen[36], _zetDagpasParameters(), _schermen[36].wisParameters);
                            resolve(_schermen[85]); //Dagpas scherm
                            return;
                        }

                        //10
                        switch (parameterService.get(Enums.Parameters.Kanaal)) {
                            case Enums.Kanaal.Checktool:
                            case Enums.Kanaal.InformatieKioskChecktool:
                                if (angular.isNullOrWhitespace(nummerplaat)) {
                                    resolve(_schermen[74]); // IsBedrijfsvoertuig?
                                    return;
                                }
                                break;
                            case Enums.Kanaal.BackOffice:
                                if (angular.isNullOrWhitespace(parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving))) {
                                    parameterService.clear(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                                    resolve(_schermen[41]); //Keuze aanvraag soort
                                    return;
                                }
                                break;
                            case Enums.Kanaal.EloketEmail:
                                var user = authenticatieService.userIsAnoniem();
                                if (angular.isObject(user)) {
                                    user.Datum = parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving); //eerste inschrijvingsdatum als extra controle bij de user die inlogt met 2x e-mail
                                    authenticatieService.setUser(user, false);
                                }
                                break;
                        }

                        blockUI.start('whitelist');
                        whitelistService.checkWhiteList().then(function (data) {
                            // LEZ-1142 - Sugestie startdatum adhv einddatum whitelist
                            var whitelistLijst = parameterService.get(Enums.Parameters.Hotlist.Lijst);
                            if (angular.isArray(whitelistLijst) && whitelistLijst.length > 0) {
                                var edat = whitelistLijst[whitelistLijst.length - 1][Enums.Parameters.Hotlist.EindDatum];
                                if (angular.isDate(edat) && Date.Now().add(4, 'months').isAfter(edat)) {
                                    var date = moment(edat).startOf('day').add(1, 'd'); // 1 dag na laatste dag van de whitelist
                                    _schermen[54].selectedValues[Enums.Parameters.BeginDatum] = date;
                                    _schermen[55].selectedValues[Enums.Parameters.BeginDatum] = date;
                                }
                            }

                            var euronorm = parameterService.get(Enums.Parameters.Voertuig.Euronorm);
                            if (parameterService.equals(Enums.Parameters.VDIVoertuig.Categorie, 'T')) {
                                switch (euronorm) { 
                                    case Enums.Euronorm.EuroIV:
                                    case Enums.Euronorm.EuroIIIb:
                                    case Enums.Euronorm.EuroIIIa:
                                    case Enums.Euronorm.EuroII:
                                    case Enums.Euronorm.EuroI:
                                    case Enums.Euronorm.NietVermeld:
                                        return resolve(_schermen[99]);
                                    default:
                                }
                            }

                            // LEZ-1385 & // LEZ-1564
                            if (
                                parameterService.equals(Enums.Parameters.IsBelgischVoertuig, 'N') &&
                                !parameterService.get(Enums.Parameters.VDIVoertuig.Bestaat) &&
                                (
                                    data[Enums.Parameters.Hotlist.WhitelistedVlaanderen] !== 'NG' &&
                                    parameterService.get(Enums.Parameters.Voertuig.Landcode) !== 'NL'
                                ) &&
                                (
                                    data[Enums.Parameters.Hotlist.Whitelisted] === 'N' &&
                                    data[Enums.Parameters.Hotlist.WhitelistedVlaanderen] === 'NT'
                                )
                            ) {
                                return resolve(_schermen[74]);
                            }

                            //VDIWL-parameter wordt geset voor elke bron, niet enkel voor VDI
                            if (data[Enums.Parameters.Hotlist.Whitelisted] === 'N' && data[Enums.Parameters.Hotlist.WhitelistedVlaanderen] === 'NC') {
                                return resolve(_schermen[90]);
                            } else {
                                return resolve(_schermen[39]); //Resultaat nummerplaatcheck
                            }

                        }, function (error) {
                            _schermen[36].wisParameters();
                            lezErrorService.error('ERR_SRV_01', error.ErrorCodes);
                            reject(undefined);
                        }).finally(function () {
                            blockUI.stop();
                        });
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.Nummerplaat);
                    parameterService.clear(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                    parameterService.clear(Enums.Parameters.Voertuig.Landcode);
                    parameterService.clear(Enums.Parameters.IsBelgischVoertuig);

                    angular.forEach(Enums.Parameters.Hotlist, function (param) {
                        parameterService.clear(param);
                    });
                    angular.forEach(Enums.Parameters.VDIVoertuig, function (param) {
                        parameterService.clear(param);
                    });

                    parameterService.prefill(Enums.Parameters.Voertuig.Euronorm, undefined);
                }
            };
            _schermen[38] = {
                schermNr: 38,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Voertuig.CO2Waarde, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        // store current value
                        _schermen[38].extra = _toSelectedValues([{
                            key: Enums.Parameters.Voertuig.BrandstofType,
                            value: parameterService.get(Enums.Parameters.Voertuig.BrandstofType)
                        }]);

                        var brandstoftype;
                        if (parameterService.get(Enums.Parameters.Voertuig.CO2Waarde) < 50)
                            brandstoftype = Enums.BrandstofType.Elektrisch;
                        else if (parameterService.equals(Enums.Parameters.Voertuig.BrandstofTypeUitgebreid, Enums.BrandstofType.HybrideDiesel))
                            brandstoftype = Enums.BrandstofType.Diesel;
                        else
                            brandstoftype = Enums.BrandstofType.Benzine;

                        parameterService.set(Enums.Parameters.Voertuig.BrandstofType, brandstoftype);

                        switch (brandstoftype) {
                            case Enums.BrandstofType.Elektrisch:
                                resolve(_schermen[41]);
                                return;
                            case Enums.BrandstofType.Diesel:
                            case Enums.BrandstofType.Benzine:
                                resolve(_schermen[8]);
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.CO2Waarde);
                    // restore value
                    angular.forEach(_schermen[38].extra, function (value, param) {
                        parameterService.set(param, value);
                    });
                }
            };
            _schermen[39] = {
                schermNr: 39,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        if (parameterService.equals(Enums.Parameters.DirkParameters.VWD39, [7, 14]))
                            return _exit();
                        resolve(_schermen[74]);
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[40] = {
                schermNr: 40,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _exit();
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[41] = {
                schermNr: 41,
                selectedValues: _toSelectedValues([{ key: Enums.Parameters.Keuzes.Lus, value: undefined }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var keuze = parameterService.get(Enums.Parameters.Keuzes.Lus);
                        if (parameterService.get(Enums.Parameters.VolledigheidLus + '[' + keuze + ']') < 1) {
                            // Deze optie is niet zichtbaar en zou niet geselecteerd mogen zijn!
                            reject("Er werd geen volgend scherm gevonden.");
                            return;
                        }

                        if (angular.isNumber(keuze)) {
                            keuze = '' + keuze;
                            parameterService.set(Enums.Parameters.Keuzes.Lus, keuze);
                        }

                        switch (keuze) {
                            case '3': // Roetfilter Lus
                                parameterService.clear(Enums.Parameters.LusParameters.RoetfilterVlaanderen);
                                parameterService.clear(Enums.Parameters.LusParameters.RoetfilterAnderen);
                                parameterService.clear(Enums.Parameters.LusParameters.RoetfilterIngebouwd);
                                resolve(_schermen[16]);
                                break;
                            case '4': // Gehandicapten
                            case '17': // Gehandicapten 2020
                                parameterService.clear(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig);
                                parameterService.clear(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming);
                                parameterService.clear(Enums.Parameters.LusParameters.GehandikapteRolstoellift);
                                resolve(_schermen[14]);
                                break;
                            case '5': // Bewoners LEZ
                            case '18': // Bewoners LEZ 2020
                                parameterService.clear(Enums.Parameters.LusParameters.Bewoner);
                                resolve(_schermen[17]);
                                break;
                            case '7': // Aannemers
                            case '20': // Aannemers 2020
                                parameterService.clear(Enums.Parameters.LusParameters.Aannemer);
                                resolve(_schermen[65]);
                                break;
                            case '8': //Marktkramers
                            case '21': //Marktkramers 2020
                                parameterService.clear(Enums.Parameters.LusParameters.Marktkramer);
                                resolve(_schermen[72]);
                                break;
                            case '10': // Noodsituatie
                            case '23': // Noodsituatie 2020
                                parameterService.clear(Enums.Parameters.LusParameters.Noodsituatie);
                                resolve(_schermen[69]);
                                break;
                            case '1': // Automatische Registratie
                            case '15': // Registratie Technische Kenmerken 2020
                                if (authenticatieService.userIsAuthenticated()) {
                                    resolve(_schermen[54]);
                                } else {
                                    parameterService.set(Enums.Parameters.Redirect, 54);
                                    resolve(_schermen[1]);
                                }
                                break;
                            case '2': // Correctie Lus
                            case '6': // Oldtimer
                            case '9': // Toelating Euro 3
                            case '11': // Dagkaart
                            case '12': // GAPA Prioritair Voertuig
                            case '13': // GAPA Uitzonderlijk Vervoer
                            case '14': // GAPA Andere Types
                            case '16': // Registratie Correctie Euronorm 2020
                            case '24': // Dagpas 2020
                                resolve(_schermen[41]); // Geen Lus
                                break;
                            default:
                                reject("Ongeldige keuze.");
                        }
                    });
                },
                wisParameters: function () {
                    // Aanvraag gegevens
                    parameterService.clear(Enums.Parameters.AanvraagNummer);
                    parameterService.clear(Enums.Parameters.AanvraagStatus);
                    parameterService.clear(Enums.Parameters.AanvraagDatum);
                    parameterService.clear(Enums.Parameters.AanvraagSoort);
                    parameterService.clear(Enums.Parameters.AanvraagType);
                    // Keuze parameter
                    parameterService.prefill(Enums.Parameters.Keuzes.Lus, parameterService.get(Enums.Parameters.Keuzes.Lus));
                    parameterService.clear(Enums.Parameters.Keuzes.Lus);

                    // Hulp berekeningen ??
                    parameterService.clear(Enums.Parameters.VolledigheidLus);
                    parameterService.clear(Enums.Parameters.VolledigheidAanvraag);
                    parameterService.clear(Enums.Parameters.DirkParameters.VWD41);
                    parameterService.clear(Enums.Parameters.DirkParameters.VWD41B);
                }
            };
            _schermen[42] = {
                schermNr: 42,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.EuronormGecorrigeerdAndere,
                    keys: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        parameterService.set(Enums.Parameters.Voertuig.EuronormGecorrigeerd, parameterService.get(Enums.Parameters.Voertuig.EuronormGecorrigeerdAndere));
                        _controleerGecorrigeerdeEuronormResultaat(Enums.Parameters.LusParameters.EuronormAndere);
                        resolve(_schermen[45]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerd);
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerdAndere);
                    parameterService.clear(Enums.Parameters.LusParameters.EuronormAndere);
                }
            };
            _schermen[43] = {
                schermNr: 43,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.EuronormGecorrigeerdLandbouw,
                    keys: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        parameterService.set(Enums.Parameters.Voertuig.EuronormGecorrigeerd, parameterService.get(Enums.Parameters.Voertuig.EuronormGecorrigeerdLandbouw));
                        _controleerGecorrigeerdeEuronormResultaat(Enums.Parameters.LusParameters.EuronormAndere);
                        resolve(_schermen[45]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerd);
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormGecorrigeerdLandbouw);
                    parameterService.clear(Enums.Parameters.LusParameters.EuronormAndere);
                }
            };
            _schermen[45] = {
                schermNr: 45,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        parameterService.set(Enums.Parameters.Redirect, 54);
                        resolve(_schermen[41]);
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[46] = {
                // Resultaat Roetfilter lus
                schermNr: 46,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenAanvraagSoort(parameterService.get(Enums.Parameters.SelectedRequestOption));

                        let loopResult = parameterService.get(Enums.Parameters.DirkParameters.VWD46);

                        switch (loopResult) {
                            case 1:
                            case 3:
                                parameterService.set(Enums.Parameters.IsLoopFinished, true);

                                if (authenticatieService.userIsAuthenticated()) {
                                    resolve(_schermen[54]);
                                } else {
                                    parameterService.set(Enums.Parameters.Redirect, 54);
                                    resolve(_schermen[1]);
                                }
                                break;
                            default:
                                parameterService.set(Enums.Parameters.IsLoopFinished, false);
                                resolve(_schermen[41]);
                                break;
                        }
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[48] = {
                schermNr: 48,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.HeeftRolstoellift, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.HeeftRolstoellift)) {
                            case 'J':
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, true);
                                resolve(_schermen[51]);
                                return;
                            case 'N':
                                parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, false);
                                resolve(_schermen[51]);
                                return;
                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.HeeftRolstoellift);
                }
            };
            _schermen[49] = {
                schermNr: 49,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Gehandikapte.Vervaldatum, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var today = new Date();
                        var date = parameterService.get(Enums.Parameters.Gehandikapte.Vervaldatum);

                        if (!angular.isDate(date)) {
                            parameterService.set(Enums.Parameters.Gehandikapte.Vervaldatum, Constants.Datums.getEindDatum_2099());
                        }

                        if (parameterService.get(Enums.Parameters.Gehandikapte.Vervaldatum).isBefore(moment())) {
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig, false);
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming, false);
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, parameterService.equals(Enums.Parameters.HeeftRolstoellift, 'J'));
                        } else if (parameterService.equals(Enums.Parameters.HeeftVerhoogdeTegemoetkoming, 'J')) {
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig, false);
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming, true);
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, false);
                        } else {
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig, true);
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming, false);
                            parameterService.set(Enums.Parameters.LusParameters.GehandikapteRolstoellift, false);
                        }

                        resolve(_schermen[51]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Gehandikapte.Vervaldatum);
                }
            };
            _schermen[50] = {
                schermNr: 50,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Gehandikapte.RijksregisterNummer,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var rrnr = parameterService.get(Enums.Parameters.Gehandikapte.RijksregisterNummer);
                        if (angular.isString(rrnr)) {
                            rrnr = rrnr.replace(/[\.\-\s]/g, '');
                            parameterService.set(Enums.Parameters.Gehandikapte.RijksregisterNummer, rrnr);
                        }
                        resolve(_schermen[78]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Gehandikapte.RijksregisterNummer);
                }
            };
            _schermen[51] = {
                // Resultaat gehandikapte lus
                schermNr: 51,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenAanvraagSoort(parameterService.get(Enums.Parameters.SelectedRequestOption));

                        let loopResult = parameterService.get(Enums.Parameters.DirkParameters.VWD51);

                        switch (loopResult) {
                            case 1:
                            case 3:
                            case 5:
                            case 6:
                                parameterService.set(Enums.Parameters.IsLoopFinished, true);

                                if (authenticatieService.userIsAuthenticated()) {
                                    resolve(_schermen[54]);
                                } else {
                                    parameterService.set(Enums.Parameters.Redirect, 54);
                                    resolve(_schermen[1]);
                                }
                                break;
                            default:
                                parameterService.set(Enums.Parameters.IsLoopFinished, false);
                                resolve(_schermen[41]);
                                break;
                        }
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[52] = {
                // Resultaat Inwoner LEZ lus
                schermNr: 52,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenAanvraagSoort(parameterService.get(Enums.Parameters.SelectedRequestOption));

                        let loopResult = parameterService.get(Enums.Parameters.LusParameters.Bewoner);

                        if (loopResult) {
                            parameterService.set(Enums.Parameters.IsLoopFinished, true);

                            if (authenticatieService.userIsAuthenticated()) {
                                resolve(_schermen[55]);
                            } else {
                                parameterService.set(Enums.Parameters.Redirect, 55);
                                resolve(_schermen[1]);
                            }
                        } else {
                            parameterService.set(Enums.Parameters.IsLoopFinished, false);
                            resolve(_schermen[41]);
                        }
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[54] = {
                schermNr: 54,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.BeginDatum, value: Date.Yesterday()},
                    {key: Enums.Parameters.EindDatum, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        parameterService.clear(Enums.Parameters.Tarief);
                        parameterService.clear(Enums.Parameters.Termijn);
                        parameterService.clear(Enums.Parameters.Betaling.Bedrag);
                        parameterService.clear(Enums.Parameters.Betaling.KassaCode);
                        resolve(_schermen[62]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.BeginDatum);
                    parameterService.clear(Enums.Parameters.EindDatum);
                    parameterService.clear(Enums.Parameters.Redirect);
                }
            };
            _schermen[55] = {
                schermNr: 55,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.BeginDatum, value: Date.Today()},
                    {key: Enums.Parameters.EindDatum, value: undefined},
                    {key: Enums.Parameters.Tarief, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var selectedOption = parameterService.get(Enums.Parameters.SelectedRequestOption);
                        var isSelectedLoopFinished = parameterService.get(Enums.Parameters.IsLoopFinished);

                        if (isSelectedLoopFinished) {
                            resolve(_schermen[62]);
                        }

                        switch (selectedOption) {
                            case '3':
                                resolve(_schermen[16]);
                                break;
                            case '4':
                            case '17':
                                resolve(_schermen[14]);
                                break;
                            case '5':
                            case '18':
                                resolve(_schermen[17]);
                                break;
                            case '7':
                            case '20':
                                resolve(_schermen[65]);
                                break;
                            case '8':
                            case '21':
                                resolve(_schermen[72]);
                                break;
                            case '10':
                            case '23':
                                resolve(_schermen[69]);
                                break;
                            default:
                                resolve(_schermen[62]);
                                break;
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.BeginDatum);
                    parameterService.clear(Enums.Parameters.EindDatum);
                    parameterService.clear(Enums.Parameters.Tarief);
                    parameterService.clear(Enums.Parameters.Termijn);
                    parameterService.clear(Enums.Parameters.Betaling.Bedrag);
                    parameterService.clear(Enums.Parameters.Betaling.KassaCode);
                    parameterService.clear(Enums.Parameters.Redirect);
                }
            };
            _schermen[56] = {
                schermNr: 56,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Betaling.Methode, values: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _openBetaalScherm(resolve, reject);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Betaling.Methode);
                }
            };
            _schermen[57] = {
                schermNr: 57,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _exit();
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[58] = {
                schermNr: 58,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Betaling.Status)) {
                            case 'ACC':

                                if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk)) {
                                    // LEZ-1156 - Ticket is reeds geprint bij dagpas of email=null
                                    var isDagpas = parameterService.equals(Enums.Parameters.AanvraagType, Enums.AanvraagType.Dagpas);
                                    var email = parameterService.get(Enums.Parameters.Aanvrager.Email);
                                    if (isDagpas || angular.isNullOrWhitespace(email))
                                        _exit();
                                    else
                                        resolve(_schermen[96]);
                                } else
                                    _exit();
                                break;
                            default:
                                resolve(_schermen[97]);
                        }
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[59] = {
                schermNr: 59,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Disclaimer, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        // Disclaimer niet aangevinkt
                        if (!parameterService.equals(Enums.Parameters.Disclaimer, '1')) {
                            lezErrorService.error('ERR_NAV_01');
                            reject(undefined);
                            return;
                        }

                        _openBetaalScherm(resolve, reject);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Disclaimer);
                }
            };
            _schermen[60] = {
                schermNr: 60,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk))
                            resolve(_schermen[96]);
                        else
                            _exit();
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[61] = {
                schermNr: 61,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _exit();
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[62] = {
                schermNr: 62,
                selectedValues: _toSelectedValues([
                    { key: Enums.Parameters.Aanvrager.RijksregisterNummer, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Naam, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Voornaam, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Straat, value: undefined },
                    { key: Enums.Parameters.Aanvrager.HuisNummer, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Bus, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Postcode, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Gemeente, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Land, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Email, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Telefoon, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Heeft2eEmail, value: undefined },
                    { key: Enums.Parameters.Aanvrager.Email2, value: undefined },
                ]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var rrnr = parameterService.get(Enums.Parameters.Aanvrager.RijksregisterNummer);
                        if (angular.isString(rrnr)) {
                            rrnr = rrnr.replace(/[\.\-\s]/g, '');
                            parameterService.set(Enums.Parameters.Aanvrager.RijksregisterNummer, rrnr);
                        }
                        var email = parameterService.get(Enums.Parameters.Aanvrager.Email);
                        if (angular.isString(email)) {
                            email = email.toLowerCase();
                            parameterService.set(Enums.Parameters.Aanvrager.Email, email);
                        }

                        if (parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.Dagpas)) {
                            _bewaar().then(function () {
                                resolve(_schermen[83]);
                            }, function () {
                                return reject(undefined);
                            }); // Overzicht aanvraag
                        } else if (parameterService.equals(Enums.Parameters.AanvraagType, Enums.AanvraagType.Toelating)) {
                            if (parameterService.equals(Enums.Parameters.IsBedrijfsVoertuig, 'J')) {
                                //LEZ-1060 - Prefill Facturatie gegevens
                                parameterService.prefill(Enums.Parameters.Bedrijf.Straat, parameterService.get(Enums.Parameters.Aanvrager.Straat));
                                parameterService.prefill(Enums.Parameters.Bedrijf.HuisNummer, parameterService.get(Enums.Parameters.Aanvrager.HuisNummer));
                                parameterService.prefill(Enums.Parameters.Bedrijf.Bus, parameterService.get(Enums.Parameters.Aanvrager.Bus));
                                parameterService.prefill(Enums.Parameters.Bedrijf.Postcode, parameterService.get(Enums.Parameters.Aanvrager.Postcode));
                                parameterService.prefill(Enums.Parameters.Bedrijf.Gemeente, parameterService.get(Enums.Parameters.Aanvrager.Gemeente));
                                parameterService.prefill(Enums.Parameters.Bedrijf.Land, parameterService.get(Enums.Parameters.Aanvrager.Land));

                                resolve(_schermen[77]); // Facturatie gegevens
                            } else
                                resolve(_schermen[63]); // (Terug) Betalings gegevens
                        } else if (
                            (
                                parameterService.equals(Enums.Parameters.Keuzes.Lus, 4) ||
                                parameterService.equals(Enums.Parameters.Keuzes.Lus, 17)
                            ) &&
                            parameterService.equals(Enums.Parameters.IsBelgischVoertuig, 'J') &&
                            (
                                parameterService.equals(Enums.Parameters.IsGehandikapt, 'JT') ||
                                parameterService.equals(Enums.Parameters.IsGehandikapt, 'JB')
                            ) &&
                            (
                                parameterService.equals(Enums.Parameters.LusParameters.GehandikapteAangepastVoertuig, true) ||
                                parameterService.equals(Enums.Parameters.LusParameters.GehandikapteVerhoogdeTegemoetkoming, true)
                            )
                        ) {
                            resolve(_schermen[50]);
                        } else {
                            _openBijlageScherm(resolve, reject);
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Aanvrager.RijksregisterNummer);
                    parameterService.clear(Enums.Parameters.Aanvrager.Naam);
                    parameterService.clear(Enums.Parameters.Aanvrager.Voornaam);
                    parameterService.clear(Enums.Parameters.Aanvrager.Straat);
                    parameterService.clear(Enums.Parameters.Aanvrager.HuisNummer);
                    parameterService.clear(Enums.Parameters.Aanvrager.Bus);
                    parameterService.clear(Enums.Parameters.Aanvrager.Postcode);
                    parameterService.clear(Enums.Parameters.Aanvrager.Gemeente);
                    parameterService.clear(Enums.Parameters.Aanvrager.Land);
                    parameterService.clear(Enums.Parameters.Aanvrager.Email);
                    parameterService.clear(Enums.Parameters.Aanvrager.Telefoon);
                    parameterService.clear(Enums.Parameters.Aanvrager.Heeft2eEmail);
                    parameterService.clear(Enums.Parameters.Aanvrager.Email2);
                }
            };
            _schermen[63] = {
                schermNr: 63,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Betaling.TitularisRekening, value: undefined},
                    {key: Enums.Parameters.Betaling.Iban, value: undefined},
                    {key: Enums.Parameters.Betaling.Bic, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _openBijlageScherm(resolve, reject);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Betaling.TitularisRekening);
                    parameterService.clear(Enums.Parameters.Betaling.Iban);
                    parameterService.clear(Enums.Parameters.Betaling.Bic);
                }
            };
            _schermen[65] = {
                schermNr: 65,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Keuzes.AannemerType, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Keuzes.AannemerType)) {
                            case '1':
                                resolve(_schermen[66]);
                                break;
                            case '2':
                                parameterService.set(Enums.Parameters.LusParameters.Aannemer, true);
                                resolve(_schermen[68]);
                                break;
                            case '3':
                                parameterService.set(Enums.Parameters.LusParameters.Aannemer, false);
                                resolve(_schermen[68]);
                                break;
                            default:
                                reject("Ongeldige keuze.");

                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.LusParameters.Aannemer);
                    parameterService.clear(Enums.Parameters.Keuzes.AannemerType);

                    parameterService.clear(Enums.Parameters.Opdracht.Opdrachtgever);
                    parameterService.clear(Enums.Parameters.Opdracht.Begin);
                    parameterService.clear(Enums.Parameters.Opdracht.Einde);
                }
            };
            _schermen[66] = {
                schermNr: 66,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Opdracht.Opdrachtgever, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Keuzes.Lus)) {
                            case '7':
                            case '20': // Aannemer lus
                                resolve(_schermen[67]);
                                break;
                            case '10':
                            case '23': // Noodsituatie lus
                                parameterService.set(Enums.Parameters.LusParameters.Noodsituatie, true);
                                resolve(_schermen[71]);
                                break;
                            default:
                                reject("Ongeldige keuze.");
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Opdracht.Opdrachtgever);
                }
            };
            _schermen[67] = {
                schermNr: 67,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Opdracht.Begin, value: undefined},
                    {key: Enums.Parameters.Opdracht.Einde, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        parameterService.set(Enums.Parameters.LusParameters.Aannemer, true);
                        resolve(_schermen[68]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Opdracht.Begin);
                    parameterService.clear(Enums.Parameters.Opdracht.Einde);
                    parameterService.clear(Enums.Parameters.LusParameters.Aannemer);
                }
            };
            _schermen[68] = {
                // Resultaat aannemer lus
                schermNr: 68,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenAanvraagSoort(parameterService.get(Enums.Parameters.SelectedRequestOption));

                        let loopResult = parameterService.get(Enums.Parameters.DirkParameters.VWD68);

                        switch (loopResult) {
                            case 1:
                            case 2:
                                parameterService.set(Enums.Parameters.IsLoopFinished, true);

                                if (authenticatieService.userIsAuthenticated()) {
                                    resolve(_schermen[55]);
                                } else {
                                    parameterService.set(Enums.Parameters.Redirect, 55);
                                    resolve(_schermen[1]);
                                }
                                break;
                            default:
                                parameterService.set(Enums.Parameters.IsLoopFinished, false);

                                resolve(_schermen[41]);
                                break;
                        }
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[69] = {
                schermNr: 69,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Keuzes.Noodsituatie, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Keuzes.Noodsituatie)) {
                            case '1':
                                resolve(_schermen[66]);
                                break;
                            case '2':
                                parameterService.set(Enums.Parameters.LusParameters.Noodsituatie, false);
                                resolve(_schermen[71]);
                                break;
                            default:
                                reject("Ongeldige keuze.");
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Keuzes.Noodsituatie);
                    parameterService.clear(Enums.Parameters.LusParameters.Noodsituatie);

                    parameterService.clear(Enums.Parameters.Opdracht.OpdrachtgeverNoodsituatie);
                    parameterService.clear(Enums.Parameters.Opdracht.Begin);
                    parameterService.clear(Enums.Parameters.Opdracht.Einde);
                }
            };
            _schermen[70] = {
                schermNr: 70,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Medewerker.Motivatie, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        resolve(_schermen[54]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Medewerker.Motivatie);
                }
            };
            _schermen[71] = {
                // Resultaat noodsituatie lus
                schermNr: 71,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenAanvraagSoort(parameterService.get(Enums.Parameters.SelectedRequestOption));

                        let loopResult = parameterService.get(Enums.Parameters.LusParameters.Noodsituatie);

                        if (loopResult) {
                            parameterService.set(Enums.Parameters.IsLoopFinished, true);

                            if (authenticatieService.userIsAuthenticated()) {
                                resolve(_schermen[55]);
                            } else {
                                parameterService.set(Enums.Parameters.Redirect, 55);
                                resolve(_schermen[1]);
                            }
                        } else {
                            parameterService.set(Enums.Parameters.IsLoopFinished, false);
                            resolve(_schermen[41]);
                        }
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[72] = {
                schermNr: 72,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Keuzes.Marktkramer, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Keuzes.Marktkramer)) {
                            case '1':
                            case '2':
                            case '3':
                                parameterService.set(Enums.Parameters.LusParameters.Marktkramer, true);
                                resolve(_schermen[73]);
                                break;
                            case '4':
                                parameterService.set(Enums.Parameters.LusParameters.Marktkramer, false);
                                resolve(_schermen[73]);
                                break;
                            default:
                                reject('Ongeldige Keuze.');

                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Keuzes.Marktkramer);

                    parameterService.clear(Enums.Parameters.LusParameters.Marktkramer);
                }
            };
            _schermen[73] = {
                // Resultaat marktkramers lus
                schermNr: 73,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenAanvraagSoort(parameterService.get(Enums.Parameters.SelectedRequestOption));

                        let loopResult = parameterService.get(Enums.Parameters.LusParameters.Marktkramer);

                        if (loopResult) {
                            parameterService.set(Enums.Parameters.IsLoopFinished, true);

                            if (authenticatieService.userIsAuthenticated()) {
                                resolve(_schermen[55]);
                            } else {
                                parameterService.set(Enums.Parameters.Redirect, 55);
                                resolve(_schermen[1]);
                            }
                        } else {
                            parameterService.set(Enums.Parameters.IsLoopFinished, false);
                            resolve(_schermen[41]);
                        }
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[74] = {
                // Scherm met keuze of het een Privé of Bedrijfsvoertuig is.
                schermNr: 74,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.IsBedrijfsVoertuig, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var stopScherm = _schermen[6];

                        // START VEREENVOUDIGEN
                        if (!parameterService.get(Enums.Parameters.VDIVoertuig.Bestaat))
                            return resolve(stopScherm); // STOP VEREENVOUDIGEN: Het voertuig bestaat niet in de DB van VDI/RDW
                        if (!parameterService.equals(Enums.Parameters.Voertuig.Categorie, [Enums.VoertuigCategorien.Landbouwvoertuig, Enums.VoertuigCategorien.Andere, Enums.VoertuigCategorien.Personenwagen, Enums.VoertuigCategorien.Busje, Enums.VoertuigCategorien.Bus, Enums.VoertuigCategorien.Bestelwagen, Enums.VoertuigCategorien.LichteVrachtwagen, Enums.VoertuigCategorien.ZwareVrachtwagen]))
                            return resolve(stopScherm); // STOP VEREENVOUDIGEN: Ongeldige Voertuig Categorie

                        var euronorm = parameterService.get(Enums.Parameters.Voertuig.Euronorm);

                        if (euronorm === null || euronorm === undefined)
                            return resolve(stopScherm); // STOP VEREENVOUDIGEN: Ongeldige Euronorm

                        switch (euronorm) {
                            case Enums.Euronorm.Euro6:
                            case Enums.Euronorm.Euro5:
                            case Enums.Euronorm.EuroIV:
                            case Enums.Euronorm.EuroIIIb:
                                return resolve(_schermen[41]); // EINDE VEREENVOUDIGEN: Hoge Euronorm
                            case Enums.Euronorm.NietVermeld:
                                if (parameterService.equals(Enums.Parameters.VDIVoertuig.Categorie, 'T') && (parameterService.equals(Enums.Parameters.Hotlist.WhitelistedVlaanderen, 'NT') || parameterService.equals(Enums.Parameters.Hotlist.WhitelistedVlaanderen, 'NC'))) {
                                    return resolve(_schermen[9]);
                                }

                                var verrijkteEuronorm = parameterService.get(Enums.Parameters.Voertuig.EuronormVerrijkt);
                                if (angular.isUndefined(verrijkteEuronorm)) {
                                    return resolve(stopScherm); // STOP VEREENVOUDIGEN: Verrijking niet mogelijk
                                } else {
                                    return _berekenVerrijkteEuronorm(resolve, reject); // EINDE VEREENVOUDIGEN
                                }
                            default:
                                return _berekenVerrijkteEuronorm(resolve, reject); // EINDE VEREENVOUDIGEN
                        }

                        return resolve(stopScherm); // STOP VEREENVOUDIGEN: Ongekende reden
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.IsBedrijfsVoertuig);

                    // Berekend bij vereenvoudigen
                    parameterService.clear(Enums.Parameters.Voertuig.Euronorm);
                    parameterService.clear(Enums.Parameters.Voertuig.EuronormVerrijkt);
                    parameterService.clear(Enums.Parameters.DirkParameters.EuronormVoorwaarden);
                }
            };
            _schermen[76] = {
                schermNr: 76,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.PartikelMassaWaarde,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        if (parameterService.get(Enums.Parameters.Voertuig.PartikelMassaWaarde) < 0.005)
                            parameterService.set(Enums.Parameters.LusParameters.RoetfilterIngebouwd, true);
                        else
                            parameterService.set(Enums.Parameters.Voertuig.Roetfilter, Enums.RoetfilterType.Neen);

                        resolve(_schermen[46]);
                    });
                },
                wisParameters: function () {
                    parameterService.set(Enums.Parameters.Voertuig.Roetfilter, Enums.RoetfilterType.Ingebouwd);
                    parameterService.clear(Enums.Parameters.Voertuig.PartikelMassaWaarde);
                }
            };
            _schermen[77] = {
                schermNr: 77,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Bedrijf.BTWNummer, value: undefined},
                    {key: Enums.Parameters.Bedrijf.Naam, value: undefined},
                    {key: Enums.Parameters.Bedrijf.Straat, value: undefined},
                    {key: Enums.Parameters.Bedrijf.HuisNummer, value: undefined},
                    {key: Enums.Parameters.Bedrijf.Bus, value: undefined},
                    {key: Enums.Parameters.Bedrijf.Postcode, value: undefined},
                    {key: Enums.Parameters.Bedrijf.Gemeente, value: undefined},
                    {key: Enums.Parameters.Bedrijf.Land, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var btw = parameterService.get(Enums.Parameters.Bedrijf.BTWNummer);
                        if (angular.isString(btw))
                            parameterService.set(Enums.Parameters.Bedrijf.BTWNummer, btw.replace(/[\.-\s]/g, '').toUpperCase());
                        else
                            parameterService.clear(Enums.Parameters.Bedrijf.BTWNummer);
                        resolve(_schermen[63]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Bedrijf.BTWNummer);
                    parameterService.clear(Enums.Parameters.Bedrijf.Naam);
                    parameterService.clear(Enums.Parameters.Bedrijf.Straat);
                    parameterService.clear(Enums.Parameters.Bedrijf.HuisNummer);
                    parameterService.clear(Enums.Parameters.Bedrijf.Bus);
                    parameterService.clear(Enums.Parameters.Bedrijf.Postcode);
                    parameterService.clear(Enums.Parameters.Bedrijf.Gemeente);
                    parameterService.clear(Enums.Parameters.Bedrijf.Land);
                }
            };
            _schermen[78] = {
                schermNr: 78,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var validForCount = parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.EloketAprofiel, Enums.Kanaal.EloketEmail]) && angular.isUndefined(parameterService.get(Enums.Parameters.AanvraagNummer));
                        _bewaar().then(function () {
                            if (validForCount) tellerService.add('ELoket - Scherm 83 - No Manual Save');
                            resolve(_schermen[83]);
                        }, function () {
                            return reject(undefined);
                        });
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Bijlagen.Bijlagen);
                    parameterService.clear(Enums.Parameters.Bijlagen.Voorwaarden);
                }
            };
            _schermen[79] = {
                schermNr: 79,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Betaling.Methode, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Betaling.Methode)) {
                            case Enums.BetaalMethode.Bancontact:
                                resolve(_schermen[81]);
                                return;
                            case Enums.BetaalMethode.Overschrijving:
                                parameterService.set(Enums.Parameters.Disclaimer, '1');
                                _bewaar(true).then(function () {
                                    resolve(_schermen[57]);
                                }, function () {
                                    return reject(undefined);
                                });
                                return;

                        }

                        reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Betaling.Methode);
                    parameterService.clear(Enums.Parameters.Disclaimer);
                }
            };
            _schermen[80] = {
                schermNr: 80,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Betaling.Methode, value: undefined},
                    {key: Enums.Parameters.Disclaimer, value: '1'},
                    {key: Enums.Parameters.Keuzes.BetaalingBevestigd, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _bewaar(true).then(function () {
                            resolve(_schermen[60]);
                        }, function () {
                            return reject(undefined);
                        });
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Betaling.Methode);
                    parameterService.clear(Enums.Parameters.Disclaimer);
                    parameterService.clear(Enums.Parameters.Keuzes.BetaalingBevestigd);
                }
            };
            _schermen[81] = {
                schermNr: 81,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Disclaimer, value: '1'},
                    {key: Enums.Parameters.Keuzes.BetalingOk, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _bewaar(true).then(function () {
                            resolve(_schermen[60]);
                        }, function () {
                            return reject(undefined);
                        });
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Disclaimer);
                    parameterService.clear(Enums.Parameters.Keuzes.BetalingOk);
                }
            };
            _schermen[82] = {
                schermNr: 82,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Medewerker.Opmerking, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        resolve(_schermen[82]);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Medewerker.Opmerking);
                }
            };
            _schermen[83] = {
                schermNr: 83,
                volgende: function () {
                    return $q(function (resolve, reject) {
                        switch (parameterService.get(Enums.Parameters.Kanaal)) {
                            case Enums.Kanaal.EloketAprofiel:
                            case Enums.Kanaal.EloketEmail:
                            case Enums.Kanaal.InformatieKiosk:
                                resolve(_schermen[59]);
                                break;
                            case Enums.Kanaal.DLloket:
                                parameterService.set(Enums.Parameters.Disclaimer, '1');
                                if (_isGratis())
                                    _openBetaalScherm(resolve, reject);
                                else if (parameterService.equals(Enums.Parameters.Medewerker.KassaToepassing, "KAT")) {
                                    parameterService.set(Enums.Parameters.Betaling.Methode, Enums.BetaalMethode.Kat);
                                    _bewaar(true).then(function () {
                                        resolve(_schermen[60]);
                                    }, function () {
                                        return reject(undefined);
                                    });
                                } else
                                    resolve(_schermen[80]);
                                break;
                            case Enums.Kanaal.BackOffice:
                                parameterService.set(Enums.Parameters.Disclaimer, '1');
                                if (_isGratis())
                                    _openBetaalScherm(resolve, reject);
                                else
                                    resolve(_schermen[79]);
                                break;
                            case Enums.Kanaal.Chectool:
                            case Enums.Kanaal.InformatieKioskChecktool:
                            default:
                                reject("Foutief kanaal om de aanvraag te bewaren.");
                                break;
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Disclaimer);
                }
            };
            _schermen[84] = angular.copy(_schermen[83]);
            _schermen[84].schermNr = 84;
            _schermen[85] = {
                schermNr: 85,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.BeginDatum, value: Date.Today()},
                    {key: Enums.Parameters.EindDatum, value: undefined},
                    {key: Enums.Parameters.Tarief, value: undefined}]),
                volgende: function () {
                    return dagpasService.controle(parameterService.getParametersObject())
                        .then(function (resultaat) {
                                if (resultaat) {
                                    lezErrorService.error('ERR_DP_01');
                                    throw undefined;
                                }

                                switch (parameterService.get(Enums.Parameters.Kanaal)) {
                                    case Enums.Kanaal.BackOffice:
                                    case Enums.Kanaal.DLloket:
                                        return _schermen[62];
                                    case Enums.Kanaal.InformatieKiosk:
                                        return _bewaar().then(function () {
                                            return _schermen[83];
                                        }); // Overzicht aanvraag
                                    default:
                                        return _schermen[86];
                                }
                            },
                            function (error) {
                                lezErrorService.error('ERR_SRV_08', error.ErrorCodes);
                                throw undefined;
                            });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.BeginDatum);
                    parameterService.clear(Enums.Parameters.EindDatum);
                    parameterService.clear(Enums.Parameters.Tarief);
                    parameterService.clear(Enums.Parameters.Termijn);
                    parameterService.clear(Enums.Parameters.Betaling.Bedrag);
                    parameterService.clear(Enums.Parameters.Betaling.KassaCode);
                }
            };
            _schermen[86] = {
                schermNr: 86,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Aanvrager.Email, value: undefined},
                    {key: Enums.Parameters.Gebruiker.HerhalingEmail, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var email = parameterService.get(Enums.Parameters.Aanvrager.Email);
                        if (angular.isString(email)) {
                            email = email.toLowerCase();
                            parameterService.set(Enums.Parameters.Aanvrager.Email, email);
                        }

                        switch (parameterService.get(Enums.Parameters.Kanaal)) {
                            case Enums.Kanaal.EloketAprofiel:
                            case Enums.Kanaal.EloketEmail:
                                var user = authenticatieService.userIsAuthenticated();
                                user = user ? user : {};
                                if (user.ProfileType === Enums.Auth.ProfielTypes.AProfiel) user.old = {
                                    Email: user.Email,
                                    Taal: user.Taal,
                                    Token: user.Token
                                };
                                user.Email = parameterService.get(Enums.Parameters.Aanvrager.Email);
                                user.Datum = parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                                user.Taal = parameterService.get(Enums.Parameters.Taal);
                                user.Token = '86' + (Math.random() + '').substr(3);
                                user.ProfileType = Enums.Auth.ProfielTypes.Anoniem;
                                authenticatieService.setUser(user, false);
                                break;
                        }

                        _bewaar().then(function () {
                            resolve(_schermen[83]);
                        }, function () {
                            return reject(undefined);
                        });
                    });
                },
                wisParameters: function () {
                    var user = authenticatieService.userIsAuthenticated();
                    if (user && user.old) {
                        user.Email = user.old.Email;
                        user.Taal = user.old.Taal;
                        user.Token = user.old.Token;
                        user.ProfileType = Enums.Auth.ProfielTypes.AProfiel;
                        authenticatieService.setUser(user, false);
                    } else if (user) {
                        parameterService.set(Enums.Parameters.Aanvrager.Email, user.Email);
                    } else
                        parameterService.clear(Enums.Parameters.Aanvrager.Email);

                    parameterService.clear(Enums.Parameters.Gebruiker.HerhalingEmail);
                }
            };
            _schermen[87] = {
                schermNr: 87, //= URI /dagpas
                volgende: function () {
                    return $q(function (resolve, reject) {
                        resolve(_schermen[36]);
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[88] = {
                schermNr: 88, //onderhoudspagina
                volgende: function () {
                    return $q(function (resolve, reject) {
                        resolve(_schermen[_schermen[88].volgendScherm]);
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[89] = {
                schermNr: 89, //toepassing offline
                volgende: function () {
                    return $q(function (resolve, reject) {
                        resolve(_schermen[89]);
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[90] = {
                schermNr: 90, //VDI niet bereikbaar
                volgende: function () {
                    return $q(function (resolve, reject) {
                        resolve(_schermen[74]);
                    });
                },
                wisParameters: _emptyFunction
            };
            _schermen[91] = {
                schermNr: 91,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Aanvrager.Email, value: undefined},
                    {key: Enums.Parameters.Gebruiker.HerhalingEmail, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var email = parameterService.get(Enums.Parameters.Aanvrager.Email);
                        if (angular.isString(email)) {
                            email = email.toLowerCase();
                            parameterService.set(Enums.Parameters.Aanvrager.Email, email);
                        }

                        // LEZ-967 - Resetten na login enkel indien NPL niet gekend
                        var needsReset = angular.isNullOrWhitespace(parameterService.get(Enums.Parameters.Voertuig.Nummerplaat));

                        // LEZ-1526 - Vorige klikken na inloggen => verwijder login schermen van _history
                        _history.pop(); // Removes _schermen[91] from history
                        _history.pop(); // Removes _schermen[1] from history

                        var kanaal = parameterService.get(Enums.Parameters.Kanaal);
                        switch (kanaal) {
                            case Enums.Kanaal.InformatieKiosk:
                            case Enums.Kanaal.InformatieKioskChecktool:
                                parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk);
                                break;
                            default:
                                authenticatieService.setUser({
                                    Email: parameterService.get(Enums.Parameters.Aanvrager.Email),
                                    Datum: parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving),
                                    Taal: parameterService.get(Enums.Parameters.Taal),
                                    ProfileType: Enums.Auth.ProfielTypes.Anoniem,
                                    Token: '91' + (Math.random() + '').substr(3)
                                }, false);
                                break;
                        }

                        if (needsReset) resolve(_schermen[2]);
                        else {
                            const selectedOption = parameterService.get(Enums.Parameters.SelectedRequestOption);
                            var redirectTo = parameterService.get(Enums.Parameters.Redirect);

                            switch (selectedOption) {
                                case '24':
                                    redirectTo = 85;
                                    break;
                                default:
                                    redirectTo = (typeof redirectTo != "undefined") ? redirectTo : 55;
                                    break;
                            }

                            resolve(_schermen[redirectTo]);
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Aanvrager.Email);
                    parameterService.clear(Enums.Parameters.Gebruiker.HerhalingEmail);
                }
            };
            _schermen[92] = {
                schermNr: 92,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Aanvrager.Email, value: undefined},
                    {key: Enums.Parameters.Voertuig.DatumEersteInschrijving, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        var email = parameterService.get(Enums.Parameters.Aanvrager.Email);
                        if (angular.isString(email)) {
                            email = email.toLowerCase();
                            parameterService.set(Enums.Parameters.Aanvrager.Email, email);
                        }

                        authenticatieService.setUser({
                            Email: parameterService.get(Enums.Parameters.Aanvrager.Email),
                            Datum: parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving),
                            Taal: parameterService.get(Enums.Parameters.Taal),
                            ProfileType: Enums.Auth.ProfielTypes.Anoniem,
                            Token: '92' + (Math.random() + '').substr(3)
                        }, true);
                    });
                },
                wisParameters: function () {
                    parameterService.clear(Enums.Parameters.Aanvrager.Email);
                    parameterService.clear(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                }
            };
            _schermen[93] = {
                // Keuze actie voor Infokiosk
                schermNr: 93,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Keuzes.InfokioskKeuze, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {

                        switch (parameterService.get(Enums.Parameters.Keuzes.InfokioskKeuze)) {
                            case '1': // Info schermen
                                return resolve(_schermen[95]);
                            case '2': // Checktool
                                parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKioskChecktool);
                                return resolve(_schermen[2]);
                            case '3': // Infokiosk
                                parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk);
                                return resolve(_schermen[91]); // Login scherm
                            case '4': // Dagpas
                                _schermen[93].wisParameters = _undoZetParameters(_schermen[93], _zetDagpasParameters(), _schermen[93].wisParameters);
                                return resolve(_schermen[87]);
                        }
                    });
                },
                wisParameters: function () {
                    parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk);
                }
            };
            _schermen[94] = {
                // Keuze taal voor Infokiosk
                schermNr: 94,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        return resolve(_schermen[93]);
                    });
                },
                wisParameters: function () {
                }
            };
            _schermen[95] = {
                // Menu met overzicht van info paginas
                schermNr: 95,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        return reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                }
            };
            _schermen[96] = {
                // Afdrukken ticket via Ticketprinter
                schermNr: 96,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Kiosk.Print, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        if (parameterService.equals(Enums.Parameters.Kiosk.Print, 'J'))
                            _printTicket().then(function () {
                                _exit();
                            }, function () {
                                reject(undefined);
                            });
                        else
                            _exit();

                    });
                },
                wisParameters: function () {
                }
            };
            _schermen[97] = {
                // Opnieuw overgaan tot betalen
                schermNr: 97,
                selectedValues: _toSelectedValues([{key: Enums.Parameters.Kiosk.Betaal, value: undefined}]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        if (parameterService.equals(Enums.Parameters.Kiosk.Betaal, 'N')) {
                            _exit();
                            return;
                        }

                        var openBetaalScherm = function () {
                            parameterService.clear(Enums.Parameters.Betaling.Methode);
                            _openBetaalScherm(resolve, reject);
                        };

                        var tarief = parameterService.get(Enums.Parameters.Tarief);
                        var soort = parameterService.get(Enums.Parameters.AanvraagSoort);
                        if (angular.isUndefined(tarief) || angular.isUndefined(soort)) {
                            // Ophalen Basis Aanvraag gegevens
                            aanvraagService.getById(parameterService.get(Enums.Parameters.AanvraagNummer), {basic: true})
                                .then(function (aanvraag) {
                                    if (angular.isUndefined(aanvraag)) return;
                                    var params = Object.keys(aanvraag);
                                    for (var i = 0, len = params.length; i < len; ++i) {
                                        parameterService.set(params[i], aanvraag[params[i]]);
                                    }
                                })
                                .then(openBetaalScherm, function () {
                                    reject(undefined);
                                });
                        } else openBetaalScherm();
                    });
                },
                wisParameters: function () {
                }
            };
            /* LEZ-1291 - Korting voor boetes */
            _schermen[98] = {
                schermNr: 98,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.BoeteNummer,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        return resolve(_schermen[36]);
                    });
                },
                wisParameters: function () {
                }
            };
            /* LEZ-1462 - Landbouwvoertuigen */
            _schermen[99] = {
                schermNr: 99,
                selectedValues: _toSelectedValues([{
                    key: Enums.Parameters.Voertuig.Vermogen,
                    value: undefined
                }]),
                volgende: function () {
                    return $q(function (resolve, reject) {
                        _berekenVerrijkteEuronorm(resolve, reject);
                    });
                },
                wisParameters: function () {
                }
            };
            /* Template
            _schermen[] = {
                schermNr: ,
                selectedValues: {},
                volgende: function () {
                    return $q(function (resolve, reject) {
                        return reject("Er werd geen volgend scherm gevonden.");
                    });
                },
                wisParameters: function () {
                }
            };
            */
        }

        /* +++++ private methods +++++ */

        function _eersteScherm(isLogin) {
            if (parameterService.equals(Enums.Parameters.AanvraagType, Enums.AanvraagType.Dagpas)) {
                // Dagpassen starten op scherm 87
                return _schermen[87];
            } else if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.InformatieKiosk, Enums.Kanaal.InformatieKioskChecktool])) {
                // Infokiosk start op scherm 94
                return _schermen[94];
            } else if (authenticatieService.userIsAuthenticated()) {
                // Aangemelde gebruikers starten op scherm 2
                authenticatieService.login();
                return _schermen[2];
            } else if (isLogin) {
                //Indien men aanmeld
                return _schermen[1];
            } else if (!parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.Checktool, Enums.Kanaal.EloketAprofiel, Enums.Kanaal.EloketEmail, Enums.Kanaal.DLloket, Enums.Kanaal.BackOffice, Enums.Kanaal.InformatieKiosk, Enums.Kanaal.InformatieKioskChecktool])) {
                // Indien men op een niet ondersteunde kanaal wil openen
                parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.Checktool);
                return _schermen[2];
            } else if (_history.length > 0)
                return _history[_history.length - 1];
            else {
                parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.Checktool);
                return _schermen[2];
            }
        }

        function _bewaarScherm() {
            var scherm = _history[_history.length - 1];
            if (angular.isUndefined(scherm.selectedValues)) return scherm;

            _.forEach(scherm.selectedValues, function (value, param) {
                if (angular.isString(value)) value = value.trim();
                parameterService.set(param, value);
            });

            var lusKeuze = scherm.selectedValues[Enums.Parameters.Keuzes.Lus];
            if (angular.isUndefined(lusKeuze)) return scherm;

            _berekenAanvraagSoort(lusKeuze);

            return scherm;
        }

        function _bewaar(indienen) {
            var berekenActie = function (indienen) {
                    if (indienen === Enums.BewaarActies.RetryPay) {
                        return Enums.BewaarActies.RetryPay;
                    } else if (indienen) {
                        // Opnieuw Indienen
                        var status = parameterService.get(Enums.Parameters.AanvraagStatus);
                        if (angular.isDefined(status) && angular.isString(status.nl)) {
                            var matches = status.nl.match(/corr/i);
                            if (matches) return Enums.BewaarActies.OpnieuwIndienen;
                        }
                        return Enums.BewaarActies.Indienen;
                    } else
                        return Enums.BewaarActies.Bewaren;
                },
                zetParameters = function (result) {
                    _.forEach(result, function (value, key) {
                        parameterService.set(key, value);
                    });
                    parameterService.clear(Enums.Parameters.Medewerker.Opmerking);
                    _schermen[82].selectedValues[Enums.Parameters.Medewerker.Opmerking] = undefined;

                    parameterService.setDirty(false);
                },
                maakAanvraag = function (parameters) {
                   
                    if (parameters.BoeteNummer) {
                        parameters.BoeteNummer = parameters.BoeteNummer.replace(/[^A-Z0-9]/ig, "");
                    }
                    return aanvraagService
                        .create(parameters)
                        .then(function (result) {
                            var aanvraagNummer = result[Enums.Parameters.AanvraagNummer];
                            zetParameters(result);
                            lezErrorService.warning('SUC_AVR_03', undefined, [aanvraagNummer]);
                            return aanvraagNummer;
                        }, function (error) {
                            lezErrorService.error('ERR_AVR_03', error.ErrorCodes);
                            throw error;
                        });
                },
                wijzigAanvraag = function (parameters) {
                    return aanvraagService
                        .update(parameters)
                        .then(function (result) {
                            var aanvraagNummer = result[Enums.Parameters.AanvraagNummer];
                            zetParameters(result);
                            lezErrorService.warning('SUC_AVR_04', undefined, [aanvraagNummer]);
                            return aanvraagNummer;
                        }, function (error) {
                            lezErrorService.error('ERR_AVR_04', error.ErrorCodes);
                            throw error;
                        });
                },
                dienAanvraagIn = function (parameters) {
                    return aanvraagService
                        .update(parameters)
                        .then(function (result) {
                            var aanvraagNummer = result[Enums.Parameters.AanvraagNummer];
                            zetParameters(result);
                            lezErrorService.success('SUC_AVR_05', undefined, [aanvraagNummer]);
                            return aanvraagNummer;
                        }, function (error) {
                            lezErrorService.error('ERR_AVR_05', error.ErrorCodes);
                            throw error;
                        });

                },
                bewaarBijlagen = function (aanvraagId, parameters) {
                    return bijlagenService
                        .commit(aanvraagId)
                        .then(function () {
                            return parameters;
                        });
                };

            var parameters = parameterService.getParametersObject();
            parameters['Actie'] = berekenActie(indienen);

            var result;
            blockUI.start('bewaren');
            if (indienen)
                result = bewaarBijlagen(parameters[Enums.Parameters.AanvraagNummer], parameters)
                    .then(dienAanvraagIn);
            else if (angular.isNullOrWhitespace(parameters[Enums.Parameters.AanvraagNummer]))
                result = maakAanvraag(parameters)
                    .then(bewaarBijlagen);
            else
                result = bewaarBijlagen(parameters[Enums.Parameters.AanvraagNummer], parameters)
                    .then(wijzigAanvraag);
            result.finally(function () {
                blockUI.stop();
            });

            return result;
        }

        /* +++++ exposed methods +++++ */

        function _volgende() {
            var deferred = $q.defer();

            _bewaarScherm().volgende().then(
                function (volgendScherm) {
                    if (volgendScherm !== undefined) {
                        _history.push(volgendScherm);
                        return _huidigScherm();
                    } else throw "Er werd geen volgend scherm gevonden.";

                }).then(
                function (result) {
                    // Counters:
                    switch (result.schermNr) {
                        case 39: // Whitelist Resultaat
                            if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.Checktool)) tellerService.add("Checktool - Check NPL");
                            break;
                        case 41:
                            var vorigSchermNr = _history[_history.length - 2].schermNr;
                            switch (vorigSchermNr) {
                                case 45:
                                case 33:
                                case 9:
                                case 15:
                                case 7:
                                case 38:
                                case 8:
                                case 28:
                                case 6:
                                    if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.Checktool)) tellerService.add("Checktool - Scherm 41");
                                    break;
                                case 46:
                                case 51:
                                case 52:
                                case 68:
                                case 71:
                                case 73:
                                    if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.Checktool)) tellerService.add("Checktool - Scherm 41 FULL");
                                    break;
                            }

                    }
                    deferred.resolve({doReload: true, scherm: result});
                },
                function (error) {
                    if (angular.isDefined(error)) lezErrorService.error('ERR_NAV_01', error.ErrorCodes);
                    deferred.reject(error);
                });

            return deferred.promise;
        }

        function _vorige() {
            var deferred = $q.defer();
            if (_history.length > 1) {
                // Bewaarde aanvragen mogen niet meer terug naar scherm 41 omdat de Voertuiggegevens en Aanvraag Soort niet meer kunnen worden gewijzigd.
                if (angular.isDefined(parameterService.get(Enums.Parameters.AanvraagNummer))) {
                    var vorigScherm = _history[_history.length - 2];
                    if (vorigScherm.schermNr === 41) {
                        lezErrorService.error('ERR_NAV_02');
                        deferred.reject(undefined);
                        return deferred.promise;
                    }
                }

                // Ga een scherm terug
                var volgendScherm = _history.pop();

                // Uitgevoerde lussen worden ongedaan gemaakt
                var index = _.findIndex(_history, function (item) {
                    return item.schermNr === volgendScherm.schermNr;
                });
                if (index >= 0) {
                    while (_history.length > index) {
                        var res = _history.pop();
                        res.wisParameters();
                    }
                }
            }

            // In het geval van het aanvraag overzicht scherm, laad een andere angular 'state'
            var echtScherm = _history[_history.length - 1];
            var scherm = _huidigScherm();
            switch (scherm.schermNr) {
                case 84:
                    echtScherm.wisParameters();
                    var parameters = {f: true};
                    parameters[Enums.Parameters.AanvraagNummer] = parameterService.get(Enums.Parameters.AanvraagNummer);
                    parameters[Enums.Parameters.Taal] = parameterService.get(Enums.Parameters.Taal);
                    return $state.transitionTo('aanvraag', parameters, {
                        location: true,
                        notify: true,
                        reload: true,
                        inherit: false
                    }).then(function () {
                        return {doReload: false, scherm: scherm};
                    });
                case 94:
                    // Terugkeren naar start scherm op IK == annuleren
                    return _annuleren();
                default:
                    echtScherm.wisParameters();
                    deferred.resolve({doReload: true, scherm: scherm});
                    return deferred.promise;
            }
        }

        function _annuleren(needsConfirmation) {
            if (needsConfirmation) {
                return modalService.toonModal({
                    template: 'confirm.html',
                    controller: 'ConfirmModalController',
                    params: {type: 'AnnulatieTekst'}
                }).result.then(_annuleren, function () {
                    return 'Cancelled by user.';
                });
            }

            if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.InformatieKiosk, Enums.Kanaal.InformatieKioskChecktool])) {
                //laadSchermen(); // Reset all saved data
                _exit(); // Omdat het keyboard mee gereset moet worden, doen we een harde reset naar de originele URL - Dit zorgt wel voor een langere laadtijd.
                return $q(function (resolve, reject) {
                });
            }
            // Wis de parameters en reset naar het start scherm
            parameterService.clearAll();
            _history = [];
            _start();
            // Scherm herladen
            var parameters = {p: parameterService.getEncodedQueryString()};
            parameters[Enums.Parameters.Taal] = parameterService.get(Enums.Parameters.Taal);
            return $state.transitionTo('main.scherm.detail.default', parameters, {
                location: true,
                notify: true,
                reload: true,
                inherit: false
            }).then(function () {
                return {doReload: false, scherm: _huidigScherm()};
            });
        }

        function _opslaan() {
            var deferred = $q.defer();
            var scherm = _bewaarScherm();

            if (scherm.schermNr !== 82 && parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.DLloket, Enums.Kanaal.BackOffice])) {
                // Interceptor for Medewerkers
                _history.push(_schermen[82]);
                deferred.resolve({doReload: true, scherm: _huidigScherm()});
                return deferred.promise;
            }

            _bewaar(false).then(function () {
                deferred.resolve({doReload: false, scherm: _huidigScherm()});
            }, function (reason) {
                deferred.reject(reason);
            });

            return deferred.promise;
        }

        function _aanvullen() {
            var deferred = $q.defer();
            var scherm = _bewaarScherm();

            // Kanaal DL specifieke types
            if (parameterService.equals(Enums.Parameters.AanvraagSoort, [Enums.AanvraagSoort.VrijstellingPrioritairVoertuig, Enums.AanvraagSoort.VrijstellingUitzonderlijkVervoer, Enums.AanvraagSoort.RegistratieAnderType])) {
                _history.push(_schermen[70]);
                deferred.resolve({doReload: true, scherm: _huidigScherm()});
                return deferred.promise;
            }

            switch (parameterService.get(Enums.Parameters.AanvraagType)) {
                case Enums.AanvraagType.Toelating:
                    if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.EloketAprofiel, Enums.Kanaal.EloketEmail]) && angular.isUndefined(parameterService.get(Enums.Parameters.AanvraagNummer))) tellerService.add('ELoket - Can Save');
                    _history.push(_schermen[55]);
                    break;
                case Enums.AanvraagType.Dagpas:
                    var huidigScherm = _history[_history.length - 1];
                    huidigScherm.wisParameters = _undoZetParameters(huidigScherm, _zetDagpasParameters(), huidigScherm.wisParameters);
                    _history.push(_schermen[85]);
                    break;
                case Enums.AanvraagType.Vrijstelling:
                case Enums.AanvraagType.Registratie:
                    parameterService.prefill(Enums.Parameters.Tarief, undefined); // LEZ-862 - Make sure this prefill is gone
                    if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.EloketAprofiel, Enums.Kanaal.EloketEmail]) && angular.isUndefined(parameterService.get(Enums.Parameters.AanvraagNummer))) tellerService.add('ELoket - Can Save');
                    _history.push(_schermen[54]);
                    break;
            }

            deferred.resolve({doReload: true, scherm: _huidigScherm()});
            return deferred.promise;

        }

        function _login() {
            var deferred = $q.defer();

            // Bewaar de huidige scherm
            _bewaarScherm();

            // LEZ-967 - Indien alle gegevens gekend zijn, resetten we de tool niet
            var needsReset = angular.isNullOrWhitespace(parameterService.get(Enums.Parameters.Voertuig.Nummerplaat));

            if (needsReset) {
                // Retrieve current parameter set
                var parameters = parameterService.getParametersObject();
                // Clear values & prefill
                parameterService.clearAll();
                // Prefill values
                angular.forEach(parameters, function (parvalue, param) {
                    parameterService.prefill(param, parvalue);
                });
            }

            switch (parameterService.get(Enums.Parameters.Kanaal)) {
                case Enums.Kanaal.InformatieKiosk:
                    if (needsReset) _history.push(_schermen[2]);
                    break;
                case Enums.Kanaal.InformatieKioskChecktool:
                    if (needsReset) _history = [_schermen[94], _schermen[93]];
                    parameterService.set(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk);
                    _history.push(_schermen[91]);
                    break;
                case Enums.Kanaal.Checktool:
                default:
                    if (needsReset) _history = [];
                    _history.push(_schermen[1]);
                    break;
            }

            deferred.resolve({doReload: true, scherm: _huidigScherm()});
            return deferred.promise;
        }

        function _exit() {
            switch (parameterService.get(Enums.Parameters.Kanaal)) {
                case Enums.Kanaal.DLloket:
                    $window.location = Config.backofficeUiUrl + 'aanvragen/detail/' + parameterService.get(Enums.Parameters.AanvraagNummer, true) + '?tab=communicatie';
                    break;
                case Enums.Kanaal.BackOffice:
                    $window.location = Config.backofficeUiUrl + 'aanvragen/overzicht';
                    break;
                case Enums.Kanaal.InformatieKiosk:
                case Enums.Kanaal.InformatieKioskChecktool:
                    var kioskId = parameterService.get(Enums.Parameters.Kiosk.Id);
                    kioskId = angular.isString(kioskId) ? kioskId : '';
                    $window.location = Config.frontofficeUiUrl + 'infokiosk/' + kioskId.toLowerCase();
                    break;
                case Enums.Kanaal.EloketAprofiel:
                case Enums.Kanaal.EloketEmail:
                case Enums.Kanaal.Checktool:
                default:
                    $window.location = Config.snaUiUrl + parameterService.get(Enums.Parameters.Taal, true).toLowerCase() + '/lez';
                    break;
            }
        }

        function _start(navigatieActie) {
            switch (navigatieActie) {
                case Enums.NavigatieActies.Offline:
                    _history = [_schermen[89]]; // APP - Offline
                    break;
                case Enums.NavigatieActies.Maintenance:
                    if (_history.length === 0) _history = [_eersteScherm()];
                    _schermen[88].volgendScherm = _huidigScherm().schermNr;
                    _history.pop();
                    _history.push(_schermen[88]); // Maintenance
                    break;
                case Enums.NavigatieActies.Login:
                    _history = [_eersteScherm(true)];
                    break;
                case Enums.NavigatieActies.Relog:
                    _history = [_schermen[92]]; // User verification
                    break;
                case Enums.NavigatieActies.Restore:
                    // LEZ-967 - Restore
                    _history = [_eersteScherm()];
                    var length = _history.length;
                    var replay = function () {
                        return _bewaarScherm().volgende().then(function (volgendScherm) {
                            if (angular.isUndefinedOrNull(volgendScherm)) return;

                            var isLoopOver = _.findIndex(_history, function (item) {
                                return item.schermNr === volgendScherm.schermNr;
                            }) >= 0;
                            if (volgendScherm.schermNr !== _huidigScherm().schermNr) _history.push(volgendScherm);

                            if (isLoopOver) return;
                            if (_history.length <= length) return;

                            // Set selected values based on prefill
                            angular.forEach(volgendScherm.selectedValues, function (value, param) {
                                volgendScherm.selectedValues[param] = parameterService.get(param, true);
                            });

                            length = _history.length;
                            return replay();
                        });
                    };
                    return replay(); // Replay 'volgende' tot er een fout optreed...
                case Enums.NavigatieActies.Dagpas:
                    _history = [_schermen[87]];
                    break;
                case Enums.NavigatieActies.Ogone:
                    _history = [_schermen[84]];
                    _history.push(_schermen[58]); // Payment result
                    break;
                case Enums.NavigatieActies.OgoneFailed:
                    _history = [
                        _schermen[84], // Overzicht
                        _schermen[59], // Disclaimer
                        _schermen[56], // Betaalmethode
                        _schermen[58]  // Payment Result
                    ];
                    break;
                case Enums.NavigatieActies.Indienen:
                    _history = [_schermen[84]];
                    _volgende();
                    break;
                case Enums.NavigatieActies.Wijzigen:
                    _history = [_schermen[84]];
                    _aanvullen();
                    break;
                case Enums.NavigatieActies.BijlagenBeheren:
                    _history = [_schermen[84]];
                    _history.push(_schermen[78]);
                    break;
                case Enums.NavigatieActies.Verlengen:
                    _history = [_schermen[84]];
                    var huidigScherm = _history[_history.length - 1];
                    huidigScherm.wisParameters = _undoZetParameters(huidigScherm, _startVerlenging(), huidigScherm.wisParameters);
                    _history.push(_schermen[55]);
                    break;
                case Enums.NavigatieActies.Kopieren:
                    parameterService.clear(Enums.Parameters.AanvraagNummer);
                    _startKopieren();
                    _history = [_schermen[2]];
                    //$window.location = Config.frontofficeUiUrl + '?p=' + parameterService.getEncodedQueryString();
                    break;
                case Enums.NavigatieActies.BoeteNummer:
                    _history = [_schermen[98]]; // Boetenummer ingave scherm
                    break;
                case Enums.NavigatieActies.Toevoegen:
                case Enums.NavigatieActies.Verwijderen:
                default:
                    if (_history.length > 1) return;
                    if (_history.length === 1 && (_history[0] === _schermen[1] || _history[0] === _schermen[92])) return;
                    _history = [_eersteScherm()];
                    break;
            }
        }

        function _huidigScherm() {
            var scherm = _history[_history.length - 1];
            return {
                schermNr: scherm.schermNr,
                selectedValues: scherm.selectedValues,
                setValid: function (valid) {
                    scherm.isValid = valid;
                },
                isValid: function () {
                    return scherm.isValid;
                }
            }; // Dont expose other methods
        }

        function _isEersteScherm(schermNr) {
            return _history[0].schermNr === schermNr;
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(serviceName);

        init();

        return {
            volgende: _volgende,
            vorige: _vorige,
            annuleren: _annuleren,

            opslaan: _opslaan,
            aanvullen: _aanvullen,

            login: _login,

            exit: _exit,

            start: _start,
            huidigScherm: _huidigScherm,
            isEersteScherm: _isEersteScherm,

            isStarted: function () {
                return _history.length > 0;
            }
        };
    };

    theRepository.$inject = ['appConfig', 'appEnums', 'appConstants', 'AppService', '$q', '$state', 'ParameterService', 'ParameterHelperService', 'LEZErrorService', 'AanvraagService', 'WhitelistService', 'PaymentService', 'AuthenticatieService', 'BijlagenService', 'DagpasService', 'InfokioskService', 'TellerService', '$window', 'MeertaligBlockUIService', 'ModalService', 'CodeService'];
    angular.module('theApp').factory(serviceName, theRepository);
})();
;
(function () {

    'use strict';

    var componentName = "ParameterHelperService";
    var theComponent = function (Enums, appService, $q, parameterService, logicService) {

        /* +++++ exposed methods +++++ */

        function _bereken(param, extraParams) {
            var isBerekendeParameter = function (param) {
                switch (param) {
                    case Enums.Parameters.VolledigheidAanvraag:
                    case Enums.Parameters.KopieerbaarheidAanvraag:
                    case Enums.Parameters.VerlengbaarheidAanvraag:
                    case Enums.Parameters.VerlengbaarheidBijlagen:
                    case Enums.Parameters.Overlap:
                    case Enums.Parameters.Voertuig.EuronormVerrijkt:
                    case Enums.Parameters.Voertuig.EuronormGecorrigeerd:
                        return true;
                }
                if (!angular.isString(param)) return false;
                if (param.indexOf('VW') >= 0) return true;
            };

            if (!isBerekendeParameter(param)) {
                var deferred = $q.defer();
                deferred.resolve(parameterService.get(param));
                return deferred.promise;
            }

            var onSucces = function (result) {
                if (!angular.isUndefinedOrNull(result))
                    parameterService.set(param, result);
                else
                    parameterService.clear(param);

                return result;
            };
            var onError = function () {
                return parameterService.get(param);
            };

            var berekenParam = function () { return logicService.getResult(param, extraParams).then(onSucces); };

            if (param === Enums.Parameters.VolledigheidAanvraag) {
                return _bereken(Enums.Parameters.VolledigheidLus).then(function () {
                    return berekenParam();
                });
            }
            else
                return berekenParam();
        }

        function _ENCompare(value1, value2) {
            var ok1 = !angular.isUndefinedOrNull(value1);
            var ok2 = !angular.isUndefinedOrNull(value2);

            if (!ok1 && !ok2) return 0;
            if (!ok2) return 1;
            if (!ok1) return -1;

            var comparer = { '6d': 6.5, '6dTemp': 6.1, '6': 6, '5': 5, '4': 4, '3': 3, '2': 2, '1': 1, '0': 0, 'V': 5, 'IV': 4, 'IIIb': 3.5, 'IIIa': 3, 'II': 2, 'I': 1, 'NV': -1 };

            value1 = comparer[value1];
            value2 = comparer[value2];

            ok1 = !angular.isUndefinedOrNull(value1);
            ok2 = !angular.isUndefinedOrNull(value2);

            if (!ok1 && !ok2) return 0;
            if (!ok2) return 1;
            if (!ok1) return -1;

            return value1 - value2;
        }

        function _getHoogsteENParameter() {
            var euronorm = parameterService.get(Enums.Parameters.Voertuig.Euronorm);
            var verrijkt = parameterService.get(Enums.Parameters.Voertuig.EuronormVerrijkt);
            var gecorrigeerd = parameterService.get(Enums.Parameters.Voertuig.EuronormGecorrigeerd);

            if (_ENCompare(euronorm, verrijkt) >= 0) {
                return _ENCompare(euronorm, gecorrigeerd) >= 0 ? Enums.Parameters.Voertuig.Euronorm : Enums.Parameters.Voertuig.EuronormGecorrigeerd;
            } else {
                return _ENCompare(verrijkt, gecorrigeerd) >= 0 ? Enums.Parameters.Voertuig.EuronormVerrijkt : Enums.Parameters.Voertuig.EuronormGecorrigeerd;
            }
        }

        function _isVerrijkt() {
            var verrijkt = parameterService.get(Enums.Parameters.Voertuig.EuronormVerrijkt);
            if (angular.isNullOrWhitespace(verrijkt)) return false;
            var euronorm = parameterService.get(Enums.Parameters.Voertuig.Euronorm);
            if (!angular.isNullOrWhitespace(euronorm) && euronorm !== Enums.Euronorm.NietVermeld) return false;
            return true;
        }

        function _isGecorrigeerd() {
            var gecorrigeerd = parameterService.get(Enums.Parameters.Voertuig.EuronormGecorrigeerd);
            if (angular.isNullOrWhitespace(gecorrigeerd)) return false;
            var euronorm = _isVerrijkt() ? parameterService.get(Enums.Parameters.Voertuig.EuronormVerrijkt) : parameterService.get(Enums.Parameters.Voertuig.Euronorm);
            if (angular.isNullOrWhitespace(euronorm)) return true;

            return _ENCompare(gecorrigeerd, euronorm) > 0;
        }

        function _isOldtimer() {
            var res = parameterService.get(Enums.Parameters.IsOldtimerVoertuig);
            if (angular.isDefined(res)) return res;
            var date = Date.Today();
            date.add(-40, 'y');
            res = date.isSameOrAfter(parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving));
            parameterService.set(Enums.Parameters.IsOldtimerVoertuig, res);
            return res;
        }

        function _canRegisterAsOldtimer() {
            var firstRegistrationDate = parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving);
            if (!angular.isDefined(firstRegistrationDate)) return;
            var minDate = new moment();
            minDate.add(-40, 'years');
            minDate.add(4, 'months');
            var maxDate = new moment();
            maxDate.add(-40, 'years');
            return firstRegistrationDate.isBetween(maxDate, minDate);
        }

        function _calculateOldtimerStartDate() {
            var eid = parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving);

            if (!angular.isDefined(eid)) return;

            var date = new moment();
                date.add(- 40, 'years');

            var oldTimerDate = moment(date, 'YYYY-MM-DD');
            var firstRegistrationDate = moment(eid, 'YYYY-MM-DD');
            var daysDiff = Math.abs(moment.duration(oldTimerDate.diff(firstRegistrationDate)).asDays());
            var today = new moment();

            /**
             * Check if current hour is 12h or after. If so, add one day to todays date.
             * @see https://jira.antwerpen.be/browse/LEZ-1392
             */
            if (Number(moment(today).format('HH')) >= 12) {
                return today.add(daysDiff + 1, 'days');
            }

            return today.add(daysDiff, 'days');
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            bereken: _bereken,

            ENCompare: _ENCompare,
            getHoogsteENParameter: _getHoogsteENParameter,
            isVerrijkt: _isVerrijkt,
            isGecorrigeerd: _isGecorrigeerd,
            isOldtimer: _isOldtimer,
            canRegisterAsOldtimer: _canRegisterAsOldtimer,
            calculateOldtimerStartDate: _calculateOldtimerStartDate
        };

    };

    theComponent.$inject = ['appEnums', 'AppService', '$q', 'ParameterService', 'LogicService'];

    angular.module('theApp').factory(componentName, theComponent);

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

    var componentName = "ParameterService";
    var theComponent = function (Enums, appService, meertaligheidService, parameterOptionsService, formatterService, $stateParams, $q, $rootScope) {

        var _prefill = {};
        var _parameters = {};
        var _dirty = true;
        
        _initPrefill();

        function _initPrefill() {
            _prefill = {};
            _prefill[Enums.Parameters.Taal] = Enums.Taal.Nederlands;
            _prefill[Enums.Parameters.Voertuig.Landcode] = 'BE'; // LEZ-1158 - TOCH prefill van landcode...
            _prefill[Enums.Parameters.BeginDatum] = Date.Today();
        }
                
        function _parseValue(parValue) {
            if (angular.isString(parValue) && parValue.length > 0)
            {
                var result = Date.FromApi(parValue);
                if (angular.isDate(result)) return result;
            }
            return parValue;
        }

        function _createParameter(param) {
            _parameters[param.param] = {
                param: param,
                parvalue: undefined,
                sortOrder: Object.keys(_parameters).length
            };

            if (param.param === Enums.Parameters.AanvraagNummer) _parameters[param.param].sortOrder = 0; // Sort this one first
        }

        /* +++++ exposed methods +++++ */

        function _prefillFunction(param, value) {
            if (angular.isUndefined(value))
                delete _prefill[param];
            else
                _prefill[param] = value;
        }

        function _setEncodedQueryString(q) {
            if (angular.isUndefined(q)) return;

            function _canPrefillParameter(param) {
                function _hasValue(object, param) {
                    for (var p in object) {
                        if (object.hasOwnProperty(p)) {
                            if (object[p] === param) return true;
                        }
                    }
                    return false;
                }

                if (_hasValue(Enums.Parameters.VDIVoertuig, param)) return false;
                if (_hasValue(Enums.Parameters.Hotlist, param)) return false;
                if (_hasValue(Enums.Parameters.Dagpas, param)) return false;
                if (_hasValue(Enums.Parameters.LusParameters, param)) return false;
                if (_hasValue(Enums.Parameters.DirkParameters, param)) return false;

                switch (param) {
                    case Enums.Parameters.LusZichtbaarheid:
                    case Enums.Parameters.VolledigheidAanvraag:
                    case Enums.Parameters.VolledigheidLus:
                    case Enums.Parameters.Bijlagen.Voorwaarden:
                        return false;
                }

                return true;
            }

            function _canSetParameter(param) {
                switch (param) {
                    // Important global data
                    case Enums.Parameters.Taal:
                    case Enums.Parameters.Kanaal:
                        return true;
                    // User data
                    case Enums.Parameters.Gebruiker.Identificatie:
                    case Enums.Parameters.Gebruiker.Token:
                    case Enums.Parameters.Aanvrager.Naam:
                    case Enums.Parameters.Aanvrager.Voornaam:
                    case Enums.Parameters.Aanvrager.Email:
                    case Enums.Parameters.Medewerker.Loket:
                    case Enums.Parameters.Medewerker.Token:
                    case Enums.Parameters.Medewerker.Identificatie:
                        return true;
                    // Kiosk data
                    case Enums.Parameters.Kiosk.Id:
                    case Enums.Parameters.Kiosk.Naam:
                    case Enums.Parameters.Kiosk.SessieId:
                    case Enums.Parameters.Kiosk.HasScanned:
                        return true;
                }
                return false;
            }

            q = decodeURIComponent(q);
            q = angular.atou(q);
            q = angular.fromJson(q);
            q = angular.convertDateStringsToDates(q);
            angular.forEach(q, function (parvalue, param) {

                if (!_canPrefillParameter(param)) return;

                // Never 'downgrade' kanaal
                if (param === Enums.Parameters.Kanaal && (parvalue === Enums.Kanaal.Checktool || parvalue === Enums.Kanaal.InformatieKioskChecktool)) {
                    switch(_get(Enums.Parameters.Kanaal)){
                        case Enums.Kanaal.EloketAprofiel:
                        case Enums.Kanaal.EloketEmail:
                        case Enums.Kanaal.BackOffice:
                        case Enums.Kanaal.DLloket:
                        case Enums.Kanaal.InformatieKiosk:
                        case Enums.Kanaal.InformatieKioskChecktool:
                            return;
                    }
                }

                if (_canSetParameter(param))
                    _set(param, parvalue, true);
                else
                    _prefill[param] = parvalue;
            });
            _updateUrl();
        }

        function _getEncodedQueryString() {
            var q = _getParametersObject();
            angular.forEach(_prefill, function (parvalue, param) {
                if (angular.isUndefined(q[param])) q[param] = parvalue;
            });
            q = angular.toJson(q, false);
            q = angular.utoa(q);
            q = encodeURIComponent(q);
            return q;
        }

        function _getParametersObject() {
            var params = {};
            _.forEach(_parameters, function (parameter) {
                if (angular.isUndefined(parameter.parvalue)) return;

                if (angular.isDefined(parameter.parvalue.parvalue))
                    params[parameter.param.param] = parameter.parvalue.parvalue;
                else if (angular.isObject(parameter.parvalue))
                    params[parameter.param.param] = parameter.parvalue;
            });
            return  params;
        }

        function _getAll() {
            return _parameters;
        }

        // Get the parameter value (usePrefill: use prefill value when original is undefined; dontuseVDIValue: don't use VDI values when original is undefined)
        function _get(param, usePrefill, dontUseVDIValue) {
            if (angular.isUndefined(param)) return undefined;

            var matches = param.match(/^([^\[\]]+)(?:\[([^\[\]]+)\])*$/);
            if (!matches) {
                console.log("Parameter Matching Error: " + param);
                return undefined;
            }

            // Retrieve the actual value of the parameter
            function _getValue(param) {
                if (!angular.isObject(_parameters[param])) return undefined;
                if (angular.isUndefined(_parameters[param].parvalue)) return undefined;

                var parvalue = _parameters[param].parvalue;

                if (angular.isDefined(parvalue.parvalue)) {
                    if (angular.isDefined(matches[2]))
                        return parvalue.parvalue[+matches[2]];
                    else
                        return parvalue.parvalue;
                }
                else if (angular.isDefined(parvalue.parameterValue))
                    return parvalue.parameterValue;
                else
                    return parvalue;
            }

            var value = _getValue(matches[1]);
            if (angular.isDefined(value))
                return value;

            // Use prefill, in case it is defined.
            if (usePrefill) {
                value = _prefill[param];
                if (angular.isDefined(value)) {
                    if (angular.isDefined(matches[2]))
                        return value[+matches[2]];
                    else
                        return value;
                }
            }

            // Use VDI_ version of the value
            if (!dontUseVDIValue) {
                value = _get('VDI_' + param, usePrefill, true);
                if (angular.isDefined(value))
                    return value;
            }

            return undefined;
        }

        function _getOptions(param) {
            var deferred = $q.defer();

            var heeftBerekendeOpties = function (parameter) {
                switch (parameter) {
                    case Enums.Parameters.Voertuig.EuronormGecorrigeerdAndere:
                    case Enums.Parameters.Voertuig.EuronormGecorrigeerdLandbouw:
                    case Enums.Parameters.Betaling.Methode:
                        return true; // Berekend in back-end
                    default:
                        return false;
                }
            };

            var defaultResult = function () { deferred.resolve(meertaligheidService.get({ schermtype: 'Algemeen', param: param, itemtype: 'Content', visible: true })); };
            
            if (angular.isString(param) && heeftBerekendeOpties(param)) {
                parameterOptionsService.get(param, _getParametersObject()).then(
                    function (result) {
                        var res = [];
                        _.forEach(result, function (value) {
                            var found = meertaligheidService.get({ schermtype: 'Algemeen', param: param, parvalue: value, itemtype: 'Content', visible: true });
                            _.forEach(found, function (x) { res.push(x); });
                        });
                        if (res.length < 1) deferred.resolve(meertaligheidService.get({ schermtype: 'Algemeen', param: param, itemtype: 'Content', visible: true }));
                        else deferred.resolve(res);
                    }, defaultResult);
            }
            else defaultResult();            

            return deferred.promise;
        }

        function _updateUrl() {
            var taal = _get(Enums.Parameters.Taal, true);
            if ($stateParams[Enums.Parameters.Taal] !== taal) $stateParams[Enums.Parameters.Taal] = taal;
            var p = _getEncodedQueryString();
            if ($stateParams['p'] !== p) $stateParams['p'] = p;
        }

        function _set(param, parvalue, dontUpdateUrl) {
            parvalue = _parseValue(parvalue);
            if (angular.isUndefined(parvalue)) return; // Invalid value

            if (_parameters[param] === undefined)
            {
                var data = meertaligheidService.get({ schermtype: 'Algemeen', naam: 'Value', itemtype: 'Label' }, false);
                data = meertaligheidService.get({param: param}, undefined, data);
                var p = data.length > 0 ? data.shift() : { param: param, visible: false };
                 _createParameter(p);
            }
            var parameter = _parameters[param];

            //if (!angular.isArray(parvalue) && _equals(param, parvalue, true)) return; // Nothing changed
            var oldValue = _get(param, true, false);

            if (angular.isDefined(parvalue) && angular.isDefined(parvalue.nl)) {
                parameter.parvalue = parvalue;
            }
            else {
                var dat = meertaligheidService.get({ schermtype: 'Algemeen', param: param, parvalue: parvalue });
                var par = dat.length > 0 ? dat[0] : { param: param, parvalue: parvalue, visible: true };
                parameter.parvalue = par;
            }

            if (!_equals(param, oldValue)) _dirty = true;
            
            switch (param) {
                case Enums.Parameters.Taal:
                case Enums.Parameters.AanvraagType:
                case Enums.Parameters.Kanaal:
                    if (_equals(param, oldValue)) break; // Don't broadcast when there is no actual change
                    $rootScope.$broadcast(param, parvalue);
                    break;
                case Enums.Parameters.Voertuig.Landcode:
                    _prefill[Enums.Parameters.Aanvrager.Land] = parvalue;
                    _prefill[Enums.Parameters.Bedrijf.Land] = parvalue;
                    _prefill[Enums.Parameters.Gehandikapte.Land] = parvalue;
                    _prefill[Enums.Parameters.Titularis.Land] = parvalue;
                    break;
            }

            if (!dontUpdateUrl) _updateUrl();
        }

        function _clear(param) {
            if (param === Enums.Parameters.Taal) return; // Never clear this one.
            
            if (angular.isArray(param)) {
                for (var i in param) _clear(param[i]);
                return;
            }

            if (_parameters[param] === undefined)
                return;
            else {
                _dirty = true;
                delete _parameters[param];
            }

            _updateUrl();
        }

        function _clearAll() {
            var params = {
                Taal: _get(Enums.Parameters.Taal, true),
                REGT: _get(Enums.Parameters.Kanaal)
            };

            switch (params[Enums.Parameters.Kanaal]) {
                case Enums.Kanaal.BackOffice:
                case Enums.Kanaal.DLloket:
                    params[Enums.Parameters.Medewerker.Loket] = _get(Enums.Parameters.Medewerker.Loket);
                    params[Enums.Parameters.Medewerker.Naam] = _get(Enums.Parameters.Medewerker.Naam);
                    params[Enums.Parameters.Medewerker.Identificatie] = _get(Enums.Parameters.Medewerker.Identificatie);
                    params[Enums.Parameters.Medewerker.Token] = _get(Enums.Parameters.Medewerker.Token);
                    params[Enums.Parameters.Medewerker.KassaToepassing] = _get(Enums.Parameters.Medewerker.KassaToepassing);
                    break;
                case Enums.Kanaal.EloketAprofiel:
                    params[Enums.Parameters.Gebruiker.Identificatie] = _get(Enums.Parameters.Gebruiker.Identificatie);
                    params[Enums.Parameters.Gebruiker.Token] = _get(Enums.Parameters.Gebruiker.Token);
                    params[Enums.Parameters.Aanvrager.Naam] = _get(Enums.Parameters.Aanvrager.Naam);
                    params[Enums.Parameters.Aanvrager.Voornaam] = _get(Enums.Parameters.Aanvrager.Voornaam);
                    params[Enums.Parameters.Aanvrager.Email] = _get(Enums.Parameters.Aanvrager.Email);
                    break;
                case Enums.Kanaal.EloketEmail:
                    params[Enums.Parameters.Gebruiker.Identificatie] = _get(Enums.Parameters.Gebruiker.Identificatie);
                    params[Enums.Parameters.Aanvrager.Email] = _get(Enums.Parameters.Aanvrager.Email);
                    params[Enums.Parameters.Gebruiker.HerhalingEmail] = _get(Enums.Parameters.Gebruiker.HerhalingEmail);
                    break;
                case Enums.Kanaal.InformatieKiosk:
                case Enums.Kanaal.InformatieKioskChecktool:
                    params[Enums.Parameters.Kiosk.Id] = _get(Enums.Parameters.Kiosk.Id);
                    _initPrefill(); // Wis eveneens alle prefill waarden bij Infokiosk
                    break;
            }

            _parameters = {};

            angular.forEach(params, function (value, key) {
                _set(key, value);
            });

            _dirty = true;
        }

        function _equals(param, parValues) {
            var waarde = _get(param, false);

            function eq(one, two) { return one === two || one + '' === two + ''; }

            if (angular.isUndefinedOrNull(waarde)) {
                if (angular.isUndefinedOrNull(parValues)) return true;
                else return false;
            }

            if (angular.isArray(parValues)) {
                for (var i in parValues) { if (eq(waarde,parValues[i])) return true; }
                return false;
            }
            else return eq(waarde, parValues);
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);


        return {
            getEncodedQueryString: _getEncodedQueryString,
            setEncodedQueryString: _setEncodedQueryString,

            getParametersObject: _getParametersObject,

            getAll: _getAll,
            get: _get,

            getOptions: _getOptions,

            set: _set,
            prefill: _prefillFunction,

            clear: _clear,
            clearAll: _clearAll,

            equals: _equals,

            setDirty: function (dirty) { _dirty = dirty; },
            isDirty: function () { return _dirty; }
            
        };

    };

    theComponent.$inject = ['appEnums', 'AppService', 'MeertaligheidService', 'ParameterOptionsService', 'FormatterService', '$stateParams', '$q', '$rootScope'];
    angular.module('theApp').factory(componentName, theComponent);
})();;
(function () {

    'use strict';

    var componentName = "ValidationService";
    var theComponent = function (Config, Enums, Constants, ValidationResult, Validator, validationMessageService, formatterService, parameterService, parameterHelperService, errorService, $filter, aanvraagService) {

        var _values = {};
        var _validators = {};
        var _minValues = {};
        var _maxValues = {};

        _init();

        function _init() {
            _validators = {};

            // Voertuig
            _validators[Enums.Parameters.Voertuig.Nummerplaat] = new Validator([function (value) {
                if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.Checktool, Enums.Kanaal.InformatieKioskChecktool]) && angular.isNullOrWhitespace(value)) return ValidationResult.CreateSuccessResult();

                var validator = new Validator([_valideerNummerplaat, function (value) { return _validateMaxLength(value, 10); }]);
                return validator.validate(value);
            }]);
            _validators[Enums.Parameters.Voertuig.DatumEersteInschrijving] = new Validator([function (value) {
                if (angular.isNullOrWhitespace(value)) {
                    if (parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.BackOffice)) return ValidationResult.CreateSuccessResult();
                    if (parameterService.equals(Enums.Parameters.AanvraagType, Enums.AanvraagType.Dagpas)) return ValidationResult.CreateSuccessResult();
                    if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.Checktool, Enums.Kanaal.InformatieKioskChecktool]) && !parameterService.equals(Enums.Parameters.Voertuig.Euronorm, 'NV') && angular.isNullOrWhitespace(_getValue(Enums.Parameters.Voertuig.Nummerplaat))) return ValidationResult.CreateSuccessResult();
                }

                var validDate = _validateDate(value);
                if (!validDate.isValid()) return validDate;

                var validFutureDate = _validateDateBefore(value, Date.Now());
                if (!validFutureDate.isValid()) return validFutureDate;

                var validPastDate = _validateDateAfter(value, Constants.Datums.getVroegsteDatumEersteInschrijving());
                if (!validPastDate.isValid()) return validPastDate;

                return ValidationResult.CreateSuccessResult();
            }]);
            _validators[Enums.Parameters.Voertuig.DatumLaatsteInschrijving] = new Validator([function (value) {
                var result = _validateDate(value);
                if (!result.isValid()) return result;

                var validator = new Validator([function (value) { return _validateDateBefore(value, Date.Now()); },
                    function (value) {
                        var eid = _getValue(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                        if (angular.isDate(eid))
                            return _validateDateAfter(value, eid);
                        else return ValidationResult.CreateSuccessResult();
                    }]);
                return validator.validate(value);
            }]);
            _validators[Enums.Parameters.Voertuig.MaximaalToegelatenMassa] = new Validator([_validatePositiveInteger, function (value) { return _validateNumberLargerEquals(value, 500); }]);
            _validators[Enums.Parameters.Voertuig.MassaRijklareToestand] = new Validator([function (value) {
                if (_getValue(Enums.Parameters.Voertuig.MassaRijklareToestandVerplicht) === false) {
                    // LEZ-1016
                    if (angular.isNullOrWhitespace(value))
                        return ValidationResult.CreateSuccessResult();
                }
                var result = _validatePositiveNumber(value);
                if (!result.isValid()) return result;
                return _validateNumberLargerEquals(value, 100);
            }]);
            _validators[Enums.Parameters.Voertuig.Vermogen] = new Validator([function (value) {
                var result = _validatePositiveNumber(value);
                if (!result.isValid()) return result;
                return _validateNumberLarger(value, 0);
            }]);
            _validators[Enums.Parameters.Voertuig.BijkomendeZitplaatsen] = new Validator([_validatePositiveInteger]);
            _validators[Enums.Parameters.Voertuig.CO2Waarde] = new Validator([_validatePositiveInteger]);
            _validators[Enums.Parameters.Voertuig.PartikelMassaWaarde] = new Validator([_validatePositiveNumber, function (value) { return _validateNumberLargerEquals(value, 0.001); }]);
            _validators[Enums.Parameters.Voertuig.Aardcode] = new Validator([_validateCode]);
            _validators[Enums.Parameters.Voertuig.GelijkvormigheidscodeAndere] = new Validator([_validateCode]);
            _validators[Enums.Parameters.Voertuig.GelijkvormigheidscodeLandbouw] = new Validator([_validateCode]);

            // Aanvraag
            _validators[Enums.Parameters.BeginDatum] = new Validator([function (value) {
                var result = _validateDate(value);
                if (!result.isValid()) return result;

                // LEZ-733, LEZ-952, LEZ-1108 - Anything goes
                if (_getValue(Enums.Parameters.Kanaal) === Enums.Kanaal.BackOffice) {
                    return ValidationResult.CreateSuccessResult();
                }

                // Binnen de X maand
                var today = Date.Now();
                if (parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingDieselEuro4) ||
                    parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingInwonerDE4)
                ) {
                    var LEZ2020StartDatum = Constants.Datums.getLEZ2020StartDatum();
                    if (parameterService.get(Enums.Parameters.Verstrenging) && today < LEZ2020StartDatum) {
                        today = LEZ2020StartDatum;
                    }
                }

                // LEZ-1444
                switch (parameterService.get(Enums.Parameters.AanvraagSoort)) {
                    case Enums.AanvraagSoort.RegistratieTechnischeKenmerken:
                    case Enums.AanvraagSoort.RegistratieTechnischeKenmerkenBE:
                        if (parameterService.equals(Enums.Parameters.Voertuig.Euronorm, '4') && parameterService.equals(Enums.Parameters.Voertuig.BrandstofType, 'D')) {
                            result = _validateDateBefore(value, Constants.Datums.getEindDatum_2019());
                            if (result.isValid()) {
                                result = _validateDateAfter(value, Date.Yesterday());
                            }

                            return result;
                        }
                        break;
                }

                if (parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingWerken) ||
                    parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingAmbulanteHandel) ||
                    parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingNoodsituatie)
                ) {
                    switch (parameterService.get(Enums.Parameters.Voertuig.Euronorm)) {
                        case '2':
                            result = _validateDateBefore(value, Constants.Datums.getEindDatum_2019());
                            break;
                        case '3':
                        case '4':
                            result = _validateDateBefore(value, Date.Yesterday().add(Config.aantalMaandAfdekking, 'M'));
                            break;
                        default:
                    }

                    if (result.isValid()) {
                        result = _validateDateAfter(value, Date.Yesterday());
                    }

                    return result;
                }

                if (parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.RegistratieRoetfilterDieselEuro3)) {
                    result = _validateDateBefore(value, Constants.Datums.getEindDatum_2019());
                    if (result.isValid()) {
                        return _validateDateAfter(value, Date.Yesterday());
                    } else {
                        return result;
                    }
                }

                var compare = today.add(Config.aantalMaandAfdekking, 'M');
                result = _validateDateBefore(value, compare);
                if (!result.isValid()) return result;

                var type = _getValue(Enums.Parameters.AanvraagType);

                // Start datum - Gisteren, Vandaag of Morgen - Afh van Type
                switch (type) {
                    case Enums.AanvraagType.Toelating:
                        var LEZ2020StartDatum = Constants.Datums.getLEZ2020StartDatum();
                        if (parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingOldtimer)) {
                            var datumEersteInschrijving = parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                            if (datumEersteInschrijving && moment().diff(datumEersteInschrijving, 'years') < 40) {
                                var startDate = moment(parameterHelperService.calculateOldtimerStartDate(), 'YYYY-MM-DD');
                                var date = moment(value, 'YYYY-MM-DD');
                                value = date.startOf('day');
                                compare = startDate.startOf('day');
                            } else {
                                compare = Date.Yesterday();
                            }
                        } else {
                            compare = Date.Yesterday();
                        }
                        break;
                    case Enums.AanvraagType.Dagpas:
                        var huidigJaar_Eind = moment().endOf('year');
                        var volgendJaar_Eind = moment().endOf('year').add(1, 'y');
                        switch (_getValue(Enums.Parameters.DirkParameters.VWD85)) {
                            case 4: // Enkel voor het lopende (na September)
                            case 5: // Enkel voor het lopende (voor september)
                                return _validateDateBetween(value, Date.Yesterday(), huidigJaar_Eind);
                            case 3: // Dagpas voor volgend jaar mogelijk
                                return _validateDateBetween(value, Date.Yesterday(), volgendJaar_Eind);
                            case 2: // Dagpas voor huidig en volgend jaar mogelijk
                                return _validateDateBetween(value, Date.Yesterday(), volgendJaar_Eind);
                            case 6: // Geen dagpas voor lopende en voor volgende (na September)
                            case 7: // Geen dagpas voor lopende en voor volgende (voor September)
                                return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_DAGPAS_02')]);
                            case 1: // Enkel tarief van huidig jaar bekijken
                                return new ValidationResult(ValidationResult.Error, []);
                            case null:
                            default:
                                return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_DAGPAS_01')]);
                        }
                    case Enums.AanvraagType.Registratie:
                        compare = Date.Yesterday();
                        return _validateDateAfter(value, compare);
                    case Enums.AanvraagType.Vrijstelling:
                        compare = Date.Yesterday();
                        return _validateDateAfter(value, compare);
                }

                var kd1 = parameterService.get(Enums.Parameters.Kanteldatum1);
                var kd2 = parameterService.get(Enums.Parameters.Kanteldatum2);
                var kanteldatum1 = angular.isDefined(kd1) ? moment(kd1, 'DD/MM/YYYY').toDate() : null;
                var kanteldatum2 = angular.isDefined(kd2) ? moment(kd2, 'DD/MM/YYYY').toDate() : null;

                if (kanteldatum1 !== null || kanteldatum2 !== null) {
                    if (
                        parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingDieselEuro4) ||
                        parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingInwonerDE4) ||
                        parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingWerken) ||
                        parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingAmbulanteHandel) ||
                        parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingNoodsituatie) ||
                        parameterService.equals(Enums.Parameters.AanvraagSoort, Enums.AanvraagSoort.ToelatingOldtimer)
                    ) {
                        result = _validateDateAfter(value, compare);
                    } else if (kanteldatum1 !== null && !parameterService.get(Enums.Parameters.Verstrenging)) {
                        var vandaag = new Date();
                        if ((vandaag < kanteldatum1) ||
                            (kanteldatum2 !== null && vandaag >= kanteldatum1 && vandaag < kanteldatum2)) {
                            var endDate = new Date('31-12-2019'.replace(/(\d{2})-(\d{2})-(\d{4})/, '$2/$1/$3'));
                            result = _validateDateBefore(value, endDate);
                            if (result.isValid()) {
                                result = _validateDateAfter(value, compare);
                            }
                        }
                    } else if (kanteldatum2 !== null && parameterService.get(Enums.Parameters.Verstrenging)) {
                        if (vandaag >= kanteldatum2) {
                            result = _validateDateAfter(value, kanteldatum2);
                        }
                        else if (kanteldatum1 !== null && vandaag >= kanteldatum1 && vandaag < kanteldatum2) {
                            result = _validateDateAfter(value, kanteldatum1);
                        }
                    }
                    if (!result.isValid()) return result;
                } else {
                    result = _validateDateAfter(value, compare);
                    if (!result.isValid()) return result;
                }

                return ValidationResult.CreateSuccessResult();
            }]);
            _validators[Enums.Parameters.EindDatum] = new Validator([
                function (value) {
                    var result = _validateDate(value);
                    if (!result.isValid()) return result;

                    var beginDatum = _getValue(Enums.Parameters.BeginDatum);

                    result = _validateDateAfter(value, beginDatum);
                    if (!result.isValid()) return result;

                    return ValidationResult.CreateSuccessResult();
                }]);
            // Titularis
            _validators[Enums.Parameters.Titularis.Naam] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Titularis.Voornaam] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Titularis.Straat] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 100); }]);
            _validators[Enums.Parameters.Titularis.HuisNummer] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Titularis.Bus] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Titularis.Postcode] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Titularis.Gemeente] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 100); }]);

            // Aanvrager
            _validators[Enums.Parameters.Aanvrager.RijksregisterNummer] = new Validator([_validateRijksregisterNummer]);
            _validators[Enums.Parameters.Aanvrager.Email] = new Validator([_validateEmail, function (value) { return _validateMaxLength(value, 255); }]);
            _validators[Enums.Parameters.Aanvrager.Telefoon] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Aanvrager.Naam] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Aanvrager.Voornaam] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Aanvrager.Straat] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 100); }]);
            _validators[Enums.Parameters.Aanvrager.HuisNummer] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Aanvrager.Bus] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Aanvrager.Postcode] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Aanvrager.Gemeente] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 100); }]);
            _validators[Enums.Parameters.Aanvrager.Email2] = new Validator([_validateEmail, function (value) { return _validateMaxLength(value, 255); }]);

            // Fakturatie
            _validators[Enums.Parameters.Bedrijf.BTWNummer] = new Validator([_validateBTWNummer]),
                _validators[Enums.Parameters.Bedrijf.Naam] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Bedrijf.Straat] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 100); }]);
            _validators[Enums.Parameters.Bedrijf.HuisNummer] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Bedrijf.Bus] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Bedrijf.Postcode] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Bedrijf.Gemeente] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 100); }]);

            // Gehandicapte
            _validators[Enums.Parameters.Gehandikapte.Vervaldatum] = new Validator([function (value) {
                if (angular.isNullOrWhitespace(value)) return ValidationResult.CreateSuccessResult();
                return _validateDate(value);
            }]);
            _validators[Enums.Parameters.Gehandikapte.RijksregisterNummer] = new Validator([_validateRijksregisterNummer]);
            _validators[Enums.Parameters.Gehandikapte.Naam] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Gehandikapte.Voornaam] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Gehandikapte.Straat] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 100); }]);
            _validators[Enums.Parameters.Gehandikapte.HuisNummer] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Gehandikapte.Bus] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 20); }]);
            _validators[Enums.Parameters.Gehandikapte.Postcode] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 50); }]);
            _validators[Enums.Parameters.Gehandikapte.Gemeente] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 100); }]);

            // OPDR
            _validators[Enums.Parameters.Opdracht.Begin] = new Validator([_validateDate]);
            _validators[Enums.Parameters.Opdracht.Einde] = new Validator([function (value) {
                var result = _validateDate(value);
                if (!result.isValid()) return result;

                // Na start datum LEZ
                var compare = Constants.Datums.getLEZBoeteDatum();
                result = _validateDateAfter(value, compare);
                if (!result.isValid()) return result;

                // Na start datum
                compare = _getValue(Enums.Parameters.Opdracht.Begin);
                if (angular.isDate(compare))
                    return _validateDateAfter(value, compare);
                else
                    return ValidationResult.CreateSuccessResult();
            }]);
            _validators[Enums.Parameters.Opdracht.Opdrachtgever] = new Validator([_validateCode]);
            _validators[Enums.Parameters.Opdracht.OpdrachtgeverNoodsituatie] = new Validator([_validateCode]);

            // Betaling
            _validators[Enums.Parameters.Betaling.TitularisRekening] = new Validator([_validateNullOrWhitespace, function (value) { return _validateMaxLength(value, 255); }]);
            _validators[Enums.Parameters.Betaling.Iban] = new Validator([_validateIban, function (value) { return _validateMaxLength(value, 34); }]);
            _validators[Enums.Parameters.Betaling.Bic] = new Validator([_validateBIC, function (value) { return _validateMaxLength(value, 30); }]);

            // Keuzes
            _validators[Enums.Parameters.Keuzes.Lus] = new Validator([function (value) {
                // Store our selected option in a new parameter for later use.
                parameterService.set(Enums.Parameters.SelectedRequestOption, value);

                switch (value) {
                    case '1': // Automatische Registratie
                    case '6': // Oldtimer
                    case '9': // Toelating Euro 3
                    case '11': // Dagkaart
                    case '12': // DL-indienen
                    case '13': // DL-indienen
                    case '14': // DL-indienen
                        // Niet lussen
                        return new ValidationResult(ValidationResult.Error, []);
                    case undefined:
                    case null:
                        // Niet ingevuld
                        return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01B')]);
                    default:
                        return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01')]);
                }
            }]);

            // Andere
            _validators[Enums.Parameters.Gebruiker.HerhalingEmail] = new Validator([function (value) {
                var result = _validateNullOrWhitespace(value);
                if (!result.isValid()) {
                    // LEZ-1000 - Indien beiden niet ingevuld = OK
                    if (_getValue(Enums.Parameters.Kanaal) === Enums.Kanaal.InformatieKiosk && angular.isNullOrWhitespace(_getValue(Enums.Parameters.Aanvrager.Email)))
                        return ValidationResult.CreateSuccessResult();
                    else
                        return result;
                }
                return _validateMatch(value, _getValue(Enums.Parameters.Aanvrager.Email), true);
            }]);
            _validators[Enums.Parameters.Bijlagen.Bijlagen] = new Validator([_validateBestandsNaam]);
            _validators[Enums.Parameters.Medewerker.Opmerking] = new Validator([function (value) { return _validateMaxLength(value, 500); }]);
            // LEZ-1291 Kortingen voor boetes validaties
            _validators[Enums.Parameters.BoeteNummer] = new Validator([function (value) {
                // First remove any spaces and any character that is not a number or a letter.
                if (value) {
                    var sanitizedValue = value.replace(/[^A-Z0-9]/ig, "");
                    var numberMatch = /^[0-9]+$/;

                    if (sanitizedValue.length === 12) {
                        // check if Sigmax fine number
                        if (sanitizedValue.match(numberMatch)) {
                            if (sanitizedValue.substring(0, 1) === '4' || sanitizedValue.substring(0, 1) === '6') {
                                var firstTen = sanitizedValue.substring(0, 10);
                                var lastTwo = parseInt(sanitizedValue.slice(-2));

                                var remainder = firstTen % 97;

                                if (remainder === lastTwo || remainder === 0 && lastTwo === 97) { 
                                    return ValidationResult.CreateSuccessResult();
                                }
                            }

                            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BOETENUMMER_01')]);
                        } else {
                            // check if Modero fine number
                            var firstTwo = sanitizedValue.substring(0, 2);
                            var leza = sanitizedValue.substring(2, 6);
                            var lastSix = sanitizedValue.slice(-6);

                            if (firstTwo.match(numberMatch) && firstTwo > 18 && leza === 'LEZA' && lastSix.match(numberMatch)) {
                                return ValidationResult.CreateSuccessResult();
                            } else {
                                return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BOETENUMMER_01')]);
                            }
                        }
                    } else {
                        return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BOETENUMMER_01')]);
                    }
                }

                return _validateNullOrWhitespace(value);
            }]);
        }


        /* Private Methods */
        function _setValues(values) {
            if (!angular.isObject(values)) values = {};
            _values = values;
        }

        function _getValue(param) {
            var value = _values[param];
            if (angular.isDefined(value)) return value;

            return parameterService.get(param);
        }

        function _validateMatch(value, otherValue, caseInsensitive) {
            if (!caseInsensitive || !angular.isString(value) || !angular.isString(otherValue)) {
                // Case Sensitive, or not Strings
                if (value !== otherValue)
                    return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_03')]);
            }
            else {
                value = value.toLowerCase();
                otherValue = otherValue.toLowerCase();
                // Case Insensitive
                if (value !== otherValue)
                    return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_03')]);

            }

            return ValidationResult.CreateSuccessResult();
        }

        function _validateNullOrWhitespace(value, isDropdown) {
            if (angular.isNullOrWhitespace(value))
                return new ValidationResult(ValidationResult.Error, [validationMessageService.get(isDropdown ? 'VAL_01B' : 'VAL_01A')]);

            return ValidationResult.CreateSuccessResult();
        }

        function _validateMaxLength(value, length) {
            if (angular.isString(value) && value.length > length) {
                var message = validationMessageService.get('VAL_02');
                message.setValues(length);
                return new ValidationResult(ValidationResult.Error, [message]);
            }

            return ValidationResult.CreateSuccessResult();
        }

        function _validateNumber(value) {
            var match = ('' + value).match(/^\-?[\d]+\.[\d]+$/);
            if (match) return ValidationResult.CreateSuccessResult();
            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_NUM_01A')]);
        }

        function _validatePositiveNumber(value) {
            var match = ('' + value).match(/^[\d]+[\.]?[\d]*$/);
            if (match) return ValidationResult.CreateSuccessResult();
            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_NUM_01B')]);
        }

        function _validateInterger(value) {
            var match = ('' + value).match(/^\-?[\d]+$/);
            if (match) return ValidationResult.CreateSuccessResult();
            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_NUM_01C')]);
        }

        function _validatePositiveInteger(value) {
            var match = ('' + value).match(/^[\d]+$/);
            if (match) return ValidationResult.CreateSuccessResult();
            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_NUM_01D')]);
        }

        function _validateNumberLargerEquals(value, compare) {
            if (angular.isString(value)) value = parseFloat(value);
            if (angular.isNumber(value) && value >= compare) return ValidationResult.CreateSuccessResult();
            var message = validationMessageService.get('VAL_NUM_02A');
            message.setValues(compare);
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _validateNumberLarger(value, compare) {
            if (angular.isNumber(value) && value > compare) return ValidationResult.CreateSuccessResult();
            var message = validationMessageService.get('VAL_NUM_02B');
            message.setValues(compare);
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _validateNumberSmallerEquals(value, compare) {
            if (angular.isNumber(value) && value <= compare) return ValidationResult.CreateSuccessResult();
            var message = validationMessageService.get('VAL_NUM_03A');
            message.setValues(compare);
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _validateNumberSmaller(value, compare) {
            if (angular.isNumber(value) && value < compare) return ValidationResult.CreateSuccessResult();
            var message = validationMessageService.get('VAL_NUM_03B');
            message.setValues(compare);
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _validateCode(value) {
            if (angular.isObject(value) && angular.isDefined(value.id) && value.id > 0)
                return ValidationResult.CreateSuccessResult();

            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01B')]);
        }

        function _validateDate(value) {
            if (angular.isDate(value)) return ValidationResult.CreateSuccessResult();

            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_DAT_01')]);
        }

        function _validateDateBeforeExcluding(value, compare) {
            if (angular.isDate(value) && value.isBefore(compare)) return ValidationResult.CreateSuccessResult();
            var message = validationMessageService.get('VAL_DAT_03B');
            message.setValues(formatterService.toDisplayValue(compare));
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _validateDateBefore(value, compare) {
            if (angular.isDate(value) && value.isSameOrBefore(compare)) return ValidationResult.CreateSuccessResult();
            var message = validationMessageService.get('VAL_DAT_03A');
            message.setValues(formatterService.toDisplayValue(compare));
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _validateDateAfterExcluding(value, compare) {
            if (angular.isDate(value) && value.isAfter(compare)) return ValidationResult.CreateSuccessResult();
            var message = validationMessageService.get('VAL_DAT_02B');
            message.setValues(formatterService.toDisplayValue(compare));
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _validateDateAfter(value, compare) {
            if (angular.isDate(value) && value.isSameOrAfter(compare)) return ValidationResult.CreateSuccessResult();
            var message = validationMessageService.get('VAL_DAT_02A');
            message.setValues(formatterService.toDisplayValue(compare));
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _validateDateBetween(value, start, end) {
            var message;
            if (!angular.isDate(value)) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_DAT_01')]);

            var result = ValidationResult.CreateSuccessResult();
            if (value.isBefore(start)) {
                result.result = ValidationResult.Error;
                message = validationMessageService.get('VAL_DAT_02A');
                message.setValues(formatterService.toDisplayValue(start));
                result.messages.push(message);
            }
            if (value.isAfter(end)) {
                result.result = ValidationResult.Error;
                message = validationMessageService.get('VAL_DAT_03A');
                message.setValues(formatterService.toDisplayValue(end));
                result.messages.push(message);
            }
            return result;
        }

        function _valideerNummerplaat(npl) {
            if (angular.isNullOrWhitespace(npl)) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01A')]);
            if (angular.isString(npl) === false) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01')]);

            npl = npl.replace(/[\-\s]/g, ''); // Ignore - and whitespace
            npl = npl.toUpperCase();

            var matches = npl.match(/[^A-Z\u00c4\u00d6\u00dc\d]/);
            if (matches)
                return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_NPL_01')]);

            return ValidationResult.CreateSuccessResult();
        }

        function _validateRijksregisterNummer(rrnr) {
            if (angular.isNullOrWhitespace(rrnr)) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01A')]);
            if (angular.isString(rrnr) === false) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01')]);

            rrnr = rrnr.replace(/[\.\-\s]/g, ''); // Ignore . - and whitespace

            var matches = rrnr.match(/([a-z]+)/i);
            if (matches) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_RR_01')]);

            if (rrnr.length !== 11) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_RR_02')]);

            var checkDigit = parseInt(rrnr.substr(rrnr.length - 2, 2));
            var modFunction = function (nr) { return 97 - (nr % 97); };
            var nrToCheck = parseInt(rrnr.substr(0, 9));

            // first check without 2
            if (modFunction(nrToCheck) === checkDigit) return ValidationResult.CreateSuccessResult();

            // then check with 2 appended for y2k+ births
            nrToCheck = parseInt('2' + rrnr.substr(0, 9));

            if (modFunction(nrToCheck) === checkDigit) return ValidationResult.CreateSuccessResult();

            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_RR_03')]);
        }

        function _validateEmail(email) {
            if (angular.isNullOrWhitespace(email)) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01A')]);
            if (angular.isString(email) === false) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01')]);

            var matches = email.match(/\s/);
            if (matches) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_EMAIL_01')]);

            matches = email.match(/^(([A-Za-z0-9']+_+)|([A-Za-z0-9']+\-+)|([A-Za-z0-9']+\.+)|([A-Za-z0-9']+\++)|([A-Za-z0-9']+\+_))*[A-Za-z0-9'\+_\.\-]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,20}$/i);
            if (matches) return ValidationResult.CreateSuccessResult();

            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_EMAIL_01')]);
        }

        function _validateIban(iban) {
            if (angular.isNullOrWhitespace(iban)) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01A')]);
            if (angular.isString(iban) === false) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01')]);

            if (IBAN.isValid(iban)) return ValidationResult.CreateSuccessResult();

            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BANK_01')]);

        }

        function _validateBIC(bic) {
            if (angular.isNullOrWhitespace(bic)) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01A')]);
            if (angular.isString(bic) === false) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01')]);

            bic = bic.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();

            if (bic.length !== 8 && bic.length !== 11) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BANK_02')]);

            var matches = bic.match(/^[A-Z]{6}[A-Z0-9]{2}([a-z]{3})?$/);
            if (matches)
                return ValidationResult.CreateSuccessResult();

            return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BANK_03')]);
        }

        function _validateBTWNummer(btw) {
            var message;
            if (angular.isNullOrWhitespace(btw)) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01A')]);
            if (angular.isString(btw) === false) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01')]);

            btw = btw.replace(/[\.\-\s]/g, '').toUpperCase(); // Ignore . - and whitespace

            var matches = btw.match(/[^A-Z\d]/);
            if (matches) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BEDRIJF_04')]);


            var _lengths = {
                'AT': 11,
                'BE': 12,
                'BG': [11, 12],
                'CY': 9,
                'CZ': [10, 11, 12],
                'DE': 11,
                'DK': 10,
                'EE': 11,
                'EL': 11,
                'ES': 11,
                'FI': 10,
                'FR': 13,
                'GB': [7, 11, 14],
                'HR': 13,
                'HU': 10,
                'IE': 10,
                'IT': 13,
                'LT': [11, 14],
                'LU': 10,
                'LV': 13,
                'MT': 10,
                'NL': 14,
                'PL': 12,
                'PT': 11,
                'RO': [4, 5, 6, 7, 8, 9, 10, 11, 12],
                'SE': 14,
                'SI': 10,
                'SK': 12
            };

            var land = (btw.length < 2) ? undefined : btw.substr(0, 2).toUpperCase();
            if (_getValue(Enums.Parameters.Bedrijf.Land) === 'BE') land = 'BE'; // LEZ-946
            var lengthToCheck = _lengths[land];
            if (angular.isUndefined(lengthToCheck)) {
                var maxLength = 25;
                if (btw.length > maxLength) {
                    message = validationMessageService.get('VAL_02');
                    message.setValues(maxLength);
                    return new ValidationResult(ValidationResult.Error, [message]);
                }
            }
            else if (angular.isArray(lengthToCheck)) {
                var valid = false;
                for (var i = 0, l = lengthToCheck.length; i < l; ++i) {
                    if (btw.length === lengthToCheck[i]) {
                        valid = true;
                        break;
                    }
                }

                if (!valid) {
                    message = validationMessageService.get('VAL_BEDRIJF_03B');
                    var last = lengthToCheck.pop();
                    message.setValues(lengthToCheck, last);
                    return new ValidationResult(ValidationResult.Error, [message]);
                }

            }
            else {
                if (btw.length !== lengthToCheck) {
                    message = validationMessageService.get('VAL_BEDRIJF_03A');
                    message.setValues(lengthToCheck);
                    return new ValidationResult(ValidationResult.Error, [message]);
                }
            }

            if (land === 'BE') {
                if (btw.substr(0, 3) !== 'BE0')
                    return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BEDRIJF_02')]);

                var checkDigit = parseInt(btw.substr(btw.length - 2, 2));
                var modFunction = function (nr) { return 97 - (nr % 97); };
                var nrToCheck = parseInt(btw.substr(3, 7));

                if (modFunction(nrToCheck) !== checkDigit)
                    return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_BEDRIJF_02')]);
            }

            return ValidationResult.CreateSuccessResult();
        }

        function _validateBestandsNaam(fileName) {
            var message;
            if (angular.isNullOrWhitespace(fileName)) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01A')]);
            if (angular.isString(fileName) === false) return new ValidationResult(ValidationResult.Error, [validationMessageService.get('VAL_01')]);
            if (fileName.length > 250) {
                message = validationMessageService.get('VAL_02');
                message.setValues(250);
                return new ValidationResult(ValidationResult.Error, [message]);
            }

            var matches = fileName.match(/^[a-zA-Z\d\-\_ ]+\.[a-zA-Z\d]+$/);
            if (matches)
                return ValidationResult.CreateSuccessResult();

            message = validationMessageService.get('VAL_FILE_01');
            message.setValues(fileName);
            return new ValidationResult(ValidationResult.Error, [message]);
        }

        function _isDropdownValue(param) {
            switch (param) {
                case Enums.Parameters.Kanaal:
                case Enums.Parameters.Voertuig.EuronormGecorrigeerdAndere:
                case Enums.Parameters.Voertuig.EuronormGecorrigeerdLandbouw:
                case Enums.Parameters.Voertuig.Land:
                case Enums.Parameters.Voertuig.GelijkvormigheidscodeAndere:
                case Enums.Parameters.Voertuig.GelijkvormigheidscodeLandbouw:
                case Enums.Parameters.Voertuig.Gelijkvormigheidscode:
                    return true;
                default:
                    return false;
            }
        }

        /* Public methods */
        function _okResult() {
            return ValidationResult.CreateSuccessResult();
        }

        function _validate(param, values) {
            _setValues(values);

            var value = values[param];
            var validator = _validators[param];

            if (angular.isDefined(validator))
                return validator.validate(value); // A Specific Validator
            else
                return _validateNullOrWhitespace(value, _isDropdownValue(param)); // Default Validation
        }

        function _validateOverlap(values) {
            var extraParams = [];
            angular.forEach(values, function (value, key) { extraParams.push({ key: key, value: value }); });

            var beginDatum = values.BDAT ? values.BDAT : '';
            var eindDatum = values.EDAT ? values.EDAT : '';

            var aanvraagNummer = parameterService.get(Enums.Parameters.BasisAanvraagNummer);
            if (aanvraagNummer && beginDatum && eindDatum) {
                return aanvraagService.validateOverlap(aanvraagNummer, beginDatum.format(), eindDatum.format()).then(function (result) {
                    var applicationEndDate = parameterService.get(Enums.Parameters.ApplicationEndDate);

                    if (result && beginDatum.isSameOrAfter(applicationEndDate)) {
                        return _okResult();
                    }

                    var message = validationMessageService.get('VAL_OVERL_01');
                    message.setValues(formatterService.toDisplayValue(beginDatum), formatterService.toDisplayValue(eindDatum));

                    return new ValidationResult(ValidationResult.Warning, [message]);
                }).catch(function (error) {
                    return _okResult();
                });
            } else {
                if (values.BDAT && values.EDAT) {
                    var query = {
                        CountryCode: parameterService.get(Enums.Parameters.Voertuig.Landcode),
                        LicensePlate: parameterService.get(Enums.Parameters.Voertuig.Nummerplaat),
                        FirstRegistrationDate: parameterService.get(Enums.Parameters.Voertuig.DatumEersteInschrijving),
                        startdate: values.BDAT,
                        enddate: values.EDAT
                    };

                    return aanvraagService.checkWhitelisted(query).then(function (response) {
                        if (response.data && response.data.WhitelistedApplications.length > 0) {
                            var sortedApplications = response.data.WhitelistedApplications.sort(function (a, b) {
                                return new Date(a.WhitelistEndDate) - new Date(b.WhitelistEndDate);
                            });

                            var lastApplication = sortedApplications[sortedApplications.length - 1];

                            var message = validationMessageService.get('VAL_OVERL_01');
                            message.setValues(formatterService.toDisplayValue(lastApplication.WhitelistStartDate), formatterService.toDisplayValue(lastApplication.WhitelistEndDate));

                            var extraInfo = validationMessageService.get('VAL_DAT_02A');
                            extraInfo.setValues(formatterService.toDisplayValue(moment(lastApplication.WhitelistEndDate).add(1, 'd').format()));

                            return new ValidationResult(ValidationResult.Warning, [message, extraInfo]);
                        } else {
                            return _okResult();
                        }
                    }).catch(function (error) {
                        return _okResult();
                    });
                } else {
                    var okResponse = new Promise(function (resolve, reject) {
                        resolve();
                    });

                    return okResponse.then(function () {
                        return _okResult();
                    });
                }
            }
        }

        function _getMinValue(param, values) {
            _setValues(values);

            function get(p) {
                switch (param) {
                    case Enums.Parameters.Voertuig.DatumEersteInschrijving:
                        return moment('1879-1-1', 'YYYY-MM-DD'); // Very First car
                    case Enums.Parameters.Voertuig.DatumLaatsteInschrijving:
                        var date = _getValue(Enums.Parameters.Voertuig.DatumEersteInschrijving);
                        date = angular.isDate(date) ? date : moment('1879-1-1', 'YYYY-MM-DD');
                        return date;
                    case Enums.Parameters.Voertuig.MaximaalToegelatenMassa:
                        return 500;
                    case Enums.Parameters.Voertuig.MassaRijklareToestand:
                        return 100;
                    case Enums.Parameters.Voertuig.BijkomendeZitplaatsen:
                    case Enums.Parameters.Voertuig.CO2Waarde:
                        return 0;
                    case Enums.Parameters.Voertuig.PartikelMassaWaarde:
                        return 0.001;
                    case Enums.Parameters.BeginDatum:
                        // LEZ-1108 - Anything goes
                        if (_getValue(Enums.Parameters.Kanaal) === Enums.Kanaal.BackOffice)
                            return undefined;

                        if (parameterService.get(Enums.Parameters.BasisAanvraagNummer)) {
                            var startDate = parameterService.get(Enums.Parameters.BeginDatum);
                            var dayBeforeStartDate = moment(startDate).subtract(1, 'd');
                            var endDate = parameterService.get(Enums.Parameters.ApplicationEndDate);

                            if (dayBeforeStartDate.isSameOrBefore(endDate)) {
                                return startDate;
                            } else {
                                return dayBeforeStartDate;
                            }
                        }

                        var type = _getValue(Enums.Parameters.AanvraagType);
                        switch (type) {
                            case Enums.AanvraagType.Dagpas: // TODO: Special validation
                                return Date.Yesterday();
                            case Enums.AanvraagType.Toelating:
                                var today = Date.Now();
                                var soort = _getValue(Enums.Parameters.AanvraagSoort);
                                switch (soort) {
                                    case Enums.AanvraagSoort.ToelatingInwonerDE4:
                                    case Enums.AanvraagSoort.ToelatingDieselEuro4:
                                        return Date.Yesterday();
                                    case Enums.AanvraagSoort.ToelatingAmbulanteHandel:
                                    case Enums.AanvraagSoort.ToelatingWerken:
                                    case Enums.AanvraagSoort.ToelatingNoodsituatie:
                                        switch (parameterService.get(Enums.Parameters.Voertuig.Euronorm)) {
                                            case '3':
                                            case '4':
                                                return Date.Yesterday();
                                        }
                                        break;
                                    default:
                                        return Date.Yesterday();
                                }

                                break;
                            case Enums.AanvraagType.Registratie:
                            case Enums.AanvraagType.Vrijstelling:
                                var soort = _getValue(Enums.Parameters.AanvraagSoort);
                                switch (soort) {
                                    case Enums.AanvraagSoort.RegistratieAnderType:
                                    case Enums.AanvraagSoort.VrijstellingPrioritairVoertuig:
                                    case Enums.AanvraagSoort.VrijstellingUitzonderlijkVervoer:
                                        if (_getValue(Enums.Parameters.Kanaal) === Enums.Kanaal.BackOffice) return undefined;
                                        else return Date.Yesterday();
                                    default:
                                        return Date.Yesterday();
                                } // Switch Soort
                        } // Switch Type
                        break;
                    case Enums.Parameters.EindDatum:
                        return _getValue(Enums.Parameters.BeginDatum);
                    case Enums.Parameters.Opdracht.Begin:
                        return moment('1980-1-1', 'YYYY-MM-DD'); // Some random date far enough in the past (sanity check)
                    case Enums.Parameters.Opdracht.Einde:
                        var begin = _getValue(Enums.Parameters.Opdracht.Begin);
                        var startLEZ = Constants.Datums.getLEZBoeteDatum();
                        if (!angular.isDate(begin)) return startLEZ;
                        else return startLEZ.isBefore(begin) ? begin : startLEZ;
                    case Enums.Parameters.Gehandikapte.Vervaldatum:
                        return moment('1800-1-1', 'YYYY-MM-DD'); // Some random date far enough in the past (sanity check)
                    default:
                        return undefined;
                }
            }

            // To prevent digestion loops, return EXACTLY the same object, unless it actually changed
            var value = get(param);
            if (!angular.isDate(value)) {
                // Geen deftige min waarde gedefineerd
                return undefined;
            }

            var huidig = _minValues[param];
            // Registreer indien andere datum
            if (!angular.isDate(huidig) || !value.isSame(huidig.toShortISOString(), 'day')) _minValues[param] = Date.FromMoment(value);

            return _minValues[param];
        }

        function _getMaxValue(param, values) {
            _setValues(values);

            function get(p) {
                switch (p) {
                    case Enums.Parameters.Voertuig.DatumEersteInschrijving:
                    case Enums.Parameters.Voertuig.DatumLaatsteInschrijving:
                        return Date.Now(); // Can not be in the future
                    case Enums.Parameters.BeginDatum:
                        // LEZ-1108 - Anything goes
                        if (_getValue(Enums.Parameters.Kanaal) === Enums.Kanaal.BackOffice)
                            return undefined;

                        var today = Date.Now();
                        var soort = _getValue(Enums.Parameters.AanvraagSoort);
                        switch (soort) {
                            case Enums.AanvraagSoort.ToelatingDagpas: // TODO: Special validation
                                break;
                            case Enums.AanvraagSoort.ToelatingInwonerDE4:
                            case Enums.AanvraagSoort.ToelatingDieselEuro4:
                                var LEZ2020StartDatum = Constants.Datums.getLEZ2020StartDatum();
                                if (parameterService.get(Enums.Parameters.Verstrenging) && today < LEZ2020StartDatum) {
                                    today = LEZ2020StartDatum;
                                }
                                break;
                            case Enums.AanvraagSoort.ToelatingWerken:
                            case Enums.AanvraagSoort.ToelatingAmbulanteHandel:
                            case Enums.AanvraagSoort.ToelatingNoodsituatie:
                                switch (parameterService.get(Enums.Parameters.Voertuig.Euronorm)) {
                                    case '2':
                                        return Constants.Datums.getEindDatum_2019();
                                    case '3':
                                    case '4':
                                        return Date.Yesterday().add(Config.aantalMaandAfdekking, 'M');
                                    default:
                                        if (parameterService.get(Enums.Parameters.Verstrenging) && today < Constants.Datums.getLEZ2020StartDatum()) {
                                            today = Constants.Datums.getLEZ2020StartDatum();
                                        }
                                }
                                break;
                            case Enums.AanvraagSoort.RegistratieRoetfilterDieselEuro3:
                                return Constants.Datums.getEindDatum_2019();
                            case Enums.AanvraagSoort.RegistratieTechnischeKenmerken:
                            case Enums.AanvraagSoort.RegistratieTechnischeKenmerkenBE:
                                if (parameterService.equals(Enums.Parameters.Voertuig.Euronorm, '4') && parameterService.equals(Enums.Parameters.Voertuig.BrandstofType, 'D')) {
                                    return Constants.Datums.getEindDatum_2019();
                                }
                                break;
                        } // Switch Soort
                        return today.add(Config.aantalMaandAfdekking, 'M'); // Binnen de X maand
                    default:
                        return undefined;
                }
            }

            // To prevent digestion loops, return EXACTLY the same object, unless it actually changed
            var value = get(param);
            if (!angular.isDate(value)) {
                // Geen deftige max waarde gedefineerd
                return undefined;
            }

            var huidig = _maxValues[param];
            // Registreer indien andere datum
            if (!angular.isDate(huidig) || !value.isSame(huidig.toShortISOString(), 'day')) _maxValues[param] = Date.FromMoment(value);

            return _maxValues[param];
        }


        return {
            okResult: _okResult,
            validate: _validate,
            validateOverlap: _validateOverlap,
            getMinValue: _getMinValue,
            getMaxValue: _getMaxValue
        };

    };

    theComponent.$inject = ['appConfig', 'appEnums', 'appConstants', 'ValidationResult', 'Validator', 'ValidationMessageService', 'FormatterService', 'ParameterService', 'ParameterHelperService', 'LEZErrorService', '$filter', 'AanvraagService'];

    angular.module('theApp').factory(componentName, theComponent);

})();
;
(function () {

    'use strict';

    var componentName = "AanvraagService";
    var theComponent = function (appService, appConfig, Enums, $http) {
        var _url = appConfig.apiUrl + "aanvragen/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */
        function _authentication(id) {
            return $http.get(_url + id + '/authentication').then(function (response) {
                return response.data;
            }, _onError);
        }

        function _getById(id, userdata) {
            userdata = angular.convertDatesToDateStrings(userdata);
            return $http.get(_url + id, { params: userdata }).then(function (response) {
                return angular.convertDateStringsToDates(response.data);
            }, _onError);
        }

        function _create(parameters) {
            return $http.post(_url, parameters)
                .then(function (response) {
                    return angular.convertDateStringsToDates(response.data);
                }, _onError);
        }

        function _update(parameters) {
            return $http.put(_url + parameters[Enums.Parameters.AanvraagNummer], parameters)
                .then(function (response) {
                    return angular.convertDateStringsToDates(response.data);
                }, _onError);
        }

        function _remove(id) {
            return $http({ method: 'DELETE', url: _url + id })
                    .then(function (response) {
                        return response.data;
                    }, _onError);
        }

        function _validateOverlap(id, beginDatum, eindDatum) {
            var data = {
                "validateOverlapModel": {
                    "looptijdStart": new Date(beginDatum),
                    "looptijdEind": new Date(eindDatum)
                }
            };

            return $http.post(_url + "validateoverlap/" + id, data).then(function (response) {
                return response.data;
            }, _onError);
        }

        function _checkWhitelisted(query) {
            query = angular.convertDatesToDateStrings(query);
            return $http.get(_url + "whitelisted", { params: query });
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            authentication: _authentication,
            getById: _getById,
            create: _create,
            update: _update,
            remove: _remove,
            validateOverlap: _validateOverlap,
            checkWhitelisted: _checkWhitelisted
        };

    };

    theComponent.$inject = ['AppService', 'appConfig', 'appEnums', '$http'];

    angular.module('theApp').factory(componentName, theComponent);

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

    var serviceName = "AddressService";
    var theRepository = function (logger, appConfig, $http) {
        var _url = appConfig.apiUrl + "address/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */
        function _get(postcode, gemeente, taal) {
            return $http({
                url: _url,
                method: 'GET',
                params: { postcode: postcode, gemeente: gemeente, taal: taal }
            }).then(function (response) { return response.data; }, _onError);            
        }

        /* +++++ public interface +++++ */

        logger.creation(serviceName);

        return {
            get: _get
        };
    };

    theRepository.$inject = ['Logger', 'appConfig', '$http'];
    angular.module('theApp').factory(serviceName, theRepository);
})();;
(function () {
    'use strict';

    var serviceName = "BijlageService";
    var theRepository = function (logger, appConfig, $http, fileService, Bijlage) {

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data)) {
                    if (response.data instanceof ArrayBuffer) {
                        var json = new TextDecoder('utf-8').decode(response.data);
                        throw angular.fromJson(json);
                    }
                    else throw response.data;
                }
                else
                    throw response;
            }
            else
                throw {};
        }

        function _getUrl(aanvraagId) {
            return appConfig.apiUrl + "aanvragen/" + aanvraagId + "/bijlagen/";
        }

        function _getAll(aanvraagId) {
            return $http.get(_getUrl(aanvraagId))
                                        .then(function (response) { return response.data; }, _onError)
                                        .then(Bijlage.apiResponseTransformer);
        }

        function _getById(aanvraagId, id) {
            return $http.get(_getUrl(aanvraagId) + id)
                                       .then(function (response) { return response.data; }, _onError)
                                       .then(Bijlage.apiResponseTransformer);
        }

        function _download(aanvraagId, id) {
            return $http.get(_getUrl(aanvraagId) + id + "/download", { responseType: "arraybuffer" })
                                       .then(function (response) {
                                           var contentType = response.headers('content-type') || 'application/octet-stream';
                                           var fileName = Object.parseFileName(response.headers);
                                           fileService.viewInBrowser(fileName, contentType, response.data);
                                       }, _onError);
        }

        function _add(aanvraagId, bijlage) {
            return $http({
                        method: "POST",
                        url: _getUrl(aanvraagId),
                        headers: { 'Content-Type': undefined },
                        transformRequest: function (data) {
                            var formData = new FormData();
                            formData.append("model", angular.toJson(data.model));
                            formData.append("file", data.file);
                            return formData;
                        },
                        data: { model: bijlage.GetModel(), file: bijlage.GetData() },
                        file: bijlage.GetData()
                    })
                    .then(function (response) { return response.data; }, _onError)
                    .then(Bijlage.apiResponseTransformer);
        }

        function _remove(aanvraagId, bijlageId) {
            return $http.delete(_getUrl(aanvraagId) + bijlageId).then(undefined, _onError);
        }

        /* +++++ public interface +++++ */

        logger.creation(serviceName);

        return {
            getAll: _getAll,
            getById: _getById,
            download: _download,
            add: _add,
            remove: _remove
        };
    };

    theRepository.$inject = ['Logger', 'appConfig', '$http', 'FileService', 'Bijlage'];
    angular.module('theApp').factory(serviceName, theRepository);
})();;
(function() {

    'use strict';

    var componentName = "ChatService";
    var theComponent = function(logger, appConfig, $http) {
        var _url = appConfig.apiUrl + "chat/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ private +++++ */
        
        function _checkChatServiceStatus() {
            return $http.get(_url + "status").then(function (response) {
                return response;
            }, _onError);
        }

        function _checkChatAvailable(taal) {
            return $http.get(_url + "available?taal=" + taal).then(function (response) {
                return response;
            }, _onError);
        }

        function _getChatUrl(taal) {
            return $http.get(_url + "url?taal=" + taal).then(function (response) {
                return response;
            }, _onError);
        }
        
        /* +++++ public interface +++++ */

        logger.creation(componentName);

        return {
            checkChatServiceStatus: _checkChatServiceStatus,
            checkChatAvailable: _checkChatAvailable,
            getChatUrl: _getChatUrl
        };

    };

    theComponent.$inject = ['Logger', 'appConfig', '$http'];

    angular.module('theApp').factory(componentName, theComponent);

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

    var serviceName = "CodeService";
    var theRepository = function (logger, appConfig, $http, Code) {
        var _url = appConfig.apiUrl + "code/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */
        function _getByCodeSoort(codeSoort) {
            return $http.get(_url + "soort/" + codeSoort).then(function (response) { return response.data; }, _onError)
                                                         .then(Code.apiResponseTransformer);
        }

        function _getById(id) {
            return $http.get(_url + id).then(function (response) { return response.data; }, _onError)
                                       .then(Code.apiResponseTransformer);
        }

        function _getByTechnischeSleutel(sleutel) {
            return $http.get(_url + "technischesleutel/" + sleutel).then(function (response) { return response.data; }, _onError)
                                                                   .then(Code.apiResponseTransformer);
        }

        /* +++++ public interface +++++ */

        logger.creation(serviceName);

        return {
            getByCodeSoort: _getByCodeSoort,
            getById: _getById,
            getByTechnischeSleutel: _getByTechnischeSleutel
        };
    };

    theRepository.$inject = ['Logger', 'appConfig', '$http', 'Code'];
    angular.module('theApp').factory(serviceName, theRepository);
})();;
(function () {
    'use strict';

    var serviceName = "DagpasService";
    var theRepository = function (logger, appConfig, $http) {
        var _url = appConfig.apiUrl + "dagpas/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */
        function _searchCount(parameters) {
            return $http.post(_url + "searchcount/", parameters).then(function (response) { return response.data; }, _onError);
        }

        function _controle(parameters) {
            return $http.post(_url + "controle/", parameters).then(function (response) { return response.data; }, _onError);
        }

        /* +++++ public interface +++++ */

        logger.creation(serviceName);

        return {
            searchCount: _searchCount,
            controle: _controle
        };
    };

    theRepository.$inject = ['Logger', 'appConfig', '$http'];
    angular.module('theApp').factory(serviceName, theRepository);
})();;
(function () {

    'use strict';

    var componentName = "ErrorMessageService";
    var theComponent = function (appConfig, $http, ErrorMessage) {
        var _url = appConfig.apiUrl + "messages/error/";

        var _call = { status: false };

        var _messages = [
            new ErrorMessage('ERR_EX_01', 'Er is een ongekende fout opgetreden.', 'An unknown error occured. $0', 'Une erreur inconnue s\'est produite.', 'Ein unbekannter Fehler aufgetreten.'),
            new ErrorMessage('ERR_EX_02', 'De toepassing kon niet worden geladen. Probeer later nog eens.', 'Could not load the application. Try again later.', 'L\'application ne peut ëtre chargé. Veuillez réessayer plus tard.', 'Die Anwendung konnte nicht geladen werden. Versucchen Sie es später noch einmal.')
        ];

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        function _getAll() {
            return $http.get(_url).then(function (response) { return response.data; }, _onError)
                                  .then(ErrorMessage.apiResponseTransformer);
        }

        /* +++++ exposed methods +++++ */
        function _init() {
            if (_call.status) return _call.promise;

            _call.promise = _getAll().then(function (messages) {
                if (!angular.isArray(messages) || messages.length < 2)
                    throw _get('ERR_EX_02');
                _messages = messages;
            });
            _call.status = true;

            _call.promise.then(function () { _call.status = true; }, function () { _call.status = false; });

            return _call.promise;
        }

        function _get(identifier) {
            var result = _.find(_messages, { id: identifier });
            if (angular.isDefined(result)) return angular.copy(result);
            else if (identifier !== 'ERR_EX_01') return _get('ERR_EX_01');
        }

        /* +++++ public interface +++++ */

        return {
            init: _init,
            get: _get
        };

    };

    theComponent.$inject = ['appConfig', '$http', 'ErrorMessage'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function () {

    'use strict';

    var componentName = "GebruikerService";
    var theComponent = function (appService, appConfig, $http) {
        var _url = appConfig.apiUrl + "gebruiker/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */
        function _getUserData(authCode) {
            return $http.get(_url + authCode).then(function (response) { return response.data; }, _onError);
        }

        function _validateMedewerkerData(token) {
            return $http.get(_url + "medewerker?token=" + window.encodeURIComponent(token)).then(function (response) { return response.data; }, _onError);
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            getUserData: _getUserData,
            validateMedewerkerData: _validateMedewerkerData
        };

    };

    theComponent.$inject = ['AppService', 'appConfig', '$http'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function () {

    'use strict';

    var componentName = "InfokioskService";
    var theComponent = function (logger, appConfig, Enums, $http, $q, $timeout, $rootScope, parameterService, errorService, blockUI) {
        var _url = appConfig.apiUrl + "infokiosk/";
        var maxRetries = 60;

        $rootScope.$on(Enums.Parameters.Taal, function () {
            if (!parameterService.equals(Enums.Parameters.Kanaal, Enums.Kanaal.InformatieKiosk)) return;

            $http.post(_url + 'taal', parameterService.getParametersObject());
        });

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        // Process: Type of process, startErrorAction: Action executed when the StartProcess failed, statusErrorAction: Action executed when the failed status poll retries exceeds the limit.
        function _startProcess(process, startErrorAction, statusErrorAction) {
            var deferred = $q.defer();
            var retries = 0;

            function onStartError(response) {
                var error = {};
                if (angular.isObject(response) && angular.isObject(response.data)) {
                    error = response.data;
                }
                startErrorAction(error);
                deferred.reject(response);
            }

            function onStatusError(response) {
                var error = {};
                if (angular.isObject(response) && angular.isObject(response.data)) {
                    error = response.data;
                }
                statusErrorAction(error);
                deferred.reject(response);
            }

            function getStatus() {
                $http.get(_url + process + '/' + parameterService.get(Enums.Parameters.Kiosk.SessieId))
                    .then(pollStatus) // Allow for pollStatus to process the status
                    .then(undefined, function (reason) {
                            ++retries;
                            if (retries > maxRetries) onStatusError(reason);
                            else pollStatus();  // Fake it till you make it
                        });
            }

            function pollStatus(result) {
                console.log("Status poll - " + result); // To prevent a 'Timeout' during status polls, we log to the console
                if (!angular.isDefined(result) || !angular.isDefined(result.data)) {
                    // No valid data, retry poll
                    $timeout(getStatus, 3000); // 3s delay on errors - resulting in 3s x 60 = 3 min wait max.
                    return;
                }

                switch (result.data) {
                    case Enums.InfokioskStatus.Bezig:
                        // Keep polling untill we are no longer 'InProgress'
                        $timeout(getStatus, 1000);
                        break;
                    case Enums.InfokioskStatus.Initieel:
                    case Enums.InfokioskStatus.Klaar:
                    case Enums.InfokioskStatus.Geannuleerd:
                    case Enums.InfokioskStatus.Fout:
                        deferred.resolve(result.data);
                        break;
                    default:
                        // On Invalid results, act like an arror occured
                        throw "Invalid Status";
                }
            }

            $http.post(_url + process, parameterService.getParametersObject())
                .then(function (result) {
                    result = result.data;
                    // Params updaten
                    if (!angular.isNullOrWhitespace(result[Enums.Parameters.Kiosk.SessieId]))
                        parameterService.set(Enums.Parameters.Kiosk.SessieId, result[Enums.Parameters.Kiosk.SessieId]);

                    getStatus();
                }, onStartError);

            return deferred.promise;
        }

        /* +++++ private +++++ */

        function _getKioskInfo(kioskId) {
            return $http.get(_url + kioskId + '/details/').then(function (response) {
                return response.data;
            }, _onError);
        }

        function _startScan() {
            blockUI.start('ikscan');
            var result = _startProcess('scan', function (error) { errorService.error('ERR_IK_10', error.ErrorCodes); }, function (error) { errorService.error('ERR_IK_12', error.ErrorCodes); });
            result.finally(function () { blockUI.stop(); });
            return result;
        }

        function _startPayment() {
            blockUI.start('ikpay');
            var result = _startProcess('pay', function (error) { errorService.error('ERR_IK_20', error.ErrorCodes); }, function (error) { errorService.error('ERR_IK_22', error.ErrorCodes); });
            result.finally(function () { blockUI.stop(); });
            return result;
        }

        function _startPrint() {
            blockUI.start('ikprint');
            var result = _startProcess('print', function (error) { errorService.error('ERR_IK_30', error.ErrorCodes); }, function (error) { errorService.error('ERR_IK_32', error.ErrorCodes); });
            result.finally(function () { blockUI.stop(); });
            return result;
        }

        function _processPayment() {
            blockUI.start('ikprocesspay');
            var result =  $http.put(_url + 'pay/completed', parameterService.getParametersObject()).then(function (response) {
                return response.data;
            }, _onError);
            result.finally(function () { blockUI.stop(); });
            return result;
        }

        /* +++++ public interface +++++ */

        logger.creation(componentName);

        return {
            getKioskInfo: _getKioskInfo,
            startScan: _startScan,
            startPayment: _startPayment,
            startPrint: _startPrint,

            processPayment: _processPayment
        };

    };

    theComponent.$inject = ['Logger', 'appConfig', 'appEnums', '$http', '$q', '$timeout', '$rootScope', 'ParameterService', 'LEZErrorService', 'MeertaligBlockUIService'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function() {

    'use strict';

    var componentName = "LogicService";
    var theComponent = function (appService, appConfig, parameterService, $http) {
        var _url = appConfig.apiUrl + "logic/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }
        
        /* +++++ exposed methods +++++ */

        function _getResult(param, extraParams) {
            var params = parameterService.getParametersObject();
            angular.forEach(extraParams, function (item) { params[item.key] = item.value; });
            return $http.post(_url + param, params).then(function (result) { return result.data; }, _onError);
        }
        
        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            getResult: _getResult
        };

    };

    theComponent.$inject = ['AppService', 'appConfig', 'ParameterService', '$http'];

    angular.module('theApp').factory(componentName, theComponent);

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

    var serviceName = "MeertaligheidService";
    var theRepository = function (logger, appConfig, filterService, $http, $rootScope) {
        var url = appConfig.apiUrl + "meertaligheid/";

        logger.creation(serviceName);

        var _checkToolData = [];
        var _call = { status: false };

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */

        function _init() {
            if (_call.status) return _call.promise;

            _call.promise = $http.get(url)
                                 .then(function (response) {
                                     var data = response.data;

                                     if (data === undefined || data === null || data.length <= 0) throw { status: 404, statusText: "Not found" };

                                     angular.forEach(data, function (value, index) {
                                         angular.forEach(value, function (attributeValue, attribute) {
                                             if (!angular.isString(attributeValue)) return;
                                             if (attributeValue.length === 0) data[index][attribute] = undefined;
                                             if (attributeValue.toLowerCase() === "null") data[index][attribute] = undefined;
                                             if (attributeValue.toLowerCase() === "false") data[index][attribute] = false;
                                             if (attributeValue.toLowerCase() === "true") data[index][attribute] = true;
                                         });
                                         if (value.visible && angular.isNullOrWhitespace(value.nl) && angular.isNullOrWhitespace(value.de) && angular.isNullOrWhitespace(value.en) && angular.isNullOrWhitespace(value.fr))
                                             data[index].visible = false;
                                     });

                                     _checkToolData = data;
                                     logger.init(serviceName);
                                     return data;
                                 }, _onError);
            _call.status = true;

            _call.promise.then(function () { _call.status = true; }, function () { _call.status = false; });

            return _call.promise;
        }

        function _get(filter, strict, data) {
            if (data === undefined) data = _checkToolData;
            return filterService.filter(data, filter, strict);
        }

        /* +++++ public interface +++++ */

        return {
            init: _init,

            get: _get,

            getAll: _init
        };
    };

    theRepository.$inject = ['Logger', 'appConfig', 'FilterService', '$http', '$rootScope'];
    angular.module('theApp').factory(serviceName, theRepository);
})();;
(function () {

    'use strict';

    var componentName = "ParameterOptionsService";
    var theComponent = function (appService, appConfig, $http) {
        var _url = appConfig.apiUrl + "parameters/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */
        function _get(parameter, parameters) {
            return $http.post(_url + parameter + "/options", parameters).then(function (response) { return response.data; }, _onError);
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            get: _get
        };

    };

    theComponent.$inject = ['AppService', 'appConfig', '$http'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function () {

    'use strict';

    var componentName = "PaymentService";
    var theComponent = function (appService, appConfig, $http, blockUI) {
        var _url = appConfig.apiUrl + "payment/";

        function _onSucces(response) {
            return response.data;
        }

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */
        function _getOgone(aanvraagId) {
            return $http.get(_url + "ogone/" + aanvraagId).then(_onSucces, _onError);
        }

        function _processOgoneStatus(aanvraagId, status) {
            blockUI.start('olprocesspay');
            var result = $http.post(_url + "ogone/" + aanvraagId + "/status/" + status).then(_onSucces, _onError);
            result.finally(function () { blockUI.stop(); });
            return result;
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            getOgone: _getOgone,
            processOgoneStatus: _processOgoneStatus
        };

    };

    theComponent.$inject = ['AppService', 'appConfig', '$http', 'MeertaligBlockUIService'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function () {

    'use strict';

    var componentName = "TariefService";
    var theComponent = function (appService, appConfig, $http, Tarief) {
        var _url = appConfig.apiUrl + "tarieven/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ exposed methods +++++ */
        function _search(parameters) {
            parameters = angular.convertDatesToDateStrings(parameters);
            return $http({
                url: _url + "search",
                method: 'GET',
                params: parameters
            }).then(function (response) { return response.data; }, _onError)
              .then(Tarief.apiResponseTransformer);
        }

        /* +++++ public interface +++++ */

        appService.logger.creation(componentName);

        return {
            search: _search
        };

    };

    theComponent.$inject = ['AppService', 'appConfig', '$http', 'Tarief'];

    angular.module('theApp').factory(componentName, theComponent);

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

    var serviceName = "TellerService";
    var theRepository = function (logger, appConfig, $http, $cookies, $q) {
        var _url = appConfig.apiUrl + "teller/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        function _getSessionId() {
            var user = $cookies.getObject('LEZsessionuser');
            if (angular.isUndefinedOrNull(user) || angular.isUndefinedOrNull(user.sessieId))
            {
                return $http.get(_url).then(function (response) {
                    user = $cookies.getObject('LEZsessionuser');
                    user = user ? user : {};
                    user.sessieId = response.data.sessieId;
                    $cookies.putObject('LEZsessionuser', user);
                    return user.sessieId;
                }, _onError);
            }
            else
            {
                return $q.resolve(user.sessieId);
            }
        }

        /* +++++ exposed methods +++++ */
        function _add(naam) {
            return _getSessionId().then(function (sessieId) {
                return $http.post(_url, { SessieId: sessieId, TellerNaam: naam });
            });
            
        }

        /* +++++ public interface +++++ */

        logger.creation(serviceName);

        return {
            add: _add
        };
    };

    theRepository.$inject = ['Logger', 'appConfig', '$http', '$cookies', '$q'];
    angular.module('theApp').factory(serviceName, theRepository);
})();;
(function () {

    'use strict';

    var componentName = "ValidationMessageService";
    var theComponent = function (appConfig, $http, ValidationMessage) {
        var _url = appConfig.apiUrl + "messages/validatie/";

        var _call = { status: false };

        var _messages = [
            new ValidationMessage('VAL_01', 'Gelieve een geldige waarde in te geven.', 'Please enter a valid value.', 'Veuillez entrer une valeur valide.', 'Bitte geben sie einen gültigen Wert ein.')
        ];

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }
        
        function _getAll() {
            return $http.get(_url).then(function (response) { return response.data; }, _onError)
                                  .then(ValidationMessage.apiResponseTransformer);
        }

        /* +++++ exposed methods +++++ */
        function _init() {
            if (_call.status) return _call.promise;

            _call.promise = _getAll().then(function (messages) {
                if (!angular.isArray(messages) || messages.length < 2)
                    throw 'Not found.';
                _messages = messages;
            });
            _call.status = true;

            _call.promise.then(function () { _call.status = true; }, function () { _call.status = false; });

            return _call.promise;
        }

        function _get(identifier) {
            var result = _.find(_messages, { id: identifier });
            if (angular.isDefined(result)) return angular.copy(result);
            else if (identifier !== 'VAL_01') return _get('VAL_01');
        }

        /* +++++ public interface +++++ */

        return {
            init: _init,
            get: _get
        };

    };

    theComponent.$inject = ['appConfig', '$http', 'ValidationMessage'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function() {

    'use strict';

    var componentName = "WhitelistService";
    var theComponent = function(logger, appConfig, Enums, parameterService, $http) {
        var _url = appConfig.apiUrl + "whitelist/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        function _toWhitelistResult(data) {
            if (angular.isUndefinedOrNull(data)) return undefined;
            var result = {};

            function _toDate(parameter) {
                var date = Date.FromApi(data[parameter]);
                if (angular.isDate(date)) result[parameter] = date;
                else result[parameter] = null;
            }

            _toDate(Enums.Parameters.Hotlist.BeginDatum);
            _toDate(Enums.Parameters.Hotlist.EindDatum);

            return result;
        }

        /* +++++ exposed methods +++++ */
        
        function _checkWhiteList() {

            return $http.post(_url, parameterService.getParametersObject())
                              .then(function (response) {
                                  var data = response.data;

                                  parameterService.set(Enums.Parameters.Hotlist.Whitelisted, data[Enums.Parameters.Hotlist.Whitelisted]);
                                  parameterService.set(Enums.Parameters.Hotlist.Blacklisted, data[Enums.Parameters.Hotlist.Blacklisted]);
                                  parameterService.set(Enums.Parameters.Hotlist.WhitelistedVlaanderen, data[Enums.Parameters.Hotlist.WhitelistedVlaanderen]);
                                  parameterService.set(Enums.Parameters.Hotlist.Gecontroleerd, 4); // WL Controle gebeurd

                                  if (angular.isDefined(data[Enums.Parameters.Hotlist.WhitelistVolledig]))
                                      parameterService.set(Enums.Parameters.Hotlist.WhitelistVolledig, data[Enums.Parameters.Hotlist.WhitelistVolledig]);
                                  if (angular.isArray(data[Enums.Parameters.Hotlist.Lijst])) {
                                      var lijst = data[Enums.Parameters.Hotlist.Lijst].map(_toWhitelistResult).filter(Boolean);
                                      parameterService.set(Enums.Parameters.Hotlist.Lijst, lijst);
                                  }
                                  if (angular.isObject(data.VoertuigGegevens)) {
                                      parameterService.set(Enums.Parameters.VDIVoertuig.Bestaat, true);
                                      angular.forEach(data.VoertuigGegevens, function (value, key) {
                                          // LEZ-809 - VDI Parameters bewaren en gebruiken in berekeningen
                                          parameterService.set('VDI_' + key, value);
                                          if (angular.isNullOrWhitespace(value)) return;
                                          // LEZ-738 - Enkel Euronorm prefillen indien <> CT
                                          if (parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.Checktool, Enums.Kanaal.InformatieKioskChecktool])) return;
                                          if (key === Enums.Parameters.Voertuig.Euronorm) parameterService.prefill(key, value);
                                      });
                                  }
                                  return data;
                                }, _onError);
        }
        
        /* +++++ public interface +++++ */

        logger.creation(componentName);

        return {
            checkWhiteList: _checkWhiteList
        };

    };

    theComponent.$inject = ['Logger', 'appConfig', 'appEnums', 'ParameterService', '$http'];

    angular.module('theApp').factory(componentName, theComponent);

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

    var serviceName = "FilterService";
    var theService = function ($filter, $q) {

        function _filter(data, filterObject, filterFunction) {
            if (angular.isUndefined(filterFunction)) filterFunction = function (actual, expected) { return actual === expected; };
            return $filter('filter')(data, filterObject, filterFunction);
        }

        function _filterRegex(data, filterObject) {
            var filterFunction = function (actual, expected) {
                if (!angular.isString(actual)) return false;
                var matches = actual.match(expected);
                if (matches) return true;
                else return false;
            };

            return _filter(data, filterObject, filterFunction);
        }

        function _filterToegestaan(data, parameterService) {
            var resultSet = [];
            var elseSet = [];

            var i = 0, len, row;
	
            // Add each row where no condition is set, or when the condition is met.
            // But add each row that has an 'else' condition to the elseSet.
            for (i = 0, len = data.length; i < len; ++i) {
                row = data[i];
                if (angular.isUndefinedOrNull(row.conditie) || angular.isUndefinedOrNull(row.conditievalue)) resultSet.push(row);
                else if (row.conditievalue === 'else') elseSet.push(row);
                else if (parameterService.equals(row.conditie, row.conditievalue)) resultSet.push(row);
            }

            // Process the elseSet, and add each item that has no matching records.
            for (i = 0, len = elseSet.length; i < len; ++i) {
                row = elseSet[i];
                var res = _filter(resultSet, { itemNr: row.itemNr, type: row.type, naam: row.naam, itemtype: row.itemtype });
                if (res.length === 0) resultSet.push(row);
            }
	
            return resultSet;
        }

        function _filterKeuzeOpties(data, parameterService) {
            var params = {};
            var options = [];
            var tasks = [];

            // loop all rows and fetch all params and start up the tasks
            for (var i = 0, len = data.length; i < len; ++i) {
                var row = data[i];
                if (angular.isUndefinedOrNull(row.param) || angular.isUndefinedOrNull(row.parvalue)) continue;
                if (angular.isDefined(params[row.param])) continue;
                var task = parameterService.getOptions(row.param);
                tasks.push(task);
                task.then(function (result) {
                    for (var j = 0, l = result.length; j < l; ++j) options.push(result[j]);
                });
                params[row.param] = true;
            }

            return $q.all(tasks).then(function () {
                if (tasks.length <= 0) return data;
                var resultSet = [];
                // Test param-parvalue sets with alowed options
                for (var i = 0, len = data.length; i < len; ++i) {
                    var row = data[i];
                    if (angular.isUndefinedOrNull(row.param) || angular.isUndefinedOrNull(row.parvalue)) {
                        resultSet.push(row);
                        continue; // Geen parameter veld
                    }
                    var rows = _filter(options, { param: row.param, parvalue: row.parvalue });
                    if (rows.length > 0) {
                        resultSet.push(row);
                        continue; // De optie is een 'valid' option
                    }
                    else if (_filter(options, { param: row.param }).length <= 0) {
                        // Er zijn simpelweg geen waarden gedefineerd op het 'Algemeen' scherm
                        resultSet.push(row);
                        continue;
                    }
                }
                return resultSet;
            });
        }

        return {
            filter: _filter,
            filterRegex: _filterRegex,
            filterToegestaan: _filterToegestaan,
            filterKeuzeOpties: _filterKeuzeOpties
        };

    };

    theService.$inject = ['$filter', '$q'];

    angular.module('theApp').factory(serviceName, theService);

})();

;
(function () {
    'use strict';

    var serviceName = "FormatterService";
    var theService = function ($filter) {

        function _toQueryString(paramObject) {
            var queryString = [];
            _.forEach(paramObject, function (value, key) {
                value = encodeURIComponent(value);
                queryString.push(key + "=" + value);
            });
            return queryString.join("&");
        }

        function _toDisplayValue(value, format) {
            if (angular.isDate(value))
                return formatDate(value, format);

            if (angular.isString(value) && value.length > 0){
                var date = Date.FromApi(value);
                if (angular.isDate(date))
                    return formatDate(date, format);
            }

            return value;
        }

        function formatDate(date, format) {
            if (date instanceof moment) {
                if (angular.isUndefined(format)) format = 'DD/MM/YYYY';
                return date.format(format);
            }
            else {
                if (angular.isUndefined(format)) format = 'dd/MM/yyyy';
                return $filter('date')(date, format);
            }
        }

        return {
            toQueryString: _toQueryString,
            toDisplayValue: _toDisplayValue
        };

    };

    theService.$inject = ['$filter'];

    angular.module('theApp').factory(serviceName, theService);

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

    var serviceName = "MeertaligBlockUIService";
    var theService = function (Enums, parameterService, meertaligheidService, blockUI, $timeout) {

        var timeoutPromise;
        var meertaligheid = {};

        meertaligheidService.init().finally(_init);

        function _init() {
            var getMeertaligheid = function (filter, defaultValue) {
                var result = meertaligheidService.get({ scherm: 0, type: 'InProcessTekst', naam: filter }).shift();
                if (angular.isObject(result)) return result;
                else return defaultValue;
            };

            meertaligheid['whitelist'] = getMeertaligheid('whitelist', { nl: 'De whitelist wordt gecontroleerd.' });
            meertaligheid['bewaren'] = getMeertaligheid('bewaren', { nl: 'Uw gegevens worden verwerkt, een ogenblik geduld.' });
            meertaligheid['ikscan'] = getMeertaligheid('ikscan', { nl: 'Een ogenblik geduld.' });
            meertaligheid['ikpay'] = getMeertaligheid('ikpay', { nl: 'Volg de instructies op de terminal.' });
            meertaligheid['ikprint'] = getMeertaligheid('ikprint', { nl: 'Je ticket wordt geprint.' });
            meertaligheid['ikprocesspay'] = getMeertaligheid('ikprocesspay', { nl: 'De betaling wordt verwerkt.' });
            meertaligheid['olprocesspay'] = getMeertaligheid('olprocesspay', { nl: 'De betaling wordt verwerkt.' });
        }

        function _start(filter) {
            var message;
            var item = meertaligheid[filter];
            if (angular.isObject(item)) {
                message = item[parameterService.get(Enums.Parameters.Taal, true).toLowerCase()];
                if (angular.isNullOrWhitespace(message)) message = item.nl;
            }
            if (angular.isNullOrWhitespace(message)) message = 'Please wait...';
            blockUI.start(message);

            if (!parameterService.equals(Enums.Parameters.Kanaal, [Enums.Kanaal.InformatieKiosk, Enums.Kanaal.InformatieKioskChecktool])) return;

            var maxDuration = 1000 * 60; // 1 minute wait time
            switch (filter) {
                case 'ikpay':
                    maxDuration = maxDuration * 6; // 6 minutes max
                    break;
                case 'ikprocesspay':
                case 'olprocesspay':
                    maxDuration = maxDuration * 2; // 2 minutes max
                    break;
                case 'bewaren':
                    maxDuration = maxDuration * 2; // 2 minutes max
                    break;
                case 'whitelist':
                    maxDuration = maxDuration * 1.5; // 2 minutes max
                    break;
                case 'ikscan':
                    maxDuration = maxDuration * 5; // 5 minutes max
                    break;
                case 'ikprint':
                    // 1 minute max
                    break;
            }

            var log = function (m, duration) {
                var time = 0, delay = 10000;
                var onTimeout = function () {
                    time += delay;
                    console.log(m);
                    if (time < duration) {
                        timeoutPromise = $timeout(onTimeout, delay);
                    } else timeoutPromise = undefined;
                };
                console.log(m);
                timeoutPromise = $timeout(onTimeout, delay);
            };
            log(message, maxDuration);
        }

        function _stop() {
            blockUI.stop();
            if (timeoutPromise) {
                $timeout.cancel(timeoutPromise);
                timeoutPromise = undefined;
            }
        }
        

        return {
            start: _start,
            stop: _stop
        };

    };

    theService.$inject = ['appEnums', 'ParameterService', 'MeertaligheidService', 'blockUI', '$timeout'];

    angular.module('theApp').factory(serviceName, theService);

})();

;
// Bevat de common functionaliteit zoals logging, ...

(function() {

    'use strict';

    var componentName = "AppService";
    var theComponent = function(logger, config, enums) {
        
        /* +++++ public interface +++++ */

        logger.creation(componentName);

        return {
            logger: logger,
            config: config,
            enums: enums
        };

    }

    theComponent.$inject = ['Logger', 'appConfig', 'appEnums'];

    var appServiceModule = angular.module('AppService', []);

    appServiceModule.factory(componentName, theComponent);

})();
;
(function () {
    'use strict';
    var componentName = "BaseService";
    var theComponent = function ($http, $q) {

        function _createServiceCallGET(requesturl) {
            var deferred = $q.defer();
            $http.get(requesturl).then(function (response) {
                deferred.resolve(response.data);
            }).catch(function (response) {
                deferred.reject();
            });
            return deferred.promise;
        };

        function _createServiceCallGETwithParams(requesturl, params) {
            var deferred = $q.defer();
            $http.get(requesturl, params).then(function (response) {
                deferred.resolve(response.data);
            }).catch(function (response) {
                deferred.reject();
            });
            return deferred.promise;
        };

        function _createServiceCallPOST(requesturl, data) {
            var deferred = $q.defer();
            $http.post(requesturl, data).then(function (response) {
                deferred.resolve(response.data);
            }).catch(function (response) {
                deferred.reject();
            });
            return deferred.promise;
        };

        function _createServiceCallPUT(requesturl, data) {
            var deferred = $q.defer();
            $http.put(requesturl, data).then(function (response) {
                deferred.resolve(response.data);
            }).catch(function (response) {
                deferred.reject();
            });
            return deferred.promise;
        };

        function _createServiceCallDELETE(requesturl, data) {
            var deferred = $q.defer();
            var request = $http({
                method: "DELETE",
                url: requesturl,
                data: data,
                headers: { 'Content-Type': 'application/json' }
            }).then(function (response) {
                deferred.resolve(response.data);
            }).catch(function (response) {
                deferred.reject();
            });
            return deferred.promise;
        };

        return {
            get: _createServiceCallGET,
            getWithParams: _createServiceCallGETwithParams,
            post: _createServiceCallPOST,
            put: _createServiceCallPUT,
            remove: _createServiceCallDELETE,
        };
    };
    theComponent.$inject = ['$http', '$q'];
    angular.module('theApp').factory(componentName, theComponent);
})();
;
(function () {
    'use strict';

    angular.module('theApp').constant('appEnums', {
        Parameters: {
            Taal: 'Taal',

            Redirect: 'redirectToAfterLogin',
            SelectedRequestOption: 'selectedRequestOption',
            IsLoopFinished: 'isSelectedLoopFinished',
            IsExtension: 'isExtension',
            ApplicationEndDate: 'aanvraagEindDatum',

            MaxVermogen: 130,

            BoeteNummer: 'BoeteNummer',
            AanvraagNummer: 'ANR',
            AanvraagStatus: 'ASTAT',
            AanvraagDatum: 'ADAT',
            AStadStatus: 'STATAS',
            AStadStatusDatum: 'STATASDAT',

            Kanaal: 'REGT',
            AanvraagType: 'ATYPE',
            AanvraagSoort: 'ASOORT',

            BeginDatum: 'BDAT',
            EindDatum: 'EDAT',
            Termijn: 'TERM',
            Tarief: 'TARID',
            Overlap: 'OVERL',

            IsBedrijfsVoertuig: 'BedJN',
            IsBelgischVoertuig: 'BelJN',
            IsNederlandsVoertuig: 'NedJN',
            IsOldtimerVoertuig: 'OLDTMR',
            IsAangepastVoertuig: 'AV',

            Kanteldatums: 'Kanteldatums',
            Kanteldatum1: 'KD1',
            Kanteldatum2: 'KD2',
            Verstrenging: 'Verstrenging',

            Kiosk: {
                Id: 'IKID',
                Naam: 'IKNAME',
                SessieId: 'IKSESSID',
                HasScanned: 'IKSCAN',
                Print: 'IKPRINT',
                Betaal: 'IKBET'
            },

            // Voertuig gegevens
            Voertuig: {
                Nummerplaat: 'NPL',
                Landcode: 'LAND',
                Categorie: 'VC',
                BrandstofType: 'BT',
                BrandstofTypeUitgebreid: 'BT2',
                DatumEersteInschrijving: 'EID',
                DatumLaatsteInschrijving: 'LID',
                Euronorm: 'EN',
                EuronormVerrijkt: 'EN2',
                EuronormGecorrigeerd: 'EN3',
                EuronormGecorrigeerdLandbouw: 'EN3T',
                EuronormGecorrigeerdAndere: 'EN3A',
                Roetfilter: 'RF',
                RoetfilterPremieVlaanderen: 'RFV',
                MassaRijklareToestand: 'MRT',
                MassaRijklareToestandVerplicht: 'MRT_VERPL',
                Aardcode: 'AC',
                BijkomendeZitplaatsen: 'BZP',
                MaximaalToegelatenMassa: 'MTM',
                PartikelMassaWaarde: 'PMW',
                CO2Waarde: 'CO2',
                ChassisNummer: 'CHAS',
                Gelijkvormigheidscode: 'COC',
                GelijkvormigheidscodeLandbouw: 'GVCT',
                GelijkvormigheidscodeAndere: 'GVCA',
                Vermogen: 'Vermogen'
            },
            VDIVoertuig: {
                Bestaat: 'VDI-HeeftGegevens',
                Euronorm: 'VDI_EN',
                EuronormVerrijkt: 'VDI_EN2',
                BrandstofType: 'VDI_BT',
                BrandstofTypeUitgebreid: 'VDI_BT2',
                Categorie: 'VDI_VC'
            },
            Gebruiker: {
                Identificatie: 'UID',
                Token: 'UTOKEN',
                HerhalingEmail: 'EMCONT2'
            },
            Medewerker: {
                Identificatie: 'LOKID',
                Loket: 'LOK',
                Naam: 'LOKMED',
                Token: 'LOKMEDTOKEN',
                Opmerking: 'GAPAOPM',
                Motivatie: 'GAPAMOT',
                KassaToepassing: "KASTOEP"
            },
            Aanvrager: {
                RijksregisterNummer: 'RRCONT',
                Naam: 'NCONT',
                Voornaam: 'VNCONT',
                Straat: 'SCONT',
                HuisNummer: 'HCONT',
                Bus: 'BCONT',
                Postcode: 'PCONT',
                Gemeente: 'GCONT',
                Land: 'LCONT',
                Email: 'EMCONT',
                Heeft2eEmail: 'EM2CONTJN',
                Email2: 'EM2CONT',
                Telefoon: 'TCONT'
            },

            Bedrijf: {
                BTWNummer: 'BTWFAKT',
                Naam: 'NFAKT',
                Straat: 'SFAKT',
                HuisNummer: 'HFAKT',
                Bus: 'BFAKT',
                Postcode: 'PFAKT',
                Gemeente: 'GFAKT',
                Land: 'LFAKT'
            },

            Betaling: {
                Methode: 'BETMODE',
                Status: 'OSTAT',
                TitularisRekening: 'REKTITAVR',
                Iban: 'IBANAVR',
                Bic: 'BICAVR',
                Bedrag: 'BEDR',
                KassaCode: 'KASSA',
                Mededeling: 'OGMS',
                IsBetaald: 'BET'
            },

            Titularis: {
                IsBedrijf: 'BPTIT',
                BTWNummer: 'BTWTIT',
                RijksregisterNummer: 'RRTIT',
                Naam: 'NTIT',
                Voornaam: 'VNTIT',
                Straat: 'STIT',
                HuisNummer: 'HTIT',
                Bus: 'BTIT',
                Postcode: 'PTIT',
                Gemeente: 'GTIT',
                Land: 'LTIT'
            },

            IsGehandikapt: 'GHK',
            HeeftVerhoogdeTegemoetkoming: 'VT',
            IsInwonerLEZ: 'LEZVT',
            IsInwonerLEZMetVerhoogdeTegemoetkoming: 'LEZVT2',
            HeeftRolstoellift: 'ROLST',

            Gehandikapte: {
                KaartNummer: 'GHKNR',
                Vervaldatum: 'GHKDAT',
                RijksregisterNummer: 'RRGHK',
                Naam: 'NGHK',
                Voornaam: 'VNGHK',
                Straat: 'SGHK',
                HuisNummer: 'HGHK',
                Bus: 'BGHK',
                Postcode: 'PGHK',
                Gemeente: 'GGHK',
                Land: 'LGHK'
            },

            Opdracht: {
                Begin: 'OPDRBDAT',
                Einde: 'OPDREDAT',
                Opdrachtgever: 'OPDRGEVER',
                OpdrachtgeverNoodsituatie: 'OPDRGEVERNOOD'
            },

            Hotlist: {
                Lijst: 'WLLIST',
                Whitelisted: 'WL',
                Blacklisted: 'BL',
                WhitelistVolledig: 'WLV',
                WhitelistedVlaanderen: 'VDIWL',
                Gecontroleerd: 'CTRLWL',
                BeginDatum: 'WLBDAT',
                EindDatum: 'WLEDAT'
            },

            Dagpas: {
                AantalDagpassenLopendJaar: 'DPLJ',
                AantalDagpassenVolgendJaar: 'DPVJ'
            },

            Bijlagen: {
                Bijlagen: 'BIJL',
                Voorwaarden: 'VWBIJL'
            },
            Documenten: 'DOC',

            Disclaimer: 'DISC',

            // Kopieren/Verlengen
            BasisAanvraagNummer: 'BANR',
            KopieerbaarheidAanvraag: 'KOPAVR',
            VerlengbaarheidAanvraag: 'VERLAVR',
            VerlengbaarheidBijlagen: 'VERLBIJL',

            // Extra
            LusZichtbaarheid: 'VWOP',
            VolledigheidLus: 'VWX',
            VolledigheidAanvraag: 'VALZ',


            Keuzes: {
                EuronormCorrigeren: 'KZ1',
                AangepastVoertuig: 'KZ14',
                Lus: 'KZ41',
                AannemerType: 'KZ65',
                Noodsituatie: 'KZ69',
                Marktkramer: 'KZ72',
                BetaalingBevestigd: 'KZ80',
                BetalingOk: 'KZ81',
                InfokioskKeuze: 'KZ93'
            },
            LusParameters: {
                Voertuig: 'KZR1',
                EuronormGecorrigeerd: 'KZR2A',
                EuronormAndere: 'KZR2B',
                RoetfilterVlaanderen: 'KZR3A',
                RoetfilterAnderen: 'KZR3B',
                RoetfilterIngebouwd: 'KZR3C',
                GehandikapteAangepastVoertuig: 'KZV4A',
                GehandikapteVerhoogdeTegemoetkoming: 'KZV4B',
                GehandikapteRolstoellift: 'KZV4C',
                Bewoner: 'KZT5',
                OldTimer: 'KZT6',
                Aannemer: 'KZT7',
                Marktkramer: 'KZT8',
                Euronorm3: 'KZT9',
                Euronorm4: 'KZT22',
                Noodsituatie: 'KZT10',
                PrioritairVoertuig: 'KZV12',
                UizonderlijkVervoer: 'KZV13',
                AndereType: 'KZR14'
            },

            DirkParameters: {
                EuronormVoorwaarden: 'VWCE',
                VWD39: 'VWD39',
                VWD41: 'VWD41',
                VWD41B: 'VWD41B',
                VWD62: 'VWD62',
                VWD63: 'VWD63',
                VWD77: 'VWD77',
                VWD85: 'VWD85',
                VWD90: 'VWD90',
                VWD51: 'VWD51',
                VWD46: 'VWD46',
                VWD68: 'VWD68'
            }          
        },
        Taal: {
            Nederlands: 'NL',
            Frans: 'FR',
            Engels: 'EN',
            Duits: 'DE'
        },
        Kanaal: {
            Checktool: 'CT',
            EloketAprofiel: 'AT',
            EloketEmail: 'ET',
            BackOffice: 'BO',
            DLloket: 'DL',
            ParkeerMeter: 'PK',
            InformatieKiosk: 'IK',
            InformatieKioskChecktool: 'IKCT'
        },
        AanvraagType: {
            Dagpas: 'D',
            Toelating: 'T',
            Registratie: 'R',
            Vrijstelling: 'V'
        },
        AanvraagSoort: {
            RegistratieTechnischeKenmerken: "R1",
            RegistratieTechnischeKenmerkenBE: "R1B",
            RegistratieCorrectieEuronormCertificaat: "R2A",
            RegistratieCorrectieEuronorm: "R2B",
            RegistratieRoetfilterPremie: "R3A",
            RegistratieRoetfilterDieselEuro3: "R3B",
            RegistratieIngebouwdeRoetfilter: "R3C",
            
            VrijstellingAangepastVoertuig: "V4A",
            VrijstellingVerhoogdeTegemoetkoming: "V4B",
            VrijstellingRolstoellift: "V4C",
            
            ToelatingInwoner: "T5",
            ToelatingInwonerDE4: "T18",
            ToelatingOldtimer: "T6",
            ToelatingWerken: "T7",
            ToelatingAmbulanteHandel: "T8",
            ToelatingDieselEuro3: "T9",
            ToelatingDieselEuro4: "T22",
            ToelatingNoodsituatie: "T10",
            ToelatingDagpas: "T11",
            
            VrijstellingPrioritairVoertuig: "V12",
            VrijstellingUitzonderlijkVervoer: "V13",
            RegistratieAnderType: "R14"
        },
        VoertuigCategorien: {
            Landbouwvoertuig: 'T',
            Andere: 'AN',
            NietVermeld: 'NV',

            Personenwagen: 'M1',
            Busje: 'M2',
            Bus: 'M3',
            Bestelwagen: 'N1',
            LichteVrachtwagen: 'N2',
            ZwareVrachtwagen: 'N3'
        },
        Euronorm: {
            NietVermeld: 'NV',

            Euro6d: '6d',
            Euro6dTemp: '6dTemp',
            Euro6: '6',
            Euro5: '5',
            Euro4: '4',
            Euro3: '3',
            Euro2: '2',
            Euro1: '1',

            EuroV: 'V',
            EuroIV: 'IV',
            EuroIIIb: 'IIIb',
            EuroIIIa: 'IIIa',
            EuroII: 'II',
            EuroI: 'I',

            Euro0: '0'

        },
        BrandstofType: {
            Elektrisch: 'E',
            Diesel: 'D',
            Benzine: 'B',
            Waterstof: 'W',
            HybrideBenzine: 'HB',
            HybrideLiquid: 'HL',
            HybrideDiesel: 'HD',
            LPG: 'LPG',
            CNG: 'CNG',
            BE: 'BE'
        },
        RoetfilterType: {
            AchterafGeinstalleerd: 'J',
            ZonderPremie: 'JNV',
            MetPremie: 'JVL',
            Neen: 'N',
            Ingebouwd: 'JI'
        },
        Auth: {
            ProfielTypes: {
                AProfiel: 'A-Profiel',
                Anoniem: 'Anoniem',
                Medewerker: 'Medewerker'
            }
        },
        BetaalMethode: {
            Online: '1',
            Overschrijving: '2',
            Bancontact: '3',
            InfoKioskTerminal: '8',
            Kat: '9'
        },
        NavigatieActies: {
            Offline: 'Offline',
            Maintenance: 'Maintenance',
            Login: 'Login',
            Relog: 'Relogin',
            Restore: 'Restore',
            Dagpas: 'Dagpas',
            Toevoegen: 'Toevoegen',
            Indienen: 'Indienen',
            Wijzigen: 'Wijzigen',
            Verlengen: 'Verlengen',
            Kopieren: 'Kopieren',
            Verwijderen: 'Verwijderen',
            BijlagenBeheren: 'BeheerBijlagen',
            Ogone: 'Ogone',
            OgoneFailed: 'Ogone - Failed',
            BoeteNummer: 'BoeteNummer'
        },
        BewaarActies: {
            OpnieuwIndienen: 'OPNIEUW_INDIENEN',
            Indienen: 'INDIENEN',
            Bewaren: 'BEWAREN',
            RetryPay: 'RETRY_PAY'
        },
        FieldOptions: {
            Hidden: 0,
            ReadOnly: 1,
            Editable: 2,
            Required: 3
        },
        InfokioskStatus: {
            Initieel: 'Initieel',
            Bezig: 'Bezig',
            Geannuleerd: 'Geannuleerd',
            Klaar: 'Klaar',
            Fout: 'Fout'
        },
        LabelTranslations: {
            nl: "Onbepaald",
            de: "Unbestimmt",
            en: "Indefinite",
            fr: "Indéfini",
        }
    });

    angular.module('theApp').constant('appConstants', {
        Datums: {
            getLEZStartDatum: function () { return moment("2017-02-01T00:00:00.000", moment.ISO_8601, true); },
            getLEZ2020StartDatum: function () { return moment("2020-01-01T00:00:00.000", moment.ISO_8601, true); },
            getBeginDatum_2019_sept: function () { return moment("2019-09-01T00:00:00.000", moment.ISO_8601, true); },
            getLEZBoeteDatum: function () { return moment("2017-03-01T00:00:00.000", moment.ISO_8601, true); },
            getEindDatum_2019: function () { return moment("2019-12-31T23:59:59.999", moment.ISO_8601, true); },
            getEindDatum_2024: function () { return moment("2024-12-31T23:59:59.999", moment.ISO_8601, true); },
            getEindDatum_2027_sept: function () { return moment("2027-08-31T23:59:59.999", moment.ISO_8601, true); },
            getEindDatum_2027: function () { return moment("2027-12-31T23:59:59.999", moment.ISO_8601, true); },
            getEindDatum_2028: function () { return moment("2028-12-31T23:59:59.999", moment.ISO_8601, true); },
            getEindDatum_2099: function () { return moment("2099-12-31T23:59:59.999", moment.ISO_8601, true); },
            getVroegsteDatumEersteInschrijving: function () { return moment("1879-01-01T00:00:00.000", moment.ISO_8601, true); }
        },
        Meertaligheid: {
            Ja: { nl: 'Ja', fr: 'Oui', en: 'Yes', de: 'Ja' },
            Neen: { nl: 'Neen', fr: 'Non', en: 'No', de: 'Nein' },
            KeuzeTekst: { nl: '-- Maak een keuze.', fr: '-- Faites un choix.', en: '-- Make a choice.', de: '-- Machen Sie eine Auswahl.' },
            Infopaginas: { nl: 'Er zijn geen info pagina\'s beschikbaar.', fr: 'Il n\'y a pas de pages d\'informations disponibles', en: 'There are no info pages available.', de: 'Es sind keine Infoseiten verfügbar.' }
        }
    });

})();;
/*! @source http://purl.eligrey.com/github/FileSaver.js/blob/master/FileSaver.js */
var saveAs=saveAs||typeof navigator!="undefined"&&navigator.msSaveOrOpenBlob&&navigator.msSaveOrOpenBlob.bind(navigator)||function(n){"use strict";if(typeof navigator=="undefined"||!/MSIE [1-9]\./.test(navigator.userAgent)){var s=n.document,r=function(){return n.URL||n.webkitURL||n},i=s.createElementNS("http://www.w3.org/1999/xhtml","a"),a="download"in i,v=function(t){var i=s.createEvent("MouseEvents");i.initMouseEvent("click",!0,!1,n,0,0,0,0,0,!1,!1,!1,!1,0,null);t.dispatchEvent(i)},u=n.webkitRequestFileSystem,h=n.requestFileSystem||u||n.mozRequestFileSystem,y=function(t){(n.setImmediate||n.setTimeout)(function(){throw t;},0)},f="application/octet-stream",c=0,p=500,e=function(t){var i=function(){typeof t=="string"?r().revokeObjectURL(t):t.remove()};n.chrome?i():setTimeout(i,p)},o=function(n,t,i){var r,u;for(t=[].concat(t),r=t.length;r--;)if(u=n["on"+t[r]],typeof u=="function")try{u.call(n,i||n)}catch(f){y(f)}},l=function(t,s){var l=this,k=t.type,d=!1,y,b,g=function(){o(l,"writestart progress write writeend".split(" "))},p=function(){if((d||!y)&&(y=r().createObjectURL(t)),b)b.location.href=y;else{var i=n.open(y,"_blank");i==undefined&&typeof safari!="undefined"&&(n.location.href=y)}l.readyState=l.DONE;g();e(y)},w=function(n){return function(){if(l.readyState!==l.DONE)return n.apply(this,arguments)}},nt={create:!0,exclusive:!1},tt;if(l.readyState=l.INIT,s||(s="download"),a){y=r().createObjectURL(t);i.href=y;i.download=s;v(i);l.readyState=l.DONE;g();e(y);return}if(n.chrome&&k&&k!==f&&(tt=t.slice||t.webkitSlice,t=tt.call(t,0,t.size,f),d=!0),u&&s!=="download"&&(s+=".download"),(k===f||u)&&(b=n),!h){p();return}c+=t.size;h(n.TEMPORARY,c,w(function(n){n.root.getDirectory("saved",nt,w(function(n){var i=function(){n.getFile(s,nt,w(function(n){n.createWriter(w(function(i){i.onwriteend=function(t){b.location.href=n.toURL();l.readyState=l.DONE;o(l,"writeend",t);e(n)};i.onerror=function(){var n=i.error;n.code!==n.ABORT_ERR&&p()};"writestart progress write abort".split(" ").forEach(function(n){i["on"+n]=l["on"+n]});i.write(t);l.abort=function(){i.abort();l.readyState=l.DONE};l.readyState=l.WRITING}),p)}),p)};n.getFile(s,{create:!1},w(function(n){n.remove();i()}),w(function(n){n.code===n.NOT_FOUND_ERR?i():p()}))}),p)}),p)},t=l.prototype,w=function(n,t){return new l(n,t)};return t.abort=function(){var n=this;n.readyState=n.DONE;o(n,"abort")},t.readyState=t.INIT=0,t.WRITING=1,t.DONE=2,t.error=t.onwritestart=t.onprogress=t.onwrite=t.onabort=t.onerror=t.onwriteend=null,w}}(typeof self!="undefined"&&self||typeof window!="undefined"&&window||this.content);typeof module!="undefined"&&module.exports?module.exports.saveAs=saveAs:typeof define!="undefined"&&define!==null&&define.amd!=null&&define([],function(){return saveAs});
//# sourceMappingURL=FileSaver.min.js.map
;
(function () {

    'use strict';

    var serviceName = "FileService";
    var theService = function ($q) {

        var BASE64_MARKER = ';base64,';

        function _convertDataURIToBinary(dataURI) {
            var base64Index = dataURI.indexOf(BASE64_MARKER) + BASE64_MARKER.length;
            var base64 = dataURI.substring(base64Index);
            var raw = window.atob(base64);
            var rawLength = raw.length;
            var array = new Uint8Array(new ArrayBuffer(rawLength));

            for (i = 0; i < rawLength; i++) {
                array[i] = raw.charCodeAt(i);
            }
            return array;
        }

        function _parseHeaders(headers) {

            var result = {
                contentType: "application/octet-stream",
                fileName: "download.bin"
            };
            //console.log(headers());
            result.contentType = headers('content-type') || 'application/octet-stream';

            //console.log('contentType', result.contentType);

            var disposition = headers('Content-Disposition');

            //console.log('disposition', disposition);

            if (disposition && (disposition.indexOf('attachment') !== -1 || disposition.indexOf('inline') !== -1)) {
                var filenameRegex = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/;
                var matches = filenameRegex.exec(disposition);
                //console.log(matches);
                if (matches != null && matches[1]) {
                    result.fileName = matches[1].replace(/['"]/g, '');
                }
            }

            //console.log(result);
            return result;
        }

        var _download = function (fileName, contentType, data) {
            var deferred = $q.defer();
            
            var blob = new Blob([data], { type: contentType });
            saveAs(blob, fileName);// FileSaver 

            deferred.resolve();

            return deferred.promise;
        };

        // geeft problemen in IE
        var _viewInBrowser = function (fileName, contentType, data) {
            var deferred = $q.defer();

            var blob = new Blob([data], { type: contentType });

            // Url instellen
            var url = null;
            if (window.webkitURL) {
                url = window.webkitURL.createObjectURL(blob);
            } else if (window.URL && window.URL.createObjectURL) {
                url = window.URL.createObjectURL(blob);
            } else {
                deferred.reject(new ErrorResult());
            }


            //window.location.href = url;

            window.open(url);

            deferred.resolve();

            return deferred.promise;
        };

        /* +++++ public interface +++++ */

        return {
            viewInBrowser: _download,
            download: _download,
            parseHeaders: _parseHeaders
        };
    };

    theService.$inject = ['$q'];
    angular.module('theApp').factory(serviceName, theService);
})();;
(function() {

    'use strict';

    var componentName = "Logger";
    var theComponent = function($log, appConfig) {

        function _success(message) {
            if (appConfig.enableLog) {
                $log.log(message);
            }
        }

        function _debug(message) {
            if (appConfig.enableLog) {
                if (appConfig.enableDebug) {
                    $log.debug(message);
                }
            }
        }

        function _info(message) {
            if (appConfig.enableLog) {
                $log.info(message);
            }
        }

        function _warn(message) {
            if (appConfig.enableLog) {
                $log.warn(message);
            }
        }

        function _error(message) {
            if (appConfig.enableLog) {
                $log.error(message);
            }
        }

        function _creation(name) {
            _debug(name + " : gecreëerd.");
        }

        function _initialization(name) {
            _debug(name + " : geïnitialiseerd.");
        }

        /* +++++ public interface +++++ */

        return {
            success: _success,
            debug: _debug,
            info: _info,
            warn: _warn,
            error: _error,
            creation: _creation,
            init: _initialization
        };

    };

    theComponent.$inject = ['$log', 'appConfig'];

    angular.module('AppService').factory(componentName, theComponent);

})();;
(function () {
    'use strict';
    var componentName = "ModalService";
    var theComponent = function ($modal) {
        function _toonModal(options) {
            return $modal.open({
                templateUrl: "app/views/modals/" + options.template,
                controller: options.controller,
                controllerAs: 'ctrl',
                backdrop: true,
                keyboard: true,
                resolve: {
                    params: function () {
                        return options.params
                    }
                }
            });
        };

        return {
            toonModal: _toonModal
        };
    };
    theComponent.$inject = ['$modal'];
    angular.module('theApp').factory(componentName, theComponent);
})();;
(function () {
    'use strict';
    var directiveName = "loadingSpinner";
    var theDirective = function () {
        return {
            restrict: 'E',
            template:   '<div align="center" ng-show="isLoading">' +
                            '<div class="loader"></div>' +
                        '</div>',
            scope: {
                isLoading: '='
            }
        };
    }
    angular.module('theApp').directive(directiveName, theDirective);
})();





    
;
(function () {
    'use strict';
    angular.module('theApp').provider('tinkUploadService', function () {
        return {
            $get: ['BijlagenService', '$q', function (bijlagenService, $q) {
                return {
                    upload: function (file, options) {
                        var deferred = $q.defer();
                        bijlagenService.add(file.fileData, options);
                        deferred.resolve('Ok!');
                        return deferred.promise;
                    },
                    remove: function (file) {
                        bijlagenService.remove(file.fileData);
                    }
                };
            }]
        };
    });
})();;
(function() {
    'use strict';

    var ctrlName = "ChatcomponentButtonController";
    var theController = function (appService, chatService, $scope, $timeout, $location, errorService) {

        var ctrl = this;

		var pollTime = 5000;
		var errorCount = 0;
		var pollPromise;

		ctrl.chatWindow = {
			closed: true
		};
		ctrl.available;
		ctrl.disabled = false;
		ctrl.occupied = false;
		ctrl.popupOpen = false;

		function getChatAvailability() {
		    chatService.getAvailability($scope.taal)
				.then(function (response) {
					ctrl.available = response;

					errorCount = 0;
					nextPoll();
				},function (response) {
					ctrl.available = false;

                    errorCount = Math.min(12, errorCount + 1); // Max delay = 5sec*12 = 60sec
                    nextPoll(errorCount * pollTime);
                    return undefined;
				});
		}

		function nextPoll(delay) {
			delay = delay || pollTime;

			// Clear last timeout before starting a new one
			cancelPoll();
			pollPromise = $timeout(getChatAvailability, delay);
		}

		function cancelPoll() {
			$timeout.cancel(pollPromise);
		}

		function getChatURL() {
		    return chatService.getChatUrl($scope.taal);
		}

		function clickHandler(available) {
			var windowName = 'chatservicer_window';
			var windowFeatures = 'width=640,height=480,resizable,scrollbars=yes,status=1';

			var windowUrl = $scope.urlwhenunavailable;
			if (!available && !angular.isNullOrWhitespace(windowUrl)) {
				window.open(windowUrl, "_blank");
				return;
			}

			// Check if a chat window is already open
			if (ctrl.chatWindow && !ctrl.chatWindow.closed) {
				// if so focus back on the window and end here
				ctrl.chatWindow.focus();
				return;
			} else {
				ctrl.disabled = false;
			}

			getChatURL()
				.then(function (result) {
					var chatUrlAvailable = result;

					// Chat is available
					if (angular.isString(chatUrlAvailable) && chatUrlAvailable.length > 0) {
						// Chat agent is also available => Stop polling + open window with chat url
						cancelPoll();

						var windowURL = $location.absUrl().split('?')[0] + 'chat?RedirectUrl=' + encodeURIComponent(chatUrlAvailable);
						var referrer = 'referrer=' + window.location.href;

						if (chatUrlAvailable.indexOf('?') >= -1) {
							referrer = '&' + referrer;
						} else {
							referrer = '?' + referrer;
						}

						ctrl.chatWindow = window.open(windowURL + referrer, windowName, windowFeatures);
						ctrl.disabled = true;
					} else {
						// Chat agents are all occupied => show popup with message + set chat availability to false
						ctrl.occupied = true;
						ctrl.popupOpen = !ctrl.popupOpen;
						ctrl.available = false;

						// Restart polling after 5 seconds to avoid closing of popup when availability changes
						nextPoll(5000);
					}
				}, function () {
				    errorService.error('ERR_CHA_01');
				});
		}

		ctrl.clickHandler = clickHandler;
		ctrl.nextPoll = nextPoll;
		ctrl.cancelPoll = cancelPoll;
		ctrl.getChatAvailability = getChatAvailability;
    };

    theController.$inject = ['AppService', 'ChatService', '$scope', '$timeout', '$location', 'LEZErrorService'];

    angular.module('theApp').controller(ctrlName, theController);
})();
;
(function () {
    'use strict';

    angular.module('theApp').directive('chatcomponentButton', ['$timeout', '$window', function ($timeout, $window) {
        return {
			restrict: 'AE',
			replace: true,
			templateUrl: 'app/shared/chatcomponent/chatcomponent-button.htm',
			controller: 'ChatcomponentButtonController',
			controllerAs: 'chatservicer',
			scope: {
				urlwhenunavailable: '@',
				buttontext: '@',
				buttontextnoagent: '@',
                taal: '@'
			},
			link: function (scope, element, attrs, ctrl) {

				function initialize() {
					ctrl.getChatAvailability();
				}

				scope.$watch('chatservicer.available', function onAvailabiltyChange(newValue, oldValue) {
					if (newValue !== oldValue && !ctrl.disabled) {
						if (!ctrl.occupied || (ctrl.occupied && newValue === true)) {
							ctrl.nextPoll(2000);
						}
					}
				});

				scope.$on('$destroy', function () {
					ctrl.cancelPoll();
				});

				$window.addEventListener('focus', function () {
					// Had to wrap in timeout because chatwindow.closed wasn't
					// being set directly to false when it was closed in Firefox
					$timeout(function () {
						if (ctrl.chatWindow && ctrl.chatWindow.closed) {
							ctrl.disabled = false;
							ctrl.nextPoll();
						}
					});
				});

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

    'use strict';

    var componentName = "ChatService";
    var theComponent = function(logger, appConfig, $http) {
        var _url = appConfig.apiUrl + "chat/";

        function _onError(response) {
            if (angular.isObject(response)) {
                if (angular.isObject(response.data))
                    throw response.data;
                else
                    throw response;
            }
            else
                throw {};
        }

        /* +++++ private +++++ */
        
        function _getChatServiceStatus() {
            return $http.get(_url + "status").then(function (response) {
                return response.data;
            }, _onError);
        }

        function _getAvailability(taal) {
            return $http.get(_url + "available?taal=" + taal).then(function (response) {
                var result = response;
                return response.data;
            }, _onError);
        }

        function _getChatUrl(taal) {
            return $http.get(_url + "url?taal=" + taal).then(function (response) {
                return response.data;
            }, _onError);
        }
        
        /* +++++ public interface +++++ */

        logger.creation(componentName);

        return {
            getChatServiceStatus: _getChatServiceStatus,
            getAvailability: _getAvailability,
            getChatUrl: _getChatUrl
        };

    };

    theComponent.$inject = ['Logger', 'appConfig', '$http'];

    angular.module('theApp').factory(componentName, theComponent);

})();;
(function () {
    'use strict';
    var filterName = 'orderObjectBy';
    var filterFunction = function () {
        return function (items, field, reverse) {
            var filtered = [];
            _.forEach(items, function (item) {
                filtered.push(item);
            });
            filtered.sort(function (a, b) {
                return (a[field] > b[field] ? 1 : -1);
            });
            if (reverse) filtered.reverse();
            return filtered;
        };
    };

    angular.module('theApp').filter(filterName, filterFunction);
})();;