DEV Community: Sophia Semga

ServiceNow UI Builder

Sophia Semga — Thu, 09 Jan 2025 00:15:13 +0000

Hey guys, happy new year!

✨
I know some of you have been wondering where I’ve been for the last few months. After passing my Cloud Architect exam, I decided to dive into this shiny, new web interface everyone’s been talking about: UI Builder!

What is UI Builder?

UI Builder is a web interface for creating and configuring custom pages for workspaces and portals. It’s part of the Now Experience UI Framework and allows you to:
•Build pages.
•Set up layouts and components.
•Define event handlers for actions.
•Fetch and display data using data binding.
•Create client scripts and client state parameters(also known as variables) to use within components.

It’s essentially a one-stop shop for creating custom web experiences. Let’s break down the key parts of UI Builder and how to get started.

How UI Builder Works

1. Experiences and Pages

An experience is a collection of pages where users can manage work, find information, or get help. Each page is defined by its URL and defines the contents sitting in that URL. It consists of two key elements: Layout and Components.
2. Layouts
Layouts organize how content is displayed on a page. They’re the first step in building a page and can use:
•Basic column layouts: Predefined structures with up to six columns.
•Advanced layouts: Flexbox or CSS grid-based designs for more customization.
Layouts also come with tools like a simplified content tree and panels for configuration and styling.
3. Components
Components are the building blocks of a page, such as forms, buttons, data lists, charts, images, or menus. Once you set up a layout, you can add components to the page. You can customize each component using the Configuration Panel, which includes:
•Configure Tab: Edit properties using static values, data binding, or JavaScript.
•Styles Tab: Add custom CSS.
•Events Tab: Set up actions triggered by user interactions.

It’s best practice to add layouts first, then components.

Page Variants and Conditions

All pages in UI Builder are variants. The first page you create is the default variant. Think of variants like form views: the same record, but displayed differently based on the context. You can create additional variants for different audiences or conditions.
Conditions determine when a page variant is visible. These can be set using:
•Using the Condition Builder to set rules.
•Specifying conditions via encoded queries.
For conditions to work, they rely on data passed by page parameters, which we’ll cover in detail in the next article.

What’s Next?

Lets create a simple experience in UI Builder!
We will be creating an experience that allows us to view a record page.

1.Getting Started.

.Log in to your ServiceNow instance.
.Navigate to Now Experience Framework > UI Builder in the filter navigator to open the UI Builder interface.

2.Creating an Experience

.Click the Create button in the top-right corner.

.Select Experience from the dropdown. A modal window will appear.
. Fill in the following details:
•Name: Any name. Ex ‘ Default Workspace’.
•App Shell UI: Ex ‘Workspace App Shell’.
An app shell is the wrapper of the contents for an experience and defines the general look of your experience—it’s the theme of the experience.
•Landing Path: Leave as default - Home.
•Roles: Remove the default role for now.

.Click Create, then select Open Experience to proceed.

3.Creating a Page

.In your new experience, click Create New Page or the + icon next to Pages and Variants.

We are going to be using a template
Choose Standard Record Template

.Enter a page name for your template. The URL path will auto-populate.

.Click Continue,
.Our record template comes with pre configured required(table & sys_id) and optional(query, extraParams views, selectedTab)parameters, review it then select Looks Good.

4.Creating a Variant

.Name your page variant, then skip Audience and Conditions for now. Click Continue.
.Familiarize yourself with the Variant Editor:
•Left Panel: Content tree for adding layouts and components.
•Right Panel: Configuration panel with tabs for customizing components.
•Bottom Left: Tools for dynamic data like Data Resources, Client State Parameters, and Client Scripts.

Thats it!

In the next article we will be expanding on our experience by adding page parameters to the our page variant- to allow us to pass data values to be utilized within the page.

This overview introduced the basics of UI Builder, from layouts and components to pages and variants. In upcoming articles, we’ll dive deeper into creating dynamic, interactive pages by exploring:
•Page Parameters.
•Data Resources.
•Client State Parameters.
•Client Scripts.
•Events.
By the end of this series, you’ll have a solid grasp of UI Builder and how to create resourceful, user-friendly experiences!!

Learn More About UI Builder
•Take a Free Now Learning Course on UI Builder
https://nowlearning.servicenow.com/lxp/en/now-platform/ui-builder-fundamentals-washington?id=learning_course_prev&course_id=7ba080d447fdd65076e07884f16d435e

•ServiceNow Documentation on UI Builder
https://www.servicenow.com/docs/bundle/xanadu-application-development/page/administer/ui-builder/concept/ui-builder-overview.html

SubFlows in ServiceNow Flow Designer

Sophia Semga — Wed, 02 Oct 2024 01:12:03 +0000

In ServiceNow Flow Designer, subflows are reusable actions or smaller units of logic that can be called from a parent flow or another subflow. They cover specific processes, making them reusable and easier to maintain across different automation scenarios. This flexibility helps simplify workflows, particularly in complex automation environments.

Subflows allow developers to create reusable logic without rewriting the same steps repeatedly in various flows. These components are essential in managing complexity, improving maintainability, and enhancing overall system efficiency.

Key Components of Subflows

Inputs: These are the data or parameters provided to the subflow when it is executed. They define what information the subflow needs to perform its tasks.
Outputs: After the subflow runs, it can return data to the calling flow through outputs. These outputs can be used by the parent flow to make further decisions or trigger other actions.

The Difference Between Inputs and Outputs in Subflows

Inputs: Inputs are like the ingredients you pass into a recipe. They are the parameters that the subflow requires to operate. For example, if you have a subflow to create an incident, inputs might include:
• Short description
• Priority
• Assignment group
• Caller

Outputs: Once the subflow runs its course, outputs are the results or the outcome that can be passed back to the main flow. For example, in the same incident creation subflow, outputs might include:
• Incident number
• Incident sys_id
• Created date

Inputs are essentially the information you provide the subflow to work with, and outputs are the useful data you get after the subflow completes its task.

Let’s break down a basic use case to understand how subflows work in a real-world scenario. We’ll create a subflow that handles the creation of change requests.

In the sub-flow we will:

Create a change request.
Set assignment group in change request.
Send an email to assignment group.

Watch this 14 minute Youtube video on automating change request using sub flows.

Advantages of Using Subflows

Reusability: Once created, a subflow can be reused in multiple parent flows, reducing redundancy and improving maintenance.
Simplicity: Break complex flows into smaller, manageable subflows, simplifying the overall design.
Maintainability: When a subflow is updated, any flow using it benefits from the update, enhancing consistency across the platform.

Best Practices for Working with Subflows

• Limit Inputs and Outputs: Keep your inputs and outputs concise and relevant. Avoid overloading subflows with unnecessary parameters.
• Test Regularly: Make sure to test subflows independently before integrating them into a larger flow. This ensures they work correctly in isolation.
• Use Subflows for Repetitive Tasks: If a task is common across multiple flows, create a subflow to handle it, saving development time and reducing duplication.

Conclusion

Subflows are powerful tools in ServiceNow Flow Designer, enabling developers to create reusable logic that can simplify complex workflows. By understanding the differences between inputs and outputs, and using practical use cases like the change automation subflow, developers can build efficient and maintainable solutions.

Subflows are particularly useful when multiple flows share similar logic or actions, ensuring consistency across processes while reducing the risk of errors.

#TheWorldWorksWithServiceNow :)

-ServiceNow Product documentation on SubFlows:
https://docs.servicenow.com/bundle/xanadu-build-workflows/page/administer/flow-designer/concept/subflows.html

-ServiceNow Product documentation on Flow Designer:
https://docs.servicenow.com/bundle/washingtondc-build-workflows/page/administer/flow-designer/concept/flow-designer.html

-Watch Youtube Video on SubFlows:
https://youtu.be/Kqhq4-KhPX8

ServiceNow Xanadu Release: An Overview of Key Upgrades

Sophia Semga — Mon, 05 Aug 2024 01:24:46 +0000

ServiceNow has once again impressed us with the Xanadu release. In this blog, we'll explore some of my favorite upgrades from this new release and what they entail.

When ServiceNow announces upgrades, they truly mean it. I appreciate how each upgrade not only enhances ServiceNow functionalities but also ensures that these enhancements benefit every professional using the platform. These upgrades are designed to improve operations not just for developers, but also for administrators, process owners, business analysts, and product owners.

In this overview of the Xanadu release, we’ll delve into some ITSM and ITOM product release notes:

ITSM Product Release Notes

Incident Management: Email notifications now offer greater flexibility by allowing you to choose where links to an incident record are redirected. Instead of opening automatically in the Classic UI 16 Interface, the incident record can be redirected to the Service Operation Workspace (SOW). The incident record link in the email will open in SOW under the following conditions:

The (sow_email_notification_redirect) system property is set to true.
The user clicking the incident record link has the sn_sow_user role.

Now Assist ITSM:

Knowledge Articles: Enable your agents to create comprehensive knowledge articles by leveraging information from similar incidents.
Chat Reply Recommendations: Assist agents in responding to common questions in chats using the “Write with Now Assist” feature for chat reply suggestions.
Contextual Understanding: Help agents gain a better understanding of chat and incident contexts with Sidebar discussion summarization when proposing resolutions.

Note: The Now Assist for ITSM application requires an IT Service Management Pro Plus or Enterprise Plus license.

Service Operations Workspace (SOW):

SOW provides a unified experience for multiple IT Service Management and IT Operations Management capabilities. In the Xanadu release, several enhancements have been made:

View VIP field decorators on call fields in incident records for VIP users.
Test Incident Management features and workflows in SOW with quick start tests.
Resolve password-reset related incidents using the password-reset UI action on an incident record.
Obtain AI-powered search results for the following record types: Incident, Incident Tasks, Problem, Problem Tasks, Change Requests, Change Request Tasks, Interaction, and Request.

IT Operations Management (ITOM) Release Notes

The Xanadu release introduces updated features across ServiceNow ITOM products:

ITOM Health: Track and maintain the health of your organization's services, including Health Log Analytics, Event Management, Agent Client Collector applications, and more.
ITOM Cloud Accelerate: Provides workflows to assess cloud readiness and enforce ITOM Cloud Accelerate guidelines.
ITOM Optimization: Automates cloud workflows for managing resources throughout their life cycles, offering visibility into costs and enabling the deployment of certified, enterprise-compliant clouds.
ITOM Visibility: Provides a unified, connected view of your entire IT network and the services it supports.

ITOM Visibility Highlights in the Xanadu Release:

Benefit from a unified workspace for configuring discovery, managing errors, and tracking progress with diagnostic tools that offer insights into discovered data. View discovery trends, tasks, and access relevant information through the Discovery Admin home. Analyze discovery errors and troubleshoot them using the Diagnostic tab.
With the Xanadu release, you can enhance your application Service Mapping by installing the App Service Extension application from the ServiceNow store. Use Automated Service Suggestions and CMDB data to create a new application service, eliminating the need for Mid-servers.

The Xanadu release documentation includes many more powerful upgrades that I can’t all cover in detail here. I encourage you to review the release notes this week, identify your favorite upgrades, and make sure to update your PDI to Xanadu to experience these new features firsthand on the ServiceNow platform.

`#TheWorldWorksWithServiceNow :)`

Learn More About ServiceNow Xanadu release here:
https://docs.servicenow.com/bundle/xanadu-release-notes/page/release-notes/family-release-notes.html

Learn More about Xanadu IT Service Management release notes:
https://docs.servicenow.com/bundle/xanadu-release-notes/page/release-notes/it-service-management/it-service-management-rn-landing.html

Learn More about Xanadu IT Operation Management release notes:
https://docs.servicenow.com/bundle/xanadu-release-notes/page/release-notes/it-operations-management/it-operations-management-rn-landing.html

THE POWER OF LDAP INTEGRATION

Sophia Semga — Wed, 24 Jul 2024 14:58:42 +0000

Lightweight Directory Access Protocol (LDAP) is a cross-platform protocol used to manage and access directory services, such as Active Directory, which is used to authenticate users and groups. LDAP follows a client/server model, where an LDAP application requests information from an associated LDAP server. Once authenticated, the database responds to the LDAP server, which in turn sends the response back to the application.

LDAP integration enables ServiceNow to connect with an existing LDAP directory/server for user authentication and data synchronization. The integration works by having the LDAP application request data (acting as the client side) and providing a username and password for authentication. The server verifies these credentials, and if they are valid, the data is transmitted. Notably, the password entered is contained entirely within the HTTPS session, as this integration never stores LDAP passwords.

There are two key aspects to the integration:

1.Data Population

Integration with LDAP servers allows you to quickly and easily populate ServiceNow with user records from the existing LDAP database. Configuration flags are available to either create, ignore, or skip incoming LDAP records to prevent data inconsistencies. You can limit the data imported by specifying LDAP attributes, thereby importing only the data you want to expose to an instance. If no LDAP attributes are specified, the integration imports all available object attributes from the LDAP server.

2.Authentication

In an LDAP-integrated ServiceNow environment, when users try to log in, their credentials are passed to all defined LDAP servers. By authenticating against your LDAP server, users can access the platform with the same credentials they use for other internal resources on your network domain.

LDAP Directories/Structure

LDAP directories are structured as tree entities, where each entity consists of a set of attribute-value pairs describing an object.

Prerequisites for LDAP Integration

.Allow inbound network access through the firewall
.External IP/Name of the LDAP server
.User credentials with read-only access
.The directory services server must be LDAP V3 compliant
.PKI certificate for an LDAP V3 compliant directory services server

LDAP Servers Supported by ServiceNow

.Microsoft Active Directory
.Novell
.Domino
.Open LDAP

How to Set Up and Perform LDAP Integration in ServiceNow

LDAP integration uses a read-only connection that never writes to the LDAP directory/server. The integration's sole purpose is to query for information and update the database accordingly.

1. Search for LDAP in Application Navigator and create a new server:

-For "Type of LDAP Server," leave it as Active Directory (or choose "other" if working with a different server).
-For "Server Name," enter a name (e.g., TestLDAPIntegration).
-For the server URL, use a free LDAP test server found online (e.g., forumsys.com).
-Paste the server URL from the free test server into ServiceNow.
-For "Starting Search Directory," indicate where ServiceNow should begin its search for users and groups.

2. Submit the form:

-You will be taken to a different record containing the information you filled out.
-Provide a Login Distinguished Name and Login Password to allow ServiceNow to access the server/directory. You can find these details on the free test server website.

-Save and submit the form.

3. Verify the connection:

-A message should display indicating that the connection has been successful.
-In the related list under LDAP OU Definitions, click "Users."
-Remove the out-of-the-box (OOB) value displayed in the filter field and replace it with the specific data you are querying (e.g., users with names starting with "e").

-Click the 'Test connection' related link to secure connection and 'Browse' related link to validate and check if the test worked.

4. Import and map data:

-Now that you have fetched the desired user data, populate the data into your ServiceNow database on the sys_user table.
-Under LDAP OU Definition > Users, click on the data included in Data Source to access the import set.
-Click "Load All Records."

-Create a transform map, name it, set the target table to 'sys_user', and automap fields.

-Use the mapping assist to map fields (e.g., UID to UserID).

-Save and transform the data.

-Verify that the users have been populated successfully in the user table.

Congratulations! you have been able to successfully perform LDAP integration on your ServiceNow instance. LDAP integration is a powerful feature that streamlines user management and authentication in ServiceNow, making it easier to maintain consistency and security across your network.

Here are some additional links + documentation to help you sharpen your understanding of LDAP Integration:

•What is ServiceNow Integration:
https://www.servicenow.com/content/dam/servicenow-assets/public/en-us/doc-type/success/enablement/integration-implementation-faq.pdf

•ServiceNow LDAP : https://docs.servicenow.com/bundle/vancouver-platform-security/page/integrate/ldap/concept/c_LDAPIntegration.html

•Understanding ServiceNow LDAP :
https://docs.servicenow.com/bundle/vancouver-platform-security/page/integrate/ldap/reference/r_LDAPIntegrationFAQs.html

•LDAP Test Servers : https://www.google.com/search?q=ldap+test+server&ie=UTF-8&oe=UTF-8&hl=en-us&client=safari

•Configure LDAP in ServiceNow : https://youtu.be/e4c0MgJzwu4?si=GN70OLjLRKIDzvxG

ServiceNow Mid-Server Insights

Sophia Semga — Wed, 03 Jul 2024 18:25:13 +0000

ServiceNow Mid servers, also known as Management Instrumentation and Discovery, play a crucial role in extending the platform's capabilities. These Java applications, installed on external servers, act as bridges, fetching data from third-party sources and delivering it back to ServiceNow.

What are Mid Servers and How Do They Work?

Mid servers facilitate seamless data flow between ServiceNow and external applications, services, and data sources. They initiate communication with the ServiceNow instance and leverage the External Communication Channel (ECC) Queue for message exchange. This queue acts as a communication log, allowing data insertion, updates, and queries.

ECC Queue: The Communication Hub

Think of the ECC Queue as a central communication point. It houses two record types:

Output Probes: Instructions sent by ServiceNow to the mid-server for data retrieval.
Input Probes: Responses containing retrieved data sent by the mid-server back to ServiceNow.

Security is Paramount

Secure connections are essential for both mid-server installation and data discovery. ServiceNow utilizes HTTPS:443 for encrypted communication with the mid-server. Similarly, the mid server establishes secure network connections with data sources to ensure information integrity.

Installing a Mid Server in ServiceNow

1.Create a User and Give Them the Mid-Server Role

•Go to the sys_user table on your ServiceNow instance to create a new user who will interact with the mid-server. This user account is created to have a specific account to manage the integration, preventing it from stopping. Using other user accounts risks termination or revocation, which can cause the server to stop running.
•Create a user and set a password.
•Once the user is created, give them the mid-server role.

2.Download the Mid Server

•Search for “Mid Server” in your application navigator and click on “Downloads” to download the mid server. Select the appropriate installer based on your operating system (e.g., Windows, Linux).
•Download the mid-server.
•Once the download is complete, it will be accessible under your file downloads.
•Go to your files and create a folder in your C: drive, which will act as your directory. In the directory, create a new folder and name it.
•Under downloads, where your mid server has been downloaded, right-click to extract all and select the folder you created under your directory so that it is extracted into the designated folder.
•Go to your drive/folder, which now contains mid-server contents, and click on the agent folder.
•Under the agent folder, click on the config XML file and fill in the required parameters, including your instance URL(ex,https://dev210312.service-now.com/)
the username (ex, midserver_user)
and password of the user you created and assigned the mid-server role to, and create a name.
Then save.

3.Validate and Update

•Wait for it to populate on your instance under mid_server. Then click on it to validate and update it. Wait for it to validate and for the status to be up.
•Once the status is populated, congratulations! You have successfully installed a mid server into your ServiceNow instance.

Upgrading the Mid Server

ServiceNow mid servers typically perform periodic checks for upgrade availability. Upon detecting a newer version, they automatically download and install the upgrade package. Manual upgrades are also an option.

Troubleshooting Mid-Server Issues

1. Restarting the Mid Server:

You can restart the mid-server through the ServiceNow UI or the Command Line Interface (CLI).

UI Method

•Sign in to ServiceNow.
•Go to “System Definition” and select “Mid Servers.”
•Choose the mid-server that needs restarting.
•Click the “Restart” button at the top.
•Wait a few minutes until the mid-server status changes to “Running.”
•Verify its connectivity and performance.

CLI Method

•Log into the machine hosting the mid-server.
•Execute commands from ServiceNow documentation.

2.Checking Mid-Server Logs:

The mid-server logs, located in the installation directory, offer valuable insights into any issues encountered.

ServiceNow Applications that Leverage Mid Servers:

.Discovery
.Service Mapping
.Event Management
.Cloud Management
.Integration Hub
.Orchestration

External Applications that Utilize Mid Servers:

.Import sets
.Microsoft System Center Configuration Manager (SCCM)
.Microsoft Identity Integration Server (MIIS)
.Microsoft System Center Operations Manager (SCOM)

Compatibility Matters

For seamless communication, ensure compatibility between the mid-server version and your ServiceNow instance version. The mid-server version should at least belong to the same major release (e.g., Tokyo) as the instance. While minor version compatibility (e.g., Tokyo Patch 1) might work, it's highly recommended to upgrade to the latest version for optimal performance and security.

Conclusion

ServiceNow mid servers are powerful tools for extending platform functionality. By understanding their purpose, configuration process, and use cases, you can leverage them to streamline data integration and enhance your overall ServiceNow experience.

ServiceNow Product Documentation on MidServers:

What is a mid-server: https://docs.servicenow.com/bundle/washingtondc-servicenow-platform/page/product/mid-server/concept/mid-server-landing.html

Configure mid-server parameters: https://docs.servicenow.com/bundle/washingtondc-servicenow-platform/page/product/mid-server/reference/mid-server-parameters.html

Leverage ServiceNow REST API: Integrate & Create Records Selectively

Sophia Semga — Wed, 19 Jun 2024 19:27:45 +0000

ServiceNow offers a powerful tool for integrating with external applications: the REST (Representational State Transfer) API. This inbound web service allows external applications and clients to interact with data within your ServiceNow instance in a controlled manner.

Think of it as a set of well-defined functions that enable you to send requests and receive responses from other applications using HTTP protocols.
Common REST HTTP methods include:
• GET: Retrieve data from a third-party application.
• PUT: Update data within a third-party application.
• POST: Create new data within a third-party application.
• DELETE: Delete data from a third-party application.
• PATCH: Partially update data within a third-party application.

Use Case: Creating a ServiceNow Record from Another Application with Selective Field Copying

This scenario demonstrates how to create a ServiceNow record from another application while including specific fields from being copied into the ServiceNow record.

1. Setting Up the Inbound Web Service

•Navigate to Web Services > Inbound. This is where you define how external applications can interact with your ServiceNow data.
•Fill in the Label Name (a user-friendly name for your integration).
Select the Target Table where the data will be stored (e.g., Incident table).
•Under Web Service Fields, define the fields you'll receive from the third-party application. These are the fields required to create a record in ServiceNow (e.g., caller, short description).
•Click Create.

2. Configuring the Transform Map

•Upon creation, a Transform Map is generated. This map translates data from the source table (where the third-party application sends data) to the target table (the ServiceNow table you selected).
•Click on Automapping Assist to automatically map fields from source to target.
Review and adjust the mappings as needed.
•Click Save to save the transform map.

3. Testing the Web Service

•Locate your newly created inbound web service in the Application Navigator.

•Under Related Links, click Explore REST API. This interface allows you to test the web service before integrating with the third-party application.
•On the Explore REST API interface, you'll see the staging table name and a request body section.

•In the request body, enter test data for the fields you defined earlier.

•Click Send.
Remember, request formats for ServiceNow REST APIs are always in JSON format.

4. Verifying Successful Test

•A successful test will return a status code of 201 (Created).

•The response body will display a newly created test record.

•Double-check by navigating to Incident > Open to confirm the test record exists.

5. Integration with Third-Party Application (HoppScotch)

🔗:https://hoppscotch.com/

Now, let's integrate your ServiceNow instance with a third-party application called HoppScotch to create records directly from HoppScotch.

Configuration on HoppScotch

•Use the POST method as you're creating a new record.

•In the Request URL, copy the method URL from the ServiceNow REST API Explorer. This URL defines the resource where data will be posted.

•For Authorization, select Basic Auth and enter your ServiceNow username and password. This ensures secure communication between applications.

•Under Headers, set the Content-Type to application/json.

•In the Body section, copy and paste the request body data from the ServiceNow REST API Explorer. This data defines the information to be included in the new record.

•Click Send.

6. Confirmation and Verification

•A successful creation will return a status code of 201 (Created).
The response body will contain details about the import set, staging table, and the newly created ServiceNow record.

•Navigate back to your ServiceNow instance under Incident > Open to confirm the record was successfully created.

Conclusion

Congratulations! You've successfully utilized ServiceNow's REST API to create a record in your instance through a third-party application.
🎊🎊

Expand Your Toolkit: Exploring Additional REST API Clients

Beyond HoppScotch, several other tools offer functionalities similar to API testing, development, and collaboration. Here are a few popular options:

•Insomnia:[https://insomnia.rest/]
•Paw: [https://paw.cloud/]
•Postman:[https://www.postman.com/]
•SwaggerHub: [https://swagger.io/tools/swaggerhub/]

Further Learning:

For a deeper dive into ServiceNow REST API functionalities and methods, refer to the ServiceNow product documentation on REST APIs.
•ServiceNow REST API: https://docs.servicenow.com/bundle/washingtondc-application-development/page/integrate/inbound-rest/concept/c_RESTAPI.html

•ServiceNow REST API reference: https://docs.servicenow.com/bundle/washingtondc-api-reference/page/build/applications/concept/api-rest.html

Leveraging SOAP APIs for Outbound Integration: A Step-by-Step Guide.

Sophia Semga — Wed, 05 Jun 2024 21:23:05 +0000

Soap API: Outbound Integration

SOAP (Simple Object Access Protocol) is an XML-based messaging protocol used for exchanging information between two applications. It includes a WSDL file, which contains the necessary information about what the web service does and the location of the web service.
WSDL, also known as Web Service Definition Language, is the format in which data can be represented. All tables and import sets dynamically generate a WSDL XML document that describes the table schema and available operations.

You can obtain a table’s WSDL by using a URL call to your instance that contains the name of the target table and the WSDL parameter (e.g., https://myinstance.servicenow.com/incident.do?WSDL).

To get started with SOAP, you need a source instance and a target instance (the target instance could be another third-party application or another ServiceNow instance).

Use case: Whenever an incident record is created in the source instance, that same record should get inserted/populated in the target instance/application.

We are going to create an inbound integration on the target instance, essentially an import set that will synchronously transform the incoming data (SOAP message + Basic AUTH) based on associated transform maps.

Web Services > Inbound

•Label - Name of Import : Incident demo
•Name - Value of name of Import: u_incidentdemo
•Checkmark <u>Copy fields from target table</u>, because we need all the fields that are in the table
•Target Table - Name of table you’re deriving data from: Incident

Click Create

•Then Click “Automapping Assist” to pull out all the fields from the target table, creating an import set.

What Is The Purpose:

To generate the WSDL URL data of the table. If you type the label name, it’ll come up as a module. Click on it and copy the WSDL URL.

On to the Source Instance:

On the source instance, search for SOAP API - SOAP Message. Keep in mind that our source instance is performing the outbound integration because a record is being ‘thrown out’ of the system.

On SOAP Message:
Click New

1•Name: Name of Soap Message: IncidentDemo
(Naming conventions doesn’t matter)

2•WSDL: Date copied from target instance

3•Authentication Type: Basic
4•Basic Auth Profile: Serves as credentials to authenticate the client( target instance ) by verifying the username and password against its authentication system before processing soap requests.
To get the Basic Auth profile, go to the target instance to get your system administrator username and password. Make sure it’s set or reset it if need be. (Sys_user.LIST to access the admin account.)

•Once username and password has been reset,
go back to source instance and add it on Basic AUTH profile field, then save form.

5•Once you save it, you will see a “Generate Sample Soap Messages” related link. —-this is a no code approach to simply insert requested data without any need for a customization(scripting).

6•Click on the link, and it'll download the WSDL of the target instance target table from the URL, generating the Soap methods.
•Update - to update records. •getRecords - to get multiple records. •deleteRecord - to delete a record. •Insert - to insert a record. •deleteMultiple - deletes multiple records. •get- to get a record.

Click on the Insert Method, because we’re going to be inserting a new record on the target instance.
1• Select authentication as Basic and choose the Basic Auth we created.

2•On the envelope field, we see all the fields that make up incident record in an XML file, you can remove fields that aren’t required/ part of requirement.

3•Once done, Save the form.

4•Go to the “Autogenerate Variables” related link on form, which generates variable substitution for all template variables on the envelope/ XML data.

5•Once generated, we are given the option to test,
by providing these variables with test values to validate integration success, before implementing business rule to customize the integration.

6• After given it test values, click on the Test related link, upon testing review the HTTP status to ensure it states: 200,
meaning testing was successful and integration worked.

How do we check if the incident record was created/inserted in the target instance?

Go to the target instance, navigate to the target table (Incident), and check if the test record has been inserted.

Our test record got inserted—great job! You successfully performed SOAP integration. 😊

However, our set priority is of a different value because the priority field value is dependent on two other fields (impact and urgency). To properly set the priority field value, you have to set values for the impact and urgency fields.

Other than that, you successfully performed a SOAP integration that inserted a new record into another application!

Check YouTube video here:

[https://youtu.be/mAOIWpEiTF8?si=AYIke1KphsITk1CP]
To watch the implementation on how to create an after-business rule to always insert a new incident record into the target instance whenever an incident record is created in the source instance.

PS: Do not ever use the **“Before”** business rule during integration because you don’t want the record to get stored in the target system before the source system.

Key things to keep in mind when watching the YouTube video:

We are going to be creating an “After” business rule with the “Insert” operation.

For the advanced field, to set up the code, go back to the SOAP message insert function and click on the “Preview Script Usage” related link, copy the code, preview, and paste it into the business rule advanced field.

What is the code doing?

The code is calling the SOAP message we created ‘IncidentDemo’ and the method ‘Insert’ that was used in the SOAP message.
Then it’s setting parameters; the values in our parameters are from our testing, so we will need to replace them with current values.
Once that’s done, save your business rule, and again, by creating a new incident on the source instance, go to your target instance to make sure that it got populated there as well.

PS: It’s very important to keep in mind that only the field values that are being set in the parameter would show up in the target instance.

Thank you for reading and watching! I hope this lesson broke down SOAP integrations properly. To learn more about SOAP, check out these product documentations:
•https://docs.servicenow.com/bundle/tokyo-application-development/page/integrate/inbound-soap/concept/c_SOAPWebService.html

Unveiling GlideUser: Your Guide To Current User Information in ServiceNow

Sophia Semga — Wed, 15 May 2024 17:33:31 +0000

ServiceNow is a powerful platform that empowers businesses to streamline IT service management. When developing applications within ServiceNow, understanding the context of the user who's logged in is often crucial. This is where the GlideUser API comes in!

What is GlideUser?

GlideUser is a client-side API specifically designed to retrieve information about the user currently logged into ServiceNow. It provides a more efficient way to access user data compared to other traditional GlideRecord queries.

Key Functionalities of GlideUser:

Retrieving User Details: With GlideUser, you can easily access various user attributes like first name, last name,username, and user ID. It even offers a convenient getFullName() method to retrieve the user's full name in one go.

1. `getUserID()`

Description: Returns the sys_id of the current user.

2. `getUserName()`

Description: Returns the username (login name) of the current user.

3. `getFullName()`

Description: Returns the full name of the current user.

Checking User Roles: GlideUser empowers you to determine if the current user possesses a specific role or belongs to a particular group. This functionality is essential for access control and personalizing the user experience within your ServiceNow applications. Imagine forms that automatically adjust visibility based on a user's role!

4. `hasRole(role)`

Description: Checks if the current user has the specified role/ admin role.
Parameters: role (String) - The role to check.
Returns: Boolean - true if the user has the role, false otherwise.

5. `haRoleExactly(role)`

-Description: Logged-in user has exactly the specified role, without considering administrative privileges that might grant additional roles. The hasRoleExactly method returns true only if the user has the specific role in question, making it useful for precise role checks.
-Returns: Boolean - true if only the user had the specific/precise role In question, false otherwise.

OTHER METHODS:

6. `isMemberOf(group)`

Description: Checks if the current user is a member of the specified group.
Parameters: group (String) - The group to check.
Returns: Boolean - true if the user is a member of the group, false otherwise.

7. `getCompanyID()`

Description: Returns the sys_id of the company to which the current user belongs.

8. `getCompanyName()`

Description: Returns the name of the company to which the current user belongs.

9. `getLocation()`

Description: Returns the location name of the current user.

10. `getDepartmentID()`

Description: Returns the sys_id of the department to which the current user belongs.

11. `getDepartmentName()`

Description: Returns the name of the department to which the current user belongs.

Use Cases for GlideUser:
.GlideUser shines in client-side scripts, allowing you to:
Pre-populate forms with the current user's details, saving them time and effort.

.Control field visibility based on user roles. This ensures users only see the information relevant to them.

.Personalize greetings or notifications based on the logged-in user. A simple "Hello, [Username]" can make a big difference!

Example Usage

Here are some examples to demonstrate how GlideUser methods can be used in client scripts:

Example 1: Check if the current user has the 'admin' role.

Example 2: Display the current user's full name and username.

Example 3: Check if the current user is a member of a specific group.

Benefits of Using GlideUser:
Efficiency: GlideUser offers a faster and more efficient way to access user information compared to GlideRecord queries.

Simplified User Context: By leveraging GlideUser, you can easily incorporate user context awareness into your client-side scripts.

Considerations and Best Practices:
It's important to remember that client-side validation using GlideUser can be bypassed. To ensure proper security, always implement server-side validation for critical operations. Additionally, GlideUser is primarily for client-side scripts and not recommended for server-side scripts or UI actions running on the server.

Conclusion:
GlideUser is a valuable tool for ServiceNow developers looking to enhance their user experience in their applications by providing personalized interactions based on the user's attributes and roles within the ServiceNow platform.
By incorporating GlideUser into your client-side scripts, you can streamline data entry, personalize the user experience, and ultimately create more user-friendly and efficient workflows.

Learn More about ServiceNow Glide API's:
https://docs.servicenow.com/bundle/washingtondc-application-development/page/script/glide-server-apis/topic/p_GlideServerAPIs.html

Learn More about ServiceNow GlideUser API's:
https://docs.servicenow.com/bundle/washingtondc-api-reference/page/app-store/dev_portal/API_reference/GlideUser/concept/c_GlideUserAPI.html

LOOKUP! The Power Of ServiceNow Data Matching

Sophia Semga — Wed, 01 May 2024 17:14:18 +0000

Have you ever encountered a seemingly simple ServiceNow scripting task that turned into a lengthy debugging session?

I recently faced this challenge while working on a Catalog client script that involved matching choice fields.
What I envisioned as a quick fix became a six-hour debugging marathon! My notification script kept popping up unexpectedly, and only some choices were being matched.

But fear not, fellow developers! ServiceNow documentation, our most trusty companion, came to the rescue!!!

While searching for solutions, I stumbled upon the power of Data lookup rules.
These rules allow administrators to define conditions that automatically set field values, streamlining workflows and saving precious time.
Here's the magic: Data lookup tables enable you to look up values in fields and map them to corresponding values in other fields. Additionally, catalog items have their own dedicated data lookup definition, separate from standard table definitions.

Wanna practice data lookup rules, follow these steps:

.Create a Data Lookup Table: This table will house the fields you want to match and the corresponding fields you want to auto-populate based on the matches. Think of it as a mapping guide. In our example, we'll call the fields containing the matching values "matches" and the fields to be auto-populated "setters."

.Configure Matching Choices: Within your data lookup table, configure the choices to match exactly with the choices available in your target field (in this case, your catalog item field).

.Define the Data Lookup in Your Catalog Item: Navigate to the Catalog Data Lookup Definitions section within your catalog item form (or System Policy > Data Lookup for regular tables).

.Create a New Lookup Definition: Specify the fields you created in your data lookup table within the new lookup definition.

.Set Matchers and Setters: Within the lookup definition form, define the "matchers" (fields containing matching values) and the "setters" (fields to be auto-populated)

.Prioritize Your Lookups: Data lookup rules are processed in a specific order. Access your data lookup table again and set an order for each record. This order dictates the sequence in which the records are processed, ensuring data flows smoothly.

Conclusion:
Data lookup rules offer a powerful and efficient way to automate data population in ServiceNow. By following these steps and leveraging this functionality, you can significantly reduce manual effort, improve data accuracy, and streamline your workflows.

####TheWorldWorksWithServiceNow! 😄

Watch My Youtube Video on Custom Data Look Up Rules:

https://youtu.be/zs2td3hdZVs?si=J45yW6NqWKcpDiux

-Learn More About ServiceNow Custom Data LookUp and Record Matching:

https://docs.servicenow.com/bundle/washingtondc-platform-administration/page/administer/field-administration/concept/c_DataLookRecMatchSupport.html

Don't Get Time-Warphed! Using GlideDate and GlideDateTime In ServiceNow

Sophia Semga — Wed, 17 Apr 2024 18:52:11 +0000

What day is it today?? Can someone Glidey check the time and let us know.😅

We spent the past few weeks exploring ServiceNow JavaScript APIs and today I glidely present to you two essential API tools for managing dates and times:

GlideDate and GlideDateTime.

While both reside within the ServiceNow platform and function as server-side APIs, they cater to different scenarios and offer unique sets of functionalities.

GlideDate shines as an essential component within the platform that serves as a server side API class used for managing and manipulating date values.
It is primarily used when dealing with dates exclusively and represents only the day component without any time information. Think birthdays, anniversaries, deadlines, or any scenario where only the day component matters. GlideDate effortlessly manages these dates, storing them in the familiar "yyyy-MM-dd" format.
It also offers a comprehensive set of methods for working with dates and a fundamental tool for developers building custom functionalities involving calculation of date comparisons, and formatting.
Developers can access and initiate GlideDate object using the GlideDate() function in server side scripts, to create a new GlideDate object representing the current date. This object can be manipulated using various methods provided by the GlideDate API.

Some methods include:

getDate(): Retrieves the date portion of the GlideDate object in the form "yyyy-MM-dd".

-getByFormat(): Retrieves the date portion of the GlideDate object in the specified format "dd-MM-yyyy" or “EEEE” to get day of the week.

getDayOfMonthNoTZ(): Retrieves the day of the month, expressed in the UTC time zone.

#####P.S, GlideDate Objects are stored in UTC (Coordinated Universal Time) by default. This is crucial to remember when displaying dates to users across different time zones.

####If you need to adjust for time zones, consider leveraging the GlideTimeZone class (not covered in this blog, but readily available in ServiceNow documentation).

getDisplayValue(): Retrieves the date value and time zone formatted based on the user's display preferences.
getDisplayValueInternal(): Retrieves the date value in the internal format (yyyy-MM-dd) and time zone regardless of user preferences.
setValue(String value): Sets the value of the GlideDate object. The input must be in the internal format "yyyy-MM-dd" and the system time zone by default.
getNumericValue(): Retrieves the date value as the number of milliseconds since January 1, 1970, 00:00:00 UTC.

-isInPast(), isInFuture(): Checks if the GlideDate is in the past or future, respectively.

Similarly, you can manipulate dates by adding/subtracting days, weeks, etc using method like:

addDays(Number days), addWeeks(Number weeks), addMonths(Number months): Adds the specified number of days, weeks, or months to the GlideDate object.

-subtract(): Subtracts one GlideDate object from another, returning the difference in days.

GlideDate object can also be used to compare dates using operators like > (greater than), < (less than), and == (equal to), making decision making in workflows a breeze .

Next,

We have our timekeeper API also known as GlideDateTime.
GlideDateTime is another service side API that represents date and time combined. Think timestamps, time zone conversions, managing time-bound SLAs (Service Level Agreements), tracking login events with precise timestamps, or scheduling tasks with specific deadlines. GlideDateTime effortlessly handles all of these scenarios, representing dates and times in the format "yyyy-MM-dd HH:mm:ss [year, month, day, hour, minute, second]”.

To invoke the GlideDateTime method, similarly to GlideDate use new GlideDateTime() or provide a specific date and time string for more control.
GlideDateTime inherits all functionalities of GlideDate for date manipulation, comparison, and formatting, but some of it’s additional methods for time handling include:

getDayOfMonth(): Returns the current day of the month for the GlideDateTime object in UTC time zone.

getDayOfWeek(): Returns the day of the week for the GlideDateTime object expressed in the users time zone.

getYear(): Returns the year for the GlideDateTime object.

getDisplayValue(): Returns the date and time in the display format according to the user's preferences.

getDisplayValueInternal(): Returns the date and time in internal format, yyyy-MM-dd HH:mm:ss. This method is useful for date/time fields, but not for date fields.

####It also includes additional methods for time handling, such as adding/subtracting hours, minutes, seconds, extracting extra time components like `getHours(), getMinutes(), and getSeconds()`

####and time conversions`(with GlideTimeZone)`

getUserTimeZone(): Retrieves the time zone for the current user session.

subtract(): Subtracts specified amount time.

Choosing the Right Tool for the Job

Date Only? GlideDate is your champion for scenarios where time is irrelevant (e.g., birthdays, anniversaries).
Dates and Times? GlideDateTime reigns supreme when you need to manage both dates and times (e.g., deadlines, scheduled events). GlideDateTime's versatility makes it a future-proof choice, as you can always incorporate time elements if needed.

Remember: GlideDateTime builds upon GlideDate, offering all its functionalities in addition to time management. This makes it the more versatile option for most development scenarios.

Stay tuned for more insights on JavaScript APIs within the ServiceNow platform. We’ve merely scratched the surface, and there’s so much more knowledge waiting for us to explore.

Until our next “glide” (or should I say “dive”) into the depths of JavaScript APIs,

####Happy coding! 😄

.Learn More About ServiceNow GlideDate: https://docs.servicenow.com/bundle/washingtondc-api-reference/page/app-store/dev_portal/API_reference/GlideDate/concept/GlideDateAPI.html

.Learn More About ServiceNow GlideDateTime:
https://docs.servicenow.com/bundle/washingtondc-api-reference/page/app-store/dev_portal/API_reference/GlideDateTime/concept/c_GlideDateTimeAPI.html

Glide Like a Pro: Building Dynamic Forms with Glide Form

Sophia Semga — Wed, 03 Apr 2024 18:09:04 +0000

In our previous article, we delved into the realm of JavaScript, particularly focusing on APIs in ServiceNow, with a spotlight on Glide Record and Glide Ajax. Let’s quickly recap our journey, shall we? 😊

Glide Ajax, a client-side API, facilitates asynchronous calls to server-side scripts (such as script includes and business rules) from client-side scripts (UI policies, Catalog UI policies). It acts as a bridge enabling seamless integration of server-side functionalities like database queries without causing page refreshes.

On the flip side, Glide Record, a server-side API, is crucial for efficient database operations. It handles operations such as queries, updates, and deletions of records through server-side scripts (like script includes and business rules).

In our exploration, we delved deeper into the specific APIs associated with each function, their methods, and the tasks these methods perform. However, one lingering mystery still remains: the origin of the term “Glide”—perhaps hinting at the smooth user interface development experience?

Today, our focus shifts to another powerful and informative JavaScript class: Glide form.

Glide form, a client-side script API, plays a vital role in developing and customizing user interfaces. It allows developers to manipulate form elements, set and retrieve field values, and interact seamlessly with the user interface.
Accessed through the g_form global object in client-side scripts like UI policies and client scripts, Glide form’s methods are tailored for making precise and custom changes to form views of records.

Here's a glimpse into some key methods:

Form Element Manipulation:

g_form.setValue(fieldName, value): Sets the value of a field on the form.
g_form.getValue(fieldName): Retrieves the value of a field on the form.
g_form.setDisplay(fieldName, display): Sets the display value of a field on the form.

UI Interaction:

g_form.hideRelatedList(list-TableName): Hides a related list on the form. -g_form.showRelatedList(list-TableName): Shows a hidden related list on the form. -g_form.addInfoMessage(message): Adds an informational message to the form.

Set Field Properties:

-g_form.setMandatory(fieldName, isMandatory): Sets a field as mandatory or optional.

-g_form.setReadOnly(fieldName, isReadOnly): Sets a field as read-only or editable.

-g_form.setVisible(fieldName, isVisible): Sets a field as visible or hidden.

Ensuring Data Integrity/Form Validation:

-g_form.validate(): Validates all visible fields on the form and returns true if they are all valid; otherwise, returns false. (ideal for ensuring complete forms before submission).

But that’s just the tip of the iceberg!!
Glide form API encompasses many additional methods, such as returning HTML elements on forms to facilitate specific functions like applying custom CSS styles based on conditions or validating form fields using logic. These methods allow you to:
-getElement(): Returns HTML element of any elements on the current page/form.

-g_form.getElement(): Returns HTML elements of a specific field name on the form, useful for accessing HTML elements representing a form field.

-g_form.getHelpTextControl(): Retrieves the help text control associated with a form field, which is used to display additional information/instructions associated with a field.

These are just a few of the many different methods Glide form API has to create dynamic and user-friendly forms.
However, while these methods are incredibly powerful, they must be utilized in line with best practices to ensure maintainability and compatibility within the platform. More of these methods can be found here at:[https://docs.servicenow.com/bundle/washingtondc-api-reference/page/app-store/dev_portal/API_reference/GlideForm/concept/c_GlideFormAPI.html]

Real-World Applications
Glide forms empower you to streamline user interactions within ServiceNow applications. Here are some examples:

Customizing incident forms: Hide irrelevant fields based on the incident category.
Enhancing user input processes: Make specific fields mandatory based on selections in other fields.
Building dynamic forms: Create forms that adapt to user input and context.

Glide forms offer immense power for crafting user-friendly and dynamic forms in ServiceNow. By mastering these methods and best practices, you can elevate your development skills and create amazing experiences for users.
Stay tuned for more insights on JavaScript APIs within the ServiceNow platform. We’ve merely scratched the surface, and there’s so much more knowledge waiting for us to explore.

Until our next “glide” (or should I say “dive”) into the depths of JavaScript APIs,

####Happy coding! 😄

.Learn more about ServiceNow GlideForms Here:
https://docs.servicenow.com/bundle/washingtondc-api-reference/page/app-store/dev_portal/API_reference/GlideForm/concept/c_GlideFormAPI.html

.Learn More About ServiceNow APIs:
https://docs.servicenow.com/bundle/washingtondc-api-reference/page/build/applications/concept/api-reference.html

.Learn More about ServiceNow ClientSide Scripting:
https://docs.servicenow.com/bundle/washingtondc-application-development/page/script/client-scripts/concept/client-scripts.html

The Glides: Understanding ServiceNow Glide APIs-The Difference between GlideAjax vs GlideRecord

Sophia Semga — Wed, 20 Mar 2024 16:52:38 +0000

In the realm of ServiceNow scripting, terms like Glide Ajax, Glide Record, and Glide Form often appear, but what do they actually mean?? How do they relate to scripting syntax, and why do they sound so similar?

In this blog, we will glide through the explanation of these API functions, addressing these questions except for the curious resemblance in names.😅

To begin, it's crucial to understand that Glide Record and Glide Ajax are distinct APIs with separate functionalities, catering to different scripting aspects within ServiceNow.
Now that we’ve got that introduction out of the way, let’s dive in.⬇️

To understand and differentiate between the two sets of APIs, we need to backtrack to the beginning of ServiceNow. In the early stages of ServiceNow development, the term "Glide" originated from the foundational technology framework of the ServiceNow platform. This framework incorporates various APIs, libraries, and technologies that aid developers in building and customizing applications. Given that ServiceNow heavily relies on JavaScript for client-side and server-side scripting, the Glide APIs are JavaScript-based, making it familiar and accessible for developers.

Glide Record, Glide Ajax, and other Glide APIs were purpose-built by ServiceNow to streamline interactions within the platform, enhancing efficiency and customization capabilities for developers.

Understanding Glide Ajax

Glide Ajax operates as a client-side API, enabling asynchronous calls to server-side scripts (such as script includes and business rules) from client-side scripts (like UI policies and Catalog UI policies). This asynchronous communication ensures that server-side actions, such as querying databases, occur without disturbing website performance, ultimately enhancing the user experience.

Unlike Glide Record, Glide Ajax does not have its own set of APIs but rather serves as a channel between client-side JavaScript and server-side scripts, allowing seamless integration of server-side functionality without page refreshes. The core method in Glide Ajax, getXMLWait(), facilitates sending requests to server-side script includes or scripted REST APIs, and awaiting responses for further client-side processing.
Here's a basic example illustrating Glide Ajax usage:

Define a script include or scripted REST API with the desired logic for asynchronous invocation.
Create a client-side script (e.g., UI policy or UI action) utilizing Glide Ajax to call the server-side script and handle the response.

While Glide Ajax offers a limited range of methods, its specialized role in facilitating asynchronous client-server communication within the ServiceNow platform is invaluable.

Exploring Glide Record

On the server side, Glide Record shines as an essential API for database operations, eliminating the need for direct SQL queries. It empowers developers to conduct queries, updates, and deletions of records efficiently within ServiceNow scripts, such as script includes and business rules.

Glide Record provides a strong set of APIs, including:

query(): Executes query records based on specified conditions.
addQuery(): Adds additional conditions to the query.
get(): Retrieves a single record based on current query conditions.
next(): Moves the GlideRecord cursor to the next record in the result set.
insert(): Adds a new record to the database.
update(): Modifies the current record.
deleteRecord(): Removes the current record.

These APIs, combined with specific conditions and parameters, empower developers to manipulate records and ServiceNow tables effectively, enhancing workflow automation and data management.

In conclusion, while Glide Record and Glide Ajax fulfill distinct roles within the ServiceNow ecosystem, they are essential components contributing to platform functionality. Glide Record streamlines server-side database interactions, while Glide Ajax facilitates efficient client-server communication, collectively enhancing user experiences and productivity within ServiceNow environments.

•Learn More About ServiceNow Scripting Here:

https://developer.servicenow.com/dev.do#!/learn/learning-plans/tokyo/new_to_servicenow/app_store_learnv2_scripting_tokyo_introduction_to_servicenow_scripting

https://developer.servicenow.com/dev.do#!/learn/courses/tokyo/app_store_learnv2_scripting_tokyo_scripting_in_servicenow

•Learn More About ServiceNow GlideAjax Here:

https://docs.servicenow.com/bundle/washingtondc-api-reference/page/app-store/dev_portal/API_reference/GlideAjax/concept/c_GlideAjaxAPI.html

https://docs.servicenow.com/bundle/washingtondc-application-development/page/script/ajax/topic/p_AJAX.html

•Learn More About ServiceNow GlideRecord Here:

https://docs.servicenow.com/bundle/washingtondc-api-reference/page/app-store/dev_portal/API_reference/GlideRecord/concept/c_GlideRecordAPI.html