Skip to main content

edc_web_components/pages/
transfer_process_page.rs

1use crate::components::ListTransferProcesses;
2use crate::contexts::use_edc_connector_context;
3use crate::models::TransferProcessItem;
4use edc_connector_client::types::query::SortOrder;
5use edc_connector_client::{EdcConnectorApiVersion, types::query::Query};
6use patternfly_yew::prelude::*;
7use yew::prelude::*;
8use yew::suspense::use_future_with;
9
10#[derive(Clone, Debug, PartialEq, Properties)]
11pub struct TransferProcessPageProps {
12  #[prop_or("Transfers".to_string())]
13  pub title: String,
14  #[prop_or(None)]
15  pub tag_line: Option<String>,
16  #[prop_or_default]
17  pub contract_agreement_id: Option<String>,
18  #[prop_or_default]
19  pub onshow: Callback<String>,
20  #[prop_or("No transfer process".to_string())]
21  pub empty_title: String,
22}
23
24#[component]
25pub fn TransferProcessPage(props: &TransferProcessPageProps) -> Html {
26  let tag_line = props
27    .tag_line
28    .as_ref()
29    .map(|tag_line| html!(<p>{ tag_line }</p>))
30    .unwrap_or_default();
31
32  let refresh = use_state(|| 0usize);
33  let offset = use_state(|| 0usize);
34  let limit = use_state(|| 10usize);
35
36  let onoffset = use_callback(
37    (refresh.clone(), offset.setter()),
38    |offset, (refresh, offset_setter)| {
39      offset_setter.set(offset);
40      refresh.set(**refresh + 1);
41    },
42  );
43
44  let onlimit = use_callback(
45    (refresh.clone(), limit.setter()),
46    |limit, (refresh, limit_setter)| {
47      limit_setter.set(limit);
48      refresh.set(**refresh + 1);
49    },
50  );
51
52  let fallback = html! {
53    <Bullseye>
54      <Spinner size={SpinnerSize::Lg} />
55    </Bullseye>
56  };
57
58  html!(
59    <Stack gutter=true>
60      <StackItem>
61        <Title level={Level::H3} size={Size::XXLarge}>{ &props.title }</Title>
62        { tag_line }
63      </StackItem>
64      <StackItem>
65        <Suspense {fallback}>
66          <TransferProcessPageInner
67            offset={*offset}
68            limit={*limit}
69            {onoffset}
70            {onlimit}
71            contract_agreement_id={props.contract_agreement_id.clone()}
72            force_refresh={*refresh}
73            onshow={props.onshow.clone()}
74            empty_title={props.empty_title.clone()}
75          />
76        </Suspense>
77      </StackItem>
78    </Stack>
79  )
80}
81
82#[derive(Clone, Debug, PartialEq, Properties)]
83pub struct TransferProcessPageInnerProps {
84  pub offset: usize,
85  pub limit: usize,
86  pub onoffset: Callback<usize>,
87  pub onlimit: Callback<usize>,
88  pub contract_agreement_id: Option<String>,
89  pub force_refresh: usize,
90  pub onshow: Callback<String>,
91  #[prop_or("No transfer process".to_string())]
92  pub empty_title: String,
93}
94
95#[component]
96pub fn TransferProcessPageInner(props: &TransferProcessPageInnerProps) -> HtmlResult {
97  let edc_connector_context = use_edc_connector_context();
98
99  let transfer_processe_items = use_future_with(
100    (
101      edc_connector_context,
102      props.limit,
103      props.offset,
104      props.contract_agreement_id.clone(),
105      props.force_refresh,
106    ),
107    |parameters| async move {
108      let (edc_connector_context, limit, offset, contract_agreement_id, _) = (*parameters).clone();
109
110      let query_builder = Query::builder().limit(limit as u32).offset(offset as u32);
111
112      let query_builder = if let Some(contract_agreement_id) = contract_agreement_id {
113        query_builder.filter("contractId", "=", contract_agreement_id)
114      } else {
115        query_builder
116      };
117
118      let query = query_builder
119        .sort("stateTimestamp", SortOrder::Desc)
120        .build();
121
122      if let Some(client) = edc_connector_context.get_client() {
123        client
124          .transfer_processes(EdcConnectorApiVersion::V4)
125          .query(query)
126          .await
127          .unwrap_or_default()
128          .into_iter()
129          .map(TransferProcessItem::from)
130          .collect::<Vec<_>>()
131      } else {
132        vec![]
133      }
134    },
135  )?;
136
137  let transfer_processe_items = (*transfer_processe_items).clone();
138
139  if transfer_processe_items.is_empty() {
140    Ok(html! { <EmptyState title={props.empty_title.to_string()} /> })
141  } else {
142    Ok(html!(
143      <ListTransferProcesses
144        transfer_processe_items={transfer_processe_items}
145        offset={props.offset}
146        limit={props.limit}
147        onoffset={props.onoffset.clone()}
148        onlimit={props.onlimit.clone()}
149        onshow={props.onshow.clone()}
150      />
151    ))
152  }
153}