Creating Dashboards

import httpx

async def create_dashboard(
    tenant_id: str,
    workspace_id: str,
    name: str,
    description: Optional[str] = None,
    created_by: Optional[str] = None
):
    # 1. Call Papermap API with HMAC signature
    headers = _get_auth_headers(workspace_id, API_KEY_ID, SECRET_KEY)

    payload = {
        "workspace_id": workspace_id,
        "title": name,
        "description": description
    }

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{PAPERMAP_API_URL}/api/v1/external/dashboards",
            headers=headers,
            json=payload
        )

    external_dashboard = response.json()
    dashboard_id = external_dashboard["data"]["data"]["dashboard_id"]

    # 2. Store mapping in your database
    tenant_dashboard = TenantDashboard.create(
        session=db,
        tenant_id=tenant_id,
        workspace_id=workspace_id,
        dashboard_id=dashboard_id,
        created_by=created_by
    )

    return tenant_dashboard

import axios from "axios";

async function createDashboard(
  tenantId: string,
  workspaceId: string,
  name: string,
  description?: string
) {
  const service = new DashboardAPIService({
    apiKeyId: process.env.PAPERMAP_API_KEY_ID,
    secretKey: process.env.PAPERMAP_SECRET_KEY,
    workspaceId: workspaceId,
    baseUrl: process.env.PAPERMAP_API_URL,
  });

  const headers = service.getAuthHeaders();

  const response = await axios.post(
    `${service.config.baseUrl}/api/v1/external/dashboards`,
    {
      workspace_id: workspaceId,
      title: name,
      description,
    },
    { headers }
  );

  const dashboardId = response.data.data.dashboard_id;

  // Store mapping in your database
  await db.tenantDashboards.create({
    tenant_id: tenantId,
    workspace_id: workspaceId,
    dashboard_id: dashboardId,
  });

  return { dashboardId, ...response.data };
}

<?php
function createDashboardForTenant($tenantId, $workspaceId, $name, $description = null) {
    $headers = getAuthHeaders(
        $workspaceId,
        getenv('PAPERMAP_API_KEY_ID'),
        getenv('PAPERMAP_SECRET_KEY')
    );

    $payload = [
        'workspace_id' => $workspaceId,
        'title' => $name,
        'description' => $description
    ];

    $ch = curl_init(getenv('PAPERMAP_API_URL') . '/api/v1/external/dashboards');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));

    $headerArray = [];
    foreach ($headers as $key => $value) {
        $headerArray[] = "$key: $value";
    }
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headerArray);

    $response = curl_exec($ch);
    curl_close($ch);

    $data = json_decode($response, true);
    $dashboardId = $data['data']['data']['id'];

    // Store mapping in your database
    DB::table('tenant_dashboards')->insert([
        'tenant_id' => $tenantId,
        'workspace_id' => $workspaceId,
        'dashboard_id' => $dashboardId
    ]);

    return ['dashboard_id' => $dashboardId, 'data' => $data];
}
?>

public DashboardResponse createDashboard(
    String workspaceId,
    String name,
    String description
) throws Exception {
    HttpHeaders headers = getAuthHeaders(workspaceId);

    Map<String, String> payload = new HashMap<>();
    payload.put("workspace_id", workspaceId);
    payload.put("title", name);
    payload.put("description", description);

    HttpEntity<Map<String, String>> request = new HttpEntity<>(payload, headers);

    ResponseEntity<DashboardResponse> response = restTemplate.exchange(
        baseUrl + "/api/v1/external/dashboards",
        HttpMethod.POST,
        request,
        DashboardResponse.class
    );

    return response.getBody();
}

public async Task<DashboardResponse> CreateDashboard(
    string workspaceId,
    string name,
    string description = null
)
{
    var headers = GetAuthHeaders(workspaceId);
    var request = new HttpRequestMessage(
        HttpMethod.Post,
        $"{_baseUrl}/api/v1/external/dashboards"
    );

    foreach (var header in headers)
    {
        request.Headers.Add(header.Key, header.Value);
    }

    var payload = new
    {
        workspace_id = workspaceId,
        title = name,
        description
    };

    request.Content = new StringContent(
        JsonSerializer.Serialize(payload),
        Encoding.UTF8,
        "application/json"
    );

    var response = await _httpClient.SendAsync(request);
    var content = await response.Content.ReadAsStringAsync();

    return JsonSerializer.Deserialize<DashboardResponse>(content);
}

func (s *DashboardAPIService) CreateDashboard(
    workspaceID, name, description string,
) (*Dashboard, error) {
    headers := s.getAuthHeaders(workspaceID)

    payload := map[string]string{
        "workspace_id": workspaceID,
        "title":        name,
        "description":  description,
    }

    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest(
        "POST",
        s.BaseURL+"/api/v1/external/dashboards",
        strings.NewReader(string(jsonData)),
    )

    for key, value := range headers {
        req.Header.Set(key, value)
    }

    resp, err := s.Client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result Dashboard
    json.NewDecoder(resp.Body).Decode(&result)

    return &result, nil
}