Skip to main content

raps_da/
activities.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright 2024-2025 Dmytro Yemelianov
3
4//! Activity operations for the Design Automation API.
5
6use anyhow::{Context, Result};
7use serde::Serialize;
8
9use raps_kernel::http;
10
11use crate::DesignAutomationClient;
12use crate::types::*;
13
14impl DesignAutomationClient {
15    /// List all activities
16    pub async fn list_activities(&self) -> Result<Vec<String>> {
17        let token = self.auth.get_token().await?;
18        let url = format!("{}/activities", self.config.da_url());
19
20        let response = http::send_with_retry(&self.config.http_config, || {
21            self.http_client.get(&url).bearer_auth(&token)
22        })
23        .await?;
24
25        if !response.status().is_success() {
26            let status = response.status();
27            let error_text = response.text().await.unwrap_or_default();
28            anyhow::bail!("Failed to list activities ({status}): {error_text}");
29        }
30
31        let paginated: PaginatedResponse<String> = response
32            .json()
33            .await
34            .context("Failed to parse activities response")?;
35
36        Ok(paginated.data)
37    }
38
39    /// Create a new activity
40    pub async fn create_activity(&self, request: CreateActivityRequest) -> Result<Activity> {
41        let token = self.auth.get_token().await?;
42        let url = format!("{}/activities", self.config.da_url());
43
44        let response = http::send_with_retry(&self.config.http_config, || {
45            self.http_client
46                .post(&url)
47                .bearer_auth(&token)
48                .header("Content-Type", "application/json")
49                .json(&request)
50        })
51        .await?;
52
53        if !response.status().is_success() {
54            let status = response.status();
55            let error_text = response.text().await.unwrap_or_default();
56            anyhow::bail!("Failed to create activity ({status}): {error_text}");
57        }
58
59        let activity: Activity = response
60            .json()
61            .await
62            .context("Failed to parse activity response")?;
63
64        Ok(activity)
65    }
66
67    /// Create an alias for an activity
68    pub async fn create_activity_alias(
69        &self,
70        activity_id: &str,
71        alias: &str,
72        version: i32,
73    ) -> Result<()> {
74        let token = self.auth.get_token().await?;
75        let url = format!(
76            "{}/activities/{}/aliases",
77            self.config.da_url(),
78            activity_id
79        );
80
81        #[derive(Serialize)]
82        struct AliasRequest {
83            id: String,
84            version: i32,
85        }
86
87        let request = AliasRequest {
88            id: alias.to_string(),
89            version,
90        };
91
92        let response = http::send_with_retry(&self.config.http_config, || {
93            self.http_client
94                .post(&url)
95                .bearer_auth(&token)
96                .header("Content-Type", "application/json")
97                .json(&request)
98        })
99        .await?;
100
101        if !response.status().is_success() {
102            let status = response.status();
103            let error_text = response.text().await.unwrap_or_default();
104            anyhow::bail!("Failed to create activity alias ({status}): {error_text}");
105        }
106
107        Ok(())
108    }
109
110    /// Delete an activity
111    pub async fn delete_activity(&self, id: &str) -> Result<()> {
112        let token = self.auth.get_token().await?;
113        let url = format!("{}/activities/{}", self.config.da_url(), id);
114
115        let response = http::send_with_retry(&self.config.http_config, || {
116            self.http_client.delete(&url).bearer_auth(&token)
117        })
118        .await?;
119
120        if !response.status().is_success() {
121            let status = response.status();
122            let error_text = response.text().await.unwrap_or_default();
123            anyhow::bail!("Failed to delete activity ({status}): {error_text}");
124        }
125
126        Ok(())
127    }
128}