Bulk create and remove teams ownership mappings

// Bulk create and remove teams ownership mappings 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"
)

func main() {
	body := datadogV2.TeamsOwnershipMappingBatchRequest{
		AtomicOperations: []datadogV2.TeamsOwnershipMappingBatchOperation{
			{
				Op: datadogV2.TEAMSOWNERSHIPMAPPINGBATCHOPERATIONOP_ADD,
				Data: &datadogV2.TeamsOwnershipMappingBatchOperationData{
					Type: datadogV2.TEAMSOWNERSHIPMAPPINGTYPE_TEAMS_OWNERSHIP_MAPPINGS,
					Attributes: datadogV2.TeamsOwnershipMappingBatchOperationDataAttributes{
						TeamHandle: datadog.PtrString("team-rum"),
						ViewName:   datadog.PtrString("/checkout-examplerumteamsownership"),
						Service:    datadog.PtrString("web-checkout-examplerumteamsownership"),
						MatchType:  datadogV2.TEAMSOWNERSHIPMATCHTYPE_EXACT.Ptr(),
					},
				},
			},
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewRumTeamsOwnershipApi(apiClient)
	resp, r, err := api.CreateTeamsOwnershipMappingsBatch(ctx, body)

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

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

// Bulk create and remove teams ownership mappings returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.RumTeamsOwnershipApi;
import com.datadog.api.client.v2.model.TeamsOwnershipMappingBatchOperation;
import com.datadog.api.client.v2.model.TeamsOwnershipMappingBatchOperationData;
import com.datadog.api.client.v2.model.TeamsOwnershipMappingBatchOperationDataAttributes;
import com.datadog.api.client.v2.model.TeamsOwnershipMappingBatchOperationOp;
import com.datadog.api.client.v2.model.TeamsOwnershipMappingBatchRequest;
import com.datadog.api.client.v2.model.TeamsOwnershipMappingBatchResponse;
import com.datadog.api.client.v2.model.TeamsOwnershipMappingType;
import com.datadog.api.client.v2.model.TeamsOwnershipMatchType;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN"));
    RumTeamsOwnershipApi apiInstance = new RumTeamsOwnershipApi(defaultClient);

    TeamsOwnershipMappingBatchRequest body =
        new TeamsOwnershipMappingBatchRequest()
            .atomicOperations(
                Collections.singletonList(
                    new TeamsOwnershipMappingBatchOperation()
                        .op(TeamsOwnershipMappingBatchOperationOp.ADD)
                        .data(
                            new TeamsOwnershipMappingBatchOperationData()
                                .type(TeamsOwnershipMappingType.TEAMS_OWNERSHIP_MAPPINGS)
                                .attributes(
                                    new TeamsOwnershipMappingBatchOperationDataAttributes()
                                        .teamHandle("team-rum")
                                        .viewName("/checkout-examplerumteamsownership")
                                        .service("web-checkout-examplerumteamsownership")
                                        .matchType(TeamsOwnershipMatchType.EXACT)))));

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

"""
Bulk create and remove teams ownership mappings returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.rum_teams_ownership_api import RumTeamsOwnershipApi
from datadog_api_client.v2.model.teams_ownership_mapping_batch_operation import TeamsOwnershipMappingBatchOperation
from datadog_api_client.v2.model.teams_ownership_mapping_batch_operation_data import (
    TeamsOwnershipMappingBatchOperationData,
)
from datadog_api_client.v2.model.teams_ownership_mapping_batch_operation_data_attributes import (
    TeamsOwnershipMappingBatchOperationDataAttributes,
)
from datadog_api_client.v2.model.teams_ownership_mapping_batch_operation_op import TeamsOwnershipMappingBatchOperationOp
from datadog_api_client.v2.model.teams_ownership_mapping_batch_request import TeamsOwnershipMappingBatchRequest
from datadog_api_client.v2.model.teams_ownership_mapping_type import TeamsOwnershipMappingType
from datadog_api_client.v2.model.teams_ownership_match_type import TeamsOwnershipMatchType

body = TeamsOwnershipMappingBatchRequest(
    atomic_operations=[
        TeamsOwnershipMappingBatchOperation(
            op=TeamsOwnershipMappingBatchOperationOp.ADD,
            data=TeamsOwnershipMappingBatchOperationData(
                type=TeamsOwnershipMappingType.TEAMS_OWNERSHIP_MAPPINGS,
                attributes=TeamsOwnershipMappingBatchOperationDataAttributes(
                    team_handle="team-rum",
                    view_name="/checkout-examplerumteamsownership",
                    service="web-checkout-examplerumteamsownership",
                    match_type=TeamsOwnershipMatchType.EXACT,
                ),
            ),
        ),
    ],
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
with ApiClient(configuration) as api_client:
    api_instance = RumTeamsOwnershipApi(api_client)
    response = api_instance.create_teams_ownership_mappings_batch(body=body)

    print(response)

# Bulk create and remove teams ownership mappings returns "OK" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.access_token = ENV["DD_BEARER_TOKEN"]
end
api_instance = DatadogAPIClient::V2::RumTeamsOwnershipAPI.new

body = DatadogAPIClient::V2::TeamsOwnershipMappingBatchRequest.new({
  atomic_operations: [
    DatadogAPIClient::V2::TeamsOwnershipMappingBatchOperation.new({
      op: DatadogAPIClient::V2::TeamsOwnershipMappingBatchOperationOp::ADD,
      data: DatadogAPIClient::V2::TeamsOwnershipMappingBatchOperationData.new({
        type: DatadogAPIClient::V2::TeamsOwnershipMappingType::TEAMS_OWNERSHIP_MAPPINGS,
        attributes: DatadogAPIClient::V2::TeamsOwnershipMappingBatchOperationDataAttributes.new({
          team_handle: "team-rum",
          view_name: "/checkout-examplerumteamsownership",
          service: "web-checkout-examplerumteamsownership",
          match_type: DatadogAPIClient::V2::TeamsOwnershipMatchType::EXACT,
        }),
      }),
    }),
  ],
})
p api_instance.create_teams_ownership_mappings_batch(body)

// Bulk create and remove teams ownership mappings returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_rum_teams_ownership::RumTeamsOwnershipAPI;
use datadog_api_client::datadogV2::model::TeamsOwnershipMappingBatchOperation;
use datadog_api_client::datadogV2::model::TeamsOwnershipMappingBatchOperationData;
use datadog_api_client::datadogV2::model::TeamsOwnershipMappingBatchOperationDataAttributes;
use datadog_api_client::datadogV2::model::TeamsOwnershipMappingBatchOperationOp;
use datadog_api_client::datadogV2::model::TeamsOwnershipMappingBatchRequest;
use datadog_api_client::datadogV2::model::TeamsOwnershipMappingType;
use datadog_api_client::datadogV2::model::TeamsOwnershipMatchType;

#[tokio::main]
async fn main() {
    let body =
        TeamsOwnershipMappingBatchRequest::new(vec![TeamsOwnershipMappingBatchOperation::new(
            TeamsOwnershipMappingBatchOperationOp::ADD,
        )
        .data(TeamsOwnershipMappingBatchOperationData::new(
            TeamsOwnershipMappingBatchOperationDataAttributes::new()
                .match_type(TeamsOwnershipMatchType::EXACT)
                .service("web-checkout-examplerumteamsownership".to_string())
                .team_handle("team-rum".to_string())
                .view_name("/checkout-examplerumteamsownership".to_string()),
            TeamsOwnershipMappingType::TEAMS_OWNERSHIP_MAPPINGS,
        ))]);
    let configuration = datadog::Configuration::new();
    let api = RumTeamsOwnershipAPI::with_config(configuration);
    let resp = api.create_teams_ownership_mappings_batch(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

/**
 * Bulk create and remove teams ownership mappings 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,
    },
  },
});
const apiInstance = new v2.RumTeamsOwnershipApi(configuration);

const params: v2.RumTeamsOwnershipApiCreateTeamsOwnershipMappingsBatchRequest =
  {
    body: {
      atomicOperations: [
        {
          op: "add",
          data: {
            type: "teams_ownership_mappings",
            attributes: {
              teamHandle: "team-rum",
              viewName: "/checkout-examplerumteamsownership",
              service: "web-checkout-examplerumteamsownership",
              matchType: "exact",
            },
          },
        },
      ],
    },
  };

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