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