GlideSystem API Guide

// Basic logging
gs.log('Script execution started');

// Logging with source
gs.log('Processing incident INC0000123', 'IncidentProcessor');

// Logging variables
var recordCount = 10;
gs.log('Processed ' + recordCount + ' records');

// Logging in Business Rule
gs.log('Before Insert - Incident: ' + current.number, 'BR_Incident_Before');

// Logging object information
var gr = new GlideRecord('incident');
if (gr.get(incidentId)) {
    gs.log('Found incident: ' + gr.number + ' - ' + gr.short_description);
}

// Simple info message
gs.info('User logged in successfully');

// Message with parameters
gs.info('Processing incident {0} for user {1}', current.number, current.caller_id);

// Multiple parameters
var count = 5;
var table = 'incident';
var duration = '2.3 seconds';
gs.info('Processed {0} records from {1} in {2}', count, table, duration);

// Real-world example: Logging assignment
gs.info('Incident {0} assigned to {1} by {2}', 
    current.number, 
    current.assigned_to.getDisplayValue(), 
    gs.getUserName());

// Conditional logging
if (current.priority == '1') {
    gs.info('Critical incident created: {0}', current.number);
}

// Warning for missing data
if (gs.nil(current.assigned_to)) {
    gs.warn('Incident {0} has no assigned user', current.number);
}

// Warning for unexpected condition
if (current.priority == '1' && gs.nil(current.assignment_group)) {
    gs.warn('Critical incident {0} has no assignment group!', current.number);
}

// Warning for deprecated functionality
gs.warn('Using deprecated method. Please update to new API.');

// Warning with multiple parameters
if (daysOpen > 30) {
    gs.warn('Incident {0} has been open for {1} days - requires attention', 
        current.number, daysOpen);
}

// Performance warning
var startTime = new GlideDateTime();
// ... processing ...
var endTime = new GlideDateTime();
var duration = gs.dateDiff(startTime, endTime, true);
if (duration > 5000) { // 5 seconds
    gs.warn('Script execution took {0}ms - performance issue detected', duration);
}

// Error handling in try-catch
try {
    // Some risky operation
    var result = riskyOperation();
} catch (e) {
    gs.error('Error in riskyOperation: {0}', e.message);
}

// Database operation error
var gr = new GlideRecord('incident');
if (!gr.get(incidentId)) {
    gs.error('Failed to retrieve incident: {0}', incidentId);
    return;
}

// Required field validation
if (gs.nil(current.caller_id)) {
    gs.error('Cannot process incident {0} - caller_id is mandatory', current.number);
    current.setAbortAction(true);
}

// Integration error
var response = callExternalAPI();
if (response.status != 200) {
    gs.error('API call failed with status {0}: {1}', 
        response.status, response.message);
}

// Data integrity error
if (current.closed_at < current.opened_at) {
    gs.error('Data integrity issue - Incident {0} closed before it was opened!', 
        current.number);
}

// Detailed debugging information
gs.debug('Entering calculateSLA function with priority: {0}', current.priority);

// Variable state debugging
var assignmentGroup = current.assignment_group.toString();
var assignedTo = current.assigned_to.toString();
gs.debug('Assignment state - Group: {0}, User: {1}', assignmentGroup, assignedTo);

// Loop debugging
for (var i = 0; i < records.length; i++) {
    gs.debug('Processing record {0} of {1}: {2}', i+1, records.length, records[i]);
}

// Function flow debugging
gs.debug('Starting incident validation');
if (validateIncident()) {
    gs.debug('Validation passed - proceeding with assignment');
} else {
    gs.debug('Validation failed - aborting action');
}

// Query debugging
gs.debug('Query: {0}', gr.getEncodedQuery());

// Get current user ID
var currentUserId = gs.getUserID();
gs.info('Current user ID: ' + currentUserId);

// Auto-assign to current user
current.assigned_to = gs.getUserID();
current.update();

// Check if current user is the caller
if (current.caller_id == gs.getUserID()) {
    gs.addInfoMessage('You are the caller on this incident');
}

// Query records for current user
var gr = new GlideRecord('incident');
gr.addQuery('assigned_to', gs.getUserID());
gr.addQuery('active', true);
gr.query();
gs.info('Found {0} active incidents for current user', gr.getRowCount());

// Audit logging
var auditGr = new GlideRecord('u_audit_log');
auditGr.initialize();
auditGr.user = gs.getUserID();
auditGr.action = 'Record Updated';
auditGr.record = current.sys_id;
auditGr.insert();

// Set created_by field in custom table
current.u_created_by = gs.getUserID();

// Check ownership
function isRecordOwner(record) {
    return record.assigned_to == gs.getUserID() || 
           record.opened_by == gs.getUserID();
}

// Get current username
var currentUser = gs.getUserName();
gs.info('Current user: ' + currentUser);

// Log with username
gs.info('Record modified by: {0}', gs.getUserName());

// Check for specific user
if (gs.getUserName() == 'admin') {
    // Admin-specific logic
    gs.info('Admin user detected');
}

// Exclude system users
if (gs.getUserName() != 'system' && gs.getUserName() != 'guest') {
    // Process for regular users
    processUserAction();
}

// Add to work notes
current.work_notes = 'Updated by ' + gs.getUserName() + ' on ' + gs.nowDateTime();

// Query by username
var gr = new GlideRecord('sys_user');
gr.addQuery('user_name', gs.getUserName());
gr.query();
if (gr.next()) {
    gs.info('User full name: {0}', gr.name);
}

// Notification personalization
var message = 'Hello ' + gs.getUserName() + ', your request has been approved.';
gs.eventQueue('request.approved', current, gs.getUserName(), message);

// Custom authentication logging
gs.log('User {0} accessed sensitive record {1}', gs.getUserName(), current.number);

// Get current user object
var user = gs.getUser();

// Access user properties
var userName = user.getName();           // Username
var fullName = user.getFullName();       // Full name
var userID = user.getID();              // sys_id
var email = user.getEmail();            // Email address
var firstName = user.getFirstName();    // First name
var lastName = user.getLastName();      // Last name

gs.info('User: {0} ({1}) - {2}', fullName, userName, email);

// Check roles
if (user.hasRole('admin')) {
    gs.info('User is an administrator');
}

if (user.hasRole('itil')) {
    // ITIL role specific logic
}

// Check multiple roles
if (user.hasRole('incident_manager') || user.hasRole('problem_manager')) {
    current.assignment_group = 'Service Desk Managers';
}

// Get user's company
var company = user.getCompanyID();
gs.info('User company: {0}', company);

// Get user's department
var dept = user.getDepartmentID();

// Check if user is member of a group
var groupSysId = '1234567890abcdef';
if (user.isMemberOf(groupSysId)) {
    gs.info('User is member of the specified group');
}

// Complete example: Assignment based on user context
var currentUser = gs.getUser();
if (currentUser.hasRole('service_desk')) {
    current.assigned_to = currentUser.getID();
    current.assignment_group = user.getGroupID(); // First group
    gs.info('Auto-assigned to {0}', currentUser.getFullName());
}

// Get user preferences
var userPrefs = user.getPreference('timezone');
gs.info('User timezone: {0}', userPrefs);

// Check if current user has admin role
if (gs.hasRole('admin')) {
    gs.info('User has admin privileges');
    // Admin-specific logic
}

// Check for ITIL role
if (gs.hasRole('itil')) {
    // Allow ITIL operations
    current.state = 'In Progress';
} else {
    gs.addErrorMessage('You do not have permission to change state');
    current.setAbortAction(true);
}

// Check multiple roles (OR condition)
if (gs.hasRole('incident_manager') || gs.hasRole('admin')) {
    // Manager or admin can close incident
    current.state = 'Closed';
}

// Role-based assignment
if (gs.hasRole('service_desk_manager')) {
    current.assigned_to = gs.getUserID();
} else if (gs.hasRole('service_desk')) {
    current.assignment_group = getServiceDeskGroup();
}

// Check specific user's role
var userId = current.assigned_to.toString();
if (gs.hasRole('resolver', userId)) {
    gs.info('Assigned user has resolver role');
}

// Deny action based on role
if (!gs.hasRole('admin') && !gs.hasRole('security_admin')) {
    gs.addErrorMessage('Only admins can perform this action');
    current.setAbortAction(true);
}

// Complex role logic
function canApproveRequest() {
    return gs.hasRole('approver_user') || 
           gs.hasRole('manager') || 
           gs.hasRole('admin');
}

if (canApproveRequest()) {
    current.approval = 'approved';
    current.update();
}

// Role-based field access
if (!gs.hasRole('finance')) {
    current.u_cost.setDisplayValue('');
    gs.addInfoMessage('Cost field hidden - Finance role required');
}

// Get system property
var instanceName = gs.getProperty('instance_name');
gs.info('Instance: {0}', instanceName);

// Get property with default value
var maxRetries = gs.getProperty('my.app.max_retries', '3');
gs.info('Max retries: {0}', maxRetries);

// Get email configuration
var emailDomain = gs.getProperty('glide.email.domain', 'company.com');
var fromEmail = 'noreply@' + emailDomain;

// Feature flag pattern
var featureEnabled = gs.getProperty('my.app.new_feature.enabled', 'false');
if (featureEnabled == 'true') {
    // Execute new feature
    executeNewFeature();
} else {
    // Use legacy code
    executeLegacyFeature();
}

// Timeout configuration
var timeout = parseInt(gs.getProperty('my.app.api.timeout', '30000'));
var response = callAPI(timeout);

// Environment-specific configuration
var apiEndpoint = gs.getProperty('my.app.api.endpoint', 
    'https://api.default.com');

// Integration credentials (use cautiously!)
var apiKey = gs.getProperty('my.app.external.api_key');
if (gs.nil(apiKey)) {
    gs.error('API key not configured');
    return;
}

// Business rule configuration
var autoAssign = gs.getProperty('incident.auto_assign.enabled', 'true');
if (autoAssign == 'true' && current.assignment_group.nil()) {
    assignToDefaultGroup();
}

// Notification settings
var notifyOnHigh = gs.getProperty('incident.notify.high_priority', 'true');
if (notifyOnHigh == 'true' && current.priority <= 2) {
    sendNotification();
}

// Dynamic threshold
var criticalThreshold = parseInt(
    gs.getProperty('incident.critical.age_days', '7')
);
if (daysOpen >= criticalThreshold) {
    escalateIncident();
}

// Set a system property
gs.setProperty('my.app.last_run', gs.nowDateTime());

// Create property with description
gs.setProperty('my.app.max_records', '1000', 
    'Maximum records to process in batch job');

// Update existing property
gs.setProperty('my.app.feature.enabled', 'true');

// Store counter
var currentCount = parseInt(gs.getProperty('my.app.counter', '0'));
currentCount++;
gs.setProperty('my.app.counter', currentCount.toString());

// Store last successful sync time
gs.setProperty('my.app.last_sync', new GlideDateTime().getValue());

// Configuration update
function updateConfiguration(key, value) {
    var oldValue = gs.getProperty(key);
    gs.setProperty(key, value);
    gs.info('Updated property {0} from {1} to {2}', key, oldValue, value);
}

// Feature toggle
function enableFeature(featureName) {
    var propKey = 'my.app.feature.' + featureName + '.enabled';
    gs.setProperty(propKey, 'true', 'Feature: ' + featureName);
    gs.info('Enabled feature: {0}', featureName);
}

// WARNING: Use sparingly - can cause performance issues
// Better to update properties through UI in most cases

// Simple info message
gs.addInfoMessage('Record saved successfully');

// Message with record details
gs.addInfoMessage('Incident ' + current.number + ' has been assigned to you');

// Confirmation message
gs.addInfoMessage('Email notification sent to ' + current.caller_id.email);

// Status update
gs.addInfoMessage('Your request has been submitted for approval');

// Business rule feedback
if (current.priority == '1') {
    gs.addInfoMessage('High priority incident - escalation team notified');
}

// Multiple actions feedback
var updated = updateRelatedRecords();
if (updated > 0) {
    gs.addInfoMessage('Updated ' + updated + ' related records');
}

// Workflow message
if (current.state == 'Resolved') {
    gs.addInfoMessage('Resolution email sent to caller');
}

// Assignment notification
gs.addInfoMessage('Assigned to ' + current.assigned_to.getDisplayValue() + 
    ' in group ' + current.assignment_group.getDisplayValue());

// Time-based message
var slaBreached = checkSLAStatus();
if (slaBreached) {
    gs.addInfoMessage('SLA has been breached - manager notified');
} else {
    gs.addInfoMessage('Record updated within SLA timeframe');
}

// Validation error
if (gs.nil(current.short_description)) {
    gs.addErrorMessage('Short description is required');
    current.setAbortAction(true);
}

// Permission error
if (!gs.hasRole('admin')) {
    gs.addErrorMessage('You do not have permission to perform this action');
    current.setAbortAction(true);
}

// Data integrity error
if (current.closed_at < current.opened_at) {
    gs.addErrorMessage('Closed date cannot be before opened date');
    current.setAbortAction(true);
}

// Business logic error
if (current.priority == '1' && gs.nil(current.assignment_group)) {
    gs.addErrorMessage('Critical incidents must have an assignment group');
    current.setAbortAction(true);
}

// Duplicate check
var gr = new GlideRecord('incident');
gr.addQuery('caller_id', current.caller_id);
gr.addQuery('short_description', current.short_description);
gr.addQuery('active', true);
gr.addQuery('sys_id', '!=', current.sys_id);
gr.query();
if (gr.hasNext()) {
    gs.addErrorMessage('A similar active incident already exists: ' + gr.next().number);
    current.setAbortAction(true);
}

// External service error
var response = callExternalService();
if (!response.success) {
    gs.addErrorMessage('External service error: ' + response.error);
}

// Required relationship error
if (gs.nil(current.cmdb_ci) && current.category == 'hardware') {
    gs.addErrorMessage('Hardware incidents must have a Configuration Item');
    current.setAbortAction(true);
}

// State transition error
if (current.state == 'Closed' && current.resolution_code.nil()) {
    gs.addErrorMessage('Resolution code required to close incident');
    current.setAbortAction(true);
}

// Get current date
var today = gs.now();
gs.info('Today is: {0}', today);

// Set due date field
current.due_date = gs.now();

// Query records created today
var gr = new GlideRecord('incident');
gr.addQuery('sys_created_on', '>=', gs.now());
gr.query();

// Compare dates
if (current.due_date < gs.now()) {
    gs.warn('Task is overdue');
}

// Set target date
current.u_target_completion = gs.now();

// Create dated work notes
current.work_notes = '[' + gs.now() + '] Status update...';

// Example: Set follow-up date to today
current.follow_up = gs.now();

// Get current date and time
var now = gs.nowDateTime();
gs.info('Current date/time: {0}', now);

// Set timestamp fields
current.u_last_checked = gs.nowDateTime();
current.u_processed_on = gs.nowDateTime();

// Audit trail
current.work_notes = 'Updated by ' + gs.getUserName() + ' at ' + gs.nowDateTime();

// Set closed time
if (current.state == 'Closed') {
    current.closed_at = gs.nowDateTime();
}

// Log processing time
gs.info('Processing started at: {0}', gs.nowDateTime());
processRecords();
gs.info('Processing completed at: {0}', gs.nowDateTime());

// Set expiration
current.u_session_expires = gs.nowDateTime();

// Query recent records (last hour)
var gr = new GlideRecord('incident');
gr.addQuery('sys_created_on', '>', gs.nowDateTime());
gr.query();

// Query incidents from last 7 days
var gr = new GlideRecord('incident');
gr.addQuery('opened_at', '>', gs.daysAgo(7));
gr.query();
gs.info('Found {0} incidents in last 7 days', gr.getRowCount());

// Query incidents older than 30 days
var gr = new GlideRecord('incident');
gr.addQuery('sys_created_on', '<', gs.daysAgo(30));
gr.addQuery('state', '!=', 'Closed');
gr.query();
gs.info('Found {0} open incidents older than 30 days', gr.getRowCount());

// Set reminder date
current.u_reminder_date = gs.daysAgo(-7); // 7 days from now

// Archive old records
var archiveDate = gs.daysAgo(365); // 1 year ago
var gr = new GlideRecord('u_custom_table');
gr.addQuery('sys_created_on', '<', archiveDate);
gr.addQuery('active', false);
gr.query();
while (gr.next()) {
    gr.u_archived = true;
    gr.update();
}

// Performance report - last 90 days
var startDate = gs.daysAgo(90);
var gr = new GlideRecord('incident');
gr.addQuery('opened_at', '>=', startDate);
gr.addQuery('state', 'Closed');
gr.query();

// Check if field is empty
if (gs.nil(current.assigned_to)) {
    gs.addErrorMessage('Assigned to field is required');
    current.setAbortAction(true);
}

// Validate multiple fields
if (gs.nil(current.short_description) || gs.nil(current.caller_id)) {
    gs.addErrorMessage('Short description and caller are required');
    current.setAbortAction(true);
}

// Set default value if empty
if (gs.nil(current.priority)) {
    current.priority = '4'; // Default to Low
}

// Conditional logic
if (!gs.nil(current.assignment_group)) {
    // Has assignment group
    notifyGroup(current.assignment_group);
} else {
    // No assignment group
    assignToDefaultGroup();
}

// Safe string concatenation
var description = '';
if (!gs.nil(current.short_description)) {
    description += current.short_description;
}
if (!gs.nil(current.description)) {
    description += '\n' + current.description;
}

// Validation before processing
function processIncident(incident) {
    if (gs.nil(incident.number)) {
        gs.error('Cannot process incident - number is empty');
        return false;
    }
    // Process incident
    return true;
}

// Check reference field
if (gs.nil(current.caller_id)) {
    gs.warn('Incident {0} has no caller', current.number);
}

// Generate unique ID
var uniqueId = gs.generateGUID();
gs.info('Generated GUID: {0}', uniqueId);

// Create unique reference number
current.u_reference_id = gs.generateGUID();

// Generate transaction ID
var transactionId = gs.generateGUID();
gs.info('Transaction ID: {0}', transactionId);
processTransaction(transactionId);

// Create unique token
var apiToken = gs.generateGUID();
current.u_api_token = apiToken;

// Generate session ID
var sessionId = gs.generateGUID();
gs.setProperty('user.session.' + gs.getUserID(), sessionId);

// Queue event for notification
gs.eventQueue('incident.assigned', current, current.assigned_to, current.assignment_group);

// Queue event with custom parameters
gs.eventQueue('custom.event', current, 'param1_value', 'param2_value');

// Queue event for workflow
if (current.priority == '1') {
    gs.eventQueue('incident.critical', current, gs.getUserName(), current.number);
}

// Queue event for integration
gs.eventQueue('external.sync', current, current.sys_id, current.number);

// Multiple events
if (current.state.changesTo('Closed')) {
    gs.eventQueue('incident.closed', current, current.caller_id, current.closed_by);
    gs.eventQueue('incident.metrics', current, current.number, current.resolved_at);
}