♻️ Use of Store interfaces

src/domain/model/account.rs

@@ -11,7 +11,9 @@ use super::{
     },
     room::{Room, RoomId},
     space::{Space, SpaceId},
-    store_interface::AccountStoreProviderInterface,
+    store_interface::{
+        AccountStoreProviderInterface, RoomStoreConsumerInterface, SpaceStoreConsumerInterface,
+    },
 };
 
 type Rooms = HashMap<RoomId, Rc<Room>>;
@@ -100,7 +102,9 @@ impl AccountMessagingConsumerInterface for Account {
             .borrow_mut()
             .insert(room_id, Rc::clone(&room));
 
-        let room_store = self.store.on_new_room(Rc::clone(&room));
+        let room_store = self
+            .store
+            .on_new_room(Rc::clone(&room) as Rc<dyn RoomStoreConsumerInterface>);
 
         room.set_store(room_store);
 
@@ -114,7 +118,9 @@ impl AccountMessagingConsumerInterface for Account {
             .borrow_mut()
             .insert(space_id, Rc::clone(&space));
 
-        let space_store = self.store.on_new_space(Rc::clone(&space));
+        let space_store = self
+            .store
+            .on_new_space(Rc::clone(&space) as Rc<dyn SpaceStoreConsumerInterface>);
 
         space.set_store(space_store);
 

src/domain/model/room.rs

@@ -207,3 +207,17 @@ impl RoomMessagingConsumerInterface for Room {
         trace!("Room::on_new_name({:?})", name);
     }
 }
+
+impl RoomStoreConsumerInterface for Room {
+    fn id(&self) -> &RoomId {
+        &self.id
+    }
+
+    fn is_direct(&self) -> Option<bool> {
+        self.is_direct
+    }
+
+    fn name(&self) -> Option<String> {
+        self.name.borrow().clone()
+    }
+}

src/domain/model/space.rs

@@ -8,7 +8,7 @@ use super::{
     common::Avatar,
     messaging_interface::{SpaceMessagingConsumerInterface, SpaceMessagingProviderInterface},
     room::RoomId,
-    store_interface::SpaceStoreProviderInterface,
+    store_interface::{SpaceStoreConsumerInterface, SpaceStoreProviderInterface},
 };
 
 pub type SpaceId = OwnedRoomId;
@@ -89,3 +89,13 @@ impl SpaceMessagingConsumerInterface for Space {
         }
     }
 }
+
+impl SpaceStoreConsumerInterface for Space {
+    fn id(&self) -> &SpaceId {
+        &self.id
+    }
+
+    fn name(&self) -> Option<String> {
+        self.name.borrow().clone()
+    }
+}

src/domain/model/store_interface.rs

@@ -1,21 +1,46 @@
 use std::rc::Rc;
 
-use super::{room::Room, space::Space};
+use super::{
+    room::{Invitation, RoomId},
+    room_member::RoomMember,
+    space::SpaceId,
+};
 
 #[allow(dead_code)]
 pub trait AccountStoreConsumerInterface {}
 
 pub trait AccountStoreProviderInterface {
-    fn on_new_room(&self, room: Rc<Room>) -> Rc<dyn RoomStoreProviderInterface>;
-    fn on_new_space(&self, space: Rc<Space>) -> Rc<dyn SpaceStoreProviderInterface>;
+    fn on_new_room(
+        &self,
+        room: Rc<dyn RoomStoreConsumerInterface>,
+    ) -> Rc<dyn RoomStoreProviderInterface>;
+    fn on_new_space(
+        &self,
+        space: Rc<dyn SpaceStoreConsumerInterface>,
+    ) -> Rc<dyn SpaceStoreProviderInterface>;
 }
 
 #[allow(dead_code)]
-pub trait RoomStoreConsumerInterface {}
-pub trait RoomStoreProviderInterface {}
+pub trait RoomStoreConsumerInterface {
+    fn id(&self) -> &RoomId;
+
+    fn is_direct(&self) -> Option<bool>;
+    fn name(&self) -> Option<String>;
+}
+
+pub trait RoomStoreProviderInterface {
+    fn on_new_member(&self, member: RoomMember);
+    fn on_new_name(&self, name: Option<String>);
+    fn on_invitation(&self, invitation: Invitation);
+}
 
 #[allow(dead_code)]
-pub trait SpaceStoreConsumerInterface {}
+pub trait SpaceStoreConsumerInterface {
+    fn id(&self) -> &SpaceId;
+
+    fn name(&self) -> Option<String>;
+}
+
 pub trait SpaceStoreProviderInterface {
     fn set_name(&self, _name: Option<String>) {}
 }

src/ui/store/mod.rs

@@ -1,50 +1,52 @@
 pub(crate) mod room;
 pub(crate) mod space;
 
-use std::cell::RefCell;
 use std::{collections::HashMap, rc::Rc};
 
 use async_trait::async_trait;
 use dioxus::prelude::*;
 
-use crate::domain::model::room::{Room as DomainRoom, RoomId};
-use crate::domain::model::space::{Space as DomainSpace, SpaceId};
+use crate::domain::model::room::RoomId;
+use crate::domain::model::space::SpaceId;
 use crate::domain::model::store_interface::{
-    AccountStoreProviderInterface, RoomStoreProviderInterface, SpaceStoreProviderInterface,
+    AccountStoreProviderInterface, RoomStoreConsumerInterface, RoomStoreProviderInterface,
+    SpaceStoreConsumerInterface, SpaceStoreProviderInterface,
 };
 
-use room::{Room, RoomProps};
-use space::{Space, SpaceProps};
+use room::Room;
+use space::Space;
 
 #[modx::store]
 pub struct Store {
-    rooms: HashMap<RoomId, Room>,
-    spaces: HashMap<SpaceId, Space>,
+    rooms: HashMap<RoomId, Rc<Room>>,
+    spaces: HashMap<SpaceId, Rc<Space>>,
 }
 
 #[async_trait(?Send)]
 impl AccountStoreProviderInterface for GlobalSignal<Store> {
-    fn on_new_room(&self, domain_room: Rc<DomainRoom>) -> Rc<dyn RoomStoreProviderInterface> {
+    fn on_new_room(
+        &self,
+        domain_room: Rc<dyn RoomStoreConsumerInterface>,
+    ) -> Rc<dyn RoomStoreProviderInterface> {
         let room_id = domain_room.id();
-
-        let props = RoomProps::new(room_id.clone(), domain_room.name());
-        let room = Room::new(props);
+        let room = Rc::new(Room::from_domain(Rc::clone(&domain_room)));
 
         let mut rooms = self.read().rooms;
-        rooms.write().insert(room_id.clone(), room);
+        rooms.write().insert(room_id.clone(), Rc::clone(&room));
 
-        Rc::new(room.clone())
+        room
     }
 
-    fn on_new_space(&self, domain_space: Rc<DomainSpace>) -> Rc<dyn SpaceStoreProviderInterface> {
+    fn on_new_space(
+        &self,
+        domain_space: Rc<dyn SpaceStoreConsumerInterface>,
+    ) -> Rc<dyn SpaceStoreProviderInterface> {
         let space_id = domain_space.id();
-
-        let props = SpaceProps::new(space_id.clone(), domain_space.name());
-        let space = Space::new(props);
+        let space = Rc::new(Space::from_domain(Rc::clone(&domain_space)));
 
         let mut spaces = self.read().spaces;
-        spaces.write().insert(space_id.clone(), space);
+        spaces.write().insert(space_id.clone(), Rc::clone(&space));
 
-        Rc::new(RefCell::new(space.clone()))
+        space
     }
 }

src/ui/store/room.rs

@@ -1,21 +1,73 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
 use dioxus::prelude::*;
 
+use crate::domain::model::room::Invitation;
 use crate::domain::model::{
-    room::RoomId, room_member::RoomMember, store_interface::RoomStoreProviderInterface,
+    room::RoomId,
+    room_member::RoomMember,
+    store_interface::{RoomStoreConsumerInterface, RoomStoreProviderInterface},
 };
 
-#[modx::props(id, name)]
+#[modx::props(id, is_direct, name)]
 #[modx::store]
-pub struct Room {
+pub struct Store {
     id: RoomId,
+
+    is_direct: Option<bool>,
     name: Option<String>,
+
     members: Vec<RoomMember>,
+    invitations: Vec<Invitation>,
+    is_invited: bool,
+}
+
+#[derive(Clone)]
+pub struct Room {
+    store: RefCell<Store>,
+    domain: Rc<dyn RoomStoreConsumerInterface>,
+}
+
+impl Room {
+    pub fn signal(&self) -> Store {
+        self.store.borrow().clone()
+    }
+
+    pub fn from_domain(room: Rc<dyn RoomStoreConsumerInterface>) -> Self {
+        let props = StoreProps::new(room.id().clone(), room.is_direct(), room.name());
+
+        Self {
+            store: RefCell::new(Store::new(props)),
+            domain: room,
+        }
+    }
 }
 
 impl PartialEq for Room {
     fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
+        self.store.borrow().id == other.store.borrow().id
     }
 }
 
-impl RoomStoreProviderInterface for Room {}
+impl RoomStoreProviderInterface for Room {
+    fn on_new_member(&self, member: RoomMember) {
+        let mut store = self.store.borrow_mut();
+        store.members.write().push(member);
+    }
+
+    fn on_new_name(&self, name: Option<String>) {
+        let mut store = self.store.borrow_mut();
+        store.name.set(name);
+    }
+
+    fn on_invitation(&self, invitation: Invitation) {
+        let mut store = self.store.borrow_mut();
+
+        if !store.is_invited() && invitation.is_account_user() {
+            store.is_invited.set(true);
+        }
+
+        store.invitations.write().push(invitation);
+    }
+}

src/ui/store/space.rs

@@ -1,24 +1,50 @@
 use std::cell::RefCell;
+use std::rc::Rc;
 
 use dioxus::prelude::*;
 
-use crate::domain::model::{space::SpaceId, store_interface::SpaceStoreProviderInterface};
+use crate::domain::model::{
+    space::SpaceId,
+    store_interface::{SpaceStoreConsumerInterface, SpaceStoreProviderInterface},
+};
 
 #[modx::props(id, name)]
 #[modx::store]
-pub struct Space {
+pub struct Store {
     id: SpaceId,
     name: Option<String>,
 }
 
-impl PartialEq for Space {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
+#[derive(Clone)]
+pub struct Space {
+    store: RefCell<Store>,
+    domain: Rc<dyn SpaceStoreConsumerInterface>,
+}
+
+impl Space {
+    pub fn signal(&self) -> Store {
+        self.store.borrow().clone()
+    }
+
+    pub fn from_domain(space: Rc<dyn SpaceStoreConsumerInterface>) -> Self {
+        let props = StoreProps::new(space.id().clone(), space.name());
+
+        Self {
+            store: RefCell::new(Store::new(props)),
+            domain: space,
+        }
     }
 }
 
-impl SpaceStoreProviderInterface for RefCell<Space> {
-    fn set_name(&self, name: Option<String>) {
-        self.borrow_mut().name.set(name);
+impl PartialEq for Space {
+    fn eq(&self, other: &Self) -> bool {
+        self.store.borrow().id == other.store.borrow().id
+    }
+}
+
+impl SpaceStoreProviderInterface for Space {
+    fn set_name(&self, name: Option<String>) {
+        let mut store = self.store.borrow_mut();
+        store.name.set(name);
     }
 }