Getting Purchase Order List
Function: purchase_order_list()
Purpose
This SDK function retrieves a paginated list of all purchase orders available to the authenticated account. It returns essential header-level purchase order information along with nested details such as currency, supplier invoice linkage, totals, tax details, custom attributes, and item line breakdowns. This operation is commonly used for reporting, auditing, listing purchase order summaries in dashboards, or retrieving identifiers for further API operations.
Parameters
| Parameter | Type | Description |
|---|---|---|
| limit | integer | Optional. Number of records to return per page. |
| offset | integer | Optional. Starting point for paginated results. |
Use Case
This function is used when a system needs to display, process, or audit a list of purchase orders. For example, an inventory control officer or purchasing department may call this endpoint to retrieve all purchase orders created within a financial period, to review pending orders, or to extract item-level purchasing information for reconciliation. Using the SDK, a developer can quickly list purchase orders without manually constructing HTTP requests.
def purchase_order_list():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.list()
print(response)
# ResponseToObj().process(response=response["purchase_orders"][0])
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)public function purchaseOrderList()
{
try {
$response = $this->purchaseOrderService->readAll('v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}Response
The function returns a structured list of purchase orders along with pagination metadata. Each purchase order includes identifiers, status, currency information, supplier invoice links, issue and due dates, subtotal, tax, total amounts, notes, custom attributes, and a detailed list of line items including item quantities, tax configuration, accounting codes, and pricing snapshots. The SDK formats this into objects or associative arrays so developers can easily extract values or iterate through multiple purchase order records.
{
"purchaseOrders": [
{
"status": "STATUS_PLACEHOLDER",
"id": "PURCHASE_ORDER_ID_PLACEHOLDER",
"currency": {
"uuid": "CURRENCY_UUID_PLACEHOLDER",
"name": "CURRENCY_NAME_PLACEHOLDER",
"link": "CURRENCY_LINK_PLACEHOLDER"
},
"supplierInvoiceId": "SUPPLIER_INVOICE_ID_PLACEHOLDER",
"saleOrderId": "SALE_ORDER_ID_PLACEHOLDER",
"issueDate": "ISSUE_DATE_PLACEHOLDER",
"dueDate": "DUE_DATE_PLACEHOLDER",
"expectedCompletionDate": "EXPECTED_COMPLETION_DATE_PLACEHOLDER",
"subtotal": "SUBTOTAL_PLACEHOLDER",
"tax": "TAX_PLACEHOLDER",
"total": "TOTAL_PLACEHOLDER",
"priceTaxInclusive": "PRICE_TAX_INCLUSIVE_PLACEHOLDER",
"purchaseOrderNote": "PURCHASE_ORDER_NOTE_PLACEHOLDER",
"accountId": "ACCOUNT_ID_PLACEHOLDER",
"createdBy": "CREATED_BY_PLACEHOLDER",
"createdOn": "CREATED_ON_PLACEHOLDER",
"lastUpdatedBy": "LAST_UPDATED_BY_PLACEHOLDER",
"lastUpdatedOn": "LAST_UPDATED_ON_PLACEHOLDER",
"uuid": "PURCHASE_ORDER_UUID_PLACEHOLDER",
"version": "VERSION_PLACEHOLDER",
"customAttributes": [],
"customObjects": [],
"lines": [
{
"subtotal": "LINE_SUBTOTAL_PLACEHOLDER",
"total": "LINE_TOTAL_PLACEHOLDER",
"tax": "LINE_TAX_PLACEHOLDER",
"itemUuid": "ITEM_UUID_PLACEHOLDER",
"itemId": "ITEM_ID_PLACEHOLDER",
"itemName": "ITEM_NAME_PLACEHOLDER",
"itemQuantity": "ITEM_QUANTITY_PLACEHOLDER"
}
]
}
],
"pagination": {
"records": RECORDS_PLACEHOLDER,
"limit": LIMIT_PLACEHOLDER,
"offset": OFFSET_PLACEHOLDER,
"previousPage": "PREVIOUS_PAGE_PLACEHOLDER",
"nextPage": "NEXT_PAGE_PLACEHOLDER"
}
}
{
"purchase_orders": [
{
"status": "ACTIVE",
"id": "PO-53KROS-0002",
"currency": {
"uuid": "4f444464-defa-4180-a18e-e2bf4b5a84a1",
"name": "AUD",
"link": "https:\/\/dev-api.exsited.com\/api\/v1\/currencies\/4f444464-defa-4180-a18e-e2bf4b5a84a1"
},
"supplier_invoice_id": "",
"origin": "",
"issue_date": "2025-06-26T00:00:00Z",
"due_date": "2025-06-26T00:00:00Z",
"expected_completion_date": "",
"subtotal": "22.220000",
"tax": "0.000000",
"total": "22.220000",
"price_tax_inclusive": "false",
"purchase_order_note": "",
"account_id": "53KROS",
"created_by": "TestApp",
"created_on": "2025-06-26T11:13:09Z",
"last_updated_by": "",
"last_updated_on": "2025-06-26T11:13:09Z",
"uuid": "dcc49ba3-8ca3-4096-b5ee-b26541c359ad",
"version": "2",
"custom_form": {
"uuid": "a8cd4bf3-5d8c-4753-aae2-fa2723dc7de8",
"name": "Default for Purchase Order"
},
"custom_attributes": [],
"custom_objects": [],
"lines": [
{
"subtotal": "22.220000",
"total": "22.220000",
"tax": "0.000000",
"item_uuid": "3ce93e34-ac13-424c-9d3f-586c4c57a610",
"item_id": "ITEM-0010",
"item_name": "testItem",
"item_quantity": "2.000000",
"item_price_snapshot": {
"pricing_rule": {
"uuid": "",
"version": "",
"price_type": "",
"price": "",
"uom": "",
"warehouse": "BareHouse",
"pricing_version": ""
}
},
"item_purchase_tax_configuration": {
"purchase_price_is_tax_inclusive": "false",
"tax_code": {}
},
"item_price_tax_exempt": "false",
"item_price_tax": {
"rate": "0.000000"
},
"purchase_order_note": "",
"item_accounting_code": {
"cost_of_goods_sold": ""
},
"uuid": "4e50b651-052d-429e-bd56-74f324e0e9ed",
"version": "1"
}
],
"kpis": {
"total_expense": 0,
"estimated_total": 0,
"total_outstanding": 0,
"total_overdue": 0,
"last_invoice_issue_date": "",
"last_invoice_total": 0,
"total_purchase_invoice": 0,
"last_reactivated_on": "",
"last_calcelled_on": "",
"last_changed_on": "",
"last_deleted_on": "",
"issue_date": ""
}
},
{
"status": "ACTIVE",
"id": "PO-53KROS-0003",
"currency": {
"uuid": "4f444464-defa-4180-a18e-e2bf4b5a84a1",
"name": "AUD",
"link": "https:\/\/dev-api.exsited.com\/api\/v1\/currencies\/4f444464-defa-4180-a18e-e2bf4b5a84a1"
},
"supplier_invoice_id": "",
"origin": "",
"issue_date": "2025-06-26T00:00:00Z",
"due_date": "2025-06-26T00:00:00Z",
"expected_completion_date": "",
"subtotal": "133.320000",
"tax": "0.000000",
"total": "133.320000",
"price_tax_inclusive": "false",
"purchase_order_note": "",
"account_id": "53KROS",
"created_by": "TestApp",
"created_on": "2025-06-26T11:22:37Z",
"last_updated_by": "",
"last_updated_on": "2025-06-26T11:22:37Z",
"uuid": "503961be-3e5f-468f-b5ec-caf688fed6e2",
"version": "2",
"custom_form": {
"uuid": "a8cd4bf3-5d8c-4753-aae2-fa2723dc7de8",
"name": "Default for Purchase Order"
},
"custom_attributes": [],
"custom_objects": [],
"lines": [
{
"subtotal": "133.320000",
"total": "133.320000",
"tax": "0.000000",
"item_uuid": "3ce93e34-ac13-424c-9d3f-586c4c57a610",
"item_id": "ITEM-0010",
"item_name": "testItem",
"item_quantity": "2.000000",
"item_price_snapshot": {
"pricing_rule": {
"uuid": "",
"version": "",
"price_type": "",
"price": "",
"uom": "",
"warehouse": "BareHouse",
"pricing_version": ""
}
},
"item_purchase_tax_configuration": {
"purchase_price_is_tax_inclusive": "false",
"tax_code": {}
},
"item_price_tax_exempt": "false",
"item_price_tax": {
"rate": "0.000000"
},
"purchase_order_note": "",
"item_accounting_code": {
"cost_of_goods_sold": ""
},
"uuid": "67e5899e-ca54-4b21-9860-8753709bfb70",
"version": "1"
}
],
"kpis": {
"total_expense": 0,
"estimated_total": 0,
"total_outstanding": 0,
"total_overdue": 0,
"last_invoice_issue_date": "",
"last_invoice_total": 0,
"total_purchase_invoice": 0,
"last_reactivated_on": "",
"last_calcelled_on": "",
"last_changed_on": "",
"last_deleted_on": "",
"issue_date": ""
}
}
],
"pagination": {
"records": 25,
"limit": 20,
"offset": 0,
"previous_page": "",
"next_page": "https:\/\/dev-api.exsited.comapi\/v2\/purchase-orders?limit=20&offset=20"
}Getting Purchase Order Details
Function: purchase_order_details()
Purpose
This function allows user to retrieve the complete details of a specific purchase order by providing its unique purchase order identifier. It is typically used when validating purchase order data, displaying order information within applications, syncing order data with external systems, or performing accounting and procurement operations. The response returns all relevant attributes, including currency information, dates, line items, pricing snapshots, tax configurations, KPIs, and other metadata associated with the purchase order.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_order_id | String | The unique identifier of the purchase order whose details are to be retrieved. This must be a valid purchase order ID that already exists in the system. |
Use Case
This function is used when a system or user needs to fetch the full details of a specific purchase order for validation, display, or integration purposes. For example, when building a procurement dashboard, an application may need to load all items, pricing information, tax details, and metadata associated with a purchase order. Similarly, QA testers may use this to validate that the order exists, verify field values, check correct handling of tax-inclusive pricing, and ensure nested structures such as KPIs, custom attributes, and line details are being returned correctly.
def purchase_order_details():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "PATH_TO_TOKEN_FILE.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.details(id='{{PURCHASE_ORDER_ID}}')
print(response)
return response
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
public function purchaseOrderDetails()
{
$id = 'PO-53KROS-0002';
try {
$response = $this->purchaseOrderService->readDetails($id,'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}Response
The response returns a complete purchase order object containing status, currency information, dates, totals, pricing details, line items, tax configurations, metadata, KPIs, and UUID references. Each nested object describes a specific portion of the purchase order such as item-level tax details, pricing snapshots, accounting codes, and custom attributes. This response structure ensures that integrators, developers, and testers have full visibility into every element of a purchase order for validation, automation, or system-to-system synchronization. The exact values shown below are placeholders and should be replaced with the real values returned from your environment.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderDTO(
status='{{STATUS}}',
id='{{PURCHASE_ORDER_ID}}',
currency=PurchaseOrderCurrencyDTO(
uuid='{{CURRENCY_UUID}}',
name='{{CURRENCY_NAME}}',
link='{{CURRENCY_LINK}}'
),
supplierInvoiceId='{{SUPPLIER_INVOICE_ID}}',
saleOrderId='{{SALE_ORDER_ID}}',
issueDate='{{ISSUE_DATE}}',
dueDate='{{DUE_DATE}}',
expectedCompletionDate='{{EXPECTED_COMPLETION_DATE}}',
subtotal='{{SUBTOTAL}}',
tax='{{TAX}}',
total='{{TOTAL}}',
priceTaxInclusive='{{PRICE_TAX_INCLUSIVE}}',
purchaseOrderNote='{{PURCHASE_ORDER_NOTE}}',
accountId='{{ACCOUNT_ID}}',
createdBy='{{CREATED_BY}}',
createdOn='{{CREATED_ON}}',
lastUpdatedBy='{{LAST_UPDATED_BY}}',
lastUpdatedOn='{{LAST_UPDATED_ON}}',
uuid='{{PURCHASE_ORDER_UUID}}',
version='{{VERSION}}',
customAttributes=[],
customObjects=[],
lines=[
PurchaseOrderLineDTO(
subtotal='{{LINE_SUBTOTAL}}',
total='{{LINE_TOTAL}}',
tax='{{LINE_TAX}}',
itemUuid='{{ITEM_UUID}}',
itemId='{{ITEM_ID}}',
itemName='{{ITEM_NAME}}',
itemQuantity='{{ITEM_QUANTITY}}',
itemOrderQuantity='{{ITEM_ORDER_QUANTITY}}',
itemPriceSnapshot=PurchaseOrderItemPriceSnapshotDTO(
pricingRule=PurchaseOrderPricingRuleDTO(
uuid='{{PRICING_RULE_UUID}}',
version='{{PRICING_RULE_VERSION}}',
priceType='{{PRICE_TYPE}}',
price='{{PRICE}}',
uom='{{UOM}}',
warehouse='{{WAREHOUSE}}',
pricingVersion='{{PRICING_VERSION}}',
latestUsedPricingVersion='{{LATEST_USED_PRICING_VERSION}}'
)
),
itemPurchaseTaxConfiguration=PurchaseOrderItemPurchaseTaxConfigurationDTO(
purchasePriceIsTaxInclusive='{{ITEM_TAX_INCLUSIVE}}',
taxCode=PurchaseOrderTaxCodeDTO(
uuid='{{TAX_CODE_UUID}}',
code='{{TAX_CODE}}',
rate='{{TAX_RATE}}',
link='{{TAX_LINK}}'
)
),
itemPriceTaxExempt='{{ITEM_PRICE_TAX_EXEMPT}}',
itemPriceTax=TaxDTO(
uuid='{{TAX_UUID}}',
code='{{TAX_CODE}}',
rate='{{TAX_RATE}}',
link='{{TAX_LINK}}',
amount='{{TAX_AMOUNT}}'
),
purchaseOrderNote='{{LINE_NOTE}}',
itemAccountingCode=PurchaseOrderItemAccountingCodeDTO(
costOfGoodsSold='{{COGS}}'
),
op='{{OPERATION}}',
uuid='{{LINE_UUID}}',
version='{{LINE_VERSION}}',
itemSerialOrBatchNumber='{{SERIAL_OR_BATCH}}',
taxExemptWhenSold='{{TAX_EXEMPT_WHEN_SOLD}}'
)
],
kpis=KPIDTO(
totalExpense='{{TOTAL_EXPENSE}}',
estimatedTotal='{{ESTIMATED_TOTAL}}',
totalOutstanding='{{TOTAL_OUTSTANDING}}',
totalOverdue='{{TOTAL_OVERDUE}}',
lastInvoiceIssueDate='{{LAST_INVOICE_ISSUE_DATE}}',
lastInvoiceTotal='{{LAST_INVOICE_TOTAL}}',
totalPurchaseInvoice='{{TOTAL_PURCHASE_INVOICE}}',
lastReactivatedOn='{{LAST_REACTIVATED_ON}}',
lastCalcelledOn='{{LAST_CANCELLED_ON}}',
lastChangedOn='{{LAST_CHANGED_ON}}',
lastDeletedOn='{{LAST_DELETED_ON}}',
issueDate='{{KPI_ISSUE_DATE}}'
)
)
)
{
"purchase_order": {
"status": "ACTIVE",
"id": "PO-53KROS-0002",
"currency": {
"uuid": "4f444464-defa-4180-a18e-e2bf4b5a84a1",
"name": "AUD",
"link": "https:\/\/dev-api.exsited.com\/api\/v1\/currencies\/4f444464-defa-4180-a18e-e2bf4b5a84a1"
},
"supplier_invoice_id": "",
"origin": "",
"issue_date": "2025-06-26T00:00:00Z",
"due_date": "2025-06-26T00:00:00Z",
"expected_completion_date": "",
"subtotal": "22.220000",
"tax": "0.000000",
"total": "22.220000",
"price_tax_inclusive": "false",
"purchase_order_note": "",
"account_id": "53KROS",
"created_by": "TestApp",
"created_on": "2025-06-26T11:13:09Z",
"last_updated_by": "",
"last_updated_on": "2025-06-26T11:13:09Z",
"uuid": "dcc49ba3-8ca3-4096-b5ee-b26541c359ad",
"version": "2",
"custom_form": {
"uuid": "a8cd4bf3-5d8c-4753-aae2-fa2723dc7de8",
"name": "Default for Purchase Order"
},
"custom_attributes": [],
"custom_objects": [],
"lines": [
{
"subtotal": "22.220000",
"total": "22.220000",
"tax": "0.000000",
"item_uuid": "3ce93e34-ac13-424c-9d3f-586c4c57a610",
"item_id": "ITEM-0010",
"item_name": "testItem",
"item_quantity": "2.000000",
"item_price_snapshot": {
"pricing_rule": {
"uuid": "",
"version": "",
"price_type": "",
"price": "",
"uom": "",
"warehouse": "BareHouse",
"pricing_version": ""
}
},
"item_purchase_tax_configuration": {
"purchase_price_is_tax_inclusive": "false",
"tax_code": {}
},
"item_price_tax_exempt": "false",
"item_price_tax": {
"rate": "0.000000"
},
"purchase_order_note": "",
"item_accounting_code": {
"cost_of_goods_sold": ""
},
"uuid": "4e50b651-052d-429e-bd56-74f324e0e9ed",
"version": "1"
}
],
"kpis": {
"total_expense": 0,
"estimated_total": 0,
"total_outstanding": 0,
"total_overdue": 0,
"last_invoice_issue_date": "",
"last_invoice_total": 0,
"total_purchase_invoice": 0,
"last_reactivated_on": "",
"last_calcelled_on": "",
"last_changed_on": "",
"last_deleted_on": "",
"issue_date": ""
}
}Deleting a Purchase Order
Function: purchase_order_delete()
Purpose
This function deletes a purchase order by its unique ID. It is implemented in both Python and PHP SDKs, allowing developers to seamlessly integrate deletion functionality into their applications. The function ensures that obsolete or incorrect purchase orders can be removed from the system, maintaining clean and accurate procurement records.
Parameters
| Parameter | Type | Description |
|---|---|---|
| order_id | String | The unique identifier of the purchase order to delete |
Use Case
The function is used to remove a purchase order that is no longer valid, such as test data, duplicate entries, or incorrect records. By specifying the purchase order ID, the system executes a deletion request, ensuring that procurement and financial records remain consistent and up to date. This is particularly useful in workflows where maintaining accurate supplier and order data is critical.
def purchase_order_delete():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.delete(id='PURCHASE_ORDER_ID')
print(response)
return response
# ResponseToObj().process(response=response["purchase_order"])
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)public function purchaseOrderDelete()
{
$id = 'PURCHASE_ORDER_ID';
try {
$response = $this->purchaseOrderService->delete($id,'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}Response
The response returns a simple object confirming the outcome of the deletion request. A successful deletion is indicated with 204 status code represents a successful operation with no content returned. If the deletion fails, the response will reflect the error state, allowing developers to handle exceptions appropriately.
{'success': True, 'status_code': 204}nullGetting Purchase Order Information
Function: purchase_order_information()
Purpose
This function retrieves detailed information about a specific purchase order by its unique ID. It provides access to order metadata, supplier linkage, currency details, financial values, and notes, ensuring that procurement teams can accurately track and manage purchase orders.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_id | String | The unique identifier of the purchase order |
Use Case
The function is used to review or validate the details of an existing purchase order. By specifying the purchase order ID, organizations can access information such as supplier invoice references, issue and due dates, expected completion dates, and financial metrics like subtotal, tax, and total. This supports procurement workflows, auditing, and compliance by ensuring visibility into the lifecycle of individual purchase orders.
def purchase_order_information():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.information(id='PURCHASE_ORDER_ID')
print(response)
return response
# ResponseToObj().process(response=response["purchase_order"])
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)public function purchaseOrderInformation()
{
$id = 'PURCHASE_ORDER_ID';
try {
$response = $this->purchaseOrderService->readDetailsInformation($id,'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}Response
The response returns a object containing comprehensive details of the specified purchase order. It includes identifiers such as the purchase order ID and UUID, supplier account linkage, currency information, issue and due dates, and versioning metadata. Financial values such as subtotal, tax, and total are provided, along with flags for tax inclusivity and purchase order notes. Metadata fields like createdBy, createdOn, lastUpdatedBy, and lastUpdatedOn confirm the record’s history. In this case, line items.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderDTO(
status="PURCHASE_ORDER_STATUS",
id="PURCHASE_ORDER_ID",
currency=PurchaseOrderCurrencyDTO(
uuid="CURRENCY_UUID",
name="CURRENCY_NAME",
link="CURRENCY_LINK"
),
supplierInvoiceId="SUPPLIER_INVOICE_ID",
issueDate="ISSUE_DATE",
dueDate="DUE_DATE",
expectedCompletionDate="EXPECTED_COMPLETION_DATE",
subtotal="PURCHASE_ORDER_SUBTOTAL",
tax="PURCHASE_ORDER_TAX",
total="PURCHASE_ORDER_TOTAL",
priceTaxInclusive="BOOLEAN",
purchaseOrderNote="PURCHASE_ORDER_NOTE",
accountId="ACCOUNT_ID",
createdBy="CREATED_BY",
createdOn="CREATED_TIMESTAMP",
lastUpdatedBy="LAST_UPDATED_BY",
lastUpdatedOn="LAST_UPDATED_TIMESTAMP",
uuid="PURCHASE_ORDER_UUID",
version="PURCHASE_ORDER_VERSION",
customAttributes=[],
customObjects=[],
lines="PURCHASE_ORDER_LINES",
kpis="PURCHASE_ORDER_KPIS"
)
){
"purchase_order": {
"status": "PURCHASE_ORDER_STATUS",
"id": "PURCHASE_ORDER_ID",
"currency": {
"uuid": "CURRENCY_UUID",
"name": "CURRENCY_NAME",
"link": "CURRENCY_LINK"
},
"supplier_invoice_id": "SUPPLIER_INVOICE_ID",
"issue_date": "ISSUE_DATE",
"due_date": "DUE_DATE",
"expected_completion_date": "EXPECTED_COMPLETION_DATE",
"subtotal": "PURCHASE_ORDER_SUBTOTAL",
"tax": "PURCHASE_ORDER_TAX",
"total": "PURCHASE_ORDER_TOTAL",
"price_tax_inclusive": "BOOLEAN",
"purchase_order_note": "PURCHASE_ORDER_NOTE",
"account_id": "ACCOUNT_ID",
"created_by": "CREATED_BY",
"created_on": "CREATED_TIMESTAMP",
"last_updated_by": "LAST_UPDATED_BY",
"last_updated_on": "LAST_UPDATED_TIMESTAMP",
"uuid": "PURCHASE_ORDER_UUID",
"version": "PURCHASE_ORDER_VERSION",
"custom_attributes": [],
"custom_objects": []
},
"autobillCredential": {
"apiUrl": "API_URL",
"appUrl": "APP_URL",
"ClientId": "CLIENT_ID",
"ClientSecret": "CLIENT_SECRET",
"file_path": "FILE_PATH"
}
}Canceling a Purchase Order
Function: purchase_order_cancel()
Purpose
This function cancels a specific purchase order using its unique identifier. It ensures that active or pending purchase orders can be terminated when no longer required, helping businesses maintain accurate procurement records and avoid processing unnecessary transactions.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_order_id | string | The unique identifier of the purchase order to cancel. |
Use Case
The function is used to cancel an existing purchase order that is either active or pending. Typical scenarios include supplier changes, incorrect order creation, or adjustments in procurement plans. By providing the purchase order ID, the system executes a cancellation request, ensuring that procurement workflows remain consistent and free from obsolete records.
def purchase_order_cancel():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.cancel(id="PURCHASE_ORDER_ID")
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)public function purchaseOrderCancel()
{
$id = 'PURCHASE_ORDER_ID';
try {
$response = $this->purchaseOrderService->cancel($id,'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}Response
The response returns a confirmation object indicating the outcome of the cancellation request. A successful cancellation is represented that the operation was successful and no content is returned. If the cancellation fails, the response will include an error message or status code, allowing developers and QA teams to handle exceptions appropriately.
{'success': True, 'status_code': 204}
nullReactivating a Purchase Order
Function: purchase_order_reactivate()
Purpose
This function reactivates a previously canceled purchase order using its unique identifier. It ensures that purchase orders which were terminated can be restored to an active state, allowing businesses to continue processing transactions or managing procurement workflows without needing to recreate the order.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_order_id | string | Unique identifier of the purchase order to reactivate. |
Use Case
The function is used to bring a canceled purchase order back into circulation. Typical scenarios include reinstating an order after supplier confirmation, correcting accidental cancellations, or resuming procurement processes that were paused. By specifying the purchase order ID, the system reactivates the order, enabling further updates, invoicing, or fulfillment activities.
def purchase_order_reactivate():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.reactivate(id="PURCHASE_ORDER_ID")
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)public function purchaseOrderReactivate()
{
$id = 'PURCHASE_ORDER_ID';
try {
$response = $this->purchaseOrderService->reactivate($id,'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}Response
The response returns a confirmation object indicating the outcome of the reactivation request. A successful reactivation is represented that the operation was successful and no content is returned. If the reactivation fails, the response will include an error message or status code, allowing developers and QA teams to handle exceptions appropriately.
{'success': True, 'status_code': 204}NULLGetting Specific Line Details of a Purchase order
Function: purchase_order_line_details()
Purpose
Retrieves detailed information about a specific line item within a purchase order using its unique line UUID. This allows you to review the exact status, pricing, quantities, and related metadata of a particular line in the purchase order.
Parameters
|
Parameter |
Type |
Description |
|---|---|---|
|
purchase_order_id |
String |
The unique identifier of the purchase order |
|
line_uuid |
String |
The unique line UUID associated with the order |
Use Case
Use this function when you need to inspect or verify the details of a specific line in a purchase order. For example, a retailer might need to confirm pricing, quantity, item specifications, or other key attributes before processing a shipment or updating inventory. This can also help in identifying discrepancies in a complex order where multiple items, custom attributes, or special conditions are involved, ensuring that each line is accurately managed and accounted for in operational workflows.
def purchase_order_line_details():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.line_uuid(id='PURCHASE_ORDER_ID', uuid='LINE_UUID')
print(response)
return response
# ResponseToObj().process(response=response["purchase_order"])
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
public function purchaseOrderLineDetails()
{
$id = 'PURCHASE_ORDER_ID';
$lineUUID = 'LINE_UUID';
try {
$response = $this->purchaseOrderService->readLineDetails($id,$lineUUID,'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}Response
A response object containing the detailed information for the specified purchase order line, including item details, pricing, and any associated attributes.
PurchaseOrderLineUuidDetailsDTO(
purchaseOrder=PurchaseOrderLineUuidDTO(
line=PurchaseOrderLineDTO(
subtotal='subtotal',
total='total',
tax='tax',
itemUuid='item_uuid',
itemId='item_id',
itemName='item_name',
itemQuantity='item_quantity',
itemOrderQuantity='item_order_quantity',
itemPriceSnapshot=PurchaseOrderItemPriceSnapshotDTO(
pricingRule=PurchaseOrderPricingRuleDTO(
uuid='pricing_rule_uuid',
version='pricing_rule_version',
priceType='price_type',
price='price',
uom='unit_of_measure',
warehouse='warehouse',
pricingVersion='pricing_version',
latestUsedPricingVersion='latest_used_pricing_version'
)
),
itemPurchaseTaxConfiguration=PurchaseOrderItemPurchaseTaxConfigurationDTO(
purchasePriceIsTaxInclusive='is_tax_inclusive',
taxCode=PurchaseOrderTaxCodeDTO(
uuid='tax_code_uuid',
code='tax_code',
rate='tax_rate',
link='tax_code_link'
)
),
itemPriceTaxExempt='item_price_tax_exempt',
itemPriceTax=TaxDTO(
uuid='tax_uuid',
code='tax_code',
rate='tax_rate',
link='tax_link',
amount='tax_amount'
),
purchaseOrderNote='purchase_order_note',
itemAccountingCode=PurchaseOrderItemAccountingCodeDTO(
costOfGoodsSold='cogs_code'
),
op='operation',
uuid='purchase_order_line_uuid',
version='version',
itemSerialOrBatchNumber='serial_or_batch_number',
taxExemptWhenSold='tax_exempt_when_sold'
)
)
)
{
"purchase_order": {
"line": {
"subtotal": "subtotal",
"total": "total",
"tax": "tax",
"item_uuid": "item_uuid",
"item_id": "item_id",
"item_name": "item_name",
"item_quantity": "item_quantity",
"item_order_quantity": "item_order_quantity",
"item_price_snapshot": {
"pricing_rule": {
"uuid": "pricing_rule_uuid",
"version": "pricing_rule_version",
"price_type": "price_type",
"price": "price",
"uom": "unit_of_measure",
"warehouse": "warehouse",
"pricing_version": "pricing_version",
"latest_used_pricing_version": "latest_used_pricing_version"
}
},
"item_purchase_tax_configuration": {
"purchase_price_is_tax_inclusive": "is_tax_inclusive",
"tax_code": {
"uuid": "tax_code_uuid",
"code": "tax_code",
"rate": "tax_rate",
"link": "tax_code_link"
}
},
"item_price_tax_exempt": "item_price_tax_exempt",
"item_price_tax": {
"uuid": "tax_uuid",
"code": "tax_code",
"rate": "tax_rate",
"link": "tax_link",
"amount": "tax_amount"
},
"purchase_order_note": "purchase_order_note",
"item_accounting_code": {
"cost_of_goods_sold": "cogs_code"
},
"op": "operation",
"uuid": "purchase_order_line_uuid",
"version": "version",
"item_serial_or_batch_number": "serial_or_batch_number",
"tax_exempt_when_sold": "tax_exempt_when_sold"
}
}
}
Getting Purchase Order Line
Function: purchase_order_line()
Purpose
This function is designed to test the retrieval of detailed information about one or more lines within a purchase order. It allows developers or system integrators to ensure that the SDK or service layer correctly fetches the line-level data associated with a specific purchase order ID. This function is essential for verifying the integration and accurate data retrieval from the backend system for use cases such as validating line items, pricing details, quantities, tax configurations, or any related metadata required for processing or analysis. The function ensures smooth operational workflows by identifying potential discrepancies in purchase orders or their lines before they impact downstream processes like inventory updates, shipment handling, or financial reconciliation.
Parameters
|
Parameter |
Type |
Description |
|---|---|---|
| purchase_order_id |
String |
The unique identifier of the purchase order |
Use Case
Use this function when you need to confirm that the integration for retrieving line-level details of a purchase order is functioning as expected. For example, during a system integration test, developers might use this to verify that line items' pricing, tax configurations, and quantities are accurately retrieved and match expected values in the backend database.
def purchase_order_line():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.po_line(id='purchase_order_id')
print(response)
return response
# ResponseToObj().process(response=response["purchase_order"])
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)public function purchaseOrderLine()
{
$id = 'purchase_order_id';
try {
$response = $this->purchaseOrderService->readLines($id,'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}Response
A response object containing the detailed information for the specified lines in the purchase order, including item details, pricing, quantities, tax configurations, and other associated metadata.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderDTO(
status="PURCHASE_ORDER_STATUS",
id="PURCHASE_ORDER_ID",
currency="PURCHASE_ORDER_CURRENCY",
supplierInvoiceId="SUPPLIER_INVOICE_ID",
issueDate="ISSUE_DATE",
dueDate="DUE_DATE",
expectedCompletionDate="EXPECTED_COMPLETION_DATE",
subtotal="PURCHASE_ORDER_SUBTOTAL",
tax="PURCHASE_ORDER_TAX",
total="PURCHASE_ORDER_TOTAL",
priceTaxInclusive="BOOLEAN",
purchaseOrderNote="PURCHASE_ORDER_NOTE",
accountId="ACCOUNT_ID",
createdBy="CREATED_BY",
createdOn="CREATED_TIMESTAMP",
lastUpdatedBy="LAST_UPDATED_BY",
lastUpdatedOn="LAST_UPDATED_TIMESTAMP",
uuid="PURCHASE_ORDER_UUID",
version="PURCHASE_ORDER_VERSION",
customAttributes="CUSTOM_ATTRIBUTES",
customObjects="CUSTOM_OBJECTS",
lines=[
PurchaseOrderLineDTO(
subtotal="LINE_SUBTOTAL",
total="LINE_TOTAL",
tax="LINE_TAX",
itemUuid="ITEM_UUID",
itemId="ITEM_ID",
itemName="ITEM_NAME",
itemQuantity="ITEM_QUANTITY",
itemPriceSnapshot=PurchaseOrderItemPriceSnapshotDTO(
pricingRule=PurchaseOrderPricingRuleDTO(
uuid="PRICING_RULE_UUID",
version="PRICING_RULE_VERSION",
priceType="PRICE_TYPE",
price="ITEM_PRICE",
uom="UOM",
warehouse="WAREHOUSE",
pricingVersion="PRICING_VERSION",
latestUsedPricingVersion="LATEST_USED_PRICING_VERSION"
)
),
itemPurchaseTaxConfiguration=PurchaseOrderItemPurchaseTaxConfigurationDTO(
purchasePriceIsTaxInclusive="BOOLEAN",
taxCode=PurchaseOrderTaxCodeDTO(
uuid="TAX_CODE_UUID",
code="TAX_CODE",
rate="TAX_RATE",
link="TAX_LINK"
)
),
itemPriceTaxExempt="BOOLEAN",
itemPriceTax=TaxDTO(
uuid="TAX_UUID",
code="TAX_CODE",
rate="TAX_RATE",
link="TAX_LINK",
amount="TAX_AMOUNT"
),
purchaseOrderNote="LINE_NOTE",
itemAccountingCode=PurchaseOrderItemAccountingCodeDTO(
costOfGoodsSold="COGS"
),
uuid="LINE_UUID",
version="LINE_VERSION",
itemSerialOrBatchNumber="SERIAL_OR_BATCH"
)
],
kpis="PURCHASE_ORDER_KPIS"
)
){
"purchase_order": {
"lines": [
{
"subtotal": "LINE_SUBTOTAL",
"total": "LINE_TOTAL",
"tax": "LINE_TAX",
"item_uuid": "ITEM_UUID",
"item_id": "ITEM_ID",
"item_name": "ITEM_NAME",
"item_quantity": "ITEM_QUANTITY",
"item_price_snapshot": {
"pricing_rule": {
"uuid": "PRICING_RULE_UUID",
"version": "PRICING_RULE_VERSION",
"price_type": "PRICE_TYPE",
"price": "ITEM_PRICE",
"uom": "UOM",
"warehouse": "WAREHOUSE",
"pricing_version": "PRICING_VERSION",
"latest_used_pricing_version": "LATEST_USED_PRICING_VERSION"
}
},
"item_purchase_tax_configuration": {
"purchase_price_is_tax_inclusive": "BOOLEAN",
"tax_code": {
"uuid": "TAX_CODE_UUID",
"code": "TAX_CODE",
"rate": "TAX_RATE",
"link": "TAX_LINK"
}
},
"item_price_tax_exempt": "BOOLEAN",
"item_price_tax": {
"uuid": "TAX_UUID",
"code": "TAX_CODE",
"rate": "TAX_RATE",
"link": "TAX_LINK"
},
"purchase_order_note": "LINE_NOTE",
"item_accounting_code": {
"cost_of_goods_sold": "COGS"
},
"uuid": "LINE_UUID",
"version": "LINE_VERSION"
}
]
},
"autobillCredential": {
"apiUrl": "API_URL",
"appUrl": "APP_URL",
"ClientId": "CLIENT_ID",
"ClientSecret": "CLIENT_SECRET",
"file_path": "FILE_PATH"
}
}Creating Purchase Order Note
Function: create_purchase_order_note()
Purpose
This SDK method allows you to add a note (with or without file attachments) to a purchase order. Notes can contain text details such as comments, instructions, or approval remarks, and optionally include supporting documents like scanned purchase orders, supplier communication, or receipts. This provides a reliable way to capture and manage contextual information alongside financial records for better traceability and collaboration.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_order_id | string | Unique identifier of the purchase order to which the note will be added. |
| datas | string | The content of the note (text message, comment, or description). |
| file_urls / filePaths | array (Python) / string (PHP) | One or more file paths or URLs to be attached with the note. |
Use Case
This method is commonly used when businesses need to document additional context or approvals related to a purchase order. For example, a procurement officer might attach the supplier’s confirmation email and add a note stating that the order is approved for processing. Similarly, supporting files such as scanned receipts or supplier contracts can be uploaded with the note for future auditing. This ensures that critical decision-making information is recorded directly with the purchase order, improving accountability and compliance.
def create_purchase_order_note():
from exsited_sdk import ExsitedSDK, SDKConfig, FileTokenManager, CommonData
from exsited_sdk.exceptions import ABException
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "TOKEN_FILE_PATH"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
datas = "This is a test note for purchase order."
file_urls = [
"FILE_PATH"
]
response = exsited_sdk.notes.purchase_order_add_notes(
file_urls=file_urls,
datas=datas,
purchase_order_id="PURCHASE_ORDER_ID"
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
public function createPurchaseOrderNote()
{
$purchaseOrderId = 'PURCHASE_ORDER_ID';
$filePaths = 'FILE_PATH';
$note = 'from sdk purchase order notes';
try {
$response = $this->notesService->createPurchaseOrderNotes(
$filePaths,
$note,
$purchaseOrderId,
'v3'
);
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}
Response
On success, the method returns a purchase-order object containing a notes element with the UUID of the newly created note. This UUID acts as a unique reference for the added note and can be used to fetch, update, or manage the note later. If files are attached, they are linked with the note for retrieval in subsequent API calls. This ensures that both textual and file based information are securely recorded with the purchase order, enabling complete audit trails and seamless collaboration.
PurchaseOrderNoteResponseDetailsDTO(
purchaseOrder=None
)
{
"purchase-order": {
"notes": {
"uuid": "{{NOTE_UUID}}"
}
}
}
Getting All Notes for a Purchase Order
Function: purchase_order_notes()
Purpose
This API retrieves all notes attached to a specific purchase order. Each note may contain textual content, metadata (such as who created or last updated it), versioning details, and optionally attached files. The endpoint also returns pagination information to handle scenarios where multiple notes are linked to the same purchase order. This is essential for purchase order lifecycle tracking, where comments, approvals, clarifications, and supporting documents need to be stored and retrieved for audit and operational purposes.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_order_id | string | Unique identifier of the purchase order whose notes are to be retrieved. |
Use Case
In real-world procurement workflows, purchase orders often go through multiple stakeholders, such as procurement officers, managers, and suppliers. Each stakeholder may add notes for example, clarifications about quantities, approvals from management, or attached files like supplier quotations and compliance certificates. Instead of managing this information externally, organizations can use this endpoint to retrieve all related notes in one call, providing a complete history of communications and document attachments linked to the purchase order. This supports audit trails, reduces miscommunication, and ensures that all purchase-related documentation is centralized and easily accessible.
def purchase_order_notes():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.notes.purchase_order_note_details(
id="purchase_order_id"
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
public function purchaseOrderNotes()
{
$purchaseOrderId = 'purchase_order_id';
try {
$response = $this->notesService->readPurchaseOrderAllNotes($purchaseOrderId, 'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}
Response
On success, the API returns a purchase_order object containing an array of notes. Each note object includes its unique identifier (uuid), versioning information, rich-text content (HTML-supported), any attached files (with their own UUID, name, and version), and audit metadata such as who created or last updated the note and when. Additionally, the response includes a pagination object that provides metadata about the number of records, limits, offsets, and pagination links. This structure ensures that even when multiple notes exist for a purchase order, applications can manage them efficiently with clear visibility of history and attachments.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderNoteDataDTO(
notes=[
NoteDataDTO(
uuid='NOTE_UUID',
version='VERSION_NUMBER',
content='NOTE_CONTENT',
files=[
FileDTO(
uuid='FILE_UUID',
name='FILE_NAME',
version='FILE_VERSION'
)
],
createdBy='CREATED_BY',
createdOn='CREATED_ON_TIMESTAMP',
lastUpdatedBy='LAST_UPDATED_BY',
lastUpdatedOn='LAST_UPDATED_ON_TIMESTAMP'
)
],
pagination=PaginationDTO(
records='TOTAL_RECORDS',
limit='PAGE_LIMIT',
offset='PAGE_OFFSET',
previousPage='PREVIOUS_PAGE_URL',
nextPage='NEXT_PAGE_URL'
)
)
)
{
"purchase_order": {
"notes": [
{
"uuid": "note_uuid",
"version": "note_version",
"content": "<p>note_content</p>",
"files": [
{
"uuid": "file_uuid",
"name": "file_name",
"version": "file_version"
}
],
"created_by": "created_by",
"created_on": "created_on",
"last_updated_by": "last_updated_by",
"last_updated_on": "last_updated_on",
"custom_attributes": []
}
],
"pagination": {
"records": "records_count",
"limit": "limit",
"offset": "offset",
"previous_page": "previous_page",
"next_page": "next_page"
}
}
}
Getting Purchase Order Note Details
Function: purchase_order_note_details()
Purpose
This function retrieves the details of a single note attached to a purchase order. The note object contains information such as its unique identifier(uuid), version, HTML-supported content, attached files, and audit metadata (who created/updated it and when). This is particularly useful when an application needs to display or process a specific note without fetching all notes for a purchase order.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_order_id | string | Unique identifier of the purchase order. |
| NOTE_UUID | string | Unique identifier of the note to be retrieved. |
Use Case
In procurement workflows, individual notes often contain important instructions, supplier clarifications, or internal approvals. While a purchase order may have multiple notes, sometimes a system needs to fetch details of a specific note for example, showing the latest clarification added by a supplier or checking an attached file for compliance. This function provides direct access to that note’s full details, including attachments and metadata, without retrieving all purchase order notes.
def purchase_order_note_details():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.notes.purchase_order_note_uuid_details(
id="purchase_order_id",
uuid="note_uuid"
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
public function purchaseOrderNoteDetails()
{
$purchaseOrderId = 'purchase_order_id';
$noteUuid = 'note_uuid';
try {
$response = $this->notesService->readPurchaseOrderNotesDetails($purchaseOrderId, $noteUuid, 'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}
Response
On success, the function returns a purchase_order object containing a single note. This note includes its UUID, version, content (HTML-supported), optional file attachments (each with its own UUID, name, and version), and audit fields such as created_by, created_on, last_updated_by, and last_updated_on. The custom_attributes field is provided for client-defined metadata. This makes it easy to track note ownership, review attached files, and maintain compliance/audit records for the purchase order.
PurchaseOrderNoteUuidDetailsDTO(
purchaseOrder=PurchaseOrderNoteUuidDataDTO(
note=NoteDataDTO(
uuid='note_uuid',
version='note_version',
content='<p>note_content</p>',
files=[
FileDTO(
uuid='file_uuid',
name='file_name',
version='file_version'
)
],
createdBy='created_by',
createdOn='created_on',
lastUpdatedBy='last_updated_by',
lastUpdatedOn='last_updated_on'
)
)
)
{
"purchase_order": {
"note": {
"uuid": "note_uuid",
"version": "note_version",
"content": "<p>note_content</p>",
"files": [
{
"uuid": "file_uuid",
"name": "file_name",
"version": "file_version"
}
],
"created_by": "created_by",
"created_on": "created_on",
"last_updated_by": "last_updated_by",
"last_updated_on": "last_updated_on",
"custom_attributes": []
}
}
}
Getting All Files of a Purchase Order Note
Function: purchase_order_note_files()
Purpose
This function retrieves all files attached to a specific note within a purchase order. Each file object includes metadata such as UUID, filename, and version. This is useful when notes contain supporting documents, images, or compliance-related attachments that need to be displayed, downloaded, or processed.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_order_id | string | Unique identifier of the purchase order. |
| NOTE_UUID | string | Unique identifier of the note whose files are being retrieved. |
Use Case
In many procurement processes, users attach important files (such as invoices, compliance certificates, delivery confirmations, or supplier communications) to notes within a purchase order. Instead of fetching all notes and filtering files manually, this function allows applications to retrieve just the files of a specific note. For example, if a supplier attaches a product quality certificate to a purchase order note, the system can fetch it directly using this endpoint.
def purchase_order_note_files():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.notes.purchase_order_note_uuid_files_details(
id="purchase_order_id",
uuid="note_uuid"
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
public function purchaseOrderNoteFiles()
{
$purchaseOrderId = '{{purchase_order_id}}';
$noteUuid = '{{note_uuid}}';
try {
$response = $this->notesService->readPurchaseOrderNoteAllFiles($purchaseOrderId, $noteUuid, 'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}
Response
On success, the function returns a purchase_order object containing a single note, which holds an array of files. Each file entry provides the UUID (for identification and retrieval), file name, and version (for version tracking). The custom_attributes array is available for client-defined metadata. This makes it simple to list and manage all attachments of a specific note without scanning all purchase order notes.
PurchaseOrderUuidFileDetailsDTO(
purchaseOrder=PurchaseOrderUuidFileDataDTO(
note=NoteFileDataDTO(
files=[
FileDTO(
uuid='file_uuid',
name='file_name',
version='file_version'
)
]
)
)
)
{
"purchase_order": {
"note": {
"files": [
{
"uuid": "file_uuid",
"name": "file_name",
"version": "file_version"
}
],
"custom_attributes": []
}
}
}
Getting a Specific File of a Purchase Order Note
Function: purchase_order_note_file_details()
Purpose
This function retrieves details of a single file attached to a specific note within a purchase order. It is useful for fetching metadata (UUID, name, version) of a particular file, typically when the user selects a file from a note for preview, download, or validation.
Parameters
| Parameter | Type | Description |
|---|---|---|
| purchase_order_id | string | Unique identifier of the purchase order. |
| NOTE_UUID | string | Unique identifier of the note containing the file. |
| FILE_UUID | string | Unique identifier of the file to be retrieved. |
Use Case
When users attach multiple files to a purchase order note, sometimes only a specific file needs to be accessed (example: downloading an invoice PDF, verifying a compliance certificate, or retrieving a product image). Instead of listing all files and filtering manually, this function directly fetches the details of the file by its UUID.
def purchase_order_note_file_details():
SDKConfig.PRINT_REQUEST_DATA = True
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.notes.purchase_order_note_uuid_files_uuid_details(
id="purchase_order_id",
uuid="note_uuid",
file_uuid="file_uuid"
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)
public function purchaseOrderNoteFileDetails()
{
$purchaseOrderId = 'purchase_order_id';
$noteUuid = 'note_uuid';
$fileUuid = 'file_uuid';
try {
$response = $this->notesService->readPurchaseOrderNoteFileDetails($purchaseOrderId, $noteUuid, $fileUuid, 'v3');
echo '<pre>' . json_encode($response, JSON_PRETTY_PRINT) . '</pre>';
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}
Response
On success, the function returns a purchase_order object containing a note, which includes the requested file. The file object provides its UUID (for identification), name (usually filename with extension), and version (for tracking different versions of the file). An empty custom_attributes array is included for extensibility if client-defined metadata is needed.
PurchaseOrderNoteUuidFileUuidDetailsDTO(
purchaseOrder=PurchaseOrderNoteUuidFileUuidDataDTO(
note=NoteFileUuidDataDTO(
file=FileDTO(
uuid='file_uuid',
name='file_name',
version='file_version'
)
)
)
)
{
"purchase_order": {
"note": {
"file": {
"uuid": "file_uuid",
"name": "file_name",
"version": "file_version"
},
"custom_attributes": []
}
}
}
Getting Purchase Order Lines
Function: po_line()
Purpose
This function retrieves all line items for a specific purchase order by its ID. It returns the purchase order details including all associated line items with pricing, tax, and item information.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order whose lines are to be retrieved. |
Use Case
This function is used when viewing the individual line items of a purchase order. Common scenarios include displaying order breakdowns, reviewing item quantities and pricing, auditing purchase order contents, and generating line-level reports.
def test_purchase_order_line():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.po_line(id='PO-1E4TEZ-0001')
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
The function returns a PurchaseOrderDetailsDTO object containing the purchase order with its line items. Each line includes item details, pricing snapshots, tax configuration, quantities, and accounting codes.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderDTO(
status='PURCHASE_ORDER_STATUS',
id='PURCHASE_ORDER_ID',
currency=PurchaseOrderCurrencyDTO(
uuid='CURRENCY_UUID',
name='CURRENCY_NAME'
),
issueDate='ISSUE_DATE',
dueDate='DUE_DATE',
subtotal='SUBTOTAL',
tax='TAX',
total='TOTAL',
priceTaxInclusive='PRICE_TAX_INCLUSIVE',
accountId='ACCOUNT_ID',
lines=[
PurchaseOrderLineDTO(
subtotal='LINE_SUBTOTAL',
total='LINE_TOTAL',
tax='LINE_TAX',
itemUuid='ITEM_UUID',
itemId='ITEM_ID',
itemName='ITEM_NAME',
itemQuantity='ITEM_QUANTITY',
itemOrderQuantity='ITEM_ORDER_QUANTITY',
itemPriceSnapshot=PurchaseOrderItemPriceSnapshotDTO(
pricingRule=PurchaseOrderPricingRuleDTO(
price='PRICE',
uom='UOM'
)
),
itemPurchaseTaxConfiguration=PurchaseOrderItemPurchaseTaxConfigurationDTO(
purchasePriceIsTaxInclusive='TAX_INCLUSIVE',
taxCode=PurchaseOrderTaxCodeDTO(
uuid='TAX_CODE_UUID',
code='TAX_CODE',
rate='TAX_RATE'
)
),
uuid='LINE_UUID',
version='LINE_VERSION'
)
],
uuid='PURCHASE_ORDER_UUID',
version='PURCHASE_ORDER_VERSION'
)
)Getting Purchase Order Line by UUID
Function: line_uuid()
Purpose
This function retrieves a specific line item from a purchase order by the purchase order ID and the line item UUID. It returns detailed information about a single line item.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order. |
| uuid | String | The unique UUID of the specific line item to be retrieved. |
Use Case
This function is used when viewing a single line item within a purchase order. Common scenarios include drilling into specific item details, reviewing individual line pricing, and auditing particular line items.
def test_purchase_order_line_uuid():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.line_uuid(
id='PO-K8XQSE-0001',
uuid='f18fad9e-fc64-447b-a071-be6da34657cf'
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
The function returns a PurchaseOrderLineUuidDetailsDTO object containing the specific line item details.
PurchaseOrderLineUuidDetailsDTO(
purchaseOrder=PurchaseOrderLineUuidDTO(
line=PurchaseOrderLineDTO(
subtotal='LINE_SUBTOTAL',
total='LINE_TOTAL',
tax='LINE_TAX',
itemUuid='ITEM_UUID',
itemId='ITEM_ID',
itemName='ITEM_NAME',
itemQuantity='ITEM_QUANTITY',
itemOrderQuantity='ITEM_ORDER_QUANTITY',
itemPriceSnapshot=PurchaseOrderItemPriceSnapshotDTO(
pricingRule=PurchaseOrderPricingRuleDTO(
price='PRICE',
uom='UOM'
)
),
itemPurchaseTaxConfiguration=PurchaseOrderItemPurchaseTaxConfigurationDTO(
purchasePriceIsTaxInclusive='TAX_INCLUSIVE',
taxCode=PurchaseOrderTaxCodeDTO(
uuid='TAX_CODE_UUID',
code='TAX_CODE',
rate='TAX_RATE'
)
),
itemAccountingCode=PurchaseOrderItemAccountingCodeDTO(
costOfGoodsSold='COGS_CODE'
),
uuid='LINE_UUID',
version='LINE_VERSION'
)
)
)Getting Purchase Orders by Account
Function: list_by_account()
Purpose
This function retrieves a paginated list of purchase orders associated with a specific account. It returns all purchase orders linked to the given account ID.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| account_id | String | The unique ID of the account whose purchase orders are to be retrieved. |
| limit | int | Maximum number of records to return. |
| offset | int | Number of records to skip for pagination. |
| direction | String | Sort direction (e.g., "asc" or "desc"). |
| order_by | String | Field to order results by. |
Use Case
This function is used when viewing all purchase orders for a particular account/supplier. Common scenarios include reviewing supplier order history, generating account-level purchase reports, and managing vendor relationships.
def test_purchase_order_list_by_account():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.list_by_account(account_id="9FOR9X")
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
The function returns an AccountPurchaseOrdersResponseDTO object containing the account's purchase orders with pagination.
AccountPurchaseOrdersResponseDTO(
account=AccountPurchaseOrdersDataDTO(
purchaseOrders=[
PurchaseOrderDTO(
status='PURCHASE_ORDER_STATUS',
id='PURCHASE_ORDER_ID',
currency=PurchaseOrderCurrencyDTO(
uuid='CURRENCY_UUID',
name='CURRENCY_NAME'
),
issueDate='ISSUE_DATE',
dueDate='DUE_DATE',
subtotal='SUBTOTAL',
tax='TAX',
total='TOTAL',
accountId='ACCOUNT_ID',
uuid='PURCHASE_ORDER_UUID',
version='PURCHASE_ORDER_VERSION'
)
],
pagination=PaginationDTO(
records=PAGINATION_RECORDS,
limit=PAGINATION_LIMIT,
offset=PAGINATION_OFFSET,
previousPage=PAGINATION_PREVIOUS_PAGE,
nextPage=PAGINATION_NEXT_PAGE
)
)
)Getting Purchase Order Notes
Function: purchase_order_note_details()
Purpose
This function retrieves all notes associated with a specific purchase order. It returns a paginated list of notes including content, files, user information, and timestamps.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order whose notes are to be retrieved. |
| limit | int | Maximum number of records to return. |
| offset | int | Number of records to skip for pagination. |
| direction | String | Sort direction (e.g., "asc" or "desc"). |
| order_by | String | Field to order results by. |
Use Case
This function is used when viewing all notes attached to a purchase order. Common scenarios include reviewing communication history, auditing order annotations, and tracking order-related discussions.
def test_purchase_order_note_details():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.notes.purchase_order_note_details(id="PO-JGR955-0018")
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
The function returns a PurchaseOrderDetailsDTO (notes context) object containing the purchase order's notes with pagination.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderNoteDataDTO(
notes=[
NoteDataDTO(
uuid='NOTE_UUID',
version='NOTE_VERSION',
content='NOTE_CONTENT',
noteGroup=NoteGroupDTO(
uuid='GROUP_UUID',
status='GROUP_STATUS',
name='GROUP_NAME',
displayName='GROUP_DISPLAY_NAME'
),
noteUser=NoteUserDTO(
uuid='USER_UUID',
name='USER_NAME',
displayName='USER_DISPLAY_NAME',
emailAddress='USER_EMAIL'
),
files=[
FileDTO(
uuid='FILE_UUID',
name='FILE_NAME',
version='FILE_VERSION'
)
],
createdBy='CREATED_BY',
createdOn='CREATED_ON',
lastUpdatedBy='LAST_UPDATED_BY',
lastUpdatedOn='LAST_UPDATED_ON'
)
],
pagination=PaginationDTO(
records=PAGINATION_RECORDS,
limit=PAGINATION_LIMIT,
offset=PAGINATION_OFFSET,
previousPage=PAGINATION_PREVIOUS_PAGE,
nextPage=PAGINATION_NEXT_PAGE
)
)
)Getting Purchase Order Note by UUID
Function: purchase_order_note_uuid_details()
Purpose
This API retrieves a single note from a purchase order using the purchase order ID and the note's UUID. The response contains the full detail of that specific note, including its content (HTML-supported), noteGroup classification, noteUser author details (name, displayName, emailAddress), optional file attachments (each with uuid, name, version), and audit fields such as createdBy, createdOn, lastUpdatedBy, and lastUpdatedOn. The watcherList and customAttributes fields provide notification management and client-defined metadata. This is useful when a specific note needs to be displayed, edited, or audited in isolation, without loading the full list of notes on the purchase order.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order. |
| uuid | String | The unique UUID of the specific note to be retrieved. |
Use Case
In procurement operations, teams often need to review a specific note rather than scrolling through the entire note history. For example, during an audit, a compliance officer may need to retrieve a particular approval note by its UUID to verify that the correct authorization was recorded. A procurement manager may need to check the content and attachments of a note referenced in a supplier dispute. Support teams may also need to look up a specific note to understand the context of a past decision. This endpoint allows direct retrieval of a single note with all its metadata, content, and file attachments, supporting targeted lookups without the overhead of loading the entire note collection.
def test_purchase_order_note_uuid_details():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.notes.purchase_order_note_uuid_details(
id="PO-JGR955-0018",
uuid='ac9326ce-eb8a-4c92-ae53-f17f1d39bd35'
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On success, the function returns a purchase_order object containing a single note. This note includes its uuid, version, content (HTML-supported), a noteGroup object (uuid, status, name, displayName), a noteUser object (uuid, name, displayName, emailAddress), optional file attachments (each with its own uuid, name, and version), and audit fields such as createdBy, createdOn, lastUpdatedBy, and lastUpdatedOn. The customAttributes field is provided for client-defined metadata. This makes it easy to track note ownership, review attached files, and maintain compliance/audit records for the purchase order.
PurchaseOrderNoteUuidDetailsDTO(
purchaseOrder=PurchaseOrderNoteUuidDataDTO(
note=NoteDataDTO(
uuid='NOTE_UUID',
version='NOTE_VERSION',
content='NOTE_CONTENT',
noteGroup=NoteGroupDTO(
uuid='GROUP_UUID',
status='GROUP_STATUS',
name='GROUP_NAME',
displayName='GROUP_DISPLAY_NAME'
),
noteUser=NoteUserDTO(
uuid='USER_UUID',
name='USER_NAME',
displayName='USER_DISPLAY_NAME',
emailAddress='USER_EMAIL'
),
files=[
FileDTO(
uuid='FILE_UUID',
name='FILE_NAME',
version='FILE_VERSION'
)
],
createdBy='CREATED_BY',
createdOn='CREATED_ON',
lastUpdatedBy='LAST_UPDATED_BY',
lastUpdatedOn='LAST_UPDATED_ON'
)
)
)Getting Purchase Order Note Files
Function: purchase_order_note_uuid_files_details()
Purpose
This API retrieves all files attached to a specific note on a purchase order, identified by the purchase order ID and note UUID. The response contains a files array where each file entry includes its uuid, name, and version. This is useful when an application needs to enumerate the attachments on a note before initiating downloads, display a file listing to the user, or verify that expected documents (such as quotations, delivery receipts, or compliance certificates) have been uploaded. The file UUIDs returned can be used with the file-by-UUID endpoint for individual file retrieval.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order. |
| uuid | String | The unique UUID of the note whose files are to be retrieved. |
Use Case
In procurement workflows, notes on purchase orders frequently include file attachments such as supplier quotations, signed contracts, delivery receipts, inspection reports, or compliance certificates. When building user interfaces or integrating with document management systems, applications need to list all files on a note to display download links, verify that required documents have been uploaded, or synchronize attachments to external storage. For example, a procurement dashboard might show a note's content alongside a list of its attached files, allowing users to click through to individual documents. This endpoint provides the file metadata needed for these scenarios without downloading the actual file content, keeping the response lightweight and efficient.
def test_purchase_order_note_uuid_files_details():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.notes.purchase_order_note_uuid_files_details(
id="PO-JGR955-0018",
uuid='ac9326ce-eb8a-4c92-ae53-f17f1d39bd35'
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On success, the function returns a purchase_order object containing the file list for the specified note. The response wraps a note object that holds a files array, where each file entry includes its uuid, name, and version. This makes it easy to enumerate all attachments on a note, display file names to the user, and use the file UUIDs for subsequent download or detail retrieval operations.
PurchaseOrderUuidFileDetailsDTO(
purchaseOrder=PurchaseOrderUuidFileDataDTO(
note=NoteFileDataDTO(
files=[
FileDTO(
uuid='FILE_UUID',
name='FILE_NAME',
version='FILE_VERSION'
)
]
)
)
)Getting Purchase Order Note File by UUID
Function: purchase_order_note_uuid_files_uuid_details()
Purpose
This API retrieves the metadata for a specific file attached to a note on a purchase order, identified by the purchase order ID, note UUID, and file UUID. The response contains the file's uuid, name, and version. This is useful when an application needs to verify a specific file's details, check whether it has been updated (via the version field), or prepare download parameters for a single attachment. The three-level identifier (order → note → file) ensures precise targeting of the exact file within the note's attachment collection.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order. |
| uuid | String | The unique UUID of the note. |
| file_uuid | String | The unique UUID of the file to be retrieved. |
Use Case
In document management and compliance scenarios, there is often a need to access a specific file rather than listing all attachments. For example, during an audit, an auditor may request a particular compliance certificate attached to a purchase order note — the application can retrieve that exact file using its UUID without loading other unrelated attachments. Similarly, when integrating with external systems (such as document archival or ERP platforms), individual file metadata retrieval allows precise synchronization of specific documents. This endpoint provides a targeted, lightweight way to access a single file's details, supporting both user-facing download workflows and system-to-system integration scenarios.
def test_purchase_order_note_uuid_files_uuid_details():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.notes.purchase_order_note_uuid_files_uuid_details(
id="PO-JGR955-0018",
uuid='ac9326ce-eb8a-4c92-ae53-f17f1d39bd35',
file_uuid='98614a8d-206b-4a79-80c8-e2488fbbb464'
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On success, the function returns a purchase_order object containing a single file's metadata. The response wraps a note object that holds a file object with the file's uuid, name, and version. This makes it easy to verify a specific file's identity, check its version for updates, and use the metadata for download or display operations.
PurchaseOrderNoteUuidFileUuidDetailsDTO(
purchaseOrder=PurchaseOrderNoteUuidFileUuidDataDTO(
note=NoteFileUuidDataDTO(
file=FileDTO(
uuid='FILE_UUID',
name='FILE_NAME',
version='FILE_VERSION'
)
)
)
)Creating a Purchase Order
Function: create()
Purpose
This API creates a new purchase order in the system. The request accepts comprehensive order details including the target account (supplier), currency, dates (issueDate, dueDate, expectedCompletionDate), tax inclusivity settings, an optional purchase order note, and a lines array containing one or more items with their quantities and tax exemption flags. The system generates the order ID, calculates financial totals, applies pricing rules and tax configurations, and returns the fully populated purchase order object. This is the starting point of the procurement lifecycle, where organizations formally commit to purchasing goods or services from a supplier.
Parameters
This function does not require any input parameters.
Use Case
In procurement workflows, creating a purchase order is the formal step that initiates the purchasing process with a supplier. A procurement officer typically selects the supplier account, specifies the currency and delivery timeline, and adds line items representing the goods or services being ordered. Each line item includes the item identifier, quantity, and tax exemption status — the system then resolves pricing rules and tax codes automatically. Organizations use this endpoint to programmatically generate purchase orders from approved requisitions, automate reordering based on inventory thresholds, or integrate with external ERP systems that manage procurement approvals. This eliminates manual order entry, reduces errors, and ensures that every order is properly recorded in the system from the moment it is created.
def test_purchase_order_create():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
purchase_order_data = PurchaseOrderDataDTO(
currency="AUD",
issueDate="2025-08-11",
dueDate="2025-08-11",
expectedCompletionDate="2025-08-31",
priceTaxInclusive="false",
purchaseOrderNote="Note added",
accountId="ATZNS3",
lines=[
PurchaseOrderLineDTO(
itemId="ITEM-0015",
itemQuantity="1",
taxExemptWhenSold="false"
)
]
)
request_obj = PurchaseOrderCreateDTO(purchaseOrder=purchase_order_data)
response = exsited_sdk.purchase_order.create(request_data=request_obj)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On success, the function returns a purchase_order object containing the newly created purchase order. The response includes the generated id, status, currency (uuid, name), dates (issueDate, dueDate, expectedCompletionDate), financial totals (subtotal, tax, total), priceTaxInclusive flag, purchaseOrderNote, and accountId. Each line item in the lines array includes itemId, itemName, itemQuantity, financial totals, and its own uuid and version. Audit fields such as createdBy, createdOn, uuid, and version are provided for tracking and concurrency control. This makes it easy to confirm the order was created correctly and retrieve the system-generated identifiers for subsequent operations.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderDTO(
status='PURCHASE_ORDER_STATUS',
id='PURCHASE_ORDER_ID',
currency=PurchaseOrderCurrencyDTO(
uuid='CURRENCY_UUID',
name='CURRENCY_NAME'
),
issueDate='ISSUE_DATE',
dueDate='DUE_DATE',
expectedCompletionDate='EXPECTED_COMPLETION_DATE',
subtotal='SUBTOTAL',
tax='TAX',
total='TOTAL',
priceTaxInclusive='PRICE_TAX_INCLUSIVE',
purchaseOrderNote='PURCHASE_ORDER_NOTE',
accountId='ACCOUNT_ID',
createdBy='CREATED_BY',
createdOn='CREATED_ON',
uuid='PURCHASE_ORDER_UUID',
version='PURCHASE_ORDER_VERSION',
lines=[
PurchaseOrderLineDTO(
subtotal='LINE_SUBTOTAL',
total='LINE_TOTAL',
tax='LINE_TAX',
itemId='ITEM_ID',
itemName='ITEM_NAME',
itemQuantity='ITEM_QUANTITY',
uuid='LINE_UUID',
version='LINE_VERSION'
)
]
)
)Reactivating a Purchase Order
Function: reactivate()
Purpose
This API reactivates a previously cancelled purchase order, restoring it to an active state. The endpoint accepts the purchase order ID and transitions the order's status back to active, updating the kpis object with a lastReactivatedOn timestamp to record when the reactivation occurred. The full purchase order object is returned with its current state, including all lines, financial totals, and audit fields. This is important in procurement scenarios where cancelled orders need to be reinstated — for example, when a cancellation was made in error, when a supplier resolves a previously blocking issue, or when business priorities change and a previously cancelled procurement becomes necessary again.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order to be reactivated. |
Use Case
In real-world procurement operations, purchase orders may be cancelled for various reasons — budget constraints, supplier issues, or changing business requirements. However, circumstances often change, and a previously cancelled order may need to be reinstated. For example, a procurement manager may cancel an order during a budget freeze, only to reactivate it once funding is approved. Similarly, an order cancelled due to a supplier delivery dispute may be restored after the dispute is resolved. This endpoint allows organizations to reactivate orders without having to recreate them from scratch, preserving the original order details, line items, and history. The lastReactivatedOn timestamp in the KPIs provides a clear audit trail of when the reactivation occurred.
def test_purchase_order_reactivate():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
response = exsited_sdk.purchase_order.reactivate(id="PO-1E4TEZ-0001")
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On success, the function returns a purchase_order object containing the reactivated purchase order. The response includes the updated status, id, currency, dates (issueDate, dueDate), financial totals (subtotal, tax, total), accountId, and audit fields such as createdBy, createdOn, uuid, and version. The kpis object includes a lastReactivatedOn timestamp indicating when the reactivation took effect. This makes it easy to confirm the order has been restored to an active state and track the reactivation history for audit purposes.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderDTO(
status='PURCHASE_ORDER_STATUS',
id='PURCHASE_ORDER_ID',
currency=PurchaseOrderCurrencyDTO(
uuid='CURRENCY_UUID',
name='CURRENCY_NAME'
),
issueDate='ISSUE_DATE',
dueDate='DUE_DATE',
subtotal='SUBTOTAL',
tax='TAX',
total='TOTAL',
accountId='ACCOUNT_ID',
uuid='PURCHASE_ORDER_UUID',
version='PURCHASE_ORDER_VERSION',
kpis=KPIDTO(
lastReactivatedOn='LAST_REACTIVATED_ON'
)
)
)Changing a Purchase Order
Function: purchase_order_change()
Purpose
This API applies changes to an existing purchase order's line items. The request specifies an operation type (e.g., "CHANGE") along with the target line's UUID and the updated values such as itemOrderQuantity and pricing snapshot (with the new price). The system recalculates financial totals based on the modifications and returns the fully updated purchase order object with the revised lines, totals, and a lastChangedOn timestamp in the KPIs. This is critical for procurement workflows where order modifications are common — quantities may need to be adjusted after supplier negotiations, unit prices may change based on volume discounts, or additional line items may need to be added to an existing order.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order to be changed. |
| request_data | PurchaseOrderChangeDTO | The change request payload containing modifications. |
Use Case
In procurement, purchase orders are rarely static documents. After an order is created, suppliers may propose different quantities or pricing, management may request adjustments based on budget reviews, or operational needs may shift requiring more or fewer items. For example, a procurement officer may increase the order quantity after a supplier offers a bulk discount, or reduce quantities if the project scope changes. Finance teams may also need to update line-level pricing to reflect negotiated rates. This endpoint allows targeted modifications to specific line items using the line's UUID and operation type, without affecting other lines on the order. The system automatically recalculates all financial totals and records the change timestamp, ensuring a complete audit trail of all order modifications.
def test_purchase_order_change():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
purchase_order_data = PurchaseOrderDTO(
lines=[
PurchaseOrderLineDTO(
op="CHANGE",
uuid="0d257e95-7a10-490f-a716-b77a2cdb2ea5",
itemOrderQuantity="5",
itemPriceSnapshot=PurchaseOrderItemPriceSnapshotDTO(
pricingRule=PurchaseOrderPricingRuleDTO(
price="200.000000"
)
)
)
]
)
request_obj = PurchaseOrderChangeDTO(purchaseOrder=purchase_order_data)
response = exsited_sdk.purchase_order.purchase_order_change(
id="PO-1E4TEZ-0001",
request_data=request_obj
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On success, the function returns a purchase_order object containing the updated purchase order after the change operation. The response includes the updated status, id, currency, dates (issueDate, dueDate), financial totals (subtotal, tax, total), accountId, and the modified lines array. Each line includes the updated itemOrderQuantity, pricing snapshot with the new price and uom, financial totals, and its own uuid and version for concurrency control. The kpis object includes a lastChangedOn timestamp recording when the change was applied. This makes it easy to verify that line-level modifications (quantities, pricing) were applied correctly and track the change history.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderDTO(
status='PURCHASE_ORDER_STATUS',
id='PURCHASE_ORDER_ID',
currency=PurchaseOrderCurrencyDTO(
uuid='CURRENCY_UUID',
name='CURRENCY_NAME'
),
issueDate='ISSUE_DATE',
dueDate='DUE_DATE',
subtotal='SUBTOTAL',
tax='TAX',
total='TOTAL',
accountId='ACCOUNT_ID',
uuid='PURCHASE_ORDER_UUID',
version='PURCHASE_ORDER_VERSION',
lines=[
PurchaseOrderLineDTO(
subtotal='LINE_SUBTOTAL',
total='LINE_TOTAL',
tax='LINE_TAX',
itemId='ITEM_ID',
itemName='ITEM_NAME',
itemQuantity='ITEM_QUANTITY',
itemOrderQuantity='ITEM_ORDER_QUANTITY',
itemPriceSnapshot=PurchaseOrderItemPriceSnapshotDTO(
pricingRule=PurchaseOrderPricingRuleDTO(
price='PRICE',
uom='UOM'
)
),
uuid='LINE_UUID',
version='LINE_VERSION'
)
],
kpis=KPIDTO(
lastChangedOn='LAST_CHANGED_ON'
)
)
)Adding a Purchase Order Note
Function: purchase_order_add_notes()
Purpose
This API adds a new note to a purchase order, with optional file attachments uploaded in the same operation. The request accepts a text content string (datas) and an optional list of local file paths (file_urls) to attach. The system creates the note, uploads any specified files, and returns the newly created note object with its system-generated uuid, version, content, noteGroup classification, file attachment details, and audit fields (createdBy, createdOn). This is essential for maintaining a running record of communications, decisions, and supporting documents throughout the purchase order lifecycle, enabling organizations to keep all order-related information centralized within the system.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| purchase_order_id | String | The unique ID of the purchase order to add the note to. |
| datas | String | The text content of the note. |
| file_urls | list | List of local file paths to attach to the note. |
Use Case
In procurement workflows, maintaining a documented record of all communications and decisions related to a purchase order is critical for compliance, accountability, and operational continuity. Procurement officers may add notes to record supplier conversations, attach quotation PDFs, or document the rationale behind pricing decisions. Managers may add approval notes with signed authorization documents. Warehouse teams may attach delivery receipts or inspection reports upon receiving goods. Instead of relying on external email threads or shared drives, this endpoint allows all notes and documents to be attached directly to the purchase order, creating a single source of truth. This supports regulatory compliance, simplifies auditing, and ensures that anyone reviewing the order can access the full communication and documentation history.
def test_purchase_order_add_notes():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
datas = "This is a test note."
file_urls = [
"C:\\path\\to\\file1.jpg",
"C:\\path\\to\\file2.jpg"
]
response = exsited_sdk.notes.purchase_order_add_notes(
file_urls=file_urls,
datas=datas,
purchase_order_id="PO-UZW8TH-0021"
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On success, the function returns a purchase_order object containing the newly created note. The note includes its system-generated uuid, version, content text, a noteGroup object (uuid, status, name, displayName), and any uploaded file attachments (each with its own uuid, name, and version). Audit fields such as createdBy and createdOn are provided for tracking who created the note and when. This makes it easy to confirm the note was created successfully, retrieve the generated identifiers for the note and its files, and maintain an audit trail of purchase order communications.
PurchaseOrderNoteResponseDetailsDTO(
purchaseOrder=PurchaseOrderNoteResponseDataDTO(
notes=NoteDataDTO(
uuid='NOTE_UUID',
version='NOTE_VERSION',
content='NOTE_CONTENT',
noteGroup=NoteGroupDTO(
uuid='GROUP_UUID',
status='GROUP_STATUS',
name='GROUP_NAME',
displayName='GROUP_DISPLAY_NAME'
),
files=[
FileDTO(
uuid='FILE_UUID',
name='FILE_NAME',
version='FILE_VERSION'
)
],
createdBy='CREATED_BY',
createdOn='CREATED_ON'
)
)
)Updating Purchase Order Information
Function: update_information()
Purpose
This API updates the metadata and information fields of an existing purchase order without modifying its line items. The updatable fields include supplierInvoiceId (the supplier's own reference number), dates (issueDate, dueDate, expectedCompletionDate), purchaseOrderNote (free-text annotations), and customAttributes (client-defined name-value pairs for extended metadata). The system returns the full purchase order object with the updated information fields. This is important for keeping purchase order records accurate and up-to-date throughout the procurement lifecycle, where supplementary information such as supplier references, revised timelines, and organizational metadata need to be maintained alongside the core order data.
Parameters
| Parameter name | Type | Description |
|---|---|---|
| id | String | The unique ID of the purchase order to update. |
| request_data | PurchaseOrderInformationUpdateDTO | The update request payload containing information changes. |
Use Case
Throughout the lifecycle of a purchase order, various metadata fields need to be updated as new information becomes available. For example, once a supplier sends their invoice, the procurement team records the supplier's invoice reference (supplierInvoiceId) against the purchase order for cross-referencing. Due dates and expected completion dates may shift based on supplier delivery schedules or internal project timelines. Notes are frequently updated to document important decisions, approvals, or communications. Custom attributes allow organizations to tag orders with business-specific metadata such as cost centers, project codes, or approval statuses. This endpoint enables all these updates in a single operation without touching the order's line items, ensuring that supplementary information stays current while preserving the integrity of the ordered items and their pricing.
def test_purchase_order_update_information():
SDKConfig.PRINT_REQUEST_DATA = False
SDKConfig.PRINT_RAW_RESPONSE = False
token_file_path = "shared_token.json"
file_token_mgr = FileTokenManager(token_file_path)
exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
request_token_dto=CommonData.get_request_token_dto(),
file_token_mgr=file_token_mgr
)
try:
purchase_order_data = PurchaseOrderDataDTO(
supplierInvoiceId="SUP-INV-001",
issueDate="2026-03-03",
dueDate="2026-03-03",
expectedCompletionDate="2026-03-03",
purchaseOrderNote="Updated note",
customAttributes=[
{
"name": "attribute_name",
"value": "attribute_value"
}
]
)
request_obj = PurchaseOrderInformationUpdateDTO(purchaseOrder=purchase_order_data)
response = exsited_sdk.purchase_order.update_information(
id="PO-9FOR9X-0028",
request_data=request_obj
)
print(response)
except ABException as ab:
print(ab)
print(ab.get_errors())
print(ab.raw_response)Response
On success, the function returns a purchase_order object containing the updated purchase order with the modified information fields. The response includes the updated supplierInvoiceId, dates (issueDate, dueDate, expectedCompletionDate), purchaseOrderNote, and customAttributes array with name-value pairs. Standard fields such as status, id, currency, financial totals (subtotal, tax, total), accountId, and audit fields (uuid, version) are also returned. This makes it easy to confirm that metadata updates were applied correctly and retrieve the current state of all information fields on the purchase order.
PurchaseOrderDetailsDTO(
purchaseOrder=PurchaseOrderDTO(
status='PURCHASE_ORDER_STATUS',
id='PURCHASE_ORDER_ID',
currency=PurchaseOrderCurrencyDTO(
uuid='CURRENCY_UUID',
name='CURRENCY_NAME'
),
supplierInvoiceId='SUPPLIER_INVOICE_ID',
issueDate='ISSUE_DATE',
dueDate='DUE_DATE',
expectedCompletionDate='EXPECTED_COMPLETION_DATE',
subtotal='SUBTOTAL',
tax='TAX',
total='TOTAL',
purchaseOrderNote='PURCHASE_ORDER_NOTE',
accountId='ACCOUNT_ID',
uuid='PURCHASE_ORDER_UUID',
version='PURCHASE_ORDER_VERSION',
customAttributes=[
CustomAttributesDTO(
name='ATTRIBUTE_NAME',
value='ATTRIBUTE_VALUE'
)
]
)
)