Create or update a form version

// Create or update a form version returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
	"github.com/google/uuid"
)

func main() {
	// there is a valid "form" in the system
	FormDataID := uuid.MustParse(os.Getenv("FORM_DATA_ID"))

	body := datadogV2.UpsertFormVersionRequest{
		Data: datadogV2.UpsertFormVersionData{
			Attributes: datadogV2.UpsertFormVersionDataAttributes{
				DataDefinition: datadogV2.FormDataDefinition{
					Description: datadog.PtrString("Welcome to the Engineering Experience Survey."),
					Required:    []string{},
					Title:       datadog.PtrString("Developer Experience Survey"),
					Type:        datadogV2.FORMDATADEFINITIONTYPE_OBJECT.Ptr(),
				},
				State: datadogV2.FORMVERSIONSTATE_FROZEN,
				UiDefinition: datadogV2.FormUiDefinition{
					UiOrder: []string{},
					UiTheme: &datadogV2.FormUiDefinitionUiTheme{
						PrimaryColor: datadogV2.FORMUIDEFINITIONUITHEMEPRIMARYCOLOR_GRAY.Ptr(),
					},
				},
				UpsertParams: datadogV2.UpsertFormVersionUpsertParams{
					Etag:        *datadog.NewNullableString(datadog.PtrString("b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d")),
					InsertOnly:  datadog.PtrBool(false),
					MatchPolicy: datadogV2.LATESTVERSIONMATCHPOLICY_NONE,
				},
			},
			Type: datadogV2.FORMVERSIONTYPE_FORM_VERSIONS,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.UpsertFormVersion", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewFormsApi(apiClient)
	resp, r, err := api.UpsertFormVersion(ctx, FormDataID, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `FormsApi.UpsertFormVersion`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `FormsApi.UpsertFormVersion`:\n%s\n", responseContent)
}

// Create or update a form version returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.FormsApi;
import com.datadog.api.client.v2.model.FormDataDefinition;
import com.datadog.api.client.v2.model.FormDataDefinitionType;
import com.datadog.api.client.v2.model.FormUiDefinition;
import com.datadog.api.client.v2.model.FormUiDefinitionUiTheme;
import com.datadog.api.client.v2.model.FormUiDefinitionUiThemePrimaryColor;
import com.datadog.api.client.v2.model.FormVersionResponse;
import com.datadog.api.client.v2.model.FormVersionState;
import com.datadog.api.client.v2.model.FormVersionType;
import com.datadog.api.client.v2.model.LatestVersionMatchPolicy;
import com.datadog.api.client.v2.model.UpsertFormVersionData;
import com.datadog.api.client.v2.model.UpsertFormVersionDataAttributes;
import com.datadog.api.client.v2.model.UpsertFormVersionRequest;
import com.datadog.api.client.v2.model.UpsertFormVersionUpsertParams;
import java.util.UUID;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN"));
    defaultClient.setUnstableOperationEnabled("v2.upsertFormVersion", true);
    FormsApi apiInstance = new FormsApi(defaultClient);

    // there is a valid "form" in the system
    UUID FORM_DATA_ID = null;
    try {
      FORM_DATA_ID = UUID.fromString(System.getenv("FORM_DATA_ID"));
    } catch (IllegalArgumentException e) {
      System.err.println("Error parsing UUID: " + e.getMessage());
    }

    UpsertFormVersionRequest body =
        new UpsertFormVersionRequest()
            .data(
                new UpsertFormVersionData()
                    .attributes(
                        new UpsertFormVersionDataAttributes()
                            .dataDefinition(
                                new FormDataDefinition()
                                    .description("Welcome to the Engineering Experience Survey.")
                                    .title("Developer Experience Survey")
                                    .type(FormDataDefinitionType.OBJECT))
                            .state(FormVersionState.FROZEN)
                            .uiDefinition(
                                new FormUiDefinition()
                                    .uiTheme(
                                        new FormUiDefinitionUiTheme()
                                            .primaryColor(
                                                FormUiDefinitionUiThemePrimaryColor.GRAY)))
                            .upsertParams(
                                new UpsertFormVersionUpsertParams()
                                    .etag(
                                        "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d")
                                    .insertOnly(false)
                                    .matchPolicy(LatestVersionMatchPolicy.NONE)))
                    .type(FormVersionType.FORM_VERSIONS));

    try {
      FormVersionResponse result = apiInstance.upsertFormVersion(FORM_DATA_ID, body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling FormsApi#upsertFormVersion");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

"""
Create or update a form version returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.forms_api import FormsApi
from datadog_api_client.v2.model.form_data_definition import FormDataDefinition
from datadog_api_client.v2.model.form_data_definition_type import FormDataDefinitionType
from datadog_api_client.v2.model.form_ui_definition import FormUiDefinition
from datadog_api_client.v2.model.form_ui_definition_ui_theme import FormUiDefinitionUiTheme
from datadog_api_client.v2.model.form_ui_definition_ui_theme_primary_color import FormUiDefinitionUiThemePrimaryColor
from datadog_api_client.v2.model.form_version_state import FormVersionState
from datadog_api_client.v2.model.form_version_type import FormVersionType
from datadog_api_client.v2.model.latest_version_match_policy import LatestVersionMatchPolicy
from datadog_api_client.v2.model.upsert_form_version_data import UpsertFormVersionData
from datadog_api_client.v2.model.upsert_form_version_data_attributes import UpsertFormVersionDataAttributes
from datadog_api_client.v2.model.upsert_form_version_request import UpsertFormVersionRequest
from datadog_api_client.v2.model.upsert_form_version_upsert_params import UpsertFormVersionUpsertParams

# there is a valid "form" in the system
FORM_DATA_ID = environ["FORM_DATA_ID"]

body = UpsertFormVersionRequest(
    data=UpsertFormVersionData(
        attributes=UpsertFormVersionDataAttributes(
            data_definition=FormDataDefinition(
                description="Welcome to the Engineering Experience Survey.",
                required=[],
                title="Developer Experience Survey",
                type=FormDataDefinitionType.OBJECT,
            ),
            state=FormVersionState.FROZEN,
            ui_definition=FormUiDefinition(
                ui_order=[],
                ui_theme=FormUiDefinitionUiTheme(
                    primary_color=FormUiDefinitionUiThemePrimaryColor.GRAY,
                ),
            ),
            upsert_params=UpsertFormVersionUpsertParams(
                etag="b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d",
                insert_only=False,
                match_policy=LatestVersionMatchPolicy.NONE,
            ),
        ),
        type=FormVersionType.FORM_VERSIONS,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
configuration.unstable_operations["upsert_form_version"] = True
with ApiClient(configuration) as api_client:
    api_instance = FormsApi(api_client)
    response = api_instance.upsert_form_version(form_id=FORM_DATA_ID, body=body)

    print(response)

# Create or update a form version returns "OK" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.access_token = ENV["DD_BEARER_TOKEN"]
  config.unstable_operations["v2.upsert_form_version".to_sym] = true
end
api_instance = DatadogAPIClient::V2::FormsAPI.new

# there is a valid "form" in the system
FORM_DATA_ID = ENV["FORM_DATA_ID"]

body = DatadogAPIClient::V2::UpsertFormVersionRequest.new({
  data: DatadogAPIClient::V2::UpsertFormVersionData.new({
    attributes: DatadogAPIClient::V2::UpsertFormVersionDataAttributes.new({
      data_definition: DatadogAPIClient::V2::FormDataDefinition.new({
        description: "Welcome to the Engineering Experience Survey.",
        required: [],
        title: "Developer Experience Survey",
        type: DatadogAPIClient::V2::FormDataDefinitionType::OBJECT,
      }),
      state: DatadogAPIClient::V2::FormVersionState::FROZEN,
      ui_definition: DatadogAPIClient::V2::FormUiDefinition.new({
        ui_order: [],
        ui_theme: DatadogAPIClient::V2::FormUiDefinitionUiTheme.new({
          primary_color: DatadogAPIClient::V2::FormUiDefinitionUiThemePrimaryColor::GRAY,
        }),
      }),
      upsert_params: DatadogAPIClient::V2::UpsertFormVersionUpsertParams.new({
        etag: "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d",
        insert_only: false,
        match_policy: DatadogAPIClient::V2::LatestVersionMatchPolicy::NONE,
      }),
    }),
    type: DatadogAPIClient::V2::FormVersionType::FORM_VERSIONS,
  }),
})
p api_instance.upsert_form_version(FORM_DATA_ID, body)

// Create or update a form version returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_forms::FormsAPI;
use datadog_api_client::datadogV2::model::FormDataDefinition;
use datadog_api_client::datadogV2::model::FormDataDefinitionType;
use datadog_api_client::datadogV2::model::FormUiDefinition;
use datadog_api_client::datadogV2::model::FormUiDefinitionUiTheme;
use datadog_api_client::datadogV2::model::FormUiDefinitionUiThemePrimaryColor;
use datadog_api_client::datadogV2::model::FormVersionState;
use datadog_api_client::datadogV2::model::FormVersionType;
use datadog_api_client::datadogV2::model::LatestVersionMatchPolicy;
use datadog_api_client::datadogV2::model::UpsertFormVersionData;
use datadog_api_client::datadogV2::model::UpsertFormVersionDataAttributes;
use datadog_api_client::datadogV2::model::UpsertFormVersionRequest;
use datadog_api_client::datadogV2::model::UpsertFormVersionUpsertParams;

#[tokio::main]
async fn main() {
    // there is a valid "form" in the system
    let form_data_id =
        uuid::Uuid::parse_str(&std::env::var("FORM_DATA_ID").unwrap()).expect("Invalid UUID");
    let body = UpsertFormVersionRequest::new(UpsertFormVersionData::new(
        UpsertFormVersionDataAttributes::new(
            FormDataDefinition::new()
                .description("Welcome to the Engineering Experience Survey.".to_string())
                .required(vec![])
                .title("Developer Experience Survey".to_string())
                .type_(FormDataDefinitionType::OBJECT),
            FormVersionState::FROZEN,
            FormUiDefinition::new().ui_order(vec![]).ui_theme(
                FormUiDefinitionUiTheme::new()
                    .primary_color(FormUiDefinitionUiThemePrimaryColor::GRAY),
            ),
            UpsertFormVersionUpsertParams::new(LatestVersionMatchPolicy::NONE)
                .etag(Some(
                    "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d".to_string(),
                ))
                .insert_only(false),
        ),
        FormVersionType::FORM_VERSIONS,
    ));
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.upsert_form_version", true);
    let api = FormsAPI::with_config(configuration);
    let resp = api.upsert_form_version(form_data_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

/**
 * Create or update a form version returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration({
  authMethods: {
    AuthZ: {
      accessToken: process.env.DD_BEARER_TOKEN as string,
    },
  },
});
configuration.unstableOperations["v2.upsertFormVersion"] = true;
const apiInstance = new v2.FormsApi(configuration);

// there is a valid "form" in the system
const FORM_DATA_ID = process.env.FORM_DATA_ID as string;

const params: v2.FormsApiUpsertFormVersionRequest = {
  body: {
    data: {
      attributes: {
        dataDefinition: {
          description: "Welcome to the Engineering Experience Survey.",
          required: [],
          title: "Developer Experience Survey",
          type: "object",
        },
        state: "frozen",
        uiDefinition: {
          uiOrder: [],
          uiTheme: {
            primaryColor: "gray",
          },
        },
        upsertParams: {
          etag: "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d",
          insertOnly: false,
          matchPolicy: "none",
        },
      },
      type: "form_versions",
    },
  },
  formId: FORM_DATA_ID,
};

apiInstance
  .upsertFormVersion(params)
  .then((data: v2.FormVersionResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));