mirror of
https://github.com/nitnelave/lldap.git
synced 2023-04-12 14:25:13 +00:00
167 lines
5.6 KiB
Rust
167 lines
5.6 KiB
Rust
use crate::api::HostService;
|
|
use anyhow::{anyhow, Result};
|
|
use lldap_model::*;
|
|
use wasm_bindgen::JsCast;
|
|
use yew::prelude::*;
|
|
use yew::services::{fetch::FetchTask, ConsoleService};
|
|
use yew::FocusEvent;
|
|
|
|
pub struct LoginForm {
|
|
link: ComponentLink<Self>,
|
|
on_logged_in: Callback<String>,
|
|
error: Option<anyhow::Error>,
|
|
node_ref: NodeRef,
|
|
login_start: Option<opaque::client::login::ClientLogin>,
|
|
// Used to keep the request alive long enough.
|
|
_task: Option<FetchTask>,
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Properties)]
|
|
pub struct Props {
|
|
pub on_logged_in: Callback<String>,
|
|
}
|
|
|
|
pub enum Msg {
|
|
Submit,
|
|
AuthenticationStartResponse(Result<Box<login::ServerLoginStartResponse>>),
|
|
AuthenticationFinishResponse(Result<String>),
|
|
}
|
|
|
|
fn get_form_field(field_id: &str) -> Option<String> {
|
|
let document = web_sys::window()?.document()?;
|
|
Some(
|
|
document
|
|
.get_element_by_id(field_id)?
|
|
.dyn_into::<web_sys::HtmlInputElement>()
|
|
.ok()?
|
|
.value(),
|
|
)
|
|
}
|
|
|
|
impl LoginForm {
|
|
fn set_error(&mut self, error: anyhow::Error) {
|
|
ConsoleService::error(&error.to_string());
|
|
self.error = Some(error);
|
|
}
|
|
|
|
fn call_backend<M, Req, C, Resp>(&mut self, method: M, req: Req, callback: C) -> Result<()>
|
|
where
|
|
M: Fn(Req, Callback<Resp>) -> Result<FetchTask>,
|
|
C: Fn(Resp) -> <Self as Component>::Message + 'static,
|
|
{
|
|
self._task = Some(method(req, self.link.callback(callback))?);
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_message(&mut self, msg: <Self as Component>::Message) -> Result<()> {
|
|
match msg {
|
|
Msg::Submit => {
|
|
let username = get_form_field("username")
|
|
.ok_or_else(|| anyhow!("Could not get username from form"))?;
|
|
let password = get_form_field("password")
|
|
.ok_or_else(|| anyhow!("Could not get password from form"))?;
|
|
let mut rng = rand::rngs::OsRng;
|
|
let login_start_request =
|
|
opaque::client::login::start_login(&password, &mut rng)
|
|
.map_err(|e| anyhow!("Could not initialize login: {}", e))?;
|
|
self.login_start = Some(login_start_request.state);
|
|
let req = login::ClientLoginStartRequest {
|
|
username,
|
|
login_start_request: login_start_request.message,
|
|
};
|
|
self.call_backend(
|
|
HostService::login_start,
|
|
req,
|
|
Msg::AuthenticationStartResponse,
|
|
)?;
|
|
Ok(())
|
|
}
|
|
Msg::AuthenticationStartResponse(Ok(res)) => {
|
|
debug_assert!(self.login_start.is_some());
|
|
let login_finish = match opaque::client::login::finish_login(
|
|
self.login_start.as_ref().unwrap().clone(),
|
|
res.credential_response,
|
|
) {
|
|
Err(e) => {
|
|
// Common error, we want to print a full error to the console but only a
|
|
// simple one to the user.
|
|
ConsoleService::error(&format!("Invalid username or password: {}", e));
|
|
self.error = Some(anyhow!("Invalid username or password"));
|
|
return Ok(());
|
|
}
|
|
Ok(l) => l,
|
|
};
|
|
let req = login::ClientLoginFinishRequest {
|
|
server_data: res.server_data,
|
|
credential_finalization: login_finish.message,
|
|
};
|
|
self.call_backend(
|
|
HostService::login_finish,
|
|
req,
|
|
Msg::AuthenticationFinishResponse,
|
|
)?;
|
|
Ok(())
|
|
}
|
|
Msg::AuthenticationStartResponse(Err(e)) => Err(anyhow!(
|
|
"Could not log in (invalid response to login start): {}",
|
|
e
|
|
)),
|
|
Msg::AuthenticationFinishResponse(Ok(user_id)) => {
|
|
self.on_logged_in.emit(user_id);
|
|
Ok(())
|
|
}
|
|
Msg::AuthenticationFinishResponse(Err(e)) => Err(anyhow!("Could not log in: {}", e)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Component for LoginForm {
|
|
type Message = Msg;
|
|
type Properties = Props;
|
|
|
|
fn create(props: Self::Properties, link: ComponentLink<Self>) -> Self {
|
|
LoginForm {
|
|
link,
|
|
on_logged_in: props.on_logged_in,
|
|
error: None,
|
|
node_ref: NodeRef::default(),
|
|
login_start: None,
|
|
_task: None,
|
|
}
|
|
}
|
|
|
|
fn update(&mut self, msg: Self::Message) -> ShouldRender {
|
|
self.error = None;
|
|
if let Err(e) = self.handle_message(msg) {
|
|
self.set_error(e);
|
|
}
|
|
true
|
|
}
|
|
|
|
fn change(&mut self, _: Self::Properties) -> ShouldRender {
|
|
false
|
|
}
|
|
|
|
fn view(&self) -> Html {
|
|
html! {
|
|
<form ref=self.node_ref.clone() onsubmit=self.link.callback(|e: FocusEvent| { e.prevent_default(); Msg::Submit })>
|
|
<div>
|
|
<label for="username">{"User name:"}</label>
|
|
<input type="text" id="username" />
|
|
</div>
|
|
<div>
|
|
<label for="password">{"Password:"}</label>
|
|
<input type="password" id="password" />
|
|
</div>
|
|
<button type="submit">{"Login"}</button>
|
|
<div>
|
|
{ if let Some(e) = &self.error {
|
|
html! { e.to_string() }
|
|
} else { html! {} }
|
|
}
|
|
</div>
|
|
</form>
|
|
}
|
|
}
|
|
}
|