File Manager ASP.NET 2.0

Editing file: unifiedEnrollment.js

//
// Copyright (C) Microsoft. All rights reserved.
//
"use strict";
var CloudExperienceHost;
(function (CloudExperienceHost) {
    var UnifiedEnroll;
    (function (UnifiedEnroll) {
        var HTTP_E_STATUS_UNEXPECTED = -2145845247;
        var E_ABORT = -2147483641;
        var S_OK = 0;
        var DMLOGGING_ENROLLMENT = 0;
        var DMLOGGING_WEBAUTH = 1;
        var DMLOGGING_WEBAUTH_HTTP = 2;
        var WEB_AUTHENTICATION_STATUS_USER_CANCEL = 1;
        var WEB_AUTHENTICATION_STATUS_ERROR_HTTP = 2;
        var ENROLL_TYPE_MAM = 5;
        var ENROLL_TYPE_MDM_DEVICE_WITH_AAD = 6;
        var CONNECTIVITY_TIMEOUT = 1500000; // 25 minutes (in ms)
        var DSREG_E_CXH_DEVICE_NOT_JOINED = -2145647628;

// Make sure this matches ReflectedJoinType in EnterpriseDeviceManagement.idl
        var reflectedEnrollmentJoinType = {
            DeviceJoin: 0,
            UserJoin: 1,
            MAMWithDiscovery: 2,
            MAMWithoutDiscovery: 3,
            BulkDeviceJoin: 4,
            DeviceJoinForDomainJoin: 5
        };

CloudExperienceHost.Telemetry.logEvent("Device enrollment returned successfully with internal server error: " + enrollmentResultObject.enrollmentInternalError);
                            
                            if (enrollmentResultObject.enrollmentInternalError === 1) {
                                enrollmentResultObject.enrollmentInternalError = 0;
                            }

enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_ENROLLMENT, result.enrollmentInternalError);
                            completeDispatch(enrollmentResultObject);
                        }, function (e) {
                            enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_ENROLLMENT, e.number);
                            errorDispatch(e);
                        });
                    } else {
                        var emptyEnrollmentObject = {
                            enrollmentErrorCode: 0, enrollmentErrorString: "", enrollmentInternalError: 0, enrollmentGUIDAsString: ""
                        };
                        CloudExperienceHost.Telemetry.logEvent("AutopilotWhiteGlove hybrid mode detected, skipping enrollment");
                        completeDispatch(emptyEnrollmentObject);
                    }
                });
            });
        }
        UnifiedEnroll.doEnrollmentForDomainJoin = doEnrollmentForDomainJoin;
        function waitForDomainConnectivity() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.prepForFirstSignin();
                enterpriseManagementWorker.checkForDomainControllerConnectivity(CONNECTIVITY_TIMEOUT).then(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.waitForDomainConnectivity = waitForDomainConnectivity;
        function doUnenrollmentForDomainJoin() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.getEnrollment(ENROLL_TYPE_MDM_DEVICE_WITH_AAD).then(function (result) {
                    enterpriseManagementWorker.unenrollAsync(result).then(completeDispatch, errorDispatch);
                }, errorDispatch);
            });
        }
        UnifiedEnroll.doUnenrollmentForDomainJoin = doUnenrollmentForDomainJoin;
        function doWebAuth(webAuthUrl, upn, accessToken, deviceIdentifier, tenantIdentifier, ownership) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var appId = "";
                var platform = CloudExperienceHost.Environment.getPlatform();
                if (platform === CloudExperienceHost.TargetPlatform.MOBILE) {
                    // App SID of the old enrollment splash app, enrollUI.exe.
                    appId = "ms-app://s-1-15-2-4108341168-3731623572-3746702997-906799925-2574769856-1402521575-1149971147";
                } else {
                    // Desktop Settings appid.
                    appId = "ms-app://windows.immersivecontrolpanel";
                }

// Check for optional parameters from the Deep Link scenario
                var queryString = "";
                if (accessToken !== null)
                {
                    queryString = queryString + "&accesstoken=" + Windows.Foundation.Uri.escapeComponent(accessToken);
                }
                if (deviceIdentifier !== null) {
                    queryString = queryString + "&deviceidentifier=" + Windows.Foundation.Uri.escapeComponent(deviceIdentifier);
                }
                if (tenantIdentifier !== null) {
                    queryString = queryString + "&tenantidentifier=" + Windows.Foundation.Uri.escapeComponent(tenantIdentifier);
                }
                if (ownership !== 0)
                {
                    queryString = queryString + "&ownership=" + ownership;
                }

// Check if there is already a query string in the auth URL
                var startURI;
                var escapedUPN = Windows.Foundation.Uri.escapeComponent(upn);
                if (webAuthUrl.includes("?")) {
                    startURI = new Windows.Foundation.Uri(webAuthUrl + "&appru=" + Windows.Foundation.Uri.escapeComponent(appId) + "&login_hint=" + escapedUPN + "&username=" + escapedUPN + queryString);
                } else {
                    startURI = new Windows.Foundation.Uri(webAuthUrl + "?appru=" + Windows.Foundation.Uri.escapeComponent(appId) + "&login_hint=" + escapedUPN + "&username=" + escapedUPN + queryString);
                }

var stopURI = new Windows.Foundation.Uri(appId);
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.allowAuthUri(startURI);

Windows.Security.Authentication.Web.WebAuthenticationBroker.authenticateAsync(Windows.Security.Authentication.Web.WebAuthenticationOptions.useHttpPost | Windows.Security.Authentication.Web.WebAuthenticationOptions.useCorporateNetwork, startURI, stopURI).done(function (result) {
                    enterpriseManagementWorker.removeAuthUriAllowList();
                    var stringToSearch = "wresult=";
                    var beginningIndex = result.responseData.search(stringToSearch);
                    var endingIndex = result.responseData.indexOf("&", beginningIndex + stringToSearch.length);
                    var endString;
                    if (endingIndex === -1) {
                        endString = result.responseData.substring(beginningIndex + stringToSearch.length);
                    } else {
                        endString = result.responseData.substring(beginningIndex + stringToSearch.length, endingIndex);
                    }
                    var webAuthenticationResultObject = {
                        responseStatus: result.responseStatus, responseData: endString
                    };
                    if (WEB_AUTHENTICATION_STATUS_ERROR_HTTP === result.responseStatus) {
                        enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_WEBAUTH_HTTP, result.responseErrorDetail);
                    } else if (WEB_AUTHENTICATION_STATUS_USER_CANCEL === result.responseStatus) {
                        enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_WEBAUTH, E_ABORT);
                    } else {
                        enterpriseManagementWorker.eventWriteForEnrollment(DMLOGGING_WEBAUTH, S_OK);
                    }
                    completeDispatch(webAuthenticationResultObject);
                }, function (e) {
                    enterpriseManagementWorker.removeAuthUriAllowList();
                    enterpriseManagementWorker.eventWriteForEnrollment(1, e.number);
                    errorDispatch(e);
                });
            });
        }
        UnifiedEnroll.doWebAuth = doWebAuth;
        function checkCustomPageText() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.retrieveCustomAllDonePageAsync().then(function (result) {
                    var customAllDonePageResultsObject = {
                        customAllDonePageTitle: result.customAllDonePageTitle, customAllDonePageBody: result.customAllDonePageBody, customAllDonePageHyperlinkHref: result.customAllDonePageHyperlinkHref,
                        customAllDonePageHyperlinkText: result.customAllDonePageHyperlinkText
                    };
                    completeDispatch(customAllDonePageResultsObject);
                }, errorDispatch);
            });
        }
        UnifiedEnroll.checkCustomPageText = checkCustomPageText;
        function retrieveMamEnrollmentID() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.getEnrollment(ENROLL_TYPE_MAM).then(function (result) {
                    var enrollmentIDWithoutBrackets = result.substring(1, result.length -1);
                    completeDispatch(enrollmentIDWithoutBrackets);
                }, errorDispatch);
            });
        }
        UnifiedEnroll.retrieveMamEnrollmentID = retrieveMamEnrollmentID;
        function setMamEnrollmentAsDormant(enrollmentID) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.setEnrollmentAsDormant(enrollmentID, true, false).then(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.setMamEnrollmentAsDormant = setMamEnrollmentAsDormant;
        function completeMAMToMDMUpgrade(mdmEnrollmentID, mamEnrollmentID, isFailedUpgrade) {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.completeMAMToMDMUpgrade(mdmEnrollmentID, mamEnrollmentID, isFailedUpgrade).then(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.completeMAMToMDMUpgrade = completeMAMToMDMUpgrade;
        function createCorrelationVector() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var enterpriseManagementWorker = new EnterpriseDeviceManagement.Enrollment.ReflectedEnroller();
                enterpriseManagementWorker.createCorrelationVector().then(completeDispatch, errorDispatch);
            });
        }
        UnifiedEnroll.createCorrelationVector = createCorrelationVector;
        function checkIfPinPromptScenario() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var context = CloudExperienceHost.getContext();
                if (context.host.toLowerCase() !== "nthentormdm" && context.host.toLowerCase() !== "nthaadormdm") {
                    completeDispatch(true);
                } else {
                    completeDispatch(-1 !== context.source.toLowerCase().indexOf("ngc=enabled"));
                }
            });
        }
        UnifiedEnroll.checkIfPinPromptScenario = checkIfPinPromptScenario;
        function resetDevice() {
            return new WinJS.Promise(function (completeDispatch, errorDispatch) {
                var pluginManager = new CloudExperienceHostAPI.Provisioning.PluginManager();
                pluginManager.initiateSystemResetAsync().then(function (results) {
                    bridge.invoke("CloudExperienceHost.Telemetry.logEvent", "UnifiedEnrollment_ProvisioningProgressPage_ResetDevice_Successful");
                    completeDispatch(true);
                }, function (e) {
                    bridge.invoke("CloudExperienceHost.Telemetry.logEvent", "UnifiedEnrollment_ProvisioningProgressPage_ResetDevice_Error", JSON.stringify({ error: e }));
                    errorDispatch(e);
                });
            });
        }
        UnifiedEnroll.resetDevice = resetDevice;
        function localizedStrings() {
            var unifiedEnrollmentResources = {};
            var keyList = ['Title', 'LeadText', 'Description', 'UserPlaceholder', 'ServerUrlPlaceholder', 'FooterHeader', 'DjLink', 'Error_NoUsername', 'Error_UsernameFormat',
                'Error_UsernameLookup', 'Error_DomainLookup', 'Error_Network', 'Error_Generic_Code', 'Error_Generic', 'NextButton', 'Error_MDM_StandardUser', 'Error_MDM_AlreadyConnected',
                'Error_MDM_DiscoveryError', 'DomainUsernamePlaceholder', 'PasswordPlaceholder', 'EnrollerLeadText', 'EnrollmentErrorFinishedTitle',
                'EnrollmentErrorFinishedLeadText', 'EnrollmentFinishedTitle', 'EnrollmentFinishedLeadText', 'FinishedButton', 'InsecureRedirectTitle', 'InsecureRedirectLeadText',
                'InsecureRedirectDescription', 'InvalidCertTitle', 'InvalidCertLeadText', 'InvalidCertDescription', 'TraceIdError', 'WebAuthError', 'MENROLL_E_DEVICE_UNKNOWN_ERROR', 'MENROLL_E_DEVICENOTSUPPORTED',
                'MENROLL_E_CONNECTIVITY', 'MENROLL_E_DEVICECAPREACHED', 'MENROLL_E_DEVICE_AUTHENTICATION_ERROR', 'MENROLL_E_PROV_UNKNOWN', 'MENROLL_E_PLATFORM_UNKNOWN_ERROR', 'DiscoveryProgressText',
                'WABProgressText', 'Error_MAM_DiscoveryError', 'MAMWebAuthError', 'EnrollmentProgressPoliciesText', 'EnrollmentProgressProfilesText', 'EnrollmentProgressAppsText', 'EnrollmentProgressCertificatesText',
                'EnrollmentProgressPolicyNotStartedText', 'EnrollmentProgressPolicyInProgressText', 'EnrollmentProgressPolicyFinishedText', 'EnrollmentProgressProfileNotStartedText', 'EnrollmentProgressProfileInProgressText', 
                'EnrollmentProgressProfileFinishedText', 'EnrollmentProgressApplicationNotStartedText', 'EnrollmentProgressApplicationInProgressText', 'EnrollmentProgressApplicationFinishedText',
                'EnrollmentProgressCertificateNotStartedText', 'EnrollmentProgressCertificateInProgressText', 'EnrollmentProgressCertificateFinishedText', 'EnrollmentProgressNotifyOfNotificationText',
                'UserNarratorText', 'ServerUrlNarratorText'];
            keyList.forEach(function (key) {
                var resourceId = '/unifiedEnrollment/' + key;
                unifiedEnrollmentResources[key] = WinJS.Resources.getString(resourceId).value;
            });
            return JSON.stringify(unifiedEnrollmentResources);
        }
        UnifiedEnroll.localizedStrings = localizedStrings;
        function localizedProvProgressStrings() {
            var unifiedEnrollmentResources = {};
            var keyList = ['BootstrapPageTitle', 'BootstrapPageRebootWarning', 'BootstrapPageDevicePrepTitle', 'BootstrapPageDeviceSetupTitle', 'BootstrapPageAccountSetupTitle', 'BootstrapPageShowDetailButton',
            'BootstrapPageGettingReady', 'BootstrapPageWaitingForPrevious', 'BootstrapPageComplete', 'BootstrapPageWorking', 'BootstrapPageStillWorking', 'BootstrapPageTPM', 'BootstrapPageAADJ', 'BootstrapPagePrepareMDM',
            'BootstrapPageMDM', 'BootstrapPageIdentifying', 'BootstrapPageAuthentication', 'BootstrapPageSecurityPolicies', 'BootstrapPageCertificates', 'BootstrapPageNetwork', 'BootstrapPageApps', 'BootstrapPagePolicyTrack',
            'BootstrapPageNetworkTrack', 'BootstrapPageAppTrack', 'BootstrapPageDontClose', 'BootstrapPagePatience', 'BootstrapPageFailed', 'BootstrapPageDefualtError', 'BootstrapPageCollectLogs',
            'BootstrapPageResetDevice', 'BootstrapPageTryAgain', 'BootstrapPageContinue', 'BootstrapPagePrevStepFailed', 'BootstrapPageContinueMessage', 'BootstrapPageSignInWait', 'BootstrapPageNotSetUp'];
            keyList.forEach(function (key) {
                var resourceId = '/unifiedEnrollment/' + key;
                unifiedEnrollmentResources[key] = WinJS.Resources.getString(resourceId).value;
            });
            return JSON.stringify(unifiedEnrollmentResources);
        }
        UnifiedEnroll.localizedProvProgressStrings = localizedProvProgressStrings;
    })(UnifiedEnroll = CloudExperienceHost.UnifiedEnroll || (CloudExperienceHost.UnifiedEnroll = {}));
})(CloudExperienceHost || (CloudExperienceHost = {}));