Cancel subscriptions

final CreateOrderRequest createOrderRequest = new CreateOrderRequest()
            .category(OrderCategory.NEWSALES)
            .orderDate(LocalDate.of(2024,12,20))
            .existingAccountNumber("A00000006")
            .description("Order cancel a subscription")
            .subscriptions(Arrays.asList(new CreateOrderSubscription()
                    .subscriptionNumber("A-S00000038")
                    .orderActions(Arrays.asList(new CreateOrderAction()
                            .type(OrderActionType.CANCELSUBSCRIPTION)
                            .triggerDates(Arrays.asList(
                                    new TriggerDate()
                                            .name(TriggerDateName.CONTRACTEFFECTIVE)
                                            .triggerDate(LocalDate.of(2024,12,20))

                            ))
                            .cancelSubscription(new OrderActionCancelSubscription()
                                    .cancellationPolicy(SubscriptioncancellationPolicy.ENDOFLASTINVOICEPERIOD))
                    ))))
            .processingOptions(new ProcessingOptionsWithDelayedCapturePayment()
                    .runBilling(true)
                    .collectPayment(false)
            );

CreateOrderResponse response = zuoraClient.ordersApi().createOrderApi(createOrderRequest).executeWithOrderMetrics();
System.out.print(response);

const triggerDate = new TriggerDate();
triggerDate.name = "ContractEffective";
triggerDate.triggerDate = new Date().toISOString().split('T')[0];

const orderActionCancelSubs = new OrderActionCancelSubscription();
orderActionCancelSubs.cancellationPolicy = 'EndOfLastInvoicePeriod';

const cancelSubsOrderAction = new CreateOrderAction();
cancelSubsOrderAction.type = 'CancelSubscription';
cancelSubsOrderAction.triggerDates = [triggerDate];
cancelSubsOrderAction.cancelSubscription = orderActionCancelSubs;

const createOrderSubcription = new CreateOrderSubscription();
createOrderSubcription.subscriptionNumber = 'A-S00000038';
createOrderSubcription.orderActions = [cancelSubsOrderAction];

const processingOptions = new ProcessingOptionsWithDelayedCapturePayment();
processingOptions.runBilling = true;
processingOptions.collectPayment = false;

const request = new CreateOrderRequest();
request.existingAccountNumber = 'A00000006';
request.category = 'NewSales';
request.orderDate = new Date().toISOString().split('T')[0];
request.description = 'Cancel Subscription Order';
request.subscriptions = [createOrderSubcription];
request.processingOptions = processingOptions;
    
const createOrderResp = await zuoraClient.ordersApi.createOrder(request);
console.log(JSON.stringify(createOrderResp, (k, v) => v ?? undefined, 2));

def cancel_subscription(client, subscription_name, cancellation_date=None):
    """
    Parameters:
        client (ZuoraClient): An authenticated instance of the Zuora client.
        subscription_name (str): The name of the subscription to cancel.
        cancellation_date (str, optional): The effective cancellation date in 'YYYY-MM-DD' format.
            If not provided, the cancellation will be effective on the next billing day (EndOfLastInvoicePeriod)
    """
    try:
        # Find the subscription objects by name to verify they exists
        sub_verify = client.object_queries_api().query_subscriptions(filter=['name.EQ:%s' % subscription_name,'status.EQ:%s' % 'Active'])

        if len(sub_verify.data) == 0:
            return {
                "error": f"Subscription with name '{subscription_name}' not found or query failed."
            }

        account_id = sub_verify.data[0].account_id

        # Prepare cancellation payload
        cancellation_payload = {
            "cancellationPolicy": "SpecificDate" if cancellation_date else "EndOfLastInvoicePeriod",
        }
        if cancellation_date:
            # Validate and add the cancellation date
            try:
                cancellation_date_obj = datetime.strptime(cancellation_date, "%Y-%m-%d")
                cancellation_payload["cancellationEffectiveDate"] = cancellation_date_obj.strftime("%Y-%m-%d")
            except ValueError:
                return {"error": "Invalid cancellation date format. Use 'YYYY-MM-DD'."}


        create_order_request = CreateOrderRequest(
            order_date=date.today().strftime('%Y-%m-%d'),
            existingAccountId=account_id,
            subscriptions=[{
                'subscriptionNumber': subscription_name,
                'order_actions': [{
                    'type': 'CancelSubscription',
                    'cancel_subscription': cancellation_payload
                }]
            }],
        )

        #  Submit the order request
        response = client.orders_api().create_order(create_order_request)
        print("Cancellation Order Created Successfully!")
        print(response.to_json())
        return

    except Exception as e:
        print(f"Failed to create cancellation order: {e}")
        return {"error": f"An exception occurred: {str(e)}"}

if __name__ == '__main__':
    cancel_subscription(client, subscription_name='A-S00000038')