Getting Integration Connection List
Function: get_integration_connections()
Purpose
This SDK function retrieves a list of all integration connections available calling the get_integration_connections() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and sends a request to the backend to fetch integration connection records associated with the authenticated user or organization.
Parameters
This function does not require any input parameters.
Use Case
The user can apply this function to view all existing integration connections linked to their environment. This is helpful for administrative views, system health checks, integration setup validation, or configuration dashboards. It provides an overview of all connected services or third-party platforms and helps in identifying connection status, providers, and configuration details. In the event of authentication failure or other backend issues, the function raises an exception for debugging and analysis.
def test_get_integration_connections():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.connection_list()
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Returns a list of integration connections with associated metadata such as connection UUID, integration partner name, remote instance ID and name, client ID, client secret, access token, and refresh token. The response structure is typically a JSON object containing a list of connections under the integration_connection key and a pagination object for handling paginated records. In case of failure, such as invalid authentication, permission denial, or service error, an ABException is thrown. The function handles the exception and prints the error message, backend error content, and raw response for debugging purposes.
IntegrationConnectionListResponseDTO(
integration_connection = [
IntegrationConnectionDTO(
status = "CONNECTION_STATUS",
uuid = "CONNECTION_UUID",
integrationPartner = "INTEGRATION_PARTNER_NAME",
remoteInstanceId = "REMOTE_INSTANCE_ID",
remoteInstanceName = "REMOTE_INSTANCE_NAME",
clientId = "CLIENT_ID",
clientSecret = "CLIENT_SECRET",
accessToken = "ACCESS_TOKEN",
refreshToken = "REFRESH_TOKEN"
)
],
pagination = {}
)Getting Integration Connection Details by ID
Function: get_integration_connection_by_id()
Purpose
This SDK function retrieves a specific integration connection by its UUID using the get_connection_by_id() method from the ExsitedSDK. It initializes the SDK with a valid authentication token and sends a request to the backend to fetch details of the specified integration connection associated with the authenticated user or organization.
Parameters
| Parameter | Type | Description |
|---|---|---|
connection_uuid |
String | Unique ID of a integration connection |
Use Case
The function can be used to validate and inspect the details of a specific integration connection. It is useful in scenarios like integration diagnostics, admin tools, or audit panels where inspecting configuration details (e.g., integration partner, remote instance ID, credentials metadata) is required. If the UUID is invalid or access is restricted, an ABException is raised with detailed error messages for debugging.
def test_get_integration_connection_by_id():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.get_connection_by_id(connection_uuid='f18f18c6-ac24-4b92-8a26-0a205168e966')
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Returns details of a single integration connection with associated metadata such as connection UUID, integration partner name, remote instance ID and name, client ID, client secret, access token, and refresh token. The response structure is typically a JSON object representing one integration connection, rather than a list. This object includes all configuration details required to identify and manage the integration. In case of failure, such as invalid authentication, an incorrect or missing UUID, permission denial, or a backend service error, an ABException is thrown. The function handles the exception and prints the error message, backend error content, and raw response for debugging purposes.
IntegrationConnectionListResponseDTO(
integration_connection = [
IntegrationConnectionDTO(
status = "CONNECTION_STATUS",
uuid = "CONNECTION_UUID",
integrationPartner = "INTEGRATION_PARTNER_NAME",
remoteInstanceId = "REMOTE_INSTANCE_ID",
remoteInstanceName = "REMOTE_INSTANCE_NAME",
clientId = "CLIENT_ID",
clientSecret = "CLIENT_SECRET",
accessToken = "ACCESS_TOKEN",
refreshToken = "REFRESH_TOKEN"
)
]
)Enabling Integration Connection
Function: enable_integration_connection()
Purpose
This SDK function enables a previously inactive or disabled integration connection by internally calling the enable_connection() method from the ExsitedSDK. It initializes the SDK with a valid authentication token and sends a request to the backend to activate the integration connection specified by its UUID. Once enabled, the connection becomes available for use in data synchronization or integration workflows.
Parameters
| Parameter | Type | Description |
|---|---|---|
connection_uuid | String | Unique ID of a integration connection |
Use Case
This function is used when reactivating an integration connection that was previously disabled—such as during system maintenance, temporary credential issues, or administrative suspension. It is helpful in integration control panels, monitoring tools, or automation scripts that manage connection states. If the UUID is invalid, the connection doesn't exist, or the user lacks access rights, an ABException is raised containing diagnostic messages for troubleshooting.
def test_enable_integration_connection():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.enable_connection(connection_uuid='ff7018bb-e659-4faf-831b-54742f934935')
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Enabling an integration connection returns a confirmation response indicating the connection was successfully activated. The response typically includes the connection UUID, updated status (e.g., "ACTIVE"), and metadata such as integration partner name, remote instance identifiers, and client credentials. The structure is a JSON object representing the updated integration connection.In case of failure, such as an invalid or missing UUID, insufficient permissions, invalid authentication, or service-side errors, an ABException is thrown. The function captures this exception and outputs the error message, backend error details, and the raw API response to assist in debugging and resolution.
EntegrationConnectionEnableResponseDTO(
message="XERO integration has been enable successfully"
)Disabling Integration Connection
Function: disable_integration_connection()
Purpose
This SDK function disables an active integration connection by internally calling the disable_connection() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and sends a request to the backend to deactivate the specified integration connection using its UUID. Once disabled, the connection is prevented from participating in any further data synchronization or integration activities until explicitly re-enabled.
Parameters
| Parameter | Type | Description |
|---|---|---|
connection_uuid | String | Unique ID of a integration connection |
Use Case
This function is used when suspending an integration connection, commonly required during credential rotation, system updates, temporary service downtime, or administrative decision to pause data exchange. It is useful in integration management consoles, operational workflows, or automated scripts that manage third-party service states. If the UUID is incorrect, the connection is already disabled, or access is denied, the function raises an ABException with full diagnostic details to assist with debugging and resolution.
def test_disable_integration_connection():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.disable_connection(connection_uuid='ff7018bb-e659-4faf-831b-54742f934935')
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Disabling an integration connection returns a confirmation response indicating the connection was successfully deactivated. The response typically includes a message confirming the action, such as "XERO integration has been disable successfully". The structure is a JSON object or DTO conveying the success status of the operation. In case of failure—such as an invalid or missing UUID, insufficient permissions, invalid authentication, or service-side errors—an ABException is thrown. The function captures this exception and prints the error message, backend error content, and raw API response to assist in debugging and resolution.
IntegrationConnectionDisableResponseDTO(
message='XERO integration has been disable successfully'
)Creating Partner Function
Function: create_partner_function()
Purpose
This SDK function creates a new partner function under a specified integration connection by calling the create_partner_function() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and constructs a PartnerFunctionRequestDTO that includes details such as function name, direction, description, object mapping, event name, and tags. The function then sends a request to the backend to register this partner function against the provided connection UUID, establishing an operational rule or handler for the specified data object and event.
Parameters
| Parameter | Type | Description |
|---|---|---|
connection_uuid | String | Unique ID of a integration connection |
Use Case
This function is helpful when a developer wants to set up a new partner function for an integration — for example, to define what should happen when data is imported or updated from an external system like Xero. You can use it to configure how specific objects (like "customer") are handled during certain events (like "update"). It’s useful during the setup of integrations, especially when building custom data flows or automation rules. If something goes wrong (like the UUID is wrong or you're not authorized), the function will throw an ABException with clear error details to help you debug the issue quickly.
def test_create_partner_function():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
request_obj = PartnerFunctionRequestDTO(
partnerFunction=PartnerFunctionDTO(
name="PARTNER_FUNCTION_NAME",
direction="FUNCTION_DIRECTION",
description="FUNCTION_DESCRIPTION",
objectName="OBJECT_NAME",
objectMapping="OBJECT_MAPPING_NAME",
eventName="EVENT_NAME",
tag="FUNCTION_TAG"
)
)
connection_uuid = "INTEGRATION_CONNECTION_UUID"
response = exsited_sdk.integration.create_partner_function(connection_uuid=connection_uuid, request_data=request_obj)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
Response
Creating a partner function returns a response containing metadata for the newly created integration function. The response includes details such as the function UUID, name, description, direction (e.g., import/export), associated event name, provider name, object mapping details, script references, and timestamps indicating creation and last update. The structure is represented by a PartnerFunctionCreateResponseDTO, which wraps a PartnerFunctionDTO containing all relevant partner function attributes. In case of failure, such as invalid input data, missing required fields, authentication issues, or permission errors, an ABException is raised. This exception includes the error message, detailed backend error data, and the raw response to help with debugging and issue resolution.
PartnerFunctionCreateResponseDTO(
partnerFunction=PartnerFunctionDTO(
uuid="PARTNER_FUNCTION_UUID",
name="PARTNER_FUNCTION_NAME",
description="FUNCTION_DESCRIPTION",
direction="FUNCTION_DIRECTION",
eventName="EVENT_NAME",
providerName="INTEGRATION_PROVIDER_NAME",
objectName="OBJECT_NAME",
objectMapping="OBJECT_MAPPING_NAME",
mappingId="MAPPING_ID",
enabled="BOOLEAN_STRING",
preRunScriptId="PRE_RUN_SCRIPT_ID",
postRunScriptId="POST_RUN_SCRIPT_ID",
tag="FUNCTION_TAG",
created="CREATED_TIMESTAMP",
updated="UPDATED_TIMESTAMP"
)
)
Enabling Partner Function
Function: enable_partner_function()
Purpose
This SDK function enables a previously disabled or inactive partner function by calling the enable_partner_function() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and sends a request to the backend to activate the specified partner function under a given integration connection. Once enabled, the partner function becomes operational and can be used as part of automated data workflows or event-driven processes defined in the integration.
Parameters
| Parameter | Type | Description |
|---|---|---|
connection_uuid | String | Unique ID of the integration connection |
partner_function_uuid | String | Unique ID of the partner function to be enabled |
Use Case
This function is useful when a developer or administrator wants to re-enable a specific partner function that was previously turned off—for example, after resolving errors, updating configurations, or finishing maintenance. It helps restore automation or synchronization logic associated with the function, such as import/export behaviors. If the UUIDs are invalid or the user lacks appropriate permissions, an ABException is raised with detailed error information to assist in resolving the issue efficiently.
def test_enable_partner_function():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
connection_uuid = "connection-uuid"
partner_function_uuid = "partner-function-uuid"
response = exsited_sdk.integration.enable_partner_function(connection_uuid, partner_function_uuid)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
Response
Enabling a partner function returns a confirmation response indicating the function was successfully activated. The response is structured as a PartnerFunctionEnableResponseDTO object containing a message field, such as: "Partner function has been enabled successfully". This confirms that the specified function is now active and ready for use in the integration workflow. If there is an issue, such as an invalid connection UUID, incorrect partner function UUID, permission denial, or authentication failure, an ABException is raised. This exception provides the error message, backend error details, and raw response to assist with effective debugging and resolution.
PartnerFunctionEnableResponseDTO(
message='Partner function has been enabled successfully'
)
Disabling Partner Function
Function: disable_partner_function()
Purpose
This SDK function disables an active partner function by calling the disable_partner_function() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and sends a request to the backend to deactivate the specified partner function under a given integration connection. Once disabled, the partner function becomes inactive and is excluded from any data automation or event-driven processing associated with the integration.
Parameters
| Parameter | Type | Description |
|---|---|---|
| connection_uuid | String | Unique ID of the integration connection |
| partner_function_uuid | String | Unique ID of the partner function to be disabled |
Use Case
This function is helpful when an integration administrator or developer wants to temporarily or permanently disable a specific partner function—such as stopping the execution of a data import/export rule or an event handler during maintenance, debugging, or configuration changes. Disabling the function ensures that it no longer runs until explicitly re-enabled. If either UUID is incorrect or permissions are lacking, an ABException is raised with detailed error messages and raw response content for effective troubleshooting.
def test_disable_partner_function():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
connection_uuid = "connection-uuid"
partner_function_uuid = "partner-function-uuid"
response = exsited_sdk.integration.disable_partner_function(connection_uuid, partner_function_uuid)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Disabling a partner function returns a confirmation response indicating that the function was successfully deactivated. The response is structured as a PartnerFunctionDisableResponseDTO object and contains a message field, such as: "Partner function has been disabled successfully". This confirms that the specified function is no longer active and will not participate in integration workflows until re-enabled. If any issue occurs, such as an invalid connection UUID, incorrect partner function UUID, lack of permissions, or authentication failure, an ABException is raised. This exception provides helpful information including the error message, backend error details, and the raw response to support efficient debugging and resolution.
PartnerFunctionDisableResponseDTO(
message='Partner function has been disabled successfully'
)Creating Integration Connection
Function: create_integration_connections()
Purpose
This SDK function creates a new integration connection by calling the create_connection() method from the ExsitedSDK. It initializes the SDK with a valid authentication token and constructs an IntegrationConnectionCreateRequestDTO containing details such as provider name, remote instance metadata, OAuth credentials, supporting fields, and company information. Once invoked, the function sends a request to the backend to register the integration connection, establishing a secure link between the platform and an external service like an accounting or ERP system.
Parameters
This function does not require any input parameters.
Use Case
This function is useful when a developer or system administrator wants to set up a new integration connection for syncing data between the platform and a third-party provider. It is typically used during the onboarding or configuration phase of an integration, enabling data exchange by saving the connection credentials and relevant metadata. Common use cases include connecting to systems like Xero, NetSuite, or QuickBooks, defining tenant-specific details, and supplying authentication tokens. If any required fields are missing, credentials are invalid, or permissions are insufficient, the function raises an ABException with detailed error information to support fast debugging and resolution.
def test_create_integration_connections():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
request_obj = IntegrationConnectionCreateRequestDTO(
provider="PROVIDER_NAME",
remoteInstanceId="REMOTE_INSTANCE_ID",
remoteInstanceCode="REMOTE_INSTANCE_CODE",
remoteInstanceName="REMOTE_INSTANCE_NAME",
remoteInstanceDisplay="REMOTE_INSTANCE_DISPLAY",
integrationClientId="CLIENT_ID",
integrationClientSecret="CLIENT_SECRET",
integrationAccessToken="ACCESS_TOKEN",
integrationRefreshToken="REFRESH_TOKEN",
tokenType="TOKEN_TYPE",
expiresIn="EXPIRY_DATE",
accountServer="ACCOUNT_SERVER_URL",
apiDomain="API_DOMAIN_URL",
supportingFields='{"key":"value"}',
userName="USERNAME",
userPassword="USER_PASSWORD",
requireAuthentication=True,
state="STATE_VALUE",
companyFile="COMPANY_FILE_ID",
companyName="COMPANY_NAME",
)
response = exsited_sdk.integration.create_connection(request_data=request_obj)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Creating an integration connection returns a structured IntegrationConnectionCreateResponseDTO containing a data object. Inside this, the integration field holds an IntegrationConnectionDTO with details such as connection status, UUID, integration partner name, remote instance identifiers, and client authentication credentials (client ID, secret, access and refresh tokens). This confirms that the connection has been successfully established and is ready for use in integration workflows. If the request fails due to missing fields, invalid values, or permission issues, an ABException is raised, including a clear error message, backend error content, and the raw response to help troubleshoot the issue effectively.
IntegrationConnectionCreateResponseDTO(
data=IntegrationConnectionResponseDataDTO(
integration=IntegrationConnectionDTO(
status="CONNECTION_STATUS",
uuid="CONNECTION_UUID",
integrationPartner="INTEGRATION_PARTNER",
remoteInstanceId="REMOTE_INSTANCE_ID",
remoteInstanceName="REMOTE_INSTANCE_NAME",
clientId="CLIENT_ID",
clientSecret="CLIENT_SECRET",
accessToken="ACCESS_TOKEN",
refreshToken="REFRESH_TOKEN"
)
)
)Creating Automation
Function: create_automation()
Purpose
This SDK function creates a new automation under a specified integration connection by calling the create_automation() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and constructs an AutomationRequestDTO object, which includes configuration data such as automation name, trigger type (e.g., timer-based), direction (IMPORT/EXPORT), execution frequency, overwrite behavior, criteria rules, and associated actions. The function sends this request to the backend, where the automation logic is registered and becomes active for use in scheduled or conditional integration workflows.
Parameters
| Parameter | Type | Description |
|---|---|---|
| connection_uuid | String | Unique ID of the integration connection. |
Use Case
This function is useful when developers or integration administrators need to define and enable automated workflows — for example, syncing data every 8 hours, filtering suppliers based on conditions, or executing import actions tied to specific partner functions. It simplifies integration management by programmatically defining automation without using the UI. If the request data is invalid, missing required fields, or the user lacks proper permissions, an ABException is raised, containing error messages and raw backend details for fast debugging and resolution.
def test_create_automation():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
request_obj = AutomationRequestDTO(
integration=IntegrationDTO(
automationDetails=AutomationDetailsDTO(
name="Generic Automation",
displayName="Generic Automation Display",
code="auto_code_01",
descriptionEnabled="true",
description="This is a generic automation description.",
anotherAutomation="SecondaryAutomation",
appliesTo="vendor",
appliesToFunction="create",
automationType="eventBased",
direction="EXPORT",
checkOn="12 hours",
customDay="monday",
customTime="09:30:00",
doNotOverWriteLatestData="false",
ignoreThreshold="5",
performAction="12345678-abcd-1234-efgh-567890abcdef",
sinceLastLookUp="false",
additionalCriteria="true",
propertyName=""
),
additionalCriteriaDetails=[
AdditionalCriteriaDTO(
groupCondition="OR",
rules=[
CriteriaRuleDTO(
fieldName="CustomerID",
operator="CONTAINS",
value="CUST001",
condition="OR"
),
CriteriaRuleDTO(
fieldName="Email",
operator="HAS_VALUE",
value=None,
condition="OR"
)
]
)
]
)
)
connection_uuid = "11112222-3333-4444-aaaa-bbbbbbbbbbbb"
response = exsited_sdk.integration.create_automation(connection_uuid, request_data=request_obj)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Creating an automation returns a structured response confirming the automation rule has been successfully created. The response is represented by an AutomationCreateResponseDTO, which wraps an IntegrationAutomationDTO containing detailed attributes of the newly created automation. These attributes include automation UUID, name, code, direction (e.g., IMPORT), trigger type (e.g., timerBased), execution frequency (checkOn), condition text, and related partner function references. It also reflects metadata such as provider name, status, and configured criteria logic. If the creation fails due to issues like missing fields, invalid data, or permission errors, an ABException is raised with descriptive error messages, backend details, and raw response content for effective troubleshooting.
AutomationCreateResponseDTO(
integrationAutomation=IntegrationAutomationDTO(
checkOn="CHECK_INTERVAL",
checkOnMinutes="CHECK_INTERVAL_MINUTES",
additionalCriteria="BOOLEAN_FLAG",
appliesTo="ENTITY_TYPE",
appliesToFunction="FUNCTION_TYPE",
automationType="AUTOMATION_TYPE",
code="AUTOMATION_CODE",
customDay="CUSTOM_DAY",
customDayTime="CUSTOM_DAY_TIME",
customTime="CUSTOM_TIME",
description="AUTOMATION_DESCRIPTION",
direction="DIRECTION",
displayName="DISPLAY_NAME",
name="AUTOMATION_NAME",
performFunction="FUNCTION_UUID",
provider="PROVIDER_NAME",
status="AUTOMATION_STATUS",
uuid="AUTOMATION_UUID",
triggerConditionText="TRIGGER_CONDITION",
performActionText="ACTION_LABEL",
checkOnText="CHECK_INTERVAL_LABEL"
)
)Updating Automation with Additional Criteria
Function: update_automation()
Purpose
This SDK function updates an existing automation under a specified integration connection by calling the update_automation() method with additional criteria from the ExsitedSDK. It initializes the SDK using a valid authentication token and builds an AutomationRequestDTO object containing updated automation details — including name, display name, description, trigger type, execution frequency, criteria logic, and linked partner functions. The function sends this update request to the backend using the automation’s unique UUID, allowing users to modify automation behavior or configuration without recreating it.
Parameters
| Parameter | Type | Description |
|---|---|---|
| connection_uuid | String | Unique ID of the integration connection. |
| automation_uuid | String | Unique ID of the automation. |
Use Case
This function is helpful when developers or system administrators need to update or refine existing automation workflows for additional criteria, for example, changing the trigger condition, execution schedule, or logic rules for when an import or export should happen. This enables dynamic adjustment of automation behavior in response to changing business requirements or data flows. If the automation UUID is invalid, the request is malformed, or the user lacks the necessary permissions, an ABException is raised with descriptive error messages and raw backend response for debugging.
def test_update_automation():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
request_obj = AutomationRequestDTO(
integration=IntegrationDTO(
automationDetails=AutomationDetailsDTO(
name="AUTOMATION_NAME",
displayName="DISPLAY_NAME",
code="AUTOMATION_CODE",
descriptionEnabled="BOOLEAN_FLAG",
description="AUTOMATION_DESCRIPTION",
anotherAutomation="SECONDARY_AUTOMATION",
appliesTo="ENTITY_TYPE",
appliesToFunction="FUNCTION_TYPE",
automationType="AUTOMATION_TYPE",
checkOn="CHECK_INTERVAL",
customDay="CUSTOM_DAY",
customTime="CUSTOM_TIME",
direction="DIRECTION",
doNotOverWriteLatestData="BOOLEAN_FLAG",
ignoreThreshold="IGNORE_THRESHOLD_VALUE",
performAction="FUNCTION_UUID",
sinceLastLookUp="BOOLEAN_FLAG",
additionalCriteria="BOOLEAN_FLAG",
propertyName=""
),
additionalCriteriaDetails=[
AdditionalCriteriaDTO(
groupCondition="AND",
rules=[
CriteriaRuleDTO(
fieldName="FIELD_NAME_1",
operator="EQUALS",
value="VALUE_1",
condition="AND"
)
]
),
AdditionalCriteriaDTO(
groupCondition="OR",
rules=[
CriteriaRuleDTO(
fieldName="FIELD_NAME_2",
operator="HAS_VALUE",
value=None,
condition="OR"
),
CriteriaRuleDTO(
fieldName="FIELD_NAME_3",
operator="CONTAINS",
value="STRING_VALUE",
condition="AND"
)
]
),
AdditionalCriteriaDTO(
groupCondition="AND",
rules=[
CriteriaRuleDTO(
fieldName="FIELD_NAME_4",
operator="DOES_NOT_HAVE_VALUE",
value=None,
condition="AND"
),
CriteriaRuleDTO(
fieldName="FIELD_NAME_5",
operator="EQUALS",
value="VALUE_2",
condition="AND"
)
]
)
]
)
)
connection_uuid = "CONNECTION_UUID_PLACEHOLDER"
automation_uuid = "AUTOMATION_UUID_PLACEHOLDER"
response = exsited_sdk.integration.update_automation(
connection_uuid=connection_uuid,
automation_uuid=automation_uuid,
request_data=request_obj
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Updating an automation returns a structured confirmation wrapped in an AutomationUpdateResponseDTO. This includes an IntegrationAutomationDTO that reflects the updated automation attributes such as UUID, name, execution timing (checkOn, customTime), trigger direction (IMPORT/EXPORT), automation type (e.g., timerBased), and partner function association. The response also includes provider info, status, and human-readable labels for the trigger condition and action. If the update fails due to issues like invalid values or missing parameters, the SDK raises an ABException with complete error diagnostics to help quickly resolve the problem.
AutomationUpdateResponseDTO(
integrationAutomation=IntegrationAutomationDTO(
checkOn="CHECK_INTERVAL",
checkOnMinutes="CHECK_INTERVAL_MINUTES",
additionalCriteria="BOOLEAN_FLAG",
appliesTo="ENTITY_TYPE",
appliesToFunction="FUNCTION_TYPE",
automationType="AUTOMATION_TYPE",
code="AUTOMATION_CODE",
customDay="CUSTOM_DAY",
customDayTime="CUSTOM_DAY_TIME",
customTime="CUSTOM_TIME",
description="AUTOMATION_DESCRIPTION",
direction="DIRECTION",
displayName="DISPLAY_NAME",
name="AUTOMATION_NAME",
performFunction="FUNCTION_UUID",
provider="PROVIDER_NAME",
status="AUTOMATION_STATUS",
uuid="AUTOMATION_UUID",
triggerConditionText="TRIGGER_CONDITION",
performActionText="ACTION_LABEL",
checkOnText="CHECK_INTERVAL_LABEL"
)
)Updating Integration Configuration
Function: update_integration_configuration()
Purpose
This SDK function updates the configuration of an existing integration connection by calling the update_integration_configuration() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and constructs an IntegrationConnectionConfigRequestDTO object containing updated settings related to accounts and transactions. These configurations include import/export preferences, account mappings, tax settings, field identifiers, and invoice revenue mappings. The function sends this data to the backend to modify how the platform handles accounting and transactional synchronization with the external provider.
Parameters
| Parameter | Type | Description |
|---|---|---|
| connection_uuid | String | Unique ID of the integration connection. |
Use Case
This function is used when a developer or administrator needs to update how the platform communicates with a third-party service, such as Xero. Common use cases include adjusting account receivable/payable mappings, changing tax settings, enabling or disabling data sync, and customizing invoice number formats. These changes are often required when financial structures evolve, integration behavior changes, or during integration fine-tuning. If the request contains invalid fields or lacks permission, the function raises an ABException with detailed backend error information to support effective debugging and resolution.
def test_update_integration_configuration():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
request_obj = IntegrationConnectionConfigRequestDTO(
account=AccountDTO(
export=AccountImportExportDTO(
enabled="true",
defaultAccountReceivable="RECEIVABLE_ACCOUNT_NAME",
accountReceivableMapping=AccountMappingDTO(
enabled="true",
mappings=[
MappingDTO(source="SOURCE_NAME_1", target="TARGET_NAME_1"),
MappingDTO(source="SOURCE_NAME_2", target="TARGET_NAME_2"),
],
),
defaultAccountPayable="PAYABLE_ACCOUNT_NAME",
accountPayableMapping=AccountMappingDTO(
enabled="true",
mappings=[
MappingDTO(source="SOURCE_NAME_3", target="TARGET_NAME_3"),
MappingDTO(source="SOURCE_NAME_4", target="TARGET_NAME_4"),
],
),
defaultTax=None,
taxMapping=AccountMappingDTO(
enabled="false",
mappings=[],
),
xeroAccountNumberField="ACCOUNT_NUMBER_FIELD",
syncToXero="true",
),
import_=AccountImportExportDTO(
enabled="true",
defaultAccountReceivable="IMPORT_RECEIVABLE_NAME",
accountReceivableMapping=AccountMappingDTO(
enabled="true",
mappings=[
MappingDTO(source="SOURCE_NAME_5", target="TARGET_NAME_5"),
MappingDTO(source="SOURCE_NAME_6", target="TARGET_NAME_6"),
],
),
defaultAccountPayable="IMPORT_PAYABLE_NAME",
accountPayableMapping=AccountMappingDTO(
enabled="true",
mappings=[
MappingDTO(source="SOURCE_NAME_7", target="TARGET_NAME_7"),
MappingDTO(source="SOURCE_NAME_8", target="TARGET_NAME_8"),
],
),
xeroAccountIdField="ACCOUNT_ID_FIELD",
),
),
transaction=TransactionDTO(
invoice=InvoiceDTO(
export=InvoiceExportDTO(
enabled="true",
defaultSalesRevenue="SALES_REVENUE_ACCOUNT",
salesRevenueMapping=SalesRevenueMappingDTO(
enabled="true",
mappings=[
MappingDTO(source="SALES_SOURCE_1", target="SALES_TARGET_1"),
MappingDTO(source="SALES_SOURCE_2", target="SALES_TARGET_2"),
],
),
xeroInvoiceNumberField="INVOICE_NUMBER_FIELD",
syncToXero="true",
)
)
)
)
connection_uuid = "CONNECTION_UUID_PLACEHOLDER"
response = exsited_sdk.integration.update_integration_configuration(
connection_uuid, request_data=request_obj
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Updating an integration configuration returns a structured response confirming the configuration was successfully applied. The response contains a message field, such as: "Configuration has been updated successfully", indicating that the account and transaction settings have been saved and applied to the integration connection. If the update fails due to issues like invalid input data, missing fields, or permission errors, an ABException is raised. This exception includes descriptive error messages, backend details, and the raw response to assist with troubleshooting and resolution.
IntegrationConnectionConfigResponseDTO(
message='Configuration has been updated successfully'
)Updating Partner Function
Function: update_partner_function()
Purpose
This SDK function updates the configuration of an existing partner function under a specified integration connection by calling the update_partner_function() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and builds a PartnerFunctionRequestDTO, which includes details like the function's name, direction (IMPORT/EXPORT), description, associated object and mapping, event name, and an optional tag. The function sends this request to the backend using the partner function’s unique UUID, allowing users to modify the behavior of a partner function without deleting or recreating it.
Parameters
| Parameter | Type | Description |
|---|---|---|
| connection_uuid | String | Unique ID of the integration connection. |
| partner_function_uuid | String | Unique ID of the partner function. |
Use Case
This function is used when developers or administrators need to update an existing partner function’s configuration — for example, changing its mapped object, direction (from IMPORT to EXPORT), or event trigger. It allows quick iteration or correction of automation behavior without full deletion. If the UUIDs are invalid, the input data is malformed, or the user lacks necessary permissions, an ABException is raised with detailed error messages, backend error details, and the raw response to assist in debugging and resolution.
def test_update_partner_function():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
request_obj = PartnerFunctionRequestDTO(
partnerFunction=PartnerFunctionDTO(
name="FUNCTION_NAME_PLACEHOLDER",
direction="DIRECTION_TYPE", # IMPORT or EXPORT
description="FUNCTION_DESCRIPTION",
objectName="OBJECT_NAME_PLACEHOLDER",
objectMapping="OBJECT_MAPPING_NAME_PLACEHOLDER",
eventName="EVENT_NAME_PLACEHOLDER",
tag="FUNCTION_TAG_PLACEHOLDER"
)
)
connection_uuid = "CONNECTION_UUID_PLACEHOLDER"
partner_function_uuid = "PARTNER_FUNCTION_UUID_PLACEHOLDER"
response = exsited_sdk.integration.update_partner_function(
connection_uuid=connection_uuid,
partner_function_uuid=partner_function_uuid,
request_data=request_obj
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Updating a partner function returns a structured response confirming that the function was successfully modified. The response is represented by a PartnerFunctionUpdateResponseDTO object, which contains updated attributes of the partner function including its UUID, name, direction (IMPORT or EXPORT), event name, provider, and associated object mapping. It also includes metadata such as creation and update timestamps, whether the function is enabled, any pre- or post-execution script IDs, and a custom tag for labeling or categorization. If the update fails due to invalid UUIDs, malformed data, or insufficient permissions, an ABException is raised. This exception contains error messages, backend diagnostic information, and the raw response to support efficient debugging and resolution.
PartnerFunctionUpdateResponseDTO(
uuid="PARTNER_FUNCTION_UUID",
name="FUNCTION_NAME_PLACEHOLDER",
description="FUNCTION_DESCRIPTION_PLACEHOLDER",
direction="DIRECTION_TYPE", # e.g., IMPORT or EXPORT
eventName="EVENT_NAME_PLACEHOLDER",
providerName="PROVIDER_NAME_PLACEHOLDER",
objectName="OBJECT_NAME_PLACEHOLDER",
objectMapping="OBJECT_MAPPING_PLACEHOLDER",
mappingId="MAPPING_ID_PLACEHOLDER",
enabled="BOOLEAN_FLAG",
preRunScriptId="SCRIPT_ID_BEFORE_PLACEHOLDER",
postRunScriptId="SCRIPT_ID_AFTER_PLACEHOLDER",
tag="TAG_LABEL_PLACEHOLDER",
created="CREATED_TIMESTAMP_PLACEHOLDER",
updated="UPDATED_TIMESTAMP_PLACEHOLDER"
)Deleting Integration Connection
Function: connection_delete()
Purpose
This SDK function deletes an existing integration connection by calling the connection_delete() method from the ExsitedSDK. It initializes the SDK with a valid authentication token and sends a request to the backend to remove the specified integration connection identified by its unique UUID. Once deleted, the connection is no longer available for data synchronization or integration workflows.
Parameters
| Parameter | Type | Description |
|---|---|---|
| connection_uuid | String | Unique ID of the integration connection to be deleted. |
Use Case
This function is useful when a developer or system administrator needs to permanently remove an integration connection that is no longer needed or is being replaced. Deleting the connection stops all automated syncs and integrations associated with it. If the UUID is invalid or the user lacks proper permissions, an ABException is raised with detailed error information to aid in troubleshooting and resolution.
def test_delete_integration_connections():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.connection_delete(connection_uuid="CONNECTION_UUID_PLACEHOLDER")
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On successful deletion, the function returns a dictionary confirming the operation, with a 204 status code and a success flag.
{'success': True, 'status_code': 204}Getting Integration Configuration
Function: integration_configuration()
Purpose
This SDK function retrieves the current configuration details of an integration connection by calling the integration_configuration() method from the ExsitedSDK. It initializes the SDK using a valid authentication token and fetches the configuration tied to the provided integration UUID. The response includes configuration data for accounts and transactions, such as import/export mapping, tax settings, default accounts, and invoice behavior.
Parameters
| Parameter | Type | Description |
|---|---|---|
| integration_uuid | String | Unique ID of an integration connection |
Use Case
This function is useful when developers or integration administrators want to view or audit the current settings applied to a given integration. It helps verify mapped accounts, tax logic, synchronization rules, and invoice export behavior before making changes or debugging issues. If the UUID is invalid or permissions are insufficient, an ABException is raised with backend details and raw error output to aid troubleshooting.
def test_get_integration_configuration():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.integration_configuration( integration_uuid="INTEGRATION_UUID_PLACEHOLDER")
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
Response
Calling this function returns a structured response represented by the XeroIntegrationConfigurationResponseDTO. This response encapsulates the current integration configuration for the connected system, categorized into four primary modules: account, item, transaction, and purchase. Each module includes both export and import configurations. Export settings (XeroExportSettingsDTO) define which entity types (such as accounts, items, invoices, payments, credit notes, refunds, purchase orders, and purchase bills) are enabled for outbound synchronization. Import settings are returned as key-value pairs where each key represents a specific data flow (e.g., importing tax details or enabling mappings), and the corresponding value indicates whether that flow is active. These values use string-based booleans like "true" or "false". This structured response allows developers or administrators to verify the active configuration for each integration module and assess what data is being exchanged between the platforms. If the retrieval fails — for instance, due to an invalid integration identifier or insufficient access — an ABException is raised with detailed error messages and the raw response for troubleshooting.
XeroIntegrationConfigurationResponseDTO(
integration=XeroIntegrationDataDTO(
account=XeroAccountDTO(
provider="PROVIDER_NAME_PLACEHOLDER",
accountSyncToXero="BOOLEAN_FLAG",
export=XeroExportSettingsDTO(
accountToXeroEnabled="BOOLEAN_FLAG",
accountToXeroTaxEnable="BOOLEAN_FLAG",
itemToXeroEnabled=None,
productToXeroSalesRevenueEnable=None,
productToXeroTaxEnable=None,
invoiceToXeroEnabled=None,
invoiceToXeroSalesRevenueEnable=None,
invoiceToXeroTaxEnable=None,
paymentToXeroEnabled=None,
creditNoteToXeroEnabled=None,
refundToXeroEnabled=None,
purchaseOrderToXeroEnabled=None,
purchaseOrderToXeroTaxEnable=None,
purchaseInvoiceToXeroEnabled=None,
purchaseInvoiceToXeroTaxEnable=None,
purchasePaymentToXeroEnabled=None,
purchasePaymentToXeroTaxEnable=None,
purchaseCreditNoteToXeroEnabled=None,
purchaseRefundToXeroEnabled=None
),
import_={
accountFromXeroEnabled: "BOOLEAN_FLAG",
accountToXeroAccountReceivableEnable: "BOOLEAN_FLAG",
accountToXeroAccountPayableEnable: "BOOLEAN_FLAG",
accountToXeroTaxEnable: "BOOLEAN_FLAG"
}
),
item=XeroItemDTO(
provider="PROVIDER_NAME_PLACEHOLDER",
itemSyncToXero="BOOLEAN_FLAG",
export=XeroExportSettingsDTO(
accountToXeroEnabled=None,
accountToXeroTaxEnable=None,
itemToXeroEnabled="BOOLEAN_FLAG",
productToXeroSalesRevenueEnable="BOOLEAN_FLAG",
productToXeroTaxEnable="BOOLEAN_FLAG",
invoiceToXeroEnabled=None,
invoiceToXeroSalesRevenueEnable=None,
invoiceToXeroTaxEnable=None,
paymentToXeroEnabled=None,
creditNoteToXeroEnabled=None,
refundToXeroEnabled=None,
purchaseOrderToXeroEnabled=None,
purchaseOrderToXeroTaxEnable=None,
purchaseInvoiceToXeroEnabled=None,
purchaseInvoiceToXeroTaxEnable=None,
purchasePaymentToXeroEnabled=None,
purchasePaymentToXeroTaxEnable=None,
purchaseCreditNoteToXeroEnabled=None,
purchaseRefundToXeroEnabled=None
),
import_={
itemFromXeroEnabled: "BOOLEAN_FLAG",
productFromXeroSalesRevenueEnable: "BOOLEAN_FLAG",
productFromXeroTaxEnable: "BOOLEAN_FLAG"
}
),
transaction=XeroTransactionDTO(
provider="PROVIDER_NAME_PLACEHOLDER",
invoiceSyncToXero="BOOLEAN_FLAG",
paymentSyncToXero="BOOLEAN_FLAG",
creditNoteSyncToXero="BOOLEAN_FLAG",
refundSyncToXero="BOOLEAN_FLAG",
export=XeroExportSettingsDTO(
accountToXeroEnabled=None,
accountToXeroTaxEnable=None,
itemToXeroEnabled=None,
productToXeroSalesRevenueEnable=None,
productToXeroTaxEnable=None,
invoiceToXeroEnabled="BOOLEAN_FLAG",
invoiceToXeroSalesRevenueEnable="BOOLEAN_FLAG",
invoiceToXeroTaxEnable="BOOLEAN_FLAG",
paymentToXeroEnabled="BOOLEAN_FLAG",
creditNoteToXeroEnabled="BOOLEAN_FLAG",
refundToXeroEnabled="BOOLEAN_FLAG",
purchaseOrderToXeroEnabled=None,
purchaseOrderToXeroTaxEnable=None,
purchaseInvoiceToXeroEnabled=None,
purchaseInvoiceToXeroTaxEnable=None,
purchasePaymentToXeroEnabled=None,
purchasePaymentToXeroTaxEnable=None,
purchaseCreditNoteToXeroEnabled=None,
purchaseRefundToXeroEnabled=None
),
import_={
invoiceFromXeroEnabled: "BOOLEAN_FLAG",
invoiceFromXeroSalesRevenueEnable: "BOOLEAN_FLAG",
invoiceFromXeroTaxEnable: "BOOLEAN_FLAG",
paymentFromXeroEnabled: "BOOLEAN_FLAG",
creditNoteFromXeroEnabled: "BOOLEAN_FLAG",
refundFromXeroEnabled: "BOOLEAN_FLAG"
}
),
purchase=XeroPurchaseDTO(
provider="PROVIDER_NAME_PLACEHOLDER",
purchaseOrderSyncToXero="BOOLEAN_FLAG",
purchaseInvoiceSyncToXero="BOOLEAN_FLAG",
purchasePaymentSyncToXero="BOOLEAN_FLAG",
export=XeroExportSettingsDTO(
accountToXeroEnabled=None,
accountToXeroTaxEnable=None,
itemToXeroEnabled=None,
productToXeroSalesRevenueEnable=None,
productToXeroTaxEnable=None,
invoiceToXeroEnabled=None,
invoiceToXeroSalesRevenueEnable=None,
invoiceToXeroTaxEnable=None,
paymentToXeroEnabled=None,
creditNoteToXeroEnabled=None,
refundToXeroEnabled=None,
purchaseOrderToXeroEnabled="BOOLEAN_FLAG",
purchaseOrderToXeroTaxEnable="BOOLEAN_FLAG",
purchaseInvoiceToXeroEnabled="BOOLEAN_FLAG",
purchaseInvoiceToXeroTaxEnable="BOOLEAN_FLAG",
purchasePaymentToXeroEnabled="BOOLEAN_FLAG",
purchasePaymentToXeroTaxEnable="BOOLEAN_FLAG",
purchaseCreditNoteToXeroEnabled="BOOLEAN_FLAG",
purchaseRefundToXeroEnabled="BOOLEAN_FLAG"
),
import_={
purchaseOrderFromXeroEnabled: "BOOLEAN_FLAG",
purchaseOrderFromXeroExpenseEnable: "BOOLEAN_FLAG",
purchaseOrderFromXeroTaxEnable: "BOOLEAN_FLAG",
purchaseBillFromXeroEnabled: "BOOLEAN_FLAG",
purchaseBillFromXeroExpenseEnable: "BOOLEAN_FLAG",
purchaseBillFromXeroTaxEnable: "BOOLEAN_FLAG",
purchasePaymentFromXeroEnabled: "BOOLEAN_FLAG",
purchasePaymentProcessorFromXeroEnable: "BOOLEAN_FLAG",
purchaseCreditNoteFromXeroEnabled: "BOOLEAN_FLAG",
purchaseRefundFromXeroEnabled: "BOOLEAN_FLAG"
}
)
)
)Getting Partner Function List
Function: partner_function_list()
Purpose
This SDK function retrieves a list of partner functions associated with a given integration connection by calling the partner_function_list() method from the ExsitedSDK. It initializes the SDK with a valid authentication token and uses the specified integration UUID to fetch all partner functions available under that connection. Each partner function represents an action or trigger (e.g., import, export, event) tied to specific business logic within the integration.
Parameters
| Parameter | Type | Description |
|---|---|---|
| integration_uuid | String | Unique ID of an integration connection |
Use Case
This function is useful when developers or integration administrators want to retrieve all defined partner functions for a specific integration. This enables them to audit or configure automations, review available triggers and actions, or inspect partner mappings for event handling. If the UUID is invalid or access is unauthorized, the function raises an ABException with detailed backend errors and raw response data for debugging.
def test_get_integration_partner_function_list():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.partner_function_list(integration_uuid='INTEGRATION_UUID_PLACEHOLDER')
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Calling the partner_function_list() function returns a PartnerFunctionListResponseDTO, which includes a list of PartnerFunctionDTO objects representing each partner function configured under the specified integration. Each entry contains metadata such as UUID, name, direction (IMPORT or EXPORT), event name, object name, object mapping, provider, status, and timestamps for creation and updates. It also provides pagination details through PaginationDTO, which helps in navigating large result sets. If the request encounters issues like an invalid integration UUID or insufficient permissions, an ABException is raised with descriptive error messages, backend diagnostics, and the raw API response to support effective debugging.
PartnerFunctionListResponseDTO(
partnerFunctions=[
PartnerFunctionDTO(
uuid="UUID_PLACEHOLDER_1",
name="FUNCTION_NAME_1",
description="FUNCTION_DESCRIPTION_1",
direction="DIRECTION_TYPE_1", # e.g., IMPORT or EXPORT
eventName="EVENT_NAME_1",
providerName="PROVIDER_NAME_1",
objectName="OBJECT_NAME_1",
objectMapping="OBJECT_MAPPING_1",
mappingId="MAPPING_ID_1",
enabled="BOOLEAN_FLAG_1",
preRunScriptId="SCRIPT_BEFORE_ID_1",
postRunScriptId="SCRIPT_AFTER_ID_1",
tag="TAG_1",
created="CREATED_TIMESTAMP_1",
updated="UPDATED_TIMESTAMP_1"
),
PartnerFunctionDTO(
uuid="UUID_PLACEHOLDER_2",
name="FUNCTION_NAME_2",
description="FUNCTION_DESCRIPTION_2",
direction="DIRECTION_TYPE_2",
eventName="EVENT_NAME_2",
providerName="PROVIDER_NAME_2",
objectName="OBJECT_NAME_2",
objectMapping="OBJECT_MAPPING_2",
mappingId="MAPPING_ID_2",
enabled="BOOLEAN_FLAG_2",
preRunScriptId="SCRIPT_BEFORE_ID_2",
postRunScriptId="SCRIPT_AFTER_ID_2",
tag="TAG_2",
created="CREATED_TIMESTAMP_2",
updated="UPDATED_TIMESTAMP_2"
),
PartnerFunctionDTO(
uuid="UUID_PLACEHOLDER_3",
name="FUNCTION_NAME_3",
description="FUNCTION_DESCRIPTION_3",
direction="DIRECTION_TYPE_3",
eventName="EVENT_NAME_3",
providerName="PROVIDER_NAME_3",
objectName="OBJECT_NAME_3",
objectMapping="OBJECT_MAPPING_3",
mappingId="MAPPING_ID_3",
enabled="BOOLEAN_FLAG_3",
preRunScriptId="SCRIPT_BEFORE_ID_3",
postRunScriptId="SCRIPT_AFTER_ID_3",
tag="TAG_3",
created="CREATED_TIMESTAMP_3",
updated="UPDATED_TIMESTAMP_3"
),
PartnerFunctionDTO(
uuid="UUID_PLACEHOLDER_4",
name="FUNCTION_NAME_4",
description="FUNCTION_DESCRIPTION_4",
direction="DIRECTION_TYPE_4",
eventName="EVENT_NAME_4",
providerName="PROVIDER_NAME_4",
objectName="OBJECT_NAME_4",
objectMapping="OBJECT_MAPPING_4",
mappingId="MAPPING_ID_4",
enabled="BOOLEAN_FLAG_4",
preRunScriptId="SCRIPT_BEFORE_ID_4",
postRunScriptId="SCRIPT_AFTER_ID_4",
tag="TAG_4",
created="CREATED_TIMESTAMP_4",
updated="UPDATED_TIMESTAMP_4"
)
],
pagination=PaginationDTO(
records=TOTAL_RECORDS,
limit=PAGE_LIMIT,
offset=PAGE_OFFSET,
previousPage="PREV_PAGE_URL_OR_EMPTY",
nextPage="NEXT_PAGE_URL_OR_NULL"
)
)Getting Partner Function Details by ID
Function: partner_function_details()
Purpose
This SDK function retrieves the details of a specific partner function under a given integration. It calls the partner_function_details() method from the ExsitedSDK, using a valid authentication token. The function fetches configuration attributes such as name, direction, object mapping, event trigger, and other metadata associated with the partner function. This enables the user to programmatically access the setup of a particular partner function without navigating through the UI.
Parameters
| Parameter | Type | Description |
|---|---|---|
| integration_uuid | String | Unique ID of the integration connection. |
| partner_function_uuid | String | Unique ID of the partner function to retrieve. |
Use Case
This function is useful when developers or administrators need to inspect or verify the configuration of a specific partner function — for example, to confirm mappings, tags, or trigger logic. It supports debugging, validation, and display of integration metadata in custom tools or dashboards. If the provided UUIDs are invalid or access is restricted, an ABException is raised with detailed error messages and the raw backend response to facilitate troubleshooting.
def test_get_integration_partner_function_details():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.partner_function_details(integration_uuid='INTEGRATION_UUID_PLACEHOLDER', partner_function_uuid='PARTNER_FUNCTION_UUID_PLACEHOLDER')
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Calling this function returns the details of a single partner function in a structured response, represented by a PartnerFunctionDetailsResponseDTO, which wraps a PartnerFunctionDTO object. This includes all configuration details such as the partner function's uuid, name, description, direction (e.g., IMPORT), eventName, providerName, objectName, and objectMapping. It also contains mapping identifiers, enabled status, optional pre- and post-run script IDs, tag, and timestamps for created and updated. This response enables consumers of the SDK to retrieve and inspect the setup of an individual partner function. If the request fails, an ABException is raised containing descriptive error information and the raw backend response for effective debugging.
PartnerFunctionDetailsResponseDTO(
partnerFunction=PartnerFunctionDTO(
uuid="PARTNER_FUNCTION_UUID",
name="FUNCTION_NAME_PLACEHOLDER",
description="FUNCTION_DESCRIPTION_PLACEHOLDER",
direction="DIRECTION_TYPE", # e.g., IMPORT or EXPORT
eventName="EVENT_NAME_PLACEHOLDER",
providerName="PROVIDER_NAME_PLACEHOLDER",
objectName="OBJECT_NAME_PLACEHOLDER",
mappingId="MAPPING_ID_PLACEHOLDER",
enabled="BOOLEAN_FLAG",
preRunScriptId="PRE_RUN_SCRIPT_ID_PLACEHOLDER",
postRunScriptId="POST_RUN_SCRIPT_ID_PLACEHOLDER",
tag="TAG_PLACEHOLDER",
created="CREATED_TIMESTAMP_PLACEHOLDER",
updated="UPDATED_TIMESTAMP_PLACEHOLDER",
objectMapping="OBJECT_MAPPING_PLACEHOLDER"
)
)Getting Integration Automation List
Function: automation_list()
Purpose
This SDK function retrieves a list of automation configurations linked to a specified integration. It calls the automation_list() method from the ExsitedSDK, initializing the SDK with a valid authentication token and supplying the integration UUID. The function fetches automation metadata such as name, type (timer-based, event-based, etc.), execution frequency, trigger conditions, and direction (IMPORT/EXPORT) for each automation.
Parameters
| Parameter | Type | Description |
|---|---|---|
| integration_uuid | String | Unique ID of the integration connection. |
Use Case
This function is useful when developers or integration administrators need to view all existing automations configured under a particular integration. It supports audit, monitoring, and management activities by providing details about each automation’s purpose and behavior. If the integration UUID is incorrect or inaccessible, an ABException is raised, providing backend error messages and raw response data to assist in resolution.
def test_get_integration_automation_list():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.automation_list(integration_uuid='INTEGRATION_UUID_PLACEHOLDER')
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
The function returns an AutomationListResponseDTO containing a list of IntegrationAutomationDTO objects. Each object represents a configured automation under the integration and includes key details such as UUID, name, display name, code, direction (e.g., IMPORT or EXPORT), automation type (e.g., timerBased), execution interval (checkOn), trigger condition text, and partner function references. It also includes metadata like status, provider name, and timestamps for creation and updates. The response supports pagination through a PaginationDTO object, which includes information like record count, limit, offset, and navigation references. If the request encounters issues such as an invalid integration UUID or permission errors, an ABException is raised, providing descriptive error messages and backend response content to assist with resolution.
IntegrationAutomationListResponseDTO(
integrationAutomations=[
IntegrationAutomationDTO(
checkOn="CHECK_INTERVAL_PLACEHOLDER",
checkOnMinutes="CHECK_INTERVAL_MINUTES_PLACEHOLDER",
additionalCriteria="BOOLEAN_FLAG",
appliesTo="ENTITY_TYPE_PLACEHOLDER",
appliesToFunction="FUNCTION_TYPE_PLACEHOLDER",
automationType="AUTOMATION_TYPE_PLACEHOLDER",
code="AUTOMATION_CODE_PLACEHOLDER",
customDay="CUSTOM_DAY_PLACEHOLDER",
customDayTime="CUSTOM_DAY_TIME_PLACEHOLDER",
customTime="CUSTOM_TIME_PLACEHOLDER",
description="AUTOMATION_DESCRIPTION_PLACEHOLDER",
direction="DIRECTION_PLACEHOLDER", # e.g., IMPORT or EXPORT
displayName="DISPLAY_NAME_PLACEHOLDER",
name="AUTOMATION_NAME_PLACEHOLDER",
performFunction="FUNCTION_UUID_PLACEHOLDER",
provider="PROVIDER_NAME_PLACEHOLDER",
status="AUTOMATION_STATUS_PLACEHOLDER",
uuid="AUTOMATION_UUID_PLACEHOLDER",
triggerConditionText="TRIGGER_CONDITION_TEXT_PLACEHOLDER",
performActionText="ACTION_TEXT_PLACEHOLDER",
checkOnText="CHECK_INTERVAL_TEXT_PLACEHOLDER"
)
],
pagination=PaginationDTO(
records=TOTAL_RECORDS_PLACEHOLDER,
limit=LIMIT_PLACEHOLDER,
offset=OFFSET_PLACEHOLDER,
previousPage="PREVIOUS_PAGE_PLACEHOLDER",
nextPage="NEXT_PAGE_PLACEHOLDER"
)
)Getting Integration Automation Details by ID
Function: automation_details()
Purpose
This SDK function retrieves the details of a specific automation configured under an integration connection. It uses the automation_details() method of the ExsitedSDK, initialized with a valid authentication token. The function requires both the integration_uuid and the automation_uuid to locate and return the full configuration of the automation, including execution settings, type, direction, criteria, and linked partner functions.
Parameters
| Parameter | Type | Description |
|---|---|---|
| integration_uuid | String | Unique ID of the integration connection. |
| automation_uuid | String | Unique ID of the automation to retrieve details. |
Use Case
This function is useful when developers or integration admins need to inspect the current configuration of an automation—such as to validate settings before updating, auditing automation behavior, or troubleshooting integration issues. It returns all relevant configuration fields so that they can be reviewed or reused in future operations.
def test_get_integration_automation_details():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
try:
response = exsited_sdk.integration.automation_details(integration_uuid="INTEGRATION_UUID_PLACEHOLDER", automation_uuid="AUTOMATION_UUID_PLACEHOLDER")
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
Retrieving automation details returns a structured response represented by an IntegrationAutomationDetailsResponseDTO, which encapsulates an IntegrationAutomationDTO containing the full configuration of the automation. This includes metadata such as the automation’s UUID, name, and code, along with technical configurations like trigger type (timerBased), execution frequency (checkOn), direction (IMPORT or EXPORT), and status (ACTIVE). It also includes contextual attributes such as which entity the automation applies to (supplier), the associated partner function (performFunction), and descriptive fields like display name and custom notes. Optional fields like performActionText and checkOnText may be null if not explicitly set. If the automation UUID is invalid or access is restricted, an ABException is thrown with diagnostic messages and the raw backend response to assist in troubleshooting.
IntegrationAutomationDetailsResponseDTO(
integrationAutomation=IntegrationAutomationDTO(
checkOn="CHECK_INTERVAL",
checkOnMinutes="CHECK_INTERVAL_MINUTES",
additionalCriteria="BOOLEAN_FLAG",
appliesTo="ENTITY_TYPE",
appliesToFunction="FUNCTION_TYPE",
automationType="AUTOMATION_TYPE",
code="AUTOMATION_CODE",
customDay="CUSTOM_DAY",
customDayTime="CUSTOM_DAY_TIME",
customTime="CUSTOM_TIME",
description="AUTOMATION_DESCRIPTION",
direction="DIRECTION_TYPE",
displayName="AUTOMATION_DISPLAY_NAME",
name="AUTOMATION_NAME",
performFunction="FUNCTION_UUID",
provider="PROVIDER_NAME",
status="AUTOMATION_STATUS",
uuid="AUTOMATION_UUID",
triggerConditionText="TRIGGER_CONDITION_LABEL",
performActionText="ACTION_LABEL_PLACEHOLDER",
checkOnText="CHECK_INTERVAL_LABEL"
)
)