♻️ Use of Store interfaces

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);
     }
 }