reach: use default module, add reach log

Author: 4t145

basic/src/rbum/dto/rbum_item_dto.rs

@@ -27,6 +27,19 @@ pub struct RbumItemAddReq {
     pub disabled: Option<bool>,
 }
 
+impl Default for RbumItemAddReq {
+    fn default() -> Self {
+        Self {
+            id: Default::default(),
+            code: Default::default(),
+            name: TrimString::from(""),
+            rel_rbum_kind_id: Default::default(),
+            rel_rbum_domain_id: Default::default(),
+            scope_level: Default::default(),
+            disabled: Default::default(),
+        }
+    }
+}
 /// For security reasons, this object cannot be used as an input to the API
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(default)]

services/bios-all/src/initializer.rs

@@ -11,7 +11,7 @@ pub async fn init(web_server: &TardisWebServer) -> TardisResult<()> {
         web_server,
         SendChannelMap::new()
             .with_arc_channel(bios_client_hwsms::SmsClient::from_reach_config())
-            .with_arc_channel(Arc::new(tardis::TardisFuns::mail_by_module(bios_reach::reach_consts::MODULE_CODE))),
+            .with_arc_channel(Arc::new(tardis::TardisFuns::mail_by_module_or_default(bios_reach::reach_consts::MODULE_CODE))),
     )
     .await?;
 

support/reach/src/serv/message_send.rs

@@ -2,12 +2,12 @@ use std::collections::{HashMap, HashSet};
 
 use bios_basic::rbum::{dto::rbum_item_dto::RbumItemAddReq, serv::rbum_crud_serv::RbumCrudOperation};
 use tardis::{
-    basic::{result::TardisResult, dto::TardisContext},
+    basic::{dto::TardisContext, result::TardisResult},
     db::sea_orm::{sea_query::Query, ColumnTrait, Iterable},
     TardisFunsInst,
 };
 
-use crate::{reach_consts::*, domain, dto::*, serv::*};
+use crate::{domain, dto::*, reach_consts::*, serv::*};
 
 pub async fn message_send(send_req: ReachMsgSendReq, funs: &TardisFunsInst, ctx: &TardisContext) -> TardisResult<()> {
     let err = |msg: &str| funs.err().not_found("reach", "event_listener", msg, "");
@@ -54,11 +54,11 @@ pub async fn message_send(send_req: ReachMsgSendReq, funs: &TardisFunsInst, ctx:
         map.entry(item.receive_group_code.clone()).or_default().push(item);
         map
     });
-
-    let mut instance_group_code = instances.into_iter().filter(|inst| receive_group_code.contains_key(&inst.receive_group_code.clone())).fold(HashMap::<String, Vec<_>>::new(), |mut map, item| {
-        map.entry(item.receive_group_code.clone()).or_default().push(item);
-        map
-    });
+    let mut instance_group_code =
+        instances.into_iter().filter(|inst| receive_group_code.contains_key(&inst.receive_group_code.clone())).fold(HashMap::<String, Vec<_>>::new(), |mut map, item| {
+            map.entry(item.receive_group_code.clone()).or_default().push(item);
+            map
+        });
 
     if instance_group_code.is_empty() {
         return Ok(());

support/reach/src/task/message_send_listener.rs

@@ -1,10 +1,11 @@
 use std::{collections::HashSet, sync::Arc};
 
-use crate::{reach_send_channel::*, reach_config::ReachConfig, reach_consts::*, domain::*, dto::*, reach_init::get_reach_send_channel_map, serv::*};
-use bios_basic::rbum::helper::rbum_scope_helper;
+use crate::{domain::*, dto::*, reach_config::ReachConfig, reach_consts::*, reach_init::get_reach_send_channel_map, reach_send_channel::*, serv::*};
+use bios_basic::rbum::{helper::rbum_scope_helper, serv::rbum_crud_serv::RbumCrudOperation};
 use bios_sdk_invoke::clients::iam_client::IamClient;
 use tardis::{
     basic::{dto::TardisContext, result::TardisResult},
+    chrono::Utc,
     db::sea_orm::{sea_query::Query, *},
     log, tokio, TardisFunsInst,
 };
@@ -28,6 +29,7 @@ impl Default for MessageSendListener {
 
 impl MessageSendListener {
     async fn execute_send_account(&self, message: message::Model, template: message_template::Model) -> TardisResult<()> {
+        let content_replace: ContentReplace = message.content_replace.parse()?;
         let cfg = self.funs.conf::<ReachConfig>();
         let _lock = self.sync.lock().await;
         let ctx = TardisContext {
@@ -44,7 +46,7 @@ impl MessageSendListener {
             return Ok(());
         }
         let mut to = HashSet::new();
-
+        let start_time = Utc::now();
         let owner_path = rbum_scope_helper::get_pre_paths(RBUM_SCOPE_LEVEL_TENANT as i16, &message.own_paths).unwrap_or_default();
         for account_id in message.to_res_ids.split(ACCOUNT_SPLIT) {
             if let Ok(mut resp) = iam_client.get_account(account_id, &owner_path).await {
@@ -55,12 +57,47 @@ impl MessageSendListener {
                 to.insert(phone);
             }
         }
-        match self.channel.send(message.rel_reach_channel, &template, &message.content_replace.parse()?, &to).await {
+        match self.channel.send(message.rel_reach_channel, &template, &content_replace, &to).await {
             Ok(_) => {
                 ReachMessageServ::update_status(&message.id, ReachStatusKind::Sending, ReachStatusKind::SendSuccess, &self.funs, &ctx).await?;
+                for rel_account_id in to {
+                    ReachMessageLogServ::add_rbum(
+                        &mut ReachMsgLogAddReq {
+                            rbum_add_req: Default::default(),
+                            dnd_time: Default::default(),
+                            rel_account_id,
+                            dnd_strategy: ReachDndStrategyKind::Ignore,
+                            start_time,
+                            end_time: Utc::now(),
+                            failure: false,
+                            fail_message: Default::default(),
+                            rel_reach_message_id: message.id.clone(),
+                        },
+                        &self.funs,
+                        &ctx,
+                    ).await?;
+                }
             }
             Err(e) => {
                 ReachMessageServ::update_status(&message.id, ReachStatusKind::Sending, ReachStatusKind::Fail, &self.funs, &ctx).await?;
+                for rel_account_id in to {
+                    ReachMessageLogServ::add_rbum(
+                        &mut ReachMsgLogAddReq {
+                            rbum_add_req: Default::default(),
+                            dnd_time: Default::default(),
+                            rel_account_id,
+                            dnd_strategy: ReachDndStrategyKind::Ignore,
+                            start_time,
+                            end_time: Utc::now(),
+                            failure: true,
+                            fail_message: e.to_string(),
+                            rel_reach_message_id: message.id.clone(),
+                        },
+                        &self.funs,
+                        &ctx,
+                    ).await?;
+                }
+
                 return Err(e);
             }
         }