Google has deprecated legacy versions of AutoML services, which directly impacts IDP's core functionality. Additionally, the IDP application was deprecated with Appian 23.2. Customers who wish to use the application will need to refactor plug-ins using AutoML. |
In the Intelligent Document Processing (IDP) application, a document channel is a grouping of document types that have their own security settings. For example, you might need to process documents for Finance and Legal teams. The Finance team will need to process financial documents such as invoices and purchase orders, while the Legal team will need to process legal documents such as partnership applications and statements of work. They will likely not want users from other teams to see the documents they are processing, as they may contain sensitive information. IDP is flexible enough to allow you to add document channels so that each team can have its own document types and security.
IDP comes with a Standard document channel, but we've made it easy to introduce more document channels. This page provides instructions for adding additional document channels so that you can tailor the security and document types for different teams. This consists of:
If you want to add a new document type to an existing document channel, refer to Adding a Document Type.
Note: Google AutoML users: Because Google Cloud only allows up to 30 deployed models at a time for a project, you should limit how many document channels you add. For example, if you have development, staging, and production Appian environments that all use the same Google Cloud project, then you should only have up to 30 deployed models. So for 3 Appian environments, you would want to have at most 10 document channels per environment.
You can access the Add Document Channel action from the Configure tab. This action makes the following changes:
dudocchannel
reference table.To complete the Add Document Channel action:
After completing this action, the document channel is added to the reference table and the associated groups are generated.
Each document channel has associated viewers, editors, reconciliation desk members, and managers. These groups have varying levels of access to the document information that flows through the channel. These access levels range from viewers (lowest access) to managers (highest access). See the Groups Reference Page for more information on the access granted to each type of group.
The Add Document Channel action generates new security groups for the document channel. However, these groups are not automatically added to the Intelligent Document Processing (IDP) application container in Appian Designer.
To add the security groups to the application:
Before you can configure the new document channel, you first need to add document types for the channel. Follow the steps in Adding a Document Type, with the following modifications.
Adding an invalid document type for new channels is necessary to classify documents that are uploaded mistakenly as invalid or to automatically classify common mistakes as invalid. For example, if you want to process signed order forms, and users tend to mistakenly send you unsigned order forms, you may want to train the classification model to automatically classify these documents as invalid.
When you add the new document channel, a channelid
is automatically generated in the dudocchannel
reference table.
To create the invalid document type, use the following database command, replacing [channelId]
with the channel ID that was generated for the new channel. Note that this command uses MySQL syntax.
1
INSERT INTO `dudoctype` (`doctypeid`, `doctypename`, `choiceindex`, `doctypestatus`, `isinvalidtype`, `channelid`) VALUES (NULL, NULL, '0', 'Inactive', '1', '[channelId]')
On the Adding a Document Type page, follow the instructions in Step 1: Add the new document type to the reference table, using the new channelid
that was generated for your new document channel.
For example, let's say you added a document channel called Legal and in the dudocchannel
reference table, the value of channelid
was automatically set to 2. To add a new document type for the Legal channel called Statement of Work, you would use a database command like the following. Note that this example uses MySQL syntax.
1
INSERT INTO `dudoctype` (`doctypeid`, `doctypename`, `choiceindex`, `doctypestatus`, `isinvalidtype`, `channelid`) VALUES (NULL, 'Statement of Work', '1', 'Inactive', '0', '2');
Follow steps 2 - 4 in Adding a Document Type for each document type you are creating for the new document channel.
After you create the new objects for the new document type CDTs and data store entity constants for each document type, you need to update existing expression rules to use the new objects. This allows the new document types to be used in the application.
The DU_returnDataTypeForChoiceIndex
expression rule returns the CDT for a document type. Basically, given a channel ID and choice index, it chooses the list of CDTs that matches the channel ID, then returns the document type CDT that matches the choice index for that list of CDTs.
For example, in the following expression rule, if you input 1
for ri!channelID
and 3
for ri!choiceIndex
, the expression would return the third item in the first list of CDTs, which is DU_Claim
.
Example expression rule
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
...
choose(
ri!channelId,
/*Channel ID 1*/
choose(
ri!choiceIndex,
'type!{urn:com:appian:types:DU}DU_Invoice'(),
'type!{urn:com:appian:types:DU}DU_PurchaseOrder'(),
'type!{urn:com:appian:types:DU}DU_Claim'(),
'type!{urn:com:appian:types:DU}DU_Receipt'()
),
/*Channel ID 2*/
choose(
ri!choiceIndex,
'type!{urn:com:appian:types:DU}DU_PartnershipApplication'(),
'type!{urn:com:appian:types:DU}DU_StatementOfWork'(),
'type!{urn:com:appian:types:DU}DU_RetirementApplication'()
)
)
...
In order for it to return the CDTs for the new types of documents, you will need to add the new CDTs to the expression rule.
To add the new CDTs to the expression rule:
DU_returnDataTypeForChoiceIndex
expression rule.choose()
statement at the index that corresponds with the channel ID of the document channel. For example, if you add a new document channel with a channel ID of 2, then the new choose()
statement must be at index 2.choose()
function as follows:
ri!choiceIndex
rule input.choiceindex
value of the dudoctype
reference table.To update the DU_returnDataTypeForChoiceIndex
expression rule to add the document type CDTs for the Legal channel, you would add a new choose()
function with the ri!choiceIndex
rule input and new CDTs.
Make sure to list the CDTs in the order indicated by the choiceindex
value of the dudoctype
reference table. For example, if you had the following reference table, you would list the CDTs in the following order: 'type!{urn:com:appian:types:DU}DU_PartnershipApplication'()
, 'type!{urn:com:appian:types:DU}DU_StatementOfWork'()
, and 'type!{urn:com:appian:types:DU}DU_RetirementApplication'()
.
doctypeid | doctypename | choiceindex | doctypestatus | isinvalidtype | channelid |
---|---|---|---|---|---|
0 | NULL | 0 | Active | 1 | 1 |
1 | Invoice | 1 | Active | 0 | 1 |
2 | Purchase Order | 2 | Active | 0 | 1 |
3 | Claim | 3 | Active | 0 | 1 |
4 | Receipt | 4 | Active | 0 | 1 |
5 | NULL | 0 | Inactive | 1 | 2 |
6 | Partnership Application | 1 | Inactive | 0 | 2 |
7 | Statement of Work | 2 | Inactive | 0 | 2 |
8 | Retirement Application | 3 | Inactive | 0 | 2 |
Tip: Entering type!DU_
and selecting the CDT name from the auto-suggest list, will automatically convert type!DU_<CDT Name>()
to type!{urn:com:appian:types:DU}DU_<CDT Name>()
.
In the example below, we added a Legal document channel with partnership application, statement of work, and retirement application document types.
DU_returnDataTypeForChoiceIndex
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
if(
rule!DU_isInvalidDocTypeId(docTypeId: ri!choiceIndex),
{},
choose(
ri!channelId,
/*Channel ID 1*/
choose(
ri!choiceIndex,
'type!{urn:com:appian:types:DU}DU_Invoice'(),
'type!{urn:com:appian:types:DU}DU_PurchaseOrder'(),
'type!{urn:com:appian:types:DU}DU_Claim'(),
'type!{urn:com:appian:types:DU}DU_Receipt'()
),
! /*Channel ID 2*/
! choose(
! ri!choiceIndex,
! 'type!{urn:com:appian:types:DU}DU_PartnershipApplication'(),
! 'type!{urn:com:appian:types:DU}DU_StatementOfWork'(),
! 'type!{urn:com:appian:types:DU}DU_RetirementApplication'()
! )
)
)
The DU_returnDataStoreEntityForChoiceIndex
expression rule returns the data store entity for a document type. It is used to dynamically invoke the correct data store entity when writing or querying the document data. Basically, given a channel ID and choice index, it chooses the list of data store entity constants that matches the channel ID, then returns the constant that matches the choice index for that list of constants.
For example, in the following expression rule, if you input 1
for ri!channelID
and 3
for ri!choiceIndex
, the expression would return the third item in the first list of constants, which is cons!DU_CLAIM_DSE
.
Example expression rule
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
choose(
ri!channelId,
/*Channel ID 1*/
choose(
ri!choiceIndex,
cons!DU_INVOICE_DSE,
cons!DU_PURCHASE_ORDER_DSE,
cons!DU_CLAIM_DSE,
cons!DU_RECEIPT_DSE
),
choose(
ri!choiceIndex,
cons!DU_PARTNERSHIP_APPLICATION_DSE,
cons!DU_STATEMENT_OF_WORK_DSE,
cons!DU_RETIREMENT_APPLICATION_DSE
)
)
In order for it to return the data store entity for the new document types, you will need to add the new data store entity constants to the expression rule.
To add the new data store entity constants to the expression rule:
DU_returnDataStoreEntityForChoiceIndex
expression rule.choose()
statement at the index that corresponds with the channel ID of the document channel. For example, if you add a new document channel with a channel ID of 2, then the new choose()
statement must be at index 2.choose()
function as follows:
ri!choiceIndex
rule input.choiceindex
value of the dudoctype
reference table.To update the DU_returnDataStoreEntityForChoiceIndex
expression rule to add the document types for the new channel, you would add a new choose()
function with the ri!choiceIndex
rule input and new data store entity constants.
Make sure to list the constants in the order indicated by the choiceindex
value of the dudoctype
reference table. For example, if you had the following reference table, you would list the constants in the following order: cons!DU_PARTNERSHIP_APPLICATION_DSE
, cons!DU_STATEMENT_OF_WORK_DSE
, and cons!DU_RETIREMENT_APPLICATION_DSE
.
doctypeid | doctypename | choiceindex | doctypestatus | isinvalidtype | channelid |
---|---|---|---|---|---|
0 | NULL | 0 | Active | 1 | 1 |
1 | Invoice | 1 | Active | 0 | 1 |
2 | Purchase Order | 2 | Active | 0 | 1 |
3 | Claim | 3 | Active | 0 | 1 |
4 | Receipt | 4 | Active | 0 | 1 |
5 | NULL | 0 | Inactive | 1 | 2 |
6 | Partnership Application | 1 | Inactive | 0 | 2 |
7 | Statement of Work | 2 | Inactive | 0 | 2 |
8 | Retirement Application | 3 | Inactive | 0 | 2 |
In the example below, we added a Legal document channel with partnership application, statement of work, and retirement application document types.
DU_returnDataStoreEntityForChoiceIndex
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
choose(
ri!channelId,
/*Channel ID 1*/
choose(
ri!choiceIndex,
cons!DU_INVOICE_DSE,
cons!DU_PURCHASE_ORDER_DSE,
cons!DU_CLAIM_DSE,
cons!DU_RECEIPT_DSE
),
! /*Channel ID 2*/
! choose(
! ri!choiceIndex,
! cons!DU_PARTNERSHIP_APPLICATION_DSE,
! cons!DU_STATEMENT_OF_WORK_DSE,
! cons!DU_RETIREMENT_APPLICATION_DSE
! )
)
Now that the document channel and document types are set up, go to the Configure tab and configure the document channel.
When you are setting the preferences, you will be able to specify different users and groups for the new document channel than the ones used in your existing document channels. Users will only be able to see the documents of the channel that they have access to.
After the document channel is configured and the classification model is trained, you can start uploading documents for processing.
Note: This section applies only if you're using Google services with IDP.
Each time you create a document processing channel, it uses a new model that relies on Google's AutoML service. After you configure and train the model, it begins to access Google AutoML and incur charges. Customers with high-volume or varied document processing needs may need to manage their usage so they don't exceed any applicable Google Cloud Platform (GCP) project budget each month. To help you proactively manage your costs, you can deactivate document channels in IDP.
Administrators can also use a process model as a utility to manually clean up any Google AutoML models that aren't being used in their application.
IDP automatically handles cleaning up models when the associated channel is deactivated. This automatic clean up should be the first option if you need to reduce the costs of deployed GCP models.
To delete a model:
When you delete a model manually, remember to also deactivate the channel that uses it. If you delete model, but it's still linked to a channel listed in the dudocchannel
database table, it may cause process errors when you deactivate or reactivate that channel.
To avoid these issues:
dudocchannel
database table.modelid
and isactive
fields to NULL
.Adding a Document Channel