863 lines
38 KiB
Rust
863 lines
38 KiB
Rust
use crate::data::communication::{CommunicationType, CommunicationValue, DataTypes};
|
|
use crate::sql::connection_status::ConnectionType;
|
|
use crate::sql::sql::{self, get_by_user_id, get_by_username, get_iota_by_id, get_omikron_by_id};
|
|
use crate::sql::user_online_tracker::{self};
|
|
use crate::util::crypto_helper::encrypt;
|
|
use crate::util::logger::PrintType;
|
|
use crate::{get_private_key, log_out};
|
|
use crate::{get_public_key, log_in};
|
|
use base64::{Engine as _, engine::general_purpose::STANDARD};
|
|
use dashmap::DashMap;
|
|
use futures::SinkExt;
|
|
use futures::stream::SplitSink;
|
|
use futures::stream::SplitStream;
|
|
use hyper::upgrade::Upgraded;
|
|
use hyper_util::rt::TokioIo;
|
|
use json::JsonValue;
|
|
use json::number::Number;
|
|
use rand::Rng;
|
|
use rand::distributions::Alphanumeric;
|
|
use std::sync::Arc;
|
|
use tokio::sync::RwLock;
|
|
use tokio_tungstenite::WebSocketStream;
|
|
use tungstenite::Message;
|
|
use tungstenite::Utf8Bytes;
|
|
use uuid::Uuid;
|
|
use x448::PublicKey;
|
|
|
|
pub struct OmikronConnection {
|
|
pub sender: Arc<RwLock<SplitSink<WebSocketStream<TokioIo<Upgraded>>, Message>>>,
|
|
pub receiver: Arc<RwLock<SplitStream<WebSocketStream<TokioIo<Upgraded>>>>>,
|
|
pub omikron_id: Arc<RwLock<i64>>,
|
|
pub pub_key: Arc<RwLock<Option<Vec<u8>>>>,
|
|
identified: Arc<RwLock<bool>>,
|
|
challenged: Arc<RwLock<bool>>,
|
|
challenge: Arc<RwLock<String>>,
|
|
pub ping: Arc<RwLock<i64>>,
|
|
waiting_tasks: DashMap<
|
|
Uuid,
|
|
Box<dyn Fn(Arc<OmikronConnection>, CommunicationValue) -> bool + Send + Sync>,
|
|
>,
|
|
}
|
|
|
|
impl OmikronConnection {
|
|
pub fn new(
|
|
sender: SplitSink<WebSocketStream<TokioIo<Upgraded>>, Message>,
|
|
receiver: SplitStream<WebSocketStream<TokioIo<Upgraded>>>,
|
|
) -> Arc<Self> {
|
|
Arc::new(Self {
|
|
sender: Arc::new(RwLock::new(sender)),
|
|
receiver: Arc::new(RwLock::new(receiver)),
|
|
omikron_id: Arc::new(RwLock::new(0)),
|
|
pub_key: Arc::new(RwLock::new(None)),
|
|
identified: Arc::new(RwLock::new(false)),
|
|
challenged: Arc::new(RwLock::new(false)),
|
|
challenge: Arc::new(RwLock::new(String::new())),
|
|
ping: Arc::new(RwLock::new(-1)),
|
|
waiting_tasks: DashMap::new(),
|
|
})
|
|
}
|
|
pub async fn send_message(&self, cv: &CommunicationValue) {
|
|
let mut sender = self.sender.write().await;
|
|
let message_text = Message::Text(Utf8Bytes::from(cv.to_json().to_string()));
|
|
if !cv.is_type(CommunicationType::pong) {
|
|
log_out!(
|
|
*self.omikron_id.read().await,
|
|
PrintType::Omikron,
|
|
"{}",
|
|
message_text
|
|
);
|
|
}
|
|
sender.send(message_text).await.unwrap();
|
|
}
|
|
pub async fn get_omikron_id(&self) -> i64 {
|
|
*self.omikron_id.read().await
|
|
}
|
|
pub async fn is_identified(&self) -> bool {
|
|
*self.identified.read().await && *self.challenged.read().await
|
|
}
|
|
pub async fn get_public_key(&self) -> PublicKey {
|
|
PublicKey::from_bytes(self.pub_key.read().await.as_ref().unwrap()).unwrap()
|
|
}
|
|
|
|
pub async fn handle_message(self: Arc<Self>, message: String) {
|
|
let cv = CommunicationValue::from_json(&message);
|
|
if cv.is_type(CommunicationType::ping) {
|
|
self.handle_ping(cv).await;
|
|
return;
|
|
}
|
|
|
|
log_in!(
|
|
*self.omikron_id.read().await,
|
|
PrintType::Omikron,
|
|
"{}",
|
|
message
|
|
);
|
|
|
|
if let Some((_, task)) = self.waiting_tasks.remove(&cv.get_id()) {
|
|
let _ = task(self.clone(), cv.clone());
|
|
return;
|
|
}
|
|
|
|
// If not yet identified
|
|
if !self.is_identified().await {
|
|
// handle identification
|
|
if !*self.identified.read().await && cv.is_type(CommunicationType::identification) {
|
|
let omikron_id = cv
|
|
.get_data(DataTypes::omikron)
|
|
.unwrap_or(&JsonValue::Null)
|
|
.as_i64()
|
|
.unwrap_or(0);
|
|
match get_omikron_by_id(omikron_id).await {
|
|
Ok((public_key, _)) => {
|
|
// Generate Challenge, encrypt it and send it to the omikron
|
|
*self.omikron_id.write().await = omikron_id;
|
|
|
|
let challenge_str: String = rand::thread_rng()
|
|
.sample_iter(&Alphanumeric)
|
|
.take(32)
|
|
.map(char::from)
|
|
.collect();
|
|
|
|
*self.challenge.write().await = challenge_str.clone();
|
|
|
|
let user_public_key_bytes = match STANDARD.decode(&public_key) {
|
|
Ok(bytes) => bytes,
|
|
Err(_) => {
|
|
self.send_error_response(
|
|
&cv.get_id(),
|
|
CommunicationType::error_invalid_omikron_id,
|
|
)
|
|
.await;
|
|
return;
|
|
}
|
|
};
|
|
*self.pub_key.write().await = Some(user_public_key_bytes.clone());
|
|
|
|
let omikron_pub_key: PublicKey =
|
|
match PublicKey::from_bytes(&user_public_key_bytes) {
|
|
Some(key) => key,
|
|
_ => {
|
|
self.send_error_response(
|
|
&cv.get_id(),
|
|
CommunicationType::error_invalid_public_key,
|
|
)
|
|
.await;
|
|
return;
|
|
}
|
|
};
|
|
|
|
let encrypted_challenge =
|
|
encrypt(get_private_key(), omikron_pub_key, &challenge_str)
|
|
.unwrap_or("".to_string());
|
|
|
|
let response = CommunicationValue::new(CommunicationType::challenge)
|
|
.add_data_str(
|
|
DataTypes::public_key,
|
|
STANDARD.encode(get_public_key().as_bytes()),
|
|
)
|
|
.add_data_str(DataTypes::challenge, encrypted_challenge)
|
|
.with_id(cv.get_id());
|
|
|
|
self.send_message(&response).await;
|
|
*self.identified.write().await = true;
|
|
return;
|
|
}
|
|
Err(e) => {
|
|
self.send_message(
|
|
&CommunicationValue::new(CommunicationType::error_not_authenticated)
|
|
.with_id(cv.get_id())
|
|
.add_data_str(DataTypes::error_type, e.to_string()),
|
|
)
|
|
.await;
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle challenge response
|
|
if *self.identified.read().await
|
|
&& !*self.challenged.read().await
|
|
&& cv.is_type(CommunicationType::challenge_response)
|
|
{
|
|
let client_response = cv
|
|
.get_data(DataTypes::challenge)
|
|
.unwrap_or(&JsonValue::Null)
|
|
.as_str()
|
|
.unwrap_or("");
|
|
let expected_challenge = self.challenge.read().await.clone();
|
|
|
|
if client_response == expected_challenge {
|
|
*self.challenged.write().await = true;
|
|
|
|
let response =
|
|
CommunicationValue::new(CommunicationType::identification_response)
|
|
.with_id(cv.get_id());
|
|
let _ = sql::set_omikron_active(self.get_omikron_id().await, true);
|
|
self.send_message(&response).await;
|
|
} else {
|
|
self.send_error_response(
|
|
&cv.get_id(),
|
|
CommunicationType::error_invalid_challenge,
|
|
)
|
|
.await;
|
|
self.close().await;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// if not identified && not identifying
|
|
self.send_error_response(&cv.get_id(), CommunicationType::error_not_authenticated)
|
|
.await;
|
|
self.close().await;
|
|
return;
|
|
}
|
|
|
|
let omikron_id = self.get_omikron_id().await;
|
|
if cv.is_type(CommunicationType::user_connected) {
|
|
if let Some(user_id) = cv.get_data(DataTypes::user_id).and_then(|v| v.as_i64()) {
|
|
user_online_tracker::track_user_status(user_id, ConnectionType::Online, omikron_id)
|
|
.await;
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::user_disconnected) {
|
|
if let Some(user_id) = cv.get_data(DataTypes::user_id).and_then(|v| v.as_i64()) {
|
|
if let Some(status) = user_online_tracker::get_user_status(user_id).await {
|
|
user_online_tracker::track_user_status(
|
|
user_id,
|
|
ConnectionType::UserOffline,
|
|
status.omikron_id,
|
|
)
|
|
.await;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::iota_connected) {
|
|
if let Some(iota_id) = cv.get_data(DataTypes::iota_id).and_then(|v| v.as_i64()) {
|
|
user_online_tracker::track_iota_connection(iota_id, omikron_id).await;
|
|
if let Ok(users) = sql::get_users_by_iota_id(iota_id).await {
|
|
for user in users {
|
|
user_online_tracker::track_user_status(
|
|
user.0,
|
|
ConnectionType::UserOffline,
|
|
omikron_id,
|
|
)
|
|
.await;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::iota_disconnected) {
|
|
if let Some(iota_id) = cv.get_data(DataTypes::iota_id).and_then(|v| v.as_i64()) {
|
|
let iota_offline =
|
|
user_online_tracker::untrack_iota_connection(iota_id, omikron_id).await;
|
|
if iota_offline {
|
|
if let Ok(users) = sql::get_users_by_iota_id(iota_id).await {
|
|
let user_ids: Vec<i64> = users.iter().map(|u| u.0).collect();
|
|
user_online_tracker::untrack_many_users(&user_ids).await;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::sync_client_iota_status) {
|
|
if let Some(json::JsonValue::Array(user_ids)) =
|
|
cv.get_data(DataTypes::user_ids).cloned()
|
|
{
|
|
for user_id_json in user_ids {
|
|
if let Some(user_id) = user_id_json.as_i64() {
|
|
user_online_tracker::track_user_status(
|
|
user_id,
|
|
ConnectionType::Online,
|
|
omikron_id,
|
|
)
|
|
.await;
|
|
}
|
|
}
|
|
}
|
|
if let Some(json::JsonValue::Array(iota_ids)) =
|
|
cv.get_data(DataTypes::iota_ids).cloned()
|
|
{
|
|
for iota_id_json in iota_ids {
|
|
if let Some(iota_id) = iota_id_json.as_i64() {
|
|
user_online_tracker::track_iota_connection(iota_id, omikron_id).await;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::get_user_data) {
|
|
if let Some(user_id) = cv.get_data(DataTypes::user_id).cloned() {
|
|
if let Some(user_id) = user_id.as_i64() {
|
|
if let Ok((
|
|
id,
|
|
iota_id,
|
|
username,
|
|
display,
|
|
status,
|
|
about,
|
|
avatar,
|
|
sub_level,
|
|
sub_end,
|
|
public_key,
|
|
_,
|
|
_,
|
|
)) = get_by_user_id(user_id).await
|
|
{
|
|
let mut response =
|
|
CommunicationValue::new(CommunicationType::get_user_data)
|
|
.add_data_str(DataTypes::username, username)
|
|
.add_data_str(DataTypes::public_key, public_key)
|
|
.add_data(DataTypes::user_id, JsonValue::Number(Number::from(id)))
|
|
.add_data(
|
|
DataTypes::iota_id,
|
|
JsonValue::Number(Number::from(iota_id)),
|
|
)
|
|
.add_data_str(DataTypes::display, display)
|
|
.add_data_str(DataTypes::status, status)
|
|
.add_data_str(DataTypes::about, about)
|
|
.add_data_str(DataTypes::avatar, avatar)
|
|
.add_data(
|
|
DataTypes::sub_level,
|
|
JsonValue::Number(Number::from(sub_level)),
|
|
)
|
|
.add_data(
|
|
DataTypes::sub_end,
|
|
JsonValue::Number(Number::from(sub_end)),
|
|
);
|
|
|
|
let user_status = user_online_tracker::get_user_status(id).await;
|
|
let iota_connections =
|
|
user_online_tracker::get_iota_omikron_connections(iota_id)
|
|
.await
|
|
.unwrap_or_default();
|
|
response = response.add_data(
|
|
DataTypes::omikron_connections,
|
|
JsonValue::Array(
|
|
iota_connections
|
|
.into_iter()
|
|
.map(|id| JsonValue::Number(Number::from(id)))
|
|
.collect(),
|
|
),
|
|
);
|
|
|
|
if let Some(user_status) = user_status {
|
|
response = response.add_data(
|
|
DataTypes::online_status,
|
|
JsonValue::String(user_status.connection_type.to_string()),
|
|
);
|
|
response = response.add_data(
|
|
DataTypes::omikron_id,
|
|
JsonValue::Number(Number::from(user_status.omikron_id)),
|
|
);
|
|
} else {
|
|
response = response.add_data(
|
|
DataTypes::online_status,
|
|
JsonValue::String(ConnectionType::IotaOffline.to_string()),
|
|
);
|
|
}
|
|
|
|
self.send_message(&response).await;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if let Some(username) = cv.get_data(DataTypes::username).cloned() {
|
|
if let Some(username) = username.as_str() {
|
|
if let Ok((
|
|
id,
|
|
iota_id,
|
|
username,
|
|
display,
|
|
status,
|
|
about,
|
|
avatar,
|
|
sub_level,
|
|
sub_end,
|
|
public_key,
|
|
_,
|
|
_,
|
|
)) = get_by_username(username).await
|
|
{
|
|
let mut response =
|
|
CommunicationValue::new(CommunicationType::get_user_data)
|
|
.add_data_str(DataTypes::username, username)
|
|
.add_data_str(DataTypes::public_key, public_key)
|
|
.add_data(DataTypes::user_id, JsonValue::Number(Number::from(id)))
|
|
.add_data(
|
|
DataTypes::iota_id,
|
|
JsonValue::Number(Number::from(iota_id)),
|
|
)
|
|
.add_data_str(DataTypes::display, display)
|
|
.add_data_str(DataTypes::status, status)
|
|
.add_data_str(DataTypes::about, about)
|
|
.add_data_str(DataTypes::avatar, avatar)
|
|
.add_data(
|
|
DataTypes::sub_level,
|
|
JsonValue::Number(Number::from(sub_level)),
|
|
)
|
|
.add_data(
|
|
DataTypes::sub_end,
|
|
JsonValue::Number(Number::from(sub_end)),
|
|
);
|
|
|
|
let user_status = user_online_tracker::get_user_status(id).await;
|
|
let iota_connections =
|
|
user_online_tracker::get_iota_omikron_connections(iota_id)
|
|
.await
|
|
.unwrap_or_default();
|
|
|
|
if let Some(user_status) = user_status {
|
|
response = response.add_data(
|
|
DataTypes::online_status,
|
|
JsonValue::String(user_status.connection_type.to_string()),
|
|
);
|
|
response = response.add_data(
|
|
DataTypes::omikron_id,
|
|
JsonValue::Number(Number::from(user_status.omikron_id)),
|
|
);
|
|
} else {
|
|
response = response.add_data(
|
|
DataTypes::online_status,
|
|
JsonValue::String(ConnectionType::IotaOffline.to_string()),
|
|
);
|
|
}
|
|
response = response.add_data(
|
|
DataTypes::omikron_connections,
|
|
JsonValue::Array(
|
|
iota_connections
|
|
.iter()
|
|
.map(|&id| JsonValue::Number(Number::from(id)))
|
|
.collect(),
|
|
),
|
|
);
|
|
|
|
self.send_message(&response).await;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
let response =
|
|
CommunicationValue::new(CommunicationType::error_not_found).with_id(cv.get_id());
|
|
self.send_message(&response).await;
|
|
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::get_iota_data) {
|
|
if let Some(iota_id) = cv.get_data(DataTypes::iota_id).cloned() {
|
|
if let Some(iota_id) = iota_id.as_i64() {
|
|
if let Ok((iota_id, public_key)) = get_iota_by_id(iota_id).await {
|
|
let mut response =
|
|
CommunicationValue::new(CommunicationType::get_iota_data)
|
|
.add_data_str(DataTypes::public_key, public_key)
|
|
.add_data(
|
|
DataTypes::iota_id,
|
|
JsonValue::Number(Number::from(iota_id)),
|
|
);
|
|
|
|
let iota_connections =
|
|
user_online_tracker::get_iota_omikron_connections(iota_id)
|
|
.await
|
|
.unwrap_or_default();
|
|
|
|
response = response.add_data(
|
|
DataTypes::omikron_connections,
|
|
JsonValue::Array(
|
|
iota_connections
|
|
.iter()
|
|
.map(|&id| JsonValue::Number(Number::from(id)))
|
|
.collect(),
|
|
),
|
|
);
|
|
self.send_message(&response).await;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if let Some(user_id) = cv.get_data(DataTypes::user_id).cloned() {
|
|
if let Some(user_id) = user_id.as_i64() {
|
|
if let Ok((_, iota_id, _, _, _, _, _, _, _, _, _, _)) =
|
|
get_by_user_id(user_id).await
|
|
{
|
|
if let Ok((iota_id, public_key)) = get_iota_by_id(iota_id).await {
|
|
let mut response =
|
|
CommunicationValue::new(CommunicationType::get_iota_data)
|
|
.add_data_str(DataTypes::public_key, public_key)
|
|
.add_data(
|
|
DataTypes::user_id,
|
|
JsonValue::Number(Number::from(user_id)),
|
|
)
|
|
.add_data(
|
|
DataTypes::iota_id,
|
|
JsonValue::Number(Number::from(iota_id)),
|
|
);
|
|
|
|
let iota_connections =
|
|
user_online_tracker::get_iota_omikron_connections(iota_id)
|
|
.await
|
|
.unwrap_or_default();
|
|
|
|
response = response.add_data(
|
|
DataTypes::omikron_connections,
|
|
JsonValue::Array(
|
|
iota_connections
|
|
.iter()
|
|
.map(|&id| JsonValue::Number(Number::from(id)))
|
|
.collect(),
|
|
),
|
|
);
|
|
|
|
self.send_message(&response).await;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if let Some(username) = cv.get_data(DataTypes::username).cloned() {
|
|
if let Some(username) = username.as_str() {
|
|
if let Ok((user_id, iota_id, _, _, _, _, _, _, _, _, _, _)) =
|
|
get_by_username(username).await
|
|
{
|
|
if let Ok((iota_id, public_key)) = get_iota_by_id(iota_id).await {
|
|
let mut response =
|
|
CommunicationValue::new(CommunicationType::get_iota_data)
|
|
.add_data_str(DataTypes::public_key, public_key)
|
|
.add_data(
|
|
DataTypes::user_id,
|
|
JsonValue::Number(Number::from(user_id)),
|
|
)
|
|
.add_data_str(DataTypes::username, username.to_string())
|
|
.add_data(
|
|
DataTypes::iota_id,
|
|
JsonValue::Number(Number::from(iota_id)),
|
|
);
|
|
|
|
let iota_connections =
|
|
user_online_tracker::get_iota_omikron_connections(iota_id)
|
|
.await
|
|
.unwrap_or_default();
|
|
|
|
response = response.add_data(
|
|
DataTypes::omikron_connections,
|
|
JsonValue::Array(
|
|
iota_connections
|
|
.iter()
|
|
.map(|&id| JsonValue::Number(Number::from(id)))
|
|
.collect(),
|
|
),
|
|
);
|
|
self.send_message(&response).await;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let response =
|
|
CommunicationValue::new(CommunicationType::error_not_found).with_id(cv.get_id());
|
|
self.send_message(&response).await;
|
|
|
|
return;
|
|
}
|
|
|
|
if cv.is_type(CommunicationType::get_register) {
|
|
let register_id = sql::get_register_id().await;
|
|
let response = CommunicationValue::new(CommunicationType::get_register)
|
|
.with_id(cv.get_id())
|
|
.add_data(
|
|
DataTypes::user_id,
|
|
JsonValue::Number(Number::from(register_id)),
|
|
);
|
|
self.send_message(&response).await;
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::complete_register_iota) {
|
|
if let (Some(iota_id), Some(public_key)) = (
|
|
cv.get_data(DataTypes::iota_id).and_then(|v| v.as_i64()),
|
|
cv.get_data(DataTypes::public_key).and_then(|v| v.as_str()),
|
|
) {
|
|
match sql::register_complete_iota(iota_id, public_key.to_string()).await {
|
|
Ok(_) => {
|
|
let response = CommunicationValue::new(CommunicationType::success)
|
|
.with_id(cv.get_id());
|
|
self.send_message(&response).await;
|
|
}
|
|
Err(e) => {
|
|
self.send_message(
|
|
&CommunicationValue::new(CommunicationType::error)
|
|
.with_id(cv.get_id())
|
|
.add_data_str(DataTypes::error_type, e.to_string()),
|
|
)
|
|
.await;
|
|
}
|
|
}
|
|
} else {
|
|
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_data)
|
|
.await;
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::complete_register_user) {
|
|
if let (
|
|
Some(user_id),
|
|
Some(username),
|
|
Some(public_key),
|
|
Some(iota_id),
|
|
Some(reset_token),
|
|
) = (
|
|
cv.get_data(DataTypes::user_id).and_then(|v| v.as_i64()),
|
|
cv.get_data(DataTypes::username).and_then(|v| v.as_str()),
|
|
cv.get_data(DataTypes::public_key).and_then(|v| v.as_str()),
|
|
cv.get_data(DataTypes::iota_id).and_then(|v| v.as_i64()),
|
|
cv.get_data(DataTypes::reset_token).and_then(|v| v.as_str()), // Assuming reset_token is sent as token
|
|
) {
|
|
// The documentation does not specify a private_key_hash, using an empty string.
|
|
match sql::register_complete_user(
|
|
user_id,
|
|
username.to_string(),
|
|
public_key.to_string(),
|
|
"".to_string(), // private_key_hash
|
|
iota_id,
|
|
reset_token.to_string(),
|
|
)
|
|
.await
|
|
{
|
|
Ok(_) => {
|
|
let response = CommunicationValue::new(CommunicationType::success)
|
|
.with_id(cv.get_id());
|
|
self.send_message(&response).await;
|
|
}
|
|
Err(e) => {
|
|
self.send_message(
|
|
&CommunicationValue::new(CommunicationType::error)
|
|
.with_id(cv.get_id())
|
|
.add_data_str(DataTypes::error_type, e.to_string()),
|
|
)
|
|
.await;
|
|
}
|
|
}
|
|
} else {
|
|
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_data)
|
|
.await;
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::change_user_data) {
|
|
if let Some(user_id) = cv.get_data(DataTypes::user_id).and_then(|v| v.as_i64()) {
|
|
let mut success = true;
|
|
let mut error_message = String::new();
|
|
|
|
if let Some(username) = cv.get_data(DataTypes::username).and_then(|v| v.as_str()) {
|
|
if let Err(e) = sql::change_username(user_id, username.to_string()).await {
|
|
success = false;
|
|
error_message = e.to_string();
|
|
}
|
|
}
|
|
if let Some(display) = cv.get_data(DataTypes::display).and_then(|v| v.as_str()) {
|
|
if let Err(e) = sql::change_display_name(user_id, display.to_string()).await {
|
|
success = false;
|
|
error_message = e.to_string();
|
|
}
|
|
}
|
|
if let Some(avatar) = cv.get_data(DataTypes::avatar).and_then(|v| v.as_str()) {
|
|
if let Err(e) = sql::change_avatar(user_id, avatar.to_string()).await {
|
|
success = false;
|
|
error_message = e.to_string();
|
|
}
|
|
}
|
|
if let Some(about) = cv.get_data(DataTypes::about).and_then(|v| v.as_str()) {
|
|
if let Err(e) = sql::change_about(user_id, about.to_string()).await {
|
|
success = false;
|
|
error_message = e.to_string();
|
|
}
|
|
}
|
|
if let Some(status) = cv.get_data(DataTypes::status).and_then(|v| v.as_str()) {
|
|
if let Err(e) = sql::change_status(user_id, status.to_string()).await {
|
|
success = false;
|
|
error_message = e.to_string();
|
|
}
|
|
}
|
|
if let Some(public_key) =
|
|
cv.get_data(DataTypes::public_key).and_then(|v| v.as_str())
|
|
{
|
|
if let Some(private_key_hash) = cv
|
|
.get_data(DataTypes::private_key_hash)
|
|
.and_then(|v| v.as_str())
|
|
{
|
|
if let Err(e) = sql::change_keys(
|
|
user_id,
|
|
public_key.to_string(),
|
|
private_key_hash.to_string(),
|
|
)
|
|
.await
|
|
{
|
|
success = false;
|
|
error_message = e.to_string();
|
|
}
|
|
} else {
|
|
success = false;
|
|
error_message =
|
|
"private_key_hash is required when changing public_key".to_string();
|
|
}
|
|
}
|
|
|
|
if success {
|
|
let response =
|
|
CommunicationValue::new(CommunicationType::success).with_id(cv.get_id());
|
|
self.send_message(&response).await;
|
|
} else {
|
|
self.send_message(
|
|
&CommunicationValue::new(CommunicationType::error)
|
|
.with_id(cv.get_id())
|
|
.add_data_str(DataTypes::error_type, error_message),
|
|
)
|
|
.await;
|
|
}
|
|
} else {
|
|
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_data)
|
|
.await;
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::change_iota_data) {
|
|
if let (Some(user_id), Some(iota_id), Some(reset_token), Some(new_token)) = (
|
|
cv.get_data(DataTypes::user_id).and_then(|v| v.as_i64()),
|
|
cv.get_data(DataTypes::iota_id).and_then(|v| v.as_i64()),
|
|
cv.get_data(DataTypes::reset_token).and_then(|v| v.as_str()),
|
|
cv.get_data(DataTypes::new_token).and_then(|v| v.as_str()),
|
|
) {
|
|
match sql::get_by_user_id(user_id).await {
|
|
Ok(user) => {
|
|
let current_token = user.11; // token is the 12th element (index 11)
|
|
if current_token == reset_token {
|
|
let mut success = true;
|
|
let mut error_message = String::new();
|
|
if let Err(e) = sql::change_iota_id(user_id, iota_id).await {
|
|
success = false;
|
|
error_message = e.to_string();
|
|
}
|
|
if success {
|
|
if let Err(e) =
|
|
sql::change_token(user_id, new_token.to_string()).await
|
|
{
|
|
success = false;
|
|
error_message = e.to_string();
|
|
}
|
|
}
|
|
|
|
if success {
|
|
let response = CommunicationValue::new(CommunicationType::success)
|
|
.with_id(cv.get_id());
|
|
self.send_message(&response).await;
|
|
} else {
|
|
self.send_message(
|
|
&CommunicationValue::new(CommunicationType::error)
|
|
.with_id(cv.get_id())
|
|
.add_data_str(DataTypes::error_type, error_message),
|
|
)
|
|
.await;
|
|
}
|
|
} else {
|
|
self.send_error_response(
|
|
&cv.get_id(),
|
|
// Using this for invalid token
|
|
CommunicationType::error_invalid_challenge,
|
|
)
|
|
.await;
|
|
}
|
|
}
|
|
Err(_) => {
|
|
self.send_error_response(&cv.get_id(), CommunicationType::error_not_found)
|
|
.await;
|
|
}
|
|
}
|
|
} else {
|
|
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_data)
|
|
.await;
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::delete_user) {
|
|
if let Some(user_id) = cv.get_data(DataTypes::user_id).and_then(|v| v.as_i64()) {
|
|
match sql::delete_user(user_id).await {
|
|
Ok(_) => {
|
|
let response = CommunicationValue::new(CommunicationType::success)
|
|
.with_id(cv.get_id());
|
|
self.send_message(&response).await;
|
|
}
|
|
Err(e) => {
|
|
self.send_message(
|
|
&CommunicationValue::new(CommunicationType::error)
|
|
.with_id(cv.get_id())
|
|
.add_data_str(DataTypes::error_type, e.to_string()),
|
|
)
|
|
.await;
|
|
}
|
|
}
|
|
} else {
|
|
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_data)
|
|
.await;
|
|
}
|
|
return;
|
|
}
|
|
if cv.is_type(CommunicationType::delete_iota) {
|
|
if let Some(iota_id) = cv.get_data(DataTypes::iota_id).and_then(|v| v.as_i64()) {
|
|
match sql::delete_iota(iota_id).await {
|
|
Ok(_) => {
|
|
let response = CommunicationValue::new(CommunicationType::success)
|
|
.with_id(cv.get_id());
|
|
self.send_message(&response).await;
|
|
}
|
|
Err(e) => {
|
|
self.send_message(
|
|
&CommunicationValue::new(CommunicationType::error)
|
|
.with_id(cv.get_id())
|
|
.add_data_str(DataTypes::error_type, e.to_string()),
|
|
)
|
|
.await;
|
|
}
|
|
}
|
|
} else {
|
|
self.send_error_response(&cv.get_id(), CommunicationType::error_invalid_data)
|
|
.await;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
async fn send_error_response(&self, message_id: &Uuid, error_type: CommunicationType) {
|
|
let error = CommunicationValue::new(error_type).with_id(*message_id);
|
|
self.send_message(&error).await;
|
|
}
|
|
pub async fn close(&self) {
|
|
let mut sender = self.sender.write().await;
|
|
if self.is_identified().await {
|
|
let _ = sql::set_omikron_active(self.get_omikron_id().await, false);
|
|
}
|
|
let _ = sender.close().await;
|
|
}
|
|
pub async fn handle_close(self: Arc<Self>) {
|
|
if self.is_identified().await {
|
|
let omikron_id = self.get_omikron_id().await;
|
|
if omikron_id != 0 {
|
|
user_online_tracker::untrack_omikron(omikron_id).await;
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn handle_ping(&self, cv: CommunicationValue) {
|
|
if let Some(last_ping) = cv.get_data(DataTypes::last_ping) {
|
|
if let Ok(ping_val) = last_ping.to_string().parse::<i64>() {
|
|
let mut ping_guard = self.ping.write().await;
|
|
*ping_guard = ping_val;
|
|
}
|
|
}
|
|
|
|
let response = CommunicationValue::new(CommunicationType::pong).with_id(cv.get_id());
|
|
|
|
self.send_message(&response).await;
|
|
}
|
|
}
|