pipedash-plugin-api 0.13.0

Plugin API for Pipedash - CI/CD pipeline dashboard
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::schema::{
    CellRenderer,
    ColumnDataType,
    ColumnDefinition,
    ColumnVisibility,
    TableDefinition,
};

impl ColumnDefinition {
    pub fn new(
        id: &str, label: &str, field_path: &str, data_type: ColumnDataType, renderer: CellRenderer,
    ) -> Self {
        Self {
            id: id.to_string(),
            label: label.to_string(),
            description: None,
            field_path: field_path.to_string(),
            data_type,
            renderer,
            visibility: ColumnVisibility::Always,
            default_visible: true,
            width: None,
            sortable: false,
            filterable: false,
        }
    }

    pub fn badge(id: &str, label: &str, field_path: &str) -> Self {
        Self::new(
            id,
            label,
            field_path,
            ColumnDataType::String,
            CellRenderer::Badge,
        )
    }

    pub fn text(id: &str, label: &str, field_path: &str) -> Self {
        Self::new(
            id,
            label,
            field_path,
            ColumnDataType::String,
            CellRenderer::Text,
        )
    }

    pub fn metadata(
        id: &str, label: &str, description: &str, renderer: CellRenderer, default_visible: bool,
    ) -> Self {
        let mut column = Self::new(
            id,
            label,
            &format!("metadata.{id}"),
            ColumnDataType::String,
            renderer,
        )
        .described(description)
        .with_width(140)
        .sortable();
        column.default_visible = default_visible;
        column
    }

    pub fn described(mut self, description: &str) -> Self {
        self.description = Some(description.to_string());
        self
    }

    pub fn with_width(mut self, width: u32) -> Self {
        self.width = Some(width);
        self
    }

    pub fn when_present(mut self) -> Self {
        self.visibility = ColumnVisibility::WhenPresent;
        self
    }

    pub fn hidden(mut self) -> Self {
        self.default_visible = false;
        self
    }

    pub fn sortable(mut self) -> Self {
        self.sortable = true;
        self
    }

    pub fn filterable(mut self) -> Self {
        self.filterable = true;
        self
    }
}

pub fn trigger_event_column(description: &str) -> ColumnDefinition {
    ColumnDefinition::badge("event", "Trigger", "metadata.event")
        .described(description)
        .with_width(130)
        .sortable()
}

impl TableDefinition {
    pub fn new(
        id: &str, name: &str, description: &str, default_sort: (&str, &str),
        columns: Vec<ColumnDefinition>,
    ) -> Self {
        Self {
            id: id.to_string(),
            name: name.to_string(),
            description: Some(description.to_string()),
            columns,
            default_sort_column: Some(default_sort.0.to_string()),
            default_sort_direction: Some(default_sort.1.to_string()),
        }
    }

    pub fn column_mut(&mut self, id: &str) -> Option<&mut ColumnDefinition> {
        self.columns.iter_mut().find(|column| column.id == id)
    }

    pub fn insert_after(
        &mut self, anchor_id: &str, columns: impl IntoIterator<Item = ColumnDefinition>,
    ) {
        let at = self
            .columns
            .iter()
            .position(|column| column.id == anchor_id)
            .map_or(self.columns.len(), |index| index + 1);
        self.columns.splice(at..at, columns);
    }
}

#[cfg(test)]
mod tests;