curl --request PUT \
  --url https://api.usedatabrain.com/api/v2/data-app/metrics/publish \
  --header 'Authorization: Bearer dbn_live_abc123...' \
  --header 'Content-Type: application/json' \
  --data '{
    "embedId": "embed_abc123",
    "metricId": "metric_xyz789",
    "isPublished": true
  }'

curl --request PUT \
  --url https://api.usedatabrain.com/api/v2/data-app/metrics/publish \
  --header 'Authorization: Bearer dbn_live_abc123...' \
  --header 'Content-Type: application/json' \
  --data '{
    "embedId": "embed_abc123",
    "metricId": "metric_xyz789",
    "isPublished": false
  }'

const response = await fetch('https://api.usedatabrain.com/api/v2/data-app/metrics/publish', {
  method: 'PUT',
  headers: {
    'Authorization': 'Bearer dbn_live_abc123...',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    embedId: 'embed_abc123',
    metricId: 'metric_xyz789',
    isPublished: true
  })
});

const result = await response.json();
console.log('Metric published:', result.id);

// Publish multiple metrics sequentially
async function publishMetrics(embedId, metricIds, isPublished = true) {
  const results = [];
  
  for (const metricId of metricIds) {
    const response = await fetch(
      'https://api.usedatabrain.com/api/v2/data-app/metrics/publish',
      {
        method: 'PUT',
        headers: {
          'Authorization': 'Bearer dbn_live_abc123...',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ embedId, metricId, isPublished })
      }
    );
    
    const result = await response.json();
    results.push({ metricId, success: !result.error });
  }
  
  return results;
}

// Usage
const metrics = ['metric_1', 'metric_2', 'metric_3'];
const results = await publishMetrics('embed_abc123', metrics, true);
console.log('Published metrics:', results);

import requests

response = requests.put(
    'https://api.usedatabrain.com/api/v2/data-app/metrics/publish',
    headers={
        'Authorization': 'Bearer dbn_live_abc123...',
        'Content-Type': 'application/json'
    },
    json={
        'embedId': 'embed_abc123',
        'metricId': 'metric_xyz789',
        'isPublished': True
    }
)

result = response.json()

if result.get('error'):
    print(f"Publish failed: {result['error']['message']}")
else:
    print(f"Metric published: {result['id']}")

import requests

def publish_metrics(embed_id, metric_ids, is_published=True):
    """Publish or unpublish multiple metrics"""
    results = []
    
    for metric_id in metric_ids:
        response = requests.put(
            'https://api.usedatabrain.com/api/v2/data-app/metrics/publish',
            headers={
                'Authorization': 'Bearer dbn_live_abc123...',
                'Content-Type': 'application/json'
            },
            json={
                'embedId': embed_id,
                'metricId': metric_id,
                'isPublished': is_published
            }
        )
        
        result = response.json()
        results.append({
            'metricId': metric_id,
            'success': 'error' not in result
        })
    
    return results

# Usage
metrics = ['metric_1', 'metric_2', 'metric_3']
results = publish_metrics('embed_abc123', metrics, True)
print(f"Published {sum(r['success'] for r in results)} metrics")

require 'net/http'
require 'json'

uri = URI('https://api.usedatabrain.com/api/v2/data-app/metrics/publish')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Put.new(uri)
request['Authorization'] = 'Bearer dbn_live_abc123...'
request['Content-Type'] = 'application/json'
request.body = {
  embedId: 'embed_abc123',
  metricId: 'metric_xyz789',
  isPublished: true
}.to_json

response = http.request(request)
result = JSON.parse(response.body)

if result['error']
  puts "Publish failed: #{result['error']['message']}"
else
  puts "Metric published: #{result['id']}"
end

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class PublishMetric {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        
        String requestBody = """
            {
                "embedId": "embed_abc123",
                "metricId": "metric_xyz789",
                "isPublished": true
            }
            """;
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.usedatabrain.com/api/v2/data-app/metrics/publish"))
            .header("Authorization", "Bearer dbn_live_abc123...")
            .header("Content-Type", "application/json")
            .PUT(HttpRequest.BodyPublishers.ofString(requestBody))
            .build();
            
        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type PublishMetricRequest struct {
    EmbedId     string `json:"embedId"`
    MetricId    string `json:"metricId"`
    IsPublished bool   `json:"isPublished"`
}

func main() {
    reqData := PublishMetricRequest{
        EmbedId:     "embed_abc123",
        MetricId:    "metric_xyz789",
        IsPublished: true,
    }
    
    jsonData, _ := json.Marshal(reqData)
    
    req, _ := http.NewRequest("PUT", 
        "https://api.usedatabrain.com/api/v2/data-app/metrics/publish", 
        bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer dbn_live_abc123...")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    
    fmt.Println("Metric published successfully")
}

<?php
$url = 'https://api.usedatabrain.com/api/v2/data-app/metrics/publish';
$data = [
    'embedId' => 'embed_abc123',
    'metricId' => 'metric_xyz789',
    'isPublished' => true
];

$options = [
    'http' => [
        'header' => [
            'Authorization: Bearer dbn_live_abc123...',
            'Content-Type: application/json'
        ],
        'method' => 'PUT',
        'content' => json_encode($data)
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);
$result = json_decode($response, true);

if (isset($result['error'])) {
    echo "Publish failed: " . $result['error']['message'];
} else {
    echo "Metric published: " . $result['id'];
}
?>

{
  "id": "metric_xyz789"
}

{
  "error": {
    "code": "INVALID_REQUEST_BODY",
    "message": "\"embedId\" is required"
  }
}

{
  "error": {
    "code": "INVALID_DATA_APP_API_KEY",
    "message": "invalid or expired API KEY, data app not found"
  }
}

{
  "error": {
    "code": "INVALID_METRIC_ID",
    "message": "Invalid metric id or embed id"
  }
}

{
  "error": {
    "code": "INTERNAL_SERVER_ERROR",
    "message": "Internal Server Error"
  }
}