edc-web-components 0.4.9

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::contexts::use_edc_connector_context;
use edc_connector_client::types::transfer_process::{TransferProcess, TransferProcessState};
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, TransferProcessState); 5] = [
  ("Initial", TransferProcessState::Initial),
  ("Provisioned", TransferProcessState::Provisioned),
  ("Requested", TransferProcessState::Requested),
  ("Started", TransferProcessState::Started),
  ("Completed", TransferProcessState::Completed),
];

#[derive(Clone, Debug, PartialEq, Properties)]
pub struct TransferProcessStatusProps {
  pub transfer_process_id: String,
  #[prop_or_default]
  pub on_started: Callback<()>,
  #[prop_or_default]
  pub on_finalized: Callback<()>,
}

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

  let transfer_process_state = use_state(|| None);
  let transfer_process_error = use_state(|| Option::<String>::None);

  use_effect_with(
    (
      props.transfer_process_id.clone(),
      edc_connector_client.clone(),
      transfer_process_state.setter(),
      transfer_process_error.setter(),
      props.on_finalized.clone(),
      props.on_started.clone(),
    ),
    |(
      transfer_process_id,
      edc_connector_client,
      transfer_process_state_setter,
      transfer_process_error_setter,
      on_finalized,
      on_started,
    )| {
      let transfer_process_id = transfer_process_id.clone();
      let edc_connector_client = edc_connector_client.clone();
      let transfer_process_state_setter = transfer_process_state_setter.clone();
      let transfer_process_error_setter = transfer_process_error_setter.clone();
      let on_finalized = on_finalized.clone();
      let on_started = on_started.clone();

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

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

          let error_message = transfer_process.as_ref().and_then(|transfer_process| {
            transfer_process
              .error_detail()
              .map(|error_detail| error_detail.to_string())
          });

          transfer_process_error_setter.set(error_message);

          transfer_process_state_setter.set(transfer_process);

          if state == Some(TransferProcessState::Started) {
            on_started.emit(());
            break;
          }

          if state == Some(TransferProcessState::Completed)
            || state == Some(TransferProcessState::Terminated)
          {
            on_finalized.emit(());
            break;
          }

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

  match (
    (*transfer_process_error).clone(),
    (*transfer_process_state).clone(),
  ) {
    (Some(error_message), _) => html!(
      <Alert title="Transfer Process failed" r#type={AlertType::Danger}>
        <div>{ error_message }</div>
      </Alert>
    ),
    (None, Some(transfer_process)) => {
      let transfer_process: TransferProcess = transfer_process;

      let current_state_index = HAPPY_PATH_STATES
        .iter()
        .position(|(_, state)| state == transfer_process.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>)
    }
    _ => html!(),
  }
}