edc-web-components 0.4.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

use crate::contexts::use_edc_connector_context;
use edc_connector_client::types::contract_negotiation::{
  ContractNegotiation, ContractNegotiationState,
};
use patternfly_yew::prelude::*;
use std::time::Duration;
use yew::platform::spawn_local;
use yew::platform::time::sleep;
use yew::prelude::*;

const HAPPY_PATH_STATES: [(&str, ContractNegotiationState); 7] = [
  ("Initial", ContractNegotiationState::Initial),
  ("Requested", ContractNegotiationState::Requested),
  ("Offered", ContractNegotiationState::Offered),
  ("Accepted", ContractNegotiationState::Accepted),
  ("Agreed", ContractNegotiationState::Agreed),
  ("Verifier", ContractNegotiationState::Verified),
  ("Finalized", ContractNegotiationState::Finalized),
];

#[derive(Clone, Debug, PartialEq, Properties)]
pub struct ContractNegotiationStatusProps {
  pub contract_negotiation_id: String,
  pub on_finalized: Callback<()>,
}

#[component]
pub fn ContractNegotiationStatus(props: &ContractNegotiationStatusProps) -> Html {
  let edc_connector_client = use_edc_connector_context();

  let contract_negotiation_state = use_state(|| None);

  use_effect_with(
    (
      props.contract_negotiation_id.clone(),
      edc_connector_client.clone(),
      contract_negotiation_state.setter(),
      props.on_finalized.clone(),
    ),
    |(
      contract_negotiation_id,
      edc_connector_client,
      contract_negotiation_state_setter,
      on_finalized,
    )| {
      let contract_negotiation_id = contract_negotiation_id.clone();
      let edc_connector_client = edc_connector_client.clone();
      let contract_negotiation_state_setter = contract_negotiation_state_setter.clone();
      let on_finalized = on_finalized.clone();

      spawn_local(async move {
        loop {
          let contract_negotiation = if let Some(client) = edc_connector_client.get_client() {
            client
              .contract_negotiations(edc_connector_client::EdcConnectorApiVersion::V4)
              .get(&contract_negotiation_id)
              .await
              .ok()
          } else {
            None
          };

          let state = contract_negotiation
            .as_ref()
            .map(|contract_negotiation| contract_negotiation.state().clone());

          contract_negotiation_state_setter.set(contract_negotiation);

          if state == Some(ContractNegotiationState::Finalized) {
            on_finalized.emit(());
            break;
          }

          sleep(Duration::from_secs(1)).await;
        }
      });
    },
  );

  if let Some(contract_negotiation) = (*contract_negotiation_state).clone() {
    let contract_negotiation: ContractNegotiation = contract_negotiation;

    let current_state_index = HAPPY_PATH_STATES
      .iter()
      .position(|(_, state)| state == contract_negotiation.state())
      .unwrap_or_default();

    let steps = HAPPY_PATH_STATES
      .iter()
      .enumerate()
      .map(|(index, (state_label, _))| {
        let status = if index < current_state_index {
          ProgressStepperStepStatus::Success
        } else if index == current_state_index {
          if index == HAPPY_PATH_STATES.len() - 1 {
            ProgressStepperStepStatus::Success
          } else {
            ProgressStepperStepStatus::Default
          }
        } else {
          ProgressStepperStepStatus::Pending
        };

        html_nested!(
          <ProgressStepperStep {status}>
            <div>{ state_label.to_string() }</div>
          </ProgressStepperStep>
        )
      });

    html!(<ProgressStepper>{ for steps }</ProgressStepper>)
  } else {
    html!()
  }
}