fix chat conn

src/apps/chat/layer.rs

@@ -22,8 +22,8 @@ use super::rpc;
 
 /// Chat connect data structure.
 /// params: Friend about me height
-#[derive(Serialize, Deserialize)]
+//#[derive(Serialize, Deserialize)]
-pub struct LayerConnect(pub i64);
+//pub struct LayerConnect(pub i64);
 
 /// ESSE chat layer Event.
 #[derive(Serialize, Deserialize)]
@@ -58,9 +58,9 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
     let pid = global.pid().await;
 
     match msg {
-        RecvType::Connect(peer, data) | RecvType::ResultConnect(peer, data) => {
+        RecvType::Connect(peer, _) | RecvType::ResultConnect(peer, _) => {
             // ESSE chat layer connect date structure.
-            if let Ok(height) = handle_connect(pid, &peer, data, global, &mut results).await {
+            if let Ok(height) = handle_connect(pid, &peer, global, &mut results).await {
                 let peer_id = peer.id;
                 let msg = SendType::Result(0, peer, true, false, vec![]);
                 results.layers.push((CHAT_ID, msg));
@@ -74,10 +74,10 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
                 results.layers.push((CHAT_ID, msg));
             }
         }
-        RecvType::Result(peer, is_ok, data) => {
+        RecvType::Result(peer, is_ok, _) => {
             // ESSE chat layer result date structure.
             if is_ok {
-                if let Ok(height) = handle_connect(pid, &peer, data, global, &mut results).await {
+                if let Ok(height) = handle_connect(pid, &peer, global, &mut results).await {
                     let info = LayerEvent::InfoReq(height);
                     let data = bincode::serialize(&info).unwrap_or(vec![]);
                     let msg = SendType::Event(0, peer.id, data);
@@ -134,7 +134,6 @@ pub(crate) async fn handle(msg: RecvType, global: &Arc<Global>) -> Result<Handle
 async fn handle_connect(
     pid: PeerId,
     peer: &Peer,
-    data: Vec<u8>,
     global: &Arc<Global>,
     results: &mut HandleResult,
 ) -> Result<u64> {
@@ -328,6 +327,7 @@ impl LayerEvent {
                 if !keep {
                     results.layers.push((CHAT_ID, SendType::Disconnect(fpid)))
                 }
+                // TODO close session
             }
         }
 
@@ -335,6 +335,12 @@ impl LayerEvent {
     }
 }
 
+pub(crate) fn chat_conn(pid: PeerId, results: &mut HandleResult) {
+    results
+        .layers
+        .push((CHAT_ID, SendType::Connect(0, Peer::peer(pid), vec![])));
+}
+
 // UPDATE SESSION.
 pub(crate) fn update_session(s_db: &DStorage, id: &i64, msg: &Message, results: &mut HandleResult) {
     let scontent = match msg.m_type {

src/apps/chat/mod.rs

@@ -2,9 +2,7 @@ mod layer;
 mod models;
 
 pub(crate) mod rpc;
-pub(crate) use layer::handle;
+pub(crate) use layer::{chat_conn, handle, update_session, LayerEvent};
-pub(crate) use layer::update_session;
-pub(crate) use layer::LayerEvent;
 pub(crate) use models::{
     from_model, from_network_message, raw_to_network_message, to_network_message, Friend,
     InviteType, Message, Request,

src/global.rs

@@ -1,3 +1,8 @@
+use chat_types::CHAT_ID;
+use cloud_types::CLOUD_ID;
+use dao_types::DAO_ID;
+use domain_types::DOMAIN_ID;
+use group_types::GROUP_CHAT_ID;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use tdn::{
@@ -49,7 +54,7 @@ impl Global {
         self_send: Sender<ReceiveMessage>,
         rpc_send: Sender<RpcSendMessage>,
     ) -> Self {
-        let gids = vec![];
+        let gids = vec![0, CHAT_ID, GROUP_CHAT_ID, DAO_ID, DOMAIN_ID, CLOUD_ID];
 
         Global {
             base,

src/rpc.rs

@@ -22,8 +22,8 @@ use tokio::sync::{
 
 use crate::account::lang_from_i64;
 use crate::apps::app_rpc_inject;
+use crate::apps::chat::chat_conn;
 use crate::global::Global;
-//use crate::apps::chat::chat_conn;
 //use crate::apps::group::{add_layer, group_conn, GroupChat};
 //use crate::event::InnerEvent;
 use crate::group::Group;
@@ -464,8 +464,7 @@ fn new_rpc_handler(global: Arc<Global>) -> RpcHandler<Global> {
                     if let Some(addr) = online {
                         return Ok(HandleResult::rpc(json!([id, id_to_str(&addr)])));
                     }
-
+                    chat_conn(remote_pid, &mut results);
-                    //results.layers.push((gid, s.gid, chat_conn(proof, Peer::peer(s.addr))));
                 }
                 SessionType::Group => {
                     let remote_gid: GroupChatId =