392 lines
14 KiB
Rust
392 lines
14 KiB
Rust
use crate::users::user_profile::UserProfile;
|
|
use crate::util::db;
|
|
use iota_util::file_util::{delete_user_directory, load_file, remove_user_credential, save_file};
|
|
use rusqlite::params;
|
|
use std::time::{SystemTime, UNIX_EPOCH};
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum LocalUserState {
|
|
Managed,
|
|
Released,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct UserResidency {
|
|
pub user_id: i64,
|
|
pub username: String,
|
|
pub state: LocalUserState,
|
|
pub data_present: bool,
|
|
}
|
|
|
|
fn now_millis() -> i64 {
|
|
SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap_or_default()
|
|
.as_millis() as i64
|
|
}
|
|
|
|
pub fn add_user(user: UserProfile) {
|
|
if let Err(e) = try_add_user(user) {
|
|
eprintln!("Failed to add_user: {}", e);
|
|
}
|
|
}
|
|
|
|
pub fn try_add_user(user: UserProfile) -> Result<(), crate::storage_error::StorageError> {
|
|
db::with_db(|conn| {
|
|
conn.execute(
|
|
r#"
|
|
INSERT INTO users (user_id, username, public_key, private_key_hash, reset_token, created_at, display_name)
|
|
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
|
|
ON CONFLICT(user_id) DO UPDATE SET
|
|
username = excluded.username,
|
|
public_key = excluded.public_key,
|
|
private_key_hash = excluded.private_key_hash,
|
|
reset_token = excluded.reset_token,
|
|
display_name = excluded.display_name
|
|
"#,
|
|
params![
|
|
user.user_id,
|
|
user.username,
|
|
user.public_key,
|
|
user.private_key_hash,
|
|
user.reset_token,
|
|
user.created_at,
|
|
user.display_name,
|
|
],
|
|
)?;
|
|
|
|
for (app_id, app_secret) in &user.trusted_apps {
|
|
conn.execute(
|
|
r#"
|
|
INSERT OR REPLACE INTO trusted_apps (user_id, app_id, app_secret)
|
|
VALUES (?1, ?2, ?3)
|
|
"#,
|
|
params![user.user_id, app_id, app_secret],
|
|
)?;
|
|
}
|
|
conn.execute(
|
|
r#"INSERT INTO user_residency (user_id, username, lifecycle_state, data_state, updated_at)
|
|
VALUES (?1, ?2, 'managed', COALESCE((SELECT data_state FROM user_residency WHERE user_id = ?1), 'present'), ?3)
|
|
ON CONFLICT(user_id) DO UPDATE SET username = excluded.username, lifecycle_state = 'managed', updated_at = excluded.updated_at"#,
|
|
params![user.user_id, user.username, now_millis()],
|
|
)?;
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
pub fn update_user(user: UserProfile) {
|
|
add_user(user);
|
|
}
|
|
|
|
pub fn get_user_by_username(username: &str) -> Option<UserProfile> {
|
|
match db::with_db(|conn| {
|
|
match conn.query_row(
|
|
"SELECT user_id, username, public_key, private_key_hash, reset_token, created_at, display_name FROM users WHERE username = ?1 LIMIT 1",
|
|
params![username],
|
|
|r| {
|
|
let user_id: i64 = r.get(0)?;
|
|
Ok(UserProfile {
|
|
user_id,
|
|
username: r.get(1)?,
|
|
display_name: r.get(6)?,
|
|
public_key: r.get(2)?,
|
|
private_key_hash: r.get(3)?,
|
|
created_at: r.get(5)?,
|
|
reset_token: r.get(4)?,
|
|
trusted_apps: load_trusted_apps(user_id),
|
|
})
|
|
},
|
|
) {
|
|
Ok(user) => Ok(Some(user)),
|
|
Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
|
|
Err(e) => Err(e.into()),
|
|
}
|
|
}) {
|
|
Ok(opt) => opt,
|
|
Err(e) => {
|
|
eprintln!("Error querying user by username: {}", e);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn get_user(user_id: i64) -> Option<UserProfile> {
|
|
match db::with_db(|conn| {
|
|
match conn.query_row(
|
|
"SELECT user_id, username, public_key, private_key_hash, reset_token, created_at, display_name FROM users WHERE user_id = ?1 LIMIT 1",
|
|
params![user_id],
|
|
|r| {
|
|
let user_id: i64 = r.get(0)?;
|
|
Ok(UserProfile {
|
|
user_id,
|
|
username: r.get(1)?,
|
|
display_name: r.get(6)?,
|
|
public_key: r.get(2)?,
|
|
private_key_hash: r.get(3)?,
|
|
created_at: r.get(5)?,
|
|
reset_token: r.get(4)?,
|
|
trusted_apps: load_trusted_apps(user_id),
|
|
})
|
|
},
|
|
) {
|
|
Ok(user) => Ok(Some(user)),
|
|
Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
|
|
Err(e) => Err(e.into()),
|
|
}
|
|
}) {
|
|
Ok(opt) => opt,
|
|
Err(e) => {
|
|
eprintln!("Error querying user: {}", e);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn get_users() -> Vec<UserProfile> {
|
|
match db::with_db(|conn| {
|
|
let mut stmt = conn.prepare(
|
|
r#"
|
|
SELECT user_id, username, public_key, private_key_hash, reset_token, created_at, display_name
|
|
FROM users
|
|
ORDER BY username
|
|
"#,
|
|
)?;
|
|
|
|
let rows = stmt.query_map([], |r| {
|
|
let user_id: i64 = r.get(0)?;
|
|
let username: String = r.get(1)?;
|
|
let public_key: String = r.get(2)?;
|
|
let private_key_hash: String = r.get(3)?;
|
|
let reset_token: String = r.get(4)?;
|
|
let created_at: i64 = r.get(5)?;
|
|
let display_name: Option<String> = r.get(6)?;
|
|
|
|
Ok(UserProfile {
|
|
user_id,
|
|
username,
|
|
display_name,
|
|
public_key,
|
|
private_key_hash,
|
|
created_at,
|
|
reset_token,
|
|
trusted_apps: std::collections::HashMap::new(),
|
|
})
|
|
})?;
|
|
|
|
let mut out = Vec::new();
|
|
for row in rows {
|
|
match row {
|
|
Ok(mut user) => {
|
|
user.trusted_apps = load_trusted_apps(user.user_id);
|
|
out.push(user);
|
|
}
|
|
Err(e) => eprintln!("Failed to read user row: {}", e),
|
|
}
|
|
}
|
|
Ok(out)
|
|
}) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
eprintln!("Failed to query users: {}", e);
|
|
Vec::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
fn load_trusted_apps(user_id: i64) -> std::collections::HashMap<String, String> {
|
|
match db::with_db(|conn| {
|
|
let mut stmt =
|
|
conn.prepare("SELECT app_id, app_secret FROM trusted_apps WHERE user_id = ?1")?;
|
|
let rows = stmt.query_map(params![user_id], |r| {
|
|
Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))
|
|
})?;
|
|
|
|
let mut map = std::collections::HashMap::new();
|
|
for row in rows {
|
|
if let Ok((k, v)) = row {
|
|
map.insert(k, v);
|
|
}
|
|
}
|
|
Ok(map)
|
|
}) {
|
|
Ok(m) => m,
|
|
Err(e) => {
|
|
eprintln!("Failed to load trusted apps: {}", e);
|
|
std::collections::HashMap::new()
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn remove_user(user_id: i64) {
|
|
if let Err(e) = db::with_db(|conn| {
|
|
conn.execute(
|
|
"DELETE FROM trusted_apps WHERE user_id = ?1",
|
|
params![user_id],
|
|
)?;
|
|
conn.execute("DELETE FROM users WHERE user_id = ?1", params![user_id])?;
|
|
Ok(())
|
|
}) {
|
|
eprintln!("Failed to remove_user: {}", e);
|
|
}
|
|
}
|
|
|
|
/// Remove only local management authority. Hosted content is intentionally
|
|
/// retained and is indexed as released for a later purge operation.
|
|
pub fn release_user(user_id: i64) -> Result<(), crate::storage_error::StorageError> {
|
|
let username = get_user(user_id).map(|user| user.username).ok_or_else(|| {
|
|
crate::storage_error::StorageError::Other("managed user was not found".into())
|
|
})?;
|
|
db::with_db(|conn| {
|
|
let tx = conn.unchecked_transaction()?;
|
|
tx.execute(
|
|
"DELETE FROM trusted_apps WHERE user_id = ?1",
|
|
params![user_id],
|
|
)?;
|
|
tx.execute("DELETE FROM users WHERE user_id = ?1", params![user_id])?;
|
|
tx.execute(
|
|
r#"INSERT INTO user_residency (user_id, username, lifecycle_state, data_state, updated_at)
|
|
VALUES (?1, ?2, 'released', COALESCE((SELECT data_state FROM user_residency WHERE user_id = ?1), 'present'), ?3)
|
|
ON CONFLICT(user_id) DO UPDATE SET username = excluded.username, lifecycle_state = 'released', updated_at = excluded.updated_at"#,
|
|
params![user_id, username, now_millis()],
|
|
)?;
|
|
tx.commit()?;
|
|
Ok(())
|
|
})?;
|
|
remove_user_credential(user_id)
|
|
.map_err(|error| crate::storage_error::StorageError::Other(error.to_string()))
|
|
}
|
|
|
|
/// Authoritative hosted-data erasure used by local purge and future Omega
|
|
/// erasure delivery. Management metadata and credentials are left intact.
|
|
pub fn purge_user_data(user_id: i64) -> Result<(), crate::storage_error::StorageError> {
|
|
db::with_db(|conn| {
|
|
let tx = conn.unchecked_transaction()?;
|
|
tx.execute("DELETE FROM message_edits WHERE message_id IN (SELECT id FROM messages WHERE storage_owner = ?1)", params![user_id])?;
|
|
tx.execute("DELETE FROM reactions WHERE message_id IN (SELECT id FROM messages WHERE storage_owner = ?1)", params![user_id])?;
|
|
tx.execute(
|
|
"DELETE FROM messages WHERE storage_owner = ?1",
|
|
params![user_id],
|
|
)?;
|
|
tx.execute(
|
|
"DELETE FROM contacts WHERE storage_owner = ?1",
|
|
params![user_id],
|
|
)?;
|
|
tx.execute(
|
|
"DELETE FROM communities WHERE storage_owner = ?1",
|
|
params![user_id],
|
|
)?;
|
|
tx.execute("DELETE FROM settings WHERE user_id = ?1", params![user_id])?;
|
|
tx.execute(
|
|
"DELETE FROM sync_events WHERE user_id = ?1",
|
|
params![user_id],
|
|
)?;
|
|
tx.execute(
|
|
"DELETE FROM sync_heads WHERE user_id = ?1",
|
|
params![user_id],
|
|
)?;
|
|
tx.execute(
|
|
"DELETE FROM client_sync_state WHERE user_id = ?1",
|
|
params![user_id],
|
|
)?;
|
|
tx.execute(
|
|
"DELETE FROM trusted_apps WHERE user_id = ?1",
|
|
params![user_id],
|
|
)?;
|
|
tx.execute(
|
|
"UPDATE user_residency SET data_state = 'empty', updated_at = ?2 WHERE user_id = ?1",
|
|
params![user_id, now_millis()],
|
|
)?;
|
|
tx.commit()?;
|
|
Ok(())
|
|
})?;
|
|
crate::util::e2ee_storage::purge_user(user_id)
|
|
.map_err(crate::storage_error::StorageError::Other)?;
|
|
delete_user_directory(user_id)
|
|
.map_err(|error| crate::storage_error::StorageError::Other(error.to_string()))
|
|
}
|
|
|
|
/// Complete local erasure is idempotent and is the target for a durable
|
|
/// Omega-hosted erasure request after account deletion.
|
|
pub fn erase_user_locally(user_id: i64) -> Result<(), crate::storage_error::StorageError> {
|
|
purge_user_data(user_id)?;
|
|
db::with_db(|conn| {
|
|
conn.execute(
|
|
"DELETE FROM trusted_apps WHERE user_id = ?1",
|
|
params![user_id],
|
|
)?;
|
|
conn.execute("DELETE FROM users WHERE user_id = ?1", params![user_id])?;
|
|
conn.execute(
|
|
"DELETE FROM user_residency WHERE user_id = ?1",
|
|
params![user_id],
|
|
)?;
|
|
Ok(())
|
|
})?;
|
|
remove_user_credential(user_id)
|
|
.map_err(|error| crate::storage_error::StorageError::Other(error.to_string()))
|
|
}
|
|
|
|
pub fn get_residency() -> Vec<UserResidency> {
|
|
db::with_db(|conn| {
|
|
let mut stmt = conn.prepare("SELECT user_id, username, lifecycle_state, data_state FROM user_residency ORDER BY username")?;
|
|
let rows = stmt.query_map([], |row| {
|
|
let lifecycle: String = row.get(2)?;
|
|
Ok(UserResidency {
|
|
user_id: row.get(0)?, username: row.get(1)?,
|
|
state: if lifecycle == "managed" { LocalUserState::Managed } else { LocalUserState::Released },
|
|
data_present: row.get::<_, String>(3)? == "present",
|
|
})
|
|
})?;
|
|
rows.collect::<Result<Vec<_>, _>>().map_err(Into::into)
|
|
}).unwrap_or_default()
|
|
}
|
|
|
|
pub fn clear() {
|
|
if let Err(e) = db::with_db(|conn| {
|
|
conn.execute_batch(
|
|
"DELETE FROM trusted_apps; DELETE FROM users; DELETE FROM user_residency;",
|
|
)?;
|
|
Ok(())
|
|
}) {
|
|
eprintln!("Failed to clear users: {}", e);
|
|
}
|
|
}
|
|
|
|
pub fn save_users() {
|
|
// No-op: users are auto-saved via SQLite.
|
|
}
|
|
|
|
pub fn load_users_sync() -> std::io::Result<()> {
|
|
// Users are loaded from SQLite on demand. This function is kept for API compat.
|
|
// If we need to migrate from a legacy users.json file, we can do so here.
|
|
let content = load_file("", "users.json");
|
|
if content.trim().is_empty() {
|
|
return Ok(());
|
|
}
|
|
if let Ok(parsed) = json::parse(&content) {
|
|
if let json::JsonValue::Array(arr) = parsed {
|
|
for j in arr.iter() {
|
|
if let Some(up) = UserProfile::from_json(j) {
|
|
add_user(up);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Rename the old file so we don't re-import
|
|
let _ = std::fs::rename(
|
|
std::path::PathBuf::from(iota_util::file_util::get_directory()).join("users.json"),
|
|
std::path::PathBuf::from(iota_util::file_util::get_directory()).join("users.json.imported"),
|
|
);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn save_app_data(user_id: i64, app_identifier: &str, data: &str) {
|
|
let path = format!("users/{}/apps", user_id);
|
|
let name = format!("{}.json", app_identifier);
|
|
save_file(&path, &name, data);
|
|
}
|
|
|
|
pub fn load_app_data(user_id: i64, app_identifier: &str) -> String {
|
|
let path = format!("users/{}/apps", user_id);
|
|
let name = format!("{}.json", app_identifier);
|
|
load_file(&path, &name)
|
|
}
|