ServiceNow Running your own health scan, for improved reporting of culprit objects

---
/**
 * Name: Config Review Script
 * Created: 2019-07-19
 * Author: Shahed Ali Shah @ Cloudefy Ltd
 * Usage: Inside the *process* function, uncomment the function for the intended review 
 * Do not run all the functions.
 */
var reviewScript = {
    WHITELIST    : ['sys_script_fix', 'clone_cleanup_script'], // of tables when running performMatch or findMatch

    process: function() {
        // WARNING - Try to reduce how many heavy scripts you run at once

        //this.hardCodedSysIDs();           // HEAVY: Hard-coded Sys IDs in Server-Side Scripts
        // this.ohardCodedSysIDs([
        //     {
        //         table: 'sys_script',
        //         field: 'script',
        //         query: 'active=true'
        //     },
        //     {
        //         table: 'sys_script_include',
        //         field: 'script',
        //         query: 'active=true'
        //     },
        //     {
        //         table: 'sys_ui_action',
        //         field: 'script',
        //         query: 'active=true'
        //     }
        // ]);
        //this.logsInClient();              // HEAVY: console.log in Client-side scripts
        //this.logsInServer();              // HEAVY: gs.log in Server-side scripts
        //this.queryAudit();                // HEAVY: DO NOT query audit log in your custom code
        //this.queryJournal();              // HEAVY: DO NOT query journal table in your custom code
        //this.grInScript();                // HEAVY: 'var gr' usage in server-side scripts
        // this.getRowCountInScript();       // HEAVY: Usage of 'getRowCount' in server-side scripts
        // this.oGetRowCountInScript([
        //     {
        //         table: 'sys_script',
        //         field: 'script',
        //         query: 'active=true'
        //     },
        //     {
        //         table: 'sys_script_include',
        //         field: 'script',
        //         query: 'active=true'
        //     },
        //     {
        //         table: 'sys_ui_action',
        //         field: 'script',
        //         query: 'active=true'
        //     }
        // ]);
        //this.scriptsUsingEval();          // HEAVY: Scripts should not use the eval() method
        //this.scriptsUsingJavaPackages();  // HEAVY: Scripts do not directly call Java packages
        //this.hardcodedUrls();             // HEAVY: Hard coded instance URL
        // this.hardcodedUrls_table('', 
        // [
        //     {
        //         table: 'sys_script',
        //         field: 'script',
        //         query: 'active=true'
        //     },
        //     {
        //         table: 'sys_script_include',
        //         field: 'script',
        //         query: 'active=true'
        //     },
        //     {
        //         table: 'sys_ui_action',
        //         field: 'script',
        //         query: 'active=true'
        //     }
        // ]);
        //this.glideRecordInClient();       // Usage of 'GlideRecord' in client-side scripts
        //this.globalBusinessRules();       // Global Business Rules
        //this.checkProperties();           // Check key properties are set to best practice values
        //this.beforeBRUpdateInsert();      // Before Business Rules should not update/insert on other tables
        //this.complexWorkflows();          // Complex Workflows, with many steps
        //this.workflowValidation();        // All workflows should pass validation
        //this.coalesceIndexed();           // Verifying that transform map fields are being indexed
        //this.transformMapBR();            // Transform maps generally don't need "Run Business Rules" enabled
        //this.dataSourceLastRun();         // JDBC Data Sources should have the "Use last run datetime" option checked
        //this.domManipulation();           // Client-side code should not use DOM manipulation technique
        //this.highSecurityPlugin();        // Making sure that the High Security Plugin is enabled.
        // this.tooManyFieldsOnForm();       // Too many fields on forms impact UX (>30 check)
        //this.minimiseErrors();            // Minimise on the number of errors per day (>10,000 check)
        //this.calculateDictWithGr();       // GlideRecord in calculated fields
        //this.isLoadingCheck();            // Client Scripts should check for isLoading and return
        //this.moduleLargeTable();          // Looking for modules linking to large tables without a filter
        //this.modifiedBusinessRules();     // Business Rule: Modified from Baseline
        //this.modifiedScriptIncludes();    // Script Includes: Modified from Baseline
        //this.modifiedClient();            // Client and UI Scripts: Modified from Baseline
        //this.modifiedJelly();             // UI Macros and UI Pages: Modified from Baseline
        //this.setValueClient();            // Client-side scripts not using setValue(field,value,display_value)
        this.currentUpdateWorkflow();     // Look for workflows that contain current.update() in it's script
        //this.currentUpdateBR();           // Before Business Rules using curent.update()
        //this.numberOfWorkflows();         // STATS: Number of workflows
        //this.rowCountPreference();        // STATS: Checking the value of rowcount
        //this.numberOfUpdateSets();        // STATS: Number of update sets
        //this.numberOfPlugins();           // STATS: Number of active plugins
        //this.skippedUpgradeItems();       // STATS: Number of skipped items in last upgrade
        //this.choiceCount();               // STATS: Number of choice fields with more than 10 choices
        //this.adminRoleCheck();            // STATS: Number of users with admin role
        //this.publicReports(); // TODO
    },

    publicReports: function() {
        //https://mojprod.service-now.com/sys_report_list.do?sysparm_query=is_published%3Dtrue%5Eroles%3Dpublic
        //https://mojprod.service-now.com/sys_report_list.do?sysparm_query=roles%3Dpublic
        var findings = [];

        var reportGr = new GlideRecord('sys_report');
        reportGr.addQuery('is_published', 'true');
        reportGr.addEncodedQuery('rolesLIKEpublic');
        reportGr.query();
        while (reportGr.next()) {
            if (this.version._isOOB(reportGr)) {
                continue;
            }
            findings.push(this._addFinding(reportGr));
        }

        if (findings && findings.length > 0) {
            this._showFindings("Public reports", findings);
        }
    },

    currentUpdateBR:function() {
        var searchTerm = "current\\.update()\\";
        var searchTable = {
            table : "sys_script",
            field : "script",
            query : "active=true^when=before"
        };

        this._performMatch(searchTerm, searchTable);
    },

    currentUpdateWorkflow: function() {
        var findings = [];

        //Assemble list of Activities that run scripts
        var activitiesGr = new GlideRecord('wf_activity');
        activitiesGr.addQuery('workflow_version.published','true');
        activitiesGr.addQuery('activity_definition.name','Run script');
        activitiesGr.query();
        while (activitiesGr._next()) {
            if (this.version._isOOB(activitiesGr)) {
                continue;
            }

            //Isolate the workflow variables that contains the script
            var table = activitiesGr.getRecordClassName();
            var sys_id = activitiesGr.getUniqueValue();

            // Speed up checks using GlideAggregate
            var scriptGa = new GlideAggregate('sys_variable_value');
            scriptGa.addAggregate('COUNT', 'sys_id');
            scriptGa.addQuery('document', table);
            scriptGa.addQuery('document_key', sys_id);
            scriptGa.addQuery('valueLIKEcurrent.update()'); // Works as an encoded query. Maybe better to use regex
            scriptGa.query();
            if (scriptGa.next()) {
                var count = scriptGa.getAggregate('COUNT', 'sys_id');                
                if (count > 0) {
                    // // Attempt to check if this is OOB and skip - not sure if it will work here
                    // var scriptGr = new GlideRecord('sys_variable_value');
                    // if (scriptGr.get(scriptGa.getValue('sys_id'))) {
                    //     if (this.version._isOOB(scriptGr)) {
                    //         continue;
                    //     }
                    // }

                    // Add some helpful stuff to the finding
                    var override = {
                        Workflow: activitiesGr.workflow_version.getDisplayValue()
                    }
                    findings.push(this._addFinding(activitiesGr, override));
                }
            }
        }

        if (findings && findings.length > 0) {
            this._showFindings("current.update in Workflows", findings);
        }

    },

    setValueClient: function() {
        var findings = [];

        var clientGr = new GlideRecord('sys_script_client');
        clientGr.addActiveQuery();
        //clientGr.addQuery('sys_class_name','sys_script_client');
        clientGr.addQuery('script','LIKE','%g_form.setValue%');
        clientGr.query();
        while (clientGr._next()) {
            if (this.version._isOOB(clientGr))
                continue;

            // This regex has a capture group to get what's inside the brackets
            var search = "g_form.setValue\\((.*)\\)";
            var match, regex = new RegExp(search, 'g');
            //var match, regex = /g_form.setValue\((.*)\)/g;
            var script = clientGr.getValue('script');
            script = this.scriptUtils._removeComments(script);

            if ((match = regex.exec(script))!= null) { 
                var paramStr = match[1]; // parameters inside the setValue() function
                var paramArr = paramStr.split(','); // Turn it into an array and count
                var msg = [], override = {};

                // Two params: field name, value
                // Three params: field name, value, display value

                if (paramArr) {
                    var isReference = false;

                    var fieldName = paramArr[0];
                    if (!fieldName || fieldName == "") {
                        gs.print("Non-existant field")
                        continue;
                    }

                    fieldName = fieldName.replace(/\'|\"/g, "");

                    // this._print(
                    //     "Script type: {1}, name: {2}, field name: {0}", 
                    //     [
                    //         fieldName,
                    //         clientGr.getValue('sys_class_name'),
                    //         clientGr.getDisplayValue()
                    //     ],
                    //     true);
                    // gs.print("field name: " + fieldName);
                    // gs.print(clientGr.getValue('sys_class_name'));

                    if (clientGr.getValue('sys_class_name') == 'sys_script_client') {
                        var tableName = clientGr.getValue('table');
                        var dictGr = new GlideRecord('sys_dictionary')
                        dictGr.addQuery('name', tableName);
                        dictGr.addQuery('element', fieldName);
                        dictGr.query();
                        if (dictGr._next()) {
                            if (dictGr.getValue('internal_type') == 'reference') {
                                isReference = true;
                            }
                        }
                    }
                    else {
                        // must a variable in the catalog

                        // gr doesn't expand to child so here goes...
                        var catScriptGr = new GlideRecord('catalog_script_client');
                        if (!catScriptGr.get(clientGr.getUniqueValue())) {
                            // can't do anything so let the loop move on
                            continue;
                        }

                        var variableSet = catScriptGr.getValue('variable_set') || null;
                        var catItem =  catScriptGr.getValue('cat_item') || null;

                        var varGr = new GlideRecord('item_option_new');
                        varGr.addQuery('name', fieldName);
                        varGr.addQuery('type', '8') // 8 is the value of type=reference
                        if (variableSet) {
                            varGr.addQuery("variable_set", variableSet);
                        }
                        if (catItem) {
                            varGr.addQuery("cat_item", catItem);
                        }
                        varGr.query();
                        if (varGr._next()) {
                            isReference = true;
                        }
                    }

                    if (isReference && paramArr.length < 3) {
                        //override.value = "Reference: " + fieldName; // track it in the finding
                        findings.push(this._addFinding(clientGr, override));
                    }
                }
            }
        }

        if (findings && findings.length > 0) {
            this._showFindings("g_form.setValue on a reference field without displayValue", findings)
        }
    },

    modifiedClient: function() {
        this.modifiedScripts('sys_script_client');
        this.modifiedScripts('sys_ui_script');
    },

    modifiedScripts: function(table) {
        var findings = [],
            clientGr = new GlideRecord(table);
            clientGr.addActiveQuery();
            clientGr.query();
        while (clientGr._next()) {
            var updateName = clientGr.getValue('sys_update_name');
            var wasOOB = this.version._wasOOB(updateName);

            if (wasOOB) {
                findings.push(this._addFinding(clientGr));

            }
        }

        if (findings && findings.length > 0) {
            var tableLabel = this._getTableLabel(table);
            this._showFindings(tableLabel + ": Modified from Baseline", findings)
        }
    },

    modifiedJelly: function() {
        this.modifiedScripts('sys_ui_macro');
        this.modifiedScripts('sys_ui_page');
    },

    modifiedBusinessRules: function() {
        var findings = [],
            bRules = new GlideRecord('sys_script');
        bRules.addActiveQuery();
        bRules.query();
        while (bRules._next()) {
            var updateName = bRules.getValue('sys_update_name');
            var wasOOB = this.version._wasOOB(updateName);

            if (wasOOB) {
                findings.push(this._addFinding(bRules));

            }
        }

        if (findings && findings.length > 0) {
            this._showFindings("Business Rule: Modified from Baseline", findings)
        }
    },

    modifiedScriptIncludes: function() {
        var findings = [],
            includeGr = new GlideRecord('sys_script_include');
            includeGr.addActiveQuery();
            includeGr.query();
        while (includeGr._next()) {
            // Safety check, it might an extension of 'name'SNC, e.g. KBCommon >> KBCommonSNC
            var dupIncludeGr = new GlideRecord('sys_script_include');
            var snName = includeGr.getValue('name') + "SNC";
            if (dupIncludeGr.get('name', snName)) {
                // Script Include intended to be modified so skip
                continue;
            }

            var updateName = includeGr.getValue('sys_update_name');
            var wasOOB = this.version._wasOOB(updateName);

            if (wasOOB) {
                findings.push(this._addFinding(includeGr));
            }
        }

        if (findings && findings.length > 0) {
            this._showFindings("Script Include: Modified from Baseline", findings)
        }
    },

    queryJournal: function() {
        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        var searchTerm = "new GlideRecord\([\"|\']sys_audit[\"|\']\)";
        this._findMatch(searchTerm, scriptFieldArr); 
    },

    queryAudit: function() {
        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        var searchTerm = "new GlideRecord\([\"|\']sys_audit[\"|\']\)";
        this._findMatch(searchTerm, scriptFieldArr); 
    },

    adminRoleCheck: function() {
        var table = 'sys_user_has_role',
            query = "user.active=true^role.name=admin";

        var count = this._getCount(table, query);
        
        var s = this._genHeader('Number of users with admin role')
        s += this._print("Recorded {0} users with the 'admin' role", [count]);
        s += "Recommendation: Limit the number of admin users on a prod instance to 5 or below."
        gs.print(s);
    },

    choiceCount: function() {
        var findings = [];
        var threshold = 10; // SN Best Practice: More than 10 options in a choice often results in a poor user experience
        var table = 'sys_choice';

        var choiceGr = new GlideAggregate(table);
        choiceGr.addQuery('name', '!=', '');
        choiceGr.addQuery('inactive', false);
        choiceGr.addQuery('name', 'NOT LIKE', 'v_%');
        choiceGr.addAggregate('COUNT', 'element');
        choiceGr.groupBy('name');
        choiceGr.groupBy('element');
        choiceGr.addHaving('COUNT', 'element', '>', threshold);
        choiceGr.query();
        while (choiceGr.next()) {
            //Trying to build the sys_update_name in the format of sys_choice_{table}_{column}
            var updateName = "sys_choice_" + choiceGr.getValue('name') + "_" + choiceGr.getValue('element');
            if (this.version._isOOB_updateName(updateName))
                continue;

            var finding = {
                name: updateName,
                table: table,
                target_table: choiceGr.getValue('name'),
                link: gs.getProperty('glide.servlet.uri') + table + '_list.do?sysparm_query=name=' + choiceGr.getValue('name') + "^element=" + choiceGr.getValue('element'),
                value: "Counted " + choiceGr.getAggregate('COUNT', 'element')
            }
            findings.push(finding);
        }

        if (findings && findings.length > 0) {
            this._showFindings("Too many options in a choice field", findings)
        }
    },

    logsInServer: function() {
        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        var searchTerm = "gs\\.log\\(";
        this._findMatch(searchTerm, scriptFieldArr); 
    },

    isLoadingCheck: function() {
        var findings = [], 
            regex = /onChange\(.*isLoading\) {([.\w\W]*)}/g,
            m,
            clientScriptGr = new GlideRecord('sys_script_client');
        clientScriptGr.addActiveQuery();
        clientScriptGr.addQuery('type', 'onChange');
        clientScriptGr.query();
        while (clientScriptGr.next()) {
            if (this.version._isOOB(clientScriptGr)) {
                continue;
            }

            var str = clientScriptGr.getValue('script');
            if ((m = regex.exec(str)) != null) {
                var subScript = m[m.length-1];
                if (subScript.indexOf("isLoading") == -1) {
                    findings.push(this._addFinding(clientScriptGr));
                }
            }
        }

        if (findings && findings.length > 0) {
            this._showFindings("Scripts without isLoading check", findings)
        }
    },

    numberOfWorkflows: function() {
        // Customers most likley will not do a *full* clone so it's best to get this statistic from prod
        var table = 'wf_workflow_version';
        var query = 'published=true';
        var count = this._getCount(table, query);

        var s = this._genHeader("Number of Workflows");
        s+= "There are {0} workflows. A large number is difficult to manage\n".replace(/\{0\}/g, count);
        s+= "Try to use baseline functionality wherever possible. " +
            "A large number of workflows is not bad; just more to manage.\n";
        gs.print(s);
    },

    skippedUpgradeItems: function() {
        var version = gs.getProperty('glide.war');
        var upgradeGr = new GlideRecord('sys_upgrade_history');
        if (upgradeGr.get('to_version', version)) {
            var table = 'sys_upgrade_history_log';
            var query = 'upgrade_history=' + upgradeGr.getUniqueValue();
            query += '^dispositionIN4,104,9,10^changed=true^ORdisposition=9^resolution_status=not_reviewed^ORresolution_status=';
            var count = this._getCount(table, query);
            var s = this._genHeader("Number of skipped items in last upgrade");
            s+= "There are {0} 'skipped' (that item was not upgraded) items in the last upgrade\n".replace(/\{0\}/g, count);
            gs.print(s);
        }
    },

    numberOfPlugins: function() {
        var plugins = this._getPluginList();
        var s = this._genHeader("Number of active plugins");
        s+= "There are {0} active\n".replace(/\{0\}/g, plugins.length);
        s+= "The more plugins that you activate, the more there is to manage.";
        gs.print(s);
    },

    calculateDictWithGr: function() {
        var findings = [];
        var dictGr = new GlideRecord('sys_dictionary');
        dictGr.addQuery('virtual', 'true');
        dictGr.addQuery('calculation', 'LIKE', '%new GlideRecord%');
        dictGr.query();
        while (dictGr.next()) {
            if (this.version._isOOB(dictGr))
                continue;

            findings.push(this._addFinding(dictGr));
        }

        if (findings && findings.length > 0) {
            this._showFindings("GlideRecord in calculated fields", findings)
        }
    },

    minimiseErrors: function() {
        // Customers most likley will not do a *full* clone so it's best to get this statistic from prod
        var table = 'syslog';
        var query = 'level=2';
        var count = this._getCount(table, query);
        if (count > 10000) {
            // The number of errors in the system log should be under 10,000
            var s = this._genHeader("Minimise the number of errors per day");
            s+= "There are {0} errors in the logs, which need to be under 10,000\n".replace(/\{0\}/g, count);
            s+= "Have a System Admin check the Error log continually during development" +
                " and regularly in production. Act on any errors to reduce future issues\n";
            gs.print(s);
        }
    },

    tooManyFieldsOnForm: function() {
        var findings = [];
        var formGr = new GlideRecord('sys_ui_section');
        formGr.addQuery('view','Default view');
        formGr.addQuery('sys_updated_by', '!=', 'glide.maint');
        formGr.query();
        while (formGr.next()) {
            if (this.version._isOOB(formGr)) {
                continue;
            }

            var table = 'sys_ui_element',
                query = 'sys_ui_section=' + formGr.getUniqueValue() + '^typeISEMPTY';
            // ISEMPTY is needed to make sure we don't pick up splits and formatters
            var count = this._getCount(table, query);
            if (count > 30) {
                var updateLink = "{0}name={1}^update_set!=NULL";
                updateLink = updateLink.replace("{0}", "sys_update_xml_list.do?sysparm_query=")
                updateLink = updateLink.replace("{1}", formGr.getValue('sys_update_name'));
                updateLink = gs.getProperty('glide.servlet.uri') + updateLink;

                var override = {
                    field_count: count,
                    update_link: updateLink
                }
                findings.push(this._addFinding(formGr, override));
            }
        }

        if (findings && findings.length > 0) {
            this._showFindings("Too many fields on a form", findings)
        }

    },


    numberOfUpdateSets: function() {
        var count = this._getCount('sys_update_set', 'state=in progress^name!=Default^ORname=NULL');
        if (count > 0) {
            var s = this._genHeader("Update Set Check");
            s+= "There are {0} in progress update sets\n".replace(/\{0\}/g, count);
            gs.print(s);
        }
    },

    moduleLargeTable: function() {
        var LARGE_TABLES = [
            'sys_audit',
            'sys_audit_delete',
            'sys_journal_field',
            'syslog',
            'syslog_transaction',
            'task',
            'cmdb_ci',
            'sys_email',
            'sys_email_log'
        ];

        var findings = [],
            moduleGr = new GlideRecord('sys_app_module');
        moduleGr.addActiveQuery();
        moduleGr.addEncodedQuery('nameIN' + LARGE_TABLES.join(','));
        moduleGr.addQuery('filter', 'NULL');
        moduleGr.query();
        while (moduleGr.next()) {
            if (this._isOOB(moduleGr)) {
                findings.push(this._addFinding(moduleGr));
            }
        }

        if (findings && findings.length > 0) {
            this._showFindings("Modules with Large Tables and no filter", findings)
        }
    },

    hardcodedUrls: function() {
        var instance_name = gs.getProperty("instance_name");
        var search = "http:\/\/" + instance_name + "|https:\/\/" + instance_name;

        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        this._findMatch(search, scriptFieldArr); 
    },

    hardcodedUrls_table: function(instance, oDict) {
        var instance_name = instance != '' ? instance : gs.getProperty("instance_name");
        var search = "http:\/\/" + instance_name + "|https:\/\/" + instance_name;
        this._findMatch(search, oDict); 
    },

    highSecurityPlugin: function() {
        var s = this._genHeader("Plugin Check");
        s+="Is High Security plugin enabled: " + this._isPluginActive('com.glide.high_security');
        s+="Is Client Transaction Timing plugin enabled: " + this._isPluginActive('com.glide.client_transaction');
        gs.print(s);
    },

    domManipulation: function() {
        // Ignore portal and UI Pages as DOM manipulation is expected
        var whitelist = ['sp_widget','sp_angular_provider', 'sys_ui_page'];

        // Look for references to $(), $j(), window., document.
        var search = "\\$\\(.*\\)|\\$j\\(.*\\)|window\\.|document\\..*\\(";

        var scriptFieldArr = this.scriptUtils._clientScriptArr();
        scriptFieldArr = this._filterTableList(scriptFieldArr, whitelist);
        this._findMatch(search, scriptFieldArr); 
    },

    transformMapBR: function() {
        var table = 'sys_transform_map';
        var query = 'run_business_rules=true^active=true';
        var brCount = this._getCount(table, query);
        if (brCount) {
            var s = this._genHeader("Transform Maps running Business Rules");
            s+= "There are {0} transform maps with 'Run Business Rules' enabled\n".replace(/\{0\}/g, brCount);
            s+= this._generateQueryUrl(table, query, true);
            gs.print(s);
        }
    },

    dataSourceLastRun: function() {
        var table = 'sys_data_source';
        var query = 'type=JDBC^use_last_run_datetime=false';
        var brCount = this._getCount(table, query);
        if (brCount) {
            var s = this._genHeader("Transform Maps last run datetime");
            s+= "There are {0} JDBC data sources without 'Use last run datetime' enabled\n".replace(/\{0\}/g, brCount);
            s+= this._generateQueryUrl(table, query, true);
            gs.print(s);
        }
    },

    coalesceIndexed: function() {
        var findings = [];

        var transformMapGr = new GlideRecord('sys_transform_map');
        transformMapGr.addActiveQuery();
        transformMapGr.query();
        while (transformMapGr.next()) {
            if (this.version._isOOB(transformMapGr))
                continue;

            var fieldMapGr = new GlideRecord('sys_transform_entry');
            fieldMapGr.addQuery('map', transformMapGr.getUniqueValue());
            fieldMapGr.addQuery('coalesce', 'true');
            fieldMapGr.query();
            if (fieldMapGr.next()) { // Get first field. Don't need to iterate
                var table = transformMapGr.getValue('target_table');
                var field = fieldMapGr.getValue('target_field');
                if (!this._isIndexed(table, field)) {
                    findings.push(this._addFinding(transformMapGr));
                }
            }
        }

        if (findings && findings.length > 0) {
            this._showFindings("Fields used to coalesce in a Table Transform Maps should be indexed", findings)
        }
    },

    workflowValidation: function() {
        var s = "";

        var wfVersionGr = new GlideRecord('wf_workflow_version');
        wfVersionGr.addQuery('published', 'true');
        wfVersionGr.query();
        while (wfVersionGr.next()) {
            if (this.version._isOOB(wfVersionGr))
                continue;
            
            var validationResult = new WorkflowValidateUtil().validateWorkflow(wfVersionGr);
            if (validationResult.result != 'valid') {
                s+= "Workflow: " + wfVersionGr.getDisplayValue() + "\n";
                s+= "Level: " + getLevelText(validationResult.level) + "\n";
                s+= "Validation results: " + validationResult.msg + "\n\n";
            }
        }

        if (s != "") {
            gs.print(this._genHeader("All workflows should pass validation") + s);
        }

        function getLevelText(level /*number*/) {
            var levelText = "";
            switch(level) {
                case 0:
                    levelText = "Info";
                    break;
                case 1:
                    levelText = "Warning";
                    break;
                case -1:
                    levelText = "Critical";
                    break;
                default:
                    levelText = "Unknown";
            }
            return levelText;
        }
    },

    hardCodedSysIDs: function() {
        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        var search = "[0-9a-f]{32}";
        var findings = this._findMatch(search, scriptFieldArr);
        if (findings && findings.length > 0) {
            this._showFindings("Hard-coded Sys IDs found", findings)
        }
    },
    ohardCodedSysIDs: function(scriptFieldArr) {
        var search = "[0-9a-f]{32}";
        var findings = this._findMatch(search, scriptFieldArr);
        if (findings && findings.length > 0) {
            this._showFindings("Hard-coded Sys IDs found", findings)
        }
    },

    globalBusinessRules: function() {
        var s=null, countEntries=0, findings = [];
        var brGr = new GlideRecord('sys_script');
        brGr.addActiveQuery();
        brGr.addQuery('collection', 'global');
        brGr.orderBy('name');
        brGr.query();
        while (brGr.next()) {
            if (!this.version._isOOB(brGr)) {
                findings.push(this._addFinding(brGr));
            }
        }
        
        if (findings && findings.length > 0) {
            this._showFindings("Global Business Rules found", findings)
        }
        
        brGr = null;
    },

    logsInClient: function() {
        var scriptFieldArr = this.scriptUtils._clientScriptArr();
        var search = "\\bconsole\\..*\\(";
        var findings = this._findMatch(search, scriptFieldArr);
        if (findings && findings.length > 0) {
            this._showFindings("Client Scripts with Logging found", findings)
        }
    },

    grInScript: function() {
        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        var search = "\\bvar gr\\b";
        var findings = this._findMatch(search, scriptFieldArr);
    },

    glideRecordInClient: function() {
        // Findings that are up for discussion. Using async with GlideRecord is safe,
        // so this is looking for any usage of query() instead of query(callback).
        // Not using findMatch or performMatch for this additional check
        var regex = /\.query\(\)/g, 
            match, 
            findings = [];
        var scriptFieldArr = this.scriptUtils._clientScriptArr();
        
        for (var i=0;i<scriptFieldArr.length;i++) {
            var dict = scriptFieldArr[i];
            var clientGr = new GlideRecord(dict.table);
            clientGr.addActiveQuery();
            clientGr.addQuery(dict.field,'LIKE','%new GlideRecord(%')
            clientGr.query();
            while (clientGr.next()) {
                if (this.version._isOOB(clientGr))
                    continue;
                
                var script = clientGr.getValue('script');
                if ((match= regex.exec(script))!=null) {
                    findings.push(this._addFinding(clientGr));
                }
            }
        }
        if (findings && findings.length > 0) {
            this._showFindings("GlideRecord Usage in Client-side", findings)
        }
    },

    getRowCountInScript: function() {
        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        var search = ".getRowCount\\(\\)";
        var findings = this._findMatch(search, scriptFieldArr);
    },

    oGetRowCountInScript: function(scriptFieldArr) {
        var search = "[0-9a-f]{32}";
        var findings = this._findMatch(search, scriptFieldArr);
        if (findings && findings.length > 0) {
            this._showFindings("Hard-coded Sys IDs found", findings)
        }
    },

    checkProperties: function() {
        var properties = this._propertiesArray();
        var s = "";

        for (var i = 0; i < properties.length; i++) {
            property = properties[i];

            var currentValue = gs.getProperty(property.property_name);
            defaultValue = property.default_value;

            if (defaultValue != currentValue) {
                s += "(" + property.rating + ") Description: " + property.description + "\n";
                s += property.product + " | " + property.category + "\n";
                s += "Value: " + defaultValue + " >> " + currentValue + "\n\n";
                
            }
        }

        if (s != "") {
            gs.print(this._genHeader("Overall property check") + s);
        }
    },

    rowCountPreference: function() {
        var count = this._getCount('sys_user_preference', 'name=rowcount^value=100');
        if (count > 0) {
            var s = this._genHeader("Rowcount preferences check")
            s += count + ' preference(s) found with "rowcount" set to "100"';
            gs.print(s);
        }
    },

    beforeBRUpdateInsert:function() {
        var searchTerm = "\.update\(\)\|\.insert\(\)";
        var searchTable = {
            table: 'sys_script',
            field: 'script',
            query: 'active=true^when=before'
        }
        this._performMatch(searchTerm, searchTable);
    },

    complexWorkflows: function() {
        // Looking at workflows with more than 30 activities
        var table = "wf_activity",
            field = "workflow_version",
            query = "workflow_version.published=true",
            threshold = 30;
        this._getFieldCount(table, field, query, threshold);
    },

    scriptsUsingEval: function() {
        var search = "\beval\(.*\)";
        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        var findings = this._findMatch(search, scriptFieldArr);
    },

    scriptsUsingJavaPackages: function() {
        var search = "Packages\.java";
        var scriptFieldArr = this.scriptUtils._scriptFieldArr();
        var findings = this._findMatch(search, scriptFieldArr);
    },
    

    /******************************
     * 
     * Supporting functions 
     * 
     ******************************/

    _generateUrl: function (gr /* GlideRecord */) {
        // Reduce the mess of generating links into a reusable function
        if (!gr)
            return null;
            
        var t = gr.getRecordClassName(); // extract table name
        var id = gr.getUniqueValue(); // get the sys_id
        return gs.getProperty('glide.servlet.uri') + gs.generateURL(t, id);
    },
    _generateQueryUrl: function(table, query, isList) {
        var s = gs.getProperty('glide.servlet.uri');
        s += (isList==true) ? table + "_list.do" : table + ".do";
        s+= "?sysparm_query=" + query;
        return s;
    },
    _getCount: function(table /* String */, query /* String */) {
        // GlideAggregate boilerplate for normal count
        var count = 0;
        var ga = new GlideAggregate(table);
        if (query) {
          ga.addEncodedQuery(query)
        }
        ga.addAggregate('COUNT');
        ga.query();

        //gs.print(ga.getEncodedQuery());
  
        if (ga.next()) {
            count = ga.getAggregate('COUNT');
        }
        return count;
    },
    _getFieldCount: function(table /* String */, field /* String */, query /* String */, threshold /* Number */) {
        var count = 0;
        var ga = new GlideAggregate(table);
        if (query) {
            ga.addEncodedQuery(query);
        }
        ga.addAggregate('COUNT', field);
        ga.addHaving('COUNT', field, '>', threshold);
        ga.query();

        while (ga.next()) {
            gs.print("(" + ga.getAggregate('COUNT', field) +") " + ga.getDisplayValue(field));
        }
    },
    _addFinding: function(findingGr /* GlideRecord */, override /* Object */) {
        var s = "";
        var findingObject = {};

        if (!findingGr) {
            return s;
        }
        //var targetRec = (this._getTableLabel(findingGr.getValue('collection'))) ? this._getTableLabel(findingGr.getValue('collection')) : findingGr.getValue('collection');
        
        // Try to find which product table this object belongs to
        var targetRec = findingGr.getValue('collection');
        if (!targetRec || targetRec == '') {
            targetRec = findingGr.getValue('table');
        }
        if (!targetRec || targetRec == '') {
            // catalog
            targetRec = findingGr.getValue('cat_item');
        }
        if (!targetRec || targetRec == '') {
            // catalog
            targetRec = findingGr.getValue('variable_set');
        }
        if (!targetRec || targetRec == '') {
            targetRec = findingGr.getValue('target_table');
        }
        if (!targetRec || targetRec == '') {
            // Some objects have the table name in the 'name' field
            targetRec = findingGr.getValue('name');
        }

        // Try to get a nice display for the product table
        if (targetRec || targetRec != '') {
            targetRec = this._getTableLabel(targetRec) ? this._getTableLabel(targetRec) : targetRec;
        }

        if (override) {
            for (var property in override) {
                findingObject[property] = override[property];
            }
        }

        findingObject.name = findingGr.getDisplayValue() || "(empty)";
        findingObject.table = (this._getTableLabel(findingGr.getRecordClassName()) != null) ? this._getTableLabel(findingGr.getRecordClassName()) : findingGr.getTableName;
        if (targetRec && targetRec != '') {
            findingObject.target_table = targetRec;
        }
        findingObject.link = this._generateUrl(findingGr);
        findingObject.updated_on = findingGr.getDisplayValue('sys_updated_on');
        findingObject.updated_by = findingGr.getValue('sys_updated_by');

        return findingObject;
    },
    _showFindings: function(review /* String */, findings /* Array */) {
        var s = "";
        if (review != "") {
            s = "\n\n----------\n\nReview: " + review + " (" + findings.length +")\n\n----------\n\n";
        }
        else {
            "\n\n----------\n\nReview: " + findings.length +" findings\n\n----------\n\n";
        }
        for (var i=0;i<findings.length;i++) {
            var finding = findings[i];
            // s += "Name: " + finding.name + "\n";
            // s += "Table: " + finding.table + "\n";
            // if (finding.target_table) {
            //     s+= "Target table: " + finding.target_table + "\n";
            // }
            // s += "Updated On: " + finding.updated_on + "\n";
            // s += "Updated By: " + finding.updated_by + "\n";
            // s += "Link: " + finding.link + "\n\n";

            // Try to walk through the properties of the finding object and output it
            for (var findingProperty in finding) {
                if (finding[findingProperty] == "")
                    continue;
                s+= this.scriptUtils._clean(findingProperty) + ": " +  finding[findingProperty] + "\n";
            }
            s+="\n";
        }
        gs.print(s);
    },
    _getTableLabel: function(table_name /* String */) {
        if (!table_name) {
            return;
        }

        var dbObjectGr = new GlideRecord('sys_db_object');
        if (dbObjectGr.get('name', table_name)) {
            return dbObjectGr.getValue('label') + " [" + table_name+ "]";
        }
        return table_name; // If we got here... good luck
    },
    _showFinding: function(record /* GlideRecord */) {
        var s = "";

        if (!record)
            return;

        var finding = this._addFinding(record);
        s += "Name: " + finding.name + "\n";
        s += "Table: " + finding.table + "\n";
        if (finding.target_table) {
            s+= "Target table: " + finding.target_table + "\n";
        }
        s += "Updated On: " + finding.updated_on + "\n";
        s += "Updated By: " + finding.updated_by + "\n";
        s += "Link: " + finding.link + "\n\n";
        gs.print(s);
    },
    _genHeader: function(headerText) {
        return "\n\n----------\n\n{0}\n\n----------\n\n".replace(/\{0\}/g, headerText);
    },
    _isIndexed: function(table, field) {

        var answer = false; // assume false
    
        if (!table || !field) {
            return false;
        }
    
        var td = GlideTableDescriptor(table);
    
        var ed;
        if (td) {
            ed = td.getElementDescriptor(field);
        }
    
        if (ed) {
            var source = ed.getTableName();
            
            var i;
            try {
                i = GlideTableDescriptor(source).getIndexDescriptors().values().iterator();
            } catch (e) {
                return false;
            }
            
            while (i.hasNext()) {
                if (i.next().getFields().get(0) == field) {
                    answer = true;
                    break;
                }
            }
        }
    
        return answer;
    },
    
    version : {
        _isOOB: function(gr) {
            // Safety check
            if (!gr)
                return false;
            
            var update_name = gr.getValue('sys_update_name');
            if (!update_name || update_name == "") {
                // Can't check so assume it's not OOB
                return false;
            }

            return this._isOOB_updateName(update_name);

            // // Close enough estimation of this being OOB
            // var update_name = gr.getValue('sys_update_name'),
            //     hasVersion = false,
            //     versionGr = new GlideAggregate('sys_update_version');
            
            // // Safety check
            // if (!update_name || update_name == "") {
            //     // Can't check so assume it's not OOB
            //     return false;
            // }
            // versionGr.addQuery('name', update_name);
            // versionGr.addQuery('source_table', '=', 'sys_upgrade_history');
            // versionGr.addAggregate('COUNT');
            // versionGr.query();
            // if (versionGr.next()) {
            //     if (versionGr.getAggregate('COUNT') > 0)
            //         hasVersion = true;
            // }
            
            // var hasUpdate = false,
            //     updateGr = new GlideAggregate('sys_update_xml');
            // updateGr.addQuery('name', update_name);
            // updateGr.addAggregate('COUNT');
            // updateGr.query();
            // if (updateGr.next()) {
            //     if (updateGr.getAggregate('COUNT') > 0)
            //         hasUpdate = true;
            // }
            
            // versionGr = null;
            // updateGr = null;
            
            // // If there is no version record and there's no sys_update_xml record then it's gotta be OOB, right?
            // if (!hasVersion && !hasUpdate)
            //     return true;
            // else
            //     return false;
        },
        _isOOB_updateName: function(update_name) {
            var hasVersion = false,
                versionGr = new GlideAggregate('sys_update_version');
            
            // Safety check
            if (!update_name || update_name == "") {
                // Can't check so assume it's not OOB
                return false;
            }
            versionGr.addQuery('name', update_name);
            versionGr.addQuery('source_table', '=', 'sys_upgrade_history');
            versionGr.addAggregate('COUNT');
            versionGr.query();
            if (versionGr.next()) {
                if (versionGr.getAggregate('COUNT') > 0)
                    hasVersion = true;
            }
            
            var hasUpdate = false,
                updateGr = new GlideAggregate('sys_update_xml');
            updateGr.addQuery('name', update_name);
            updateGr.addAggregate('COUNT');
            updateGr.query();
            if (updateGr.next()) {
                if (updateGr.getAggregate('COUNT') > 0)
                    hasUpdate = true;
            }
            
            versionGr = null;
            updateGr = null;
            
            // If there is no version record and there's no sys_update_xml record then it's gotta be OOB, right?
            if (!hasVersion && !hasUpdate)
                return true;
            else
                return false;
        },
        _wasOOB: function(update_name) {
            var table = "sys_update_version";
            var query = "name=" + update_name + "^source_table=sys_upgrade_history";
            return (reviewScript._getCount(table, query) > 0); // using 'reviewScript' instead of 'this'
        },
        _isSystem: function(gr) {
            var answer = false;
            var updated_by = gr.getValue('sys_updated_by');
            if (updated_by == 'system' || updated_by == 'system@snc') {
                answer = true;
            }
            return answer;
        }
    },

    scriptUtils: {
        _clean: function(term) {
            term = term.replace("_", " ");
            term = term.capitalize();
            return term;
        },
        _clientScriptArr: function() {
            // Similar to _scriptFieldArr but this will return tables for client-side scripting
            var result = [];
            var tableName, fieldName;

            var dictGR = new GlideRecord('sys_dictionary');
            dictGR.addQuery('internal_type', 'script')
            .addOrCondition('internal_type', 'script_plain');
            dictGR.addEncodedQuery('attributesLIKEclient_script=true'); // needs encoding for some reason
            dictGR.addQuery('name', '!=','NULL');
            dictGR.orderBy('name');
            dictGR.orderBy('element');
            dictGR.queryNoDomain();
            while (dictGR.next()) {
                tableName = dictGR.getValue('name');

                if (tableName.match('^var_')) {
                    continue;
                }
                
                var tblGR = new GlideRecord(tableName);
                if (tblGR.instanceOf('sys_metadata') == false) {
                    // This table is not an application file, skip
                    continue;
                }
                
                fieldName = dictGR.getValue('element');

                if ((tableName == 'sp_portal' && fieldName == 'quick_start_config') ||
                    (tableName == 'diagrammer_action' && fieldName == 'script') ||
                    (tableName == 'sys_ui_action' && fieldName == 'client_script_v2')) {
                    // these are niche
                    continue;
                }

                // Assume that if this field is on the table, it is a reference field to the product table
                var productTableField = '';
                if (tblGR.isValidField('table')) productTableField = 'table';
                    if (tblGR.isValidField('collection')) productTableField = 'collection';
                    
                result.push({
                    'table': tableName,
                    'field': fieldName,
                    'product_table_field': productTableField
                });
            }

            return result;
        },
        _scriptFieldArr: function() {
            var result = [];
            var tableName, fieldName;
            
            var dictGR = new GlideRecord('sys_dictionary');
            dictGR.addQuery('internal_type', 'script')
            .addOrCondition('internal_type', 'script_plain')
            .addOrCondition('internal_type', 'email_script');
            dictGR.addEncodedQuery('attributesISEMPTY^ORattributesNOT LIKEclient_script=true'); // Must be encoded for some reason
            dictGR.addQuery('name', '!=', 'NULL');
            dictGR.orderBy('name');
            dictGR.orderBy('element');
            dictGR.queryNoDomain();
            while (dictGR.next()) {
                
                tableName = dictGR.getValue('name');
                
                if (tableName.match('^var_')) {
                    continue;
                }
                
                var tblGR = new GlideRecord(tableName);
                if (tblGR.instanceOf('sys_metadata') == false) {
                    // This table is not an application file, skip
                    continue;
                }
                
                fieldName = dictGR.getValue('element');
                
                if ((tableName == 'sys_script_client' && fieldName == 'script') ||
                    (tableName == 'sys_ui_policy' && fieldName == 'script_false') ||
                (tableName == 'sys_ui_policy' && fieldName == 'script_true') ||
                (tableName == 'sys_ui_script' && fieldName == 'script') ||
                (tableName == 'sys_ui_page' && fieldName == 'client_script')) {
                    // these are client scripts
                    continue;
                }
                
                // Assume that if this field is on the table, it is a reference field to the product table
                var productTableField = '';
                if (tblGR.isValidField('table')) productTableField = 'table';
                    if (tblGR.isValidField('collection')) productTableField = 'collection';
                    
                result.push({
                    'table': tableName,
                    'field': fieldName,
                    'product_table_field': productTableField
                });
            }
            
            // for (var i = 0; i < result.length; i++) {
            //     var field = result[i];
            //     gs.print(field['table'] + "." + field['field'] + " (" + field['product_table_field'] + ")");
            // }
            
            return result;
        },
        _lineMatches: function(str, search) {
            var regex = RegExp(search,'g');

            var lines = [];

            while ((results = regex.exec(str)) !== null) {

                // Search the str and count all the new lines.
                // Could be made more efficent by not counting from 0, but from the first match.
                var newLines = str.substr(0, results.index).match(new RegExp('\r\n|\r|\n', 'g'));

                lines.push(newLines ? newLines.length + 1 : 1);
                
                // 10 matches? Bail out now. No point in returning more
                if (lines.length >= 10) return lines;

            }

            return lines;
        },
        _removeComments: function(a) {
            a = ("__" + a + "__").split("");
            for(var c = !1, d = !1, e = !1, f = !1, g = !1, h = !1, b = 0, k = a.length;b < k;b++) {
                if(e) {
                    "/" === a[b] && "\\" !== a[b - 1] && (e = !1)
                }else {
                    if(c) {
                        "'" === a[b] && "\\" !== a[b - 1] && (c = !1)
                    }else {
                        if(d) {
                            '"' === a[b] && "\\" !== a[b - 1] && (d = !1)
                        }else {
                            if(f) {
                                "*" === a[b] && "/" === a[b + 1] && (a[b + 1] = "", f = !1), "\n" != a[b] && (a[b] = "")
                            }else {
                                if(g) {
                                    if("\n" === a[b + 1] ||
ServiceNow Blog

Search This Blog

ServiceNow Running your own health scan, for improved reporting of culprit objects

ServiceNow Running your own health scan, for improved reporting of culprit objects
