fix group create

lib/apps/group/add.dart

@@ -38,6 +38,7 @@ class _GroupAddScreenState extends State<GroupAddScreen> {
   _send(String name, bool isDesktop) async {
     final res = await httpPost('group-create', [name]);
     if (res.isOk) {
+      print(res.params);
       final id = res.params[0];
       final w = GroupChatDetail(id: id);
       if (w != null) {

src/apps/chat/layer.rs

@@ -371,23 +371,14 @@ impl LayerEvent {
         fid: i64,
         m_type: MessageType,
         content: &str,
-    ) -> std::result::Result<(Message, NetworkMessage, String), tdn::types::rpc::RpcError> {
+    ) -> std::result::Result<(Message, NetworkMessage), tdn::types::rpc::RpcError> {
         let db = chat_db(&base, &mgid)?;
-
         // handle message's type.
         let (nm_type, raw) = raw_to_network_message(base, &mgid, &m_type, content).await?;
-
-        let scontent = match m_type {
-            MessageType::String => {
-                format!("{}:{}", m_type.to_int(), raw)
-            }
-            _ => format!("{}:", m_type.to_int()),
-        };
-
         let mut msg = Message::new(&mgid, fid, true, m_type, raw, false);
         msg.insert(&db)?;
         drop(db);
-        Ok((msg, nm_type, scontent))
+        Ok((msg, nm_type))
     }
 }
 

src/apps/chat/mod.rs

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

src/apps/chat/models/friend.rs

@@ -108,7 +108,7 @@ impl Friend {
     }
 
     pub fn get(db: &DStorage, id: &i64) -> Result<Friend> {
-        let sql = format!("SELECT id, gid, addr, name, wallet, remark, is_closed, datetime, is_deleted FROM friends WHERE id = {}", id);
+        let sql = format!("SELECT id, gid, addr, name, wallet, remark, is_closed, datetime FROM friends WHERE id = {}", id);
         let mut matrix = db.query(&sql)?;
         if matrix.len() > 0 {
             Ok(Friend::from_values(matrix.pop().unwrap())) // safe unwrap()

src/apps/chat/models/request.rs

@@ -107,7 +107,7 @@ impl Request {
     }
 
     pub fn list(db: &DStorage) -> Result<Vec<Request>> {
-        let matrix = db.query("SELECT id, gid, addr, name, remark, is_me, is_ok, is_over, is_delivery, datetime FROM requests WHERE ORDER BY id DESC")?;
+        let matrix = db.query("SELECT id, gid, addr, name, remark, is_me, is_ok, is_over, is_delivery, datetime FROM requests ORDER BY id DESC")?;
         let mut requests = vec![];
         for values in matrix {
             requests.push(Request::from_values(values));

src/apps/chat/rpc.rs

@@ -16,7 +16,7 @@ use crate::rpc::{session_create, session_last, sleep_waiting_close_stable, RpcSt
 use crate::session::{Session, SessionType};
 use crate::storage::{chat_db, delete_avatar, session_db};
 
-use super::layer::LayerEvent;
+use super::layer::{update_session, LayerEvent};
 use super::{Friend, Message, Request};
 
 #[inline]
@@ -436,11 +436,10 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let content = params[3].as_str().ok_or(RpcError::ParseError)?;
 
             let mut layer_lock = state.layer.write().await;
-            let base = layer_lock.base();
+            let base = layer_lock.base().clone();
             let faddr = layer_lock.running(&gid)?.online(&fgid)?;
 
-            let (msg, nw, scontent) =
-                LayerEvent::from_message(base, gid, fid, m_type, content).await?;
+            let (msg, nw) = LayerEvent::from_message(&base, gid, fid, m_type, content).await?;
             let event = LayerEvent::Message(msg.hash, nw);
             let s = super::layer::event_message(&mut layer_lock, msg.id, gid, faddr, &event);
             drop(layer_lock);
@@ -449,21 +448,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             results.layers.push((gid, fgid, s));
 
             // UPDATE SESSION.
-            let layer_lock = state.layer.read().await;
-            let s_db = session_db(&layer_lock.base, &gid)?;
-            if let Ok(id) = Session::last(
-                &s_db,
-                &fid,
-                &SessionType::Chat,
-                &msg.datetime,
-                &scontent,
-                true,
-            ) {
-                results
-                    .rpcs
-                    .push(session_last(gid, &id, &msg.datetime, &scontent, true));
-            }
-            drop(layer_lock);
+            update_session(&base, &gid, &fid, &msg, &mut results);
 
             match event {
                 LayerEvent::Message(hash, nw) => {

src/apps/group/models/group.rs

@@ -98,7 +98,7 @@ impl GroupChat {
 
     pub fn local(db: &DStorage) -> Result<Vec<GroupChat>> {
         let matrix = db.query(
-            "SELECT id, height, gcd, addr, name, close, local FROM groups WHERE local = true",
+            "SELECT id, height, gcd, addr, name, is_close, is_local FROM groups WHERE is_local = true",
         )?;
         let mut groups = vec![];
         for values in matrix {
@@ -108,7 +108,8 @@ impl GroupChat {
     }
 
     pub fn all(db: &DStorage) -> Result<Vec<GroupChat>> {
-        let matrix = db.query("SELECT id, height, gcd, addr, name, close, local FROM groups")?;
+        let matrix =
+            db.query("SELECT id, height, gcd, addr, name, is_close, is_local FROM groups")?;
         let mut groups = vec![];
         for values in matrix {
             groups.push(Self::from_values(values));
@@ -118,7 +119,7 @@ impl GroupChat {
 
     pub fn get(db: &DStorage, id: &i64) -> Result<GroupChat> {
         let sql = format!(
-            "SELECT id, height, gcd, addr, name, close, local FROM groups WHERE id = {}",
+            "SELECT id, height, gcd, addr, name, is_close, is_local FROM groups WHERE id = {}",
             id
         );
         let mut matrix = db.query(&sql)?;
@@ -132,7 +133,7 @@ impl GroupChat {
 
     pub fn get_id(db: &DStorage, gid: &GroupId) -> Result<GroupChat> {
         let sql = format!(
-            "SELECT id, height, gcd, addr, name, close, local FROM groups WHERE gcd = '{}'",
+            "SELECT id, height, gcd, addr, name, is_close, is_local FROM groups WHERE gcd = '{}'",
             gid.to_hex()
         );
         let mut matrix = db.query(&sql)?;
@@ -162,12 +163,13 @@ impl GroupChat {
             db.update(&sql)?;
         } else {
             let sql = format!(
-                "INSERT INTO groups (height, gcd, addr, name, close) VALUES ({}, '{}', '{}', '{}', {})",
+                "INSERT INTO groups (height, gcd, addr, name, is_close, is_local) VALUES ({}, '{}', '{}', '{}', {}, {})",
                 self.height,
                 self.g_id.to_hex(),
                 self.g_addr.to_hex(),
                 self.g_name,
                 self.close,
+                self.local,
             );
             let id = db.insert(&sql)?;
             self.id = id;
@@ -182,7 +184,7 @@ impl GroupChat {
 
     pub fn close(db: &DStorage, gcd: &GroupId) -> Result<GroupChat> {
         let group = Self::get_id(db, gcd)?;
-        let sql = format!("UPDATE groups SET close = true WHERE id = {}", group.id);
+        let sql = format!("UPDATE groups SET is_close = true WHERE id = {}", group.id);
         db.update(&sql)?;
         Ok(group)
     }

src/apps/group/rpc.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
-    message::{NetworkType, SendType},
+    message::{NetworkType, SendMessage, SendType},
     primitive::{HandleResult, PeerId},
     rpc::{json, rpc_response, RpcError, RpcHandler, RpcParam},
 };
@@ -105,9 +105,13 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
             let name = params[0].as_str().ok_or(RpcError::ParseError)?.to_owned();
 
-            let base = state.layer.read().await.base().clone();
+            let group_lock = state.group.read().await;
+            let base = group_lock.base().clone();
+            let addr = group_lock.addr().clone();
+            let sender = group_lock.sender();
+            let me = group_lock.clone_user(&gid)?;
+            drop(group_lock);
             let db = group_db(&base, &gid)?;
-            let addr = state.layer.read().await.addr.clone();
 
             let mut gc = GroupChat::new(addr, name);
             let gcd = gc.g_id;
@@ -118,7 +122,6 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let gdid = gc.id;
 
             let mut results = HandleResult::new();
-            let me = state.group.read().await.clone_user(&gid)?;
 
             // add to rpcs.
             results.rpcs.push(json!(gc.to_rpc()));
@@ -129,10 +132,15 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let _ = write_avatar(&base, &gid, &gid, &me.avatar).await;
 
             // Add new session.
-            let s_db = session_db(state.layer.read().await.base(), &gid)?;
+            let s_db = session_db(&base, &gid)?;
             let mut session = gc.to_session();
             session.insert(&s_db)?;
-            results.rpcs.push(session_create(gid, &session));
+            let sid = session.id;
+            tokio::spawn(async move {
+                let _ = sender
+                    .send(SendMessage::Rpc(0, session_create(gid, &session), true))
+                    .await;
+            });
 
             // Add frist member join.
             let mut layer_lock = state.layer.write().await;
@@ -143,12 +151,9 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             layer_lock
                 .running_mut(&gcd)?
                 .check_add_online(gid, Online::Direct(addr), gdid, mid)?;
-            layer_lock.running_mut(&gid)?.check_add_online(
-                gcd,
-                Online::Direct(addr),
-                session.id,
-                gdid,
-            )?;
+            layer_lock
+                .running_mut(&gid)?
+                .check_add_online(gcd, Online::Direct(addr), sid, gdid)?;
 
             drop(layer_lock);
 
@@ -176,9 +181,9 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let gcd = g.g_id;
             let mut results = HandleResult::new();
 
+            // handle invite message
             let contact_values = InviteType::Group(gcd, g.g_addr, g.g_name).serialize();
-
-            let (msg, nw, sc) = crate::apps::chat::LayerEvent::from_message(
+            let (msg, nw) = crate::apps::chat::LayerEvent::from_message(
                 &base,
                 gid,
                 fid,
@@ -187,20 +192,13 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             )
             .await?;
             let event = crate::apps::chat::LayerEvent::Message(msg.hash, nw);
-
             let mut layer_lock = state.layer.write().await;
             let s = crate::apps::chat::event_message(&mut layer_lock, msg.id, gid, f.addr, &event);
             drop(layer_lock);
             results.layers.push((gid, f.gid, s));
+            crate::apps::chat::update_session(&base, &gid, &id, &msg, &mut results);
 
-            let s_db = session_db(&base, &gid)?;
-            if let Ok(id) = Session::last(&s_db, &fid, &SessionType::Chat, &msg.datetime, &sc, true)
-            {
-                results
-                    .rpcs
-                    .push(session_last(gid, &id, &msg.datetime, &sc, false));
-            }
-
+            // handle group member
             let avatar = read_avatar(&base, &gid, &f.gid).await.unwrap_or(vec![]);
             let event = Event::MemberJoin(f.gid, f.addr, f.name.clone(), avatar);
 

src/migrate/group.rs

@@ -6,8 +6,8 @@ pub(super) const GROUP_VERSIONS: [&str; 3] = [
     gcd TEXT NOT NULL,
     addr TEXT NOT NULL,
     name TEXT NOT NULL,
-    close INTEGER NOT NULL
-    local INTEGER NOT NULL);",
+    is_close INTEGER NOT NULL,
+    is_local INTEGER NOT NULL);",
   "CREATE TABLE IF NOT EXISTS members(
     id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
     height INTEGER NOT NULL,