work version

This commit is contained in:
wt committed 2025-11-23 17:03:48 +07:00
commit e03af7466b
5 files changed
+4135

No files matched your search

+651
View File
@@ -0,0 +1,651 @@
use axum::{
extract::{
ws::{Message, WebSocket, WebSocketUpgrade},
State, Json,
},
response::Response,
routing::{get, post},
Router,
};
use serde::{Deserialize, Serialize};
use sqlx::{sqlite::SqlitePool, Row};
use std::{
collections::HashMap,
net::SocketAddr,
sync::Arc,
};
use tokio::sync::{mpsc, RwLock};
use tower_http::services::ServeDir;
use futures_util::{StreamExt, SinkExt};
use bcrypt::{hash, verify, DEFAULT_COST};
use rand::distributions::Alphanumeric;
use rand::{thread_rng, Rng};
use chrono::{Utc, Duration};
// Types for shared state
type UserMap = Arc<RwLock<HashMap<String, mpsc::UnboundedSender<Message>>>>;
#[derive(Clone)]
struct AppState {
users: UserMap,
db_pool: SqlitePool,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
struct ChatMessage {
id: String,
from_user: String,
to_user: String,
content: String,
timestamp: i64,
message_type: String,
}
#[derive(Debug, Serialize, Deserialize)]
struct UserList {
users: Vec<String>,
}
// Структуры для аутентификации
#[derive(Debug, Deserialize)]
struct RegisterRequest {
phone: String,
username: String,
password: String,
}
#[derive(Debug, Deserialize)]
struct LoginRequest {
phone: String,
password: String,
}
#[derive(Debug, Serialize)]
struct AuthResponse {
success: bool,
message: String,
username: Option<String>,
token: Option<String>,
}
#[derive(Debug, Serialize)]
struct UserProfile {
username: String,
phone: String,
}
#[derive(Debug, Serialize)]
struct ValidateTokenResponse {
success: bool,
username: Option<String>,
phone: Option<String>,
message: Option<String>,
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Initialize logging
tracing_subscriber::fmt::init();
// Initialize database
let db_pool = init_db().await?;
// Create shared state
let state = Arc::new(AppState {
users: Arc::new(RwLock::new(HashMap::new())),
db_pool,
});
// Build the application
let app = Router::new()
.route("/ws", get(websocket_handler))
.route("/api/register", post(register_handler))
.route("/api/login", post(login_handler))
.route("/api/validate-token", post(validate_token_handler))
.route("/api/profile", get(profile_handler))
.nest_service("/", ServeDir::new("web"))
.with_state(state);
let addr = SocketAddr::from(([127, 0, 0, 1], 3333));
println!("Server running on http://{}", addr);
let listener = tokio::net::TcpListener::bind(addr).await?;
axum::serve(listener, app).await?;
Ok(())
}
async fn init_db() -> Result<SqlitePool, Box<dyn std::error::Error>> {
let pool = SqlitePool::connect("sqlite:chat.db").await?;
// Create users table
sqlx::query(
r#"
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
phone TEXT UNIQUE NOT NULL,
username TEXT UNIQUE NOT NULL,
password_hash TEXT NOT NULL,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)
"#,
)
.execute(&pool)
.await?;
// Create messages table
sqlx::query(
r#"
CREATE TABLE IF NOT EXISTS messages (
id TEXT PRIMARY KEY,
from_user TEXT NOT NULL,
to_user TEXT NOT NULL,
content TEXT NOT NULL,
timestamp INTEGER NOT NULL,
message_type TEXT NOT NULL
)
"#,
)
.execute(&pool)
.await?;
// Create sessions table
sqlx::query(
r#"
CREATE TABLE IF NOT EXISTS sessions (
token TEXT PRIMARY KEY,
username TEXT NOT NULL,
phone TEXT NOT NULL,
expires_at DATETIME NOT NULL,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)
"#,
)
.execute(&pool)
.await?;
Ok(pool)
}
// Обработчики HTTP API
async fn register_handler(
State(state): State<Arc<AppState>>,
Json(payload): Json<RegisterRequest>,
) -> Json<AuthResponse> {
// Validate input
if payload.phone.len() < 5 {
return Json(AuthResponse {
success: false,
message: "Phone number is too short".to_string(),
username: None,
token: None,
});
}
if payload.username.len() < 3 {
return Json(AuthResponse {
success: false,
message: "Username must be at least 3 characters".to_string(),
username: None,
token: None,
});
}
if payload.password.len() < 6 {
return Json(AuthResponse {
success: false,
message: "Password must be at least 6 characters".to_string(),
username: None,
token: None,
});
}
// Hash password
let password_hash = match hash(&payload.password, DEFAULT_COST) {
Ok(hash) => hash,
Err(_) => {
return Json(AuthResponse {
success: false,
message: "Error hashing password".to_string(),
username: None,
token: None,
});
}
};
// Insert user into database
let result = sqlx::query(
"INSERT INTO users (phone, username, password_hash) VALUES (?, ?, ?)"
)
.bind(&payload.phone)
.bind(&payload.username)
.bind(&password_hash)
.execute(&state.db_pool)
.await;
match result {
Ok(_) => {
// Generate session token
let token = generate_token();
let expires_at = Utc::now() + Duration::days(30);
// Store session
let _ = sqlx::query(
"INSERT INTO sessions (token, username, phone, expires_at) VALUES (?, ?, ?, ?)"
)
.bind(&token)
.bind(&payload.username)
.bind(&payload.phone)
.bind(expires_at.naive_utc())
.execute(&state.db_pool)
.await;
Json(AuthResponse {
success: true,
message: "Registration successful".to_string(),
username: Some(payload.username),
token: Some(token),
})
}
Err(e) => {
let error_message = if e.to_string().contains("UNIQUE constraint failed: users.phone") {
"Phone number already registered".to_string()
} else if e.to_string().contains("UNIQUE constraint failed: users.username") {
"Username already taken".to_string()
} else {
"Registration failed".to_string()
};
Json(AuthResponse {
success: false,
message: error_message,
username: None,
token: None,
})
}
}
}
async fn login_handler(
State(state): State<Arc<AppState>>,
Json(payload): Json<LoginRequest>,
) -> Json<AuthResponse> {
// Get user from database
let user_result = sqlx::query(
"SELECT username, password_hash FROM users WHERE phone = ?"
)
.bind(&payload.phone)
.fetch_optional(&state.db_pool)
.await;
match user_result {
Ok(Some(row)) => {
let username: String = row.get("username");
let password_hash: String = row.get("password_hash");
// Verify password
match verify(&payload.password, &password_hash) {
Ok(true) => {
// Generate session token
let token = generate_token();
let expires_at = Utc::now() + Duration::days(30);
// Store session
let _ = sqlx::query(
"INSERT INTO sessions (token, username, phone, expires_at) VALUES (?, ?, ?, ?)"
)
.bind(&token)
.bind(&username)
.bind(&payload.phone)
.bind(expires_at.naive_utc())
.execute(&state.db_pool)
.await;
Json(AuthResponse {
success: true,
message: "Login successful".to_string(),
username: Some(username),
token: Some(token),
})
}
Ok(false) => Json(AuthResponse {
success: false,
message: "Invalid password".to_string(),
username: None,
token: None,
}),
Err(_) => Json(AuthResponse {
success: false,
message: "Error verifying password".to_string(),
username: None,
token: None,
}),
}
}
Ok(None) => Json(AuthResponse {
success: false,
message: "Phone number not found".to_string(),
username: None,
token: None,
}),
Err(_) => Json(AuthResponse {
success: false,
message: "Login failed".to_string(),
username: None,
token: None,
}),
}
}
#[derive(Debug, Deserialize)]
struct ValidateTokenRequest {
token: String,
}
async fn validate_token_handler(
State(state): State<Arc<AppState>>,
Json(payload): Json<ValidateTokenRequest>,
) -> Json<ValidateTokenResponse> {
match verify_token(&state.db_pool, &payload.token).await {
Ok(Some(username)) => {
// Get user details
let user_result = sqlx::query(
"SELECT phone FROM users WHERE username = ?"
)
.bind(&username)
.fetch_optional(&state.db_pool)
.await;
match user_result {
Ok(Some(row)) => {
let phone: String = row.get("phone");
Json(ValidateTokenResponse {
success: true,
username: Some(username),
phone: Some(phone),
message: None,
})
}
Ok(None) => Json(ValidateTokenResponse {
success: false,
username: None,
phone: None,
message: Some("User not found".to_string()),
}),
Err(_) => Json(ValidateTokenResponse {
success: false,
username: None,
phone: None,
message: Some("Database error".to_string()),
}),
}
}
Ok(None) => Json(ValidateTokenResponse {
success: false,
username: None,
phone: None,
message: Some("Invalid or expired token".to_string()),
}),
Err(_) => Json(ValidateTokenResponse {
success: false,
username: None,
phone: None,
message: Some("Token verification error".to_string()),
}),
}
}
async fn profile_handler() -> Json<UserProfile> {
// This would normally verify the token and return user profile
// For now, return a placeholder
Json(UserProfile {
username: "user".to_string(),
phone: "+1234567890".to_string(),
})
}
// WebSocket handlers
async fn websocket_handler(
ws: WebSocketUpgrade,
State(state): State<Arc<AppState>>,
) -> Response {
ws.on_upgrade(|socket| handle_websocket(socket, state))
}
async fn handle_websocket(socket: WebSocket, state: Arc<AppState>) {
// Split the socket into sender and receiver
let (mut sender, mut receiver) = socket.split();
// Create channel for sending messages to this client
let (tx, mut rx) = mpsc::unbounded_channel();
// Handle authentication - receive first message with token
let username = match receiver.next().await {
Some(Ok(Message::Text(auth_msg))) => {
match serde_json::from_str::<serde_json::Value>(&auth_msg) {
Ok(auth) => {
if let (Some(token), Some(auth_type)) = (auth["token"].as_str(), auth["type"].as_str()) {
if auth_type == "auth" {
// Verify token and get username
match verify_token(&state.db_pool, token).await {
Ok(Some(user_username)) => {
// Check if username is already connected
if state.users.read().await.contains_key(&user_username) {
let _ = sender.send(Message::Text(
serde_json::json!({
"type": "error",
"content": "User already connected"
}).to_string(),
)).await;
return;
}
// Register user
state.users.write().await.insert(user_username.clone(), tx);
// Send success message
let _ = sender.send(Message::Text(
serde_json::json!({
"type": "system",
"content": "Connected successfully"
}).to_string(),
)).await;
// Send user list
broadcast_user_list(&state.users).await;
// Send message history
if let Ok(messages) = get_message_history(&state.db_pool, &user_username).await {
for msg in messages {
let message_json = serde_json::to_string(&msg).unwrap();
let _ = sender.send(Message::Text(message_json)).await;
}
}
user_username
}
Ok(None) => {
let _ = sender.send(Message::Text(
serde_json::json!({
"type": "error",
"content": "Invalid or expired token"
}).to_string(),
)).await;
return;
}
Err(_) => {
let _ = sender.send(Message::Text(
serde_json::json!({
"type": "error",
"content": "Authentication error"
}).to_string(),
)).await;
return;
}
}
} else {
return;
}
} else {
return;
}
}
Err(_) => return,
}
}
_ => return,
};
println!("User {} connected", username);
// Clone state for cleanup
let state_clone = state.clone();
let username_clone = username.clone();
// Spawn a task to handle sending messages to the client
let mut send_sender = sender;
let send_task = tokio::spawn(async move {
while let Some(message) = rx.recv().await {
if send_sender.send(message).await.is_err() {
break;
}
}
});
// Handle receiving messages from the client in the main task
let recv_state = state.clone();
let recv_task = tokio::spawn(async move {
while let Some(result) = receiver.next().await {
match result {
Ok(Message::Text(text)) => {
println!("Received message from {}: {}", username, text);
if let Ok(mut chat_msg) = serde_json::from_str::<ChatMessage>(&text) {
// Set the from_user to the authenticated username
chat_msg.from_user = username.clone();
println!("Processing message from {} to {}", chat_msg.from_user, chat_msg.to_user);
// Save message to database
if let Err(e) = save_message(&recv_state.db_pool, &chat_msg).await {
eprintln!("Failed to save message: {}", e);
continue;
}
// Send to recipient if online
let users = recv_state.users.read().await;
if let Some(recipient_tx) = users.get(&chat_msg.to_user) {
let message_json = serde_json::to_string(&chat_msg).unwrap();
println!("Sending message to {}: {}", chat_msg.to_user, message_json);
let _ = recipient_tx.send(Message::Text(message_json));
} else {
println!("Recipient {} not found online", chat_msg.to_user);
}
// Also send the message back to the sender for confirmation
if let Some(sender_tx) = users.get(&username) {
let message_json = serde_json::to_string(&chat_msg).unwrap();
let _ = sender_tx.send(Message::Text(message_json));
}
} else {
println!("Failed to parse message as ChatMessage: {}", text);
}
}
Ok(Message::Close(_)) => {
println!("WebSocket closed by client");
break;
}
Err(e) => {
eprintln!("WebSocket error: {}", e);
break;
}
_ => {}
}
}
});
// Wait for both tasks to finish
tokio::select! {
_ = send_task => {},
_ = recv_task => {},
}
// Cleanup
state_clone.users.write().await.remove(&username_clone);
broadcast_user_list(&state_clone.users).await;
println!("User {} disconnected", username_clone);
}
// Utility functions
fn generate_token() -> String {
thread_rng()
.sample_iter(&Alphanumeric)
.take(32)
.map(char::from)
.collect()
}
async fn verify_token(pool: &SqlitePool, token: &str) -> Result<Option<String>, sqlx::Error> {
let result = sqlx::query(
"SELECT username FROM sessions WHERE token = ? AND expires_at > datetime('now')"
)
.bind(token)
.fetch_optional(pool)
.await?;
Ok(result.map(|row| row.get("username")))
}
async fn broadcast_user_list(users: &UserMap) {
let user_list: Vec<String> = users.read().await.keys().cloned().collect();
let user_list_msg = serde_json::json!({
"type": "user_list",
"users": user_list
});
for tx in users.read().await.values() {
let _ = tx.send(Message::Text(user_list_msg.to_string()));
}
}
async fn save_message(pool: &SqlitePool, msg: &ChatMessage) -> Result<(), sqlx::Error> {
sqlx::query(
"INSERT OR REPLACE INTO messages (id, from_user, to_user, content, timestamp, message_type) VALUES (?, ?, ?, ?, ?, ?)",
)
.bind(&msg.id)
.bind(&msg.from_user)
.bind(&msg.to_user)
.bind(&msg.content)
.bind(msg.timestamp)
.bind(&msg.message_type)
.execute(pool)
.await?;
Ok(())
}
async fn get_message_history(pool: &SqlitePool, username: &str) -> Result<Vec<ChatMessage>, sqlx::Error> {
let rows = sqlx::query(
"SELECT id, from_user, to_user, content, timestamp, message_type FROM messages WHERE from_user = ? OR to_user = ? ORDER BY timestamp"
)
.bind(username)
.bind(username)
.fetch_all(pool)
.await?;
let mut messages = Vec::new();
for row in rows {
let message = ChatMessage {
id: row.get("id"),
from_user: row.get("from_user"),
to_user: row.get("to_user"),
content: row.get("content"),
timestamp: row.get("timestamp"),
message_type: row.get("message_type"),
};
messages.push(message);
}
Ok(messages)
}