reach 0.0.1

Core P2P chat and connections functionality for Rustalk
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageType {
    Text,
    Connect,
    Disconnect,
    Handshake,
    KeyExchange,
    System,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Message {
    pub id: Uuid,
    pub sender_id: Uuid,
    pub recipient_id: Option<Uuid>,
    pub message_type: MessageType,
    pub content: String,
    pub timestamp: DateTime<Utc>,
    pub sender_name: String,
}

impl Message {
    pub fn new(
        sender_id: Uuid,
        recipient_id: Option<Uuid>,
        message_type: MessageType,
        content: String,
        sender_name: String,
    ) -> Self {
        Message {
            id: Uuid::new_v4(),
            sender_id,
            recipient_id,
            message_type,
            content,
            timestamp: Utc::now(),
            sender_name,
        }
    }

    // Alternative constructor for compatibility with session manager
    pub fn from_content(
        message_type: MessageType,
        content: String,
        sender_name: String,
        target_peer: Option<String>,
    ) -> Self {
        let sender_id = Uuid::new_v4(); // This should come from identity in real usage
        let recipient_id = target_peer.and_then(|_| Some(Uuid::new_v4())); // This should be resolved from peer lookup

        Message {
            id: Uuid::new_v4(),
            sender_id,
            recipient_id,
            message_type,
            content,
            timestamp: Utc::now(),
            sender_name,
        }
    }

    // Getter methods for compatibility
    pub fn sender(&self) -> &str {
        &self.sender_name
    }

    pub fn text_message(
        sender_id: Uuid,
        recipient_id: Uuid,
        content: String,
        sender_name: String,
    ) -> Self {
        Self::new(
            sender_id,
            Some(recipient_id),
            MessageType::Text,
            content,
            sender_name,
        )
    }

    pub fn system_message(content: String) -> Self {
        Self::new(
            Uuid::nil(),
            None,
            MessageType::System,
            content,
            "System".to_string(),
        )
    }

    pub fn handshake_message(sender_id: Uuid, public_key: String, sender_name: String) -> Self {
        Self::new(
            sender_id,
            None,
            MessageType::Handshake,
            public_key,
            sender_name,
        )
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EncryptedMessage {
    pub sender_id: Uuid,
    pub recipient_id: Uuid,
    pub encrypted_content: String,
    pub timestamp: DateTime<Utc>,
    pub sender_public_key: String,
}

impl EncryptedMessage {
    pub fn from_message(
        message: &Message,
        encrypted_content: String,
        sender_public_key: String,
    ) -> Self {
        EncryptedMessage {
            sender_id: message.sender_id,
            recipient_id: message.recipient_id.unwrap_or(Uuid::nil()),
            encrypted_content,
            timestamp: message.timestamp,
            sender_public_key,
        }
    }
}