Fields

# Editable fields only
editable_only = dc.get_fields(object_id="Company", editable=True)
 
# Fields present on the entry form
on_form = dc.get_fields(object_id="Company", entry_form=True)
 
# Combine filters (both query params)
editable_on_form = dc.get_fields(
    object_id="Company",
    editable=True,
    entry_form=True,
)
 
# Non-editable fields (API: editable=false)
read_only = dc.get_fields(object_id="Company", editable=False)

# Get field type name
from dealcloud_sdk.constants import get_field_type_name
 
field = dc.get_fields("Company")[0]
type_name = get_field_type_name(field.fieldType)
print(f"{field.apiName}: {type_name}")

field_ids = [12345, 12346, 12347]
fields = dc.get_fields_by_ids(field_ids)
 
for field in fields:
    print(f"{field.id}: {field.apiName}")

# Get a choice field
fields = dc.get_fields("Company")
industry = next(f for f in fields if f.apiName == "Industry")
 
# List choice values
if industry.choiceValues:
    for choice in industry.choiceValues:
        print(f"{choice.id}: {choice.name}")

def get_choice_map(field):
    """Build name → ID mapping for a choice field."""
    if not field.choiceValues:
        return {}
    return {c.name: c.id for c in field.choiceValues}
 
fields = dc.get_fields("Company")
industry = next(f for f in fields if f.apiName == "Industry")
 
choice_map = get_choice_map(industry)
# {"Technology": 101, "Finance": 102, "Healthcare": 103, ...}
 
# Use in data operations
tech_id = choice_map.get("Technology")

# Add new choices by field ID
dc.append_choice_values(
    field_id=12345,
    choice_values=[
        {"name": "New Option A"},
        {"name": "New Option B"},
    ]
)
 
# Add new choices by field API name
dc.append_choice_values(
    field_id="IndustryType",
    choice_values=[{"name": "Fintech"}, {"name": "Biotech"}]
)

def sync_choices(dc, field_id, external_values: list[str]):
    """Add any new choices that don't already exist."""
    fields = dc.get_fields(field_id=field_id)
    field = fields[0]
 
    existing = {c.name for c in (field.choiceValues or [])}
    new_values = [{"name": v} for v in external_values if v not in existing]
 
    if new_values:
        dc.append_choice_values(field_id=field_id, choice_values=new_values)
        print(f"Added {len(new_values)} new choices")
    else:
        print("All choices already exist")
 
sync_choices(dc, 12345, ["Technology", "Finance", "New Sector"])

# Find reference fields
fields = dc.get_fields("Contact")
ref_fields = [f for f in fields if f.entryLists]
 
for field in ref_fields:
    targets = field.entryLists  # List of target object IDs
    print(f"{field.apiName} → Object IDs: {targets}")

def get_reference_targets(dc, field):
    """Get object names that a reference field points to."""
    if not field.entryLists:
        return []
    
    objects = dc.get_objects()
    obj_map = {o.id: o.apiName for o in objects}
    
    return [obj_map.get(oid, f"Unknown({oid})") for oid in field.entryLists]
 
fields = dc.get_fields("Contact")
company_field = next(f for f in fields if f.apiName == "Company")
 
targets = get_reference_targets(dc, company_field)
print(f"Company field targets: {targets}")  # ["Company"]

# Filter system fields
fields = dc.get_fields("Company")
 
system_fields = [f for f in fields if f.systemFieldType is not None]
custom_fields = [f for f in fields if f.systemFieldType is None]
 
print(f"System: {len(system_fields)}, Custom: {len(custom_fields)}")

def get_field_by_api_name(dc, object_id: str, api_name: str):
    """Get field by its API name."""
    fields = dc.get_fields(object_id)
    return next((f for f in fields if f.apiName == api_name), None)
 
industry = get_field_by_api_name(dc, "Company", "Industry")

def get_field_by_name(dc, object_id: str, display_name: str):
    """Get field by its display name."""
    fields = dc.get_fields(object_id)
    return next((f for f in fields if f.name == display_name), None)
 
industry = get_field_by_name(dc, "Company", "Industry Type")

def get_field_map(dc, object_id: str):
    """Build API name → Field mapping."""
    fields = dc.get_fields(object_id)
    return {f.apiName: f for f in fields}
 
company_fields = get_field_map(dc, "Company")
industry = company_fields.get("Industry")

import pandas as pd
 
def export_field_docs(dc, object_id: str, filepath: str):
    """Export field documentation to Excel."""
    fields = dc.get_fields(object_id)
    
    records = []
    for f in fields:
        records.append({
            "Field ID": f.id,
            "API Name": f.apiName,
            "Display Name": f.name,
            "Type ID": f.fieldType,
            "Required": f.isRequired,
            "Multi-Select": f.isMultiSelect,
            "Calculated": f.isCalculated,
            "Description": f.description or "",
            "Choices": len(f.choiceValues) if f.choiceValues else 0,
            "References": ", ".join(map(str, f.entryLists or []))
        })
    
    df = pd.DataFrame(records)
    df.to_excel(filepath, index=False)
 
export_field_docs(dc, "Company", "company_fields.xlsx")

def validate_record(dc, object_id: str, record: dict):
    """Validate a record against field schema."""
    fields = dc.get_fields(object_id)
    field_map = {f.apiName: f for f in fields}
    
    errors = []
    
    # Check required fields
    for field in fields:
        if field.isRequired and field.apiName not in record:
            errors.append(f"Missing required field: {field.apiName}")
    
    # Check field names
    for key in record:
        if key not in field_map and key != "EntryId":
            errors.append(f"Unknown field: {key}")
    
    return errors
 
errors = validate_record(dc, "Company", {"CompanyName": "Test"})
if errors:
    print("Validation errors:", errors)