From d77c2a9d121710b725b9ad54967921e92d283e4a Mon Sep 17 00:00:00 2001 From: Adrien Date: Wed, 15 May 2024 19:07:46 +0200 Subject: [PATCH] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20=20Use=20of=20Store=20inte?= =?UTF-8?q?rfaces?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/domain/model/account.rs | 12 ++++-- src/domain/model/room.rs | 14 +++++++ src/domain/model/space.rs | 12 +++++- src/domain/model/store_interface.rs | 37 ++++++++++++++--- src/ui/store/mod.rs | 42 +++++++++---------- src/ui/store/room.rs | 62 ++++++++++++++++++++++++++--- src/ui/store/space.rs | 42 +++++++++++++++---- 7 files changed, 178 insertions(+), 43 deletions(-) diff --git a/src/domain/model/account.rs b/src/domain/model/account.rs index c1b81f5..18e083a 100644 --- a/src/domain/model/account.rs +++ b/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>; @@ -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); 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); space.set_store(space_store); diff --git a/src/domain/model/room.rs b/src/domain/model/room.rs index bd16e76..53d757d 100644 --- a/src/domain/model/room.rs +++ b/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 { + self.is_direct + } + + fn name(&self) -> Option { + self.name.borrow().clone() + } +} diff --git a/src/domain/model/space.rs b/src/domain/model/space.rs index 3c8a4c1..b269c61 100644 --- a/src/domain/model/space.rs +++ b/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 { + self.name.borrow().clone() + } +} diff --git a/src/domain/model/store_interface.rs b/src/domain/model/store_interface.rs index 856d4b4..520f700 100644 --- a/src/domain/model/store_interface.rs +++ b/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) -> Rc; - fn on_new_space(&self, space: Rc) -> Rc; + fn on_new_room( + &self, + room: Rc, + ) -> Rc; + fn on_new_space( + &self, + space: Rc, + ) -> Rc; } #[allow(dead_code)] -pub trait RoomStoreConsumerInterface {} -pub trait RoomStoreProviderInterface {} +pub trait RoomStoreConsumerInterface { + fn id(&self) -> &RoomId; + + fn is_direct(&self) -> Option; + fn name(&self) -> Option; +} + +pub trait RoomStoreProviderInterface { + fn on_new_member(&self, member: RoomMember); + fn on_new_name(&self, name: Option); + fn on_invitation(&self, invitation: Invitation); +} #[allow(dead_code)] -pub trait SpaceStoreConsumerInterface {} +pub trait SpaceStoreConsumerInterface { + fn id(&self) -> &SpaceId; + + fn name(&self) -> Option; +} + pub trait SpaceStoreProviderInterface { fn set_name(&self, _name: Option) {} } diff --git a/src/ui/store/mod.rs b/src/ui/store/mod.rs index 5771d96..0343ee4 100644 --- a/src/ui/store/mod.rs +++ b/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, - spaces: HashMap, + rooms: HashMap>, + spaces: HashMap>, } #[async_trait(?Send)] impl AccountStoreProviderInterface for GlobalSignal { - fn on_new_room(&self, domain_room: Rc) -> Rc { + fn on_new_room( + &self, + domain_room: Rc, + ) -> Rc { 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) -> Rc { + fn on_new_space( + &self, + domain_space: Rc, + ) -> Rc { 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 } } diff --git a/src/ui/store/room.rs b/src/ui/store/room.rs index 40bad22..a1c1396 100644 --- a/src/ui/store/room.rs +++ b/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, name: Option, + members: Vec, + invitations: Vec, + is_invited: bool, +} + +#[derive(Clone)] +pub struct Room { + store: RefCell, + domain: Rc, +} + +impl Room { + pub fn signal(&self) -> Store { + self.store.borrow().clone() + } + + pub fn from_domain(room: Rc) -> 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) { + 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); + } +} diff --git a/src/ui/store/space.rs b/src/ui/store/space.rs index 8ebaeb8..4bb7897 100644 --- a/src/ui/store/space.rs +++ b/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, } -impl PartialEq for Space { - fn eq(&self, other: &Self) -> bool { - self.id == other.id +#[derive(Clone)] +pub struct Space { + store: RefCell, + domain: Rc, +} + +impl Space { + pub fn signal(&self) -> Store { + self.store.borrow().clone() + } + + pub fn from_domain(space: Rc) -> Self { + let props = StoreProps::new(space.id().clone(), space.name()); + + Self { + store: RefCell::new(Store::new(props)), + domain: space, + } } } -impl SpaceStoreProviderInterface for RefCell { - fn set_name(&self, name: Option) { - 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) { + let mut store = self.store.borrow_mut(); + store.name.set(name); } }