Informat Platform System Methods

There are 119 methods in total. The parameter definition file for each method is under {baseDir}/references/.

Agent Interface Calling Rules

According to the different method names, the system will automatically select the corresponding agent interface:

1. Team Agent Interface: Methods starting with _company will call the company_agent interface
2. Application Agent Interface: Other methods will call the app_agent/{appId} interface

Get Application ID

Before calling the application agent interface, you need to get appId, you can get it through the following steps:

# 1. Call the team agent interface to get all application list
node {baseDir}/scripts/call.js company_agent _company_app_list

# 2. Find the target application ID from the returned result
# 3. Use the obtained appId to call the application agent interface
node {baseDir}/scripts/call.js app_agent <appId> _query_table_define --file params.json

Configuration

Edit {baseDir}/scripts/.env:

host=https://ai.ainformat.com/
agentToken=<your-agent-token>

Query First Before Operation -- The Most Important Rule

Before executing any creation or modification operation, you must first query the existing system structure to obtain the real ID. It is strictly forbidden to construct any ID or field name out of thin air.

Querying cannot stop at just the list, you must further query the complete field structure of each related table. Because when creating associated fields, you need the field ID of the target table, knowing only the table ID is not enough.

Before Creating an Application

1. _company_app_list          -> Get all existing applications, including unique application identifiers

Before Creating a Data Table

1. _query_table_list_designer          -> Get all existing tables and their IDs
2. Call separately for each table that may be associated
   _query_table_define_designer        -> Get the complete field list of the table (field ID, field type, option values, etc.)
   This step cannot be omitted, because the associated field requires the field ID of the target table
3. cat {baseDir}/references/system_create_table_module.json  -> Read parameter documentation
4. Construct parameters using the queried real table IDs and field IDs, create the new table

Why must query the field structure of each table:

• RelationRecord field requires tableId (target table ID) and nameFieldId (target table display field ID)
• RelationRecordField field requires fieldId (this table foreign key field ID), targetTableId, targetFieldId
• LookupList field requires sub-table ID and foreign key field ID in the sub-table
• LookupRollup field requires sub-table ID and aggregation field ID in the sub-table
• These IDs can only be obtained through _query_table_define_designer query

Before Creating Dashboard Card

1. _query_table_list_designer          -> Get all table IDs
2. Call on the target data source table
   _query_table_define_designer        -> Get all field IDs and field types of the table
   Without querying the field structure, you cannot correctly configure aggregation fields, grouping fields, filter conditions
3. _read_informat_dashboard_document   -> Get dashboard documentation
4. cat {baseDir}/references/system_save_dashboard_prochart_card.json
   or system_save_dashboard_number_card.json  -> Read parameter documentation
5. Construct card parameters using the queried real field IDs

Before Creating Automation

1. _query_app_define_designer          -> Get module list, existing automation groups
2. _query_table_list_designer          -> Get all table IDs
3. Call separately for each table involved in automation
   _query_table_define_designer        -> Get field IDs (field mapping and filter conditions in automation steps require real field IDs)
4. _automatic_doc                      -> Get automation documentation
5. cat {baseDir}/references/system_automatic_save_define.json  -> Read parameter documentation
6. Construct automation steps using the queried real IDs

Before Creating Workflow

1. _query_app_define_designer -> Get module list
2. _query_table_list_designer + _query_table_define_designer -> Get tables and fields
3. _read_informat_expression_doc -> Get expression documentation (workflow extensively uses expressions)
4. Read the corresponding parameter documentation
5. Create in order: module -> process definition -> startup configuration -> node -> flow

Before Creating Script

1. _query_informat_script_list -> Get existing scripts and directories
2. _read_informat_script_sdk -> Get script SDK documentation
3. Create directory first if needed _create_informat_script_directory
4. Read cat {baseDir}/references/system_save_informat_script.json
5. Create or edit script (when editing, must pass the existing script ID, do not create repeatedly)

Before Editing a Field

1. _query_table_list_designer -> Find the target table
2. _query_table_define_designer -> Get the complete field list of the table
3. _read_informat_expression_doc -> If you need to configure expressions
4. Read cat {baseDir}/references/system_edit_table_field.json
5. Operate with real tableId and fieldId

Before Operating Data Records

1. _query_all_table_list -> Get published table IDs (application side)
2. _query_table_define -> Get published field structure
3. Read the corresponding parameter documentation
4. Construct record data with real field IDs

Calling Steps

Step 1 - Read Parameter Documentation

cat {baseDir}/references/system_query_table_define.json

The file contains parameter types, required fields, enumeration values, and nested structures. Not reading and directly constructing parameters will cause the call to fail.

Step 2 - Write Parameter File

Write the parameters to a JSON file (you can choose the current working directory for the file location):

echo '{"tableId":"myTable"}' > params.json

Step 3 - Execute

# With parameters (passed via --file parameter file, avoid shell quote issues)
node {baseDir}/scripts/call.js _query_table_define --file params.json

# No parameters
node {baseDir}/scripts/call.js _get_current_time

Team Agent Method List

Application Agent Method List

> [Designer] = Draft environment. [Application] = Published environment. [User Operation] = Manual execution by user.

API Management

Application Management

Application Query

Data Table

Data Table Query

Data Table Editing

Data Table Record Operations

Workflow (BPMN)

Automation Process

Dashboard

Script

Scheduled Task

Internationalization

Website Resources

Designer

Module Management

System Information

Documentation

Search

Notification and Email

Survey

Task

Thread

Others

Error Handling

When calling the Informat API, you may encounter the following common errors:

1. 500 Internal Server Error

• Cause: Server internal error, may be due to application not initialized, too frequent API calls, or temporary server failure
• Solution: Wait a while and retry, or check application status

2. -32601 Exception Error

• Cause: Parameter format error, incorrect field configuration or ID does not exist
• Solution: Check parameter format is correct, ensure all IDs are real IDs obtained from system query

3. Permission Error

• Cause: Insufficient agentToken permissions or application access permission issue
• Solution: Ensure the agentToken used has sufficient permissions, check application access settings

4. Network Error

• Cause: Network connection problem or API server unreachable
• Solution: Check network connection, ensure host configuration is correct

Best Practices

1. Always Query First Then Operate

• Before executing any creation or modification operation, you must first query the existing system structure
• Get real IDs (table ID, field ID, module ID, etc.)
• Avoid constructing IDs out of thin air, this will cause API call failure

2. Strictly Follow Parameter Documentation for Parameters

• Before calling a method with parameters, you must first read the corresponding parameter documentation
• Ensure parameter types, required fields, enumeration values and nested structures are correct
• Use JSON file to pass parameters, avoid shell quote issues

3. Error Handling and Retry Mechanism

• Implement appropriate error handling, capture and analyze API errors
• For temporary errors (such as 500 errors), you can implement a retry mechanism
• Record detailed operation logs, easy to troubleshoot problems

4. Performance Optimization

• Batch operations: Use batch API to reduce the number of calls
• Reasonable caching: Cache query results, avoid repeated queries
• On-demand query: Only query necessary data, reduce data transmission

Example Workflow

Complete Process to Create a Project Management System

1. Create Application

```bash

# 1. Prepare parameter file

echo '{"name": "Project Management System", "appDefineId": "pms2026", "icon": "task", "color": "#1890ff"}' > create_app.json

# 2. Create application

node {baseDir}/scripts/call.js _company_app_create --file create_app.json

```

1. Create Data Tables

```bash

# 1. Prepare project table parameters

echo '{"id": "project", "name": "Project", "fields": [{"id": "projectName", "name": "Project Name", "type": "SingleText", "singleTextSetting": {"nullable": false}}]}' > create_project_table.json

# 2. Create project table

node {baseDir}/scripts/call.js _create_table_module --file create_project_table.json

# 3. Prepare task table parameters

echo '{"id": "task", "name": "Task", "fields": [{"id": "taskName", "name": "Task Name", "type": "SingleText", "singleTextSetting": {"nullable": false}}]}' > create_task_table.json

# 4. Create task table

node {baseDir}/scripts/call.js _create_table_module --file create_task_table.json

```

1. Create Dashboard

```bash

# 1. Prepare dashboard parameters

echo '{"id": "dashboard", "name": "Project Management Dashboard"}' > create_dashboard.json

# 2. Create dashboard

node {baseDir}/scripts/call.js _create_dashboard_module --file create_dashboard.json

```

FAQ

Q: Why does it prompt "Application module identifier already exists" when creating a data table?

A: This means the module ID is already in use, you need to use a different module ID.

Q: Why does the API return 500 error?

A: The application may not be initialized, it is recommended to wait a while and retry, or check the application status.

Q: How to get the module list of an application?

A: Use the _designer_get_module_list method to query the module list of the application.

Q: How to get the access address of the application?

A: {host}/app/{appId}