/* Minification failed. Returning unminified contents.
(472,88-89): run-time error JS1195: Expected expression: >
(481,54-55): run-time error JS1195: Expected expression: )
(488,41-49): run-time error JS1193: Expected ',' or ')': function
(488,68-69): run-time error JS1004: Expected ';': {
(492,37-38): run-time error JS1002: Syntax error: }
(512,13-14): run-time error JS1002: Syntax error: }
(615,5-6): run-time error JS1002: Syntax error: }
(619,5-6): run-time error JS1195: Expected expression: }
(623,30-31): run-time error JS1004: Expected ';': {
(1028,2-3): run-time error JS1195: Expected expression: )
(1030,31-32): run-time error JS1004: Expected ';': {
(1174,2-3): run-time error JS1195: Expected expression: )
(1175,30-31): run-time error JS1004: Expected ';': {
(1292,2-3): run-time error JS1195: Expected expression: )
(1292,11-12): run-time error JS1197: Too many errors. The file might not be a JavaScript file: ;
 */
/* Minification failed. Returning unminified contents.
(455,88-89): run-time error JS1195: Expected expression: >
(464,54-55): run-time error JS1195: Expected expression: )
(471,41-49): run-time error JS1193: Expected ',' or ')': function
(471,68-69): run-time error JS1004: Expected ';': {
(475,37-38): run-time error JS1002: Syntax error: }
(495,13-14): run-time error JS1002: Syntax error: }
(598,5-6): run-time error JS1002: Syntax error: }
(602,5-6): run-time error JS1195: Expected expression: }
(606,30-31): run-time error JS1004: Expected ';': {
(1011,2-3): run-time error JS1195: Expected expression: )
(1013,31-32): run-time error JS1004: Expected ';': {
(1157,2-3): run-time error JS1195: Expected expression: )
(1158,30-31): run-time error JS1004: Expected ';': {
(1275,2-3): run-time error JS1195: Expected expression: )
(1275,11-12): run-time error JS1197: Too many errors. The file might not be a JavaScript file: ;
 */
(function($, undefined) {
/*
    TrafficCop
    Author: Jim Cowart
    License: Dual licensed MIT (http://www.opensource.org/licenses/mit-license) & GPL (http://www.opensource.org/licenses/gpl-license)
    Version 0.3.0
*/

var inProgress = {};

$.trafficCop = function(url, options) {
    var reqOptions = url, key;
    if(arguments.length === 2) {
        reqOptions = $.extend(true, options, { url: url });
    }
    key = JSON.stringify(reqOptions);
    if (key in inProgress) {
        for (i in {done: 1, fail: 1, always: 1}) {
            inProgress[key][i](reqOptions[i]);
        }
    } else {
        // notify on any load start
        $(document).trigger("koTemplateLoadStart");

        inProgress[key] = $.ajax(reqOptions)
            .done(reqOptions.done)
            .fail(reqOptions.fail)
            .always(function() {
                delete inProgress[key];

                // trigger allTemplatesLoaded event when inProgress collection is empty
                // todo: investigate why "always" callback fires not directly after ajax but rather after ajax and cached templates were apllied
                if ($.isEmptyObject(inProgress)) {
                    $(document).trigger("koTemplatesLoaded");
                }
            });
    }
    return inProgress[key];
};

})(jQuery);

(function($, global, undefined) {
/*
    infuser.js
    Author: Jim Cowart
    License: Dual licensed MIT (http://www.opensource.org/licenses/mit-license) & GPL (http://www.opensource.org/licenses/gpl-license)
    Version 0.2.0
*/
var hashStorage = {
    templates: {},

    storeTemplate: function(templateId, templateContent) {
        this.templates[templateId] = templateContent;
    },

    getTemplate: function(templateId) {
        return this.templates[templateId];
    },

    purge: function() {
        this.templates = {};
    }
};
var scriptStorage = {
    templateIds: [],
    storeTemplate: function(templateId, templateContent) {
        var node = document.getElementById(templateId);
        if(node === null) {
            this.templateIds.push(templateId);
            node = document.createElement("script");
            node.type = "text/html";
            node.id = templateId;
            document.body.appendChild(node);
        }
        node.text = templateContent;
    },

    getTemplate: function(templateId) {
        return document.getElementById(templateId);
    },

    purge: function() {
        for(var i = 0; i < this.templateIds.length; i++) {
            document.body.removeChild(document.getElementById(this.templateIds[i]));
        }
        this.templateIds = [];
    }
};
var errorHtml = "<div class='infuser-error'>The template <a href='{TEMPLATEURL}'>{TEMPLATEID}</a> could not be loaded. {STATUS}</div>",
    returnErrorTemplate = function(status, templateId, templatePath) {
        return errorHtml.replace('{STATUS}', status).replace('{TEMPLATEID}', templateId).replace('{TEMPLATEURL}', templatePath);
    },
    errors = [];
var helpers = {
    getTemplatePath: function (templateOptions) {
        var templateFile = templateOptions.templatePrefix + templateOptions.templateId + templateOptions.templateSuffix;
        var templateUrl = templateOptions.templateUrl === undefined || templateOptions.templateUrl === ""
            ? templateFile
            : templateOptions.templateUrl + "/" + templateFile;

        return window.templateVersion
            ? templateUrl + '?v=' + window.templateVersion
            : templateUrl;
    },
    templateGetSuccess: function(templateId, callback) {
        return function(response) {
            infuser.store.storeTemplate(templateId, response);
            callback(infuser.store.getTemplate(templateId));
        };
    },
    templateGetError: function(templateId, templatePath, callback) {
        return function(exception) {
            if($.inArray(templateId, errors) === -1) {
                errors.push(templateId);
            }
            var templateHtml = returnErrorTemplate("HTTP Status code: " + exception.status, templateId, templatePath);
            infuser.store.storeTemplate(templateId, templateHtml);
            callback(infuser.store.getTemplate(templateId));
        };
    },
    getAjaxOptions: function(templateOptions) {

    }
},
infuserOptions = ['target','loadingTemplate','postRender','preRender','render','bindingInstruction','useLoadingTemplate','model','templateUrl','templateSuffix','templatePrefix',''];
var infuser = {
    storageOptions: {
        hash: hashStorage,
        script: scriptStorage
    },

    store: hashStorage,

    defaults: {
        // Template name conventions
        templateUrl: "",
        templateSuffix: ".html",
        templatePrefix: "",
        // AJAX Options
        ajax: {
            "async": true,
            "dataType": "html",
            "type": "GET"
        },
        // infuse() specific options - NOT used for "get" or "getSync"
        target:  function(templateId) { return "#" + templateId }, // DEFAULT MAPPING
        loadingTemplate:    {
            content: '<p></p>', // empty content while loading, use a spinner overlapping the whole onlineapp area
                                transitionIn:   function(target, content) {
                                                    var tgt = $(target);
                                                    //tgt.hide();
                                                    tgt.html(content);
                                                    //tgt.fadeIn();
                                                },
                                transitionOut: function (target) {
                                                    $(target).html("");
                                                }
                            },
        postRender:         function(targetElement) { }, // NO_OP effectively by default
        preRender:          function(targetElement, template) { }, // NO_OP effectively by default
        render:             function(target, template) {
                                var tgt = $(target);
                                if(tgt.children().length === 0) {
                                    tgt.append($(template));
                                }
                                else {
                                    tgt.children().replaceWith($(template));
                                }
                            },
        bindingInstruction:  function(template, model) { return template; }, // NO_OP effectively by default
        useLoadingTemplate: true // true/false
    },

    get: function (options, callback) {
        var templateOptions = $.extend({}, infuser.defaults, (typeof options === "object" ? options : { templateId: options })),
            template;
        templateOptions.ajax.url = helpers.getTemplatePath(templateOptions);
        template = infuser.store.getTemplate(templateOptions.ajax.url);
        if(!template || $.inArray(templateOptions.ajax.url, errors) !== -1) {
            templateOptions.ajax.done = helpers.templateGetSuccess(templateOptions.ajax.url, callback);
            templateOptions.ajax.fail = helpers.templateGetError(templateOptions.templateId, templateOptions.ajax.url, callback);
            $.trafficCop(templateOptions.ajax);
        }
        else {
            callback(template);
        }
    },

    getSync: function(options) {
        var templateOptions = $.extend({}, infuser.defaults, (typeof options === "object" ? options : { templateId: options }), { ajax: { async: false } }),
            template,
            templateHtml;
        templateOptions.ajax.url = helpers.getTemplatePath(templateOptions);
        template = infuser.store.getTemplate(templateOptions.ajax.url);
        if(!template || $.inArray(templateOptions.ajax.url, errors) !== -1) {
            templateHtml = null;
            templateOptions.ajax.done = function(response) { templateHtml = response; };
            templateOptions.ajax.fail = function(exception) {
                if($.inArray(templateOptions.ajax.url) === -1) {
                    errors.push(templateOptions.ajax.url);
                }
                templateHtml = returnErrorTemplate("HTTP Status code: exception.status", templateOptions.templateId, templateOptions.ajax.url);
            };
            $.ajax(templateOptions.ajax);
            if(templateHtml === null) {
                templateHtml = returnErrorTemplate("An unknown error occurred.", templateOptions.templateId, templateOptions.ajax.url);
            }
            else {
                infuser.store.storeTemplate(templateOptions.ajax.url, templateHtml);
                template = infuser.store.getTemplate(templateOptions.ajax.url);
            }
        }
        return template;
    },

    infuse: function(templateId, renderOptions) {
        var templateOptions = $.extend({}, infuser.defaults, (typeof templateId === "object" ? templateId : renderOptions), (typeof templateId === "string" ? { templateId: templateId } : undefined )),
            targetElement = typeof templateOptions.target === 'function' ? templateOptions.target(templateId) : templateOptions.target;
        if(templateOptions.useLoadingTemplate) {
            templateOptions.loadingTemplate.transitionIn(targetElement, templateOptions.loadingTemplate.content);
        }
        infuser.get(templateOptions, function(template) {
            var _template = template;
            templateOptions.preRender(targetElement, _template);
            _template = templateOptions.bindingInstruction(_template, templateOptions.model);
            if(templateOptions.useLoadingTemplate) {
                templateOptions.loadingTemplate.transitionOut(targetElement);
            }
            templateOptions.render(targetElement, _template);
            templateOptions.postRender(targetElement);
        });
    }
};
global.infuser = infuser; })(jQuery, window);


// Knockout External Template Engine
// Author: Jim Cowart
// License: MIT (http://www.opensource.org/licenses/mit-license)
// Version 2.0.4


(function ( global, ko, jQuery, infuser, undefined ) {

	var ExternalTemplateSource = function(templateId, options) {
	    var self = this, origAfterRender;
	    self.templateId = templateId;
	    self.loaded = false;
	    self.template = ko.observable(infuser.defaults.useLoadingTemplate ? infuser.defaults.loadingTemplate.content : undefined);
	    self.template.data = {};
	    self.options = ko.utils.extend({},options);
	    self.options.templateId = templateId;
	    if(self.options && self.options.afterRender) {
	        origAfterRender = self.options.afterRender;
	        // todo: investigate - afterRender fires twice when using self.options
	        // first time it fires for "Loading..." div element
	        // link https://github.com/fazzamar/Knockout.js-External-Template-Engine/commit/5b053acd0465cd5c98b947d97cbd4d2e675c9f52
	        options.afterRender = function() {
	            if (self.loaded) {
	                origAfterRender.apply(self.options, arguments);
	            }
	        };
	    }
	};
	
	ko.utils.extend(ExternalTemplateSource.prototype, {
	    data: function(key, value) {
	        if (arguments.length === 1) {
	            if(key === "precompiled") {
	                this.template();
	            }
	            return this.template.data[key];
	        }
	        this.template.data[key] = value;
	    },
	
	    text: function(value) {
	        if (!this.loaded) {
	           this.getTemplate();
	        }
	
	        if (arguments.length === 0) {
	            return this.template();
	        } else {
	           this.template(arguments[0]);
	        }
	    },
	
	    getTemplate: function() {
	        var self = this;
	        infuser.get(self.options, function(tmpl) {
	            self.data("precompiled",null);
	            self.template(tmpl);
	            self.loaded = true;
	        });
	    }
	});
	var KoExternalTemplateEngine = function(koEngineType) {
	    var engine = koEngineType ? new koEngineType() : new ko.nativeTemplateEngine();
	    engine.templates = {};
	    engine.makeTemplateSource = function(template, bindingContext, options) {
	        // Named template
	        if (typeof template == "string") {
	            var elem = document.getElementById(template);
	            if (elem)
	                return new ko.templateSources.domElement(elem);
	            else {
	                if(!engine.templates[template]) {
	                    engine.templates[template] = new ExternalTemplateSource(template, options);
	                }
	                return engine.templates[template];
	            }
	        }
	        else if ((template.nodeType == 1) || (template.nodeType == 8)) {
	            // Anonymous template
	            return new ko.templateSources.anonymousTemplate(template);
	        }
	        
	    };
	
	    engine.renderTemplate = function (template, bindingContext, options) {
	        var templateSource = engine.makeTemplateSource(template, bindingContext, options);
	        return engine.renderTemplateSource(templateSource, bindingContext, options);
	    };
	
	    return engine;
	};
	
	ko.KoExternalTemplateEngine = KoExternalTemplateEngine;
	
	if (jQuery['tmpl'] && jQuery['tmpl']['tag']['tmpl']['open'].toString().indexOf('__') >= 0) {
	    ko.setTemplateEngine(new KoExternalTemplateEngine(ko.jqueryTmplTemplateEngine));
	}
	else {
	    ko.setTemplateEngine(new KoExternalTemplateEngine());
	}

})( window, ko, jQuery, infuser );;
(function (window, undefined) {
    'use strict';

    var fail = function () {

        gJobs.screenReadersService.setAriaLiveNotification("Login was failed");

        toastr.warning(Resources.NotificationMessages.ServiceUnavailable);
        OnlineApp.Helpers.layoutHelper.hideOnlineAppInnerSpinner();
        OnlineApp.Helpers.layoutHelper.hideOnlineAppSpinner();
    };

    var jawsReaderIEFormFix = function () {
        // Focus on an empty span to prevent JAWS from reading the whole SignIn form in IE.
        if (gJobs.browserDetector.isIE()) {
            gJobs.screenReadersService.silenceScreenreader();
        }
    };

    function hideStickyHeader() {
        $('#sticky-header').hide();
        $('#content').removeClass('respect-sticky-header');
    }

    function SignInViewModel() {
        var self = this;
        self.firstFieldHasFocus = ko.observable(false);
        var ShowAccessMembershipDialog = false;    
        var CAPTCHA_USER_ANSWER_INPUT_ID_FOR_LOGIN = "captcha-user-answer-for-login";
        var CAPTCHA_INVALID_MESSAGE = "Captcha is invalid";
        self.textCaptchaViewModel = new OnlineApp.ViewModels.TextCaptchaViewModel("Login");
        self.textCaptchaViewModel.setCustomUserAnswerInputId(CAPTCHA_USER_ANSWER_INPUT_ID_FOR_LOGIN);
        self.needsCaptcha = ko.observable(false);
        OnlineApp.Services.captchaService.isCaptchaRequiredForLogin()
            .done(function (isCaptchaRequired) {
                if (isCaptchaRequired) {
                    self.textCaptchaViewModel.getTextCaptchaQuestion();
                    self.needsCaptcha(isCaptchaRequired);
                }
            });
            
        var success = function (data) {
            if (data.isCaptchaRequired) {
                if (data.errorMessage == CAPTCHA_INVALID_MESSAGE) {
                    self.textCaptchaViewModel.refreshCaptchaAndSetFocusonUserAns(true, CAPTCHA_INVALID_MESSAGE);
                }
                else {
                    self.textCaptchaViewModel.refreshCaptchaAndSetFocusonUserAns();
                }
                self.needsCaptcha(true);
            }

            if (data.forceRedirectUrl) {
                sessionStorage.setItem(OnlineApp.SessionKeys.PostBackUrl, window.location.href);
                if (self.showJobAlert()) {
                    sessionStorage.setItem(OnlineApp.LocalStorageKeys.RedirectToShowJobAlertPopup, "true");
                }
                window.location = data.forceRedirectUrl;
                return;
            }       
            OnlineApp.Helpers.layoutHelper.hideOnlineAppInnerSpinner();
            if (data.jobSeeker) {
                var savingProgress = "Saving... ";
                gJobs.screenReadersService.setAriaLiveNotification(savingProgress);
                gJobs.screenReadersService.setAriaLiveNotification("You are now logged in.");
                OnlineApp.Helpers.layoutHelper.showOnlineAppSpinner();

                var applicationViewModel = OnlineApp.ViewModels.applicationViewModel;
                applicationViewModel.load();
                applicationViewModel.isAuthorized(true);

                //Audit successfull login action

                if (!applicationViewModel.definitionsViewModel) {
                    applicationViewModel.definitionsViewModel = new OnlineApp.ViewModels.DefinitionsViewModel();
                }

                var menuStep = applicationViewModel.definitionsViewModel.menuStep.findItemByField('text', 'LoginSuccess');
                /* 
                    Alexei Skachykhin: In a context of Government Jobs, jobId may not even exists.
                                       Direct attempt to dereference missing observable causes TypeError.
                */
                var jobId = ko.utils.unwrapObservable(applicationViewModel.jobId);
                OnlineApp.Services.auditService.setAction(jobId, menuStep.id);

                var isInJobContext = !!jobId;

                $(document).trigger(OnlineApp.Events.CommonEventsNames.Login, {
                    identity: {
                        userName: self.username()
                    },
                    isInJobContext: isInJobContext
                });

                // trigger native Event
                document.dispatchEvent(new CustomEvent(Events.CommonEventsNames.Angular.Login));

                gJobs.common.analytics.trackLoginEvent('Online Account');

                OnlineApp.Services.jobAlertService.isJobAlertsEnabled()
                    .done(function (response) {
                        if (response.isJobAlertsEnabled) {
                            OnlineApp.Services.jobAlertService.isJobAlertCanBeCreated(OnlineApp.Helpers.Url.getJsonFromUrl(location.search))
                                .done(function (response) {
                                    if (response !== "") {
                                        hideStickyHeader();
                                        gJobs.dialogHelper.disableTabIndexOnParentView();
                                        $('#job-alert-out-container').html(response);
                                    }

                                    if (self.showJobAlert()) {
                                        hideStickyHeader();
                                        if (!ShowAccessMembershipDialog) {
                                            if ($('#job-alert-access-membership-popup')[0]) {
                                                OnlineApp.Services.jobAlertService.isAccessMembershipEnabled()
                                                    .done((isAccessMembershipEnabled) => {
                                                        if (!isAccessMembershipEnabled) {
                                                            $('#job-alert-access-membership-popup').removeClass('hidden');
                                                            gJobs.screenReadersService.setAriaLiveNotification("Enroll in Free Access Membership modal is opened.");
                                                            gJobs.dialogHelper.setTabIndexOnJobAlertsPopup('#job-alert-access-membership-popup');
                                                        }
                                                        else {
                                                            displayJobAlert();
                                                        }
                                                    });
                                            }
                                            else {
                                                displayJobAlert();
                                            }
                                        }

                                        function displayJobAlert() {
                                            $('#job-alert-out-container').removeClass('hidden');
                                            gJobs.dialogHelper.setTabIndexOnJobAlertsPopup("#setJobAlertDialog");
                                        }
                                    }
                                });
                        }
                    })

            } else {
                // TODO: replace with redirect to invalid login/password page 
                $(".standalone-validation-error").attr("aria-hidden", false);
                $(".form-signin").find("button[type=submit]").attr("aria-hidden", false);
                if (data.errorMessage != CAPTCHA_INVALID_MESSAGE) {
                    self.loginErrorMessage("");
                    self.loginErrorMessage(data.errorMessage);

                    $(".standalone-validation-error").focus();
                    $(document).trigger(Events.CommonEventsNames.LoginFailed);
                    $(".standalone-validation-error").attr("aria-hidden", true);
                    setTimeout(function () {
                        gJobs.screenReadersService.setAriaLiveNotification(data.errorMessage);
                    }, 300);
                }
            }
        };

        var currentUserNameFromUrlParam = window.utils.getUrlParameter('onLoadShowLoginWithUserName');
        if (!currentUserNameFromUrlParam) {
            currentUserNameFromUrlParam = '';
        }

        //Username or email for login.
        self.username = ko.observable().extend({
            required: {},
            composite: {
                validators: {
                    alphaNumericWithUnderscore: {},
                    email: {}
                },
                validationMessage: 'Invalid username or email.'
            },
        });

        self.password = ko.observable('').extend({ required: {} });
        self.showJobAlert = ko.observable(false);
        self.loginErrorMessage = ko.observable('');

        self.signInFormHeadingText = ko.observable('Sign in to apply');

        self.validate = function () {

            var isValid = true;

            self.username.validate();
            if (self.username.hasError()) {
                isValid = false;
            }

            self.password.validate();
            if (self.password.hasError()) {
                isValid = false;
            }

            self.textCaptchaViewModel.validate();
            if (self.needsCaptcha() && self.textCaptchaViewModel.userAnswer.hasError()) {
                isValid = false;
            }

            return isValid;
        };

        self.login = function () {
            if (self.validate()) {

                OnlineApp.Helpers.layoutHelper.showOnlineAppInnerSpinner();

                var promise;
                self.isBusy(true);
                if (self.needsCaptcha()) {
                    promise = OnlineApp.Services.authenticationService
                        .login(self.username(), self.password(), self.textCaptchaViewModel.userAnswer(), undefined, self.showJobAlert())
                        .always(function () {
                            self.isBusy(false);
                        })
                        .fail(fail)
                        .done(success);
                } else {
                    promise = OnlineApp.Services.authenticationService
                        .login(self.username(), self.password(), undefined, undefined, self.showJobAlert())
                        .always(function () {
                            self.isBusy(false);
                        })
                        .fail(fail)
                        .done(success);
                }

                jawsReaderIEFormFix();

                return promise;
            } else {
                OnlineApp.Helpers.layoutHelper.tabbing.activateFirstElement(undefined, function ($firstTabbingElement) {
                    gJobs.screenReadersService.onceNotification({
                        $element: $firstTabbingElement,
                        message: savingProgress + 'Entered form is invalid. Please fix the errors. '
                    });
                });
            }

            // TODO: replace call to jQuery
            return $.when();
        };

        self.isActive = ko.observable(true);

        self.isBusy = ko.observable(false);

        self.clearFields = function () {
            self.username('');
            self.username.hasError(false);

            self.password('');
            self.password.hasError(false);
        };
        $(document).on(Events.CommonEventsNames.OpenAccessMembershipDialog, function () {
            ShowAccessMembershipDialog = true;
        });
    }

    OnlineApp.Namespace.extend('OnlineApp.ViewModels', {
        SignInViewModel: SignInViewModel,
    });

})(window);
;
(function(window, undefined) {
    'use strict';

    var fail = function () {
        toastr.warning(Resources.NotificationMessages.ServiceUnavailable);
        OnlineApp.Helpers.layoutHelper.hideOnlineAppInnerSpinner();
        OnlineApp.Helpers.layoutHelper.hideOnlineAppSpinner();
    };

    var jawsReaderIEFormFix = function () {
        // Focus on an empty span to prevent JAWS from reading the whole SignIn form in IE.
        if (gJobs.browserDetector.isIE()) {
            gJobs.screenReadersService.silenceScreenreader();
        }
    };

    var captchaHelper = OnlineApp.Helpers.loginCaptchaHelper;

    // TODO: think about separating email/confirmEmail, username and password to separate entities inside of VM
    function RegisterViewModel() {
        var self = this;
        self.firstFieldHasFocus = ko.observable(false);
        self.isSubmitted = ko.observable(false);
        self.showJobAlert = ko.observable(false);

        self.textCaptchaViewModel = new OnlineApp.ViewModels.TextCaptchaViewModel();

        OnlineApp.Services.captchaService.isCaptchaRequiredForRegister()
            .done(function(isCaptchaRequired) {
                if (isCaptchaRequired) {
                    self.textCaptchaViewModel.getTextCaptchaQuestion();
                    self.needsCaptcha(true);
                }
            });

        var success = function (data) {

            //captchaHelper.resetCaptcha();

            OnlineApp.Helpers.layoutHelper.hideOnlineAppInnerSpinner();
            if (data.success) {
                if (data.forceRedirectUrl) {
                    window.location = data.forceRedirectUrl;
                    return;
                }

                var applicationViewModel = OnlineApp.ViewModels.applicationViewModel;

                applicationViewModel.load();
                applicationViewModel.isAuthorized(true);

                //Audit successfull register action

                if (!applicationViewModel.definitionsViewModel) {
                    applicationViewModel.definitionsViewModel = new OnlineApp.ViewModels.DefinitionsViewModel();
                }

                gJobs.screenReadersService.setAriaLiveNotification('Account created. You are now logged in.');

                var menuStep = applicationViewModel.definitionsViewModel.menuStep.findItemByField('text', 'Register');
                /* 
                    Alexei Skachykhin: In a context of Government Jobs, jobId may not even exists.
                                       Direct attempt to dereference missing observable causes TypeError.
                */
                var jobId = ko.utils.unwrapObservable(applicationViewModel.jobId);
                OnlineApp.Services.auditService.setAction(jobId, menuStep.id);

                var isInJobContext = !!jobId;

                $(document).trigger(OnlineApp.Events.CommonEventsNames.Register, {
                    identity: {
                        userName: self.username(),
                        email: self.email()
                    },
                    isInJobContext: isInJobContext
                });

                // trigger native Event
                document.dispatchEvent(new CustomEvent(Events.CommonEventsNames.Angular.Register));
                self.isUserRegisteredInCurrentSession(true);

                OnlineApp.Services.jobAlertService.isJobAlertsEnabled()
                    .done(function (isJobAlertsEnabled) {
                        if (isJobAlertsEnabled) {
                            OnlineApp.Services.jobAlertService.isJobAlertCanBeCreated(OnlineApp.Helpers.Url.getJsonFromUrl(location.search))
                                .done(function () {
                                    if (self.showJobAlert()) {
                                        $(document).on(Events.CommonEventsNames.CloseAccessMembershipDialog, function (event) {
                                            $('#job-alert-out-container').removeClass('hidden');
                                        });
                                    }
                                });
                        }
                    })
            } else {
                var promise;

                if (data.isCaptchaRequired) {
                    promise = self.textCaptchaViewModel.resetCaptcha()
                        .then(function() {
                            self.needsCaptcha(true);
                        });
                } else {
                    promise = $.when(function() { return true; });
                }

                promise.then(function() {
                    self.registerErrorMessage("");
                    self.email.validationMessage("");
                    switch (data.errorPropertyName) {
                        case 'Email':
                            self.email.hasError(true);
                            self.email.validationMessage(data.errorMessage);
                            self.email.isValidationMessageVisible(true);
                            self.hasEmailChangedAfterError(false);
                            self.externalEmailError(data.errorMessage);
                            OnlineApp.Helpers.layoutHelper.tabbing.activateFirstElement();
                            break;
                        case 'Username':
                            self.username.hasError(true);
                            self.username.validationMessage(data.errorMessage);
                            self.username.isValidationMessageVisible(true);
                            self.hasUsernameChangedAfterError(false);
                            self.externalUsernameError(data.errorMessage);
                            OnlineApp.Helpers.layoutHelper.tabbing.activateFirstElement();
                            break;
                        case 'Password':
                            self.password.hasError(true);
                            self.password.validationMessage(data.errorMessage);
                            self.password.isValidationMessageVisible(true);
                            self.hasPasswordChangedAfterError(false);
                            OnlineApp.Helpers.layoutHelper.tabbing.activateFirstElement();
                            break;
                        case 'Captcha':
                            self.textCaptchaViewModel.userAnswer.hasError(true);
                            self.textCaptchaViewModel.userAnswer.validationMessage(data.errorMessage);
                            self.textCaptchaViewModel.userAnswer.isValidationMessageVisible(true);
                            OnlineApp.Helpers.layoutHelper.tabbing.activateFirstElement();
                            break;
                        default:
                            self.registerErrorMessage(data.errorMessage);
                            $('.form-validation-error:visible').first().focus();
                            $('.form-validation-error:visible').first().on("blur",
                                function() {
                                    OnlineApp.Helpers.layoutHelper.tabbing.activateFirstElement();
                                    $(this).off("blur");
                                });
                            break;
                    }
                });

                return promise;
            }
        };

        self.createAccountFormHeadingText = ko.observable('Create a new account');

        self.needsCaptcha = ko.observable(false);

        self.username = ko.observable('').extend({
            required: {},
            alphaNumericWithUnderscore: {
                validationMessage: 'Username may contain only alphanumerics and underscore.',
                showValidationMessage: true
            }
        });
        self.isUsernameSelected = ko.observable(false);
        self.isUsernameAvailable = ko.computed(function () {
            return self.username() && !self.username.hasError();
        });
        self.isUsernameNotAvailable = ko.observable(false);
        self.hasUsernameChangedAfterError = ko.observable(true);
        self.externalUsernameError = ko.observable('');
        self.username.subscribe(function (value) {
            if (value) {
                self.checkUsername();
            } else {
                self.isUsernameNotAvailable(false);
            }

            self.hasUsernameChangedAfterError(true);
            self.externalUsernameError('')
        });
        self.isUsernameNotValid = ko.computed(function() {
            return self.isUsernameNotAvailable() || self.username.hasError();
        });

        self.email = ko.observable('').extend({ required: {}, email: {} });

        /* TODO - make refactoring of the code below - remove redundant variables */
        self.isEmailSelected = ko.observable(false);
        self.isEmailAllowed = ko.observable(false);
        self.isEmailAvailable = ko.computed(function () {
            return self.email() && !self.email.hasError();
        });
        self.isEmailNotAvailable = ko.observable(false);
        self.isEmailTooltipFocusable = ko.observable(true);
        self.hasEmailChangedAfterError = ko.observable(true);
        self.externalEmailError = ko.observable('');
        self.email.subscribe(function (value) {
            if (value) {
                self.checkEmail();
            } else {
                self.isEmailNotAvailable(false);
            }

            self.hasEmailChangedAfterError(true);
            self.externalEmailError('');
        });
        self.isEmailNotValid = ko.computed(function () {
            return self.isEmailNotAvailable() || self.email.hasError();
        });

        self.password = OnlineApp.ViewModels.Common.PasswordExtender({ required: {}, password: {} });
        self.passwordStrength = ko.observable('');
        self.isPasswordSelected = ko.observable(false);

        self.isInPasswordBlock = ko.observable(false);
        self.passwordRequirements = Resources.AdditionalInfoMessages.passwordRequirements;
        self.hasPasswordChangedAfterError = ko.observable(true);
        self.password.subscribe(function(value) {
            self.hasPasswordChangedAfterError(true);
        });
        self.inPasswordBlock = function () {
            self.isInPasswordBlock(true);
        };
        self.outOfPasswordBlock = function () {
            if (self.hasPasswordChangedAfterError()) {
                // set handling to the end of event queue
                setTimeout(function() {
                    if (self.isInPasswordBlock() && !self.isPasswordSelected() && !self.password.isConfirmPasswordSelected()) {
                        self.isInPasswordBlock(false);

                        self.password.validate();
                    }
                }, 0);
            }
        };

        self.outOfEmailBlock = function () {
            if (self.hasEmailChangedAfterError()) {
                // set handling to the end of event queue
                setTimeout(function () {
                    self.email.validate();
                }, 0);
            }
        };

        self.outOfUsernameBlock = function () {
            if (self.hasUsernameChangedAfterError()) {
                // set handling to the end of event queue
                setTimeout(function () {
                    self.username.validate();
                }, 0);
            }
        };

        self.showPasswordConfirmation = ko.computed(function() {
            return self.isInPasswordBlock() || !self.password.isPasswordConfirmed();
        });

        self.isPasswordAllowed = ko.computed(function() {
            return !self.password.hasError() && self.password.isPasswordConfirmed() && self.password();
        });

        self.registerErrorMessage = ko.observable('');

        self.validate = function () {
            var isValid = true;

            self.email.validate();
            if (self.email.hasError() || !self.hasEmailChangedAfterError()) {
                isValid = false;
            }

            self.username.validate();
            if (self.username.hasError() || !self.hasUsernameChangedAfterError()) {
                isValid = false;
            }

            self.password.validate();
            if (self.password.hasError() || !self.password.isPasswordConfirmed()
                || !self.hasPasswordChangedAfterError()) {
                isValid = false;
            }

            self.textCaptchaViewModel.validate();
            if (self.needsCaptcha() && self.textCaptchaViewModel.userAnswer.hasError()) {
                isValid = false;
            }

            return isValid;
        };

        self.checkUsername = function () {
            self.username.validate();
        };

        self.checkEmail = function () {
            self.email.validate();
            
        };

        self.emailIsValidNotificationMessage = ko.computed(function () {
            if (!self.isSubmitted()) {
                return '';
            }
            return !self.email() || self.email.hasError() ? 'email is not valid' : 'email is valid';
        });

        self.passwordsAreValidNotificationMessage = ko.computed(function () {
            return self.password() && self.password.isPasswordConfirmed() ? 'passwords match' : '';
        });

        self.register = function () {
            if (self.validate()) {
                var savingProgress = "Saving... ";
                gJobs.screenReadersService.setAriaLiveNotification(savingProgress);

                OnlineApp.Helpers.layoutHelper.showOnlineAppInnerSpinner();

                self.isBusy(true);

                if (self.needsCaptcha()) {

                    OnlineApp.Services.authenticationService
                    .register(self.username(),
                        self.password(),
                        self.email(),
                        self.textCaptchaViewModel.userAnswer())
                    .always(function () {
                        self.isBusy(false);
                    })
                    .fail(function (data) {
                        //fail with providedAnswer==false means that user closed the captcha modal without answering
                        if (!(data && data.providedAnswer === false)) {
                            fail();
                        }
                    })
                    .done(success);

                    var message = gJobs.common.analytics.messages.captchaMessage;
                    gJobs.common.analytics.trackLoginEvent(message + ' (CreateAccount)');
                } else {

                    OnlineApp.Services.authenticationService
                        .register(self.username(), self.password(), self.email())
                        .always(function () {
                            self.isBusy(false);
                        })
                        .done(success)
                        .fail(fail);
                }
                jawsReaderIEFormFix();
                self.isSubmitted(true);
            } else {
                self.isSubmitted(true);

                if (!self.hasEmailChangedAfterError() && !self.textCaptchaViewModel.hasError()) {
                    self.email.hasError(true);
                    self.email.validationMessage(self.externalEmailError());
                    self.email.isValidationMessageVisible(true);
                }

                if (!self.hasUsernameChangedAfterError() && !self.textCaptchaViewModel.hasError()) {
                    self.username.hasError(true);
                    self.username.validationMessage(self.externalUsernameError());
                    self.username.isValidationMessageVisible(true);
                }

                var $firstInvalidField = OnlineApp.Helpers.layoutHelper.tabbing.getFirstElement();

                var notificationContainerId = 'register-error-notification';
                var savingProgressContainerId = 'saving-progress-notification';

                gJobs.screenReadersService.onceAriaLabelledByNotification({
                    notificationContainerIds: savingProgressContainerId + ',' + notificationContainerId,
                    $element: $firstInvalidField
                });

                $firstInvalidField.focus();
            }
        };

        self.isActive = ko.observable(false);

        self.isUserRegisteredInCurrentSession = ko.observable(false);

        self.isBusy = ko.observable(false);

        self.clearFields = function () {
            self.username('');
            self.username.hasError(false);

            self.email('');
            self.email.hasError(false);

            self.password.clearFields();
        };
    }

    OnlineApp.Namespace.extend('OnlineApp.ViewModels', {
        RegisterViewModel: RegisterViewModel,
    });

})(window);
;
(function (window, undefined) {
    'use strict';

    var captchaHelper = OnlineApp.Helpers.loginCaptchaHelper;

    function LoginViewModel() {
        var self = this;
        self.schoolJobsConstant = window.SchoolJobSiteConstant;
        self.signInViewModel = new OnlineApp.ViewModels.SignInViewModel();
        self.registerViewModel = new OnlineApp.ViewModels.RegisterViewModel();

        self.loginFacebook = function (data, event) {
            var $externalSignInForm = $(event.target).closest('.form-external-signin');
            var showJobAlert = data.signInViewModel.showJobAlert();
            FB.login(function (loginResponse) {
                if (loginResponse.authResponse) {
                    $('<input>').attr({
                        type: 'hidden',
                        name: 'accessToken',
                        value: loginResponse.authResponse.accessToken
                    }).appendTo($externalSignInForm);

                    $('<input>').attr({
                        type: 'hidden',
                        name: 'provider',
                        value: 'Facebook'
                    }).appendTo($externalSignInForm);

                    if (window.enableTwoFactorAuthentication) {
                        sessionStorage.setItem(OnlineApp.SessionKeys.PostBackUrl, window.location.href);
                    }

                    if (showJobAlert) {
                        sessionStorage.setItem(OnlineApp.LocalStorageKeys.ShowJobAlertPopup, "true");
                    }

                    $externalSignInForm.trigger('submit');
                }
            }, { auth_type: 'reauthenticate', scope: 'email,public_profile' });
        }

        self.signInUrl = getSignInUrl();
        self.toggleModels = function (viewModel, e) {
            var isSignInActive = self.signInViewModel.isActive();
            var $container;
            var isStandaloneBlock = false;
            var isHeaderBlock = false;

            if (e) {
                if (e.currentTarget.id == 'login-button' || e.currentTarget.id == 'signup-button') {
                    isHeaderBlock = true;
                }

                $container = $(e.target).parents(".sign-in-sign-up-container");
                isStandaloneBlock = $container.parents("#standalone-sign-in-block").length > 0;
            }

            if (isSignInActive && e) {
                $(document).trigger(OnlineApp.Events.CommonEventsNames.RegisterAccountLinkClicked, e);
            }

            if (isSignInActive) {
                self.signInViewModel.clearFields();
            }
            else {
                self.registerViewModel.clearFields();
            }

            self.signInViewModel.isActive(!isSignInActive);
            self.registerViewModel.isActive(isSignInActive);

            if (self.registerViewModel.isActive() && self.registerViewModel.needsCaptcha())
                captchaHelper.renderCaptcha();

            $(document).trigger('layoutUpdated');

            self.registerViewModel.firstFieldHasFocus(isStandaloneBlock ? isSignInActive : false);
            self.signInViewModel.firstFieldHasFocus(isStandaloneBlock ? !isSignInActive : false);

            if (e && !isHeaderBlock) {
                if (isSignInActive) {
                    $(document).trigger(OnlineApp.Events.CommonEventsNames.RegisterAccountFormOpened, $container);
                } else {
                    $(document).trigger(OnlineApp.Events.CommonEventsNames.LoginFormOpened, $container);
                }
            }
        };

        self.onSignInLinkClick = function (e) {

            if (self.signInViewModel.isActive()) {
                self.signInViewModel.clearFields();
            } else {
                self.registerViewModel.clearFields();
            }

            if (gJobs && gJobs.signInForm && gJobs.signInForm.show && !gJobs.signInForm.isOpen()) {
                gJobs.signInForm.show();
            }
            setTimeout(function () {
                gJobs.signInForm.focusFirstTabbableElement();

                if (self.signInViewModel.isActive()) {
                    $(document).trigger(OnlineApp.Events.CommonEventsNames.LoginFormOpened);
                } else {
                    $(document).trigger(OnlineApp.Events.CommonEventsNames.RegisterAccountFormOpened);
                }
            });

            
        };

        self.onEmployerKeydown = function (el, e) {
            if (e.keyCode === $.ui.keyCode.SPACE) {
                window.location.href = $(e.target).attr("href");
            }
            return true;
        };



        function getSignInUrl() {
            var queryString = '/Oauth/Login?ReturnUrl=';

            if (window.location.hash && window.location.hash == '#_=_') {
                window.location.hash = '';
            }

            var currentUrl = encodeURIComponent(window.location.href);
            queryString += currentUrl;

            return queryString;
        };


    }

    


    OnlineApp.Namespace.extend('OnlineApp.ViewModels', {
        LoginViewModel: LoginViewModel
    });

})(window);;
(function(window, undefined) {
    'use strict';

    function TextCaptchaViewModel(keyForTextCaptchaAnswer) {
        var self = this;
        var isRefreshClicked = false;
        var setFocusonUserAnsInput = false;
        var keyForAnswer = keyForTextCaptchaAnswer ? keyForTextCaptchaAnswer : "";

        self.question = ko.observable();
        self.userAnswer = ko.observable('').extend({ required: {}});
        self.isBusy = ko.observable(false);
        self.customLabelHtmlContent = ko.observable("");
        self.customUserAnswerInputId = ko.observable("");

        self.getTextCaptchaQuestion = function () {
            self.isBusy(true);

            return OnlineApp.Services.captchaService.getCaptcha(keyForAnswer).done(function (question) {
                if (question) {
                    self.question(question);
                    gJobs.screenReadersService.setAriaLiveNotification('New captcha question is loaded', '.text-captcha-container .loaded-notification:visible');
                }
                if (isRefreshClicked) {
                    $('.reset-captcha').focus();
                }
                else if (setFocusonUserAnsInput) {
                    $('#' + self.getCustomIdForUserAnswerCaptcha()).focus();                    
                }
                else {
                    $('#skip-to-content-button').focus();
                }
            }).then(function () {
                self.isBusy(false);
                if (isRefreshClicked) {
                    $('.reset-captcha').focus();
                    isRefreshClicked = false;
                }
                else if (setFocusonUserAnsInput) {
                    $('#' + self.getCustomIdForUserAnswerCaptcha()).focus();   
                    setFocusonUserAnsInput = false;
                }
                else {
                    $('#skip-to-content-button').focus();
                }
            });
        }

        self.validate = function() {
            return self.userAnswer.validate();
        }

        self.hasError = function() {
            return self.userAnswer.hasError();
        }

        self.refreshCaptcha = function () {
            isRefreshClicked = true;
            self.resetCaptcha();
        }

        self.refreshCaptchaAndSetFocusonUserAns = function (hasError, errorMessage) {
            setFocusonUserAnsInput = true;
            self.resetCaptcha(hasError, errorMessage);
        }

        self.resetCaptcha = function (hasError, errorMessage, customUserAnswerInputId, updatedCaptchaQuestion) {
            self.userAnswer('');
            self.userAnswer.hasError(hasError);
            self.userAnswer.validationMessage(errorMessage);
            self.userAnswer.isValidationMessageVisible(hasError);

            if (updatedCaptchaQuestion) {
                self.question(updatedCaptchaQuestion);
                gJobs.screenReadersService.setAriaLiveNotification('New captcha question is loaded', '.text-captcha-container .loaded-notification:visible');
                $('#skip-to-content-button').focus();
            } else {
                self.getTextCaptchaQuestion();
            }
        }
        
        self.setCustomLabelHtmlContent = function (htmlContent) {
            if (self.customLabelHtmlContent() !== htmlContent) {
                self.customLabelHtmlContent(htmlContent);
            }
        }

        self.setCustomUserAnswerInputId = function (customUserAnswerInputId) {
            if (self.customUserAnswerInputId() !== customUserAnswerInputId) {
                self.customUserAnswerInputId(customUserAnswerInputId);
            }
        }

        self.getCaptchaLabelHtmlContent = function () {
            var customLabelHtmlContent = self.customLabelHtmlContent();

            if (customLabelHtmlContent) {
                return customLabelHtmlContent;
            } else {
                return "Please verify that you are not a robot<span class='sr-only'>.</span>";
            }
        }

        self.getCustomIdForUserAnswerCaptcha = function () {
            var customUserAnswerInputId = self.customUserAnswerInputId();
            if (customUserAnswerInputId) {
                return customUserAnswerInputId;
            } else {
                return 'text-captcha-user-answer';
            }
        }
    }

    OnlineApp.Namespace.extend('OnlineApp.ViewModels', {
        TextCaptchaViewModel: TextCaptchaViewModel,
    });

})(window);
;
(function (window, undefined) {
    'use strict';

    function ApplicationSignInViewModel() {

        var self = this;

        /*
            Define child view-models
        */
        (function () {
            var vm = OnlineApp.ViewModels;

            if (vm.LoginViewModel) {
                self.loginViewModel = new vm.LoginViewModel();
            }
        })();

        /*
            Public members.
        */
        self.isAuthorized = ko.observable(false);

        self.load = function() {
            // do nothing here
        };

        self.loginLoaded = function () {
            $(document).trigger('ApplicationSignInViewModel:ViewLoaded');
        };
        
        self.FocusinValidationVisibleChange = function (event, field) {
            if (event.type == 'focusin') {
                field.isValidationMessageVisible(false);
            } else if (event.type == 'focusout') {
                if (field.hasError()) {
                    field.isValidationMessageVisible(true);
                }
            }
        };

        self.checkIfShouldCreateNewAccount = function() {
            if (sessionStorage.getItem('shouldCreateNewAccount')) {
                sessionStorage.removeItem('shouldCreateNewAccount');

                self.loginViewModel.toggleModels(null, null);
            }
        };

        $(document).on("toggleLogInAndRegister", function (e, sourceEvent) {
            self.loginViewModel.toggleModels(null, sourceEvent);
        });
    }

    OnlineApp.Namespace.extend('OnlineApp.ViewModels', {
        applicationViewModel: new ApplicationSignInViewModel()
    });

    $(document).ready(function () {
        OnlineApp.Services.authenticationService
            .isLoggedIn()
            .fail(function () {
                toastr.warning(Resources.NotificationMessages.ServerConnectionFailed);
            })
            .done(function (data) {
                if (data) {
                    OnlineApp.ViewModels.applicationViewModel.isAuthorized(true);
                } else {
                    OnlineApp.ViewModels.applicationViewModel.isAuthorized(false);
                }
            });
    });

})(window);
;
(function (window, undefined) {
    'use strict';

    function ExternalSignInViewModel(options) {
        var self = this;

        self.username = ko.observable(options.username).extend({ required: {} });
        self.password = ko.observable('').extend({ required: {} });

        self.signInFormHeadingText = ko.observable('Confirm Credentials');

        self.loginErrorMessage = ko.observable('');

        self.isBusy = ko.observable(false);

        self.confirmCredentials = function () {
            if (!self.validate()) {
                return;
            }

            self.isBusy(true);

            OnlineApp.Services.authenticationService
                .confirmExternalLogin(self.username, self.password())
                .always(function () {
                    self.isBusy(false);
                })
                .fail(failCallback)
                .done(doneCallback);
        }
        var doneCallback = function (data) {
            if (data.returnUrl) {
                window.location.href = data.returnUrl;
            }

            if (data.errorMessage) {
                self.loginErrorMessage(data.errorMessage);
            }
        };
        var failCallback = function () {
            toastr.warning(Resources.NotificationMessages.ServiceUnavailable);
        };

        self.validate = function () {
            var isValid = true;

            self.username.validate();
            if (self.username.hasError()) {
                isValid = false;
            }

            self.password.validate();
            if (self.password.hasError()) {
                isValid = false;
            }

            return isValid;
        };
    }

    OnlineApp.Namespace.extend('OnlineApp.ViewModels', {
        ExternalSignInViewModel: ExternalSignInViewModel
    });

})(window);
;
(function (window, undefined) {
    'use strict';

    var $confirmCredentialsBlock = $('#confirm-credentials-block');

    //
    // Initializer
    //
    $(function () {
        if ($confirmCredentialsBlock.get(0)) {
            var options = {
                username: $confirmCredentialsBlock.data('username')
            };

            var externalSignInViewModel = new OnlineApp.ViewModels.ExternalSignInViewModel(options);

            ko.applyBindings(externalSignInViewModel, $confirmCredentialsBlock.get(0));
        }
    });

})(window);
;
(function (window, undefined) {
    'use strict';

    function triggerResourcesLinkClickEvent(linkType) {
        $(document).trigger(
            OnlineApp.Events.CommonEventsNames.ResourcesLinkClicked, 
            {'linkType': linkType}
        );
    }

    $('#resources-header-link').on('click', function() {
        triggerResourcesLinkClickEvent("header");
    });

    $('#resources-footer-link').on('click', function() {
        triggerResourcesLinkClickEvent("footer");
    });

})(window);
;