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
131
132
133
134
135
136
137
138
139
140

// Copyright (c) 2021 Open Community Project Association https://ocpa.ch
// This software is published under the AGPLv3 license.

//! # Chat Text Message Handling
//!
//! The chat text messages are all chat messages, that can be sent,
//! in one single message.
//!
//! The sending of the files via the chat messaging is handled in the file.rs file.

use libp2p::PeerId;
use prost::Message;

use super::rpc_proto;
use super::{Chat, ChatStorage};
use crate::node::user_accounts::{UserAccount, UserAccounts};
use crate::services::group::{Group, GroupId, GroupManage, GroupStorage};
use crate::services::messaging::{proto, Messaging, MessagingServiceType};
use crate::utilities::timestamp::Timestamp;

/// Incoming and outgoing chat message handling
pub struct ChatMessage {}

impl ChatMessage {
    /// send message
    pub fn send(
        user_account: &UserAccount,
        receiver: &PeerId,
        common_message: &proto::CommonMessage,
    ) -> Result<Vec<u8>, String> {
        let send_message = proto::Messaging {
            message: Some(proto::messaging::Message::CommonMessage(
                common_message.clone(),
            )),
        };
        Messaging::pack_and_send_message(
            user_account,
            &receiver,
            send_message.encode_to_vec(),
            MessagingServiceType::Chat,
            &common_message.message_id,
            true,
        )
    }

    /// send message
    pub fn send_chat_message(
        account_id: &PeerId,
        group_id: &Vec<u8>,
        message: String,
    ) -> Result<bool, String> {
        let groupid = GroupId::from_bytes(&group_id).unwrap();
        let group;
        match GroupStorage::get_group(account_id.to_owned(), group_id.to_owned()) {
            Some(v) => group = v,
            None => {
                let error_string = "Group not found".to_string();
                // check if group is direct message
                match groupid.is_direct(account_id.to_owned()) {
                    // get user id from q8id
                    Some(user_q8id) => {
                        // create direct chat
                        match crate::router::users::Users::get_user_id_by_q8id(user_q8id) {
                            Some(user_id) => {
                                group =
                                    GroupManage::create_new_direct_chat_group(account_id, &user_id)
                            }
                            None => return Err(error_string),
                        }
                    }
                    None => return Err(error_string),
                }
            }
        }

        let mut my_member;
        match group.get_member(&account_id.to_bytes()) {
            Some(v) => {
                my_member = v.clone();
            }
            _ => {
                return Err("you are not member in this group".to_string());
            }
        }

        let last_index = my_member.last_message_index + 1;
        let timestamp = Timestamp::get_timestamp();
        let message_id = Chat::generate_message_id(&group.id, account_id, last_index);

        // pack message
        let common_message = proto::CommonMessage {
            message_id: message_id.clone(),
            group_id: groupid.to_bytes(),
            sent_at: timestamp,
            payload: Some(proto::common_message::Payload::ChatMessage(
                proto::ChatMessage {
                    content: message.clone(),
                },
            )),
        };

        let message_content = super::rpc_proto::ChatContentMessage {
            message: Some(
                super::rpc_proto::chat_content_message::Message::ChatContent(
                    super::rpc_proto::ChatContent { text: message },
                ),
            ),
        };

        // save outgoing message
        ChatStorage::save_message(
            account_id,
            &groupid,
            account_id,
            &message_id,
            timestamp,
            message_content.clone(),
            rpc_proto::MessageStatus::Sending,
        );

        // send to all group members
        if let Some(user_account) = UserAccounts::get_by_id(account_id.clone()) {
            for user_id in group.members.keys() {
                let receiver = PeerId::from_bytes(&user_id.clone()).unwrap();
                if receiver != *account_id {
                    log::trace!("send message to {}", receiver.to_base58());
                    if let Err(error) = Self::send(&user_account, &receiver, &common_message) {
                        log::error!("chat message send error {}", error);
                    }
                }
            }
        }

        // update member state
        my_member.last_message_index = last_index;
        Group::update_group_member(account_id, group_id, &my_member);

        Ok(true)
    }
}