Planning integration projects

You can integrate a variety of external systems with PolicyCenter by using services and APIs that link PolicyCenter with custom code and external systems. This overview provides information to help you plan integration projects for your PolicyCenter deployment and provides technical details critical to successful integration efforts.

PolicyCenter addresses the following integration architecture requirements.

A service-oriented architecture: Encapsulate your integration code so that upgrading the core application requires few other changes. Also, a service-oriented architecture enables APIs to use different languages or platforms.
Configurable behavior with the help of external code or external systems: For example, implement special policy validation logic, use a legacy system that generates policy numbers, or query a legacy system.
Sending messages to external systems in a transaction-safe way: Trigger actions after important events happen in PolicyCenter, and notify external systems only if the change is successful and no exceptions occurred. For example, alert a policy database if anyone changes policy information.
Flexible export: Providing different types of export minimizes data conversion logic. Simplifying the conversion logic improves performance and code maintainability for integrating with diverse and complex legacy systems.
Predictable error handling: Find and handle errors cleanly and consistently for a stable integration with custom code and external systems.
Linking business rules to custom task-oriented Gosu or Java code: Let Gosu-based business rules in Guidewire Studio or Gosu templates call Java classes directly from Gosu.
Importing or exporting data to or from external systems: There are multiple ways to import data to and export data from PolicyCenter. You can choose which methods make the most sense for your integration project.
Using clearly defined industry standard protocols for integration points: PolicyCenter provides APIs to retrieve policies, create users, manage documents, trigger events, validate records, and trigger bulk import/export. However, most legacy system integrations require additional integration points customized for each system.

To achieve these goals, the PolicyCenter integration framework provides multiple ways to integrate external code with PolicyCenter.

Web service APIs

Web service APIs are a general-purpose set of application programming interfaces that you can use to query, add, or update Guidewire data, or trigger actions and events programmatically. Because these APIs are web services, you can call them from any language and from any operating system.

A typical use of the web service APIs is to programmatically add submissions, policy revisions, and policies to PolicyCenter.

PolicyCenter supports WS-I web services that use the SOAP protocol. You can use the built-in SOAP APIs, but you can also design your own SOAP APIs in Gosu and expose them for use by remote systems. Additionally, your Gosu code can call web services hosted on other computers to trigger actions or retrieve data.

Plugins

PolicyCenter plugins are classes that PolicyCenter invokes to perform an action or calculate a result. Guidewire recommends writing plugins in Gosu, although you can also write plugins in Java. Gosu code, like Java code, can call third-party Java classes and Java libraries.

Several types of plugins are supported.

Messaging plugins: Send messages to remote systems, and receive acknowledgments of each message. PolicyCenter has a sophisticated transactional messaging system to send information to external systems in a reliable way. Any server in the cluster can create a message for any data change. The only servers that send messages are servers with the messaging server role.
Authentication plugins: Integrate custom authentication systems. For instance, define a user authentication plugin to support a corporate directory that uses the LDAP protocol. Or define a database authentication plugin to support custom authentication between PolicyCenter and its database server.
Document and form plugins: Transfer documents to and from a document management system, and help prepare new documents from templates. Additionally, use Gosu APIs to create and attach documents.
Inbound integration plugins: Multi-threaded inbound integrations for high-performance data import. PolicyCenter provides implementations for reading files and receiving JMS messages, but you can also write your own implementations that leverage the multi-threaded framework.
Other plugins: Some examples are plugins that generate policy numbers (IPolicyNumGenAdapter) or get a claim related to a policy from a claims system (IClaimSearchAdapter).

Inbound and outbound file integration

Frameworks for configuring multiple integrations with external systems by using files to transfer data. PolicyCenter uses batch processing to read or create files and workqueues to read or write the records in the files.

Integration Views

Integration Views enables you to select and retrieve data from the PolicyCenter database and to compose and transform that data to meet business needs. Integration Views support the definition of a stable, versioned contract for this data processing. Integration Views also provides a straightforward, declarative way to map underlying PolicyCenter data into a serialized format that conforms to the contract.

GX models

A GX model supports converting the properties of a data type to XML. Supported data types that can be converted include Gosu classes and business data entities, among others. A GX model can include all or a subset of an associated data type's properties. Using GX models to limit the transfer of object data to the minimum subset of required properties conserves resources and improves performance.

REST API framework

A framework that provides the means to define, implement, and publish REST API contracts.

Templates

Generate text-based formats that contain combinations of PolicyCenter data and fixed data. Templates are ideal for name-value pair export, HTML export, text-based form letters, or simple text-based protocols.

The following table compares the main integration methods.

Integration type	Description	What you write
Web services	A full API to manipulate PolicyCenter data and trigger actions externally from any programming language or platform that uses PolicyCenter Web services APIs. Accessed by using the platform-independent SOAP protocol.	To publish web services, write Gosu classes that implement each operation as a class method. To consume web services that a Guidewire application publishes, write Java or Gosu code on an external system. The external system calls web services by using the WSDL that PolicyCenter generates. To consume external web services from Gosu, write Gosu code that uses WSDL from the external system. Gosu creates native types from the WSDL that you download to the Studio environment. In all cases, define objects that encapsulate only the data you need to transfer to and from PolicyCenter. The general name for such objects are Data Transfer Objects (DTOs). Define DTOs as Gosu classes or by using XSDs.
Plugins	Classes that PolicyCenter calls to perform tasks or calculate a result. Plugins run in the same Java virtual machine (JVM) as PolicyCenter.	Gosu classes that implement a Guidewire-defined interface. Java classes that implement a Guidewire-defined interface. Optionally use OSGi, a Java component system.
Messaging code	Changes to application data trigger events that generate messages to external systems. You can send messages to external systems and track responses called acknowledgments.	Gosu code in the Event Fired rule set. These rules create messages (Message objects) that are processed in a separate transaction, possibly on other nodes in the cluster. Messages represent data to send to external systems. Messaging plugin implementations that send the messages to external systems. The most important interface is MessageTransport. There are other optional plugins. Configure one or more messaging destinations in Studio to specify your messaging plugins. After you register your plugins in the Plugins editor, you must also use the Messaging editor for each destination. In all cases, define objects that encapsulate only the data you need to transfer to and from PolicyCenter. The general name for such objects is Data Transfer Objects (DTOs). Define DTOs as Gosu classes or by using XSDs.
Inbound and outbound files integration	Inbound and outbound files integrations communicate with external systems by transferring structured data in files. These integrations work with both the local file system and Amazon S3 buckets. PolicyCenter provides frameworks to support these integrations and your code provides the implementation of the data transfer.	Configuration details. For inbound files integration, a class implementing the InboundFileHandler interface. For outbound files integration, a class implementing the OutboundFileHandler interface.
Integration Views	Integration Views provides a versioned contract that maps the PolicyCenter data model into a serialized form that an external system can consume or produce. This contract is decoupled from the data model so that changes to either the contract or the data model do not interfere with each other.	Mappings that transform an object of a particular type first into an intermediate object that conforms to a specified schema and then to a JSON object or XML element. The schema that defines the structure of the data involved in the custom processes. Optionally, filters specifying the parts of the schema to use as output or for presentation.
GX models	GX models support the conversion of properties of an entity or other data type to XML. The GX model editor in Studio defines the data type’s properties to include in the GX model. As you define the model, PolicyCenter generates an XSD schema definition. Subsequently, an instance of the GX model containing XML data can be used to integrate with external systems. For example, messaging plugins could use a GX model to send XML to external systems. Also, a web service could accept the XML data contained in a GX model as a payload from an external system.	Using the GX Model editor in Studio, you customize the properties in an entity or other data type to export in XML format. Integration code that uses the GX model.
REST API framework	The Guidewire REST API framework, in combination with Guidewire Integration Views, provides PolicyCenter with support for the following: Swagger and OpenAPI 2.0 API schemas JSON data schema payloads Mappings from the PolicyCenter data model schema to JSON	Swagger and JSON schema files Mapping files Classes that perform the actual API work API handler classes
Templates	Several data extraction mechanisms that perform database queries and format the data as necessary. For example: Sending notifications as form letters and use plain text with embedded Gosu code to simplify deployment and ongoing updates. Designing a template that exports HTML for development of web-based reports of PolicyCenter data.	Text files that contain small amounts of Gosu code.
Links	Link from a PolicyCenter screen to a URL address, such as a screen in another InsuranceSuite application or an external application. The link is implemented by using an `ExitPoint` PCF file.	An `ExitPoint` PCF file. Incorporate the `ExitPoint` into the originating PolicyCenter screen.

PolicyCenter integration elements

The following diagram summarizes some common elements of policy management using PolicyCenter.