wx_rust_open/api/impl/
wx_open_ma_embedded_service_impl.rs1use std::sync::{Arc, Weak};
16
17use async_trait::async_trait;
18
19use wx_rust_common::error::WxErrorException;
20use wx_rust_miniapp::api::WxMaService;
21
22use crate::api::WxOpenMaEmbeddedService;
23use crate::api::WxOpenService;
24use crate::api::r#impl::WxOpenMaService;
25use crate::api::r#impl::base_wx_open_service_impl;
26use crate::bean::WxOpenMaEmbeddedListResult;
27use crate::enums::url_ma_domain::{
28 ma_embedded_add_url, ma_embedded_del_authorize_url, ma_embedded_del_url,
29 ma_embedded_get_list_url, ma_embedded_get_own_list_url, ma_embedded_set_authorize_url,
30};
31
32pub struct WxOpenMaEmbeddedServiceImpl {
34 wx_open_service: Weak<dyn WxOpenService>,
35 app_id: String,
36}
37
38impl WxOpenMaEmbeddedServiceImpl {
39 pub fn new(wx_open_service: Arc<dyn WxOpenService>, app_id: String) -> Self {
42 Self {
43 wx_open_service: Arc::downgrade(&wx_open_service),
44 app_id,
45 }
46 }
47
48 pub fn app_id(&self) -> &str {
50 &self.app_id
51 }
52
53 fn svc(&self) -> Result<Arc<dyn WxOpenService>, WxErrorException> {
54 self.wx_open_service
55 .upgrade()
56 .ok_or_else(|| WxErrorException::from_code(-99, "门面服务已被释放"))
57 }
58
59 fn ma_service(&self) -> Result<Arc<dyn WxMaService>, WxErrorException> {
62 let svc = self.svc()?;
63 let component = svc.wx_open_component_service().ok_or_else(|| {
64 WxErrorException::from_code(
65 -99,
66 "组件子服务未装配(getWxOpenComponentService 返回 null)",
67 )
68 })?;
69 let any = component
70 .get_wx_ma_service_by_appid(&self.app_id)
71 .ok_or_else(|| WxErrorException::from_code(-99, "getWxMaServiceByAppid 返回 None"))?;
72 let ma = any.downcast::<WxOpenMaService>().map_err(|_| {
73 WxErrorException::from_code(-99, "代 ma 服务 downcast 失败(缓存类型不匹配)")
74 })?;
75 Ok(ma as Arc<dyn WxMaService>)
76 }
77}
78
79#[async_trait]
80impl WxOpenMaEmbeddedService for WxOpenMaEmbeddedServiceImpl {
81 async fn add_embedded(
85 &self,
86 embedded_app_id: &str,
87 apply_reason: &str,
88 ) -> Result<(), WxErrorException> {
89 let svc = self.svc()?;
90 let config = svc.wx_open_config_storage();
91 let ma = self.ma_service()?;
92 let mut body = serde_json::json!({ "appid": embedded_app_id });
93 if !apply_reason.trim().is_empty() {
94 body["apply_reason"] = serde_json::Value::String(apply_reason.to_string());
95 }
96 ma.post(&ma_embedded_add_url(config.as_ref()), &body.to_string())
97 .await?;
98 Ok(())
99 }
100
101 async fn delete_embedded(&self, embedded_app_id: &str) -> Result<(), WxErrorException> {
104 let svc = self.svc()?;
105 let config = svc.wx_open_config_storage();
106 let ma = self.ma_service()?;
107 let body = serde_json::json!({ "appid": embedded_app_id });
108 ma.post(&ma_embedded_del_url(config.as_ref()), &body.to_string())
109 .await?;
110 Ok(())
111 }
112
113 async fn get_embedded_list(&self) -> Result<WxOpenMaEmbeddedListResult, WxErrorException> {
116 let svc = self.svc()?;
117 let config = svc.wx_open_config_storage();
118 let ma = self.ma_service()?;
119 let response = ma
120 .get(&ma_embedded_get_list_url(config.as_ref()), "")
121 .await?;
122 let response = base_wx_open_service_impl::normalize_errcode(&response)?;
125 serde_json::from_str(&response).map_err(|e| WxErrorException::Serde(e.to_string()))
126 }
127
128 async fn delete_authorized_embedded(
131 &self,
132 embedded_app_id: &str,
133 ) -> Result<(), WxErrorException> {
134 let svc = self.svc()?;
135 let config = svc.wx_open_config_storage();
136 let ma = self.ma_service()?;
137 let body = serde_json::json!({ "appid": embedded_app_id });
138 ma.post(
139 &ma_embedded_del_authorize_url(config.as_ref()),
140 &body.to_string(),
141 )
142 .await?;
143 Ok(())
144 }
145
146 async fn get_own_list(&self) -> Result<WxOpenMaEmbeddedListResult, WxErrorException> {
149 let svc = self.svc()?;
150 let config = svc.wx_open_config_storage();
151 let ma = self.ma_service()?;
152 let url = format!("{}?num=1000", ma_embedded_get_own_list_url(config.as_ref()));
153 let response = ma.get(&url, "").await?;
154 let response = base_wx_open_service_impl::normalize_errcode(&response)?;
157 serde_json::from_str(&response).map_err(|e| WxErrorException::Serde(e.to_string()))
158 }
159
160 async fn get_own_list_with(
164 &self,
165 start: Option<i32>,
166 num: Option<i32>,
167 ) -> Result<WxOpenMaEmbeddedListResult, WxErrorException> {
168 let start = start.unwrap_or(0);
169 let num = num.unwrap_or(10).min(1000);
170 let svc = self.svc()?;
171 let config = svc.wx_open_config_storage();
172 let ma = self.ma_service()?;
173 let url = format!(
174 "{}?start={start}&num={num}",
175 ma_embedded_get_own_list_url(config.as_ref())
176 );
177 let response = ma.get(&url, "").await?;
178 let response = base_wx_open_service_impl::normalize_errcode(&response)?;
181 serde_json::from_str(&response).map_err(|e| WxErrorException::Serde(e.to_string()))
182 }
183
184 async fn set_authorized_embedded(&self, flag: i32) -> Result<(), WxErrorException> {
187 let svc = self.svc()?;
188 let config = svc.wx_open_config_storage();
189 let ma = self.ma_service()?;
190 let body = serde_json::json!({ "flag": flag });
191 ma.post(
192 &ma_embedded_set_authorize_url(config.as_ref()),
193 &body.to_string(),
194 )
195 .await?;
196 Ok(())
197 }
198}