Merge branch 'ServiceNowDevProgram:main' into Hactoberfest-2025-1st-pull-request

Author: Suri123789

Client-Side Components/Client Scripts/Form Dirty State Prevention/README.md

@@ -0,0 +1,109 @@
+# Form Dirty State Prevention
+
+## Overview
+Detects form changes and warns users before navigating away or closing the form, preventing accidental data loss.
+
+## What It Does
+- Tracks form field changes (dirty state)
+- Warns user before leaving unsaved form
+- Allows user to cancel navigation
+- Works with all form fields
+- Prevents accidental data loss
+- Clean, reusable pattern
+
+## Use Cases
+- Complex multi-field forms
+- Long data entry forms
+- Forms with expensive operations
+- Critical data entry (financial, medical)
+- Any form where accidental exit would cause issues
+
+## Files
+- `form_dirty_state_manager.js` - Client Script to manage form state
+
+## How to Use
+
+### Step 1: Create Client Script
+1. Go to **System Definition > Scripts** (any table)
+2. Create new Client Script
+3. Set **Type** to "onChange"
+4. Copy code from `form_dirty_state_manager.js`
+5. Set to run on any field
+
+### Step 2: Add Navigation Handler
+1. Add to form's onLoad script:
+```javascript
+// Initialize dirty state tracking
+var formStateManager = new FormDirtyStateManager();
+```
+
+### Step 3: Test
+1. Open form and make changes
+2. Try to navigate away without saving
+3. User sees warning dialog
+4. User can choose to stay or leave
+
+## Example Usage
+```javascript
+// Automatically tracks all field changes
+// When user tries to close/navigate:
+// "You have unsaved changes. Do you want to leave?"
+// - Leave (discard changes)
+// - Stay (return to form)
+```
+
+## Key Features
+- ✅ Detects any field change
+- ✅ Persistent across form interactions
+- ✅ Works with new records and updates
+- ✅ Ignores read-only fields
+- ✅ Resets after save
+- ✅ No performance impact
+
+## Output Examples
+```
+User opens form and changes a field
+→ Form marked as "dirty"
+
+User clicks close/back button
+→ Warning dialog appears: "You have unsaved changes"
+
+User clicks Leave
+→ Form closes, changes discarded
+
+User clicks Save then navigates
+→ No warning (form is clean)
+```
+
+## Customization
+```javascript
+// Customize warning message
+var warningMessage = "Warning: You have unsaved changes!";
+
+// Add specific field tracking
+g_form.addOnFieldChange('priority', myCustomHandler);
+
+// Reset dirty flag after save
+g_form.save(); // Automatically triggers cleanup
+```
+
+## Requirements
+- ServiceNow instance
+- Client Script access
+- Any table form
+
+## Browser Support
+- Chrome, Firefox, Safari, Edge (all modern browsers)
+- Works with ServiceNow classic and modern UI
+
+## Related APIs
+- [g_form API](https://docs.servicenow.com/bundle/sandiego-application-development/page/app-store/dev_apps/concept/c_FormAPI.html)
+- [Client Script Events](https://docs.servicenow.com/bundle/sandiego-application-development/page/app-store/dev_apps/concept/c_ClientScriptEvents.html)
+- [Form Field Changes](https://docs.servicenow.com/bundle/sandiego-application-development/page/app-store/dev_apps/concept/c_FieldChanges.html)
+
+## Best Practices
+- Apply to important data entry forms
+- Test with real users
+- Consider accessibility for screen readers
+- Use with save shortcuts (Ctrl+S)
+- Combine with auto-save patterns

Client-Side Components/Client Scripts/Form Dirty State Prevention/form_dirty_state_manager.js

@@ -0,0 +1,60 @@
+// Client Script: Form Dirty State Manager
+// Purpose: Track form changes and warn user before leaving with unsaved changes
+
+var FormDirtyStateManager = Class.create();
+FormDirtyStateManager.prototype = {
+    initialize: function() {
+        this.isDirty = false;
+        this.setupFieldChangeListeners();
+        this.setupNavigationWarning();
+    },
+    
+    // Mark form as changed when any field is modified
+    setupFieldChangeListeners: function() {
+        var self = this;
+        g_form.addOnFieldChange('*', function(control, oldValue, newValue, isLoading) {
+            // Ignore system updates and form loads
+            if (isLoading || oldValue === newValue) {
+                return;
+            }
+            self.setDirty(true);
+        });
+    },
+    
+    // Warn user before navigating away with unsaved changes
+    setupNavigationWarning: function() {
+        var self = this;
+        
+        // Warn on form close attempt
+        window.addEventListener('beforeunload', function(e) {
+            if (self.isDirty && !g_form.isNewRecord()) {
+                e.preventDefault();
+                e.returnValue = 'You have unsaved changes. Do you want to leave?';
+                return e.returnValue;
+            }
+        });
+        
+        // Warn on GlideForm navigation
+        g_form.addOnSave(function() {
+            // Reset dirty flag after successful save
+            self.setDirty(false);
+            return true;
+        });
+    },
+    
+    setDirty: function(isDirty) {
+        this.isDirty = isDirty;
+        if (isDirty) {
+            // Optional: Show visual indicator
+            document.title = '* ' + document.title.replace(/^\* /, '');
+            gs.info('[Form State] Unsaved changes detected');
+        }
+    },
+    
+    isDirtyState: function() {
+        return this.isDirty;
+    }
+};
+
+// Initialize on form load
+var formDirtyState = new FormDirtyStateManager();

Core ServiceNow APIs/GlideJsonPath/Create Critical P1 Incident from Alert using GlideJsonPath/README.md

@@ -0,0 +1,17 @@
+Create Critical P1 Incident from Alert This script provides the server-side logic for a Scripted REST API endpoint in ServiceNow. 
+It allows external monitoring tools to send alert data via a POST request, which is then used to automatically create a high-priority, P1 incident. 
+Overview The API endpoint performs the following actions: Receives a JSON Payload: Accepts a POST request containing a JSON payload with alert details (severity, description, source, CI). Parses Data: Uses the GlideJsonPath API to efficiently extract the necessary alert information from the JSON body. Validates Request: Ensures that the severity is CRITICAL and the description is present. It sends an appropriate error response for invalid or incomplete data. Creates Incident: If the data is valid, it creates a new incident record in the incident table. Sets Incident Fields: Automatically populates the incident's short_description, description, source, and sets the impact, urgency, and priority to 1 - High/Critical. Associates CI: If a ci_sys_id is provided in the payload, it links the incident to the correct Configuration Item. Logs Activity: Logs the successful creation of the incident in the system log for tracking and auditing purposes. Responds to Sender: Sends a JSON response back to the external system, confirming success or failure and providing the new incident's number and sys_id. Expected JSON payload The external system should send a POST request with a JSON body structured like this: json { "alert": { "severity": "CRITICAL", "description": "The primary database server is down. Users are unable to log in.", "source": "Dynatrace", "configuration_item": "DB_Server_01", "ci_sys_id": "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6" } } Use code with caution.
+
+Installation As a Scripted REST API Resource Create the Scripted REST API: Navigate to System Web Services > Scripted REST APIs. 
+Click New and fill in the details: Name: CriticalAlertIncident API ID: critical_alert_incident Save the record.
+
+Create the Resource: On the Resources related list of the API record, click New. 
+Name: PostCriticalIncident HTTP Method: POST Relative Path: / Copy and paste the provided script into the Script field. Configure Security: Ensure appropriate authentication is configured for the API, such as OAuth or Basic Auth, to secure the endpoint. Customization Change Priority/Impact: Modify the grIncident.setValue() lines to set different priority or impact levels based on the payload (e.g., if (severity == 'MAJOR') { grIncident.setValue('priority', 2); }). Add Additional Fields: Extend the script to parse and set other incident fields, such as assignment_group, caller_id, or category, based on data from the incoming payload. Enrich Incident Data: Perform a lookup on the CI to fetch additional information and add it to the incident description or other fields. Handle Different Severity Levels: Add if/else logic to handle different severity values (e.g., MAJOR, MINOR) from the source system, creating incidents with different priorities accordingly.
+
+Dependencies This script requires the GlideJsonPath API, which is available in Jakarta and later releases. 
+The API endpoint must be secured with appropriate authentication to prevent unauthorized access.
+
+Considerations
+
+Security: This API endpoint is a powerful integration point. 
+Ensure that it is properly secured and that only trusted sources are allowed to create incidents. Error Handling: The script includes robust error handling for common failures (missing data, insertion failure) but should be extended to handle specific use cases as needed. Testing: Thoroughly test the endpoint with a variety of payloads, including valid data, missing data, and invalid data, to ensure it behaves as expected.

Core ServiceNow APIs/GlideJsonPath/Create Critical P1 Incident from Alert using GlideJsonPath/script.js

@@ -0,0 +1,78 @@
+try {
+        // Get the JSON payload from the request body.
+        var requestBody = request.body.dataString;
+
+        // Use GlideJsonPath to parse the JSON payload efficiently.
+        var gjp = new GlideJsonPath(requestBody);
+
+        // Extract key information from the JSON payload.
+        var severity = gjp.read("$.alert.severity");
+        var shortDescription = gjp.read("$.alert.description");
+        var source = gjp.read("$.alert.source");
+        var ciName = gjp.read("$.alert.configuration_item");
+        var ciSysId = gjp.read("$.alert.ci_sys_id");
+
+        // Validate that mandatory fields are present.
+        if (!shortDescription || severity != 'CRITICAL') {
+            response.setStatus(400); // Bad Request
+            response.setBody({
+                "status": "error",
+                "message": "Missing mandatory alert information or severity is not critical."
+            });
+            return;
+        }
+        
+        // Use GlideRecordSecure for added security and ACL enforcement.
+        var grIncident = new GlideRecordSecure('incident');
+        grIncident.initialize();
+        
+        // Set incident field values from the JSON payload.
+        grIncident.setValue('short_description', 'INTEGRATION ALERT: [' + source + '] ' + shortDescription);
+        grIncident.setValue('description', 'A critical alert has been received from ' + source + '.\n\nAlert Details:\nSeverity: ' + severity + '\nDescription: ' + shortDescription + '\nCI Name: ' + ciName);
+        grIncident.setValue('source', source);
+        grIncident.setValue('impact', 1); // Set Impact to '1 - High'
+        grIncident.setValue('urgency', 1); // Set Urgency to '1 - High'
+        grIncident.setValue('priority', 1); // Set Priority to '1 - Critical'
+
+        // If a CI sys_id is provided, set the Configuration Item.
+        if (ciSysId) {
+            grIncident.setValue('cmdb_ci', ciSysId);
+        }
+        
+        // Insert the new incident record and store its sys_id.
+        var newIncidentSysId = grIncident.insert();
+        
+        if (newIncidentSysId) {
+            // Get the incident number for the successful response.
+            var incNumber = grIncident.getRecord().getValue('number');
+            
+            // Log the successful incident creation.
+            gs.info('Critical P1 incident ' + incNumber + ' created from alert from ' + source);
+            
+            // Prepare the success response.
+            var responseBody = {
+                "status": "success",
+                "message": "Critical incident created successfully.",
+                "incident_number": incNumber,
+                "incident_sys_id": newIncidentSysId
+            };
+            response.setStatus(201); // Created
+            response.setBody(responseBody);
+        } else {
+            // Handle database insertion failure.
+            response.setStatus(500); // Internal Server Error
+            response.setBody({
+                "status": "error",
+                "message": "Failed to create the incident record."
+            });
+        }
+        
+    } catch (ex) {
+        // Handle any exceptions during processing.
+        gs.error('An error occurred during critical alert incident creation: ' + ex);
+        response.setStatus(500);
+        response.setBody({
+            "status": "error",
+            "message": "An internal server error occurred."
+        });
+    }

Core ServiceNow APIs/GlideRecord/Conditional Batch Update/README.md

@@ -0,0 +1,30 @@
+# GlideRecord Conditional Batch Update
+
+## Description
+This snippet updates multiple records in a ServiceNow table based on a GlideRecord encoded query.  
+It logs all updated records and provides a safe, controlled way to perform batch updates.
+
+## Prerequisites
+- Server-side context (Background Script, Script Include, Business Rule)
+- Access to the table
+- Knowledge of GlideRecord and encoded queries
+
+## Note
+- Works in Global Scope
+- Server-side execution only
+- Logs updated records for verification
+- Can be used for maintenance, bulk updates, or automated scripts
+
+## Usage
+```javascript
+// Update all active low-priority incidents to priority=2 and state=2
+batchUpdate('incident', 'active=true^priority=5', {priority: 2, state: 2});
+```
+
+## Sample Output
+```
+Updated record: abc123
+Updated record: def456
+Updated record: ghi789
+Batch update completed. Total records updated: 3
+```

Core ServiceNow APIs/GlideRecord/Conditional Batch Update/batchUpdate.js

@@ -0,0 +1,35 @@
+/**
+ * Update multiple records in a table based on an encoded query with field-level updates.
+ * Logs all updated records for verification.
+ *
+ * @param {string} table - Name of the table
+ * @param {string} encodedQuery - GlideRecord encoded query to select records
+ * @param {object} fieldUpdates - Key-value pairs of fields to update
+ */
+function batchUpdate(table, encodedQuery, fieldUpdates) {
+    if (!table || !encodedQuery || !fieldUpdates || typeof fieldUpdates !== 'object') {
+        gs.error('Table, encodedQuery, and fieldUpdates (object) are required.');
+        return;
+    }
+
+    var gr = new GlideRecord(table);
+    gr.addEncodedQuery(encodedQuery);
+    gr.query();
+
+    var count = 0;
+    while (gr.next()) {
+        for (var field in fieldUpdates) {
+            if (gr.isValidField(field)) {
+                gr.setValue(field, fieldUpdates[field]);
+            } else {
+                gs.warn('Invalid field: ' + field + ' in table ' + table);
+            }
+        }
+
+        gr.update();
+        gs.info('Updated record: ' + gr.getValue('sys_id'));
+        count++;
+    }
+
+    gs.info('Batch update completed. Total records updated: ' + count);
+}

Server-Side Components/Business Rules/Field Validation based on form view in Server side/README.md

@@ -0,0 +1,14 @@
+ServiceNow business rule for server-side field validation based on form views.
+
+This ServiceNow business rule provides comprehensive server-side validation for multiple form fields when users access specific form views. The script ensures data integrity by validating that critical fields contain expected values before allowing record submission, making it perfect for enforcing business rules and data consistency across your ServiceNow instance.
+
+What This Script Does:
+
+The business rule automatically validates multiple fields against predefined expected values when a specific form view is accessed. Key features include:
+
+View-Based Validation: Only triggers when accessing a specified form view
+Multiple Field Support: Validates multiple fields simultaneously with customizable criteria
+Required Field Checking: Ensures mandatory fields are not empty or null
+Value Validation: Confirms fields contain expected values according to business rules
+User-Friendly Messaging: Provides clear, consolidated error messages explaining all validation failures
+Server-Side Security: Performs validation on the server to prevent client-side bypassing

Server-Side Components/Business Rules/Field Validation based on form view in Server side/fieldValidationinBR.js

@@ -0,0 +1,39 @@
+(function executeRule(current, previous /*null when async*/ ) {
+    var TARGET_VIEW_NAME = 'your_target_view_name';
+    var FIELD_VALIDATIONS = [
+        {field: 'field1', expectedValue: 'value1', errorMsg: 'Field 1 validation failed'},
+        {field: 'field2', expectedValue: 'value2', errorMsg: 'Field 2 validation failed'},
+        {field: 'field3', expectedValue: 'value3', errorMsg: 'Field 3 validation failed'}
+    ];
+    
+    var gURI = "";
+    try {
+        gURI = gs.action.getGlideURI();
+    } catch(e) {
+        return;
+    }
+    
+    var view_name = gURI.get('sysparm_view');
+    
+    if (view_name == TARGET_VIEW_NAME) {
+        var validationErrors = [];
+        
+        for (var i = 0; i < FIELD_VALIDATIONS.length; i++) {
+            var validation = FIELD_VALIDATIONS[i];
+            var fieldValue = current.getValue(validation.field);
+            
+            if (gs.nil(fieldValue)) {
+                validationErrors.push(validation.field + ' is required');
+                continue;
+            }
+            
+            if (fieldValue != validation.expectedValue) {
+                validationErrors.push(validation.errorMsg);
+            }
+        }
+        
+        if (validationErrors.length > 0) {
+            gs.addErrorMessage(gs.getMessage("Validation failed: {0}", validationErrors.join(', ')));
+        }
+    }
+})(current, previous);