Processing-Context-In: Start here

What is a Processing-Context-In?

To understand the role of a Processing-Context-In,
it is useful to remember the processing sequence in AccountingIntegrator Enabler
and the concepts involved:

All Input-Events
stem from Financial-Events. An Input-Event comprises a set of segments
in a specific structure.

The principal role
of AccountingIntegrator Enabler is to transform each of the input segments contained
in an Input-Event into one or more output segments, that is, Output-Events.

AccountingIntegrator Enabler
sends the Output-Events to the Processing-Context-Outs.

Each Processing-Context-Out
can specify that the Output-Events assigned to it must undergo an additional
set of checks (for example, balancing checks) or processes (for example
auditing or aggregation).

To ensure AccountingIntegrator Enabler correctly processes a set of Input-Events
in a transformationsession,
you need to set the execution context.
It is the role of the Processing-Context-In
to set this execution context by defining the characteristics of the processing
to apply at the following levels:

For Events, the Processing-Context-In defines the following information
required by the transformation session:

Which Input-Event to process and in which
input segment to find this information

Which version of the Input-Event to use
for the processing and in which segment to find this information

The name of the segment types processed
and in which segment to find this information

Which input segment contains the instance
code

Which date to use as the DAR, that is
either the operating date or a date specified in the segments to process

For Functions, the Processing-Context-In defines whether any of the following processes
are activated:

Aggregation

Balancing

Reversal
Accounting

Group
management, and if so in which input segment the Group code is located

Phase
recycling

Auditing,
and if so, what stamping method to use and in which field to write the
stamping code

For Output-Events, the Processing-Context-In defines the following information
required by the transformation session:

Which Output-Event field contains the
Processing-Context-Out code

Whether the Output-Event or the Processing-Context-Out
identifies the names of the Aggregation-, Balancing- and Audit-Rules to
use.

In addition the Processing-Context-In sets the characteristics of the
tuning to apply during the processing operation:

For Controls
and optimizations, the Processing-Context-In defines whether the session runs additional checks
and optimizations. For example, checking:

the integrity
of numeric fields

that
at each Input-Event or Rule produces at least one Output-Event

For Errors, the Processing-Context-In defines whether the session stops if it produces
more than a certain amount of errors.

For Exits, the Processing-Context-In defines whether external exits are to be introduced
into the session.

The AccountingIntegrator EnablerRule Engine implementation script reads these parameters
to configure the Processing-Context-In.

For more information, refer to the AccountingIntegrator Reference Guide

Where is a Processing-Context-In?

Axway module:

AccountingIntegrator Enabler

Workbench:

Integration-Services: Finance tab

Object dependencies:

When
you define or import an object, it is stored in the metadata repository
and is available for reuse by other objects. Typically, the objects that
you define exist in a specific object hierarchy. That is, objects:

use objects below them in the hierarchy

are used by objects above them
in the hierarchy

To help you manage the interlinked network
of objects, the software provides the Object Dependencies Browser that
displays the object dependencies for a selected object.

The link between the Processing-Context-In and the Input-Event
is a reference and not a hard-wired link in the database. This means that any life-cycle operations you execute on the Input-Event
are not automatically cascaded to include the associated Processing-Context-In
object, and vice versa. Instead, you must execute the life-cycle
commands separately on the Processing-Context-In object associated with
the Input-Event.