Oracle Application Modules

• ABM - Activity Based Management
• AD - Applications DBA
• AHL - Oracle Advanced Service Online
• AK - Oracle Common Modules-AK
• ALR - Oracle Alert
• AMF - Oracle Fulfillment Services
• AMS - Oracle Marketing
• AP - Oracle Payables
• AR - Oracle Receivables
• AS - Oracle Sales
• ASG - Oracle CRM Gateway for Mobile Services
• ASL - Oracle Mobile Field Sales Laptop
• ASO - Oracle Order Capture
• AST - TeleSales
• AX - Global Accounting Engine
• AZ - Application Implementation
• BEN - Oracle Advanced Benefits
• BIC - Customer Intelligence
• BIL - Sales Intelligence
• BIM - Marketing Intelligence
• BIS - Oracle Applications BIS
• BIX - Call Center Intelligence
• BNE - Oracle Web ADI
• BOM - Oracle Bills of Material
• BSC - Balanced Scorecard
• CCT - Oracle Call Center and Telephony
• CE - Oracle Cash Management
• CHV - Oracle Supplier Scheduling
• CLN - Supply Chain Trading Connector for RosettaNet
• CN - Oracle Sales Compensation
• CS - Oracle Service
• CSC - Customer Care
• CSD - Depot Repair
• CSE - Oracle Enterprise Install Base
• CSF - Field Service
• CSI - Install Base
• CSM - Oracle Field Service Palm
• CSP - Oracle Spares Management
• CSR - Oracle Scheduler
• CSS - Support
• CUG - Oracle Citizen Interaction Center
• CUN - Oracle Network Logistics NATS
• CZ - Oracle Configurator
• EAM - Oracle Enterprise Asset Management
• EC - Oracle e-Commerce Gateway
• ECX - Oracle XML Gateway
• EDR - Oracle E Records
• ENG - Oracle Engineering
• FII - Financials Intelligence
• FLM - Oracle Flow Manufacturing
• FND - Application Object Library
• FTE - Oracle Transportation Hub
• FV - Oracle Federal Financials
• GHR - Oracle Federal HR
• GL - Oracle General Ledger
• GMA - Oracle Process Manufacturing Systems
• GMD - Oracle Process Manufacturing Product Development
• GME - Oracle Process Manufacturing Process Execution
• GMF - Oracle Process Manufacturing Financials
• GMI - Oracle Process Manufacturing Inventory
• GML - Oracle Process Manufacturing Logistics
• GMP - Oracle Process Manufacturing Process Planning
• GMS - Oracle Grants Accounting
• GR - Oracle Process Regulatory Mgmt
• HRI - Human Resources Intelligence
• HXC - Oracle Time and Labor
• HXT - Oracle Time and Labor Rules
• IBA - iMarketing
• IBC - Oracle iContent
• IBE - iStore
• IBU - iSupport
• IBY - iPayment
• ICX - Oracle Self-Service Web Applications
• IEB - Oracle Interaction Blending
• IEC - Oracle Campaign Plus
• IEM - Oracle eMail Center
• IEO - Call Center Technology
• IES - Scripting
• IEU - Oracle Universal Work Queue
• IEX - Oracle Collections
• IGC - Commitment Administration
• IGF - Student Systems Fin Aid
• IGI - Oracle International Public Sector Financials
• IGS - Oracle Student Sytems
• IGW - Oracle Grants Proposal
• INV - Oracle Inventory
• IPD - Oracle Product Development Exchange
• ISC - Supply Chain Intelligence
• JTF - CRM Foundation
• JTM - Oracle CRM Mobile Foundation
• JTS - Oracle CRM Self Service Administration
• MRP - Oracle Master Scheduling/MRP
• MSC - Oracle Advanced Supply Chain Planning
• MSD - Oracle Demand Planning
• OFA - Oracle Assets
• OKC - Oracle Contracts Core
• OKI - Oracle Contracts Intelligence
• OKL - Oracle Lease Management
• OKR - Oracle Contracts for Rights
• OKS - Oracle Contracts Service Module
• ONT - Oracle Order Management
• OPI - Operations Intelligence
• OTA - Oracle Training Administration
• OZF - Funds & Budgets
• PA - Oracle Projects
• PAY - Oracle Payroll
• PER - Oracle Human Resources
• PJM - Oracle Project Manufacturing
• PN - Oracle Property Manager
• PO - Oracle Purchasing
• POA - Purchasing Intelligence
• POM - Oracle Exchange
• PON - Oracle Sourcing
• POS - Internet Supplier Portal
• PQH - Oracle Public Sector HR
• PSA - Public Sector Applications
• PSB - Oracle Public Sector Budgeting
• PSP - Oracle Labor Distribution
• PV - Partner Relationship Management
• QA - Oracle Quality
• QP - Oracle Pricing
• QRM - Oracle Risk Management
• RG - Application Report Generator
• RLM - Oracle Release Management
• VEA - Oracle Automotive
• WIP - Oracle Work in Process
• WMS - Oracle Warehouse Management System
• WSH - Oracle Shipping
• WSM - Shop Floor Management
• XDP - Oracle Provisioning
• XNC - Oracle Sales for Communications
• XNI - Oracle Install Base Intelligence
• XNP - Oracle Number Portability
• XNS - Oracle Service for Communications
• XTR - Oracle Treasury

Interface

• Interfaces are extensively used to integrate external system into oracle application
• It is used at the time of data migration

- data migration from external system into oracle application
- data migration from oracle application to external system

• It can also be used at the time of fresh installation of oracle application

TYPES OF INTERFACES

there are 2 main types of interfaces

1. INBOUND INTERFACE
these are used for transferring data from external system(legacy system) into oracle
application

2. OUTBOUND INTERFACE
these are used for transferring data from oracle application to external system.

There are 2 Distinct types of interfaces

1. OPEN INTERFACE
In this the logic is been provided by the oracle itself

OPEN INTERFACE LOGIC

• Data from the external file is transfered to the database table called as Interface table for that specific module.
• Then Validation are performed an that available data.
• Any error found are then transfered to the error table.
• Then the validated record are then transferred to the application tables.
  

2. CUSTOM INTERFACE
In this the logic has to be developed by the implementer.

For Interface we need A staging table

What is the need of a staging table or temporary table in between flat file and standard interface table while transferring data from flat file to interface table?

1.Once we have data in the interface table we are simply running the standard program and it automatically send data to the base table so in this time we can't do any validations in in between the interface table and base table that'y we use staging table to validate the data before putting into the interface table.Finally the staging tables are used to load the data from legacy systems what ever the client provided .after that we write a validation program to send proper valid data to interface table.

2.The basic need for a staging table is to serve as another step before loading into the interface tables after which we run oracle standard APIs to load them into the bas tables sometimes even after running APIS we may need some concurrent programmes to be run so for that data to be reflected across the base tables. The staging area serves for updates like date formats (MM-DD-RRRR) and other such critical data format changes neede before we load into interface tables and then running APIS in them . As explained above a bad file if formed while loading if some data format is not in consonance with the API or base file and hence the whole API/validation fails, In some case though it creates a corrupt log file which also indicates the failure of the validation.

3.These staging tables are used to hold temporary data i.e data with in the temporary table will be automatically get deleted when we issue commit or when we close oracle session that depends on how we create table

eg: create global temporary table eg1(name varchar2(20),num number(10)) on commit delete rows;

this will delete the rows on temporary table when we issue a commit at sql prompt.

moreover these staging tables are used to do some primray validations before inserting data into actual tables.

so we need data to be erased after inserting into acutal tables. so we go for staging tables.

we can use normal tables also as staging table but we need to truncate table for each insert. thats why we go for temporary tables.

What are Interface table in AP

1). AP_INTERFACE_CONTROLS.
2). AP_INTERFACE_REJECTIONS
3). AP_INVOICE_INTERFACE
4). AP_INVOICE_LINES_INTERFACE.

AR INTERFACE TABLE:

1). AR_PAYMENTS_INTERFACE_ALL
2). AR_TAX_INTERFACE
3). HZ_PARTY_INTERFACE
4). HZ_PARTY_INTERFACE_ERRORS
5). RA_CUSTOMERS_INTERFACE_ALL
6). RA_INTERFACE_DISTRIBUTIONS_ALL
7). RA_INTERFACE_ERRORS_ALL
8). RA_INTERFACE_LINES_ALL
9). RA_INTERFACE_SALESCREDITS_ALL

GL INTERFACE TABLE:

1). GL_BUDGET_INTERFACE
2). GL_DAILY_RATES_INTERFACE
3). GL_IEA_INTERFACE
4). GL_interface
5). GL_INTERFACE_CONTROL
6). GL_INTERFACE_HISTORY

EXAMPLE FOR INTERFACE TRY

ITEM UPLOAD INTERFACE

STEP1.

GO TO APPS AND CREATE STAGING TABLE

create table SG_ITEM_STAGE
(segment1 varchar2(25),
DESCRIPTION VARCHAR2(25),
TEMPLATE_NAME VARCHAR2(25),
MATERIAL_COST NUMBER,
PROCESS_FLAG NUMBER,
ENABLED_FLAG VARCHAR2(1),
TRANSACTION_TYPE VARCHAR2(25),
ORGANIZATION_CODE VARCHAR2(25))

STEP 2.

Create a SG_ITEM_DATA.dat File

SGTest Item51, SGTest Item11,Finished Good,100,
SGTest Item52, SGTest Item12, Finished Good, 500,
SGTest Item53, SGTest item13, Finished Good, 600,
SGtest Item54, SGTest Item14, Finished Good,300,

STEP 3.

Create a shri.ctl file (control file which contains the logic of uploading data from flat file to the stagging table)

LOAD DATA
INFILE '/apps/visappl/cust/11.5.0/bin/SG_ITEM_DATA.dat'
INTO TABLE SG_ITEM_STAGE
APPEND
FIELDS TERMINATED BY "," OPTIONALLY ENCLOSED BY '"'
(SEGMENT1,
DESCRIPTION,
TEMPLATE_NAME,
MATERIAL_COST,
PROCESS_FLAG CONSTANT 1,
ENABLED_FLAG CONSTANT 'Y',
TRANSACTION_TYPE CONSTANT 'Create',
ORGANIZATION_CODE CONSTANT "V1")

STEP 4.

UP LOAD CTL AND DAT FILE
FTP
TELNET

STEP 5.

CHECK DATA IN STAGING TABLE
select count(*) from
SG_STAGE_TABLE;

STEP 6.

CREATE PRE_INTERFACE TABLE AS INTERFACE TABLE

create table SG_ITEM_PRE_INTERFACE AS
select * from mtl_system_items_interface ;

STEP 7.

RUN THIS PROCEDURE TO UPLOAD DATA FROM STAGING TABLE TO PREINTERFACE
TABLE

STAGING TABLE---------------------------->PRE-INTERFACE TABLE

CREATE OR REPLACE Procedure SG_ITEM_PRE_INTERFACE Is
m_Segment1 varchar2(40);
m_Description varchar2(40);
M_TEMPLATE_NAME VARCHAR2(40);
M_MATERIAL_COST NUMBER;
M_PROCESS_FLAG NUMBER;
m_Transaction_Type varchar2(10);
m_Organization_CODE VARCHAR2(10);
M_ENABLED_FLAG VARCHAR2(1);
m_set_process_id number;
Cursor C1 is Select * from SG_STAGE_TABLE;
Begin
For rec in C1
loop
m_Segment1 := REC.SEGMENT1;
m_Description := REC.DESCRIPTION;
M_TEMPLATE_NAME := REC.TEMPLATE_NAME;
IF M_MATERIAL_COST>500 THEN
M_MaTERIAL_COST:=500;
END IF;
IF M_PROCESS_FLAG IN(2,3,4,5) THEN
M_PROCESS_FLAG:=1;
ELSE
M_PROCESS_FLAG:=REC.PROCESS_FLAG;
END IF;
M_MATERIAL_COST := abs(REC.MATERIAL_COST);
M_PROCESS_FLAG := REC.PROCESS_FLAG;
m_Transaction_Type := REC.TRANSACTION_TYPE;
m_Organization_CODE:= REC.ORGANIZATION_CODE;
M_ENABLED_FLAG := REC.ENABLED_FLAG;
m_set_process_id := 25101974;
Insert into
SG1_ITEM_PRE_INTERFACE
(
SEGMENT1,
DESCRIPTION,
TEMPLATE_NAME,
MATERIAL_COST,
PROCESS_FLAG,
TRANSACTION_TYPE,
ORGANIZATION_CODE,
ENABLED_FLAG,
SET_PROCESS_ID
)
values
(
m_Segment1,
m_Description,
M_TEMPLATE_NAME,
M_MATERIAL_COST,
M_PROCESS_FLAG,
m_Transaction_Type,
m_Organization_CODE,
M_ENABLED_FLAG,
M_SET_PROCESS_ID
);
End Loop;
End SG_ITEM_PRE_INTERFACE;
/

Compile & execute this procedure. After this check data is uploaded in the pre-interface
table.
EXEC SG_ITEM_PRE_INTERFACE;
SELECT COUNT(*) FROM SG1_ITEM_PRE_INTERFACE;

STEP 7.

TRANSFER DATA FROM
PRE-INTERFACE TABLE-------------------------->INTERFACE TABLE

CREATE OR REPLACE Procedure SG2_ITEM_INTERFACE Is
m_Segment1 varchar2(40);
m_Description varchar2(40);
M_TEMPLATE_NAME VARCHAR2(40);
M_MATERIAL_COST NUMBER;
M_PROCESS_FLAG NUMBER;
m_Transaction_Type varchar2(10);
m_Organization_CODE VARCHAR2(10);
M_ENABLED_FLAG VARCHAR2(1);
m_set_process_id number;
Cursor C1 is Select * from SG1_ITEM_PRE_INTERFACE;
Begin
For rec in C1
loop
m_Segment1 := REC.SEGMENT1;
m_Description := REC.DESCRIPTION;
M_TEMPLATE_NAME := REC.TEMPLATE_NAME;
M_MATERIAL_COST := REC.MATERIAL_COST;
M_PROCESS_FLAG := REC.PROCESS_FLAG;
m_Transaction_Type := REC.TRANSACTION_TYPE;
m_Organization_CODE:= REC.ORGANIZATION_CODE;
M_ENABLED_FLAG := REC.ENABLED_FLAG;
m_set_process_id := 25101974;
Insert into MTL_SYSTEM_ITEMS_INTERFACE
(
SEGMENT1,
DESCRIPTION,
TEMPLATE_NAME,
MATERIAL_COST,
PROCESS_FLAG,
TRANSACTION_TYPE,
ORGANIZATION_CODE,
ENABLED_FLAG,
SET_PROCESS_ID
)
values
(
m_Segment1,
m_Description,
M_TEMPLATE_NAME,
M_MATERIAL_COST,
M_PROCESS_FLAG,
m_Transaction_Type,
m_Organization_CODE,
M_ENABLED_FLAG,
M_SET_PROCESS_ID
);
End Loop;
End SG2_ITEM_INTERFACE;

EXEC SG_ITEM_PRE_INTERFACE;

SELECT COUNT(*) FROM SG1_ITEM_PRE_INTERFACE;

STEP 8.
Check the data
SELECT COUNT(*) FROM MTL_SYSTEM_ITEMS_INTERFACE;

STEP 9.
Log on to apps(mfg/welcome).
select ==>Inventory.
In Navigator ==> Items==>Import Items ==> Select master organisation

Overview of Coding Standards

Importance of these Standards

The coding standards described in this manual, together with the user
interface standards described in the Oracle Applications User Interface
Standards for Forms–Based Products, are used by Oracle Corporation
developers to build Oracle Applications. If you want to build custom
application code that integrates with and has the same look and feel as
Oracle Applications, you must follow these standards. If you do not
follow these standards exactly as they are presented, you may not
achieve an acceptable result.
This manual makes no attempt to analyze the consequences of
deviating from the standards in particular cases. The libraries and
procedures that are packaged with Oracle Applications all assume
adherence to these standards. In fact, since the behavior of Oracle
Forms, the Oracle Applications standard libraries, and the standards
are so tightly linked, a deviation from standards that appears to be
minor may in fact have far–reaching and unpredictable results.
Therefore, we recommend that when you develop custom application
code, you follow the standards exactly as they are described in this
manual and in the Oracle Applications User Interface Standards for
Forms–Based Products.

Coding Principles

Oracle Applications coding standards are guided by the following
principles:
• Code must be readable to be maintained
• Tools such as Oracle Forms and PL/SQL are used whenever
possible (avoid complex user exits using other coding languages)
• Fast performance over the World Wide Web (the web) is critical
• Platform–specific code should be avoided except where
absolutely necessary
• Reusable objects should be employed wherever possible

Coding With Handlers

Oracle Applications uses groups of packaged procedures, called
handlers, to organize PL/SQL code in forms so that it is easier to
develop, maintain, and debug.
In Oracle Forms, code is placed in triggers, which execute the code
when that trigger event occurs. Implementing complex logic may
require scattering its code across multiple triggers. Because code in
triggers is not located in one place, it cannot be written or reviewed
comprehensively, making development, maintenance, and debugging
more difficult. To determine what code and events affect a particular
item, a developer must scan many triggers throughout the form. Code
that affects multiple items can be extremely difficult to trace.
To centralize the code so it is easier to develop, maintain, and debug,
place the code in packaged procedures and call those procedures from
the triggers. Pass the name of the trigger as an argument for the
procedure to process. This scheme allows the code for a single
business rule to be associated with multiple trigger points, but to reside
in a single location.
There are different kinds of procedures for the different kinds of code
you write: item handlers, event handlers, table handlers, and business
rules. Code resides in these procedures; do not put any code in the
triggers other than calls to the procedures.
Handlers may reside in program units in the form itself, in form
libraries, or in stored packages in the database as appropriate.

Item Handlers

An item handler is a PL/SQL procedure that encapsulates all of the
code that acts upon an item. Most of the validation, defaulting, and
behavior logic for an item is typically in an item handler.

Event Handlers

An event handler is a PL/SQL procedure that encapsulates all of the
code that acts upon an event. Usually event handlers exist to satisfy
requirements of either Oracle Forms or the Oracle Applications User
Interface Standards for Forms–Based Products, as opposed to particular
business requirements for a product.

Table Handlers

A table handler encapsulates all of the code that manages interactions
between a block and its base table. When an updatable block is based
on a view, you must supply procedures to manage the insert, update,
lock and delete. Referential integrity checks often require additional
procedures. Table handlers may reside on either the forms server or
the database, depending on their size and the amount of interaction
with the database, but they typically reside in the database.

Business Rules

A business rule describes complex data behavior. For example, one
business rule is: ”A discount cannot be greater than 10% if the current
credit rating of the buyer is less than ’Good’.” Another business rule is:
”A Need–By Date is required if a requisition is made for an inventory
item.”
A business rule procedure encapsulates all of the code to implement
one business rule when the business rule is complex or affects more
than one item or event. The business rule procedure is then called by
the item or event handlers that are involved in the business rule. If the
business rule is simple and affects only one item or event, implement
the business rule directly in the item or event handler.

Libraries

Libraries contain reusable client–side code. They support these form
coding standards by allowing the same code to be used by all forms to
enforce specific validation, navigation and cosmetic behaviors and
appearances.
Libraries allow code to be written once and used by multiple forms.
Additionally, because the executables attach at runtime, they facilitate
development and maintenance without being invasive to a form.
Every form requires several standard triggers and procedures to link
the form with a library. Many of these triggers and procedures have a
default behavior that a developer overrides for specific items or blocks.

Application–Specific Libraries

Each application is strongly encouraged to create its own libraries.
Typically, each application creates a central library that governs
behaviors of objects found throughout many of its forms. Additional
libraries should be created for each major transaction form to facilitate
the following:
• Multiple developers can work on a single module, with some
developers coding the actual form and others coding the
supporting libraries.
• Shipment and installation of patches to code is vastly simplified
if the correction is isolated in a library. Libraries do not require
any porting or translation.
All libraries should reside in the $AU_TOP/resource directory (or its
equivalent).

Attaching Libraries

Sometimes library attachments can be lost on platforms that have
case–sensitive filenames. By Oracle Applications standards, library
names must be in all uppercase letters (except for the file extension).
However, for forms developed using Microsoft Windows, the library
filename may be attached using mixed case letters, making the
attachment invalid on case–sensitive platforms such as Unix. If you
attach a library to a form in the Oracle Forms Developer on Microsoft
Windows, you should avoid using the Browse mechanism to locate the
file. Instead, type in just the filename, in uppercase only, with no file
extension (for example, CUSTOM). Oracle Forms will then preserve
the attachment exactly as you typed it. Note that your attachment
should never include a directory path; your FORMS60_PATH should
include the directory that holds all your libraries.

Performance

Performance is a critical issue in any application. Applications must
avoid overloading the network that connects desktop client, server, and
database server computers, since often it is network performance that
most influences users’ perceptions of application performance.
Oracle Applications are designed to minimize network traffic on all
tiers. For example, they try to limit network round trips to one per
user–distinguishable event by employing the following coding
standards:

• Use database stored procedures when extensive SQL is required
• Code all non–SQL logic on the client side where possible
• Cache data on the client side where practical
• Base blocks on views that denormalize foreign key information
where practical


Coding for Web Compatibility

Following Oracle Applications standards carefully will help ensure that
your forms can be deployed on the Web.
You should avoid using the following features in your forms, as they
are not applicable in this architecture:
• ActiveX, VBX, OCX, OLE, DDE (Microsoft Windows–specific
features that would not be available for a browser running on a
Macintosh, for example, and cannot be displayed to users from
within the browser)
• Timers other than one–millisecond timers (one–millisecond
timers are treated as timers that fire immediately)
• WHEN–MOUSE–MOVE, WHEN–MOUSE–ENTER/LEAVE and
WHEN–WINDOW–ACTIVATED/DEACTIVATED triggers
• Open File dialog box
– It would open a file on the applications server, rather than
on the client machine (where the browser is) as a user might
expect
• Combo boxes
– Our standards do not use combo boxes anyhow
• Text_IO and HOST built–in routines
– These would take place on the applications server, rather
than on the client machine (where the browser is) as a user
might expect

The Standard Development Environment

These coding standards assume that you are developing code in the
appropriate Oracle Applications development environment, which
includes compatible versions of several products. You can ensure that
you have all the correct versions of the Oracle Applications and other
Oracle products by installing all products from one set of Oracle
Applications Release 11i CDs.
• Oracle Forms Developer 6i
• Oracle Reports Developer 6i
• Oracle Application Object Library Release 11i
• Oracle8i
• JInitiator
While you can develop forms using the standard Oracle Forms
Developer, you cannot run your Oracle Applications–based forms from
the Oracle Forms Developer. Running such forms requires additional
Oracle Application Object Library user exits referred to by the libraries,
as well as settings and runtime code that can only be seen when
running forms through a browser with JInitiator. Both the libraries and
the user exits also assume a full installation of the Oracle Application
Object Library database schema, as they reference tables, views, and
packages contained therein.

Mandatory Settings for Running Oracle Applications

The html file used to launch Oracle Applications must include several
specific settings for Oracle Applications to function properly. The
following table contains the required parameters and their required
values:
Name Value
colorScheme- blue
lookAndFeel -oracle
separateFrame- true
darkLook -true
readOnlyBackground- automatic
dontTruncateTabs- true
background- no

Additionally, the file OracleApplications.dat must contain the
following lines:
app.ui.requiredFieldVABGColor=255,242,203
app.ui.lovButtons=true
app.ui.requiredFieldVA=true
There are several variables that must be set correctly, either as Unix
environment variables or NT Registry settings, before starting up your
Forms Server for running Oracle Applications. These variables include
NLS_DATE_FORMAT. NLS_DATE_FORMAT must be set to
DD–MON–RR

Mandatory Settings for Form Generation

At form generation time, make sure you designate the character set
designed for your language in the NLS_LANG variable in your
Windows NT registry or environment file (for Unix). You must ensure
that the character set you specify is the character set being used for
your Oracle Applications installation.
You must also set the value of your FORMS60_PATH environment
variable in your environment file (or platform equivalent such as
Windows NT registry) to include any directory that contains forms,
files, or libraries you use to develop and generate your forms.
Specifically, you must include a path to the <$AU_TOP>/forms/US
directory to be able to find all referenced forms, and a path to the
<$AU_TOP>/resource directory to be able to find the Oracle
Applications library files you need (where <$AU_TOP> is the
appropriate directory path, not the variable).

Recommended Setting for Form Development

Oracle Forms Developer allows referenced objects to be overridden in
the local form. Oracle Forms Developer also does not normally
provide any indication that an object is referenced unless you set a
special environment variable (Registry setting for NT). Set the
environment variable (Registry setting) ORACLE_APPLICATIONS to
TRUE before starting Oracle Forms Developer. This setting allows you
to see the reference markers (little flags with an ”R” in them) on
referenced objects so you can avoid changing referenced objects
unintentionally. Any object referenced from the APPSTAND form must
never be changed.

Oracle Application Object Library for Release 11i

Oracle Application Object Library (AOL) for Release 11i includes
(partial list):
• Starting forms
– Template form with standard triggers (TEMPLATE)
– Form containing standard property classes for your runtime
platform (APPSTAND)
• PL/SQL libraries
– Routines for Flexfields, Function security, User Profiles,
Message Dictionary (FNDSQF)
– Standard user interface routines (APPCORE, APPCORE2)
– Routines for Calendar widget (APPDAYPK)
• Development standards
– Oracle Applications User Interface Standards for Forms–Based


Setting Object Characteristics

The characteristics of most form objects, including modules, windows,
canvases, blocks, regions, and items may be set in the following ways:
• Inherited through property classes, which cause certain
properties to be identical in all forms (such as canvas visual
attributes)
• At the discretion of the developer during form design (such as
window sizes)
• At runtime, by calling standard library routines (such as window
positions)

Shared Objects
These standards rely extensively on the object referencing capabilities
of Oracle Forms. These capabilities allow objects to be reused across
multiple forms, with changes to the master instance automatically
inherited by forms that share the object. Additionally, these shared
objects provide flexibility for cross–platform support, allowing Oracle
Applications to adhere to the look and feel conventions of the platform
they run on.
APPSTAND Form
The APPSTAND form contains the master copy of the shared objects.
It contains the following:
• Object group STANDARD_PC_AND_VA, which contains the
Visual Attributes and Property Classes required to implement
much of the user interface described in the Oracle Applications
User Interface Standards for Forms–Based Products. A property
class exists for almost every item and situation needed for
development.
• Object group STANDARD_TOOLBAR, which contains the
windows, canvasses, blocks, and items of the Applications
Toolbar. This group also contains other items which are required
in all forms but are not necessarily part of the Toolbar.
• Object group STANDARD_CALENDAR, which contains the
windows, canvasses, blocks, and items of the Applications
Calendar.
Object group QUERY_FIND, which contains a window, canvas,
block, and items used as a starting point for coding a Find
Window. This object group is copied into each form, rather than
referenced, so that it can be modified.

TEMPLATE Form

The TEMPLATE form is the required starting point for all development
of new forms. It includes references to many APPSTAND objects,
several attached libraries, required triggers, and other objects.
Start developing each new form by copying this file, located in
$AU_TOP/forms/US (or your language and platform equivalent), to a
local directory and renaming it as appropriate. Be sure to rename the
filename, the internal module name, and the name listed in the call to
FND_STANDARD.FORM_INFO found in the form–level PRE–FORM
trigger.

FNDMENU

The Oracle Applications default menu (with menu entries common to
all forms, such as File, Edit, View, Help, and so on) is contained in the
$AU_TOP/resource/US directory (or its equivalent) as the file
FNDMENU. You should never modify this file, nor should you create
your own menu for your forms.

Standard Libraries

Application Object Library contains several libraries that support the
Oracle Applications User Interface Standards for Forms–Based Products:

• FNDSQF contains packages and procedures for Message
Dictionary, flexfields, profiles, and concurrent processing. It also
has various other utilities for navigation, multicurrency, WHO,
etc.

• APPCORE and APPCORE2 contain the packages and procedures
that are required of all forms to support the menu, Toolbar, and
other required standard behaviors. APPCORE2 is a
near–duplicate of APPCORE intended for use with the CUSTOM
library.

• APPDAYPK contains the packages that control the Applications
Calendar.

• APPFLDR contains all of the packages that enable folder blocks.

• VERT, GLOBE, PSAC, PQH_GEN, GHR, JA, JE, and JL exist to
support globalization and vertical markets. These libraries are
for Oracle Applications use only and may not be attached to
custom forms. However, they appear to be attached to most
forms based on the TEMPLATE form because they are attached
to the APPCORE library or other standard libraries.

• CUSTOM contains stub calls that may be modified to provide
custom code for Oracle Applications forms without modifying
the Oracle Applications forms directly.

The TEMPLATE form includes attachments to the FNDSQF, APPCORE
and APPDAYPK libraries. Other standard Oracle Applications libraries
are attached to those libraries and may appear to be attached to the
TEMPLATE form.


Property Classes

Property classes are sets of attributes that can be applied to almost any
Oracle Forms object. The TEMPLATE form automatically contains
property classes, via references to APPSTAND, that enforce standard
cosmetic appearances and behaviors for all widgets and containers as
described in the Oracle Applications User Interface Standards for
Forms–Based Products.

Application–specific Property Classes, Object Groups and Objects
Each application should take advantage of the referencing capabilities
of Oracle Forms to help implement standards for their particular
application in the same manner as APPSTAND.
For example, the General Ledger application might have specified
standard widths and behaviors for ”Total” fields throughout the
application. A GL_TOTAL Property Class, referenced into each form,
could set properties such as width, format mask, etc. A General
Ledger developer, after referencing in this set of property classes, can
then simply apply the GL_TOTAL property class to each item in the
form that is a Total field and it inherits its standard appearance and
behavior automatically. Entire items or blocks can also be reused.
Further, property classes can be based on other property classes, so the
GL_TOTAL class could be based on the standard TEXT_ITEM_
DISPLAY_ONLY class in APPSTAND. Such subclassing allows the
application–specific object to inherit changes made within APPSTAND
automatically.
Most Oracle Applications products also have a ”standard” form
(typically called [Application short name]STAND, such as GLSTAND
or BOMSTAND) in the same directory if you install the development
versions of those products. These files are used for storing
application–specific object groups, property classes, and other objects
that are referenced into Oracle Applications forms.

Visual Attributes

All of the visual attributes described in the Oracle Applications User
Interface Standards for Forms–Based Products are automatically included
in the TEMPLATE form via references to APPSTAND. Each visual
attribute is associated with a property class or is applied at runtime by
APPCORE routines.
For detailed information about the specific color palettes and effects of
the visual attributes, see the Oracle Applications User Interface Standards
for Forms–Based Products.

Overview of Application Development Steps

This is the general process of creating an application that integrates
with Oracle Applications.
1. Register your application.
2. Set up your application directory structures.
3. Modify the appropriate environment files.
4. Register your custom Oracle schema.
5. Include your custom application and Oracle schema in data
groups.
6. Create your application tables and views.
7. Integrate your tables and views with the Oracle Applications APPS
schema.
8. Register your flexfields tables.
9. Build your application libraries and forms.
10. Build your application functions and menus.
11. Build your application responsibilities.
12. Build concurrent programs and reports.
13. Customize Oracle Applications forms if necessary using the
CUSTOM library.

Overview of Form Development Steps

This is the general process of building a form that integrates with
Oracle Applications.
1. Copy the form TEMPLATE and rename it.
2. Attach any necessary libraries to your copy of TEMPLATE.
TEMPLATE comes with several libraries already attached.
3. Create your form blocks, items, LOVs, and other objects and apply
appropriate property classes.
4. Create your window layout in adherence with the Oracle
Applications User Interface Standards for Forms–Based Products.
5. Add table handler logic.
6. Code logic for window and alternative region control.
7. Add Find windows and/or Row–LOVs and enable Query Find.
8. Code logic for item relations such as dependent fields.
9. Code any messages to use Message Dictionary.
10. Add flexfields logic if necessary.
11. Add choices to the Special menu and add logic to modify the
default menu and toolbar behavior if necessary.
12. Code any other appropriate logic.
13. Test your form by itself.
14. Register your form with Oracle Application Object Library.
15. Create a form function for your form and register any subfunctions.
16. Add your form function to a menu, or create a custom menu.
17. Assign your menu to a responsibility and assign your responsibility
to a user.
18. Test your form from within Oracle Applications (especially if it
uses features such as user profiles or function security).

Getting Help

Oracle Applications provides you with a complete online help facility.
Whenever you need assistance, simply choose an item from the Help
menu to pinpoint the type of information you want.



To display help for a current window:
1. Choose Window Help from the Help menu, click the Help button
on the toolbar, or hold down the Control key and type ’h’.

Example

A web browser window appears, containing search and navigation
frames on the left, and a frame that displays help documents on the
right.
The document frame provides information on the window
containing the cursor. The navigation frame displays the top–level
topics for your responsibility, arranged in a tree control.
2. If the document frame contains a list of topics associated with the
window, click on a topic of interest to display more detailed
information.
3. You can navigate to other topics of interest in the help system, or
choose Close from your web browser’s File menu to close help.
Suppose you are using Oracle General Ledger and are in the Define
Budget Organization window. You want to know how to create a
budget organization using this window. Choose Window Help from
the Help menu to display a help on this topic.
 To display online help for any of the Oracle Applications products:
1. Choose Oracle Applications Library from the Help menu.
A web browser window appears, containing search and navigation
frames on the left, and a document frame on the right.
2. In the navigation frame, click on the name of a product family to
display a list of products in that family. Click on a product name to
display the list of top–level topics in that product’s online
documentation.
3. Click on a topic of interest. Topics preceded by a plus sign (+)
expand to show subtopics. Help on the topic displays in the
document frame.
4. To collapse sections of the tree you previously expanded, click on
topics preceded by a minus sign (–).
5. When you are finished, choose Close from the web browser’s File
menu to close help.
Note: A topic called ”Library” and topics corresponding to
other products and product families are often included on the
navigation tree associated with a particular responsibility.
These topics function in a fashion similar to the Library tree
described here.
1 – 26 Oracle Applications User’s Guide
 To display version information for Oracle Applications:
1. Choose About Oracle Applications from the Help menu.
2. An About Oracle Applications window appears on your screen.
The window provides details about the version of the Oracle
Applications components you are using, your login information,
and information about the current form you are using.
You can supply this information to your system administrator or to
Oracle Customer Support if you need to report a problem.
3. Choose OK to close this window.


Searching for Help

You can perform a search to find the Oracle Applications help
information you want. Simply enter your query in the text field located
in the top–left frame of the browser window when viewing help, then
click the adjacent Find button.
A list of titles, ranked by relevance and linked to the documents in
question, is returned from your search in the right–hand document
frame. Click on whichever title seems to best answer your needs to
display the complete document in this frame. If the document doesn’t
fully answer your questions, use your browser’s Back button to return
to the list of titles and try another.
The search syntax to use in constructing your query can be any of those
shown in the following table.

Use this syntax . . . To find files containing . . .
term the word ”term”
string* words that begin with ”string”
”words, and punctuation” the precise phrase ”words, and punctuation”
term1 OR term2 either term1 or term2
term1 term2
term1 AND term2 both term1 and term2
term1 +term2
term1 AND NOT term2 term1, but not term2
term1 –term2

Using Keyboard Shortcuts

Experienced Oracle Applications users can access the menu by using a
keyboard shortcut, a specific combination of keystrokes that performs the
same function as a corresponding menu item. Oracle Applications
assigns many commonly used functions, such as Run Query, Save, or
Clear Record to keyboard shortcuts.
You can display a list of the keyboard shortcuts that map to your
computer terminal’s keyboard at any time.
Note: Rather than list the actual keys for a keyboard shortcut,
we refer to keyboard shortcuts in this guide using the format
[Function] where Function represents the function that the
keyboard shortcut performs.
 To display a list of keyboard shortcuts:
1. Choose Keyboard Help... from the Help menu.



2. When you finish scrolling through the listing, choose OK to close
the window.
Most window buttons are also mapped to keyboard shortcuts. The
shortcut key is indicated with an underline in the button label. For
example, in the Request Summary window, the button label Hold
Request has the ”H” underlined. This indicates that you can use the
keyboard shortcut Alt–H to put a request on hold instead of using the
mouse.

Using Menus

Oracle Applications use a Multiple Document Interface (MDI). All
windows are displayed inside a single container window, with a single
toolbar, menu, message line, and status line attached to that window.
Pulldown Menu
The pulldown menu bar includes the following menus:
• File
• Edit
• View
• Folder
• Tools
• Special A & B (only visible when active)
• Window
• Help
Use these menus to navigate through a form, to edit or retrieve data, or
to perform various other actions.
See Also
Oracle Applications Pulldown Menu Bar: page A – 2
Right Mouse Button Menus
In addition to the Pulldown menu, using the right mouse button allows
you to access the following menu items:
• Cut
• Copy
• Paste
• Folder Menu
• Help

Changing Your Security Access

If you have several responsibilities and you want to work in Oracle
Applications under a different responsibility, you can do so without
exiting Oracle Applications.
You can also change the password to your user sign–on at any time.
Your system administrator may require all users to periodically change
their passwords to maintain better security to Oracle Applications.
 To switch your responsibility:
1. Click in the Navigate window or choose Navigator from the
Window menu to make the Navigate window active.
2. Choose Switch Responsibility from the File menu.
If there are windows still open in your current responsibility,
Oracle Applications asks you to save your changes, if there are any,
before it closes those windows. You may cancel switching
responsibilities by choosing Cancel in the save changes window.
Note: The save changes window only appears if there are any
changes to save. If there are no changes to save, all open windows
other than the Navigate window close, and Oracle Applications
displays your responsibility list.
Note: If you have only one responsibility, the Switch Responsibility
menu item is disabled.
3. Select a new responsibility from the Responsibilities window and
choose OK.
The Navigate window title and contents then update to reflect the
new responsibility you chose.
 To change your password:
1. Click in the Navigate window or choose Navigator from the
Window menu to make the Navigate window active.
2. Choose Change Password... from the Edit, Preferences menu, to
display the Password Update window.



3. Enter your old password in the Old Password field.
4. Enter your new password in the New Password field.
5. Enter your new password again in the Re–enter New Password
field.
6. Choose OK.
If the second entry of your new password does not match your
first, Oracle Applications asks you to re–enter your new password
again, until both entries match. Your new password takes effect
immediately.
Note: If you change your mind and do not want to alter your
password, choose Cancel to close the Password Update window.

Opening a Form from the Navigator Window

The Navigator consists of three regions: Functions, Documents, and
Processes. The Functions region provides a list of forms displayed like
the files in a file system, the Documents region is a customizable region
that allows you to create links to specific documents that you use frequently,
and the Processes region provides graphical maps of
business processes, allowing you to automate business flows across
forms.

Getting Started in Oracle Applications

To log on to Oracle Applications:
1. Enter your username in the User Name field.
Attention: Do not press [Enter] after entering each item, as [Enter]
is normally used to accept the default button. Instead, use [Tab] or
the mouse to navigate between fields.
2. Enter your password in the Password field.
3. Choose Connect.
Notice your password does not appear as you type it, to prevent
others from seeing it. Keep your password confidential to prevent
access to Oracle Applications by unauthorized users.



From the main tab on your personal homepage you can access a
list of links to your responsibilities.
A responsibility is a level of authority in Oracle Applications that lets
you access only those Oracle Applications functions and data
appropriate to fulfill your role in an organization. Each responsibility
allows access to:
• A specific application or applications, such as Oracle General
Ledger or Oracle Planning.
• A set of books, such as U.S. Operations or German Sales or an
organization, such as New York Manufacturing or New York
Distribution.
• A restricted list of windows that you can navigate to; for
example, a responsibility may allow certain Oracle Planning
users to enter forecast items, but not enter master demand
schedule items.
• A restricted list of functions you can perform. For example, two
responsibilities may have access to the same window, but one
responsibility’s window may have additional function buttons
that the other responsibility’s window does not have.
• Reports in a specific application; your system administrator can
assign groups of reports to one or more responsibilities, so the
responsibility you choose determines the reports you can submit.
Each user has at least one responsibility and several users can share the
same responsibility.

Two Types of Responsibilities
The Navigate region may contain links to Self–Service Web applications
as well as Forms–based applications. Forms–based responsibilities
launch Oracle Applications Forms.
For information about Oracle Self–Service Web Applications, see
Personal Homepage in Oracle Self–Service Web Applications: page
B – 2.
You will see a link for each responsibility assigned to you.

To choose a Forms–based responsibility:
Simply click on a link in the Navigate region of your Personal
Homepage. Doing this will open the Oracle Applications
Navigator window for the responsibility you have chosen.
For more information about the Navigator Window, see Opening a
Form from the Navigator Window: page 1 – 10.
Note: If your system administrator assigns you just one
Forms–based responsibility with no other options on your
homepage, your responsibility will launch when you sign on.
If you are assigned one Self–Service responsibility with many
functions, and you have no other options on your personal
homepage, your responsibility’s list of functions will display as
if you had clicked the link.
If you are assigned one Self–Service responsibility with just one
function, and you have no other options on your personal
homepage, your function will launch automatically when you
sign on.

Setting your Preferences through the Personal Homepage
There are several choices you can make about how you want to view
information in Oracle Applications. These choices include languages,
date formats, and number formats.
To access your preferences, choose the Preferences link in the Favorites
region of your personal homepage.
 To select your language
• Click on the drop down list labeled ”Language.”
• Select the language in which you prefer to work. You will see
screens, reports, and some data in the language you choose.
 To select your date format
• Click on the drop down list labeled ”Date Format.”
• Select the format in which you would like to view dates.
 To select your number format
• Click on the drop down list labeled ”Number Format”
• Select the format in which you would like to view numbers.
Attention: Currently only the US number format is
recognized in Oracle self–service applications.
For information about Oracle Self Service Web Applications, see
Personal Homepage in Oracle Self–Service Web Applications: page
B – 2.

Overview of Oracle Applications

Oracle Applications is a tightly–integrated family of application
products that share a common look and feel. Using the menus and
windows of Oracle Applications, you have access to all the functions
you need to manage your business information.
Oracle Applications is highly responsive to users, supporting a
multi–window graphical user interface (GUI) that provides you with
full point–and–click capability. You can use your mouse or keyboard to
operate graphical controls such as pull–down menus, buttons, poplists,
and check boxes.
In addition, Oracle Applications offers many other features such as
field–to–field validation and list of values to help you simplify data
entry and maintain the integrity of the data you enter.
The best way to familiarize yourself with the common look and feel of
Oracle Applications products is to log in and use the products. This
chapter describes how to get started with Oracle Applications and
provides you with the basic information you need to explore Oracle
Applications in greater depth.

Basic Business Needs

Oracle Applications provides you with features you need for your
business. With Oracle Applications you can:
• Learn how to use the system quickly. Oracle Applications uses
familiar and easy–to–use menus so you, your staff, and your new
employees can be productive after a few minutes of coaching
from a colleague.
• Be productive even if you are a novice user. A simple, intuitive
graphical user interface (GUI) lets you use all of the power of
Oracle Applications.
Getting Started 1 – 3
• Increase your productivity as a power user. When you become
familiar with Oracle Applications, you can use shortcuts in the
graphical user interface to quickly navigate and work with
multiple windows at once.
• Get help when you need it. Context–sensitive online help is
always available whenever you need assistance.
• Secure your application data from unauthorized access. You
can control access to your application data and customize the
windows available for each user based on that user’s level of
authority

Basic GUI Terminology
Before using Oracle Applications, you should familiarize yourself with
the specifics of your GUI environment and how to perform basic tasks,
such as using a menu or selecting an item. In doing so, you should
come across and become familiar with the following generic terms:

desktop - The part of your computer monitor that displays
information and where your work takes place.
This is also referred to as your screen.

window - A box around a set of related information on your
desktop

menu - A list that appears in a bar across the top of a
window that consists of commands or actions you
can perform.

click - Quickly press and release a mouse button while the
mouse pointer is on a particular item.

double–click - Rapidly click a mouse button twice while the
mouse pointer is on a particular item.

drag - Move the mouse while holding down a mouse
button.

select - Mark an item. Examples include highlighting text,
or clicking on a value from a list.

choose - Select an item and initiate the action associated
with the item. Examples include choosing a menu
item or choosing a button.

scroll bar - A vertical or horizontal bar that appears on a
window whose contents are not entirely visible.

Starting Oracle Applications
To start Oracle Applications, you need to:
• Start up your computer system
• Start your Web Browser
• Start the Oracle Applications program
• Log on to Oracle Applications
• Choose a responsibility (if necessary)
• Navigate to an application window (if necessary)

Starting and Logging On
The first step in starting Oracle Applications is to enter the appropriate
URL for your site in an Oracle Applications certified browser.
After starting Oracle Applications, the first window you see is the
sign–on window.

Preface

Information Sources
You can choose from many sources of information, including online
documentation, training, and support services, to increase your
knowledge and understanding of Oracle Applications.
If this guide refers you to other Oracle Applications documentation,
use only the Release 11i versions of those guides unless we specify
otherwise.

Online Documentation
All Oracle Applications documentation is available online (HTML and
PDF). The technical reference guides are available in paper format
only. Note that the HTML documentation is translated into over
twenty languages.
The HTML version of this guide is optimized for onscreen reading, and
you can use it to follow hypertext links for easy access to other HTML
guides in the library. When you have an HTML window open, you can
use the features on the left side of the window to navigate freely
throughout all Oracle Applications documentation.
• You can use the Search feature to search by words or phrases.
• You can use the expandable menu to search for topics in the
menu structure we provide. The Library option on the menu
expands to show all Oracle Applications HTML documentation.
You can view HTML help in the following ways:
• From an application window, use the help icon or the help menu
to open a new Web browser and display help about that window.
• Use the documentation CD.
• Use a URL provided by your system administrator.

User Guides Related to All Products
Oracle Alert User Guide
Use this guide to define periodic and event alerts that monitor the
status of your Oracle Applications data.
Oracle Applications Implementation Wizard User Guide
If you are implementing more than one Oracle product, you can use the
Oracle Applications Implementation Wizard to coordinate your setup
activities. This guide describes how to use the wizard.
Oracle Applications Developer’s Guide
This guide contains the coding standards followed by the Oracle
Applications development staff. It describes the Oracle Application
Object Library components needed to implement the Oracle
Applications user interface described in the Oracle Applications User
Interface Standards for Forms–Based Products. It also provides
information to help you build your custom Oracle Developer forms so
that they integrate with Oracle Applications.
Oracle Applications User Interface Standards for Forms–Based
Products
This guide contains the user interface (UI) standards followed by the
Oracle Applications development staff. It describes the UI for the
Oracle Applications products and how to apply this UI to the design of
an application built by using Oracle Forms.

CRM CONTRACTS CORE

Oracle Contracts Core

The Contracts Core module acts as a central repository for the collection and dissemination of contract information. It contains all data on terms and conditions, deliverables, and parties to the contracts. This repository is the key to provide a single source for all the information in any contract in your enterprise.

You can author, execute and control non-industry specific contracts with Contracts Core, for both buy and sell contracts. It helps companies manage internal and external obligations, control daily deliverables, and be focused on contractual goals.

Contract Phases

Authoring

Enables you to create, define, modify, and approve the contract. By using Contracts core/ service you can author and original buy or sell contract, define a contract from a template, or copy another contract. Business rules can be set up to force contracts to go through an approval process to ensure that the contracts are accurate and satisfactory.

Execution

Enables you to review deliverables schedule revisions, communications, and sales information such as quotes or orders. During execution you can track the deliverables and tasks. Communications between parties can be recorded and become part of the contract. Rule are also used to execute a contract, enforcing such things as ship-to and bill-to address, ship method, freight terms and pricing information.

Administration

Enables you to perform contract management such as change requests, renew/ extend/ terminate, copy contract, and so on. Change requests are a formal way of documenting the changes to a contract. You can submit a change request to initiate a contract change. After the change request is approved, the contract can be changed.

Authoring Flow

1. The customer and the vendor discuss the options.

2. The contracts administrator creates the new contract, by using a template, the copy function, and so on.

3. The contracts administrator authors the contract.

4. The contract is submitted for online quality assurance check to make sure that all information is accurate and complete.

5. The contracts administrator submits the contract to the manager for approval.

6. The contract manager approves the contract.

7. The contracts administrator sends the contract to the customer who then approves and signs it.

8. The contract administrator signs the contract.

9. Once the vendor and the customer have signed the contract, the contract becomes active and the customer is delivered the contract items according to the terms and conditions of the contract.

The Contracts Core / Sales (OKC/OKO) business flow:

1. Generate Lead: In Telesales or sales Online a sales representative cerates and qualifies a lead for an existing customer or a prospect for certain items.

2. Create Opportunity: As soon as the lead gets more qualified, the sales representative creates an opportunity in Telesales or Sales online.

3. Create Quote: The customer agrees with the conditions, a quote is created in the quoting module.

4. Create Contract: Based on the data in the quote and the negotiated terms and conditions a contract is created.

5. Renew Lines and Terms & Conditions: The contract administrator might review and verify the entered contract lines and terms & conditions.

6. Approve and Sign Contract: After the contract is accepted, the contract administrator will start the approval process and the administrator’s manager will approve the contract.

7. Active Contract: After the approval process passed successfully the contract has the status ‘Active’.

8. Create Sales Order: Based on the active contract a sales order can be created automatically.

9. Renewal Process: Prior or after the contract expiration a renewal process can be started.

CONTRACT BUNDLING

	Contract Integration Layer (OKX)

Oracle Contracts Integration (OKX)

OKX is a layer of integration that allows contracts applications (OKC, OKO, and OKS) to interface to external applications in both ERP and CRM.

Integration to ERP Modules

General Ledger (GL), Human Resources (PER), Purchasing (PO), Order Management (ONT), Payables (AP), Pricing (QP), Configurator (CZ), Inventory (INV), Receivables (AR).

Integration to CRM

1. Interaction History: - Data pulled includes resources, actions and outcomes. The interaction history feature tracks all interactions between contract parties and serves as a repository for the interaction data. An interaction is a point of contact and may relate to parties, orders, quotes and so on.
2. Task Manager: - Data pulled includes resources, roles and task status. This information is uses when assigning tasks for specific contract deliverables.
3. Resources Manager: - Data pulled includes resources, roles and categories. This information is used when defining parties.
4. Telesales (AST)
5. Quoting (ASO)