slacko 0.2.2

Comprehensive Rust SDK for the Slack API with stealth mode support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Workflows API
//!
//! Methods for Workflow Builder integrations.

use crate::client::SlackClient;
use crate::error::Result;
use serde::{Deserialize, Serialize};

/// Workflows API client
pub struct WorkflowsApi {
    client: SlackClient,
}

impl WorkflowsApi {
    pub(crate) fn new(client: SlackClient) -> Self {
        Self { client }
    }

    /// Complete or advance a workflow step execution
    ///
    /// # Arguments
    ///
    /// * `workflow_step_execute_id` - Workflow step execution ID
    /// * `outputs` - Output values from the step
    pub async fn step_completed(
        &self,
        workflow_step_execute_id: &str,
        outputs: serde_json::Value,
    ) -> Result<WorkflowsStepCompletedResponse> {
        let params = WorkflowsStepCompletedRequest {
            workflow_step_execute_id: workflow_step_execute_id.to_string(),
            outputs: Some(outputs),
        };

        self.client.post("workflows.stepCompleted", &params).await
    }

    /// Mark a workflow step execution as failed
    ///
    /// # Arguments
    ///
    /// * `workflow_step_execute_id` - Workflow step execution ID
    /// * `error` - Error message
    pub async fn step_failed(
        &self,
        workflow_step_execute_id: &str,
        error: &str,
    ) -> Result<WorkflowsStepFailedResponse> {
        let params = WorkflowsStepFailedRequest {
            workflow_step_execute_id: workflow_step_execute_id.to_string(),
            error: error.to_string(),
        };

        self.client.post("workflows.stepFailed", &params).await
    }

    /// Update the configuration for a workflow step
    ///
    /// # Arguments
    ///
    /// * `workflow_step_edit_id` - Workflow step edit ID
    /// * `inputs` - Input configuration
    /// * `outputs` - Output configuration
    pub async fn update_step(
        &self,
        workflow_step_edit_id: &str,
        inputs: serde_json::Value,
        outputs: serde_json::Value,
    ) -> Result<WorkflowsUpdateStepResponse> {
        let params = WorkflowsUpdateStepRequest {
            workflow_step_edit_id: workflow_step_edit_id.to_string(),
            inputs: Some(inputs),
            outputs: Some(outputs),
        };

        self.client.post("workflows.updateStep", &params).await
    }
}

// Request/Response types

#[derive(Debug, Serialize)]
pub struct WorkflowsStepCompletedRequest {
    pub workflow_step_execute_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub outputs: Option<serde_json::Value>,
}

#[derive(Debug, Deserialize)]
pub struct WorkflowsStepCompletedResponse {}

#[derive(Debug, Serialize)]
pub struct WorkflowsStepFailedRequest {
    pub workflow_step_execute_id: String,
    pub error: String,
}

#[derive(Debug, Deserialize)]
pub struct WorkflowsStepFailedResponse {}

#[derive(Debug, Serialize)]
pub struct WorkflowsUpdateStepRequest {
    pub workflow_step_edit_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inputs: Option<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub outputs: Option<serde_json::Value>,
}

#[derive(Debug, Deserialize)]
pub struct WorkflowsUpdateStepResponse {}