폼 버전 업서트 및 게시

// Upsert and publish 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.UpsertAndPublishFormVersionRequest{
		Data: datadogV2.UpsertAndPublishFormVersionData{
			Attributes: datadogV2.UpsertAndPublishFormVersionDataAttributes{
				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(),
				},
				UiDefinition: datadogV2.FormUiDefinition{
					UiOrder: []string{},
					UiTheme: &datadogV2.FormUiDefinitionUiTheme{
						PrimaryColor: datadogV2.FORMUIDEFINITIONUITHEMEPRIMARYCOLOR_GRAY.Ptr(),
					},
				},
				UpsertParams: datadogV2.UpsertAndPublishFormVersionUpsertParams{
					Etag: "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d",
				},
			},
			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.UpsertAndPublishFormVersion", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewFormsApi(apiClient)
	resp, r, err := api.UpsertAndPublishFormVersion(ctx, FormDataID, body)

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

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

// Upsert and publish 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.FormResponse;
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.FormVersionType;
import com.datadog.api.client.v2.model.UpsertAndPublishFormVersionData;
import com.datadog.api.client.v2.model.UpsertAndPublishFormVersionDataAttributes;
import com.datadog.api.client.v2.model.UpsertAndPublishFormVersionRequest;
import com.datadog.api.client.v2.model.UpsertAndPublishFormVersionUpsertParams;
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.upsertAndPublishFormVersion", 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());
    }

    UpsertAndPublishFormVersionRequest body =
        new UpsertAndPublishFormVersionRequest()
            .data(
                new UpsertAndPublishFormVersionData()
                    .attributes(
                        new UpsertAndPublishFormVersionDataAttributes()
                            .dataDefinition(
                                new FormDataDefinition()
                                    .description("Welcome to the Engineering Experience Survey.")
                                    .title("Developer Experience Survey")
                                    .type(FormDataDefinitionType.OBJECT))
                            .uiDefinition(
                                new FormUiDefinition()
                                    .uiTheme(
                                        new FormUiDefinitionUiTheme()
                                            .primaryColor(
                                                FormUiDefinitionUiThemePrimaryColor.GRAY)))
                            .upsertParams(
                                new UpsertAndPublishFormVersionUpsertParams()
                                    .etag(
                                        "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d")))
                    .type(FormVersionType.FORM_VERSIONS));

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

"""
Upsert and publish 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_type import FormVersionType
from datadog_api_client.v2.model.upsert_and_publish_form_version_data import UpsertAndPublishFormVersionData
from datadog_api_client.v2.model.upsert_and_publish_form_version_data_attributes import (
    UpsertAndPublishFormVersionDataAttributes,
)
from datadog_api_client.v2.model.upsert_and_publish_form_version_request import UpsertAndPublishFormVersionRequest
from datadog_api_client.v2.model.upsert_and_publish_form_version_upsert_params import (
    UpsertAndPublishFormVersionUpsertParams,
)

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

body = UpsertAndPublishFormVersionRequest(
    data=UpsertAndPublishFormVersionData(
        attributes=UpsertAndPublishFormVersionDataAttributes(
            data_definition=FormDataDefinition(
                description="Welcome to the Engineering Experience Survey.",
                required=[],
                title="Developer Experience Survey",
                type=FormDataDefinitionType.OBJECT,
            ),
            ui_definition=FormUiDefinition(
                ui_order=[],
                ui_theme=FormUiDefinitionUiTheme(
                    primary_color=FormUiDefinitionUiThemePrimaryColor.GRAY,
                ),
            ),
            upsert_params=UpsertAndPublishFormVersionUpsertParams(
                etag="b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d",
            ),
        ),
        type=FormVersionType.FORM_VERSIONS,
    ),
)

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

    print(response)

# Upsert and publish 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_and_publish_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::UpsertAndPublishFormVersionRequest.new({
  data: DatadogAPIClient::V2::UpsertAndPublishFormVersionData.new({
    attributes: DatadogAPIClient::V2::UpsertAndPublishFormVersionDataAttributes.new({
      data_definition: DatadogAPIClient::V2::FormDataDefinition.new({
        description: "Welcome to the Engineering Experience Survey.",
        required: [],
        title: "Developer Experience Survey",
        type: DatadogAPIClient::V2::FormDataDefinitionType::OBJECT,
      }),
      ui_definition: DatadogAPIClient::V2::FormUiDefinition.new({
        ui_order: [],
        ui_theme: DatadogAPIClient::V2::FormUiDefinitionUiTheme.new({
          primary_color: DatadogAPIClient::V2::FormUiDefinitionUiThemePrimaryColor::GRAY,
        }),
      }),
      upsert_params: DatadogAPIClient::V2::UpsertAndPublishFormVersionUpsertParams.new({
        etag: "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d",
      }),
    }),
    type: DatadogAPIClient::V2::FormVersionType::FORM_VERSIONS,
  }),
})
p api_instance.upsert_and_publish_form_version(FORM_DATA_ID, body)

// Upsert and publish 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::FormVersionType;
use datadog_api_client::datadogV2::model::UpsertAndPublishFormVersionData;
use datadog_api_client::datadogV2::model::UpsertAndPublishFormVersionDataAttributes;
use datadog_api_client::datadogV2::model::UpsertAndPublishFormVersionRequest;
use datadog_api_client::datadogV2::model::UpsertAndPublishFormVersionUpsertParams;

#[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 = UpsertAndPublishFormVersionRequest::new(UpsertAndPublishFormVersionData::new(
        UpsertAndPublishFormVersionDataAttributes::new(
            FormDataDefinition::new()
                .description("Welcome to the Engineering Experience Survey.".to_string())
                .required(vec![])
                .title("Developer Experience Survey".to_string())
                .type_(FormDataDefinitionType::OBJECT),
            FormUiDefinition::new().ui_order(vec![]).ui_theme(
                FormUiDefinitionUiTheme::new()
                    .primary_color(FormUiDefinitionUiThemePrimaryColor::GRAY),
            ),
            UpsertAndPublishFormVersionUpsertParams::new(
                "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d".to_string(),
            ),
        ),
        FormVersionType::FORM_VERSIONS,
    ));
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.upsert_and_publish_form_version", true);
    let api = FormsAPI::with_config(configuration);
    let resp = api
        .upsert_and_publish_form_version(form_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

/**
 * Upsert and publish 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.upsertAndPublishFormVersion"] = 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.FormsApiUpsertAndPublishFormVersionRequest = {
  body: {
    data: {
      attributes: {
        dataDefinition: {
          description: "Welcome to the Engineering Experience Survey.",
          required: [],
          title: "Developer Experience Survey",
          type: "object",
        },
        uiDefinition: {
          uiOrder: [],
          uiTheme: {
            primaryColor: "gray",
          },
        },
        upsertParams: {
          etag: "b51f08b698d88d8027a935d9db649774949f5fb41a0c559bfee6a9a13225c72d",
        },
      },
      type: "form_versions",
    },
  },
  formId: FORM_DATA_ID,
};

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