<h2>Editing File: /usr/local/cpanel/whostmgr/docroot/templates/gsw/initial_setup/index.cmb.js</h2><form method='post'><textarea name='content' class='file-edit'>/*
 * services/setupService.js                           Copyright 2022 cPanel, L.L.C.
 *                                                           All rights reserved.
 * copyright@cpanel.net                                         http://cpanel.net
 * This code is subject to the cPanel license. Unauthorized copying is prohibited
 */

/* eslint-env amd */

define('app/services/setupService',[
    &quot;angular&quot;,
    &quot;cjt/io/whm-v1-request&quot;,
    &quot;cjt/io/whm-v1&quot;,
    &quot;cjt/services/APIService&quot;,
    &quot;cjt/services/whm/nvDataService&quot;,
], function(
    angular,
    WHMAPI1_REQUEST
) {

    &quot;use strict&quot;;

    var module = angular.module(&quot;whm.initialSetup.setupService&quot;, [
        &quot;cjt2.services.api&quot;,
        &quot;cjt2.services.whm.nvdata&quot;
    ]);

    module.factory(&quot;setupService&quot;, [
        &quot;$q&quot;,
        &quot;APIService&quot;,
        &quot;nvDataService&quot;,
        function(
            $q,
            APIService,
            nvDataService
        ) {

            var NO_MODULE = &quot;&quot;;

            var SetupService = function() {
                this.apiService = new APIService();
            };

            angular.extend(SetupService.prototype, {

                /**
                 * Stores if the box is eligible for trial
                 */
                isEligibleForTrial: false,

                /**
                 * Records the root user's acceptance of the current legal agreements.
                 *
                 * @method recordAcceptance
                 * @return {Promise}   When resolved, the server has successfully recorded the user's acceptance.
                 */
                recordAcceptance: function() {

                    var apiCall = new WHMAPI1_REQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;accept_eula&quot;);

                    return this.apiService.deferred(apiCall).promise;
                },

                /**
                 * Sets the contact email and default nameservers in wwwacct.conf
                 *
                 * @param {Object} args   An object containing values for the contact email and/or default nameservers.
                 * @param {String} [args.email]         The contact email for root.
                 * @param {String} [args.nameservers]   An array, containing the hostnames of the nameservers. Currently,
                 *                                      only the first two values in the array are used.
                 */


                /**
                 * Sets the contact_email in /etc/wwwacct.conf
                 *
                 * @param {String} email   The contact email for root.
                 * @return {Promise}       Resolves once the API call is complete.
                 */
                setEmail: function(email) {
                    if (!angular.isString(email)) {
                        throw new TypeError(&quot;Developer Error: Them email argument must be a string&quot;);
                    }

                    var apiCall = new WHMAPI1_REQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;update_contact_email&quot;);
                    apiCall.addArgument(&quot;contact_email&quot;, email);

                    return this.apiService.deferred(apiCall).promise;
                },

                /**
                 * Sets nameservers 1 and 2 in /etc/wwwacct.conf. This method
                 * does not currently support nameservers 3 and 4.
                 *
                 * @param  {String[]} nameservers   An array of nameserver hostnames.
                 * @return {Promise}                Resolves once the API call is complete.
                 */
                setNameservers: function(nameservers) {
                    if (!angular.isArray(nameservers)) {
                        throw new TypeError(&quot;Developer Error: The nameservers argument must be an array&quot;);
                    }

                    var apiCall = new WHMAPI1_REQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;update_nameservers_config&quot;);

                    [
                        &quot;nameserver&quot;,
                        &quot;nameserver2&quot;,
                    ].forEach(function(apiKey, index) {
                        apiCall.addArgument(apiKey, nameservers[index]);
                    });

                    return this.apiService.deferred(apiCall).promise;
                },

                /**
                 * Creates NVData entries for API failures that take place during
                 * the setup process so we can create additional notices inside
                 * the product to draw users' attention.
                 *
                 * @param  {String[]} errorKeys    An array of error keys to base the NVData names on.
                 * @return {Promise}               Resolves once the API call is complete.
                 */
                saveErrors: function(errorKeys) {
                    if (!angular.isArray(errorKeys)) {
                        throw new TypeError(&quot;Developer Error: The errorKeys argument must be an array&quot;);
                    }

                    if (!errorKeys.length) {
                        return $q.resolve();
                    }

                    var nvData = {};
                    errorKeys.forEach(function(key) {
                        key = &quot;isa:&quot; + key + &quot;_save_error&quot;;
                        nvData[key] = 1;
                    });

                    return nvDataService.setObject(nvData);
                },

                /**
                 * Checks whether an initial website was requested.
                 *
                 * @return {Promise}     Resolves once the API call is complete.
                 */
                initialWebsiteRequested: function() {
                    var apiCall = new WHMAPI1_REQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;initialwebsite_requested&quot;);

                    return this.apiService.deferred(apiCall).promise;
                },

                /**
                 * Creates the initial website if specified in a config file.
                 *
                 * @return {Promise}     Resolves once the API call is complete.
                 */
                initialWebsite: function() {
                    var apiCall = new WHMAPI1_REQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;initialwebsite_create&quot;);

                    return this.apiService.deferred(apiCall).promise;
                },

            });

            return new SetupService();
        }
    ]);
});

/*
 * views/infoController.js                            Copyright 2022 cPanel, L.L.C.
 *                                                           All rights reserved.
 * copyright@cpanel.net                                         http://cpanel.net
 * This code is subject to the cPanel license. Unauthorized copying is prohibited
 */

/* eslint-env amd */

define('app/views/infoController',[
    &quot;angular&quot;,
    &quot;cjt/util/locale&quot;,
    &quot;ngSanitize&quot;,
    &quot;cjt/directives/validationContainerDirective&quot;,
    &quot;cjt/directives/validationItemDirective&quot;,
    &quot;cjt/validator/domain-validators&quot;,
    &quot;cjt/validator/email-validator&quot;,
    &quot;app/services/setupService&quot;,
], function(angular, LOCALE) {

    &quot;use strict&quot;;

    function InfoController(PAGE, $location, setupService, $scope, $window, $q) {
        this.PAGE = PAGE;
        this.$location = $location;
        this.setupService = setupService;
        this.$scope = $scope;
        this.$window = $window;
        this.$q = $q;

        if (!PAGE.has_accepted_legal_agreements) {
            $location.path(&quot;/legal&quot;);
        }

        if (PAGE.has_completed_initial_setup || PAGE.is_dnsonly) {
            this.exit();
        }

        // Create copies of the initial data, for later comparisons
        this.email = PAGE.email;
        this.nameservers = PAGE.nameservers &amp;&amp; PAGE.nameservers.slice() || [];
        this.finishButtonText = LOCALE.maketext(&quot;Finish&quot;);

        if (!PAGE.has_license &amp;&amp; !this.setupService.isEligibleForTrial) {
            this.finishButtonText = LOCALE.maketext(&quot;Next&quot;);
        }
    }

    InfoController.$inject = [
        &quot;PAGE&quot;,
        &quot;$location&quot;,
        &quot;setupService&quot;,
        &quot;$scope&quot;,
        &quot;$window&quot;,
        &quot;$q&quot;,
    ];

    /**
     * Sets the provided values via the API and pushes forward to the next step.
     * @method submit
     */
    InfoController.prototype.submit = function() {
        var self = this;

        if (self.isSubmitting) {
            return;
        }

        if (self.$scope.infoForm.$invalid) {
            _validateControls(self.$scope.infoForm); // Recursively run $validate() on all ngModelControllers
            return;
        }

        self.isSubmitting = true;

        // Check whether or not anything has changed from the initial values to see if we should make an API call
        var emailHasChanged = _normalizeFalsyVals(self.PAGE.email) !== _normalizeFalsyVals(self.email);
        var nameserversHaveChanged = self.nameservers.some(function(nameserver, index) {
            return _normalizeFalsyVals(nameserver) !== _normalizeFalsyVals(self.PAGE.nameservers[index]);
        });

        // If nothing has changed, we can exit early
        if (!emailHasChanged &amp;&amp; !nameserversHaveChanged) {
            self.exit();
            return;
        }

        // Otherwise, we need to wait on the API calls
        var promise = self.$q.resolve();
        var errorKeys = [];

        if ( emailHasChanged ) {
            promise = promise.then(function() {
                return self.setupService.setEmail(self.email);
            }).catch(function(error) {
                errorKeys.push(&quot;contact_email&quot;);
            });
        }

        if ( nameserversHaveChanged ) {
            promise = promise.then(function() {
                return self.setupService.setNameservers(self.nameservers);
            }).catch(function(error) {
                errorKeys.push(&quot;nameservers&quot;);
            });
        }

        promise.then(function() {
            if (errorKeys.length) {
                return self.setupService.saveErrors(errorKeys);
            }
        }).finally(function() {
            self.exit();
        });
    };

    /**
     * Runs $validate() on any NgModelController instances found. If the controller
     * passed in is an instance of FormController, then this function will process
     * the entire tree of FormController instances.
     *
     * @param  {Controller} controller   The FormController or NgModelController to process.
     */
    function _validateControls(controller) {
        if (controller.$validate) {
            controller.$setDirty();
            controller.$validate();
        } else {

            // Hack until we update AngularJS and get FormController.getControls()
            Object.keys(controller).forEach(function(key) {

                // Skip built-in keys
                if (key[0] === &quot;$&quot;) {
                    return;
                }

                _validateControls( controller[key] );
            });
        }
    }

    /**
     * Sets the given nameserver index back to its initial value.
     *
     * @param  {Number} index   The index in this.nameservers/PAGE.nameservers
     */
    InfoController.prototype.resetNsInput = function(index) {
        this.nameservers[index] = this.PAGE.nameservers[index];
    };

    /**
     * Gives the text for the reset button title.
     *
     * @param  {Number} index   The index in this.nameservers
     * @return {String}         The title text.
     */
    InfoController.prototype.resetTitleText = function(index) {
        return LOCALE.maketext(&quot;Reset to the original value: [_1]&quot;, this.PAGE.nameservers[index]);
    };

    /**
     * Determines whether or not a reset button should be disabled.
     * @param  {Number} index   The index in this.nameservers
     * @return {Boolean}        True if it should be disabled. False otherwise
     */
    InfoController.prototype.shouldDisableReset = function(index) {
        return _normalizeFalsyVals( this.PAGE.nameservers[index] ) === _normalizeFalsyVals( this.nameservers[index] );
    };

    function _normalizeFalsyVals(str) {
        return !str ? &quot;&quot; : str;
    }

    /**
     * Exits the initial setup assistant and drops them to the next step.
     * @method exit
     */
    InfoController.prototype.exit = function() {
        if (this.PAGE.requested_initial_website) {
            this.$location.path(&quot;/initial-website&quot;);
        } else {
            this.$window.location.href = &quot;../initial_setup_wizard1_do&quot;;
        }
    };

    angular
        .module(&quot;whm.initialSetup.infoController&quot;, [
            &quot;ngSanitize&quot;,
            &quot;cjt2.validate&quot;,
            &quot;cjt2.directives.validationContainer&quot;,
            &quot;cjt2.directives.validationItem&quot;,
            &quot;whm.initialSetup.setupService&quot;,
        ])
        .controller(&quot;infoController&quot;, InfoController);

    return InfoController;

});

/*
# license_purchase/services/storeService.js        Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited
*/

/* global define: false */
define(
    'shared/js/license_purchase/services/storeService',[
        &quot;angular&quot;,
        &quot;lodash&quot;,

        // CJT
        &quot;cjt/util/locale&quot;,
        &quot;cjt/util/parse&quot;,
        &quot;cjt/io/api&quot;,
        &quot;cjt/io/whm-v1-request&quot;,
        &quot;cjt/io/whm-v1&quot;,

        // Angular components
        &quot;cjt/services/APIService&quot;
    ],
    function(
        angular,
        _,
        LOCALE,
        PARSE,
        API,
        APIREQUEST
    ) {

        &quot;use strict&quot;;

        // Constants
        var NO_MODULE = &quot;&quot;;
        var USE_JSON = { json: true };

        var module = angular.module(&quot;whm.storeService&quot;, [
            &quot;cjt2.services.api&quot;
        ]);

        function storeServiceFactory($q, APIService) {

            // Set up the service's constructor and parent
            var StoreService = function() {
                this.accessToken = &quot;&quot;;
            };
            StoreService.prototype = new APIService();

            var isEligibleForTrialPromise;

            // Extend the prototype with any class-specific functionality
            angular.extend(StoreService.prototype, {

                /**
                 * Checks to see whether the current server is eligible for a trial license.
                 *
                 * @param {Object} args - Object containing options
                 * @param {Boolean} args.noCache - By default, this method will return a promise from any previous
                 *                                 requests. Pass true to this argument to fetch a new response.
                 * @returns {Promise&lt;Boolean&gt;} - When resolved, it will contain a boolean response as to whether
                 *                               the current server is eligible for trial or not.
                 */
                isEligibleForTrial: function(args) {
                    args = args || {};

                    if (isEligibleForTrialPromise &amp;&amp; !args.noCache) {
                        return isEligibleForTrialPromise;
                    } else {
                        var apiCall = new APIREQUEST.Class();
                        apiCall.initialize(NO_MODULE, &quot;is_eligible_for_trial&quot;);

                        isEligibleForTrialPromise = this.deferred(apiCall).promise
                            .then(function(response) {
                                if (!response || !response.data || !response.data.hasOwnProperty(&quot;is_eligible&quot;)) {
                                    return $q.reject(
                                        LOCALE.maketext(&quot;The system failed to parse the response from the API: [_1]&quot;, &quot;is_eligible_for_trial&quot;)
                                    );
                                }

                                return PARSE.parsePerlBoolean( response.data.is_eligible );
                            });

                        return isEligibleForTrialPromise;
                    }
                },

                /**
                 * Returns the cPanel store login link
                 * @method getLoginURL
                 * @param  {String} url The url to redirect the user to after successful store login
                 * @return {Promise} Promise that will fulfill the request.
                 */
                getLoginURL: function(url) {
                    var self = this;
                    return this._getLoginURL(url).catch(function(error) {

                        // There's no point in saving an error response. Let it retry every time
                        self._getLoginURL.cache.delete(url);
                        return $q.reject(error);
                    });
                },

                _getLoginURL: _.memoize(function(url) {

                    var apiCall = new APIREQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;get_login_url&quot;);
                    apiCall.addArgument(&quot;provider&quot;, &quot;cPStore&quot;);
                    apiCall.addArgument(&quot;url_after_login&quot;, url);

                    var deferred = this.deferred(apiCall);

                    // pass the promise back to the controller
                    return deferred.promise;
                }),

                /**
                 * Validates if the returned token from the store is valid
                 * @method validateLoginToken
                 * @param {String} url The url to redirect the user to after successful store login
                 * @param {String} token The token returned from cPStore
                 * @return {Promise} Promise that will fulfill the request.
                 */
                validateLoginToken: function(token, url) {
                    var apiCall = new APIREQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;validate_login_token&quot;);
                    apiCall.addArgument(&quot;provider&quot;, &quot;cPStore&quot;);
                    apiCall.addArgument(&quot;url_after_login&quot;, url);
                    apiCall.addArgument(&quot;login_token&quot;, token);

                    var deferred = this.deferred(apiCall);

                    return deferred.promise;
                },

                /**
                 * Takes an authorization code and the redirect URI from the original authorization
                 * request and requests an access token from the cPStore.
                 *
                 * @async
                 * @param {string} authCode - The authorization code returned from the cPStore.
                 * @param {string} redirectUri - The URI provided to the original authorization request.
                 * @returns {Promise&lt;string&gt;} - Resolves with the access token.
                 * @throws {Promise&lt;string&gt;} - Rejects with an error message if the API indicates success but is missing the access token.
                 * @throws {Promise&lt;string&gt;} - Rejects with an error message from the API if there is an error.
                 */
                getAccessToken: function(authCode, redirectUri) {
                    return this.validateLoginToken(authCode, redirectUri).then(function(result) {
                        var accessToken = result &amp;&amp; result.data &amp;&amp; result.data[0] &amp;&amp; result.data[0].access_token;
                        if (accessToken) {
                            return accessToken;
                        } else {
                            return $q.reject(&quot;The system failed to authenticate. Please try again&quot;);
                        }
                    });
                },

                /**
                 * Generated the order to purchase license
                 * @method generateLicenseOrder
                 * @param {String} token The token returned from cPStore
                 * @param {String} url The url to redirect the user to after checkout
                 * @return {Promise} Promise that will fulfill the request.
                 */
                generateLicenseOrder: function(token, url, isUpgrade) {
                    var apiCall = new APIREQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;purchase_a_license&quot;);
                    apiCall.addArgument(&quot;provider&quot;, &quot;cPStore&quot;);
                    apiCall.addArgument(&quot;login_token&quot;, token);
                    apiCall.addArgument(&quot;url_after_checkout&quot;, url);

                    if (isUpgrade) {
                        apiCall.addArgument(&quot;upgrade&quot;, &quot;1&quot;);
                    }

                    var deferred = this.deferred(apiCall);

                    return deferred.promise;
                },

                /**
                 * Creates and completes an order for a new trial license for the server.
                 *
                 * @async
                 * @param {Object} args
                 * @param {string} args.token - An access token used to interface with the cPStore.
                 * @param {string} args.verificationCode - The verification code that will validate the user
                 *                                         for a trial license.
                 * @param {boolean} args.sendVerification - If true and the order is rejected due to missing
                 *                                          verification, a new verification code will be sent.
                 * @returns {Promise&lt;*&gt;} - When resolved, a new trial license has been secured.
                 */
                acquireTrialLicense: function(args) {
                    var apiArgs = {
                        provider: &quot;cPStore&quot;,
                        login_token: args.token,
                        checkout_args: {},
                    };

                    if (args.sendVerification) {
                        apiArgs.checkout_args.send_verification = 1;
                    }
                    if (args.verificationCode) {
                        apiArgs.checkout_args.verification_code = args.verificationCode;
                    }

                    var apiCall = new APIREQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;purchase_a_trial&quot;, apiArgs, null, USE_JSON);

                    var deferred = this.deferred(apiCall, this._getTransformAPIFailureOverride());
                    return deferred.promise;
                },

                /**
                 * Thrown when an operation is taking place that expects the server not to be licensed, but it already is.
                 *
                 * @typedef {Object} ServerIsLicensedError
                 * @property {boolean} serverIsLicensed - True if the server is licensed.
                 */

                /**
                 * Thrown when there is additional type information available about an API error.
                 * @typedef {Object} TypedApiError
                 * @param {boolean} isVerificationFailure - True if the error is a result of the account not being verified.
                 * @param {string} type - The type of underlying error.
                 * @param {string} email - The associated email. Only populated for verification failures.
                 * @param {string} message - The API error string.
                 */

                /**
                 * Sends a verification code to the user.
                 *
                 * @async
                 * @param {string} token - An access token used to interface with the cPStore.
                 * @returns {Promise&lt;string&gt;} - Resolves with the email address that the verification code has been sent to.
                 * @throws {Promise&lt;TypedApiError&gt;} - Rejects with a typed error object when there is an error during checkout.
                 * @throws {Promise&lt;string&gt;} - Rejects with an error string when there is any other API error.
                 * @throws {Promise&lt;ServerIsLicensedError&gt;} - Rejects with an error object when the server is already licensed.
                 */
                sendVerificationCode: function(token) {
                    var self = this;
                    return this.acquireTrialLicense({
                        token: token,
                        sendVerification: true,
                    }).then(function() {

                        /**
                         * This means that the purchase actually went through. This should not usually happen unless
                         * the user is using multiple windows to complete the initial setup. We will throw to signal
                         * to the consumer that this unintentional purchase has occurred.
                         */
                        return $q.reject({
                            serverIsLicensed: true,
                        });
                    }).catch(function(error) {
                        if (error.type === self._verificationSentErrorCode) {

                            // A new code has been sent, so we won't rethrow the error
                            return error.email;
                        } else {

                            // We have some other failure, so rethrow
                            return $q.reject(error);
                        }
                    });
                },

                _verificationSentErrorCode: &quot;X::EmailNotVerified::EmailSent&quot;,

                /**
                 * Calls the API to run cpkeyclt to check for a valid license
                 * @method updateLicense
                 * @return {Promise} Promise that will fulfill the request.
                 */
                updateLicense: function() {
                    var apiCall = new APIREQUEST.Class();
                    apiCall.initialize(NO_MODULE, &quot;run_cpkeyclt&quot;);

                    // force is undocumented by design to prevent users from locking out their system
                    apiCall.addArgument(&quot;force&quot;, &quot;1&quot;);

                    var deferred = this.deferred(apiCall);

                    return deferred.promise;
                },

                /**
                 * Override for the default transformAPIFailure() handler in APIService so we
                 * can get the data object (that contains the error type information) as well.
                 */
                _getTransformAPIFailureOverride: function() {
                    var self = this;
                    return {

                        /**
                         * Transforms an API error into a typed error with additional information.
                         * @param {Object} resp - The API response object.
                         * @returns {TypedApiError}
                         */
                        transformAPIFailure: function(resp) {
                            if (!resp) {
                                return {};
                            }

                            var errorType = resp.data &amp;&amp; resp.data.type;
                            return {
                                isVerificationFailure: errorType &amp;&amp; self._isVerificationFailure(errorType),
                                type: errorType,
                                email: resp.data &amp;&amp; resp.data.detail &amp;&amp; resp.data.detail.data &amp;&amp; resp.data.detail.data.email,
                                message: resp.error,
                            };
                        }
                    };
                },

                _verificationFailureRegex: /^X::EmailNotVerified/,
                _isVerificationFailure: function(errorType) {
                    return this._verificationFailureRegex.test(errorType);
                },
            });

            return new StoreService();
        }

        storeServiceFactory.$inject = [&quot;$q&quot;, &quot;APIService&quot;];
        return module.factory(&quot;storeService&quot;, storeServiceFactory);
    });

/*
 * views/introController.js                           Copyright 2022 cPanel, L.L.C.
 *                                                           All rights reserved.
 * copyright@cpanel.net                                         http://cpanel.net
 * This code is subject to the cPanel license. Unauthorized copying is prohibited
 */

/* eslint-env amd */

define('app/views/introController',[
    &quot;angular&quot;,
    &quot;cjt/util/locale&quot;,
    &quot;ngSanitize&quot;,
    &quot;cjt/directives/disableAnimations&quot;,
    &quot;shared/js/license_purchase/services/storeService&quot;,
], function(angular, LOCALE) {

    &quot;use strict&quot;;

    function IntroController(PAGE, $timeout, storeService) {
        this.PAGE = PAGE;
        this.$timeout = $timeout;

        this.isDone = false;

        $timeout(this.checkExpiration.bind(this));

        storeService.isEligibleForTrial();
    }

    IntroController.$inject = [
        &quot;PAGE&quot;,
        &quot;$timeout&quot;,
        &quot;storeService&quot;
    ];

    IntroController.prototype.checkExpiration = function() {
        var self = this;

        var msUntilExpiration = this.msUntilExpiration();
        self.isDone = msUntilExpiration &lt; 0;

        if (!self.isDone) {

            // We need to wait some more
            self.$timeout(function() {
                self.isDone = true;
            }, msUntilExpiration);
        }
    };

    IntroController.prototype.msUntilExpiration = function() {
        var self = this;
        return self.PAGE.introEndTime - Date.now();
    };

    IntroController.prototype.skip = function() {
        this.isDone = true;
    };

    angular
        .module(&quot;whm.initialSetup.introController&quot;, [
            &quot;ngSanitize&quot;,
            &quot;cjt2.directives.disableAnimations&quot;,
            &quot;whm.storeService&quot;
        ])
        .controller(&quot;introController&quot;, IntroController);

    return IntroController;

});

/*
 * views/legalController.js                           Copyright 2022 cPanel, L.L.C.
 *                                                           All rights reserved.
 * copyright@cpanel.net                                         http://cpanel.net
 * This code is subject to the cPanel license. Unauthorized copying is prohibited
 */

/* eslint-env amd */

define('app/views/legalController',[
    &quot;angular&quot;,
    &quot;cjt/util/locale&quot;,
    &quot;ngSanitize&quot;,
    &quot;cjt/directives/actionButtonDirective&quot;,
    &quot;cjt/services/alertService&quot;,
    &quot;app/services/setupService&quot;,
    &quot;shared/js/license_purchase/services/storeService&quot;,
], function(angular, LOCALE) {

    &quot;use strict&quot;;

    function LegalController(PAGE, $anchorScroll, $location, $timeout, setupService, storeService, alertService, $window) {

        this.PAGE = PAGE;
        this.agreements = PAGE.agreements;
        this.$anchorScroll = $anchorScroll;
        this.$location = $location;
        this.$timeout = $timeout;
        this.setupService = setupService;
        this.alertService = alertService;
        this.$window = $window;
        this.storeService = storeService;

        if (PAGE.has_accepted_legal_agreements) {
            this.continueToNextStep();
            return;
        }

        this.setTopButtonMargin();
    }

    LegalController.$inject = [
        &quot;PAGE&quot;,
        &quot;$anchorScroll&quot;,
        &quot;$location&quot;,
        &quot;$timeout&quot;,
        &quot;setupService&quot;,
        &quot;storeService&quot;,
        &quot;alertService&quot;,
        &quot;$window&quot;,
    ];

    /**
     * Adds left and right margin to the floating &quot;top&quot; button to make sure
     * that it accounts for the scrollbar width, if any. We use left and right
     * margin so that it works for both LTR and RTL cases.
     *
     * @method setTopButtonMargin
     */
    LegalController.prototype.setTopButtonMargin = function() {
        this.$timeout(function() {
            var panelElem = angular.element(&quot;.panel-body&quot;).get(0);
            var topElem = angular.element(&quot;#top-link&quot;).get(0);

            if (!panelElem || !topElem) {
                return;
            }

            var scrollbarWidth = panelElem.offsetWidth - panelElem.clientWidth;
            topElem.style.opacity = 1;
            if (scrollbarWidth) {
                topElem.style.marginLeft = scrollbarWidth + &quot;px&quot;;
                topElem.style.marginRight = scrollbarWidth + &quot;px&quot;;
            }
        }, 1500);
    };

    /**
     * Prints the legal agreements.
     */
    LegalController.prototype.print = function() {
        window.print();
    };

    /**
     * Scrolls to the specified id using the location hash
     *
     * @method scrollTo
     * @param {String} id   The id of the anchor to scroll the view to
     */
    LegalController.prototype.scrollTo = function(id) {
        this.$location.hash(id);
        this.$anchorScroll();
    };

    /**
     * Records the user's acceptance of all of the legal agreements.
     *
     * @method acceptAll
     * @return {Promise}   When resolved, the server has successfully recorded the acceptance.
     */
    LegalController.prototype.acceptAll = function() {
        var self = this;
        self.isAccepting = true;
        self.alertService.clear();

        return this.setupService.recordAcceptance().then(function() {
            self.PAGE.has_accepted_legal_agreements = true;
            self.continueToNextStep();
        }).catch(function(error) {
            self.alertService.add({
                type: &quot;danger&quot;,
                id: &quot;eula-api-error-alert&quot;,
                message: LOCALE.maketext(&quot;The system could not process your agreement: [_1]&quot;, error),
                replace: true
            });
        }).finally(function() {
            self.isAccepting = false;
        });
    };

    LegalController.prototype.continueToNextStep = function() {
        var self = this;

        // TODO: Start using &quot;cjt/services/viewNavigationApi&quot; instead of $location.path() to propagate debug mode

        if (self.PAGE.has_license) {
            if (self.PAGE.has_completed_initial_setup || self.PAGE.is_dnsonly !== 0) {
                self.$window.location.href = &quot;../initial_setup_wizard1_do&quot;;
            } else {
                self.$location.path(&quot;/info&quot;);
            }
        } else {
            self.storeService.isEligibleForTrial().then(function(isEligible) {
                if (isEligible) {
                    self.setupService.isEligibleForTrial = true;
                    self.$location.path(&quot;/trial-activation/login&quot;);
                } else {
                    if (self.PAGE.has_completed_initial_setup || self.PAGE.is_dnsonly !== 0) {
                        self.$window.location.href = &quot;../initial_setup_wizard1_do&quot;;
                    } else {
                        self.setupService.isEligibleForTrial = false;
                        self.$location.path(&quot;/info&quot;);
                    }
                }
            }, function error() {
                if (self.PAGE.has_completed_initial_setup || self.PAGE.is_dnsonly !== 0) {
                    self.$window.location.href = &quot;../initial_setup_wizard1_do&quot;;
                } else {
                    self.setupService.isEligibleForTrial = false;
                    self.$location.path(&quot;/info&quot;);
                }
            });
        }
    };

    angular
        .module(&quot;whm.initialSetup.legalController&quot;, [
            &quot;ngSanitize&quot;,
            &quot;cjt2.directives.actionButton&quot;,
            &quot;cjt2.services.alert&quot;,
            &quot;whm.initialSetup.setupService&quot;,
            &quot;whm.storeService&quot;
        ])
        .controller(&quot;legalController&quot;, LegalController);

    return LegalController;

});

/*
 * views/createAccountController.js                 Copyright 2022 cPanel, L.L.C.
 *                                                           All rights reserved.
 * copyright@cpanel.net                                         http://cpanel.net
 * This code is subject to the cPanel license. Unauthorized copying is prohibited
 */

/* eslint-env amd */

define('app/views/createAccountController',[
    &quot;angular&quot;,
    &quot;cjt/util/locale&quot;,
    &quot;app/services/setupService&quot;,
], function(angular, LOCALE) {

    &quot;use strict&quot;;

    function CreateAccountController(PAGE, $location, setupService, $scope, $window, $q) {
        this.PAGE = PAGE;
        this.$location = $location;
        this.setupService = setupService;
        this.$scope = $scope;
        this.$window = $window;
        this.$q = $q;

        if (!PAGE.has_accepted_legal_agreements) {
            $location.path(&quot;/legal&quot;);
        }

        if (PAGE.has_completed_initial_setup || PAGE.is_dnsonly || !PAGE.requested_initial_website) {
            this.exit();
        }
    }

    CreateAccountController.$inject = [
        &quot;PAGE&quot;,
        &quot;$location&quot;,
        &quot;setupService&quot;,
        &quot;$scope&quot;,
        &quot;$window&quot;,
        &quot;$q&quot;,
    ];

    /**
     * Creates the account via the API.
     * @method submit
     */
    CreateAccountController.prototype.create = function() {
        var self = this;

        if (self.isSubmitting) {
            return;
        }

        if (!self.PAGE.requested_initial_website) {
            self.exit();
            return;
        }

        self.isSubmitting = true;

        var errorKeys = [];

        return self.setupService.initialWebsite(self.email)
            .catch(function(error) {
                errorKeys.push(&quot;initial_website&quot;);
            })
            .then(function() {
                if (errorKeys.length) {
                    return self.setupService.saveErrors(errorKeys);
                }
            }).finally(function() {
                self.exit();
            });
    };

    /**
     * Exits the initial setup assistant and drops them to the next step.
     * @method exit
     */
    CreateAccountController.prototype.exit = function() {
        this.$window.location.href = &quot;../initial_setup_wizard1_do&quot;;
    };

    CreateAccountController.prototype.requested = function() {
        return this.PAGE.requested_initial_website;
    };

    angular
        .module(&quot;whm.initialSetup.createAccountController&quot;, [
            &quot;whm.initialSetup.setupService&quot;,
        ])
        .controller(&quot;createAccountController&quot;, CreateAccountController);

    return CreateAccountController;
});

/*
 * views/trialActivationController.js               Copyright 2022 cPanel, L.L.C.
 *                                                           All rights reserved.
 * copyright@cpanel.net                                         http://cpanel.net
 * This code is subject to the cPanel license. Unauthorized copying is prohibited
 */

/* eslint-env amd */

define('app/views/trialLicenseActivationController',[
    &quot;angular&quot;,
    &quot;cjt/util/locale&quot;,
    &quot;app/services/setupService&quot;,
    &quot;shared/js/license_purchase/services/storeService&quot;,
    &quot;cjt/services/alertService&quot;,
    &quot;cjt/directives/actionButtonDirective&quot;,
    &quot;cjt/directives/validationContainerDirective&quot;,
    &quot;cjt/directives/validationItemDirective&quot;,
], function(angular, LOCALE) {

    &quot;use strict&quot;;

    function trialActivationController(PAGE, $location, setupService, storeService, alertService, $scope, $window, $q, $timeout, $routeParams) {
        this.PAGE = PAGE;
        this.$location = $location;
        this.setupService = setupService;
        this.storeService = storeService;
        this.alertService = alertService;
        this.$scope = $scope;
        this.$window = $window;
        this.$q = $q;
        this.$timeout = $timeout;
        this.$routeParams = $routeParams;

        if (!PAGE.has_accepted_legal_agreements) {
            $location.path(&quot;/legal&quot;);
        }

        if (PAGE.has_license) {
            if (PAGE.has_completed_initial_setup || PAGE.is_dnsonly !== 0) {
                $window.location.href = &quot;../initial_setup_wizard1_do&quot;;
            } else {
                $location.path(&quot;/info&quot;);
            }

            return;
        }

        var steps = [&quot;login&quot;, &quot;activation&quot;, &quot;activation-status&quot;, &quot;email-verification&quot;];

        var currentStep = steps[0];

        if ($routeParams.nextStep &amp;&amp;
            steps.indexOf($routeParams.nextStep) !== -1) {
            currentStep = $routeParams.nextStep;
        }

        this.$scope.currentStep = currentStep;

        this.$scope.onActivationStatusView = this.$scope.currentStep === &quot;activation-status&quot;;


        this.startTrialActivationProcess();

        // redirects to server setup page
        this.redirectToServerSetup = function() {
            $location.path(&quot;/info&quot;);
        };

        // Prefetch store URL if we haven't logged in yet.
        var queryArgs = $location.search();
        if (!queryArgs || !queryArgs.code) {
            this.prefetchLoginUrl();
        }
    }

    /**
    * Prefetches the login URL
    *
    * @method prefetchLoginUrl
    */
    trialActivationController.prototype.prefetchLoginUrl = function() {
        var returnUrl = this.getReturnURL(&quot;activation&quot;);
        this.storeService.getLoginURL(returnUrl);
    };

    /**
    * Generates return url thats passed to store
    *
    * @method getReturnURL
    * @param {string} step step key which is same as the route parameter.
    * @returns {string} return url that store will redirect to
    */
    trialActivationController.prototype.getReturnURL = function(step) {
        var self = this;
        var queryArgs = self.$location.search();

        var returnURL = self.PAGE.baseURL + self.PAGE.pageURL + &quot;/trial-activation/&quot; + step;
        if (queryArgs &amp;&amp; queryArgs.debug) {
            returnURL += &quot;?debug=1&quot;;
        }

        return returnURL;
    };

    /**
    * Redirect to the store login
    *
    * @method storeLoginRedirect
    * @returns {string} login url
    */
    trialActivationController.prototype.storeLoginRedirect = function() {
        var self = this;
        var returnURL = self.getReturnURL(&quot;activation&quot;);
        self.alertService.clear();

        return self.storeService.getLoginURL(returnURL).then(function(results) {
            if ( results.data &amp;&amp; results.data.length ) {
                self.$window.location.href = results.data[0];
            }
        }, function(error) {
            self.alertService.add({
                type: &quot;danger&quot;,
                id: &quot;getLoginURL-api-error-alert&quot;,
                message: LOCALE.maketext(&quot;The system could not log in to the cPanel Store: [_1]&quot;, error),
                replace: true
            });
        });
    };

    /**
    * Switches routes and presentation and performs trial license activation
    *
    * @method startTrialActivationProcess
    */
    trialActivationController.prototype.startTrialActivationProcess = function() {

        var self = this;
        var authenticationCode = self.authenticationCode = self.$location.search().code;
        var nextStep = self.$routeParams.nextStep;

        self.activationInProgress = true;
        self.emailAddress = self.$routeParams.everythingelse;

        // Verify Login, Get Access Token and Generate Order
        if (authenticationCode &amp;&amp; nextStep === &quot;activation&quot;) {

            return _fetchAndStoreAccessToken(self).then(function(accessToken) {

                if (!accessToken) {

                    // _fetchAndStoreAccessToken() will already redirect them to /login on failure
                    return;
                }

                // Place the order and perform checkout
                return self.storeService.acquireTrialLicense({
                    token: accessToken,
                    sendVerification: true,
                }).then(
                    function() {
                        return self.storeService.updateLicense().then(
                            function(result) {
                                self.$location.path(&quot;/trial-activation/activation-status/&quot;);
                            },
                            function error(error) {
                                self.activationInProgress = false;
                                self.alertService.add({
                                    type: &quot;danger&quot;,
                                    id: &quot;updateLicense-api-error-alert&quot;,
                                    message: LOCALE.maketext(&quot;The system failed to update the license on your cPanel [output,amp] WHM server. [output,url,_1,Fix License File Errors]&quot;, &quot;../../scripts10/license_error&quot;),
                                    replace: true
                                });

                            }
                        );
                    }, function(error) {
                        self.activationInProgress = false;

                        if ( error.isVerificationFailure ) {
                            self.$location.path(&quot;/trial-activation/email-verification/&quot; + error.email);
                        } else {
                            self.alertService.add({
                                type: &quot;danger&quot;,
                                id: &quot;purchase_a_trial-api-error-alert&quot;,
                                message: LOCALE.maketext(&quot;The system could not activate the trial license.&quot;),
                                replace: true
                            });
                        }
                    }
                );
            }, function(error) {
                self.activationInProgress = false;
                self.alertService.add({
                    type: &quot;danger&quot;,
                    id: &quot;validateLoginToken-api-error-alert&quot;,
                    message: LOCALE.maketext(&quot;The system failed to authenticate. Please try again&quot;),
                    replace: true
                });

                self.$location.path(&quot;/trial-activation/login&quot;);
            });
        }

        // We need to get an access token
        if (nextStep !== &quot;activation-status&quot; &amp;&amp; nextStep !== &quot;email-verification&quot;) {
            self.$location.path(&quot;/trial-activation/login&quot;);
            return;
        }
    };

    trialActivationController.prototype.verifyEmail = function(form) {
        var self = this;

        if (form.$invalid) {
            return;
        }

        var verificationCode = self.verificationCode;
        var accessToken = self.storeService.accessToken;

        self.verificationInProgress = true;
        self.alertService.clear();

        // Place the order and perform checkout
        return self.storeService.acquireTrialLicense({
            token: accessToken,
            verificationCode: verificationCode,
        }).then(
            function() {
                return self.storeService.updateLicense().then(
                    function(result) {
                        self.alertService.clear();
                        self.$location.path(&quot;/trial-activation/activation-status/&quot;);
                    },
                    function error(error) {
                        self.activationInProgress = false;
                        self.alertService.add({
                            type: &quot;danger&quot;,
                            id: &quot;updateLicense-api-error-alert&quot;,
                            message: LOCALE.maketext(&quot;The system failed to update the license on your cPanel [output,amp] WHM server. [output,url,_1,Fix License File Errors]&quot;, &quot;../../scripts10/license_error&quot;),
                            replace: true
                        });

                    }
                );
            }, function(error) {
                self.activationInProgress = false;

                if ( error.isVerificationFailure ) {
                    self.alertService.add({
                        type: &quot;danger&quot;,
                        id: &quot;verify-email-api-error-alert&quot;,
                        message: LOCALE.maketext(&quot;The verification code was incorrect. Please try again.&quot;),
                        replace: true
                    });
                    return;
                }

                self.alertService.add({
                    type: &quot;danger&quot;,
                    id: &quot;purchase_a_trial-api-error-alert&quot;,
                    message: LOCALE.maketext(&quot;The system could not activate the trial license.&quot;),
                    replace: true
                });
            }
        ).finally(function() {
            self.verificationInProgress = false;
        });
    };

    trialActivationController.prototype.resendCode = function() {
        var self = this;
        var accessToken = self.storeService.accessToken;
        self.alertService.clear();

        return this.storeService.sendVerificationCode(accessToken).then(function(email) {
            self.alertService.add({
                type: &quot;success&quot;,
                id: &quot;resend-verification-api-success-alert&quot;,
                message: LOCALE.maketext(&quot;A new verification code has been sent to [_1].&quot;, email),
                replace: true
            });
        }).catch(function(error) {
            if (error.serverIsLicensed) {

                /**
                 * There service may determine that the server is already licensed, in which case we
                 * can send them to the success screen.
                 */
                self.$location.path(&quot;/trial-activation/activation-status/&quot;);
                self.activationInProgress = false;
                self.alertService.add({
                    type: &quot;success&quot;,
                    id: &quot;resend-verification-api-error-alert&quot;,
                    message: LOCALE.maketext(&quot;The system determined that your server is already licensed.&quot;),
                    replace: true
                });
                return;
            }

            self.alertService.add({
                type: &quot;danger&quot;,
                id: &quot;resend-verification-api-error-alert&quot;,
                message: LOCALE.maketext(&quot;The system failed to send a new verification code to [_1].&quot;, error.email),
                replace: true
            });
        });
    };

    /**
     * Fetches an access token for a controller instance and stores it to the storeService.
     * This method's promise return does not ever reject and relies on the resolved return
     * value instead.
     *
     * @private
     * @async
     * @param {Object} self - The controller instance. It must have an authenticationCode property
     *                        or the API call will fail.
     * @returns {Promise&lt;string|undefined&gt;} - The access token, if successful. Undefined, if not.
     */
    function _fetchAndStoreAccessToken(self) {
        var authenticationCode = self.authenticationCode;
        var returnUri = self.getReturnURL(&quot;activation&quot;);

        return self.storeService.getAccessToken(authenticationCode, returnUri).then(function(accessToken) {
            self.storeService.accessToken = accessToken;
            return accessToken;
        }).catch(function() {
            self.activationInProgress = false;
            self.alertService.add({
                type: &quot;danger&quot;,
                id: &quot;getAccessToken-api-error-alert&quot;,
                message: LOCALE.maketext(&quot;The system failed to authenticate. Please try again&quot;),
                replace: true
            });

            self.$location.path(&quot;/trial-activation/login&quot;);

            return void 0;
        });
    }

    trialActivationController.$inject = [
        &quot;PAGE&quot;,
        &quot;$location&quot;,
        &quot;setupService&quot;,
        &quot;storeService&quot;,
        &quot;alertService&quot;,
        &quot;$scope&quot;,
        &quot;$window&quot;,
        &quot;$q&quot;,
        &quot;$timeout&quot;,
        &quot;$routeParams&quot;
    ];


    angular
        .module(&quot;whm.initialSetup.trialActivationController&quot;, [
            &quot;ngSanitize&quot;,
            &quot;whm.initialSetup.setupService&quot;,
            &quot;whm.storeService&quot;,
            &quot;cjt2.services.alert&quot;
        ])
        .controller(&quot;trialActivationController&quot;, trialActivationController);

    return trialActivationController;

});

/*
 * index.js                                           Copyright 2022 cPanel, L.L.C.
 *                                                           All rights reserved.
 * copyright@cpanel.net                                         http://cpanel.net
 * This code is subject to the cPanel license. Unauthorized copying is prohibited
 */

/* eslint-env amd */

define(
    'app/index',[
        &quot;angular&quot;,
        &quot;cjt/modules&quot;,
        &quot;ngRoute&quot;,
        &quot;ngSanitize&quot;,

    ],
    function(angular, $) {

        &quot;use strict&quot;;

        return function() {

            require(
                [
                    &quot;cjt/bootstrap&quot;,
                    &quot;cjt/directives/alertList&quot;,
                    &quot;app/views/infoController&quot;,
                    &quot;app/views/introController&quot;,
                    &quot;app/views/legalController&quot;,
                    &quot;app/views/createAccountController&quot;,
                    &quot;app/views/trialLicenseActivationController&quot;
                ], function(BOOTSTRAP) {

                    var app = angular.module(&quot;whm.initialSetup&quot;, [
                        &quot;cjt2.config.whm.configProvider&quot;, // This needs to load before ngRoute
                        &quot;ngRoute&quot;,
                        &quot;cjt2.directives.alertList&quot;,
                        &quot;whm.initialSetup.infoController&quot;,
                        &quot;whm.initialSetup.introController&quot;,
                        &quot;whm.initialSetup.legalController&quot;,
                        &quot;whm.initialSetup.createAccountController&quot;,
                        &quot;whm.initialSetup.trialActivationController&quot;
                    ]);

                    app.config([
                        &quot;$routeProvider&quot;,
                        function($routeProvider) {

                            $routeProvider.when(&quot;/legal&quot;, {
                                controller: &quot;legalController&quot;,
                                controllerAs: &quot;vm&quot;,
                                templateUrl: &quot;gsw/initial_setup/views/legalView.ptt&quot;,
                            });

                            $routeProvider.when(&quot;/trial-activation/:nextStep?/:everythingelse?&quot;, {
                                controller: &quot;trialActivationController&quot;,
                                controllerAs: &quot;vm&quot;,
                                templateUrl: &quot;gsw/initial_setup/views/trialLicenseActivationView.ptt&quot;,
                            });

                            $routeProvider.when(&quot;/info&quot;, {
                                controller: &quot;infoController&quot;,
                                controllerAs: &quot;vm&quot;,
                                templateUrl: &quot;gsw/initial_setup/views/infoView.ptt&quot;,
                            });

                            $routeProvider.when(&quot;/initial-website&quot;, {
                                controller: &quot;createAccountController&quot;,
                                controllerAs: &quot;vm&quot;,
                                templateUrl: &quot;gsw/initial_setup/views/createAccountView.ptt&quot;,
                            });

                            $routeProvider.otherwise({
                                &quot;redirectTo&quot;: &quot;/legal/&quot;
                            });
                        }
                    ]);

                    app.value(&quot;PAGE&quot;, window.PAGE);

                    BOOTSTRAP(&quot;#content&quot;, &quot;whm.initialSetup&quot;);

                });
        };
    }
);

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fwhostmgr%2Fdocroot%2Ftemplates%2Fgsw%2Finitial_setup'>Back to Directory</a>