Merge branch 'ServiceNowDevProgram:main' into main

Author: raghavs046

Check Attachment

@@ -0,0 +1,3 @@
+An onSubmit Client script that checks whether only one file is attached and also file type should be .doc, .pdf or .txt. Otherwise form will not be submitted and required error message will be displayed to user.
+
+Note: Check this property - glide.attachment.extensions

CheckAttachmentFiletypr.js

@@ -0,0 +1,30 @@
+function onSubmit() {
+    var arr = [];
+    var extension1 = '.txt';
+    var extension2 = '.pdf';
+    var extension3 = '.docx';
+    var names = this.document.getElementsByClassName('get-attachment ng-binding ng-scope');
+    for (var i = 0; i < names.length; i++) {
+        var val = names[i].innerHTML;
+        arr.push(val.toString());
+    }
+
+    var countRequired = 1;
+    if (window == null) {
+        if (this.document.getElementsByClassName('get-attachment').length != countRequired) {
+            g_form.addErrorMessage('You can add only one attachment');
+            return false;
+        }
+    }
+
+    for (var j = 0; j < arr.length; j++) {
+        if ((arr[j].indexOf(extension1) > -1) || (arr[j].indexOf(extension2) > -1) || (arr[j].indexOf(extension3) > -1)) {
+            return true;
+        } else {
+            g_form.addErrorMessage('Unsupported file format. Please attach files with extensions .txt, .pdf, .doc');
+            return false;
+        }
+
+    }
+
+}

Client-Side Components/Client Scripts/Date Range Validation (Within 30 Days)/README.md

@@ -0,0 +1,10 @@
+Date Range Validation (Within 30 Days) in Client Side
+
+This ServiceNow client script provides real-time date validation for form fields, ensuring users can only select dates within a specific 30-day window from today's date. The script runs automatically when a user changes a date field value, providing immediate feedback and preventing invalid date submissions.
+
+The script validates that any date entered in a form field meets these criteria:
+Minimum Date: Today's date (no past dates allowed)
+Maximum Date: 30 days from today's date
+Real-time Validation: Instant feedback as users type or select dates
+User-friendly Errors: Clear error messages explaining the valid date range
+Automatic Field Clearing: Invalid dates are automatically cleared to prevent submission

Client-Side Components/Client Scripts/Date Range Validation (Within 30 Days)/dateRangeValidation.js

@@ -0,0 +1,23 @@
+function onChange(control, oldValue, newValue, isLoading, isTemplate) {
+    if (isLoading || newValue === '') {
+        return;
+    }
+    
+    var todayDate = new Date();
+    var futureDate = new Date();
+    futureDate.setDate(futureDate.getDate() + 30);
+    
+    var todayDateStr = formatDate(todayDate, g_user_date_format);
+    var futureDateStr = formatDate(futureDate, g_user_date_format);
+    
+    var selectedDateNum = getDateFromFormat(newValue, g_user_date_format);
+    var todayDateNum = getDateFromFormat(todayDateStr, g_user_date_format);
+    var futureDateNum = getDateFromFormat(futureDateStr, g_user_date_format);
+    
+    if (selectedDateNum < todayDateNum || selectedDateNum > futureDateNum) {
+        g_form.showFieldMsg(control, 'Date must be between today and 30 days from today', 'error');
+        g_form.clearValue(control);
+    } else {
+        g_form.hideFieldMsg(control);
+    }
+}

Client-Side Components/Client Scripts/Field Validations/README.md

@@ -0,0 +1,12 @@
+An `onLoad` client script that validates required fields in specific ServiceNow form views.
+
+This ServiceNow client script provides automatic validation of required form fields when users access specific form views. The script runs immediately when a form loads and checks that critical fields are populated, displaying user-friendly error messages for any missing required information. This ensures data completeness and improves form submission success rates by catching validation issues early in the user workflow.
+
+What This Script Does:
+The onLoad client script performs comprehensive field validation with these key capabilities:
+View-Specific Validation: Only triggers validation when accessing a designated form view
+Multiple Field Support: Validates multiple required fields simultaneously in a single operation
+Smart Field Detection: Uses field labels (not technical names) in error messages for better user experience
+Consolidated Error Display: Shows all missing required fields in a single, clear error message
+Immediate Feedback: Provides instant validation results as soon as the form loads
+Non-Intrusive Design: Displays informational errors without blocking form interaction

Client-Side Components/Client Scripts/Field Validations/fieldValidation.js

@@ -0,0 +1,23 @@
+function onLoad(){
+  var targetViewName = 'your_target_view_name';
+    var requiredFields = ['field1', 'field2', 'field3'];
+    
+    var currentViewName = g_form.getViewName();
+    
+    if (currentViewName === targetViewName) {
+        var emptyFields = [];
+        
+        for (var i = 0; i < requiredFields.length; i++) {
+            var fieldValue = g_form.getValue(requiredFields[i]);
+            if (!fieldValue || fieldValue.trim() === '') {
+                emptyFields.push(g_form.getLabelOf(requiredFields[i]));
+            }
+        }
+        
+        if (emptyFields.length > 0) {
+            var errorMessage = "The following required fields cannot be empty: " + 
+                             emptyFields.join(', ');
+            g_form.addErrorMessage(errorMessage);
+        }
+    }
+}

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/GlideAggregate/Find Oldest Open Incidents per Group/README.md

@@ -0,0 +1,38 @@
+ServiceNow Script: Find Oldest Open Incidents per Group
+This script leverages GlideAggregate to efficiently find the oldest active incident for each assignment group. This is a powerful tool for monitoring and reporting on potential service level agreement (SLA) risks and improving incident management processes.
+Overview
+The script performs the following actions:
+Initializes GlideAggregate: Creates an aggregate query on the incident table.
+Filters Active Incidents: Uses addActiveQuery() to restrict the search to only open (active) incidents.
+Aggregates by Minimum Date: Finds the minimum (MIN) opened_at date, which represents the oldest record.
+Groups by Assignment Group: Groups the results by the assignment_group to get a separate result for each team.
+Iterates and Logs: Loops through the query results and logs the assignment group and the opening date of its oldest open incident.
+How to use
+This script is intended to be used in a server-side context within a ServiceNow instance. Common use cases include:
+Scheduled Job: Run this script on a regular schedule (e.g., daily) to generate a report on aging incidents.
+Script Include: Incorporate the logic into a reusable function within a Script Include, allowing other scripts to call it.
+
+Use code with caution.
+
+Installation
+As a Scheduled Job
+Navigate to System Definition > Scheduled Jobs.
+Click New and select Automatically run a script of your choosing.
+Name the job (e.g., Find Oldest Open Incidents).
+Set your desired frequency and time.
+Paste the script into the Run this script field.
+Save and activate the job.
+As a Script Include
+Navigate to System Definition > Script Includes.
+Click New.
+Name it (e.g., IncidentHelper).
+API Name: global.IncidentHelper
+
+
+Customization
+Change the output: Modify the gs.info() line to instead write to a custom log, send an email, or create a report.
+Refine the query: Add more addQuery() statements to filter incidents by other criteria, such as priority or category.
+Change the aggregate: Use MAX instead of MIN to find the newest incident in each group.
+Get incident details: To get the actual incident record (e.g., its number), you would need to perform a secondary GlideRecord query based on the aggregated data.
+Dependencies
+This script uses standard ServiceNow APIs (GlideAggregate, gs). No external libraries are required.

Core ServiceNow APIs/GlideAggregate/Find Oldest Open Incidents per Group/script.js

@@ -0,0 +1,11 @@
+var ga = new GlideAggregate('incident');
+    ga.addActiveQuery();
+    ga.addAggregate('MIN', 'opened_at');
+    ga.groupBy('assignment_group');
+    ga.query();
+
+    while (ga.next()) {
+        var group = ga.assignment_group.getDisplayValue();
+        var oldestIncidentDate = ga.getAggregate('MIN', 'opened_at');
+        gs.info("Oldest open incident for " + group + " was created on: " + oldestIncidentDate);
+    }