reactive_graph/client/instances/relations/
mod.rs

1use crate::client::error::CommandError;
2use crate::client::error::CommandError::NoContent;
3use crate::client::error::CommandError::NotFound;
4use crate::client::instances::properties::output_format::PropertyInstancesOutputFormatWrapper;
5use crate::client::instances::relations::args::RelationInstancesArgs;
6use crate::client::instances::relations::commands::RelationInstancesCommands;
7use crate::client::instances::relations::output_format::RelationInstancesOutputFormatWrapper;
8use crate::client::result::CommandResult;
9use crate::client::types::components::output_format::ComponentTypeIdsOutputFormatWrapper;
10use reactive_graph_client::ReactiveGraphClient;
11use reactive_graph_graph::ComponentTypeId;
12use reactive_graph_graph::PropertyInstanceGetter;
13use reactive_graph_table_model::instances::properties::PropertyInstance;
14use std::sync::Arc;
15
16pub(crate) mod args;
17pub(crate) mod commands;
18pub(crate) mod output_format;
19
20pub(crate) async fn relation_instances(client: &Arc<ReactiveGraphClient>, relation_instances_args: RelationInstancesArgs) -> CommandResult {
21    let output_format_wrapper: RelationInstancesOutputFormatWrapper = relation_instances_args.output_format.clone().into();
22    let Some(command) = relation_instances_args.commands else {
23        return Err(CommandError::MissingSubCommand);
24    };
25    match command {
26        RelationInstancesCommands::List(args) => match client.instances().relations().search((&args).into()).await {
27            Ok(Some(relation_instances)) => output_format_wrapper.collection(relation_instances.to_vec()),
28            Ok(None) => Err(NoContent("No relation instances found".to_string())),
29            Err(e) => Err(e.into()),
30        },
31        RelationInstancesCommands::Get(args) => match client.instances().relations().get_by_id(&args).await {
32            Ok(Some(relation_instance)) => output_format_wrapper.single(relation_instance),
33            Ok(None) => Err(args.not_found()),
34            Err(e) => Err(e.into()),
35        },
36        RelationInstancesCommands::ListProperties(args) => match client.instances().relations().get_by_id(&args).await {
37            Ok(Some(relation_instance)) => {
38                let output_format_wrapper: PropertyInstancesOutputFormatWrapper = relation_instances_args.output_format.into();
39                let property_instances = relation_instance
40                    .properties
41                    .iter()
42                    .map(|property_instance| PropertyInstance::new(property_instance.key().clone(), property_instance.value().clone()))
43                    .collect();
44                output_format_wrapper.collection(property_instances)
45            }
46            Ok(None) => Err(args.not_found()),
47            Err(e) => Err(e.into()),
48        },
49        RelationInstancesCommands::GetProperty(args) => match client.instances().relations().get_by_id(&args).await {
50            Ok(Some(relation_instance)) => Ok(relation_instance.get(&args.property_name).ok_or(args.property_not_found())?.into()),
51            Ok(None) => Err(args.not_found()),
52            Err(e) => Err(e.into()),
53        },
54        RelationInstancesCommands::SetProperty(args) => match client
55            .instances()
56            .relations()
57            .set_property(&args.id, &args.property_instance.property_name, args.property_instance.property_value.clone())
58            .await
59        {
60            Ok(Some(relation_instance)) => Ok(relation_instance
61                .get(&args.property_instance.property_name)
62                .ok_or(args.property_not_found())?
63                .into()),
64            Ok(None) => Err(args.not_found()),
65            Err(e) => Err(e.into()),
66        },
67        RelationInstancesCommands::AddProperty(args) => match client.instances().relations().add_property(&args.id, &args.property_type).await {
68            Ok(Some(relation_instance)) => output_format_wrapper.single(relation_instance),
69            Ok(None) => Err(args.id_not_found()),
70            Err(e) => Err(e.into()),
71        },
72        RelationInstancesCommands::RemoveProperty(args) => match client.instances().relations().remove_property(&args.id, args.property_name.clone()).await {
73            Ok(Some(relation_instance)) => output_format_wrapper.single(relation_instance),
74            Ok(None) => Err(args.not_found()),
75            Err(e) => Err(e.into()),
76        },
77        RelationInstancesCommands::ListComponents(args) => match client.instances().relations().get_by_id(&args).await {
78            Ok(Some(relation_instance)) => {
79                let output_format_wrapper: ComponentTypeIdsOutputFormatWrapper = relation_instances_args.output_format.into();
80                let component_tys = relation_instance.components.iter().map(|ty| ty.clone()).collect();
81                output_format_wrapper.collection(component_tys)
82            }
83            Ok(None) => Err(args.not_found()),
84            Err(e) => Err(e.into()),
85        },
86        RelationInstancesCommands::AddComponent(args) => {
87            let component_ty: ComponentTypeId = args.component_ty.clone().into();
88            match client.instances().relations().add_component(&args, component_ty).await {
89                Ok(Some(relation_instance)) => output_format_wrapper.single(relation_instance),
90                Ok(None) => Err(args.not_found()),
91                Err(e) => Err(e.into()),
92            }
93        }
94        RelationInstancesCommands::RemoveComponent(args) => {
95            let component_ty: ComponentTypeId = args.component_ty.clone().into();
96            match client.instances().relations().remove_component(&args, component_ty).await {
97                Ok(Some(relation_instance)) => output_format_wrapper.single(relation_instance),
98                Ok(None) => Err(args.not_found()),
99                Err(e) => Err(e.into()),
100            }
101        }
102        RelationInstancesCommands::Create(args) => match client
103            .instances()
104            .relations()
105            .create(&args.id, args.description.clone(), args.properties())
106            .await
107        {
108            Ok(Some(relation_instance)) => output_format_wrapper.single(relation_instance),
109            Ok(None) => Err(NoContent("Relation instance not created".to_string())),
110            Err(e) => Err(e.into()),
111        },
112        RelationInstancesCommands::Delete(args) => match client.instances().relations().delete(&args).await {
113            Ok(Some(true)) => Ok(format!("Relation instance {} deleted", &args).into()),
114            Ok(Some(false)) => Ok(format!("Relation instance {} not deleted", &args).into()),
115            Ok(None) => Err(args.not_found()),
116            Err(e) => Err(e.into()),
117        },
118        RelationInstancesCommands::JsonSchema => match client.json_schema().instances().relations().await {
119            Ok(Some(json_schema)) => Ok(json_schema.into()),
120            Ok(None) => Err(NotFound("JSON Schema not available".to_string())),
121            Err(e) => Err(e.into()),
122        },
123    }
124}