lldap/app/src/components/user_details.rs

265 lines
9.3 KiB
Rust
Raw Normal View History

use crate::{
components::router::{AppRoute, NavButton},
infra::api::HostService,
};
use anyhow::{anyhow, Result};
use graphql_client::GraphQLQuery;
use yew::{
prelude::*,
services::{fetch::FetchTask, ConsoleService},
};
#[derive(GraphQLQuery)]
#[graphql(
schema_path = "../schema.graphql",
query_path = "queries/get_user_details.graphql",
response_derives = "Debug",
custom_scalars_module = "crate::infra::graphql"
)]
pub struct GetUserDetails;
type User = get_user_details::GetUserDetailsUser;
#[derive(GraphQLQuery)]
#[graphql(
schema_path = "../schema.graphql",
query_path = "queries/update_user.graphql",
response_derives = "Debug",
variables_derives = "Clone",
custom_scalars_module = "crate::infra::graphql"
)]
pub struct UpdateUser;
pub struct UserDetails {
link: ComponentLink<Self>,
username: String,
user: Option<User>,
// Needed for the form.
node_ref: NodeRef,
// Error message displayed to the user.
error: Option<anyhow::Error>,
// The request, while we're waiting for the server to reply.
update_request: Option<update_user::UpdateUserInput>,
// True iff we just finished updating the user, to display a successful message.
update_successful: bool,
// Used to keep the request alive long enough.
_task: Option<FetchTask>,
}
pub enum Msg {
UserDetailsResponse(Result<get_user_details::ResponseData>),
SubmitForm,
UpdateFinished(Result<update_user::ResponseData>),
}
#[derive(yew::Properties, Clone, PartialEq)]
pub struct Props {
pub username: String,
}
#[allow(clippy::ptr_arg)]
fn not_empty(s: &String) -> bool {
!s.is_empty()
}
impl UserDetails {
fn get_user_details(&mut self) {
self._task = HostService::graphql_query::<GetUserDetails>(
get_user_details::Variables {
2021-08-30 07:49:13 +00:00
id: self.username.clone(),
},
self.link.callback(Msg::UserDetailsResponse),
"Error trying to fetch user details",
)
.map_err(|e| {
ConsoleService::log(&e.to_string());
e
})
.ok();
}
fn handle_msg(&mut self, msg: <Self as Component>::Message) -> Result<bool> {
self.update_successful = false;
match msg {
Msg::UserDetailsResponse(Ok(user)) => {
self.user = Some(user.user);
}
Msg::UserDetailsResponse(Err(e)) => {
self.error = Some(anyhow!("Error getting user details: {}", e));
self.user = None;
}
Msg::SubmitForm => {
let base_user = self.user.as_ref().unwrap();
let mut user_input = update_user::UpdateUserInput {
id: self.username.clone(),
email: None,
displayName: None,
firstName: None,
lastName: None,
};
let mut should_send_form = false;
let email = get_element("email")
.filter(not_empty)
.ok_or_else(|| anyhow!("Missing email"))?;
if base_user.email != email {
should_send_form = true;
user_input.email = Some(email);
}
if base_user.display_name != get_element_or_empty("display_name") {
should_send_form = true;
user_input.displayName = Some(get_element_or_empty("display_name"));
}
if base_user.first_name != get_element_or_empty("first_name") {
should_send_form = true;
user_input.firstName = Some(get_element_or_empty("first_name"));
}
if base_user.last_name != get_element_or_empty("last_name") {
should_send_form = true;
user_input.lastName = Some(get_element_or_empty("last_name"));
}
if !should_send_form {
return Ok(false);
}
self.update_request = Some(user_input.clone());
let req = update_user::Variables { user: user_input };
self._task = Some(HostService::graphql_query::<UpdateUser>(
req,
self.link.callback(Msg::UpdateFinished),
"Error trying to update user",
)?);
return Ok(false);
}
Msg::UpdateFinished(r) => {
match r {
Err(e) => return Err(e),
Ok(_) => {
ConsoleService::log("Successfully updated user");
self.update_successful = true;
let user = self.user.as_ref().unwrap();
let new_user = self.update_request.take().unwrap();
self.user = Some(User {
id: user.id.clone(),
email: new_user.email.unwrap_or_else(|| user.email.clone()),
display_name: new_user
.displayName
.unwrap_or_else(|| user.display_name.clone()),
first_name: new_user
.firstName
.unwrap_or_else(|| user.first_name.clone()),
last_name: new_user.lastName.unwrap_or_else(|| user.last_name.clone()),
creation_date: user.creation_date,
});
}
};
}
}
Ok(true)
}
}
fn get_element(name: &str) -> Option<String> {
use wasm_bindgen::JsCast;
Some(
web_sys::window()?
.document()?
.get_element_by_id(name)?
.dyn_into::<web_sys::HtmlInputElement>()
.ok()?
.value(),
)
}
fn get_element_or_empty(name: &str) -> String {
get_element(name).unwrap_or_default()
}
impl Component for UserDetails {
type Message = Msg;
// The username.
type Properties = Props;
fn create(props: Self::Properties, link: ComponentLink<Self>) -> Self {
let mut table = UserDetails {
link,
username: props.username,
node_ref: NodeRef::default(),
_task: None,
user: None,
error: None,
update_request: None,
update_successful: false,
};
table.get_user_details();
table
}
fn update(&mut self, msg: Self::Message) -> ShouldRender {
self.error = None;
match self.handle_msg(msg) {
Err(e) => {
ConsoleService::error(&e.to_string());
self.error = Some(e);
true
}
Ok(b) => b,
}
}
fn change(&mut self, _: Self::Properties) -> ShouldRender {
false
}
fn view(&self) -> Html {
match (&self.user, &self.error) {
(None, None) => html! {{"Loading..."}},
(None, Some(e)) => html! {<div>{"Error: "}{e.to_string()}</div>},
(Some(u), error) => {
html! {
<form ref=self.node_ref.clone() onsubmit=self.link.callback(|e: FocusEvent| { e.prevent_default(); Msg::SubmitForm })>
<div>
<span>{"User ID: "}</span>
<span>{&u.id}</span>
</div>
<div>
<label for="email">{"Email: "}</label>
<input type="text" id="email" value={u.email.clone()} />
</div>
<div>
<label for="display_name">{"Display name: "}</label>
<input type="text" id="display_name" value={u.display_name.clone()} />
</div>
<div>
<label for="first_name">{"First name: "}</label>
<input type="text" id="first_name" value={u.first_name.clone()} />
</div>
<div>
<label for="last_name">{"Last name: "}</label>
<input type="text" id="last_name" value={u.last_name.clone()} />
</div>
<div>
<span>{"Creation date: "}</span>
<span>{&u.creation_date.with_timezone(&chrono::Local)}</span>
</div>
<div>
<button type="submit">{"Update"}</button>
</div>
{ if self.update_successful {
html! {
<span>{"Update successful!"}</span>
}
} else if let Some(e) = error {
html! {
<div>
<span>{"Error: "}{e.to_string()}</span>
</div>
}
} else { html! {} }}
<div>
<NavButton route=AppRoute::ChangePassword(self.username.clone())>{"Change password"}</NavButton>
</div>
</form>
}
}
}
}
}