reactive_graph_plugin_delegates/
relation_instance_manager_impl.rs

1use std::sync::Arc;
2
3use serde_json::Value;
4use uuid::Uuid;
5
6use reactive_graph_behaviour_model_api::BehaviourTypeId;
7use reactive_graph_graph::ComponentTypeId;
8use reactive_graph_graph::Mutability;
9use reactive_graph_graph::Namespace;
10use reactive_graph_graph::RelationInstance;
11use reactive_graph_graph::RelationInstanceId;
12use reactive_graph_graph::RelationTypeId;
13use reactive_graph_reactive_model_impl::ReactiveRelation;
14use reactive_graph_reactive_service_api::ReactiveRelationComponentAddError;
15use reactive_graph_reactive_service_api::ReactiveRelationComponentRemoveError;
16use reactive_graph_reactive_service_api::ReactiveRelationCreationError;
17use reactive_graph_reactive_service_api::ReactiveRelationManager;
18use reactive_graph_reactive_service_api::ReactiveRelationPropertyAddError;
19use reactive_graph_reactive_service_api::ReactiveRelationPropertyRemoveError;
20use reactive_graph_reactive_service_api::ReactiveRelationRegistrationError;
21use reactive_graph_type_system_api::ComponentManager;
22use reactive_graph_type_system_api::RelationTypeManager;
23
24pub struct RelationInstanceManagerDelegate {
25    component_manager: Arc<dyn ComponentManager + Send + Sync>,
26    relation_type_manager: Arc<dyn RelationTypeManager + Send + Sync>,
27    reactive_relation_manager: Arc<dyn ReactiveRelationManager + Send + Sync>,
28}
29
30impl RelationInstanceManagerDelegate {
31    pub fn new(
32        component_manager: Arc<dyn ComponentManager + Send + Sync>,
33        relation_type_manager: Arc<dyn RelationTypeManager + Send + Sync>,
34        reactive_relation_manager: Arc<dyn ReactiveRelationManager + Send + Sync>,
35    ) -> Self {
36        Self {
37            component_manager,
38            relation_type_manager,
39            reactive_relation_manager,
40        }
41    }
42}
43impl reactive_graph_plugin_api::RelationInstanceManager for RelationInstanceManagerDelegate {
44    fn has(&self, relation_instance_id: &RelationInstanceId) -> bool {
45        self.reactive_relation_manager.has(relation_instance_id)
46    }
47
48    fn get(&self, relation_instance_id: &RelationInstanceId) -> Option<ReactiveRelation> {
49        self.reactive_relation_manager.get(relation_instance_id)
50    }
51
52    fn get_by_outbound_entity(&self, outbound_entity_id: Uuid) -> Vec<ReactiveRelation> {
53        self.reactive_relation_manager.get_by_outbound_entity(outbound_entity_id)
54    }
55
56    fn get_by_inbound_entity(&self, inbound_entity_id: Uuid) -> Vec<ReactiveRelation> {
57        self.reactive_relation_manager.get_by_inbound_entity(inbound_entity_id)
58    }
59
60    fn get_all(&self) -> Vec<ReactiveRelation> {
61        self.reactive_relation_manager.get_all()
62    }
63
64    fn get_by_type(&self, ty: &RelationTypeId) -> Vec<ReactiveRelation> {
65        self.reactive_relation_manager.get_by_type(ty)
66    }
67
68    fn get_by_namespace(&self, namespace: &Namespace) -> Vec<ReactiveRelation> {
69        self.reactive_relation_manager.get_by_namespace(namespace)
70    }
71
72    fn get_keys(&self) -> Vec<RelationInstanceId> {
73        self.reactive_relation_manager.get_relation_instance_ids()
74    }
75
76    fn count(&self) -> usize {
77        self.reactive_relation_manager.count()
78    }
79
80    fn count_by_type(&self, ty: &RelationTypeId) -> usize {
81        self.reactive_relation_manager.count_by_type(ty)
82    }
83
84    fn count_by_component(&self, component: &ComponentTypeId) -> usize {
85        self.reactive_relation_manager.count_by_component(component)
86    }
87
88    fn count_by_behaviour(&self, behaviour_ty: &BehaviourTypeId) -> usize {
89        self.reactive_relation_manager.count_by_behaviour(behaviour_ty)
90    }
91
92    fn create(&self, relation_instance: RelationInstance) -> Result<ReactiveRelation, ReactiveRelationCreationError> {
93        let relation_ty = relation_instance.relation_type_id();
94        let relation_type = self.relation_type_manager.get(&relation_ty);
95        // let relation_type = self.relation_type_manager.get_starts_with(&relation_instance.ty);
96        match relation_type {
97            Some(relation_type) => {
98                let id = relation_instance.id();
99                if self.reactive_relation_manager.has(&id) {
100                    if let Some(reactive_relation_instance) = self.reactive_relation_manager.get(&id) {
101                        return Ok(reactive_relation_instance);
102                    }
103                }
104                let relation_instance = relation_instance;
105                // Add properties from relation type if not existing
106                for property in relation_type.properties.iter() {
107                    if !relation_instance.properties.contains_key(property.key()) {
108                        relation_instance.properties.insert(property.key().clone(), property.data_type.default_value());
109                    }
110                }
111                // Add properties from components if not existing
112                for component_ty in relation_type.components.iter() {
113                    if let Some(component) = self.component_manager.get(&component_ty) {
114                        for property in component.properties.iter() {
115                            if !relation_instance.properties.contains_key(property.key()) {
116                                relation_instance.properties.insert(property.key().clone(), property.data_type.default_value());
117                            }
118                        }
119                    }
120                }
121                self.reactive_relation_manager.create_reactive_instance(relation_instance)
122            }
123            None => Err(ReactiveRelationCreationError::UnknownRelationType(relation_ty.clone())),
124        }
125    }
126
127    fn register(&self, reactive_relation: ReactiveRelation) -> Result<ReactiveRelation, ReactiveRelationRegistrationError> {
128        self.reactive_relation_manager.register_reactive_instance(reactive_relation)
129    }
130
131    fn add_component(&self, relation_instance_id: &RelationInstanceId, component: &ComponentTypeId) -> Result<(), ReactiveRelationComponentAddError> {
132        self.reactive_relation_manager.add_component(relation_instance_id, component)
133    }
134
135    fn remove_component(&self, relation_instance_id: &RelationInstanceId, component: &ComponentTypeId) -> Result<(), ReactiveRelationComponentRemoveError> {
136        self.reactive_relation_manager.remove_component(relation_instance_id, component)
137    }
138
139    fn add_property(
140        &self,
141        relation_instance_id: &RelationInstanceId,
142        property_name: &str,
143        mutability: Mutability,
144        value: Value,
145    ) -> Result<(), ReactiveRelationPropertyAddError> {
146        self.reactive_relation_manager
147            .add_property(relation_instance_id, property_name, mutability, value)
148    }
149
150    fn remove_property(&self, relation_instance_id: &RelationInstanceId, property_name: &str) -> Result<(), ReactiveRelationPropertyRemoveError> {
151        self.reactive_relation_manager.remove_property(relation_instance_id, property_name)
152    }
153
154    fn delete(&self, id: &RelationInstanceId) -> bool {
155        self.reactive_relation_manager.delete(id)
156    }
157}