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

/* global define, PAGE */
/* jshint -W100 */
/* jshint -W089 */

define(
    [
        &quot;lodash&quot;,
        &quot;angular&quot;,
        &quot;cjt/util/parse&quot;,
        &quot;cjt/util/query&quot;,
        &quot;cjt/io/api&quot;,
        &quot;cjt/io/whm-v1-request&quot;,
        &quot;cjt/io/whm-v1&quot;, // IMPORTANT: Load the driver so it’s ready
    ],
    function(_, angular, CJT_PARSE, QUERY, API, APIREQUEST) {
        &quot;use strict&quot;;

        var app = angular.module(&quot;App&quot;);

        var NO_MODULE = &quot;&quot;;

        // Calculated by:
        // +1 for each supported DCV method (x2 if provider supports ancestor DCV)
        // +1 for lowest AVERAGE_DELIVERY_TIME
        // +1 for highest RATE_LIMIT_CERTIFICATES_PER_REGISTERED_DOMAIN_PER_WEEK
        // +1 for highest MAX_DOMAINS_PER_CERTIFICATE
        // +1 for highest HTTP_DCV_MAX_REDIRECTS
        // +1 for SUPPORTS_WILDCARD
        var MAX_USABILITY_SCORE = 8;

        var _tableColumns = [];

        function TableColumn(label, desc, starRating) {
            this.label = label;
            this.desc = desc;
            this.isScorePart = starRating ? true : false;
            this.starRating = starRating || 0;
            this.getLabel = function() {
                return this.label;
            };
            this.getDescription = function() {
                if (!this.desc) {
                    return &quot;&quot;;
                }
                var combinedDesc = &quot;&quot;;
                combinedDesc += this.desc;
                if (this.starRating) {
                    combinedDesc += &quot;&lt;br /&gt;&quot;;
                    combinedDesc += &quot;&lt;em&gt;&quot;;
                    combinedDesc += this._starDescription();
                    combinedDesc += &quot;&lt;/em&gt;&quot;;
                }
                return combinedDesc;
            };
            this._starDescription = function() {
                return LOCALE.maketext(&quot;A maximum of [quant,_1,star,stars] is possible.&quot;, this.starRating);
            };
        }

        function DCVMethodsColumn(label, desc, starRating) {
            TableColumn.call(this, label, desc, starRating);
            this._starDescription = function() {
                var desc = &quot;&quot;;
                desc += LOCALE.maketext(&quot;A maximum of 2 stars per method if the provider supports Ancestor DCV.&quot;);
                desc += &quot; &quot;;
                desc += LOCALE.maketext(&quot;Otherwise, a maximum of 1 star per method.&quot;);
                return desc;
            };
        }
        function SummaryColumn(label, desc, starRating) {
            TableColumn.call(this, label, desc, starRating);
            this.isScorePart = false;
        }

        _tableColumns[_tableColumns.length] = new TableColumn( LOCALE.maketext(&quot;Provider&quot;) );
        _tableColumns[_tableColumns.length] = new SummaryColumn( LOCALE.maketext(&quot;Usability Score&quot;), LOCALE.maketext(&quot;The capabilities of a provider determine the provider’s rank.&quot;), MAX_USABILITY_SCORE);
        _tableColumns[_tableColumns.length] = new DCVMethodsColumn( LOCALE.maketext(&quot;DCV Methods&quot;), LOCALE.maketext(&quot;The Domain Control Validation methods that the provider offers.&quot;), 4 );
        _tableColumns[_tableColumns.length] = new TableColumn( LOCALE.maketext(&quot;Ancestor DCV Support&quot;), LOCALE.maketext(&quot;Whether the successful Domain Control Validation of a parent domain implies the success of a subdomain. For example, if “example.com” succeeds, “store.example.com” would succeed.&quot;) );
        _tableColumns[_tableColumns.length] = new TableColumn( LOCALE.maketext(&quot;Domains per Certificate&quot;), LOCALE.maketext(&quot;The number of unique domains each certificate can contain.&quot;), 1 );
        _tableColumns[_tableColumns.length] = new TableColumn( LOCALE.maketext(&quot;Delivery Method&quot;), LOCALE.maketext(&quot;The method that the provider uses to issue the certificate.&quot;) );
        _tableColumns[_tableColumns.length] = new TableColumn( LOCALE.maketext(&quot;Average Delivery Time&quot;), LOCALE.maketext(&quot;The amount of time that the provider requires to issue a certificate.&quot;), 1 );
        _tableColumns[_tableColumns.length] = new TableColumn( LOCALE.maketext(&quot;Validity Period&quot;), LOCALE.maketext(&quot;The amount of time before the certificate expires.&quot;) );
        _tableColumns[_tableColumns.length] = new TableColumn( LOCALE.maketext(&quot;Maximum Number of Redirects&quot;), LOCALE.maketext(&quot;The maximum number of redirections a domain can use and still pass an HTTP-based Domain Control Validation.&quot;), 1 );

        _tableColumns[_tableColumns.length] = new TableColumn( LOCALE.maketext(&quot;Wildcard Support&quot;), LOCALE.maketext(&quot;The provider supports wildcard domains.&quot;), 1 );

        function manageServiceFactory($q, $interval, PAGE) {

            function apiCallPromise(apiCall) {
                var deferred = $q.defer();
                API.promise(apiCall.getRunArguments())
                    .done(function(response) {
                        response = response.parsedResponse;

                        deferred[response.status ? &quot;resolve&quot; : &quot;reject&quot;](response);
                    });

                return deferred.promise;
            }

            // XXX TODO: Refactor this to be reusable.
            function _call_apiv1(call_info) {

                var apiCall = new APIREQUEST.Class();

                apiCall.initialize(NO_MODULE, call_info.func);

                if (call_info.data) {
                    for (var k in call_info.data) {
                        apiCall.addArgument(k, call_info.data[k]);
                    }
                }

                return apiCallPromise(apiCall);
            }

            // XXX TODO: Refactor this to be reusable.
            function _batch_apiv1(calls_infos) {
                var apiCall = new APIREQUEST.Class();
                apiCall.initialize(NO_MODULE, &quot;batch&quot;);

                calls_infos.forEach(function(call, i) {
                    apiCall.addArgument(
                        (&quot;command-&quot; + i),
                        call.func + &quot;?&quot; + QUERY.make_query_string(call.data)
                    );
                });

                return apiCallPromise(apiCall);
            }

            // NB: There’s no particular reason to use epoch seconds here;
            // that’s just what this started off as, and changing it now
            // isn’t really worthwhile.
            function _convert_iso_to_epoch(things, key) {
                for (var r = 0; r &lt; things.length; r++) {
                    if (!things[r][key]) {
                        continue;
                    }

                    things[r][key + &quot;_epoch&quot;] = Date.parse(things[r][key]) / 1000;
                }
            }

            var _bestSpecsList = [&quot;AVERAGE_DELIVERY_TIME&quot;, &quot;MAX_DOMAINS_PER_CERTIFICATE&quot;, &quot;HTTP_DCV_MAX_REDIRECTS&quot;];
            var _bestScores = {};

            function _updateUsabilityScore(provider) {
                var usabilityScore = 0;

                // For each DCV method ...
                usabilityScore += provider.specs.DCV_METHODS.length;

                // ... and counts double if ancestor dcv is supported
                if (provider.specs.SUPPORTS_ANCESTOR_DCV.toString() === &quot;1&quot;) {
                    provider.specSpecifics[&quot;SUPPORTS_ANCESTOR_DCV&quot;] = 1;
                    usabilityScore *= 2;
                }
                if (provider.specs.SUPPORTS_WILDCARD &amp;&amp; provider.specs.SUPPORTS_WILDCARD.toString() === &quot;1&quot;) {
                    provider.specSpecifics[&quot;SUPPORTS_WILDCARD&quot;] = 1;
                    usabilityScore += 1;
                }
                _bestSpecsList.forEach(function(spec) {
                    if (provider.specs[spec] === _bestScores[spec]) {
                        provider.specSpecifics[spec] = 1;
                        usabilityScore++;
                    }
                });


                return usabilityScore;

            }

            var nullDefaults = {
                AVERAGE_DELIVERY_TIME: 1000000,
                RATE_LIMIT_CERTIFICATES_PER_REGISTERED_DOMAIN_PER_WEEK: -1,
                MAX_DOMAINS_PER_CERTIFICATE: -1,
            };

            // Find the best score based on
            function _findBestSpecScore(providers, spec) {

                if (_bestScores[spec]) {
                    return _bestScores[spec];
                }

                var findLowest = false;

                // These are best when they are highest
                // everything else is best when it's lowest
                if ([&quot;AVERAGE_DELIVERY_TIME&quot;].indexOf(spec) !== -1) {
                    findLowest = true;
                }

                providers.forEach(function(provider) {
                    var value = _.isNil(provider.specs[spec]) &amp;&amp; nullDefaults[spec] ? nullDefaults[spec] : provider.specs[spec];
                    if ( _.isUndefined(_bestScores[spec]) ) {
                        _bestScores[spec] = value;
                    } else if (spec === &quot;RATE_LIMIT_CERTIFICATES_PER_REGISTERED_DOMAIN_PER_WEEK&quot;) {
                        if (_bestScores[spec] === 0) {

                            // Zero is the best score for this cause it's unlimited
                            return;
                        } else if (value.toString() === &quot;0&quot;) {
                            _bestScores[spec] = 0;
                        } else {
                            if (value &gt; _bestScores[spec]) {
                                _bestScores[spec] = value;
                            }
                        }
                    } else if ( findLowest &amp;&amp; value &lt; _bestScores[spec]) {
                        _bestScores[spec] = value;
                    } else if ( !findLowest &amp;&amp; value &gt; _bestScores[spec] ) {
                        _bestScores[spec] = value;
                    }
                });

                return _bestScores[spec];

            }

            // i.e., the system’s provider module setting
            var savedProviderModuleName;
            var currentProviderAccountID = PAGE.currentAccountID;

            PAGE.provider_info.forEach(function(p) {
                if (CJT_PARSE.parsePerlBoolean(p.enabled)) {
                    savedProviderModuleName = p.module_name;
                }
            });

            var metadataVars = [
                &quot;clobber_externally_signed&quot;,
                &quot;notify_autossl_expiry&quot;,
                &quot;notify_autossl_expiry_coverage&quot;,
                &quot;notify_autossl_renewal_coverage&quot;,
                &quot;notify_autossl_renewal_coverage_reduced&quot;,
                &quot;notify_autossl_renewal_uncovered_domains&quot;,
                &quot;notify_autossl_renewal&quot;,
            ];

            metadataVars.forEach( function(v) {
                PAGE.metadata[v] = CJT_PARSE.parseInteger( PAGE.metadata[v] );
                if ( v !== &quot;clobber_externally_signed&quot; ) {
                    PAGE.metadata[v + &quot;_user&quot;] = CJT_PARSE.parseInteger( PAGE.metadata[v + &quot;_user&quot;] );
                }
            } );

            PAGE.constants.MIN_VALIDITY_DAYS_LEFT_BEFORE_CONSIDERED_ALMOST_EXPIRED = CJT_PARSE.parseInteger(
                PAGE.constants.MIN_VALIDITY_DAYS_LEFT_BEFORE_CONSIDERED_ALMOST_EXPIRED
            );

            var logsCatalog = _.sortBy(PAGE.logs_catalog, &quot;start_time&quot;).reverse();

            // We save references to the $scope variables here upon view load.
            // That way, when/if the view is reloaded, we can grab any values
            // that we want to restore and put them into the controller.
            //
            // Note that the values on a saved scope will change after its
            // reference here is created.
            var SAVED_SCOPE = {};

            var providers = PAGE.provider_info;

            // Update the best scores because too many nest loops makes me uncomfortable
            _bestSpecsList.forEach(function(spec) {
                _findBestSpecScore(providers, spec);
            });

            providers.forEach(function(p) {

                p.specSpecifics = {};

                // so this checks the radio button correctly
                if (!p.x_terms_of_service_accepted) {
                    p.x_terms_of_service_accepted = &quot;&quot;;
                }

                p.saved_x_terms_of_service_accepted = p.x_terms_of_service_accepted;

                p.usabilityScore = _updateUsabilityScore(p);
                p.maxUsabilityScore = MAX_USABILITY_SCORE;
            });

            providers.sort(function(a, b) {
                return b.usabilityScore - a.usabilityScore;
            });

            var nextAutosslCheckTime;
            var afterNextCheckRefresh;

            function refreshNextAutosslCheckTime() {
                return _call_apiv1({
                    func: &quot;get_autossl_check_schedule&quot;,
                }).then(
                    function(resp) {
                        nextAutosslCheckTime = new Date(resp.data.next_time);
                        if (afterNextCheckRefresh) {
                            afterNextCheckRefresh(nextAutosslCheckTime);
                            afterNextCheckRefresh = null;
                        }

                        return nextAutosslCheckTime;
                    }
                );
            }

            // This is an interval, not a timeout, because it’s conceivable
            // that someone might tinker with their cron so that it only
            // runs once monthly. JS can’t handle timeouts greater than a
            // signed 32-bit integer, which gives us about 24 days.
            var nextTimeInterval;

            function nextTimeChecker() {
                var time = nextAutosslCheckTime;
                if (!time || time &lt;= (new Date())) {
                    refreshNextAutosslCheckTime().then(function() {
                        if (!nextTimeInterval) {
                            nextTimeInterval = $interval(
                                nextTimeChecker,
                                60000 // 1 minute
                            );
                        }
                    });
                }
            }

            if (savedProviderModuleName) {
                nextTimeChecker();
            }

            function callProviderSetter(funcName, payload) {
                return _batch_apiv1([{
                    func: funcName,
                    data: payload,
                }, {
                    func: &quot;get_autossl_check_schedule&quot;,
                }, {
                    func: &quot;get_autossl_providers&quot;,
                }]).then(function(resp) {
                    var nextTimeIso = resp.data[1].parsedResponse.next_time;
                    nextAutosslCheckTime = new Date(nextTimeIso);

                    savedProviderModuleName = payload.provider;

                    var updatedProviders = resp.data[2].parsedResponse.data;

                    updatedProviders.forEach(function(provider) {
                        if (provider.enabled.toString() === &quot;1&quot;) {
                            currentProviderAccountID = provider.x_account_id;
                        }
                    });

                    // This will set the interval to check whether
                    // it’s time to poll again.
                    nextTimeChecker();
                });
            }

            function _groom_logs_catalog(entries) {
                _convert_iso_to_epoch(entries, &quot;start_time&quot;);
                for (var t = 0; t &lt; entries.length; t++) {
                    entries[t].in_progress = CJT_PARSE.parsePerlBoolean(entries[t].in_progress);
                }
            }

            return {
                groom_logs_catalog: _groom_logs_catalog,

                get_next_autossl_check_time: function() {
                    return nextAutosslCheckTime;
                },

                refresh_next_autossl_check_time: refreshNextAutosslCheckTime,

                after_next_check_refresh: function(todoFn) {
                    if (typeof todoFn !== &quot;function&quot;) {
                        throw &quot;Needs a function!&quot;;
                    }

                    afterNextCheckRefresh = todoFn;
                },

                getTableColumns: function() {
                    return _tableColumns;
                },

                get_providers: function() {
                    return providers;
                },

                get_provider_display_name: function(p_mod_name) {
                    for (var p = 0; p &lt; providers.length; p++) {
                        if (providers[p].module_name === p_mod_name) {
                            return providers[p].display_name;
                        }
                    }

                    return p_mod_name;
                },

                get_saved_provider_module_name: function() {
                    return savedProviderModuleName;
                },

                getSavedProviderAccountID: function getSavedProviderAccountID() {
                    return currentProviderAccountID;
                },

                // Called at the end of controller initialization.
                // The “key” identifies the view. If SAVED_SCOPE contains
                // a saved scope by that name, then we copy each of “props”
                // into the new scope. Once that’s done, “new_scope”
                // becomes the new SAVED_SCOPE[key], whose values will
                // be imported when/if the view is reloaded later.
                restore_and_save_scope: function(key, new_scope, props) {
                    if (SAVED_SCOPE[key]) {
                        props.forEach(function(p) {
                            new_scope[p] = SAVED_SCOPE[key][p];
                        });
                    }
                    SAVED_SCOPE[key] = new_scope;
                },

                get_logs_catalog: function() {
                    return logsCatalog;
                },

                refresh_logs_catalog: function() {
                    return _call_apiv1({
                        func: &quot;get_autossl_logs_catalog&quot;,

                        // TODO: use abstraction layer
                        data: {
                            &quot;api.sort.enable&quot;: 1,
                            &quot;api.sort.a.field&quot;: &quot;start_time&quot;,
                            &quot;api.sort.a.reverse&quot;: 1,
                        },
                    }).then(
                        function(resp) {
                            resp = resp.data;
                            _groom_logs_catalog(resp, &quot;start_time&quot;);
                            logsCatalog = resp;
                            return resp;
                        }
                    );
                },

                get_log: function(payload) {
                    return _call_apiv1({
                        func: &quot;get_autossl_log&quot;,
                        data: payload,
                    }).then(
                        function(resp) {
                            resp = resp.data;
                            _convert_iso_to_epoch(resp, &quot;timestamp&quot;);
                            return resp;
                        }
                    );
                },

                get_autossl_pending_queue: function() {
                    return _call_apiv1({
                        func: &quot;get_autossl_pending_queue&quot;,
                    }).then(function(result) {
                        return result.data;
                    });
                },

                start_autossl_for_all_users: function() {
                    return _call_apiv1({
                        func: &quot;start_autossl_check_for_all_users&quot;,
                    });
                },

                reset_provider_data: function(payload) {
                    return callProviderSetter(
                        &quot;reset_autossl_provider&quot;,
                        payload
                    );
                },

                save_provider_data: function(payload) {
                    var promise;
                    if (payload.provider) {
                        promise = callProviderSetter(
                            &quot;set_autossl_provider&quot;,
                            payload
                        );
                    } else {
                        promise = _call_apiv1({
                            func: &quot;disable_autossl&quot;,
                        }).then(function() {
                            savedProviderModuleName = null;
                            $interval.cancel(nextTimeInterval);
                            nextAutosslCheckTime = null;
                        });
                    }

                    return promise;
                },

                metadata: PAGE.metadata,

                save_metadata: function() {
                    return _call_apiv1({
                        func: &quot;set_autossl_metadata&quot;,
                        data: {
                            metadata_json: JSON.stringify(PAGE.metadata),
                        },
                    });
                },
            };
        }

        manageServiceFactory.$inject = [&quot;$q&quot;, &quot;$interval&quot;, &quot;PAGE&quot;];
        return app.factory(&quot;manageService&quot;, manageServiceFactory);
    }
);
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fwhostmgr%2Fdocroot%2Ftemplates%2Fautossl%2Fservices'>Back to Directory</a>