Mountain/Track/Effect/CreateEffectForRequest/
Configuration.rs1#![allow(non_snake_case, unused_variables, dead_code, unused_imports)]
2
3use std::{future::Future, pin::Pin, sync::Arc};
4
5use CommonLibrary::{
6 Configuration::{
7 ConfigurationInspector::ConfigurationInspector,
8 ConfigurationProvider::ConfigurationProvider,
9 DTO::ConfigurationTarget::ConfigurationTarget,
10 },
11 Environment::Requires::Requires,
12 IPC::IPCProvider::IPCProvider as IPCProviderTrait,
13};
14use serde_json::{Value, json};
15use tauri::Runtime;
16
17use crate::{RunTime::ApplicationRunTime::ApplicationRunTime, Track::Effect::MappedEffectType::MappedEffect, dev_log};
18
19pub fn CreateEffect<R:Runtime>(MethodName:&str, Parameters:Value) -> Option<Result<MappedEffect, String>> {
20 match MethodName {
21 "config.get" => {
22 let effect =
23 move |run_time:Arc<ApplicationRunTime>| -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send>> {
24 Box::pin(async move {
25 let provider:Arc<dyn ConfigurationInspector> = run_time.Environment.Require();
26 let Key = if let Some(Object) = Parameters.as_object() {
27 Object.get("key").and_then(Value::as_str).unwrap_or("").to_string()
28 } else {
29 Parameters.get(0).and_then(Value::as_str).unwrap_or("").to_string()
30 };
31 let result = provider.InspectConfigurationValue(Key, Default::default()).await;
32 result
33 .map(|Inspection| serde_json::to_value(Inspection).unwrap_or(Value::Null))
34 .map_err(|e| e.to_string())
35 })
36 };
37 Some(Ok(Box::new(effect)))
38 },
39
40 "config.update" => {
41 let effect =
42 move |run_time:Arc<ApplicationRunTime>| -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send>> {
43 Box::pin(async move {
44 use tauri::Emitter;
45 let provider:Arc<dyn ConfigurationProvider> = run_time.Environment.Require();
46 let (Key, Value_, Target) = if let Some(Object) = Parameters.as_object() {
47 let K = Object.get("key").and_then(Value::as_str).unwrap_or("").to_string();
48 let V = Object.get("value").cloned().unwrap_or_default();
49 let T = match Object.get("target").and_then(Value::as_u64) {
50 Some(0) => ConfigurationTarget::User,
51 Some(1) => ConfigurationTarget::Workspace,
52 _ => ConfigurationTarget::User,
53 };
54 (K, V, T)
55 } else {
56 let K = Parameters.get(0).and_then(Value::as_str).unwrap_or("").to_string();
57 let V = Parameters.get(1).cloned().unwrap_or_default();
58 let T = match Parameters.get(2).and_then(Value::as_u64) {
59 Some(0) => ConfigurationTarget::User,
60 Some(1) => ConfigurationTarget::Workspace,
61 _ => ConfigurationTarget::User,
62 };
63 (K, V, T)
64 };
65 let KeyForEvents = Key.clone();
66 let result = provider
67 .UpdateConfigurationValue(Key, Value_, Target, Default::default(), None)
68 .await;
69 if result.is_ok() {
70 let Payload = json!({
71 "keys": [KeyForEvents.clone()],
72 "affected": [KeyForEvents.clone()],
73 });
74 let AppHandle = run_time.Environment.ApplicationHandle.clone();
75 let _ = AppHandle.emit("sky://configuration/changed", Payload.clone());
76 let IPCProvider:Arc<dyn IPCProviderTrait> = run_time.Environment.Require();
77 let _ = IPCProvider
78 .SendNotificationToSideCar(
79 "cocoon-main".to_string(),
80 "configuration.change".to_string(),
81 Payload,
82 )
83 .await;
84 }
85 result.map(|_| json!(null)).map_err(|e| e.to_string())
86 })
87 };
88 Some(Ok(Box::new(effect)))
89 },
90
91 "Configuration.Inspect" => {
92 let effect =
93 move |run_time:Arc<ApplicationRunTime>| -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send>> {
94 Box::pin(async move {
95 let provider:Arc<dyn ConfigurationInspector> = run_time.Environment.Require();
96 let section = Parameters.get(0).and_then(Value::as_str).unwrap_or("").to_string();
97 let result = provider.InspectConfigurationValue(section, Default::default()).await;
98 result
99 .map(|Inspection| serde_json::to_value(Inspection).unwrap_or(Value::Null))
100 .map_err(|e| e.to_string())
101 })
102 };
103 Some(Ok(Box::new(effect)))
104 },
105
106 "Configuration.Update" => {
107 let effect =
108 move |run_time:Arc<ApplicationRunTime>| -> Pin<Box<dyn Future<Output = Result<Value, String>> + Send>> {
109 Box::pin(async move {
110 use tauri::Emitter;
111 let provider:Arc<dyn ConfigurationProvider> = run_time.Environment.Require();
112 let key = Parameters.get(0).and_then(Value::as_str).unwrap_or("").to_string();
113 let value = Parameters.get(1).cloned().unwrap_or_default();
114 let target = match Parameters.get(2).and_then(Value::as_u64) {
115 Some(0) => ConfigurationTarget::User,
116 Some(1) => ConfigurationTarget::Workspace,
117 _ => ConfigurationTarget::User,
118 };
119 let KeyForEvents = key.clone();
120 let result = provider
121 .UpdateConfigurationValue(key, value, target, Default::default(), None)
122 .await;
123 if result.is_ok() {
124 let Payload = json!({
125 "keys": [KeyForEvents.clone()],
126 "affected": [KeyForEvents.clone()],
127 });
128 let AppHandle = run_time.Environment.ApplicationHandle.clone();
129 if let Err(Error) = AppHandle.emit("sky://configuration/changed", Payload.clone()) {
130 dev_log!(
131 "config",
132 "warn: [Configuration.Update] sky://configuration/changed emit failed: {}",
133 Error
134 );
135 }
136 let IPCProvider:Arc<dyn IPCProviderTrait> = run_time.Environment.Require();
137 if let Err(Error) = IPCProvider
138 .SendNotificationToSideCar(
139 "cocoon-main".to_string(),
140 "configuration.change".to_string(),
141 Payload,
142 )
143 .await
144 {
145 dev_log!(
146 "config",
147 "warn: [Configuration.Update] Cocoon configuration.change notification failed: {}",
148 Error
149 );
150 }
151 }
152 result.map(|_| json!(null)).map_err(|e| e.to_string())
153 })
154 };
155 Some(Ok(Box::new(effect)))
156 },
157
158 _ => None,
159 }
160}