main_apply_transaction_nests_to_event.py

import requests
import json

from methods import init_session, select_active, confirm_environment, environment_url
from methods import recursively_convert_parameter_for_event

select_active("source")

rh, settings, src_project, _ = init_session(validate_src=True, validate_target=False)
org_id = settings["srcOrgId"]
project_id = settings["srcProjectId"]
environment_id = settings["srcEnvId"]
project_name = src_project.get("name", "Unknown Project")


print(" APPLY TRANSACTION'S NESTED OBJECT/ARRAY BLOCKS TO ANOTHER EVENT ")
confirm_environment(settings, "source", src_project, label="TARGET")

print("-------------------------------------------------")
print("Fetching all events...")

src_schemas = rh.get_schemas(org_id, project_id, environment_id)
if not src_schemas:
    print("No schemas found in source project. This probably means your token is expired. Look in the cookie for https://cloud.unity.com/, under 'token'.")
    print("Store the latest token in token.auth and re-run the script.")
    print("Exiting...")
    exit(1)


transaction_name = "transaction"
transaction_schema = rh.get_schema_by_id(org_id, project_id, environment_id, "transaction")
if not transaction_schema:
    print(f"Failed to fetch transaction schema. Exiting...")
    exit(1)

# Locate TRANSACTION's eventParams block and pull out its OBJECT/ARRAY children
# verbatim — these are the blocks (productsReceived, productsSpent, …) we'll
# graft onto the target event's eventParams with their full child trees intact.
event_params_node = next(
    (p for p in transaction_schema["parameters"] if p["name"] == "eventParams"),
    None,
)

nested_blocks = [
    c for c in (event_params_node.get("children", []) or [])
    if c.get("type") in ("OBJECT", "ARRAY") and c.get("name") in ("productsSpent", "productsReceived")
]
print(f"Found {len(nested_blocks)} OBJECT/ARRAY block(s) in {transaction_name}.eventParams:")
for block in nested_blocks:
    child_names = [c["name"] for c in block.get("children", []) or []]
    print(f"  - {block['type']} '{block['name']}' (children: {', '.join(child_names) or '<none>'})")


# Build the list of selectable target events (exclude TRANSACTION itself and
# restricted/predefined events that the API will refuse to PUT).
selectable_schemas = [
    s for s in src_schemas
    if not s.get("isRestricted")
    and not s.get("isPredefined")
    and s["name"] != transaction_name
]
if not selectable_schemas:
    print("No editable target events available. Exiting...")
    exit(1)

print("-------------------------------------------------")
print("Select the event to apply the nested OBJECT/ARRAY blocks to:")
for index, schema in enumerate(selectable_schemas):
    description = schema.get("description", "") or ""
    print(f"{index} - {schema['name']} \t- {description}")

schema_index = input("Please select the event's number: ")
if not schema_index.isdigit() or int(schema_index) < 0 or int(schema_index) >= len(selectable_schemas):
    print("Invalid event index. Exiting...")
    exit(1)
schema_index = int(schema_index)
target_event_summary = selectable_schemas[schema_index]
target_event_name = target_event_summary["name"]

print(f"Selected event: \"{target_event_name}\"")
print("-------------------------------------------------")
input("If this is correct, press enter to continue... If not, terminate the script and change the settings.json file.\n THERE WILL BE NO FURTHER CONFIRMATIONS.")

print("thanks! beginning...")

# Fetch the current state of the target event.
target_schema = rh.get_schema_by_id(org_id, project_id, environment_id, target_event_name)
if not target_schema:
    print(f"Failed to fetch {target_event_name} schema. Exiting...")
    exit(1)

# Recursively merge a source subtree (TRANSACTION-side, full parameter shape)
# into a list of target children (event-parameter shape). If a same-named child
# is already present, descend into it and ensure every nested child from the
# source is also present. Existing nodes are NOT removed — a user may have
# manually added their own children, and we preserve those.
def merge_subtree_into_children(target_children, source_node):
    existing = next((c for c in target_children if c["name"] == source_node["name"]), None)
    if existing is None:
        target_children.append(recursively_convert_parameter_for_event(source_node))
        return
    existing.setdefault("children", [])
    for src_child in source_node.get("children", []) or []:
        merge_subtree_into_children(existing["children"], src_child)


updated_parameters = target_schema["parameters"]
target_event_params = next(
    (p for p in updated_parameters if p["name"] == "eventParams"),
    None,
)
if target_event_params is None:
    print(f"{target_event_name} has no eventParams block. Exiting...")
    exit(1)
target_event_params.setdefault("children", [])

for block in nested_blocks:
    print(f"Merging {block['type']} block '{block['name']}' into 'eventParams'")
    merge_subtree_into_children(target_event_params["children"], block)


response = rh.update_schema(
    org_id,
    project_id,
    environment_id,
    target_event_name,
    target_schema.get("description", "") or "",
    updated_parameters,
    target_schema.get("isEnabled", True),
)
if response:
    print(f"Successfully updated schema {target_event_name}")
    print(f"View it here: {environment_url(org_id, project_id, environment_id)}/analytics/v2/events/{target_event_name}")
else:
    print(f"Failed to update schema {target_event_name}")