Mastering ServiceNow - Second Edition

By Martin Wood

This book is aimed at advanced ServiceNow System Administrators and developers who would like to gain greater control of ServiceNow and its architecture. The book expects you to be new to ServiceNow, but have a good grounding in internet and computing technologies, like HTML, JSON, REST and database systems. Readers should be especially familiar with JavaScript, and be keen to extend and alter the platform. With this book, they will be able to develop a new application for their company.

• Language: English
• Publisher: Packt Publishing
• Release date: Oct 27, 2016
• ISBN: 9781786467423

Book preview

Table of Contents

Mastering ServiceNow Second Edition

Credits

Notice

About the Author

About the Reviewer

www.PacktPub.com

Why subscribe?

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

1. ServiceNow Foundations

Diving into the infrastructure

Keeping up with the examples

Being in charge

Changing your instance

Knowing the platform

Choosing functionalities with plugins

Running the latest version

Digging into the hosting

Knowing the nodes

Exploring the database

Introducing the Gardiner Hotel data structure

Creating tables

Adding fields

Knowing what's happening

Introducing the dictionary

The globally unique identifier

Storing data

Storing files as attachments

Setting properties

Reference fields

Creating a reference field

Building out the data structure

Linking the data together

Looking from different perspectives

Using reference qualifiers

Dot-walking through data

Using derived fields

Building the interface

Lists

Choosing the fields to show

Having reference fields on lists

The varied capabilities of lists

Forms

Creating useful forms

Adding related and embedded lists

Defining your own related lists

Enjoying views

Controlling views

Menus and modules

Setting a filter

Building the right modules

Making the most of the UI

Finding your way around the interface

Adding a favorite

Seeing back in time

Defining a tag

Connecting with people

Chatting over records

Live record updates

Summary

2. Developing Custom Applications

Developing applications in Studio

Recording files

Scoping out limits

Separating by name

Seeing the scope

Moving between applications

Enforcing the separation

Taking control of your application

Delegating to developers

Allowing other applications access

Controlling application access

Restricting your choices during development

Building hierarchical tables

Benefiting from an object-oriented design

Extending the User table

Interacting with hierarchical tables

Viewing hierarchical tables

Overriding field properties

Understanding the background behavior

Making it visual with the Schema Map

Changing class

Repointing the reference field

Many-to-many relationships

Building a many-to-many table

Adding fields to a many-to-many table

Comparing reference fields and many-to-many tables

Deleting a many-to-many table

Choosing lists

Cascading with reference fields

Dynamic creation

Deleting records

Summary

3. Server-Side Control

Deciding to write code

Using the developer community

Running background scripts

Using GlideRecord (and its friends)

Understanding iterators

Accessing data from GlideRecord

Walking through reference fields

Converting data types

The surprising results of GlideElement

Getting the value another way

Dealing with dates

Counting records with GlideAggregate

Scripting in scoped apps

Being in scope

Improving scripting with ECMAScript 5

Activating ECMAScript 5

Protecting data from scripts

Running scripts in global

Building the restrictions

Business rules

Setting the table

Being advanced

Knowing the predefined variables

Displaying the right table

Conditioning your scripts

Having good conditions

Controlling the database

Controlling database queries with Business Rules

Choosing when to execute - before, after, and really after

Defaulting data

Validating information

Working with dates

Updating information

Running things later with system scheduling

Display business rules

Global business rules

Script Includes

Creating classes

Coding a class

Accessing across scope

Using classes to store and validate data

Having an API for scoped apps

Extending classes

Taking advantage of utility classes

Providing utility classes

Storing functions

Having functions in Script Includes

Client Callable Script Includes

Enforcing data

Forcing a comment using a data policy

Specifying dynamic filters

Displaying guests that are Me

Scripting reference qualifiers

Showing only guests with reservations

Filtering using the current record

Rhino - the JavaScript engine powering ServiceNow

Accessing Java

Summary

4. Client-Side Interaction

Building a modern interface

The power and pitfalls of Ajax

Being in control

Using client-side code effectively

Choosing a UI Action

Finding the current table

Displaying UI Actions in the right place, at the right time

Using the Condition field

Running client- or server-side code

Saving and redirecting

Converting a record from Reservation to Check-in

Managing fields with UI Policy

Manipulating the form

Client-side conditioning

Forcing a comment on reservations

Controlling UI Policies

Running client-side scripts

Scope on the client

Remembering client-side GlideRecord

Understanding callbacks

The defined function

The anonymous function

Manipulating forms with GlideForm

Using GlideForm

Choosing a UI Policy

Client-side scripting

Sending alerts for VIP guests

The disappearance of current

Changing, submitting, loading, and more

Validating the contents of fields

Storing code in UI Scripts

Efficiently transferring data to the client

Writing a script include for GlideAjax

Using GlideAjax

Passing data when the form loads

Using scratchpad on the client

Storing data in the session

Controlling lists with Context Menus

Finding out about the list

Opening a new tab

Customizing and extending the platform

Firing on more events

Using built-in libraries

What could go wrong

Taking control of the browser

Data Policies save the day

Summary

5. Getting Things Done with Tasks

Introducing tasks

Looking at the Task table

The important fields

Populating fields automatically

Recording room maintenance tasks

Working with tasks

Working without a queue

Working socially

Chatting with Connect

Communicating some more

Organizing groups and users

Creating a room-maintenance team

Creating a property

Using departments and companies

Using additional comments and work notes

Understanding the State field

Configuring different states

Representing progress

Navigating between states

Creating room maintenance states

Enforcing on the server

Adding a reference qualifier

Removing states with client scripts

Automating an assignment based on state

Using Data Lookup

Setting the Assignment group with Assignment Rules

Drag-and-drop automation with Graphical Workflows

Running a workflow

Exploring under the hood

Exploring the activities

Orchestrating your datacentre

Using data-driven workflows

Approving tasks

Making the decision

Understanding what you are approving

Asking for approval for the repair team

Performing the approval

Starting up the workflow

Monitoring progress

Using the Service Catalog

The different types of Catalog Items

Using Service Creator

Creating a record producer

Adding more information

Routing the submitted request with templates

Testing the record producer

Understanding the data behind Service Catalog

Configuring the Service Catalog

Understanding Request Fulfilment

Checking out

Using the request tables

Scripting variables

Service Level Management

Exploring the SLA data structure

Timing an SLA

Travelling through time

Enjoying relativity

Scheduling and time zones

Customizing condition rules

Avoiding a breach

Working SLAs

Ensuring maintenance is quick

Summary

6. Events, Notifications, and Reporting

Dealing with events

Registering events

Firing an event

Sending an e-mail for new reservations

Scheduling jobs

Adding your own jobs

Creating events every day

Running scripts on events

Creating tasks automatically

Sending e-mail notifications

Setting e-mail properties

Assigning work

Sending an e-mail notification on assignment

When to send

Who will receive

Send to event creator

Sending informational updates

Sending a custom e-mail

Enabling the e-mail client

Sending e-mails with additional comments and work notes

Sending out work notes

Approving via e-mail

Using the Approval table

Testing the default approval e-mail

Specifying notification preferences

Subscribing to e-mail notifications

Creating a new device

Sending text messages

Delivering an e-mail

Knowing who the e-mail is from

Receiving e-mails

Determining what an inbound e-mail is

Creating inbound email actions

Approving e-mails using Inbound Email Actions

Understanding the code in Update Approval Request

Updating the work notes of a Maintenance task

Having multiple incoming e-mail addresses

Using the Email Accounts plugin

Redirecting e-mails

Processing multiple e-mail addresses

Seeing progress being made

Recording metrics

The difference between metrics and SLAs

Running metrics

Scripting a metric definition

Monitoring the duration of maintenance tasks

Flattening data with Database Views

Creating a Metric Instance Database View

Reporting

The functionality of a list

Using reports elsewhere

Sending a shift handover report

Analytics with ServiceNow

Basic trending with line charts

Performance Analytics

Making sense of reports

Ensuring consistency

Using outside tools

Building homepages

Creating a Maintenance homepage

Making global homepages

Editing homepages

Counting on a homepage

Optimizing homepages

Summary

7. Exchanging Data – Import Sets, Web Services, and other Integrations

Beginning the web service journey

Pulling data out of ServiceNow

Downloading file-based data

Automatically download data using cURL

Being more specific with URL parameters

Choosing the fields

Specifying  records

Getting my stuff

Pulling data designed for the Web

Cleaning up with SOAP

Using direct web services

Filtering the response

Returning display values

Having a REST

Using the REST Explorer

GETting it your way

Using the right method

Selecting the right content

Updating and inserting data

Exploring other APIs

Bringing it in using Import Sets

Specifying the data source

Cleaning up Import Set tables

Getting data

Dealing with XML files

Transforming the data

Creating a field map

Enabling scripting in transform maps

Creating new values

Dealing with times

Importing into reference fields

Moving in the rooms

Scripting in Transform Maps

Knowing when scripting will run

Keeping import sets running

Importing users and groups with LDAP

Importing users from an LDAP server

Reviewing the configuration

Altering the Transform Maps

Importing in a scoped application

Building web service Import Sets

Using a web service Import Sets

Connecting to web services

Using SOAP to send tasks

Testing the web service

Sending the message

Building REST messages

Sending REST messages to CHS

Building custom interfaces

Creating scripted services

Doing multiplication with a scripted REST API

Working inside the data center - introducing the MID server

Integrating with the ECC queue

Picking up jobs

Installing the MID server

Setting up the server

Using the MID server

Running a custom command

Running JavaScript on the MID server

Interacting with the ECC queue

Creating a MID server Script Include

Using Java on the MID server

Adding additional libraries

Exporting data via the MID server

Improving exporting

Authenticating and securing web services

Inbound authentication

Outbound authentication

Designing integrations

Transferring bulk data

Real-time communication

Communicating through the firewall

Summary

8. Securing Applications and Data

Understanding roles

Defining a role

Assigning roles to users

Finding a user's role

Differentiating between requesters and fulfillers

Roles and Delegated Development

Activating Subscription Management

Using impersonation

High-security settings

Elevating your role

Controlling access to applications and modules

Controlling access to modules with groups

Protecting data with contextual security rules

Understanding contextual security

Specifying rows and fields to secure

Securing rows

Controlling fields

The order of execution

Executing the row and then the field

Rules are searched until one is found

Defaults are possible

The table hierarchy is understood

Multiple rules with the same name are both considered

Field rules check the table hierarchy twice

Summarizing the execution

Scripting and access controls

Securing other operations

Building security rules

Conditioning contextual security

Editing the automatic security rules

Testing using impersonation

Setting security rules quickly

Scripting a security rule

Using security rules effectively

Using Scoped Administration

Controlling the Hotel application

Encrypting data

Disadvantages of field encryption

Evaluating encryption gateways

Evaluating encryption gateways

Introducing Domain Separation

Defining a domain

Applying Domain Separation

Organizing domains

Introducing global

Understanding domain inheritance

Turning on Domain Separation

Looking at Domain Separation

Exploring domain visibility

Understanding Delegated Administration

Overriding configuration

Displaying different messages for different domains

Creating more domain relationships

Using Domain Separation appropriately

Authenticating users

Using internal authentication

Controlling authentication

Using an LDAP server for authentication

Enabling Single Sign-on through SAML

Automatically creating users

Logging out

Using Multiple Provider Single Sign-on

Configuring Single Sign-On

Consuming metadata from SSOCircle

Navigating to the side door

Preventing access to the instance

Securing web services

Using WS-Security

Improving security with signatures

Mutual authentication

Setting up outbound mutual authentication

Using OAuth

Summary

9. Diagnosing ServiceNow – Knowing What Is Going On

Building a methodology

Identifying the issue

Looking at the system log

Writing to the system log

Using the file log

Logging appropriately

Using the debugging tools

Debugging Business Rules

Debugging contextual security rules

Enabling the JavaScript client side log

Seeing client-side messages

Logging to the JavaScript log

Tracking each page request

Recording the time taken

Monitoring the instance's performance

Recording the browser's perspective

Breaking down the browser's time

Visualising the data

Going through other logs

Finding slow database transactions

Classifying slow queries

Examining the Slow Query log

Understanding behaviour

Seeing the plan

Dealing with other performance issues

Managing large tables

Archiving data

Rotating and extending through sharding

Choosing table extension

Selecting table rotation

Auditing and versioning

Turning on auditing

Viewing audit

Using auditing responsibly

Versioning configuration

Reviewing the changes

Optimizing hardware resources

Controlling resources with semaphores

Accessing the system internals

Understanding the ServiceNow Performance homepage

Flushing the system cache

Reviewing the system stats

Summary

10. Packaging with Applications, Update Sets, and Upgrades

Using your instances

Serializing records to XML

Exporting and importing serialized XML

Transporting data via XML

Recording configuration in Update Sets

Capturing configuration

Transferring an Update Set

Applying an Update Set

Understanding multiple Update Sets

Relying upon other updates

Managing Update Sets

Using the wrong Update Set

Working with workflows

Having the wrong IDs

Backing out Update Sets

Using Update Sets effectively

Cloning instances

Preserving and excluding data

Using clones effectively

Packaging with applications

Application use cases

The philosophy of scoped applications

Identifying configuration

Moving applications

Publishing applications

Exporting applications

Using a Git repository

Using source control effectively

Including data in applications

Sharing with Share

Selling on ServiceNow Store

Adding more with plugins

Activating plugins

Choosing the right plugin

Configuration and customization

Knowing areas of risk

Protecting your scripts

Upgrading ServiceNow

Understanding upgrades

Applying upgrades

Reverting customizations and restoring out of the box

Managing instances

Summary

11. Making ServiceNow Beautiful with Service Portal and Custom Interfaces

Making it self – service

Providing self-service access

Layering on a better look and feel

Starting with Service Portal

Getting the assets

Branding the existing portal

Reviewing Service Portal fundamentals

Service Portal and the Service Catalog

Selecting the widgets

Creating the reservation

Creating the portal

Building a home

Creating a theme

Creating some style

Adding a menu

Adding a client-side widget

Exploring dynamic widgets

Building the dynamic widget

Locking down the data

Filtering maintenance tasks

Finding the reservations

Altering access controls

Testing the site

Digging into Jelly

Creating a UI Page

Adding interactivity to UI pages

Including UI macros

Looping with Jelly

Extending Jelly

Using Angular and Jelly

Using Angular to say hello

Interacting with the database

Updating records

Including Jelly in the standard interface

Adding formatters

Decorating and contributing to fields

Launching a dialog box

Launching UI pages with GlideDialogWindow

Fitting in a form

Displaying any page with GlideBox

Summary

Mastering ServiceNow Second Edition

---

Mastering ServiceNow Second Edition

Copyright © 2016 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

First published: May 2015

Second edition: October 2016

Production reference: 1141016

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham 

B3 2PB, UK.

ISBN 978-1-78646-595-5

www.packtpub.com

Credits

Notice

Martin wrote this book in his personal capacity. The views expressed are his own, and do not necessarily reflect that of ServiceNow.

About the Author

Martin Wood has spent almost 10 years spreading the word about ServiceNow. He has been lucky enough to see the company and platform grow from the very start, beginning as one of the earliest customers in 2008, when he built one of the first custom applications.  He enjoyed the experience so much that he joined the company in 2009. There onwards, he worked with a variety of clients, from blue-chip enterprises to SMEs, helping them harness the power that the platform brings. More recently, he has taken that experience and used it to shape the latest services and products that ServiceNow creates. Martin has always been passionate about helping people make informed decisions, whether that is at the ServiceNow user conference, or over a pint in a pub.

Martin lives in the beautiful Berkshire countryside in the UK with his wife Sarah. They both love exploring the world and enjoying good food—and great wine!

His personal website is at www.dasos.com. He can be contacted at [e-mail].

I must thank my wife, who has put up with my endless late-night writing sessions. Her patience, love, and understanding has, quite frankly, made this book possible.

About the Reviewer

Andy Venables joined ServiceNow in early 2013, and he works with a wide range of ServiceNow customers, helping them implement effectively and efficiently. Andy sees himself as a full stack technical architect and enjoys working with all aspects of technology, from design through development to testing. He has over 10 years of experience working with JavaScript on both client and server.

Since joining ServiceNow, Andy says that working with the platform has been highly motivating, sometimes challenging, but always exciting, and he thoroughly enjoys seeing new capabilities introduced to the platform and what customers do with them.

He lives in Surrey with his wife, Celia, and their Maltese puppy, Freddie. He enjoys running, rugby, scuba diving, and undertaking (smallish) DIY projects.

Andy is working on authoring a video series with Packt, also titled Mastering ServiceNow.

You can find him on LinkedIn at https://www.linkedin.com/in/andyvenables.

Thank you to Martin for mentoring me through my early ServiceNow days.

www.PacktPub.com

For support files and downloads related to your book, please visit www.PacktPub.com.

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [e-mail] for more details.

At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.

https://www.packtpub.com/mapt

Get the most in-demand software skills with Mapt. Mapt gives you full access to all Packt books and video courses, as well as industry-leading tools to help you plan your personal development and advance your career.

Why subscribe?

Fully searchable across every book published by Packt

Copy and paste, print, and bookmark content

On demand and accessible via a web browser

Preface

Congratulations! You have just become the ServiceNow system administrator for Gardiner Hotels, one of the most successful chains in the region. The CIO realized that ServiceNow fits his needs exactly: it gives him a suite of feature-rich applications built to manage an array of service-management domains, including IT, HR, and facilities.

But what really caught his eye was what the platform brings. All the applications rely on a core set of capabilities, providing powerful logic, data manipulation, integration, and security features. Understanding all these elements not only helps you build your own applications quickly and easily, but it also allows you to understand how every other application works.

This book guides you through creating a custom application in the Helsinki version of ServiceNow. By building an application from the ground up, you will master the core foundational concepts that you can then apply to any other application. Each chapter builds on the last, with plenty of examples providing you hands-on experience in building out each feature.

Because the majority of the examples are built inside a scoped application, you can easily follow along by connecting your instance to a GitHub account. By switching branches, you can jump between chapters without needing to complete all the prerequisites. To do so, fork the repo at https://github.com/gardinerhotels/hotel. Further instructions are given at https://www.gardiner-hotels.com/ and in the first chapter.

What this book covers

Chapter 1, ServiceNow Foundations, looks at how ServiceNow is structured from an architectural perspective. We explore how the platform is hosted and then dive into the building blocks of tables, fields, and building interfaces.

Chapter 2, Developing Custom Applications, explains the controls and capabilities around applications in ServiceNow. Application scopes bring significant changes to the API and bring much better protection to manage the flow of data.

Chapter 3, Server-Side Control, shows you how you can implement your business logic and then start to automate, validate, and verify data and processes.

Chapter 4, Client-Side Interaction, explores how you can make the life of the people using your application a little bit better by providing validation, feedback, and quick interaction techniques.

Chapter 5, Getting Things Done with Tasks, looks at some of the base application functionalities in ServiceNow. Understand how a task-driven process system is kick-started by the Task table and take advantage of Graphical Workflow and the Service Catalog.

Chapter 6, Events, Notifications, and Reporting, introduces another level of interaction with your users, by generating reports and scheduling jobs and handling incoming and outgoing e-mail. Keep everyone informed about what's happening.

Chapter 7, Exchanging Data – Import Sets, Web Services, and other Integrations, is about importing and exporting data from other systems, integrating ServiceNow in your application landscape. No instance is an island!

Chapter 8, Securing Applications and Data, focuses on the challenges of protecting your most important asset: your information. We make sure the right people have the right data.

Chapter 9, Diagnosing ServiceNow – Knowing What Is Going On, helps you when things go wrong. Troubleshooting and investigation hints and tips are explored so that you can get back to full power quickly.

Chapter 10, Packaging with Applications, Update Sets, and Upgrades, builds on the previous chapters to explore how you can get your hard work to the right place. Understand how upgrades work and how teams can work together to get stuff done.

Chapter 11, Making ServiceNow Beautiful with Service Portal and Custom Interfaces, focuses on the service portal and advanced UI techniques. Having a good-looking, well-designed self-service system really enhances adoption. One of the fundamental components of ServiceNow, Jelly, is used to supercharge the interface.

What you need for this book

ServiceNow is an enterprise SaaS platform. In order to work with the application, you will need access to a ServiceNow instance, with system administrator access. The examples in this book are about a custom application, but it is strongly recommended that any work be performed in a sub-production instance.

The best way to work through the book is with a developer instance. By signing up to the free program, you can get a fully capable instance that lets you work through all the examples. You can sign up at https://developer.servicenow.com/. Alternatively, contact your ServiceNow representative and request a temporary sandbox instance.

To make use of the source control integration and quickly download the code for each chapter, you will need a free GitHub account. Sign up at https://www.github.com.

The examples have all been built with the Helsinki version of ServiceNow, released in mid-2016. The concepts of ServiceNow are relevant for every version, but it is strongly recommended that you follow along with a Helsinki instance.

Who this book is for

This book will be most useful to those who have a good grounding in web technologies and computer science but don’t know too much about ServiceNow. We discuss how ServiceNow implements common design patterns and technologies, enabling you to get a better understanding of how your instance works.

There is a great deal of functionality in ServiceNow, and it simply isn't possible to cram everything into a single book. ServiceNow has a comprehensive wiki and a popular community forum. The ServiceNow training department has a series of mixed-media courses to get you up to speed quickly. We aren't going to replicate those, especially the application-specific ones, but there will be some overlap.

There are several sources of documentation, which are frequently referred to throughout the book. The most common sources are the following:

The product documentation covers the key features and capabilities of the ServiceNow platform and the available applications. It works on a how-to basis, giving you focused help to accomplish specific tasks. Access it at https://docs.servicenow.com/.

The developer portal focuses on the needs of those using the platform building blocks. It importantly hosts the server and client APIs. Access it at https://developer.servicenow.com/.

Every ServiceNow system administrator needs to have at least a basic understanding of JavaScript. JavaScript underpins the ServiceNow foundations and hence is essential to fully master ServiceNow. An in-depth knowledge of all the intricacies of JavaScript is not needed, since many of the idioms and objects used are ServiceNow specific. Nonetheless, scripting is part of the product. A review of a good JavaScript manual may be helpful!

The book also assumes a working knowledge of basic web technologies, such as HTML and CSS, and standard concepts, such as databases and SQL.

Conventions

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: Let's run the standard Hello, World! program as our first script

A block of code is set as follows:

gs.info('Hello, world!');

Any command-line input or output is written as follows:

curl --user https://.service-now.com/u_maintenance_list.do?EXCEL --output MaintenanceList.xls

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: To explore the roles provided in the ServiceNow platform, navigate to System Security > Users and Groups > Roles.

Note

Warnings or important notes appear in a box like this.

Tip

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book-what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of. To send us general feedback, simply e-mail [e-mail], and mention the book's title in the subject of your message. If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this book from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

You can download the code files by following these steps:

Log in or register to our website using your e-mail address and password.

Hover the mouse pointer on the SUPPORT tab at the top.

Click on Code Downloads & Errata.

Enter the name of the book in the Search box.

Select the book for which you're looking to download the code files.

Choose from the drop-down menu where you purchased this book from.

Click on Code Download.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

WinRAR / 7-Zip for Windows

Zipeg / iZip / UnRarX for Mac

7-Zip / PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Mastering-ServiceNow-Second-Edition. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Downloading the color images of this book

We also provide you with a PDF file that has color images of the screenshots/diagrams used in this book. The color images will help you better understand the changes in the output. You can download this file from http://www.packtpub.com/sites/default/files/downloads/MasteringServiceNowSecondEdition_ColorImages.pdf.

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books-maybe a mistake in the text or the code-we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.

To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the book in the search field. The required information will appear under the Errata section.

Piracy

Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at [e-mail] with a link to the suspected pirated material.

We appreciate your help in protecting our authors and our ability to bring you valuable content.

Questions

If you have a problem with any aspect of this book, you can contact us at [e-mail], and we will do our best to address the problem.

Chapter 1. ServiceNow Foundations

This opening chapter lays out the foundational aspects of ServiceNow, from the bottom up. Understanding the fundamentals of the ServiceNow platform is important. It provides insight into the concepts that determine how all the applications built on top work.

Tip

Although long, the chapter is not exhaustive and expects basic familiarity with the ServiceNow interface. Remember to refer to the ServiceNow documentation and any training material you may have.

Perhaps you've decided to build a new hotel, and you want to ensure it won't fall down. The architect's drawings need to be understood and the right building materials ordered. It's costly (and career limiting!) if it collapses in the opening week!

In this chapter, we review the blueprints. We will understand the important design aspects of ServiceNow so that we can build on them later. The data structure available to us is critical, since it enables us to model information and processes in the right way.

In this chapter, we will cover:

The physical components of the ServiceNow architecture

How everything you see and do is in the database

A review of the most important field types

The magic of reference fields

Using and building a good interface

Diving into the infrastructure

An instance is several things. It could be part of a URL (something like https://.service-now.com/), software running in the cloud, or your copy of the ServiceNow platform.

ServiceNow provides a platform and suite of applications as a service. They worry about the hardware, Internet connectivity, and operating system security, and provide you with the URL. All you need to get going is a modern web browser.

To follow the examples in this book, you need admin access to an instance. It'll be better if you have your own, dedicated instance rather than one being used by many people. It allows you to make system-wide configuration changes, and you won't affect anyone else.

Note

It is especially important not to use the production instance assigned to your company. This book uses the examples to teach you about ServiceNow, and you will not want all of these experiments being used by your whole company.

ServiceNow runs a developer program, through which you can obtain your own instance. It is lower powered and restricted in capabilities compared to normal instances, but it is an excellent resource to test out ideas. Be sure to read the FAQ to understand the limitations.

You can access the developer program at https://developer.servicenow.com.

Keeping up with the examples

All the examples in the book have been recorded as Update Sets, which we discuss in detail in Chapter 10, Packaging with Applications, Update Sets, and Upgrades. The hotels application is also in a public Git repository. You can apply them to short-cut the examples. Even if you you wish to work through all the examples, I recommend applying the first one, so your scope identifier is the same as the book. It'll make copying and pasting code much easier!

You can download the Update Sets at http://www.gardiner-hotels.com. Alternatively, you can fork the Git repository available at https://github.com/gardinerhotels/hotel. More instructions are at the website.

Being in charge

An instance is an independent implementation of ServiceNow. It is isolated and autonomous, meaning your code and data is not shared with other customers. ServiceNow uses a single-tenancy architecture, which means your instance is yours: you can do what you want with it, such as changing logic, updating the UI, and adding fields.

Tip

ServiceNow's greatest advantage is also its biggest disadvantage. The power and flexibility can be intoxicating! Just because you can do what you want, doesn't mean you should it! This is discussed in detail throughout the book.

Every customer has several instances-again, each isolated and independent. One instance is usually marked out for developing on, another for testing, and yet another for production. And because each instance is independent, each one can be running a different release of ServiceNow. The production instance differs by having more powerful hardware.

Note

Chapter 9, Diagnosing ServiceNow – Knowing What is Going On, discusses how you can use your instances for tasks such as building functionality, testing it, and then making it live.

Changing your instance

A new instance starts with a few ServiceNow applications, some demo configuration, and example data. This is often called the out-of-the-box state. One of the example data elements is the System Administrator user. You are able to log in and get going, getting full control immediately.

Everyone makes changes to their instance. Unless the people who will be using the system are called Beth Anglin or David Dan (some of the default example users), you'll need to load some users at the very least. Some ServiceNow customers configure a lot, and some do the bare minimum. You can choose how much you wish to do. Because it is single-tenant, you can alter the configuration and data in almost any way you see fit-now, it might not always be smart to do that, but you can!

My favorite analogy, if you haven't guessed it yet, is a building. ServiceNow gives you an office that is yours. It starts off identical, built to the standard plans, but you can redecorate or remodel as you see fit-perhaps even knock down a wall! (Let's hope it's not load bearing.) This is the benefit of single tenancy.

Multitenancy is like an apartment in a block. It is generally more efficient to pack lots of people together in a single building, and you can build it pretty high. However, you don't have the flexibility that being in control gives you. The landlords of the block won't let you knock down a wall!

The vast majority of customers have their instance hosted by ServiceNow. This means that the people who built the house will also look after it, on their land. You get great economies of scale and the benefit of tools and automation design to perform maintenance and give support fast. All the gardeners and janitors are on site, ready to work-they don't need to travel to help out.

Knowing the platform

The heart of ServiceNow is the platform. This is a series of data, logic, and user interface layers, combined to provide a high-level environment that makes it really easy to build workflow and forms-based business applications. If you like, the platform takes raw materials and develops them into building blocks. You then plug them together to create what you need.

ServiceNow has already done a lot of building work. Prebuilt applications are available to perform service management, such as IT, HR, and facilities. Managing IT infrastructure is made easier with the ServiceWatch suite, while the needs of the business are helped with demand, project, and vendor management.

When you know how the platform works, you can more quickly use and support the applications built upon it. And, of course, you can build your own. Understanding the platform will help you in all respects-which is the focus of this book.

Choosing functionalities with plugins

All ServiceNow functionalities are delivered as plugins. When an instance is turned on, one of its first tasks is to load all the plugins that are turned on out of the box. There are quite a few of those: over 200 in the Helsinki version of ServiceNow. And there are several hundred more that you can turn on if you want. A plugin may provide an app, such as HR Service Management, or provide new platform functionality, such as domain separation.

Note

Chapter 9, Diagnosing ServiceNow – Knowing What is Going On, talks about plugins and upgrading ServiceNow in more detail.

When a plugin is turned on, all the data and configuration that the application needs is loaded into the database, meaning that it is ready for work in just a few moments. Many also contain demo data, giving you examples of how it could work.

Running the latest version

Each new version of ServiceNow brings new and improved applications and enhancements to the platform. These are packaged as updates to plugins.

ServiceNow tends to release twice a year, meaning it can be quite a task to keep up with the latest version! This book is written for the Helsinki version of ServiceNow, though most of the information is relevant for newer and older versions.

Aside from improved functionality and bug fixes, ServiceNow often creates improvements to the user interface. An instance provisioned with the Helsinki version of ServiceNow uses UI16 by default. The screenshots in this book show UI16, so if you use a different interface (perhaps for browser compatibility reasons or because of a different version), things may look slightly different, and all of the features may not work the same.

Tip

The product documentation lists the different interfaces available: https://docs.servicenow.com/administer/navigation_and_ui /concept/c_NavigationAndTheUserInterface.html.

Digging into the hosting

A typical ServiceNow-hosted instance is split over two physical datacenters, forming a high-availability pair. Each location runs independently of the other, creating a semi-clustered environment. In the event of a catastrophic disaster with one location being completely unavailable, the other nodes will just pick up the load, with almost no downtime. In fact, the process of switching between locations is used for maintenance procedures, enabling your instance to be well protected against hardware and other failures.

Note

The free developer instances are not replicated, and run only on a single node. A customer's production instance has many more resources!

When you visit your instance, you are directed through several layers:

By looking up DNS records, you are directed to the currently active datacenter for your instance.

The load balancer, by reading a cookie, directs you to the application server you have your session with.

If you aren't logged in, you get directed to the least busy application server.

Your application server then uses the database currently determined as active.

Knowing the nodes

From an architectural perspective, a ServiceNow instance is made up of several application and database servers or nodes. These generally run on shared hardware, meaning although your instance is logically separate and independent, it is physically hosted alongside another customer. At each location, there are generally at least two application nodes, each running a copy of the ServiceNow platform and working together to share load. Additionally, there may be worker nodes installed to process the noninteractive jobs, such as sending out e-mails or dealing with integrations. Even though you'll never directly log in to these worker nodes, they perform some background processing, allowing the interactive application servers to respond more quickly to user requests. While there are generally lots of application nodes, there is only one active database server, running on a separate physical server. It does have a redundant pair hosted in the remote datacenter.

Tip

Chapter 5, Getting Things Done with Tasks, explores the concept of event queues in more detail.

Exploring the database

So you've got an instance and have logged in. Great! What can we see? The answer: database records.

Almost everything in ServiceNow is an entry in a database. When you look at the user interface, virtually everything you see-from the data typed in by a user to log files and how the views are structured-is stored in the instance's relational database. The scripts you write are kept in a string field, and the files you attach to records are stored in chunks, all in the database.

All this data is organized into many tables. A table is a collection of records, with each record being a row. A field is a column in that table.

Everything is built on top of this structure. You don't need to reboot the server to apply new functionality; you just update data records. You don't need to reload configuration files-any properties you set will be read on the next operation. Even the database metadata-information about the fields themselves-is stored in another table.

This gives you a great deal of control. You organize, configure, and manage almost everything the same way, searching for a script like you search for users: by simply querying the right table. This means you can focus on designing and building great business applications, since the platform just works.

Tip

ServiceNow may be considered a high-level platform based on the Model-view-controller (MVC) concept. When building a ServiceNow application, you can first think of the data structure. You determine what information you need to store and how it all links together, creating tables and fields. This is the model aspect.

Automatically, you get a simple view of this data, with forms and lists showing your information.

You can then build simple ways to manipulate and change the data, through automation and simple manual updates, giving you the controller.

Introducing the Gardiner Hotel data structure

One of the first things that many people learn how to do in ServiceNow is to add a field. This is a straightforward operation: you add the new field to a form or list using the UI. Under the hood, the ServiceNow platform performs, among other operations, a simple SQL command to add a column to the table you are manipulating. When you add a field, you add a column to the table. When you remove a field, you drop it. There is no magic-the platform interface just makes it easy to do.

Tip

ServiceNow allows you to add fields to every table in the system. If you decide that adding another is a good idea, you have the power to do so!

In order to work through the ServiceNow functionality, we will build a hotel management application for your new employer, Gardiner Hotels. It will involve building a simple data structure, but one that is highly interlinked.

Here is a representation of the tables we will create in this and the following chapters:

Guests: The reason Gardiner Hotels exists! Our guests' details are the most important information we have. We definitely need their names and, optionally, their e-mail addresses and phone numbers.

Room: This details where our guests will sleep. We store the room number and the floor it is on.

Check-in: When guests want their room key, they check in. We record who checked in to a room and when and who made the entry.

We will create a link to the Room table so we can easily see information about the room, such as which floor it is on.

Reservation: Our guests like staying with us, and they often book months in advance. One reservation might be for many guests, especially if an entire family is coming. A big family might need a big room. We need to record where exactly they might stay.

Note

Over the course of the book, we will expand and further develop the application. Its primary use is to show you as much of the capability of ServiceNow as possible, so some of the examples may be better done in other ways.

Creating tables

Firstly, let's create an app to hold our configuration in. Applications are a container for custom configuration in ServiceNow. It's a great place to capture our work and keep everything we do logically separate. Depending on what configuration you do with it, there may be licensing implications to deploying it in production. But this application will stay safely on our sandbox developer system. Applications are discussed in more detail in the next chapter, and in Chapter 10, Packaging with Applications, Update sets, and Upgrades.

Throughout this book there will be examples to show off features of ServiceNow. To make them as easy to follow as possible, it's best to use the same application scope as me. To make this possible, you should import the very starting point of my Hotel application. At the moment, it's an empty shell.

The easiest way to import the application is through an Update Set. Follow these steps:

Download the Update Set from https://www.gardiner-hotels.com/sets/00-HotelApp.xml Save it to disk.

Navigate to System Update Sets > Retrieved Update Sets. Click Import Update Set from XML.

Tip

The convention for navigating through ServiceNow uses the following structure: Application Menu > Module. For modules with separators, it will be Application Menu > Section > Module. The easiest way to find a particular link is to type it in the Application Filter field at the top-left corner of the menu. Make sure you are choosing the right one, though, because some modules are identically named.

Click the Browse button, and choose the XML file you downloaded. Click Upload.

Click on the Hotel Bootstrap record, then click on the Preview Update Set button.

Once analyzed, click on Commit Update Set. Click Close once done.

If you navigate to System Applications > Applications, you should see the Hotel entry in the list.

Tip

An alternative is to fork my GitHub repository available at https://github.com/gardinerhotels/hotel.

Now, let's create our first table. Navigate to System Definition > Tables, and click New.

Fill in the following values, and click on Create, then OK to confirm. Some fields (like Name) will automatically populate.

Label: Check-in

New menu name: Hotel

Note

Notice the auto-generated table name. If you imported the Update Set, the name should be x_hotel_check_in. It's made up of several parts: the vendor prefix, the application name, and the table name itself. More about this in Chapter 2, Developing Custom Applications.

Click on Submit to create the table.

Tip

Many technical items in ServiceNow have a label and name that are used in the database and in scripts. In this case, the database table is called x_hotel_check_in, while an entry in the Field Labels (sys_documentation) table contains the mapping between the name