Development Tools for Microsoft Business Solutions-Great Plains
Microsoft Corporation
October 2004
Applies to:
Microsoft Business Solutions–Great Plains
Summary: Several development tools allow developers to create custom applications that integrate with Microsoft Business Solutions–Great Plains. If you are a developer working for a Microsoft Business Solutions independent software vendor (ISV), you can use these tools to integrate an existing application with Great Plains or to develop customized applications for vertical markets. (36 printed pages)
Contents
- Overview
- Introduction to Great Plains
- Intended Audience
- Architecture
- Choosing a Tool
- Understanding the Tools
- eConnect
- Integration Manager
- ODBC Drivers
- Integration Assistant for Excel
- Modifier with VBA
- Dexterity
- Great Plains SDK
- Continuum API
- Business Portal SDK
Overview
This article briefly describes Microsoft Business Solutions–Great Plains architecture, summarizes the features and benefits of each Great Plains development tool, and provides guidelines for choosing the right tools for various development tasks. The toolset for Great Plains may vary depending on your status as an independent software vendor (ISV) or customer; therefore, you might not have access to all of the tools discussed in this article.
Independent software vendors (ISVs) should typically build an application using Microsoft Visual Studio .NET and connect the application using eConnect. In certain circumstances, the other tools might be a better choice.
Several tools are available for developers to create custom applications that integrate with Great Plains. These tools include the following:
- eConnect
- Integration Manager
- Open Database Connectivity (ODBC) Drivers
- Great Plains Software Development Kit (SDK)
- Continuum API
- Dexterity
- Modifier with Microsoft Visual Basic for Applications (VBA)
- Integration Assistant for Microsoft Excel
- Microsoft Business Solutions–Great Plains Business Portal Software Development Kit (SDK)
You can obtain these development tools from the Great Plains CD or if you're an MSDN Universal you can download them from the MSDN subscriber downloads area.
Introduction to Great Plains
Great Plains is a comprehensive accounting and business management system. It supports business processes in the lower mid-market and scales up to meet the requirements of complex business processes in the upper mid-market and corporate market.
Great Plains divides business processes into modules, which are collections of applications that work together to meet a number of closely related accounting and business management goals. Modules that have similar purposes are organized into solution series. The solution series that are available with Great Plains include the following:
- Financial Management
- Analytics
- Human Resource Management
- Customer Relationship Management
- Field Service Management
- Supply Chain Management
- Manufacturing
- Retail Management
- Foundation
- Customization Tools
- Project Management
- Business Portal
Using the tools described in this article, developers can customize various Great Plains modules for their customers or write applications that integrate with Great Plains.
There are separate tools for the Retail Management and Customer Relationship Management solution series.
For more information about the functionality of Great Plains, visit the Microsoft Business Solutions Web site.
Intended Audience
This technical article is for software engineers who develop applications that are designed to work with Great Plains. The topics in this article are useful for independent software vendors (ISVs) and other developers who might customize or integrate with Great Plains. Readers should have basic experience with programming for business applications and using data models.
Different tools require different skill sets. To perform simple integrations, such as importing data from a table or an Excel file, you need experience with Microsoft Office applications, and experience with VBScript is recommended. Experience with automation, project management, and development significantly aids in project completion for many types of customization. For the most complex projects, you need advanced programming skills and knowledge of the networks and operating systems supported by Microsoft Business Solutions; you should be familiar with the business logic implementation of your application and with extensible markup language (XML) coding, XML schemas, Structured Query Language (SQL) programming and procedures, and scripting languages, such as Microsoft Visual Basic.
Architecture
Great Plains was designed with an open architecture, which means that there are a number of ways that the application can be customized and integrated. At a high level, the architecture can be broken down into four basic components: the database layer, the data dictionary layer, the business logic layer, and the user interface layer.
Integrating applications can interact with Great Plains at any of these four layers. Most integration should occur at the business logic layer, which ensures valid data and the best performance. Integrating to the database layer is complex and introduces the possibility that data will not be validated; modifying the user interface layer can reduce performance.
In the following diagram, the four layers of architecture are illustrated in the "Great Plains Architecture" column. Notice the close relationship between the business logic layer and the data dictionary layer; this is because the data dictionary defines the business logic rules. Pointing to each layer in the architecture are tools that you can use to integrate your external application with Great Plains or to customize Great Plains. These tools are described later in this article.
.gif)
Figure 1. Great Plains architecture
Database Layer
Database-level integration allows direct access to the data and is supported by many development environments. However, this is the most difficult layer for integration because all the data must be validated. The developer needs to understand what tables need to be populated, what fields are required, and how to ensure that the data is error-free. Tools that can integrate at this layer include Dexterity and the Continuum API. Using the Great Plains SDK documentation as a reference, you also can use ODBC drivers for Microsoft SQL Server and MSDE to access the database layer directly.
eConnect also integrates at this layer, but unlike the other tools, eConnect enforces business logic.
Data Dictionary Layer
The data dictionary layer contains all of the resources used to define and create the Great Plains data model in Microsoft SQL Server. These resources are built within the Dexterity toolset and include data types, fields, and tables.
Resources for foundational and financial components are stored in the main data dictionary. Some components are developed as integrating applications and have their own data dictionaries. These include manufacturing, project management, and human resources components. Likewise, applications developed in Dexterity by ISVs are developed as separate integrating applications and have their own data dictionaries.
In a multidictionary environment, the run-time engine interprets the main dictionary and the integrating dictionaries at the same time. This capability allows multiple integrating dictionaries to function with the main dictionary, providing a seamless user experience.
The only tool that allows integration at the data dictionary layer is Dexterity. With Dexterity, you can read tables, create new tables, and add new or existing fields to those tables. ISVs cannot add fields to the existing tables within the Great Plains data model. This method ensures that each customer installing Great Plains starts with a clean database.
Business Logic Layer
The business logic layer allows you to take advantage of the internal code that is shipped with Great Plains, so you do not need to spend time developing code that already exists.
Three tools provide the primary means for accessing the business logic: eConnect, Dexterity, and the Continuum API. eConnect uses SQL stored procedures to follow the business logic rules and to ensure that data is valid in Great Plains, while ensuring good performance. Dexterity gives you access to hundreds of procedures used by the application, such as General Ledger posting, in addition to all of the table definitions. The Continuum API uses Microsoft COM Automation, which allows non-Dexterity applications to call a Dexterity procedure.
In addition to these three tools, Integration Manager's SQL Optimized Provider also supports some integration at the business logic layer.
User Interface Layer
The last level for integration is the user interface. Of course, data can be entered manually into the windows of Great Plains. Integration Manager's standard objects integrate data through the user interface. You also can use the Continuum API, Modifier with VBA, or Dexterity to integrate at this level by automating the windows.
Modifier with VBA is a customization tool that works at the user interface layer. If data is in an Excel file, Integration Assistant for Excel can bring this data into Great Plains through the user interface level.
Choosing a Tool
If you're a developer who is customizing or developing integrating applications with Microsoft Business Solutions–Great Plains, the following tools are available:
Integration These tools allow you to transfer data from one source to another:
- eConnect
- Integration Manager
- Open Database Connectivity (ODBC) Drivers
- Integration Assistant for Excel
- Business Portal Software Development Kit (SDK)
- Dexterity
Development and Customization These tools allow you to create new applications that are based on Great Plains or to customize existing applications to fit specific needs:
- Dexterity
- Modifier with VBA
- Business Portal Software Development Kit (SDK)
Documentation These tools provide information about integrating with the Great Plains data model and typically are used in conjunction with other Great Plains development tools:
- Continuum API
- Great Plains Software Development Kit (SDK)
- Business Portal Software Development Kit (SDK)
To help you determine which development tools to use, this section describes some common tasks that you may want to perform and defines the tools most appropriate for each task.
These tasks provide a summary of the types of modifications you can make to Great Plains. If you are adding to an existing application, you can skip to the topic that describes what you are trying to do. Each task includes references to the tools that you can use for the task. When multiple tools are listed for a task, the order in which the tools are listed is not a recommendation about the ranking of the tools for the task, except where noted.
The following topics are discussed:
- Developing a New Application
- Customizing Windows
- Enabling Real-Time Integration
- Performing a Batch Integration
For more information about each tool, see Understanding the Tools later in this article.
Developing a New Application
You can develop a new application that integrates with Great Plains to meet the needs of a particular industry or a vertical market. In this scenario, you are either starting to build a new application or rewriting an existing application.
Table 1.
| For This Task | Use This Tool |
|---|---|
| Build a new application or rewrite an existing application, and then perform real-time or batch integration to Great Plains. | Visual Studio .NET to write the application, and then eConnect for real-time and batch integration, or Integration Manager for batch integration. |
| Create a rich-client, seamless integration with Great Plains. | Dexterity |
| Create a new business component, query page, Web Part, or portal page for the Business Portal to integrate with Great Plains. | Microsoft Visual Studio .NET, Rational XDE and its code generator, the Entity Relational Map Generator, and the Entity Association Map Generator to write the application, and then the Business Portal Software Development Kit (SDK) for integration. |
Customizing Windows
You can modify the windows in the Great Plains application to meet the specific needs of an industry, vertical market, or individual end-user.
Rearranging Fields
You can rearrange the fields in an existing Great Plains window, such as the Customer Maintenance window or the Receivables Transaction Entry window. Fields can be rearranged to meet the needs of the customers who use your integrating application and Great Plains for a certain industry or vertical market.
Table 2.
| For This Task | Use This Tool |
|---|---|
| Make this change for only one end-user or a small number of end-users, or for multiple end-users who have different requirements. | Modifier with Microsoft Visual Basic for Applications (VBA) |
| Make this change for all or most of the end-users. | Dexterity |
Note If the existing window or field resides in an integrating dictionary, use Modifier with VBA rather than Dexterity.
Adding Fields
You can add new fields and store additional data in an existing Great Plains window. For example, you could track additional customer attributes in the Customer Maintenance window.
Table 3.
| For This Task | Use This Tool |
|---|---|
| Make this change for only one end-user or a small number of end-users. | Modifier with VBA Modifier can add the field to the window, and VBA provides the business logic to keep the data synchronized with other Great Plains data and windows. |
| Add these fields for all or most of the end-users. | Dexterity Using Dexterity allows you to create custom lookups for the new fields. |
Note If the existing window or field resides in an integrating dictionary, use Modifier with VBA rather than Dexterity.
Changing the Properties of a Field
You can change the default values of a field's properties. For example, you could make the field a required field or hide the field from view.
Table 4.
| For This Task | Use This Tool |
|---|---|
| Make this change for only one end-user or for a small number of end-users. | Modifier with VBA |
| Make these property changes, in addition to other changes to windows, for all or most of the end-users. | Dexterity |
| Make only these property changes, for all or most of the end-users. | Continuum API |
Note If the existing window or field resides in an integrating dictionary, use Modifier with VBA rather than Dexterity.
Changing the Text Labels
You can change the text labels on an existing window to meet the needs of a specific industry or a specific customer. For example, in a medical setting you could change all occurrences of the term "Customer" on Great Plains windows to "Patient."
Table 5.
| For This Task | Use This Tool |
|---|---|
| Make one change to a text value and have this change affect all other instances of this text appearing on other windows within Great Plains. | Modifier with VBA |
| Make changes to each window individually. | Modifier with VBA or Dexterity |
Note If the existing window or field resides in an integrating dictionary, use Modifier with VBA rather than Dexterity.
Customizing the Business Logic
You have several options for adding business logic or exerting control over the business logic running in an existing window. You may simply want to insert default data into a field as the end-user opens a window or presses the TAB key to move out of a field. In a more complex scenario, you might want to stop a business process, such as posting an accounts receivable transaction, based on a certain set of criteria.
Table 6.
| For This Task | Use This Tool |
|---|---|
| Make this change for only one end-user or a small subset of end-users. | Modifier with VBA |
| Make business logic changes for all or most of the end-users, in addition to user-interface changes to existing windows. | Dexterity |
| Make simple business logic changes using another COM-compliant development tool for all or most of the end-users, but no user-interface changes to existing windows. | Continuum API |
Enabling Real-Time Integration
Several tools allow integrations in which data is written to and read from Great Plains in real time. This means that you can continually update the Great Plains databases while new data is entered into your systems.
Reading Existing Data from Great Plains
You can periodically update your application's database from the database that is used by Great Plains, or you can write code that will read from the database that is used by Great Plains from your own application. For example, you could query a list of items for a Web site every time the page opens, or you could write code in your application that queries the current list price for an item stored in the Great Plains database.
Table 7.
| For This Task | Use This Tool |
|---|---|
| Read the data for any application that needs the data and place custom requester services on all SQL tables within Great Plains. | eConnect This tool allows manual access, automated access, or a combination of the two to generate the data into an extensible markup language (XML) document. You also might consider using BizTalk in conjunction with eConnect to transfer data to another application. |
| Read the data for any application. | Open Database Connectivity (ODBC) drivers The Great Plains SDK identifies some of the tables that might be read by a developer's application. |
| Read data using native Dexterity commands, if Dexterity already is being used for other scenarios. | Dexterity |
| Read and display data in the Business Portal for any application. | Visual Studio .NET, Rational XDE and its code generator, the Query Web Service, result viewers, and the Business Portal Software Development Kit (SDK). |
Subscribing to Changes within Great Plains Data
You can update your application's database while the Great Plains end-user makes changes within Great Plains. For example, the end-user could add or change a customer in the Great Plains Customer Maintenance window or delete an existing vendor from the Great Plains Vendor Maintenance window. To keep your data synchronized with the data stored in Great Plains, you need to create code to update your application's database as these changes occur in Great Plains.
Table 8.
| For This Task | Use This Tool |
|---|---|
| Watch for changes made to the data within Great Plains for any application that needs the data. | eConnect This allows the developer to watch SQL tables as they are created, modified, and deleted. An XML document is created that shows the results of the database operation. |
| Watch for changes to selected records by either watching for user activity in the windows or on the tables within Great Plains. | Dexterity and Continuum API
Both of these tools will allow a user to place watch triggers to watch for either user interface activity or database activity and to cause other code to execute when these triggers are fired. |
Note It is possible to place SQL database triggers and access data through ODBC. However, this method is not recommended because you may need to make modifications for each product upgrade.
Writing Simple Data to Great Plains
You can update basic setup data within Great Plains.
Table 9.
| For This Task | Use This Tool |
|---|---|
| Write to the Great Plains SQL database, if the setup data is not complex and there is no need for intense data validation. | ODBC drivers
Use the Great Plains SDK as a reference for more information about various tables and fields. |
| Write to the Great Plains SQL database from within a custom interface designed in Dexterity. | Dexterity |
| Interact with a Great Plains window, rather than directly with the SQL database. | Continuum API |
Writing Transactions and Master Records to Great Plains
You can update data within Great Plains and ensure that the updated data is validated by the Great Plains business logic. For example, you could create new transactions within a Great Plains module, such as Receivables Management, or create new master records such as Customers, Vendors, Accounts, and Employees.
Table 10.
| For This Task | Use This Tool |
|---|---|
| Access the Great Plains business logic through a Component Object Model (COM) or Web services interface. | eConnect |
| Define your own transactions and utilize eConnect application programming interfaces (APIs) for integration. | eConnect |
| Interact with a Great Plains window directly. | Continuum API |
| Update the Great Plains SQL database using an interface created in Dexterity. | Dexterity |
| Create a new business component, query page, Web Part, or portal page for the Business Portal to integrate with Great Plains. | Visual Studio .NET, Rational XDE and its code generator, the Entity Relational Map Generator, and the Entity Association Map Generator to write the application, and then the Business Portal Software Development Kit (SDK) for integration. |
Note Using ODBC for this task is not recommended. However, if you need to write directly to the SQL tables through ODBC, information about common transaction and master records is available in the Great Plains SDK.
Writing and Validating System Data
You can update data within Great Plains at a system level that requires complex data validation. For example, you may want to access the next document number for a transaction record or update inventory allocations.
Table 11.
| For This Task | Use This Tool |
|---|---|
| Update data with complex validation if you are already using Dexterity for other tasks. | Dexterity |
| Update data with complex validation if you are already using the Continuum API for other tasks. | Continuum API |
Note It is possible to write directly to the SQL tables through ODBC. This method is not recommended because you may need to make modifications for each product upgrade.
Completing a Batch Integration
Batch integrations allow you to import or export large batches of data that is collected over a period of time. Whereas with real-time integrations data is updated continually and automatically on a regular schedule, batch integrations are completed manually as they are needed. Several tools allow integrations in which data is written to and read from Great Plains in batches.
Reading Existing Data from Great Plains
You can periodically update your application's database based on information within the database for Great Plains. This can be done on a schedule using a scheduling tool, or can be initiated by the user.
Table 12.
| For This Task | Use This Tool |
|---|---|
| Place custom requester services on all SQL tables within Great Plains. | eConnect This allows for manual access, automated access, or a combination of the two to generate the data as an XML document. |
| Read the data for any application that needs the data. | ODBC drivers The Great Plains SDK identifies some of the tables that might be read by a developer's application. |
| Place SQL database triggers and store the data in temporary tables or in a text file until it is ready to be processed. | Microsoft SQL Server The Great Plains SDK identifies some of the tables that might be read by a developer's application. |
| Read data for Dexterity based applications. | Dexterity |
| Watch for batch activity at the user interface level within Great Plains, such as posting or monthly reports. | Continuum API |
Writing Transactions and Master Records to Great Plains
A common scenario is to pass a large number of transactions and master records into Great Plains. First, your application needs to maintain a list of the records to be passed. Your application then publishes the list to one of the tools in the following table, and then the tool imports the data into Great Plains.
Table 13.
| For This Task | Use This Tool |
|---|---|
| Perform batch mode integration to write validated data. | Integration Manager |
| Write validated data to Great Plains in batch mode through a COM or Web services interface to the Great Plains business logic. | eConnect |
| Define your own transactions and utilize eConnect application programming interfaces (APIs) for integration. | eConnect |
| Write validated data in batch mode from Microsoft Excel. | Integration Assistant for Excel |
| Interact with a Great Plains window directly and automate the window through code. | Continuum API |
| Write transactions and master records using a Dexterity based application. | Dexterity |
Note Using ODBC for this task is not recommended. But if you need to write directly to the SQL tables through ODBC, information about common transaction and master records is available in the Great Plains SDK.
Understanding the Tools
The tools in Microsoft Business Solutions–Great Plains support interconnected business solutions for the back office, front office, and e-business. Great Plains allows you to write integrated applications, move data from existing sources to your new applications, and modify each customer's application to meet specialized needs.
To validate the integrity of data from integrated applications, many of the tools can access Great Plains business logic. The business logic restricts or qualifies data as it is transferred into the Great Plains database. This ensures that only data meeting your criteria will be committed to the database. Customizing business logic allows you to map and transform data, to define events-triggering functionality, to execute commands, to provide feedback to the user log or error log, and to accept input from the user. Developers can call existing business logic, write new business logic, or modify existing business logic. Scripting languages such as SQL, SanScript (the scripting language of Dexterity), or Microsoft Visual Basic for Applications (VBA) can be used to define the logic.
eConnect
eConnect is a set of development utilities and APIs that integrate outside data sources with Great Plains components and Great Plains back office document transactions.
For more information about eConnect, see the eConnect manual in the MSDN Library.
Advantages of eConnect
The following table lists the advantages that eConnect provides when you need to connect to external data sources.
Table 14.
| Benefit | Description |
|---|---|
| Reusable code | eConnect uses a series of transactional business objects that can be reused with little or no modification. |
| Standard technologies | eConnect uses Microsoft SQL Server technology, Visual Basic objects, stored procedures, Microsoft BizTalk, COM, Microsoft Message Queuing, and extensible markup language (XML). The business logic is stored as SQL procedures. This allows you to select your tool of choice for connectivity, so you do not need to learn new technologies. |
| Quicker development | You can focus on XML and business logic development without rebuilding transport protocols. For example, you can create an XML document for a specific transaction that utilizes a custom application in the back office. eConnect connectivity tools transfer that document from XML to the back office. Independent software vendors using eConnect can rapidly integrate Web solutions through Web services. |
Skills Needed to Use eConnect
eConnect requires advanced programming skills and knowledge of Microsoft Business Solutions systems. You need to be familiar with the business logic implementation of your application and have experience with XML coding, XML schemas, and SQL programming and procedures. You may also need experience with one or more of the following:
- Microsoft Windows network administration.
- Microsoft Internet Information Services (IIS) 5.0 or later.
- Microsoft Message Queuing (MSMQ) 2.0 or later.
- Microsoft SQL Server 2000 or later.
- BizTalk 2002 or later.
- Microsoft Data Access Components (MDAC) 2.6 or later.
- Great Plains 7.0 or later database.
Developers can modify eConnect or write a new version. Technical documentation is available to assist you and provide examples for writing your own integrations.
Capabilities of eConnect
With eConnect, you can tie your systems together in real time with multiple integration points. eConnect supports integration between data from other applications and your Great Plains application, enabling high volume and high speed in back office transactions. Data can be pushed into Great Plains from diverse application types such as Web storefronts, Web services, legacy applications, customer relationship management applications, and point-of-sale applications.
eConnect uses Great Plains business logic to ensure that data is validated and that well-formed XML documents are returned on demand. The XML documents display extensive details from back office data. You can update, insert, and delete back office transactions, and you can send back office requests to view specific documents or lists of documents.
eConnect can filter data and apply test criteria to the data before or after you import the data. You can extend the business logic to process incoming orders, invoices, or sales documents. For instance, you can limit the values that can be entered in fields, require permission for users to conduct transactions that exceed a preset monetary value, or set a default value for a field.
eConnect provides multiple methods for adding new business logic. In addition to adding script directly to the business object—as you do in Visual Basic Scripting Edition (VBScript) with tools such as Dexterity or Modifier with VBA—you can add XML nodes to the document schema in eConnect. The current nodes map directly to the SQL-based business logic on the back end, and you add the business logic in SQL to route the added XML node. The data is integrated using procedures that are stored in a Microsoft SQL Server database. Pre-SQL and post-SQL stored procedures are attached to each schema, and developers can use them to extend the integration based on their business needs.
Components of eConnect
eConnect contains an extensive set of integration components and samples. The sample integration components consist of two Visual Basic applications that demonstrate how to call the COM objects directly and how to load documents into a message queue. Developers can use these samples to implement eConnect solutions and to extend their business logic. A full SDK including additional samples is available to assist you in writing your own integrations. Other components include the following:
- A Windows Enterprise Application Integration assembly built on the Microsoft .NET Framework. This is a transport mechanism for delivering Message Queuing messages to and from the back office.
- Transaction schemas and XML examples that can be utilized with all of the eConnect connectivity tools.
- Serialization API that can dynamically create XML documents.
- Microsoft Windows 2000 services for transporting XML documents through Message Queuing.
- BizTalk adapters that can be utilized to quickly snap eConnect into your existing BizTalk server implementation.
- COM objects or ActiveX Controls can be utilized independently or in conjunction with other eConnect tools to access back office transactions.
There are more than 40 predefined integration areas available with eConnect. The following is a sample of back office integrations that eConnect supports:
- Shared Master (Accounts, Vendors, Customers, and so on)
- General Ledger
- Sales Order Processing
- Payables Management
- Receivables Management
- Purchase Order Processing
- Inventory Transfers
- Fixed Assets
- Project Accounting
Related Tasks
- Developing a New Application
- Reading Existing Data from Great Plains (Real-Time Integration)
- Reading Existing Data from Great Plains (Batch Integration)
- Subscribing to Changes within Great Plains Data
- Writing Transactions and Master Records to Great Plains (Real-Time Integration)
- Writing Transactions and Master Records to Great Plains (Batch Integration)
Integration Manager
Integration Manager is an integration tool used to convert and transfer data from most database formats or desktop applications into Great Plains. Integration Manager imports or exports data from a variety of sources including comma-delimited and tab-delimited text files and most ODBC data sources.
Integration Manager is a component-based application consisting of a core conversion engine and a set of adapters. Adapters for converting information for different formats are available for several integrating systems. The adapters process the business logic. The data source adapter processes the extraction logic, which imposes restrictions or qualifications about accepting or rejecting data. The destination adapter processes the insertion logic, which determines how to insert the new data or how to update the database.
Advantages of Integration Manager
The following table lists the advantages that Integration Manager provides for converting and transferring data.
Table 15.
| Benefit | Description |
|---|---|
| Database knowledge not required | Integration Manager assists you in mapping your data source to the Great Plains objects without having to refer to the tables directly. |
| Option to customize | All integration data is processed through Great Plains business objects. You can customize these business objects to ensure that data meets your needs. Integration Manager supports COM, VBScript, and SQL commands. |
| Minimal maintenance required for upgrades | After the integration is defined, the mappings and table formats have minimal changes between system upgrades. The object browser in Integration Manager simplifies ongoing maintenance. |
Skills Needed to Use Integration Manager
End-users and developers can use the Integration Manager graphical interface to visually map data from one format to another. Integrations can be saved and shared among other users.
Using advanced features or creating a complex integration requires development experience. A background with Great Plains, database maintenance, SQL commands, and a scripting language (such as VBA or VBScript) is helpful.
Capabilities of Integration Manager
Integration Manager allows you to complete your own integrations, by graphically mapping fields between the source and target databases, and by selecting which rules to validate the data against. You can define SQL queries to complement your integrations. A simplified import and export feature within Integration Manager allows basic integration capabilities with limited data validation. Extensive error checking and logging allow you to review the results of any integration quickly.
In addition to simple end-user integrations, Integration Manager also supports customization through VBScript, which you can use to customize business logic to meet specific business needs. For instance, you could create a new batch name using the current system date, or create a customized document number for each transaction based on data captured through VBScript.
After you have defined the integration, you can launch it manually or automatically. From within Great Plains, users explicitly launch integrations from a menu command. This allows one-time or infrequent data transfers, such as initially populating a new database. Integration Manager also can schedule integrations to run as part of a batch file or using Scheduled Tasks in Windows. This permits users to incorporate the integration as an integral part of another process or for routine transfers, such as overnight transactions or to offices in different time zones.
Like many of the Great Plains custom development tools, Integration Manager is COM-compliant. Using this industry standard ensures that existing integrations will work with product upgrades. The underlying COM objects are represented as Great Plains business objects. This abstraction layer allows users and developers to be one level removed from the implementation details of the database. Unlike database-level integrations, which are susceptible to changes in table structure during a product upgrade. Integration Manager business objects minimize the impact of table structure changes.
If you or your users require a simpler conversion tool or need to transfer data only from an Excel spreadsheet, see Integration Assistant for Excel.
Components of Integration Manager
Integration Manager comes with four destination adapters:
Table 16.
| Adapter | Does This |
|---|---|
| Great Plains standard | Creates validated conversions in defined Great Plains destinations. |
| Great Plains SQL-optimized | Completes streamlined and faster conversions specifically for Microsoft SQL Server. |
| Direct to table | Creates integrations that aren't validated through an ODBC connection. |
| XML | Reads an XML document to import into Great Plains. It also allows you to create XML documents from any type of data source. |
For other data conversion options, see Integration Assistant for Excel or ODBC Drivers.
Related Tasks
- Developing a New Application
- Writing Transactions and Master Records to Great Plains (Batch Integration)
ODBC Drivers
Open database connectivity (ODBC) drivers are integration tools to connect client applications to ODBC-compliant databases. This allows applications to share data by using a common transfer protocol.
ODBC is an industry standard for accessing databases. Database sources may be from various manufacturers and have different data formats, but as long as the database implements ODBC, information can be imported or exported by other databases or applications. Each ODBC driver is specific to a particular database management system.
Use the Great Plains SDK documentation as a reference for more information about the various tables and fields in the Great Plains database.
Advantages of ODBC Drivers
The following table lists advantages that ODBC drivers provide as a foundation for transferring information between ODBC-compliant databases.
Table 17.
| Benefit | Description |
|---|---|
| Industry standard | Because ODBC is an industry standard for exchanging information among databases, you don't need to learn new technologies or risk being locked into proprietary systems. |
| Data exchange | Data from ODBC-compliant databases can be seamlessly imported or exported between applications. Many database manufacturers support this standard, ensuring that you can integrate with a wide range of systems. |
Skills Required to Use ODBC Drivers
Developers who write applications that incorporate access to ODBC databases will require extensive knowledge of the database's table structure and have experience writing and maintaining databases. Developers must have an understanding of an ODBC driver interface and API functions.
Capabilities of ODBC Drivers
ODBC drivers control data import or export requests so that the information conforms to the formats and structures of the system that owns the data. Systems require one or more drivers to process ODBC requests. They are generally installed during the installation of the respective product and can be managed (for example, starting, stopping, or updating drivers) by the database or by the computer's operating system.
By default, Great Plains uses the ODBC drivers installed by Microsoft SQL Server or the Microsoft SQL Server Desktop Engine (MSDE) for desktop workstations. For other databases, each manufacturer's driver capabilities might vary.
The drivers read from and write to database tables. Of the data integration options that Great Plains provides, programming ODBC drivers is the most technically complex solution. Developers have direct low-level access to the database tables and must be experienced with database development.
For other data conversion options, see Integration Manager or Integration Assistant for Excel.
Related Tasks
- Reading Existing Data from Great Plains (Real-Time Integration)
- Reading Existing Data from Great Plains (Batch Integration)
- Writing Simple Data to Great Plains
Integration Assistant for Excel
Integration Assistant for Excel is an integration tool to convert and transfer data from Excel spreadsheets into Great Plains. Integration Assistant for Excel is intended for end-users and non-technical staff members as a simple method for transferring data from Excel. Users familiar and experienced with Excel will be comfortable with this tool's interface.
Advantages of Integration Assistant for Excel
The following table lists the advantages that Integration Assistant for Excel provides for converting and transferring data from Excel data sources.
Table 18.
| Benefit | Description |
|---|---|
| Ease of use | Integration Assistant for Excel incorporates standard Excel features and the standard interface. Users do not need to be developers or get additional training to use the tool. |
| Database knowledge is not required | Because the business logic is already defined, you do not need to understand database structures. |
| Minimal maintenance required for upgrades | After the integration is defined, the mappings and table formats have minimal changes between system upgrades. The object browser in Integration Manager simplifies ongoing maintenance. |
Skills Needed to Use Integration Assistant for Excel
End-users and developers can use the graphical interface of Integration Assistant for Excel to visually map data from one format to another.
Experienced developers can customize Integration Assistant for Excel. An understanding of database integration, specifically the Great Plains database structure, is helpful.
Capabilities of Integration Assistant for Excel
Integration Assistant for Excel allows users to use Excel to map data fields from the spreadsheet to the appropriate field of a Great Plains screen. Wizards are available to simplify this process. Users do not need to know either open database connectivity (ODBC) structures or the Great Plains system tables.
Integration Assistant for Excel includes the following wizards that simplify the conversion process:
- The Business Object Wizard is the standard means used to transfer information. As an alternative to manually creating the integration, this wizard provides a graphical interface for mapping data from Excel to Great Plains. The integration can be saved and shared with others.
- The Desktop Application Integration Wizard allows users with customized or specialized Excel spreadsheets to export data into Great Plains. Specifically, this allows custom Excel forms to be used with any Great Plains applications written in Dexterity. This wizard requires experience with programming in Excel and is recommended for Excel users who also have knowledge of the SanScript scripting language that is used by Dexterity.
If you require a more robust conversion tool or need to transfer data from sources other than Excel spreadsheets, see Integration Manager.
Related Tasks
- Writing Transactions and Master Records to Great Plains (Batch Integration)
Modifier with VBA
Modifier with VBA is a customization tool used to modify the appearance and functionality of any Great Plains window.
Advantages of Modifier with VBA
The following table lists the advantages that Modifier with VBA provides for modifying existing Great Plains applications.
Table 19.
| Benefit | Description |
|---|---|
| Simple for end-users | Modifier with VBA uses common graphics drawing techniques. These include using a tool palette, drawing or sweeping out new regions, and double-clicking an object to see its specific information. |
| Safe | Original information cannot be lost or overridden. The modified files are stored separately from the original files. |
| VBA and COM | Modifier with VBA uses VBA and COM technologies. This extends customization, data sharing, and the ability to access functionality among other applications. |
Skills Needed to Use Modifier with VBA
Modifier with VBA can be used by end-users and developers. End-users can use the graphical interface to make simple or cosmetic changes to the system. Experienced users can add or delete items such as windows, controls, or fields. No developer experience is required, although knowledge of Great Plains windows is helpful. Customizations can be saved and shared among other users.
Using advanced features or creating a complex integration requires development experience. A background with Great Plains, database maintenance, SQL commands, and a scripting language (such as VBA) is helpful.
Capabilities of Modifier with VBA
Modifier with VBA uses embedded VBA. Developers can add scripts, tools, and access to Microsoft Office objects to incorporate new levels of functionality into their applications. Modifier with VBA allows you to alter the appearance of the Great Plains application in multiple ways:
- Cosmetic changes can be made to individual windows, including the color, font, text, and graphics displayed within a window. For instance, you may need to display a logo on the screen or include a report in a format and font that is appropriate for printing. In addition, text can be changed. For instance, you could change the name of a menu item from "Financial" to "General Ledger."
- Information displayed within a window can be altered, moved, set to a default, deleted, or protected. This allows important information to be moved to a prominent position, and less important information to be de-emphasized or removed entirely. For instance, a technical support user may not need to see the customer's point of purchase location that a sales support user requires. In this case, you can remove the point of purchase information from only the technical support team's window. In a similar fashion, that point of purchase information could still be displayed but changed to a read-only field, because the technical support team may need to know that information but they should not be able to change it.
- New information or business logic can be added as the project evolves. This can include adding new fields or windows rather than just rearranging existing ones. For instance, you may need to limit the values that can be entered in fields or require permission for users to conduct transactions that exceed a preset monetary value.
Modifier with VBA is COM-compliant. Using this industry standard ensures that your applications can communicate with other applications such as Microsoft Office, other COM-compliant applications, or ActiveX objects. Common examples of ActiveX objects that you might want to integrate include bar code printers, credit card authorization controls, package tracking and cost calculators, and ZIP Code databases. They may be developed in-house or purchased through third parties.
To ensure data integrity, changes made with Modifier with VBA are saved as a separate file, apart from the system resources. In this way, the original information is protected from accidental modification. By providing separate files, individual users or groups of users can receive custom changes without affecting other users, compromising the underlying business logic, or endangering the accounting integrity.
Modifier with VBA does not create new applications as Visual Basic and C++ do. Instead, Modifier with VBA is designed to alter existing applications. Although it is a powerful tool for making modifications (to the point of adding new windows and fields), it is not recommended for creating new applications or for making changes that significantly alter the nature of the application. For example, do not use Modifier with VBA to transform an existing sales application into an accounts receivable application. It is better to design a new application. To create a new application, to modify a commercially available application for multiple locations, or to create a mass-marketed application, see Continuum API or Dexterity.
Related Tasks
- Rearranging Fields
- Adding Fields
- Changing the Properties of a Field
- Changing the Text Prompts
- Customizing the Business Logic
Dexterity
Dexterity is a development tool used to create or modify large-volume, transaction-based client/server applications that seamlessly integrate with Great Plains modules.
The Great Plains Integration Guide provides information about developing Dexterity applications that integrate with Great Plains. The Guide is included with Dexterity.
The Great Plains SDK documentation also includes information about the Dexterity-based procedures and functions that you can use to leverage the Great Plains business logic.
Advantages of Dexterity
The following table lists the advantages that Dexterity provides for custom application development.
Table 20.
| Benefit | Description |
|---|---|
| Common development environment | Dexterity is the same language that Great Plains was developed in. It consists of a full development environment created with C++, which allows you to integrate your custom modules with the standard Great Plains modules. |
| Extensible modules | With Dexterity, you can extend existing Great Plains modules. Dexterity implements changes by storing modifications in files separate from the system code. Individual users or user groups can change the application to suit their needs without interfering with other groups' customization requirements. |
| Easy creation of new vertical applications | You can use Dexterity to create new forms and tables and easily integrate them into the Great Plains user interface. |
Skills Needed to Use Dexterity
Extensive experience with software development is recommended. Dexterity is a complete development environment, and training is recommended. The following skills assist with development:
- An understanding of an application development environment such as Visual Basic or Microsoft Visual Studio.
- Knowledge of third-generation programming languages, such as C/C++ or Pascal.
- Experience using a scripting language such as Microsoft Visual Basic Scripting Edition (VBScript). Customizations made with Dexterity require the use of SanScript, a plain English scripting language.
- An understanding of network environments and client/server architecture.
The Great Plains SDK includes documentation and details about the integration points.
Capabilities of Dexterity
Dexterity is a development environment that provides you with the same complete set of components that were used to create Great Plains. It allows you access to all of the Great Plains resources such as screens, scripts, tables, and reports. In addition to Dexterity's native customization capabilities, you have access to the capabilities of Modifier with VBA when you use Dexterity. These features combined include graphical interface technologies, multiple-document interface (MDI) support, platform-native controls, background processing, and inter-application communications capabilities.
The programming environment includes a graphical editor to construct and arrange system components such as windows and controls. If you have used the graphical editor in Visual Basic or Visual Studio, you will be comfortable with the Dexterity programming environment. Development components include a forms builder, a database manager, an embedded macro system, and a scripting language and debugger. Dexterity supports embedded technologies such as COM and VBA.
The Dexterity scripting language is named SanScript and is the basis for all business logic in Great Plains. SanScript is a plain English language. The scripted procedures not only define actions but also define triggers that initiate actions. The wide range of triggers include database events, focus events (such as entering or leaving a field), and opening or restarting a form.
Dexterity achieves a high level of customization through the use of dictionary files. The dictionary files store the compiled windows code, control code, and the SanScript script. These files can be distributed to your system's users. The Great Plains system can load and run a virtually unlimited number of these dictionary files, and the system will run all of the appropriate procedures when an event is triggered. This multi-dictionary environment allows applications to be easily deployed to multiple sites or multiple customers. Using dictionary files protects the integrity of Great Plains. Systems can have dictionary files added or removed to provide the needed customization, but the original Great Plains source is never modified.
Dexterity can be used to create new or large applications, or to significantly modify an existing application. Dexterity provides a powerful foundation for large applications. It has direct access to call (but not view) Great Plains procedures and functions, has access to use all predefined tables and fields, and you can use it to set up triggers for new business logic or for information captures. For these reasons, Dexterity allows the most extensive changes among the various Great Plains development tools.
Related Tasks
- Developing a New Application
- Rearranging Fields
- Adding Fields
- Changing the Properties of a Field
- Changing the Text Prompts
- Customizing the Business Logic
- Reading Existing Data from Great Plains (Real-Time Integration)
- Reading Existing Data from Great Plains (Batch Integration)
- Subscribing to Changes within Great Plains
- Writing Simple Data to Great Plains
- Writing Transactions and Master Records to Great Plains (Real-Time Integration)
- Writing Transactions and Master Records to Great Plains (Batch Integration)
- Writing and Validating System Data
Great Plains SDK
The Great Plains software development kit (SDK) provides development documentation and detailed technical information about the Great Plains data formats. The resources in the SDK help you to produce products that integrate with Great Plains and to customize Great Plains components.
Advantages of the Great Plains SDK
The following table lists the advantages that the Great Plains SDK provides for custom application development.
Table 21.
| Benefit | Description |
|---|---|
| Consolidated source of information | The information required to integrate with the Great Plains data model is available in the Great Plains SDK. |
| Documented data model changes | The Great Plains SDK provides detailed information about database and procedural changes between product releases. |
Skills Needed to Use the Great Plains SDK
The information in the Great Plains SDK is intended to assist developers who are creating applications that integrate with Great Plains or who are customizing implementations of Great Plains. The information is technically detailed, and developers require extensive software development experience, database knowledge, and familiarity with their product's systems and business requirements.
Capabilities of the Great Plains SDK
The Great Plains SDK describes tables, data modeling, data formats, the creation of master and transaction records, and transaction posting flows. It is useful to developers who use customization and integration tools such as Modifier with VBA, the Continuum API, ODBC Drivers, and Dexterity. Users who are already familiar with the Great Plains development environment will find topics that describe changes from previous versions, including changes to the data model and to the Great Plains dictionary.
Some components will be useful only to Dexterity or Continuum API developers. These topics include documentation that describes changes in global procedures and functions, parameters for all procedures and functions, and changes to forms from various released versions. In those cases, that information is explicitly identified by notes such as "These topics are intended only for Dexterity developers."
Components of the Great Plains SDK
The SDK includes sections describing the following:
Table 22.
| Topic | Details Documented |
|---|---|
| Great Plains integration | Procedures and functions, table integration, warning messages, and dictionary changes. |
| ERwin models, a graphical model of the database | Provides ERwin models for the Great Plains modules. |
| Great Plains changes | Includes documentation describing database and procedural changes within Great Plains. |
Related Tasks
- Developing a New Application
- Reading Existing Data from Great Plains (Real-Time Integration)
Continuum API
The Continuum API is the Component Object Model (COM) application programming interface that is available for Great Plains. Tools that support COM automation, such as Microsoft Visual Basic for Applications, can use the Continuum API to interact with Great Plains.
Advantages of the Continuum API
The following table lists the advantages that the Continuum API provides for custom application development.
Table 23.
| Benefit | Description |
|---|---|
| Widely-used standard Microsoft technology | COM is an industry-standard technology. The Continuum API is a standard COM interface for the Great Plains application. |
| Extended integration | If you're a developer creating or modifying an application using a COM-compliant language, you can write your application so that it can interact with Great Plains using the Continuum API. |
Skills Needed to Use the Continuum API
Intermediate to advanced experience with software development is recommended. The following skills assist with development:
- An understanding of the COM-capable application development environment that you will be using, such as Visual Basic.
- An understanding of the Great Plains application and database structure.
- Experience with SanScript, the scripting language used to develop Great Plains.
A supplement that describes the SanScript language is included with the Continuum API documentation. Complete documentation and samples for SanScript are included with the documentation that ships with Dexterity. The Great Plains SDK includes documentation about Great Plains integration points.
Capabilities of the Continuum API
The Continuum API allows any applications written in a COM-compliant development environment to interact with the Great Plains application. The Continuum API allows three types of integration: interface, database, and process.
- Interface integrations: The integrating application interacts with or manipulates the user interface in Great Plains. Interface integrations are the simplest integrations to create.
- Database integrations: The integrating application reads from or writes to the Great Plains database, and can monitor database changes triggered by Great Plains. A thorough understanding of the Great Plains database is necessary to create database integrations. The Continuum API provides limited support for database integrations; therefore other integration methods might be more appropriate.
- Process integrations: The integrating application reacts to events from the Great Plains system, such as posting. Process integrations require a thorough understanding of the Great Plains application process that you are integrating with.
If you must make only minor changes to the Great Plains application, consider using Modifier with VBA instead of the Continuum API. To create new or large applications or to significantly modify the Great Plains application, use Dexterity.
Components of the Continuum API
The Continuum API in Great Plains can be used with any COM-compliant development environment such as Visual Basic .NET. The Continuum API Guide provides detailed information about the API. Sample applications demonstrate how the Continuum API can be used for integrations.
Related Tasks
- Developing a New Application
- Changing the Properties of a Field
- Customizing the Business Logic
- Reading Existing Data from Great Plains (Real-Time Integration)
- Reading Existing Data from Great Plains (Batch Integration)
- Subscribing to Changes within Great Plains Data
- Writing Simple Data to Great Plains
- Writing Transactions and Master Records to Great Plains (Real-Time Integration)
- Writing Transactions and Master Records to Great Plains (Batch Integration)
- Writing and Validating System Data
Business Portal SDK
The Business Portal software development kit (SDK) provides development documentation and detailed technical information about the Business Portal business components, query pages, Web Parts, and portal pages. The resources in the SDK help you to produce products that integrate with the Business Portal and to customize Business Portal components. See the Business Portal SDK for more information.
Advantages of the Business Portal SDK
The Business Portal SDK includes the information required to integrate with the Business Portal business components, query pages, Web Parts, and portal pages is available in the Business Portal SDK.
Skills Needed to Use the Business Portal SDK
The Business Portal SDK describes creating and using business entities, entity maps, entity associations, the Query Web Service, Web Parts, portal pages, and using security. The information in the Business Portal SDK is intended to assist developers who are creating applications that integrate with the Business Portal or who are customizing implementations of the Business Portal. The information is technically detailed, and developers require extensive software development experience, database knowledge, and familiarity with their product's systems and business requirements.
Capabilities of the Business Portal SDK
The SDK is for developers who use Microsoft Visual Studio .NET, the C# programming language, Rational XDE and its code generator, the Entity Relational Map Generator, and the Entity Association Map Generator for customizations and integrations. Users who are already familiar with the Business Portal development environment will find topics that describe changes from previous versions.
Components of the Business Portal SDK
The Business Portal SDK includes an Integration Guide, sample code, and information about the Great Plains object model.
The Integration Guide includes the following information:
- Introduces the Microsoft Business Framework.
- Describes how to create entities within business components.
- Describes how to create and use entity maps.
- Provides an overview of several Web Parts that can be created and displayed inside the Business Portal.
- Describes how Web Parts can communicate with one another.
- Provides an overview of how the Query Web Service is used in the Business Portal.
- Provides an overview of the various types of portal pages that you can create.
- Describes how security features should be implemented.
- Explains packaging Business Portal integrations for distribution so that they can be installed in other Business Portal installations.
- Explains how to provide online help support for your integration.
Related Tasks
- Developing a New Application
- Reading Existing Data from Great Plains (Real-Time Integration)