edc-web-components 0.7.1

A Rust Web Components with patternfly-yew client for EDC
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

use crate::components::{ConstraintRenderer, DidLabel};
use edc_connector_client::types::policy::{Obligation, Permission, Prohibition};
use patternfly_yew::prelude::*;
use std::collections::HashMap;
use yew::prelude::*;

#[derive(Clone, Debug, PartialEq, Properties)]
pub struct PolicyPropertiesProps {
  pub permissions: Vec<Permission>,
  pub obligations: Vec<Obligation>,
  pub prohibitions: Vec<Prohibition>,
  pub extensible_properties: HashMap<String, serde_json::Value>,
  pub assigner: Option<String>,
  pub assignee: Option<String>,
}

#[component]
pub fn PolicyProperties(props: &PolicyPropertiesProps) -> Html {
  let permissions = if props.permissions.is_empty() {
    None
  } else {
    let permissions = props.permissions.iter().map(|permission| {
      html! {
        <ConstraintRenderer
          action={permission.action().clone()}
          constraints={permission.constraints().to_vec()}
        />
      }
    });

    Some(html_nested!(<DescriptionGroup term="Permissions">{ for permissions }</DescriptionGroup>))
  };

  let obligations = if props.obligations.is_empty() {
    None
  } else {
    let obligations = props.obligations.iter().map(|obligation| {
      html! {
        <ConstraintRenderer
          action={obligation.action().clone()}
          constraints={obligation.constraints().to_vec()}
        />
      }
    });

    Some(html_nested!(<DescriptionGroup term="Obligations">{ for obligations }</DescriptionGroup>))
  };

  let prohibitions = if props.prohibitions.is_empty() {
    None
  } else {
    let prohibitions = props.prohibitions.iter().map(|prohibition| {
      html! {
        <ConstraintRenderer
          action={prohibition.action().clone()}
          constraints={prohibition.constraints().to_vec()}
        />
      }
    });

    Some(
      html_nested!(<DescriptionGroup term="Prohibitions">{ for prohibitions }</DescriptionGroup>),
    )
  };

  let extensible_properties = if props.extensible_properties.is_empty() {
    None
  } else {
    let extensible_properties = props.extensible_properties.iter().map(|(key, value)| {
      html! { <DescriptionGroup term={key.clone()}>{ value.to_string() }</DescriptionGroup> }
    });

    Some(html_nested!(
      <DescriptionGroup term="Extensible Properties">
        <DescriptionList mode={[DescriptionListMode::Horizontal]}>
          { for extensible_properties }
        </DescriptionList>
      </DescriptionGroup>
    ))
  };

  let assigner = props
    .assigner
    .as_ref()
    .map(|assigner| {
      Some(html_nested! {
        <StackItem>
          <DescriptionGroup term="Assigner">
            <DidLabel did={assigner.clone()} />
          </DescriptionGroup>
        </StackItem>
      })
    })
    .unwrap_or_default();

  let assignee = props
    .assignee
    .as_ref()
    .map(|assignee| {
      Some(html_nested! {
        <StackItem>
          <DescriptionGroup term="Assignee">
            <DidLabel did={assignee.clone()} />
          </DescriptionGroup>
        </StackItem>
      })
    })
    .unwrap_or_default();

  html!(
    <>
      { permissions }
      { obligations }
      { prohibitions }
      { extensible_properties }
      { assigner }
      { assignee }
    </>
  )
}