Generic Inquiries

Access Acumatica Generic Inquiries via OData endpoints

Overview

Generic Inquiries (GI) in Acumatica are custom data queries configured through the Acumatica UI. Easy-Acumatica automatically discovers available Generic Inquiries and generates methods to access them.

All inquiries are accessed through client.inquiries and support filtering, sorting, and pagination using QueryOptions.

from easy_acumatica import AcumaticaClient
from easy_acumatica.odata import QueryOptions, F

client = AcumaticaClient()

# Access a Generic Inquiry
results = client.inquiries.customer_sales_summary()

# With filtering
options = QueryOptions(
    filter=F.CustomerClass == "WHOLESALE",
    top=50
)
filtered_results = client.inquiries.customer_sales_summary(options=options)

Discovery

List available Generic Inquiries in your Acumatica instance:

# List all available inquiries
for service in dir(client.inquiries):
    if not service.startswith('_'):
        print(service)

# Check if specific inquiry exists
if hasattr(client.inquiries, 'customer_sales_summary'):
    results = client.inquiries.customer_sales_summary()

# Get inquiry method info
import inspect
method = getattr(client.inquiries, 'customer_sales_summary')
print(inspect.getsource(method))

Basic Usage

Access Generic Inquiry results using the dynamically generated methods:

# Call an inquiry without options
all_results = client.inquiries.open_sales_orders()

# Iterate through results
for order in all_results:
    print(f"Order: {order['OrderNbr']}, Customer: {order['CustomerID']}")

# Access specific fields
for order in all_results:
    order_number = order.get('OrderNbr')
    total = order.get('OrderTotal')
    status = order.get('Status')

Filtering Results

Use F factory and QueryOptions to filter inquiry results:

from easy_acumatica.odata import QueryOptions, F

# Simple filter
options = QueryOptions(
    filter=F.CustomerClass == "WHOLESALE"
)
wholesale_customers = client.inquiries.customer_list(options=options)

# Complex filter
options = QueryOptions(
    filter=(
        (F.Status == "Open") & 
        (F.OrderTotal > 10000) &
        (F.OrderDate.year() == 2024)
    )
)
large_orders = client.inquiries.open_sales_orders(options=options)

# String operations
options = QueryOptions(
    filter=F.CustomerName.startswith("ABC")
)
abc_customers = client.inquiries.customer_list(options=options)

Pagination

Handle large result sets with pagination:

# Get first 100 results
options = QueryOptions(top=100)
page1 = client.inquiries.inventory_summary(options=options)

# Get next 100 results (skip first 100)
options = QueryOptions(top=100, skip=100)
page2 = client.inquiries.inventory_summary(options=options)

# Pagination loop
page_size = 100
page = 0
all_results = []

while True:
    options = QueryOptions(top=page_size, skip=page * page_size)
    results = client.inquiries.inventory_summary(options=options)
    
    if not results:
        break
    
    all_results.extend(results)
    page += 1
    
    print(f"Fetched {len(results)} items (total: {len(all_results)})")

Field Selection

Select specific fields to reduce payload size:

# Select specific fields only
options = QueryOptions(
    select=["CustomerID", "CustomerName", "Balance"],
    top=50
)
customers = client.inquiries.customer_list(options=options)

# Result contains only selected fields
for customer in customers:
    print(customer)  # Only CustomerID, CustomerName, Balance

Sorting

Sort inquiry results:

# Sort ascending
options = QueryOptions(
    orderby=["CustomerName"]
)
sorted_customers = client.inquiries.customer_list(options=options)

# Sort descending
options = QueryOptions(
    orderby=["OrderTotal desc"]
)
high_value_orders = client.inquiries.open_sales_orders(options=options)

# Multiple sort fields
options = QueryOptions(
    orderby=["CustomerClass", "Balance desc"]
)
customers = client.inquiries.customer_list(options=options)

Complex Example

Combine filtering, sorting, pagination, and field selection:

from easy_acumatica import AcumaticaClient
from easy_acumatica.odata import QueryOptions, F
from datetime import datetime, timedelta

client = AcumaticaClient()

# Complex inquiry with all options
thirty_days_ago = datetime.now() - timedelta(days=30)

options = QueryOptions(
    # Filter for recent high-value wholesale orders
    filter=(
        (F.CustomerClass == "WHOLESALE") &
        (F.Status == "Open") &
        (F.OrderTotal >= 5000) &
        (F.OrderDate >= thirty_days_ago)
    ),
    # Select only needed fields
    select=[
        "OrderNbr",
        "CustomerID", 
        "CustomerName",
        "OrderDate",
        "OrderTotal",
        "Status"
    ],
    # Sort by total descending
    orderby=["OrderTotal desc"],
    # First 50 results
    top=50
)

orders = client.inquiries.open_sales_orders(options=options)

# Process results
total_value = sum(order.get('OrderTotal', 0) for order in orders)
print(f"Found {len(orders)} high-value wholesale orders")
print(f"Total value: ${total_value:,.2f}")

for order in orders:
    print(f"{order['OrderNbr']}: {order['CustomerName']} - ${order['OrderTotal']:,.2f}")

Method Naming

Generic Inquiry names are converted to snake_case method names. The system removes special characters and converts spaces to underscores.

Inquiry Name	Method Name
Customer Orders Summary	`client.inquiries.customer_orders_summary()`
AP-Invoice-Details	`client.inquiries.ap_invoice_details()`
Open Sales Orders	`client.inquiries.open_sales_orders()`
Inventory by Location	`client.inquiries.inventory_by_location()`

Best Practices

Use select to request only needed fields
Apply filters to reduce result set size
Use pagination for large datasets
Check inquiry availability with hasattr() before calling
Cache inquiry results when data doesn't change frequently
Generic Inquiries are read-only - use entity endpoints for write operations

Troubleshooting

Inquiry Not Found

# Check if inquiry exists before calling
if hasattr(client.inquiries, 'my_custom_inquiry'):
    results = client.inquiries.my_custom_inquiry()
else:
    print("Inquiry 'my_custom_inquiry' not found")
    print("Available inquiries:")
    for attr in dir(client.inquiries):
        if not attr.startswith('_'):
            print(f"  - {attr}")

# Handle potential errors
try:
    results = client.inquiries.customer_sales_summary()
except AttributeError:
    print("Inquiry not available - check Acumatica configuration")
except Exception as e:
    print(f"Error accessing inquiry: {e}")

Empty Results

If an inquiry returns empty results, verify the inquiry works in the Acumatica UI and check that your filter conditions are correct.

Performance Issues

Large Generic Inquiries can be slow. Optimize by:

Using filters to reduce result set
Selecting only necessary fields
Adding appropriate pagination
Optimizing the GI query in Acumatica

On this page